hkl-pseudoaxis

hkl-pseudoaxis

Synopsis

                    HklPseudoAxis;
                    HklPseudoAxisEngineMode;
                    HklPseudoAxisEngine;
                    HklPseudoAxisEngineList;
int                 (*HklPseudoAxisEngineModeFunc)      (HklPseudoAxisEngineMode *self,
                                                         HklPseudoAxisEngine *engine,
                                                         HklGeometry *geometry,
                                                         HklDetector *detector,
                                                         HklSample *sample,
                                                         HklError **error);
int                 (*HklFunction)                      (const gsl_vector *x,
                                                         void *params,
                                                         gsl_vector *f);
HklPseudoAxis *     hkl_pseudo_axis_new                 (HklParameter const *parameter,
                                                         HklPseudoAxisEngine *engine);
void                hkl_pseudo_axis_init                (HklPseudoAxis *self,
                                                         HklParameter const *parameter,
                                                         HklPseudoAxisEngine *engine);
void                hkl_pseudo_axis_free                (HklPseudoAxis *self);
void                hkl_pseudo_axis_fprintf             (FILE *f,
                                                         HklPseudoAxis *self);
HklPseudoAxisEngineMode * hkl_pseudo_axis_engine_mode_new
                                                        (char const *name,
                                                         HklPseudoAxisEngineModeFunc initialize,
                                                         HklPseudoAxisEngineModeFunc get,
                                                         HklPseudoAxisEngineModeFunc set,
                                                         size_t n,
                                                         ...);
int                 hkl_pseudo_axis_engine_mode_init    (HklPseudoAxisEngineMode *self,
                                                         char const *name,
                                                         HklPseudoAxisEngineModeFunc initialize,
                                                         HklPseudoAxisEngineModeFunc get,
                                                         HklPseudoAxisEngineModeFunc set,
                                                         size_t n_func,
                                                         HklFunction functions[],
                                                         size_t n_p,
                                                         HklParameter parameters[],
                                                         size_t n_axes,
                                                         char const *axes_names[]);
void                hkl_pseudo_axis_engine_mode_free    (HklPseudoAxisEngineMode *self);
HklPseudoAxisEngine * hkl_pseudo_axis_engine_new        (char const *name,
                                                         size_t n,
                                                         ...);
void                hkl_pseudo_axis_engine_free         (HklPseudoAxisEngine *self);
void                hkl_pseudo_axis_engine_add_mode     (HklPseudoAxisEngine *self,
                                                         HklPseudoAxisEngineMode *mode);
void                hkl_pseudo_axis_engine_add_geometry (HklPseudoAxisEngine *self,
                                                         double const x[]);
void                hkl_pseudo_axis_engine_select_mode  (HklPseudoAxisEngine *self,
                                                         size_t idx);
int                 hkl_pseudo_axis_engine_initialize   (HklPseudoAxisEngine *self,
                                                         HklError **error);
int                 hkl_pseudo_axis_engine_set          (HklPseudoAxisEngine *self,
                                                         HklError **error);
int                 hkl_pseudo_axis_engine_get          (HklPseudoAxisEngine *self,
                                                         HklError **error);
void                hkl_pseudo_axis_engine_fprintf      (FILE *f,
                                                         HklPseudoAxisEngine const *self);
HklPseudoAxisEngineList * hkl_pseudo_axis_engine_list_new
                                                        (void);
void                hkl_pseudo_axis_engine_list_free    (HklPseudoAxisEngineList *self);
int                 hkl_pseudo_axis_engine_list_add     (HklPseudoAxisEngineList *self,
                                                         HklPseudoAxisEngine *engine);
HklPseudoAxisEngine * hkl_pseudo_axis_engine_list_get_by_name
                                                        (HklPseudoAxisEngineList *self,
                                                         char const *name);
HklPseudoAxis *     hkl_pseudo_axis_engine_list_get_pseudo_axis_by_name
                                                        (HklPseudoAxisEngineList *self,
                                                         char const *name);
void                hkl_pseudo_axis_engine_list_clear   (HklPseudoAxisEngineList *self);
void                hkl_pseudo_axis_engine_list_init    (HklPseudoAxisEngineList *self,
                                                         HklGeometry *geometry,
                                                         HklDetector *detector,
                                                         HklSample *sample);
