qpms_types.h

Go to the documentation of this file.

 
#ifndef QPMS_TYPES_H
#define QPMS_TYPES_H
#include <complex.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifndef M_PI_2
#define M_PI_2 (1.570796326794896619231321691639751442098584699687552910487L)
#endif
#ifndef M_PI
#define M_PI (3.14159265358979323846264338327950288419716939937510582097494L)
#endif
#ifndef M_SQRT2
#define M_SQRT2 (1.41421356237309504880168872420969807856967187537694807317668L)
#endif
#ifndef M_SQRTPI
#define M_SQRTPI (1.77245385090551602729816748334114518279754945612238712821381L)
#endif
 
// integer index types
typedef int qpms_lm_t;
typedef int qpms_l_t; /* can't be unsigned because of the behaviour under the - operator;
             also -1 needed as an invalid value for scalar waves. */
 
typedef qpms_lm_t qpms_m_t;
 
 
typedef size_t qpms_y_t;
 
 
typedef size_t qpms_y_sc_t;
 
typedef enum {
    QPMS_VSWF_ELECTRIC = 2, 
    QPMS_VSWF_MAGNETIC = 1, 
    QPMS_VSWF_LONGITUDINAL = 0 
} qpms_vswf_type_t;
 
// FIXME DOC The references to the functions do not work in doxygen:
 
typedef unsigned long long qpms_uvswfi_t; 
 
 
typedef enum {
    QPMS_SUCCESS = 0, 
    QPMS_ERROR = -1, 
    QPMS_FAILURE = QPMS_ERROR,
    QPMS_ENOMEM = 8, 
    QPMS_ESING = 21, 
    QPMS_NAN_ENCOUNTERED = 1024 
} qpms_errno_t;
 
 
 
 
typedef enum {
    QPMS_NORMALISATION_UNDEF = 0, 
    QPMS_NORMALISATION_INVERSE = 1, 
    QPMS_NORMALISATION_REVERSE_AZIMUTHAL_PHASE = 2,
 
    QPMS_NORMALISATION_SPHARM_REAL = 4,
 
    QPMS_NORMALISATION_CSPHASE = 8,
    QPMS_NORMALISATION_M_I = 16, 
    QPMS_NORMALISATION_M_MINUS = 32, 
    QPMS_NORMALISATION_N_I = 64, 
    QPMS_NORMALISATION_N_MINUS = 128, 
    QPMS_NORMALISATION_L_I = 256, 
    QPMS_NORMALISATION_L_MINUS = 512, 
    QPMS_NORMALISATION_NORM_BITSTART = 65536, 
 
    QPMS_NORMALISATION_NORM_POWER = QPMS_NORMALISATION_NORM_BITSTART * 1,
 
    QPMS_NORMALISATION_NORM_SPHARM = QPMS_NORMALISATION_NORM_BITSTART * 3,
 
    QPMS_NORMALISATION_NORM_NONE = QPMS_NORMALISATION_NORM_BITSTART * 2,
    QPMS_NORMALISATION_NORM_BITS = QPMS_NORMALISATION_NORM_POWER 
        | QPMS_NORMALISATION_NORM_NONE | QPMS_NORMALISATION_NORM_SPHARM,
 
    QPMS_NORMALISATION_CONVENTION_KRISTENSSON_REAL = QPMS_NORMALISATION_NORM_POWER
        | QPMS_NORMALISATION_SPHARM_REAL,
    QPMS_NORMALISATION_CONVENTION_KRISTENSSON = QPMS_NORMALISATION_NORM_POWER
        | QPMS_NORMALISATION_CSPHASE,
    QPMS_NORMALISATION_CONVENTION_SCUFF = QPMS_NORMALISATION_NORM_POWER
        | QPMS_NORMALISATION_CSPHASE | QPMS_NORMALISATION_M_I
        | QPMS_NORMALISATION_N_MINUS,
    QPMS_NORMALISATION_DEFAULT = QPMS_NORMALISATION_CONVENTION_KRISTENSSON
} qpms_normalisation_t;
 
static inline int qpms_normalisation_t_csphase(qpms_normalisation_t norm) {
    return (norm & QPMS_NORMALISATION_CSPHASE)? -1 : 1;
}
 
typedef enum {
    QPMS_BESSEL_REGULAR = 1, 
    QPMS_BESSEL_SINGULAR = 2, 
    QPMS_HANKEL_PLUS = 3, 
    QPMS_HANKEL_MINUS = 4, 
    QPMS_BESSEL_UNDEF = 0 
} qpms_bessel_t;
 
// coordinate system types
typedef struct cart3_t {
    double x, y, z;
} cart3_t;
 
