indexing

indexing

Synopsis

enum                IndexingMethod;
typedef             IndexingPrivate;
#define             INDEXING_DEFAULTS_DIRAX
#define             INDEXING_DEFAULTS_GRAINSPOTTER
#define             INDEXING_DEFAULTS_MOSFLM
#define             INDEXING_DEFAULTS_REAX
#define             INDEXING_DEFAULTS_XDS
#define             INDEXING_METHOD_MASK
IndexingMethod *    build_indexer_list                  (const char *str);
void                cleanup_indexing                    (IndexingMethod *indms,
                                                         IndexingPrivate **privs);
IndexingPrivate **  prepare_indexing                    (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);
void                index_pattern                       (struct image *image,
                                                         IndexingMethod *indms,
                                                         IndexingPrivate **iprivs);
char *              indexer_str                         (IndexingMethod indm);
IndexingPrivate *   dirax_prepare                       (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);
int                 run_dirax                           (struct image *image,
                                                         IndexingPrivate *ipriv);
void                dirax_cleanup                       (IndexingPrivate *pp);
IndexingPrivate *   mosflm_prepare                      (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);
int                 run_mosflm                          (struct image *image,
                                                         IndexingPrivate *ipriv);
void                mosflm_cleanup                      (IndexingPrivate *pp);
IndexingPrivate *   xds_prepare                         (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);
int                 run_xds                             (struct image *image,
                                                         IndexingPrivate *ipriv);
void                xds_cleanup                         (IndexingPrivate *pp);
IndexingPrivate *   reax_prepare                        (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);
int                 reax_index                          (IndexingPrivate *pp,
                                                         struct image *image);
void                reax_cleanup                        (IndexingPrivate *pp);
IndexingPrivate *   grainspotter_prepare                (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);
int                 grainspotter_index                  (struct image *image,
                                                         IndexingPrivate *p);
void                grainspotter_cleanup                (IndexingPrivate *pp);

Description

Details

enum IndexingMethod

typedef enum {
	INDEXING_NONE   = 0,

	/* The core indexing methods themselves */
	INDEXING_DIRAX  = 1,
	INDEXING_MOSFLM = 2,
	INDEXING_REAX   = 3,
	INDEXING_GRAINSPOTTER = 4,
	INDEXING_XDS = 5,
	INDEXING_SIMULATION = 6,

	/* Bits at the top of the IndexingMethod are flags which modify the
	 * behaviour of the indexer. */
	INDEXING_CHECK_CELL_COMBINATIONS = 256,
	INDEXING_CHECK_CELL_AXES         = 512,
	INDEXING_CHECK_PEAKS             = 1024,
	INDEXING_USE_LATTICE_TYPE        = 2048,
	INDEXING_USE_CELL_PARAMETERS     = 4096,
} IndexingMethod;

An enumeration of all the available indexing methods. The dummy value INDEXING_SIMULATION is used by partial_sim to indicate that no indexing was performed, and that the indexing results are just from simulation.

INDEXING_NONE

No indexing to be performed

INDEXING_DIRAX

Invoke DirAx

INDEXING_MOSFLM

Invoke MOSFLM

INDEXING_REAX

DPS algorithm using known cell parameters

INDEXING_GRAINSPOTTER

Invoke GrainSpotter

INDEXING_XDS

Invoke XDS

INDEXING_SIMULATION

Dummy value

INDEXING_CHECK_CELL_COMBINATIONS

Check linear combinations of unit cell axes for agreement with given cell.

INDEXING_CHECK_CELL_AXES

Check unit cell axes for agreement with given cell, and permute them if necessary.

INDEXING_CHECK_PEAKS

Check that the peaks can be explained by the indexing result.

INDEXING_USE_LATTICE_TYPE

Use lattice type and centering information to guide the indexing process.

INDEXING_USE_CELL_PARAMETERS

Use the unit cell parameters to guide the indexingprocess.

IndexingPrivate

typedef void *IndexingPrivate;

This is an opaque data structure containing information needed by the indexing method.


INDEXING_DEFAULTS_DIRAX

#define             INDEXING_DEFAULTS_DIRAX

INDEXING_DEFAULTS_GRAINSPOTTER

#define             INDEXING_DEFAULTS_GRAINSPOTTER

INDEXING_DEFAULTS_MOSFLM

#define             INDEXING_DEFAULTS_MOSFLM

INDEXING_DEFAULTS_REAX

#define             INDEXING_DEFAULTS_REAX

INDEXING_DEFAULTS_XDS

#define             INDEXING_DEFAULTS_XDS

INDEXING_METHOD_MASK

#define INDEXING_METHOD_MASK (0xff)

build_indexer_list ()

IndexingMethod *    build_indexer_list                  (const char *str);

cleanup_indexing ()

void                cleanup_indexing                    (IndexingMethod *indms,
                                                         IndexingPrivate **privs);

prepare_indexing ()

IndexingPrivate **  prepare_indexing                    (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);

index_pattern ()

void                index_pattern                       (struct image *image,
                                                         IndexingMethod *indms,
                                                         IndexingPrivate **iprivs);

indexer_str ()

char *              indexer_str                         (IndexingMethod indm);

dirax_prepare ()

IndexingPrivate *   dirax_prepare                       (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);

run_dirax ()

int                 run_dirax                           (struct image *image,
                                                         IndexingPrivate *ipriv);

dirax_cleanup ()

void                dirax_cleanup                       (IndexingPrivate *pp);

mosflm_prepare ()

IndexingPrivate *   mosflm_prepare                      (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);

run_mosflm ()

int                 run_mosflm                          (struct image *image,
                                                         IndexingPrivate *ipriv);

mosflm_cleanup ()

void                mosflm_cleanup                      (IndexingPrivate *pp);

xds_prepare ()

IndexingPrivate *   xds_prepare                         (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);

run_xds ()

int                 run_xds                             (struct image *image,
                                                         IndexingPrivate *ipriv);

xds_cleanup ()

void                xds_cleanup                         (IndexingPrivate *pp);

reax_prepare ()

IndexingPrivate *   reax_prepare                        (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);

reax_index ()

int                 reax_index                          (IndexingPrivate *pp,
                                                         struct image *image);

reax_cleanup ()

void                reax_cleanup                        (IndexingPrivate *pp);

grainspotter_prepare ()

IndexingPrivate *   grainspotter_prepare                (IndexingMethod *indm,
                                                         UnitCell *cell,
                                                         struct detector *det,
                                                         struct beam_params *beam,
                                                         float *ltl);

grainspotter_index ()

int                 grainspotter_index                  (struct image *image,
                                                         IndexingPrivate *p);

grainspotter_cleanup ()

void                grainspotter_cleanup                (IndexingPrivate *pp);