int                 hkl_pseudo_axis_engine_list_get     (HklPseudoAxisEngineList *self);
void                hkl_pseudo_axis_engine_list_fprintf (FILE *f,
                                                         HklPseudoAxisEngineList const *self);

Description

Details

HklPseudoAxis

typedef struct {
	HklParameter parent;
	HklPseudoAxisEngine *engine;
} HklPseudoAxis;


HklPseudoAxisEngineMode

typedef struct {
	char const *name;
	HklPseudoAxisEngineModeFunc initialize;
	HklPseudoAxisEngineModeFunc get;
	HklPseudoAxisEngineModeFunc set;
	HKL_LIST(HklFunction, functions);
	HKL_LIST(HklParameter, parameters);
	HKL_LIST(const char*, axes_names);
	HklGeometry *geometry_init;
	HklDetector *detector_init;
	HklSample *sample_init;
} HklPseudoAxisEngineMode;


HklPseudoAxisEngine

typedef struct {
	char const *name;
	HklGeometry *geometry;
	HklDetector *detector;
	HklSample *sample;
	HKL_LIST(HklPseudoAxisEngineMode *, modes);
	HKL_LIST(HklAxis *, axes);
	HKL_LIST(HklPseudoAxis *, pseudoAxes);
	HklPseudoAxisEngineMode *mode;
	HklPseudoAxisEngineList *engines;
} HklPseudoAxisEngine;


HklPseudoAxisEngineList

typedef struct {
	HKL_LIST(HklPseudoAxisEngine *, engines);
	HklGeometryList *geometries;
	HklGeometry *geometry;
	HklDetector *detector;
	HklSample *sample;
} HklPseudoAxisEngineList;


HklPseudoAxisEngineModeFunc ()

int                 (*HklPseudoAxisEngineModeFunc)      (HklPseudoAxisEngineMode *self,
                                                         HklPseudoAxisEngine *engine,
                                                         HklGeometry *geometry,
                                                         HklDetector *detector,
                                                         HklSample *sample,
                                                         HklError **error);

self :

engine :

geometry :

detector :

sample :

error :

Returns :


HklFunction ()

int                 (*HklFunction)                      (const gsl_vector *x,
                                                         void *params,
                                                         gsl_vector *f);

x :

params :

f :

Returns :


hkl_pseudo_axis_new ()

HklPseudoAxis *     hkl_pseudo_axis_new                 (HklParameter const *parameter,
                                                         HklPseudoAxisEngine *engine);

parameter :

engine :

Returns :


hkl_pseudo_axis_init ()

void                hkl_pseudo_axis_init                (HklPseudoAxis *self,
                                                         HklParameter const *parameter,
                                                         HklPseudoAxisEngine *engine);

self :

parameter :

engine :


hkl_pseudo_axis_free ()

void                hkl_pseudo_axis_free                (HklPseudoAxis *self);

self :


hkl_pseudo_axis_fprintf ()

void                hkl_pseudo_axis_fprintf             (FILE *f,
                                                         HklPseudoAxis *self);

f :

self :


hkl_pseudo_axis_engine_mode_new ()

HklPseudoAxisEngineMode * hkl_pseudo_axis_engine_mode_new
                                                        (char const *name,
                                                         HklPseudoAxisEngineModeFunc initialize,
                                                         HklPseudoAxisEngineModeFunc get,
                                                         HklPseudoAxisEngineModeFunc set,
                                                         size_t n,
                                                         ...);

name :

initialize :

get :

set :

n :

... :

Returns :


hkl_pseudo_axis_engine_mode_init ()

int                 hkl_pseudo_axis_engine_mode_init    (HklPseudoAxisEngineMode *self,
                                                         char const *name,
                                                         HklPseudoAxisEngineModeFunc initialize,
                                                         HklPseudoAxisEngineModeFunc get,
                                                         HklPseudoAxisEngineModeFunc set,
                                                         size_t n_func,
                                                         HklFunction functions[],
                                                         size_t n_p,
                                                         HklParameter parameters[],
                                                         size_t n_axes,
                                                         char const *axes_names[]);

