LAUE INTEGRATED REFLECTION LISTS (LIRL)

INTRODUCTION

This file contains a series of routines concerned with the allocation and management of memory for lists of Laue reflection records containing integrated reflection data. These are used to collate data from integrations of single plates (using LDM based routines) and/or to collate integrated intensity data for scaling & normalisation.

The following sets of routines are available:

Creating and Writing 'LIRL' lists
Get Data from 'LIRL' Lists
Sort 'LIRL' Lists
Delete and Clear 'LIRL' Data
Routines for the Laue Scaling Module

CREATING AND WRITING 'LIRL' LISTS

Introduction

Routines are available to create new LIRL reflection lists, to add records to such lists and to modify data in such lists.

The following routines are available:

Allocate and initialise a reflections list - lirl_init
Add a reflection to a reflections list - lirl_addref
Update a reflection in a reflections list - lirl_putref
Set number of overload pixels - lirl_set_ovpix
Set reflection 'outlier' flag - lirl_set_outlier
Set reference intensity and sigma - lirl_set_refint
Update 'ksym' for a reflection - lirl_putksym
Pass symmetry matrices to LIRL routines - lirl_setsym

Allocate and initialise a reflections list - lirl_init

The routine lirl_init (lirlf_init) checks to see if a spare slot is available and, if so, allocates the memory for a new Laue integrated reflections list (LIPL) with an initial allocation of records. The routine returns an index (handle) to be used in all other routines for accessing that list. 
 
Fortran call:
 
         CALL LIRLF_INIT  (INIT_ALLOC, INT_ALLOC, LIST_TYPE, 
        +                  ICOORD_TYPE, MINDX)

 
Parameters:
 
INIT_ALLOC   i  (R)  Initial allocation required (no. of reflection
                     records).
INC_ALLOC    i  (R)  No. of records by which to extend the 
                     reflections list each time an extension is 
                     required.
LIST_TYPE    i  (R)  = 0 Integrated spots list 
                     (others reserved for future expansion)
ICOORD_TYPE  i  (R)  Coordinate type flag 
                       =0 in mm from pattern centre (ideal)
                       =1 in mm from pattern centre (distortion 
                          corrected)
                       =2 in detector raster units
MINDX        i  (W)  Index for the allocated reflection list (>=0)
                     A negative return value indicates an error and
                     the value is the return code from the routine
                     lirl_init.

 
'C' call:
 
int lirl_init (int init_alloc, int inc_alloc, int list_type, int coord_type)

 
Parameters:
 
int init_alloc;      No. of records to be allocated initially (R)
int inc_alloc;       No. of records to be added each time an extension
                     to the list is required (R)
int list_type;       = 0 Integrated spots list (others reserved for future 
                     expansion) (R)
int coord_type       Coordinate type flag 
                     =0 in mm from pattern centre (ideal)
                     =1 in mm from pattern centre (distortion corrected)
                     =2 in detector raster units (R)

Return:  >=0, the index of the allocated list
          -1, no spare reflection lists available
          -2, no spare 'dml' memory lists available
          -3, cannot allocate initial memory
          -4, init_alloc<1 or inc_alloc<1
          -5, invalid list type 
          -6, invalid coordinate type

Add a reflection to a reflections list - lirl_addref

The routine lirl_addref (lirlf_addref) adds a new reflection to the end of the requested Laue integrated reflections list providing that the list has been initialised and that sufficient memory is available or can be allocated for it. The routine sets values for the main items and default values for the optional additional items. 
 