typedef struct ccart3_t {
    complex double x, y, z;
} ccart3_t;
 
typedef struct ccart3_pair {
    ccart3_t E, H;
} ccart3_pair;
 
 
typedef struct cart2_t {
    double x, y;
} cart2_t;
 
typedef struct sph_t {
    double r, theta, phi;
} sph_t;
 
typedef struct csph_t { // Do I really need this???
    complex double r;
    double  theta, phi;
} csph_t;
 
typedef struct csphvec_t {
    complex double rc, thetac, phic; 
} csphvec_t;
 
typedef struct pol_t {
    double r, phi;
} pol_t;
 
 
typedef union anycoord_point_t {
    double z; 
    cart3_t cart3;
    cart2_t cart2;
    sph_t sph;
    pol_t pol;
} anycoord_point_t;
 
typedef enum { 
    // IF EVER CHANGING THE CONSTANT VALUES HERE, 
    // CHECK THAT THEY DO NOT CLASH WITH THOSE IN PGenPointFlags!
    QPMS_COORDS_CART1 = 64, 
    QPMS_COORDS_POL = 128, 
    QPMS_COORDS_SPH = 256, 
    QPMS_COORDS_CART2 = 512, 
    QPMS_COORDS_CART3 = 1024, 
    QPMS_COORDS_BITRANGE = QPMS_COORDS_CART1
        | QPMS_COORDS_POL
        | QPMS_COORDS_SPH
        | QPMS_COORDS_CART2
        | QPMS_COORDS_CART3,
} qpms_coord_system_t;
 
 
typedef struct qpms_quat_t {
        complex double a, b;
} qpms_quat_t;
 
 
typedef struct qpms_quat4d_t {
        double c1, ci, cj, ck;
} qpms_quat4d_t;
 
 
typedef struct qpms_irot3_t {
        qpms_quat_t rot; 
        short det; 
} qpms_irot3_t;
 
 
typedef struct qpms_vswf_set_spec_t {
        size_t n; 
        qpms_uvswfi_t *ilist; 
 
        qpms_l_t lMax; 
 
        qpms_l_t lMax_M, 
 
                 lMax_N,
 
                 lMax_L;
        size_t capacity; 
        qpms_normalisation_t norm; 
} qpms_vswf_set_spec_t;
 
typedef int32_t qpms_ss_tmi_t;
 
typedef int32_t qpms_ss_tmgi_t;
 
typedef int32_t qpms_ss_pi_t;
 
// These types are mainly used in groups.h:
typedef int qpms_gmi_t;
 
typedef int qpms_iri_t;
#define QPMS_NO_IRREP ((qpms_iri_t) -1)
 
 
typedef const char * qpms_permutation_t;
 
 
typedef struct qpms_tmatrix_t {
        const qpms_vswf_set_spec_t *spec;
        complex double *m; 
        bool owns_m; 
} qpms_tmatrix_t;
 
 
typedef enum {
 
    // Axial groups
    QPMS_PGS_CN, 
    QPMS_PGS_S2N, 
    QPMS_PGS_CNH, 
    QPMS_PGS_CNV, 
    QPMS_PGS_DN, 
    QPMS_PGS_DND, 
    QPMS_PGS_DNH, 
 
    // Remaining polyhedral groups
    QPMS_PGS_T, 
    QPMS_PGS_TD, 
    QPMS_PGS_TH, 
    QPMS_PGS_O,  
    QPMS_PGS_OH,  
    QPMS_PGS_I,  
    QPMS_PGS_IH,  
 
    // Continuous axial groups
    QPMS_PGS_CINF, 
    QPMS_PGS_CINFH, 
    QPMS_PGS_CINFV, 
    QPMS_PGS_DINF, 
    QPMS_PGS_DINFH, 
 
    // Remaining continuous groups
    QPMS_PGS_SO3,   
    QPMS_PGS_O3,    
} qpms_pointgroup_class;
 
typedef struct qpms_pointgroup_t {
    qpms_pointgroup_class c; 
    qpms_gmi_t n; 
 
    qpms_irot3_t orientation;
} qpms_pointgroup_t;
 
 
typedef struct qpms_abstract_tmatrix_t {
        const qpms_vswf_set_spec_t *spec;
    qpms_pointgroup_t sym;
} qpms_abstract_tmatrix_t;
 
 
typedef struct qpms_epsmu_t {
    complex double eps; 
    complex double mu; 
} qpms_epsmu_t;
 
struct qpms_tolerance_spec_t; // See tolerances.h
 
#define lmcheck(l,m) assert((l) >= 1 && abs(m) <= (l))
#endif // QPMS_TYPES