self :

name :

initialize :

get :

set :

n_func :

functions :

n_p :

parameters :

n_axes :

axes_names :

Returns :


hkl_pseudo_axis_engine_mode_free ()

void                hkl_pseudo_axis_engine_mode_free    (HklPseudoAxisEngineMode *self);

self :


hkl_pseudo_axis_engine_new ()

HklPseudoAxisEngine * hkl_pseudo_axis_engine_new        (char const *name,
                                                         size_t n,
                                                         ...);

name :

n :

... :

Returns :


hkl_pseudo_axis_engine_free ()

void                hkl_pseudo_axis_engine_free         (HklPseudoAxisEngine *self);

self :


hkl_pseudo_axis_engine_add_mode ()

void                hkl_pseudo_axis_engine_add_mode     (HklPseudoAxisEngine *self,
                                                         HklPseudoAxisEngineMode *mode);

self :

mode :


hkl_pseudo_axis_engine_add_geometry ()

void                hkl_pseudo_axis_engine_add_geometry (HklPseudoAxisEngine *self,
                                                         double const x[]);

self :

x :


hkl_pseudo_axis_engine_select_mode ()

void                hkl_pseudo_axis_engine_select_mode  (HklPseudoAxisEngine *self,
                                                         size_t idx);

self :

idx :


hkl_pseudo_axis_engine_initialize ()

int                 hkl_pseudo_axis_engine_initialize   (HklPseudoAxisEngine *self,
                                                         HklError **error);

self :

error :

Returns :


hkl_pseudo_axis_engine_set ()

int                 hkl_pseudo_axis_engine_set          (HklPseudoAxisEngine *self,
                                                         HklError **error);

self :

error :

Returns :


hkl_pseudo_axis_engine_get ()

int                 hkl_pseudo_axis_engine_get          (HklPseudoAxisEngine *self,
                                                         HklError **error);

self :

error :

Returns :


hkl_pseudo_axis_engine_fprintf ()

void                hkl_pseudo_axis_engine_fprintf      (FILE *f,
                                                         HklPseudoAxisEngine const *self);

f :

self :


hkl_pseudo_axis_engine_list_new ()

HklPseudoAxisEngineList * hkl_pseudo_axis_engine_list_new
                                                        (void);

Returns :


hkl_pseudo_axis_engine_list_free ()

void                hkl_pseudo_axis_engine_list_free    (HklPseudoAxisEngineList *self);

self :


hkl_pseudo_axis_engine_list_add ()

int                 hkl_pseudo_axis_engine_list_add     (HklPseudoAxisEngineList *self,
                                                         HklPseudoAxisEngine *engine);

self :

engine :

Returns :


hkl_pseudo_axis_engine_list_get_by_name ()

HklPseudoAxisEngine * hkl_pseudo_axis_engine_list_get_by_name
                                                        (HklPseudoAxisEngineList *self,
                                                         char const *name);

self :

name :

Returns :


hkl_pseudo_axis_engine_list_get_pseudo_axis_by_name ()

HklPseudoAxis *     hkl_pseudo_axis_engine_list_get_pseudo_axis_by_name
                                                        (HklPseudoAxisEngineList *self,
                                                         char const *name);

self :

name :

Returns :


hkl_pseudo_axis_engine_list_clear ()

void                hkl_pseudo_axis_engine_list_clear   (HklPseudoAxisEngineList *self);

self :


hkl_pseudo_axis_engine_list_init ()

void                hkl_pseudo_axis_engine_list_init    (HklPseudoAxisEngineList *self,
                                                         HklGeometry *geometry,
                                                         HklDetector *detector,
                                                         HklSample *sample);

self :

geometry :

detector :

sample :


hkl_pseudo_axis_engine_list_get ()

int                 hkl_pseudo_axis_engine_list_get     (HklPseudoAxisEngineList *self);

self :

Returns :


hkl_pseudo_axis_engine_list_fprintf ()

void                hkl_pseudo_axis_engine_list_fprintf (FILE *f,
                                                         HklPseudoAxisEngineList const *self);

f :

self :