Fortran call:
 
         CALL LIRLF_ADDREF  (MINDX, IH, IK, IL, IPACK, IPLATE, KSYM, 
        +                    XFD, YFD, ALAM,
        +                    MULT, MINHARM, MAXHARM, INCHARM, AI, SIGI,
        +                    ISPAT, ICLOS, IMEAS, IBAD, IOVLD, 
        +                    ICODE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IH           i  (R)  Reflection 'h' index (as measured) (lowest harmonic 
IK           i  (R)  Reflection 'k' index (as measured)  present for a
IL           i  (R)  Reflection 'l' index (as measured)  multiple)
IPACK        i  (R)  Pack no. or index (1-65535)
IPLATE       i  (R)  Plate number within pack
KSYM         i  (R)  Symmetry no. (0 if not yet determined)
XFD          r  (R)  'xfd' coordinate of spot (units as defined by
                     ICOORD_TYPE in LIRLF_INIT call)
YFD          r  (R)  'yfd' coordinate of spot (units as defined by
                     ICOORD_TYPE in LIRLF_INIT call)
ALAM         r  (R)  Wavelength (for lowest harmonic present for a
                     multiple)
MULT         i  (R)  Multiplicity (1=single) (0=deconvoluted multiple)
MINHARM      i  (R)  Minimum harmonic (if MULT > 1)
MAXHARM      i  (R)  Maximum harmonic (if MULT > 1)
INCHARM      i  (R)  Harmonics increment (if MULT > 1)
AI           r  (R)  Integrated intensity
SIGI         r  (R)  Standard deviation of integrated intensity
ISPAT        i  (R)  Spatially overlapped flag =1 yes, =0 no
ICLOS        i  (R)  Spot too close to deconvolute flag =1 yes, =0 no
IMEAS        i  (R)  Integration done flag =1 yes, =0 no
IBAD         i  (R)  Bad spot other than overload flag =1 yes, =0 no
IOVLD        i  (R)  Intensity overload flag =1 yes, =0 no
ICODE        i  (R)  Code specific to integration routine (0-255)
IERR         i  (W)  Error return code from lirl_addref

   Indices are for lowest harmonic present for a multiple

   For a deconvoluted multiple, the following items are ignored:
   IPACK, IPLATE, XFD, YFD, ALAM, MINHARM, MAXHARM, INCHARM. ISPAT, ICLOS,
   IMEAS (treated as 1), IBAD, IOVLD, ICODE. Normally the indices will 
   be the unique ones and KSYM will be 1. Note also that the intensity
   and sigma(intensity) values are already normalised and scaled.

 
'C' call:
 
int lirl_addref (int mindx, int h, int k, int l, int ipack, int iplate,
                 int ksym, float xfd, float yfd, float alam, int mult,
                 int minharm, int maxharm, int incharm, float ai, float sigi,
                 int ispat, int iclos, int imeas,
                 int ibad, int iovld, int icode)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int h;           Reflection 'h' index (as measured) (R) (lowest harmonic
int k;           Reflection 'k' index (as measured) (R)  presennt for a
int l;           Reflection 'l' index (as measured) (R)  multiple)
int ipack;       Pack no. or index (1-65535) (R)
int iplate;      Plate number within pack (R)
int ksym;        Symmetry no. (0 if not yet determined) (R)
float xfd;       'xfd' coordinate of spot (units as defined by 
                 coord_type in lirl_init call) (R)
float yfd;       'yfd' coordinate of spot  (units as defined by 
                 coord_type in lirl_init call (R)
float alam;      Wavelength (for lowest harmonic present for a
                 multiple) (R)
int mult;        Multiplicity (1=single) (R)
int minharm;     Minimum harmonic (if mult!=1) (R)
int maxharm;     Maximum harmonic (if mult!=1) (R)
int incharm;     Harmonics increment (if mult!=1) (R)
float ai;        Integrated intensity (R)
float sigi;      Standard deviation of integrated intensity (R)
int ispat;       Spatially overlapped flag =1 yes, =0 no (R)
int iclos;       Spot too close to deconvolute flag =1 yes, =0 no (R)
int imeas;       Integration done flag =1 yes, =0 no (R)
int ibad;        Bad spot other than overload flag =1 yes, =0 no (R)
int iovld;       Intensity overload flag =1 yes, =0 no (R)
int icode;       Code specific to integration routine (0-255) (R) 

    Indices are for lowest harmonic present for a multiple 

    For a deconvoluted multiple, the following items are ignored:
    ipack, iplate, xfd, yfd, alam, minharm, maxharm, incharm. ispat, iclos,
    imeas (treated as 1), ibad, iovld, icode. Normally the indices will 
    be the unique ones and KSYM will be 1. Note also that the intensity
    and sigma(intensity) values are already normalised and scaled.


Return:  =  0, OK
         = -1, Invalid index given or list not initialised
         = -2, Cannot allocate required memory

Update a reflection in a reflections list - lirl_putref

The routine lirl_putref (lirlf_putref) updates a reflection in a Laue integrated reflections list. The routine sets values for the main items and leaves unchanged any values currently stored for the optional additional items. 
 
Fortran call:
 
         CALL LIRLF_PUTREF  (MINDX, IREF, IH, IK, IL, IPACK, IPLATE, KSYM, 
        +                    XFD, YFD, ALAM,
        +                    MULT, MINHARM, MAXHARM, INCHARM, AI, SIGI,
        +                    ISPAT, ICLOS, IMEAS, IBAD, IOVLD, 
        +                    ICODE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)  
IH           i  (R)  Reflection 'h' index (as measured) (lowest harmonic 
IK           i  (R)  Reflection 'k' index (as measured)  present for a 
IL           i  (R)  Reflection 'l' index (as measured)  multiple)
IPACK        i  (R)  Pack no. or index (1-65535)
IPLATE       i  (R)  Plate number within pack
KSYM         i  (R)  Symmetry no. (0 if not yet determined)
XFD          r  (R)  'xfd' coordinate of spot (units as defined by
                     ICOORD_TYPE in LIRLF_INIT call)
YFD          r  (R)  'yfd' coordinate of spot (units as defined by
                     ICOORD_TYPE in LIRLF_INIT call)
ALAM         r  (R)  Wavelength (for lowest harmonic present for a
                     multiple)
MULT         i  (R)  Multiplicity (1=single) (0=deconvoluted multiple)
MINHARM      i  (R)  Minimum harmonic (if MULT > 1)
MAXHARM      i  (R)  Maximum harmonic (if MULT > 1)
INCHARM      i  (R)  Harmonics increment (if MULT > 1)
AI           r  (R)  Integrated intensity
SIGI         r  (R)  Standard deviation of integrated intensity
ISPAT        i  (R)  Spatially overlapped flag =1 yes, =0 no
ICLOS        i  (R)  Spot too close to deconvolute flag =1 yes, =0 no
IMEAS        i  (R)  Integration done flag =1 yes, =0 no
IBAD         i  (R)  Bad spot other than overload flag =1 yes, =0 no
IOVLD        i  (R)  Intensity overload flag =1 yes, =0 no
ICODE        i  (R)  Code specific to integration routine (0-255)
IERR         i  (W)  Error return code from lirl_putref

   For a deconvoluted multiple, the following items are ignored:
   IPACK, IPLATE, XFD, YFD, ALAM, MINHARM, MAXHARM, INCHARM. ISPAT, ICLOS,
   IMEAS (treated as 1), IBAD, IOVLD, ICODE. Normally the indices will 
   be the unique ones and KSYM will be 1. Note also that the intensity
   and sigma(intensity) values are already normalised and scaled.

 
'C' call:
 
int lirl_putref (int mindx, int iref, int h, int k, int l, 
                 int ipack, int iplate,
                 int ksym, float xfd, float yfd, float alam, int mult,
                 int minharm, int maxharm, int incharm, float ai, float sigi,
                 int ispat, int iclos, int imeas,
                 int ibad, int iovld, int icode)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
int h;           Reflection 'h' index (as measured) (R) (lowest harmonic
int k;           Reflection 'k' index (as measured) (R)  present for a
int l;           Reflection 'l' index (as measured) (R)  multiple)
int ipack;       Pack no. or index (1-65535) (R)
int iplate;      Plate number within pack (R)
int ksym;        Symmetry no. (0 if indices are as measured) (R)
float xfd;       'xfd' coordinate of spot (units as defined by 
                  coord_type in lirl_init call) (R)
float yfd;       'yfd' coordinate of spot (units as defined by 
                  coord_type in lirl_init call) (R)
float alam;      Wavelength (for lowest harmonic present for a
                 multiple) (R)
int mult;        Multiplicity (1=single) (R)
int minharm;     Minimum harmonic (if mult!=1) (R)
int maxharm;     Maximum harmonic (if mult!=1) (R)
int incharm;     Harmonics increment (if mult!=1) (R)
float ai;        Integrated intensity (R)
float sigi;      Standard deviation of integrated intensity (R)
int ispat;       Spatially overlapped flag =1 yes, =0 no (R)
int iclos;       Spot too close to deconvolute flag =1 yes, =0 no (R)
int imeas;       Integration done flag =1 yes, =0 no (R)
int ibad;        Bad spot other than overload flag =1 yes, =0 no (R)
int iovld;       Intensity overload flag =1 yes, =0 no (R)
int icode;       Code specific to integration routine (0-255) (R)

   For a deconvoluted multiple, the following items are ignored:
   ipack, iplate, xfd, yfd, alam, minharm, maxharm, incharm. ispat, iclos,
   imeas (treated as 1), ibad, iovld, icode. Normally the indices will 
   be the unique ones and KSYM will be 1. Note also that the intensity
   and sigma(intensity) values are already normalised and scaled.

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Set number of overload pixels - lirl_set_ovpix

The routine lirl_set_ovpix (lirlf_set_ovpix) sets the value for the number of overload pixels found for a reflection. 
 
Fortran call:
 
         CALL LIRLF_SET_OVPIX  (MINDX, IREF, NUM_OVPIX, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
NUM_OVPIX    i  (R)  The number of overload pixels (-1 = not known)
                     (Values > 255 stored as 255)
IERR         i  (W)  Error return code from lirl_set_ovpix 

 
'C' call:
 
int lirl_set_ovpix (int mindx, int iref, int num_ovpix)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
int num_ovpix;   The number of overload pixels (-1 = not known)
                 (Values > 255 stored as 255) (R)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Set reflection 'outlier' flag - lirl_set_outlier

The routine lirl_set_outlier (lirlf_set_outlier) sets the value for the for a reflection 'outlier' flag. 
 
Fortran call:
 
         CALL LIRLF_SET_OUTLIER  (MINDX, IREF, ICODE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
ICODE        i  (R)  Program dependent flag 0-255; 0 indicates
                     that the reflection is OK (i.e. not an
                     outlier) and any value >0 indicates an
                     outlier.
IERR         i  (W)  Error return code from lirl_set_outlier 

 
'C' call:
 
int lirl_set_outlier (int mindx, int iref, int icode)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
int icode;       Program dependent flag 0-255; 0 indicates
                 that the reflection is OK (i.e. not an outlier) 
                 and any value >0 indicates an outlier. (R)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Set reference intensity and sigma - lirl_set_refint

The routine lirl_set_refint (lirlf_set_refint) sets the values for a reflection reference intensity and its sigma value. 
 
Fortran call:
 
         CALL LIRLF_SET_REFINT  (MINDX, IREF, REFINT, SIGREF, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
REFINT       r  (R)  The reference intensity.
SIGREF       r  (R)  sigma(reference intensity). A value of 0.0
                     indicates that the intensity is not present.
IERR         i  (W)  Error return code from lirl_set_refint 

 
'C' call:
 
int lirl_set_refint (int mindx, int iref, float refint, float sigref)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
float refint;    The reference intensity. (R)
float sigref;    sigma(reference intensity). A value of 0.0
                 indicates that the intensity is not present. (R)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Update 'ksym' for a reflection - lirl_putksym

The routine lirl_putksym (lirlf_putksym) updates a reflection 'ksym' value in a Laue integrated reflections list. 
 
Fortran call:
 
         CALL LIRLF_PUTKSYM  (MINDX, IREF, KSYM, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)  
KSYM         i  (R)  Symmetry no. (0 if not yet determined)
IERR         i  (W)  Error return code from lirl_putksym

 
'C' call:
 
int lirl_putksym (int mindx, int iref, int ksym)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
int ksym;        Symmetry no. (0 if indices are as measured) (R)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Pass symmetry matrices to LIRL routines - lirl_setsym

The routine lirl_setsym (lirlf_setsym) passes the symmetry matrices (as defined in the CCP4 and LDM routines) to the LIRL routines for internal use when indices need to be converted to various forms. Note that the symmetry matrices must remain in place as copies are not made. 
 
Fortran call:
 
         CALL LIRLF_SETSYM  (MINDX, RSYM, RSYMIV, IERR)

 
Parameters:
 
MINDX          i  (R)  Index as returned by LIRLF_INIT
RSYM(4,4,96)   r  (R)  Symmetry matrices (as CCP4 & LDM)
RSYMIV(4,4,96) r  (R)  Inverse symmetry matrices (as CCP4 & LDM)
IERR           i  (W)  Error return code from lirl_setsym

 
'C' call:
 
int lirl_setsym (int mindx, float *rsym, float *rsymiv)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
float * rsym;    Symmetry matrices (as CCP4 & LDM) - see Fortran 
                 call (R)
float * rsymiv;  Inverse symmetry matrices (as CCP4 & LDM) - see Fortran
                 call (R)

Return:  >= 0, The number of reflections
         = -1, Invalid index given or list not initialised

GET DATA FROM 'LIRL' LISTS

Introduction

Routines are available to get the number of reflection records and details of the individual reflections from a Laue integrated reflections list.

The following routines are available:

Get number of reflections in a list - lirl_numrefs
Get sort order - lirl_sortord
Get reflection indices for a reflection - lirl_gethkl
Get unique reflection indices for a reflection - lirl_hklunq
Get unique nodal indices for a reflection - lirl_nodunq
Get reflection details for a reflection - lirl_getref
Get number of overload pixels - lirl_get_ovpix
Get reflection 'outlier' flag - lirl_get_outlier
Get reference intensity and sigma - lirl_get_refint

Get number of reflections in a list - lirl_numrefs

The routine lirl_numrefs (lirlf_numrefs) returns the number of reflections currently stored in a Laue integrated reflections list. 
 
Fortran call:
 
         CALL LIRLF_NUMREFS  (MINDX, NUMREFS)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
NUMREFS      i  (W)  No. of reflections in the reflections list. If
                     there is an error a value of -1 will be returned
                     from the lirl_numrefs call

 
'C' call:
 
int lirl_numrefs (int mindx)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)

Return:  >= 0, The number of reflections
         = -1, Invalid index given or list not initialised

Get sort order - lirl_sortord

The routine lirl_sortord (lirlf_sortord) returns the current sort order ('ityp' code as used in call to lirl_sort (lirlf_sort) call). 
 
Fortran call:
 
         CALL LIRLF_SORTORD  (MINDX, ISORT)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
ISORT        i  (W)  The sort order code (>0), 0=unknown. The code
                     is that was used as the 'ITYP' parameter in the
                     latest LIRLF_SORT call. If there is an error  
                     in the call, a value of -1 will be returned.

 
'C' call:
 
int lirl_sortord (int mindx)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)

Return:  = 0, Sort order unknown
         > 0, The code is that was used as the 'ityp' parameter in 
              the latest 'lirl_sort' call.
         =-1, Invalid index given or list not initialised

Get reflection indices for a reflection - lirl_gethkl

The routine lirl_gethkl (lirlf_gethkl) gets the reflection indices and symmetry no. (if set) for a given reflection in a Laue integrated reflection list. 
 
Fortran call:
 
         CALL LIRLF_GETHKL  (MINDX, IREF, IH, IK, IL, KSYM, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)
IH           i  (W)  Reflection 'h' index (as measured)
IK           i  (W)  Reflection 'k' index (as measured)
IL           i  (W)  Reflection 'l' index (as measured)
KSYM         i  (W)  Symmetry no. (0 if not yet set)
IERR         i  (W)  Error return code from lirl_gethkl

 
'C' call:
 
int lirl_gethkl (int mindx, int iref, int *h, int *k, int *l, int *ksym)

 
Parameters:
 
int mindx;        Index as returned by lirl_init (R)
int iref;         Reflection number (from 1 upwards) (R)
int *h;           Reflection 'h' index  (as measured) (W)
int *k;           Reflection 'k' index (as measured) (W)
int *l;           Reflection 'l' index (as measured) (W)
int ksym;         Symmetry no. (0 if not set) (W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or reflection
               record not present.

Get unique reflection indices for a reflection - lirl_hklunq

The routine lirl_hklunq (lirlf_hklunq) gets the unique reflection indices and for a given reflection in a Laue integrated reflection list. The symmetry number must have been set (e.g using lirl_addref, lirl_putref or lirl_putksym (lirlf_addref, lirlf_putref or lirlf_putksym) and the symmetry matrices must have been passed to the LIRL routines using the lirl_setsym (lirlf_setsym) routine. 
 
Fortran call:
 
         CALL LIRLF_HKLUNQ  (MINDX, IREF, IH, IK, IL, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)
IH           i  (W)  Reflection 'h' index (unique) (0 if error)
IK           i  (W)  Reflection 'k' index (unique) (0 if error)
IL           i  (W)  Reflection 'l' index (unique) (0 if error)
IERR         i  (W)  Error return code from lirl_hklunq

 
'C' call:
 
int lirl_hklunq (int mindx, int iref, int *h, int *k, int *l)

 
Parameters:
 
int mindx;        Index as returned by lirl_init (R)
int iref;         Reflection number (from 1 upwards) (R)
int *h;           Reflection 'h' index  (unique) (0 if error)(W)
int *k;           Reflection 'k' index (unique) (0 if error)(W)
int *l;           Reflection 'l' index (unique) (0 if error)(W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or reflection
               record not present.
         = -2, symmetry no. not set
         = -3, symmetry matrices not defined

Get unique nodal indices for a reflection - lirl_nodunq

The routine lirl_nodunq (lirlf_nodunq) gets the unique nodal reflection indices and nodal lambda value for a given reflection in a Laue integrated reflection list. The symmetry number must have been set (e.g using lirl_addref, lirl_putref or lirl_putksym (lirlf_addref, lirlf_putref or lirlf_putksym) and the symmetry matrices must have been passed to the LIRL routines using the lirl_setsym (lirlf_setsym) routine. 
 
Fortran call:
 
         CALL LIRLF_NODUNQ  (MINDX, IREF, NH, NK, NL, ALNOD, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)
NH           i  (W)  Reflection 'h' nodal index (unique) (0 if error)
NK           i  (W)  Reflection 'k' nodal index (unique) (0 if error)
NL           i  (W)  Reflection 'l' nodal index (unique) (0 if error)
ALNOD        r  (W)  Nodal lambda value
IERR         i  (W)  Error return code from lirl_hklunq

 
'C' call:
 
int lirl_nodunq (int mindx, int iref, int *nh, int *nk, int *nl, float *alnod)

 
Parameters:
 
int mindx;         Index as returned by lirl_init (R)
int iref;          Reflection number (from 1 upwards) (R)
int *nh;           Reflection 'h' nodal index (unique) (0 if error)(W)
int *nk;           Reflection 'k' nodal index (unique) (0 if error)(W)
int *nl;           Reflection 'l' nodal index (unique) (0 if error)(W)
float *alnod;      Nodal lambda value (W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or reflection
               record not present.
         = -2, symmetry no. not set
         = -3, symmetry matrices not defined

Get reflection details for a reflection - lirl_getref

The routine lirl_getref (lirlf_getref) gets the reflection details for the main items for a given reflection in a Laue integrated reflection list. The values for the optional additional items are retrieved via other routines if required. 
 
Fortran call:
 
         CALL LIRLF_GETREF  (MINDX, IREF, IH, IK, IL, IPACK, IPLATE, 
        +                    KSYM, XFD, YFD, ALAM,
        +                    MULT, MINHARM, MAXHARM, INCHARM, AI, SIGI,
        +                    ISPAT, ICLOS, IMEAS, IBAD, IOVLD, 
        +                    ICODE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)
IH           i  (W)  Reflection 'h' index (as measured)
IK           i  (W)  Reflection 'k' index (as measured)
IL           i  (W)  Reflection 'l' index (as measured)
IL           i  (R)  Reflection 'l' index
IPACK        i  (W)  Pack no. or index (1-65535)
IPLATE       i  (W)  Plate number within pack
KSYM         i  (W)  Symmetry no. (0 if not yet determined)
XFD          r  (W)  'xfd' coordinate of spot  (units as defined by 
                     ICOORD_TYPE in LIRLF_INIT call)
YFD          r  (W)  'yfd' coordinate of spot (units as defined by 
                     ICOORD_TYPE in LIRLF_INIT call)
ALAM         r  (W)  Wavelength (for lowest harmonic present for a
                     multiple)
MULT         i  (W)  Multiplicity (1=single)
MINHARM      i  (W)  Minimum harmonic (set if MULT not 1, otherwise 0)
MAXHARM      i  (W)  Maximum harmonic (set if MULT not 1, otherwise 0)
INCHARM      i  (W)  Harmonics increment (set if MULT not 1, otherwise 0)
AI           r  (W)  Integrated intensity
SIGI         r  (W)  Standard deviation of integrated intensity
ISPAT        i  (W)  Spatially overlapped flag =1 yes, =0 no
ICLOS        i  (W)  Spot too close to deconvolute flag =1 yes, =0 no
IMEAS        i  (W)  Integration done flag =1 yes, =0 no
IBAD         i  (W)  Bad spot other than overload flag =1 yes, =0 no
IOVLD        i  (W)  Intensity overload flag =1 yes, =0 no
ICODE        i  (W)  Code specific to integration routine (0-255)
IERR         i  (W)  Error return code from lirl_getref

   For a deconvoluted multiple, the following items are returned as zero:
   IPACK, IPLATE, XFD, YFD, ALAM, MINHARM, MAXHARM, INCHARM. ISPAT, ICLOS,
   IBAD, IOVLD, ICODE. IMEAS will be returned as 1. Note also that the 
   intensity and sigma(intensity) values are already normalised and scaled.

 
'C' call:
 
int lirl_getref (int mindx, int iref, int *h, int *k, int *l, int *ipack, 
                 int *iplate, int *ksym, 
                 float *xfd, float *yfd, float *alam, 
                 int *mult, int *minharm, int *maxharm, int *incharm, 
                 float *ai, float *sigi,
                 int *ispat, int *iclos, int *imeas, int *ibad, int *iovld, 
                 int *icode)

 
Parameters:
 
int mindx;        Index as returned by lirl_init (R)
int iref;         Reflection number (from 1 upwards) (R)
int *h;           Reflection 'h' index  (as measured) (W)
int *k;           Reflection 'k' index (as measured) (W)
int *l;           Reflection 'l' index (as measured) (W)
int *ipack;       Pack no. or index (1-65535) (W)
int *iplate;      Plate number within pack (W)
int *ksym;        Symmetry no. (0 if indices are as measured) (W)
float *xfd;       'xfd' coordinate of spot (units as defined by 
                  coord_type in lirl_init call) (W)
float *yfd;       'yfd' coordinate of spot (units as defined by 
                  coord_type in lirl_init call) (W)
float *alam;      Wavelength (for lowest harmonic present for a
                  multiple) (W)
int *mult;        Multiplicity (1=single) (W)
int *minharm;     Minimum harmonic (if mult!=1, else 0) (W)
int *maxharm;     Maximum harmonic (if mult!=1, else 0) (W)
int *incharm;     Harmonics increment (if mult!=1, else 0) (W)
float *ai;        Integrated intensity (W)
float *sigi;      Standard deviation of integrated intensity (W)
int *ispat;       Spatially overlapped flag =1 yes, =0 no (W)
int *iclos;       Spot too close to deconvolute flag =1 yes, =0 no (W)
int *imeas;       Integration done flag =1 yes, =0 no (W)
int *ibad;        Bad spot other than overload flag =1 yes, =0 no (W)
int *iovld;       Intensity overload flag =1 yes, =0 no (W)
int *icode;       Code specific to integration routine (0-255) (W)

   For a deconvoluted multiple, the following items are returned as zero:
   ipack, iplate, xfd, yfd, alam, minharm, maxharm, incharm. ispat, iclos,
   ibad, iovld, icode. imeas will be returned as 1. Note also that the 
   intensity and sigma(intensity) values are already normalised and scaled.

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or reflection
               record not present.

Get number of overload pixels - lirl_get_ovpix

The routine lirl_get_ovpix (lirlf_get_ovpix) returns the value for the number of overload pixels found set for a reflection. 
 
Fortran call:
 
         CALL LIRLF_GET_OVPIX  (MINDX, IREF, NUM_OVPIX, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
NUM_OVPIX    i  (W)  Returns the number of overload pixels 0-255,
                     (-1 = not known)
IERR         i  (W)  Error return code from lirl_get_ovpix 

 
'C' call:
 
int lirl_get_ovpix (int mindx, int iref, int *num_ovpix)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
int *num_ovpix;  Returns the number of overload pixels  0-255,
                 (-1 = not known) (W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Get reflection 'outlier' flag - lirl_get_outlier

The routine lirl_get_outlier (lirlf_get_outlier) gets the value for the for a reflection 'outlier' flag. 
 
Fortran call:
 
         CALL LIRLF_GET_OUTLIER  (MINDX, IREF, ICODE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
ICODE        i  (W)  Returns the program dependent flag 0-255; 
                     0 indicates that the reflection is OK (i.e. 
                     not an outlier) and any value >0 indicates an
                     outlier.
IERR         i  (W)  Error return code from lirl_get_outlier 

 
'C' call:
 
int lirl_get_outlier (int mindx, int iref, int *icode)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
int *icode;      Returns the program dependent flag 0-255; 
                 0 indicates that the reflection is OK (i.e. 
                 not an outlier) and any value >0 indicates an
                 outlier. (W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Get reference intensity and sigma - lirl_get_refint

The routine lirl_get_refint (lirlf_get_refint) gets the values for a reflection reference intensity and its sigma value. 
 
Fortran call:
 
         CALL LIRLF_GET_REFINT  (MINDX, IREF, REFINT, SIGREF, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
REFINT       r  (W)  Returns the reference intensity.
SIGREF       r  (W)  Returns sigma(reference intensity). A value of 0.0
                     indicates that the intensity is not present.
IERR         i  (W)  Error return code from lirl_get_refint 

 
'C' call:
 
int lirl_get_refint (int mindx, int iref, float *refint, float *sigref)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int iref;        Reflection number (from 1 upwards) (R)
float *refint;   Returns the reference intensity. (W)
float *sigref;   Returns sigma(reference intensity). A value of 0.0
                 indicates that the intensity is not present. (W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

SORT 'LIRL' LISTS

Introduction

A routine enables Laue integrated reflection lists to be sorted on a number of the stored parameters.

The following routines are available:

Sort LIRL reflection lists - lirl_sort

Sort LIRL reflection lists - lirl_sort

The routine lirl_sort (lirlf_sort) is used to sort the reflection list by reflection indices of various forms or on various other parameters. For options involving sorts on unique indices, the symmetry number must have been set for all the reflections (e.g using lirl_addref, lirl_putref or lirl_putksym (lirlf_addref, lirlf_putref or lirlf_putksym) and the symmetry matrices must have been passed to the LIRL routines using the lirl_setsym (lirlf_setsym) routine. The sorting process preserves the data order of items which have the same value of the sort key (this requires allocation of additional memory and hence the error return of the sort routine should alwasy be checked) 
 
Fortran call:
 
         CALL LIRLF_SORT  (MINDX, ITYP, IERR)

 
Parameters:
 
MINDX          i  (R)  Index as returned by LIRLF_INIT
ITYP           i  (R)  = 1 sort on measured hkl
                       = 2 sort on unique hkl
                       = 3 sort on pack no./index
                       = 4 sort on plate no.
                       = 5 sort on lambda
                       = 6 sort on xfd
                       = 7 sort on yfd
                       = 8 sort on intensity
                       = 9 sort on multiplicity
                       = 10 sort on unique hkl and sign
                       = 11 sort on unique nodal indices
IERR           i  (W)  Error return code from lirl_sort

 
'C' call:
 
int lirl_sort (int mindx, int ityp)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int ityp;        = 1 sort on measured indices
                 = 2 sort on unique indices
                 = 3 sort on pack no./index
                 = 4 sort on plate no.
                 = 5 sort on lambda
                 = 6 sort on xfd
                 = 7 sort on yfd
                 = 8 sort on intensity
                 = 9 sort on multiplicity
                 = 10 sort on unique hkl and sign
                 = 11 sort on unique nodal indices
                 (R)

Return:  >= 0, The number of reflections
         = -1, Invalid index given or list not initialised or invalid 
               index type requested
         = -2, Not all 'ksym' values set
         = -3, Symmetry matrices not defined (if required) 
         = -4, Cannot allocate temporary memory

DELETE AND CLEAR 'LIRL' DATA

Introduction

Routines enable the data stored in a Laue integrated reflection list to be deleted for a given pack or plate and also for complete lists to be cleared or removed.

The following routines are available:

Delete reflections for given pack(s)/plate(s) - lirl_delete
Clear a reflections list - lirl_clear
Clear and free a reflections list - lirl_free

Delete reflections for given pack(s)/plate(s) - lirl_delete

The routine lirl_delete (lirlf_delete) deletes the reflections for a requested pack (or all packs) and for a requested plate (or all plates). Unused space at the end of the list will be automatically freed. 
 
Fortran call:
 
         CALL LIRLF_DELETE  (MINDX, IPACK, IPLATE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IPACK        i  (R)  No. (or index) of pack for which reflections 
                     are to be deleted; 0 = all packs
IPLATE       i  (R)  Plate no. for requested pack(s) of reflections
                     to be deleted; 0 = all plates
IERR         i  (W)  Error return code from lirl_delete

 
'C' call:
 
int lirl_delete (int mindx, int ipack, int plate)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int ipack;       No. or index of pack to be deleted; 0 = all packs (R)
int plate;       Plate no. to be deleted; 0 = all plates (R)

Return:  =  0, OK
         = -1, Invalid index given or list not initialised

Clear a reflections list - lirl_clear

The routine lirl_clear (lirlf_clear) clears a reflections list. The memory is not released and the index returned from the lirl_init (lirlf_init) call can still be used and new reflections may be added etc. as required. 
 
Fortran call:
 
         CALL LIRLF_CLEAR  (MINDX, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IERR         i  (W)  Error return code from lirl_clear

 
'C' call:
 
int lirl_clear (int mindx)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)

Return:  =  0, OK
         = -1, Invalid index given or list not initialised

Clear and free a reflections list - lirl_free

The routine lirl_free (lirlf_free) clears a reflections list and makes it available for re-use via another initialisation call. All the memory that was allocated for the list is freed. 
 
Fortran call:
 
         CALL LIRLF_FREE  (MINDX, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IERR         i  (W)  Error return code from lirl_free

 
'C' call:
 
int lirl_free (int mindx)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)

Return:  =  0, OK
         = -1, Invalid index given or list not initialised

ROUTINES FOR THE LAUE SCALING MODULE

Introduction

These are a series of routines written specifically for use with the Laue Scaling Module (LSM).

The following routines are available:

Start to read reflections - lirl_lsm_start
Read next reflection set - lirl_lsm_next
Set LSM temporary scaling items - lirl_lsm_settemp
Set 'use reflection' flag - lirl_lsm_setuse
Get LSM scaling items - lirl_lsm_scalobs
Get LSM range items - lirl_lsm_getranges

Start to read reflections - lirl_lsm_start

The routine lirl_lsm_start (lirlf_lsm_start) is called to set some initialisation flags before sets of reflections are read using the routine lirl_lsl_next (lirlf_lsm_next). Note that the 'use_reflection' flag must be set for each reflection before reading reflection sets from a list. Note also that only one reflection list may be accessed at a time using the lirl_lsm_start/lirl_lsm_next routines and that the reflections must be sorted on unique hkl (or unique_hkl and sign if sign separated data are being used). 
 
Fortran call:
 
         CALL LIRLF_LSM_START  (MINDX, ISIGN, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
ISIGN        i  (R)  Flag =1 prepare to return sign separated reflection sets
                          =0 ingore reflection I+/I- sign
IERR         i  (W)  Error return code from lirl_lsm_start

 
'C' call:
 
int lirl_lsm_start (int mindx, int isign)

 
Parameters:
 
int mindx;       Index as returned by lirl_init (R)
int isign;       Flag =1 prepare to return sign separated reflection sets
                      =0 ingore reflection I+/I- sign (R)

Return:  =  0, OK
         = -1, Invalid index given or list not initialised

Read next reflection set - lirl_lsm_next

The routine lirl_lsm_next (lirlf_lsm_next) is called to return the next reflection set from the reflection list. Note that the routine lirl_lsm_start (lirlf_lsm_start) must be called before attempting to read the first reflection set and the 'use_reflection' flag must be set for each reflection (except for deconvoluted multiples where used) before reading the reflection sets. Note that the list index is set via lirl_lsm_start and is stored internally; only one list may be accessed at a time using lirl_lsm_start and lirl_lsm_next. 
 
Fortran call:
 
         CALL LIRLF_LSM_NEXT  (IDX_ARR, MAX_ARR, NREFS, MULT_INC, IFLAG)

 
Parameters:
 
IDX_ARR      i  (W)  Array of reflection indices (from 1 upwards) for
                     the reflections in the set (dimensioned to at least
                     MAX_ARR).
MAX_ARR      i  (R)  The maximum no. of reflections which may be returned
                     in the set.
NREFS        i  (W)  The number of reflections in the returned set.
MULT_INC     i  (R)  Include deconvoluted multiples flag
                      =1 yes, (deconvoluted multiples included 
                               unconditionally)
                      =0 no, deconvoluted multiples excluded

IFLAG        i  (W)  Return flag from lirl_lsm_next 
                     =0    OK
                     =-1   End of list reached
                     >0    List truncated; IFLAG shows the actual
                           no. of reflections present in the set.

 
'C' call:
 
int lirl_lsm_next (int idx_arr[], int max_arr, int *nrefs, int mult_inc)

 
Parameters:
 
int idx_arr[];   Array of reflection indices (from 1 upwards) for
                 the reflections in the set. (dimensioned to at least
                 max_arr). (W)
int max_arr;     The maximum no. of reflections which may be returned
                 in the set. (R)
int *nrefs;      The no. of reflections in the set. (W)
int mult_inc;    Include deconvoluted multiples flag
                 =1 yes, (deconvoluted multiples included unconditionally)
                 =0 no, deconvoluted multiples excluded

Return:  =  0,   OK
         = -1,   End of list reached
         > 0,    List truncated; IFLAG shows the actual
                 no. of reflections present in the set.

Set LSM temporary scaling items - lirl_lsm_settemp

The routine lirl_lsm_settemp (lirlf_lsm_settemp) is used to set the temporary pre-calculated values which will enable efficient scaling to be carried out within the Laue Scaling Module (LSM) routines. (The unique indices will also be calculated and stored) 
 
Fortran call:
 
         CALL LIRLF_LSM_SETTEMP  (MINDX, IREF, ABSCOR_NU, PSI_LOCAL,
        +                         PSI_GLOBAL, STOL2, AL3C2T, ABSCOR_LAMFN, 
        +                         OB_LPFAC, KNORM, KPLSC, IUSE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
ABSCOR_NU    r  (R)  'nu' angle for absorption correction 
PSI_LOCAL    r  (R)  'psi' angle for absorption correction (local)
PSI_GLOBAL   r  (R)  'psi' angle for absorption correction (global)
STOL2        r  (R)  sin**theta/lambda**2
AL3C2T       r  (R)  lambda**3/(cos(2*theta))
ABSCOR_LAMFN r  (R)  lambda dependent function for absorption correction
OB_LPFAC     r  (R)  Combined obliquity/Lorentz/polarisation factor
KNORM        i  (R)  Normalisation curve range no. flag
KPLSC        i  (R)  Plate to plate scaling range flag
IUSE         i  (R)  Use reflection flag =1 yes, =0 no
IERR         i  (W)  Error return code from lirl_lsm_settemp

 
'C' call:
 
int lirl_lsm_settemp (int mindx, int iref, float abscor_nu, float psi_local,
                      float psi_global, float stol2, float al3c2t, 
                      float abscor_lamfn, float ob_lpfac, int knorm, 
                      int kplsc, int iuse)

 
Parameters:
 
int mindx;          Index as returned by lirl_init (R)
int iref;           Reflection number (from 1 upwards) (R)
float abscor_nu;    'nu' angle for absorption correction (R)
float psi_local;    'psi' angle for absorption correction (local) (R)
float psi_global;   'psi' angle for absorption correction (global) (R)
float stol2;        sin**theta/lambda**2 (R)
float al3c2t;       lambda**3/(cos(2*theta)) (R)
float abscor_lamfn; lambda dependent function for absorption 
                    correction (R)
float ob_lpfac;     Combined obliquity/Lorentz/polarisation factor (R)
int knorm;          Normalisation curve range no. flag (R)
int kplsc;          Plate to plate scaling range flag (R)
int iuse;           Use reflection flag =1 yes, =0 no (R)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Set 'use reflection' flag - lirl_lsm_setuse

The routine lirl_lsm_setuse (lirlf_lsm_setuse) is used to set the temporary 'use_reflection' flag for a reflection within the Laue Scaling Module (LSM) routines. 
 
Fortran call:
 
         CALL LIRLF_LSM_SETUSE  (MINDX, IREF, IUSE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards) 
IUSE         i  (R)  Use reflection flag =1 yes, =0 no
IERR         i  (W)  Error return code from lirl_lsm_setuse

 
'C' call:
 
int lirl_lsm_setuse (int mindx, int iref, int iuse)

 
Parameters:
 
int mindx;          Index as returned by lirl_init (R)
int iref;           Reflection number (from 1 upwards) (R)
int iuse;           Use reflection flag =1 yes, =0 no (R)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Get LSM scaling items - lirl_lsm_scalobs

The routine lirl_lsm_scalobs (lirlf_lsm_scalobs) is used to get the items required to calculate a scaled intensity and sigma(intensity) value for use within the LSM refinement and scaling routines. Note that values must have been set for all the required items - this routine does not determine them. 
 
Fortran call:
 
         CALL LIRLF_LSM_SCALOBS  (MINDX, IREF, IPACK, IPLATE,
        +                         AINT, SIGINT, ALAM, REFINT,
        +                         ABSCOR_NU, PSI_LOCAL, PSI_GLOBAL,
        +                         STOL2, AL3C2T, ABSCOR_LAMFN, OB_LPFAC,
        +                         KNORM, KPLSC, IUSE, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)
IPACK        i  (W)  Returns the pack number 
IPLATE       i  (W)  Returns the plate number 
AINT         r  (W)  Returns the intensity value (unscaled)
SIGINT       r  (W)  Returns the sig(I) (unscaled)
ALAM         r  (W)  Returns the lambda value
REFINT       r  (W)  Returns the reference intensity
ABSCOR_NU    r  (W)  Returns 'nu' angle for absorption correction 
PSI_LOCAL    r  (W)  Returns 'psi' angle for absorption correction (local)
PSI_GLOBAL   r  (W)  Returns 'psi' angle for absorption correction (global)
STOL2        r  (W)  Returns sin**theta/lambda**2
AL3C2T       r  (W)  Returns lambda**3/(cos(2*theta))
ABSCOR_LAMFN r  (W)  Returns lambda dependent function for absorption 
                     correction
OB_LPFAC     r  (W)  Returns combined obliquity/Lorentz/polarisation 
                     factor
KNORM        i  (W)  Returns normalisation curve range no. flag
KPLSC        i  (W)  Returns plate to plate scaling range flag
IUSE         i  (W)  Returns use reflection flag =1 yes, =0 no
IERR         i  (W)  Error return code from lirl_lsm_scalobs

 
'C' call:
 
int lirl_lsm_scalobs (int mindx, int iref, int *ipack, int *iplate,
                     float *aint, float *sigint, float *alam, 
                     float *refint, float *abscor_nu, 
                     float *psi_local, float *psi_global, float *stol2, 
                     float *al3c2t, float *abscor_lamfn, float *ob_lpfac, 
                     int *knorm, int *kplsc, int *iuse)

 
Parameters:
 
int mindx;           Index as returned by lirl_init (R)
int iref;            Reflection number (from 1 upwards) (R)
int *ipack;          Returns the pack number (W)
int *iplate;         Returns the plate number (W)
float *aint;         Returns the intensity value (unscaled) (W)
float *sigint;       Returns the sig(I) (unscaled) (W)
float *alam;         Returns the lambda value (W)
float *refint;       Returns the reference intensity (W)
float *abscor_nu;    Returns 'nu' angle for absorption correction (W)
float *psi_local;    Returns 'psi' angle for absorption correction 
                     (local) (W)
float *psi_global;   Returns 'psi' angle for absorption correction 
                     (global) (W)
float *stol2;        Returns sin**theta/lambda**2 (W)
float *al3c2t;       Returns lambda**3/(cos(2*theta)) (W)
float *abscor_lamfn; Returns lambda dependent function for absorption 
                     correction (W)
float *ob_lpfac;     Returns combined obliquity/Lorentz/polarisation 
                     factor (W)
int *knorm;          Returns normalisation curve range no. flag (W)
int *kplsc;          Returns plate to plate scaling range flag (W)
int *iuse;           Returns use reflection flag =1 yes, =0 no (W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present

Get LSM range items - lirl_lsm_getranges

The routine lirl_lsm_getranges (lirlf_lsm_getranges) is used to get the stored values for the normalisation curve wavelength range and plate scaling wavelength range flags for use within the LSM refinement and scaling routines. Note that values must have been set for the required items - this routine does not determine them. 
 
Fortran call:
 
         CALL LIRLF_LSM_GETRANGES  (MINDX, IREF, KNORM, KPLSC, 
        +                           ABSCOR_NU, PSI_LOC, PSI_GLOB, IERR)

 
Parameters:
 
MINDX        i  (R)  Index as returned by LIRLF_INIT
IREF         i  (R)  The reflection number (from 1 upwards)
KNORM        i  (W)  Returns normalisation curve range no. flag
KPLSC        i  (W)  Returns plate to plate scaling range flag
ABSCOR_NU    r  (W)  'nu' value
PSI_LOC      r  (W)  'psi' value (local)
PSI_GLOB     r  (W)  'psi' valus (global)
IERR         i  (W)  Error return code from lirl_lsm_getranges

 
'C' call:
 
int lirl_lsm_getranges (int mindx, int iref,  int *knorm, int *kplsc,
                       float *abscor_nu, float *psi_loc, float *psi_glob)

 
Parameters:
 
int mindx;           Index as returned by lirl_init (R)
int iref;            Reflection number (from 1 upwards) (R)
int *knorm;          Returns normalisation curve range no. flag (W)
int *kplsc;          Returns plate to plate scaling range flag (W)
float *abscor_nu;    Returns 'nu' value (W)
float *psi_loc;      Returns 'psi' value (local) (W)
float *psi_glob;     Returns 'psi' value (global) (W)

Return:  =  0, OK
         = -1, Invalid index given, list not initialised or record not present


John W. Campbell
CCLRC Daresbury Laboratory
Last update 16 Jan 1998