IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 153


Ignore:
Timestamp:
Mar 9, 2004, 12:28:16 PM (22 years ago)
Author:
Paul Price
Message:

Doxygen-ated the source files.

Location:
trunk/archive/pslib/include
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/archive/pslib/include/psAstrom.h

    r149 r153  
    1414/***********************************************************************************************************/
    1515
    16 /* Astrometric coefficients */
    17 typedef struct {
    18     int xyOrder;                        // Spatial (x,y) order of polynomial
    19     int colourOrder;                    // Order of polynomial in colour
    20     int magOrder;                       // Order of polynomial in magnitude
    21     int xyColourOrder;                  // Spatial (x,y) order of polynomial in colour times x and y
    22     int xyMagOrder;                     // Spatial (x,y) order of polynomial in magnitude times x and y
    23     enum psColourRef colourRef;         // Colour reference
    24     psDoubleArray *restrict coeff;      // Coefficients of astrometric solution
    25     psDoubleArray *restrict coeffErr;   // Error in coefficients
     16/** Astrometric coefficients */
     17typedef struct {
     18    int xyOrder;                        //!< Spatial (x,y) order of polynomial
     19    int colourOrder;                    //!< Order of polynomial in colour
     20    int magOrder;                       //!< Order of polynomial in magnitude
     21    int xyColourOrder;                  //!< Spatial (x,y) order of polynomial in colour times x and y
     22    int xyMagOrder;                     //!< Spatial (x,y) order of polynomial in magnitude times x and y
     23    enum psColourRef colourRef;         //!< Colour reference
     24    psDoubleArray *restrict coeff;      //!< Coefficients of astrometric solution
     25    psDoubleArray *restrict coeffErr;   //!< Error in coefficients
    2626} psAstromCoeffs;
    2727
    28 /* Constructor */
     28/** Constructor */
    2929psAstromCoeffs *
    30 psAstromCoeffsNew(int xyOrder,          // Spatial (x,y) order of polynomial
    31                   int colourOrder,      // Order of polynomial in colour
    32                   int magOrder,         // Order of polynomial in magnitude
    33                   int xyColourOrder,    // Spatial (x,y) order of polynomial in colour times x and y
    34                   int xyMagOrder,       // Spatial (x,y) order of polynomial in magnitude times x and y
    35                   enum psColourRef colourRef // Colour reference
    36     );
    37 
    38 /* Destructor */
    39 void
    40 psAstromCoeffsDel(psAstromCoeffs *restrict myAstromCoeffs // Object to destroy
    41     );
    42 
    43 /***********************************************************************************************************/
    44 
    45 /* Telescope pointing information for an exposure */
     30psAstromCoeffsNew(int xyOrder,          //!< Spatial (x,y) order of polynomial
     31                  int colourOrder,      //!< Order of polynomial in colour
     32                  int magOrder,         //!< Order of polynomial in magnitude
     33                  int xyColourOrder,    //!< Spatial (x,y) order of polynomial in colour times x and y
     34                  int xyMagOrder,       //!< Spatial (x,y) order of polynomial in magnitude times x and y
     35                  enum psColourRef colourRef //!< Colour reference
     36    );
     37
     38/** Destructor */
     39void
     40psAstromCoeffsDel(psAstromCoeffs *restrict myAstromCoeffs //!< Object to destroy
     41    );
     42
     43/***********************************************************************************************************/
     44
     45/** Telescope pointing information for an exposure */
    4646typedef struct {
    4747    // Telescope longitude, latitude and height are stored separately, since they don't change with pointing
    48     double ra, dec;                     // Telescope boresight
    49     double ha;                          // Hour angle
    50     double zd;                          // Zenith distance
    51     double az;                          // Azimuth
    52     float rotAngle;                     // Rotator position angle
    53     float temp;                         // Temperature
    54     float pressure;                     // Pressure
     48    double ra, dec;                     //!< Telescope boresight
     49    double ha;                          //!< Hour angle
     50    double zd;                          //!< Zenith distance
     51    double az;                          //!< Azimuth
     52    float rotAngle;                     //!< Rotator position angle
     53    float temp;                         //!< Temperature
     54    float pressure;                     //!< Pressure
    5555    /* Derived quantities */
    56     float parallactic;                  // Parallactic angle
    57     float airmass;                      // Airmass, calculated from zenith distance
     56    float parallactic;                  //!< Parallactic angle
     57    float airmass;                      //!< Airmass, calculated from zenith distance
    5858} psTelPointing;
    5959
    60 /* Constructor */
     60/** Constructor */
    6161psTelPointing *
    62 psTelPointingNew(double ra, double dec, // Telescope boresight
    63                  double ha,             // Hour angle
    64                  double zd,             // Zenith distance
    65                  double az,             // Azimuth
    66                  float rotAngle,        // Rotator position angle
    67                  float temp,            // Temperature
    68                  float pressure         // Pressure
    69     );
    70 
    71 /* Destructor */
    72 void
    73 psTelPointingDel(psTelPointing *restrict myTelPointing // Object to destroy
    74     );
    75 
    76 
    77 /***********************************************************************************************************/
    78 
    79 /* Cell details: specifies how the cell is mounted on its parent OTA  */
    80 typedef struct {
    81     psOTAPos position;                  // Position of cell in its OTA.  Specifies the position of the
    82                                         // (imaginary) pixel (0,0)
    83     float rotation;                     // Rotation of cell in its OTA.  Specified from +x through +y
    84     int xSize, ySize;                   // Number of pixels in x and y
    85     float scale;                        // Relative pixel scales, if CCD pitch varies. Specify a positive
    86                                         // scale for a left-handed coordinate system, negative for right. If
    87                                         // NULL, then every chip has identical scale, and system is
    88                                         // left-handed.
     62psTelPointingNew(double ra, double dec, //!< Telescope boresight
     63                 double ha,             //!< Hour angle
     64                 double zd,             //!< Zenith distance
     65                 double az,             //!< Azimuth
     66                 float rotAngle,        //!< Rotator position angle
     67                 float temp,            //!< Temperature
     68                 float pressure         //!< Pressure
     69    );
     70
     71/** Destructor */
     72void
     73psTelPointingDel(psTelPointing *restrict myTelPointing //!< Object to destroy
     74    );
     75
     76
     77/***********************************************************************************************************/
     78
     79/** Cell details: specifies how the cell is mounted on its parent OTA */
     80typedef struct {
     81    psOTAPos position;                  //!< Position of cell in its OTA.  Specifies the position of the
     82                                        //!< (imaginary) pixel (0,0)
     83    float rotation;                     //!< Rotation of cell in its OTA.  Specified from +x through +y
     84    int xSize, ySize;                   //!< Number of pixels in x and y
     85    float scale;                        //!< Relative pixel scales, if CCD pitch varies. Specify a positive
     86                                        //!< scale for a left-handed coordinate system, negative for right. If
     87                                        //!< NULL, then every chip has identical scale, and system is
     88                                        //!< left-handed.
    8989} psCellDescription;
    9090
    91 /* Constructor */
     91/** Constructor */
    9292psCellDescription *
    9393psCellDescriptionNew(void);
    9494
    95 /* Destructor */
    96 void
    97 psCellDescriptionDel(psCellDescription *restrict myCell // Cell description to destroy
    98     );
    99 
    100 /***********************************************************************************************************/
    101 
    102 /* Array of cell descriptions */
     95/** Destructor */
     96void
     97psCellDescriptionDel(psCellDescription *restrict myCell //!< Cell description to destroy
     98    );
     99
     100/***********************************************************************************************************/
     101
     102/** Array of cell descriptions */
    103103PS_DECLARE_ARRAY_TYPE(psCellDescription);
    104104PS_CREATE_ARRAY_TYPE(psCellDescription);
    … …  
    106106/***********************************************************************************************************/
    107107
    108 /* OTA details: specifies how the OTA is mounted on the focal plane */
    109 typedef struct {
    110     psOTAPos position;                  // Position of OTA on the focal plane.  Specifies the position of the
    111                                         // bottom left-hand corner.
    112     float rotation;                     // Rotation of OTA on the focal plane.  Specified from +x through +y
    113     psCellDescriptionArray *restrict cells; // Cell descriptions
    114     psOTAAstrom *astrom;                // OTA astrometry
     108/** OTA details: specifies how the OTA is mounted on the focal plane */
     109typedef struct {
     110    psOTAPos position;                  //!< Position of OTA on the focal plane.  Specifies the position of the
     111                                        //!< bottom left-hand corner.
     112    float rotation;                     //!< Rotation of OTA on the focal plane.  Specified from +x through +y
     113    psCellDescriptionArray *restrict cells; //!< Cell descriptions
     114    psOTAAstrom *astrom;                //!< OTA astrometry
    115115} psOTADescription;
    116116
    117 /* Constructor */
     117/** Constructor */
    118118psOTADescription *
    119119psOTADescriptionNew(void);
    120120
    121 /* Destructor */
    122 void
    123 psOTADescriptionDel(psOTADescription *restrict myOTA // OTA description to destroy
    124     );
    125 
    126 /***********************************************************************************************************/
    127 
    128 /* Astrometric solution for an OTA */
    129 /* There are four coordinate frames that we need to worry about:
     121/** Destructor. */
     122void
     123psOTADescriptionDel(psOTADescription *restrict myOTA //!< OTA description to destroy
     124    );
     125
     126/***********************************************************************************************************/
     127
     128/** Astrometric solution for an OTA.
     129 * There are four coordinate frames that we need to worry about:
    130130 * 1. Chip frame: chip# plus x,y in pixels
    131131 * 2. Focal plane frame: X,Y in microns
    … …  
    144144typedef struct {
    145145    /* Focal plane to and from tangent plane */
    146     psAstromCoeffs *restrict tpToFP;    // General astrometric solution for tangent plane to focal plane
    147     psAstromCoeffs *restrict fpToTP;    // General astrometric solution for focal plane to tangent plane
    148     psMatrix *pattern;                  // Fixed pattern distortions for focal plane to tangent plane (simply
    149                                         // * -1 for the reverse); MAY NEED TO BE REVISED UPON IMPLEMENTATION
     146    psAstromCoeffs *restrict tpToFP;    //!< General astrometric solution for tangent plane to focal plane
     147    psAstromCoeffs *restrict fpToTP;    //!< General astrometric solution for focal plane to tangent plane
     148    psMatrix *pattern;                  //!< Fixed pattern distortions for focal plane to tangent plane (simply
     149                                        //!< * -1 for the reverse); MAY NEED TO BE REVISED UPON IMPLEMENTATION
    150150    /* Tangent plane to and from the celestial sphere */
    151     psDoubleArray *restrict tp;         // Data needed to convert from the sky to the tangent plane and back;
    152                                         // produced by and used by SLALib (a.k.a. "Wallace's Grommit")
     151    psDoubleArray *restrict tp;         //!< Data needed to convert from the sky to the tangent plane and back;
     152                                        //!< produced by and used by SLALib (a.k.a. "Wallace's Grommit")
    153153    /* Characterisation of the solution */
    154     float rmsX, rmsY;                   // Dispersion in astrometric solution
    155     float chi2;                         // chi^2 of astrometric solution
     154    float rmsX, rmsY;                   //!< Dispersion in astrometric solution
     155    float chi2;                         //!< chi^2 of astrometric solution
    156156} psOTAAstrom;
    157157
    158 /* Constructor */
     158/** Constructor */
    159159psAstrom *
    160 psAstromNew(const psTelPointing *telescope      // Telescope pointing, used to initialise the tp data.
    161     );
    162 
    163 /* Destructor */
    164 void
    165 psAstromDel(psAstrom *restrict myAstrom // Object to destroy
     160psAstromNew(const psTelPointing *telescope //!< Telescope pointing, used to initialise the tp data.
     161    );
     162
     163/** Destructor */
     164void
     165psAstromDel(psAstrom *restrict myAstrom //!< Object to destroy
    166166    );
    167167
    … …  
    170170/* Calculating and applying astrometric solutions */
    171171
    172 /* Convert (RA,Dec) to (cell#,x,y) */
     172/** Convert (RA,Dec) to (cell#,x,y) */
    173173psOTAPos *
    174 psSkyToOTA(const psSkyPos *restrict position, // Position on the sky
    175            const psOTADescription *restrict ota // OTA details
    176     );
    177 
    178 /* Convert (cell#,x,y) to (RA,Dec) */
     174psSkyToOTA(const psSkyPos *restrict position, //!< Position on the sky
     175           const psOTADescription *restrict ota //!< OTA details
     176    );
     177
     178/** Convert (cell#,x,y) to (RA,Dec) */
    179179psSkyPos *
    180 psOTAToSky(const psOTAPos *restrict position, // Position on the detector
    181            const psOTADescription *restrict ota // OTA details
    182     );
    183 
    184 /* Fit astrometric solution to list of (chip#,x,y) and (RA,Dec) */
     180psOTAToSky(const psOTAPos *restrict position, //!< Position on the detector
     181           const psOTADescription *restrict ota //!< OTA details
     182    );
     183
     184/** Fit astrometric solution to list of (chip#,x,y) and (RA,Dec) */
    185185int
    186 psFitAstrom(psOTADescription *restrict ota, // psAstrom struct containing initial guess for coefficients
    187             const psOTAPosArray *restrict detector, // Positions on OTA (chip#,x,y)
    188             const psSkyPosArray *restrict sky, // Positions on the sky (RA,Dec)
    189             const psTelPointing *telescope // Telescope pointing information, for airmass, parallactic angle
    190                                            // which may help set the astrometric solution
     186psFitAstrom(psOTADescription *restrict ota, //!< psAstrom struct containing initial guess for coefficients
     187            const psOTAPosArray *restrict detector, //!< Positions on OTA (chip#,x,y)
     188            const psSkyPosArray *restrict sky, //!< Positions on the sky (RA,Dec)
     189            const psTelPointing *telescope //!< Telescope pointing information, for airmass, parallactic angle
     190                                           //!< which may help set the astrometric solution
    191191            );
    192192
    … …  
    195195/* Functions needed for astrometry, and will likely be useful elsewhere */
    196196
    197 /* Get the airmass for a given position and sidereal time */
     197/** Get the airmass for a given position and sidereal time */
    198198float
    199 psGetAirmass(const psSkyPos *restrict position, // Position on the sky
    200              float siderealTime // Sidereal time
     199psGetAirmass(const psSkyPos *restrict position, //!< Position on the sky
     200             float siderealTime //!< Sidereal time
    201201             );
    202202
    203 /* Get the parallactic angle for a given position and sidereal time */
     203/** Get the parallactic angle for a given position and sidereal time */
    204204float
    205 psGetParallactic(const psSkyPos *restrict position, // Position on the sky
    206                  real siderealTime      // Sidereal time
     205psGetParallactic(const psSkyPos *restrict position, //!< Position on the sky
     206                 real siderealTime      //!< Sidereal time
    207207                 );
    208208
    209 /* Estimate atmospheric refraction, along the parallactic */
     209/** Estimate atmospheric refraction, along the parallactic */
    210210float
    211 psGetRefraction(float colour,           // Colour of object
    212                 enum psColourRef colourRef; // Colour reference
    213                 psTelPointing telescope // Telescope pointing information, for airmass, temp and pressure
     211psGetRefraction(float colour,           //!< Colour of object
     212                enum psColourRef colourRef; //!< Colour reference
     213                psTelPointing telescope //!< Telescope pointing information, for airmass, temp and pressure
    214214    );
    215215

  • trunk/archive/pslib/include/psBitMask.h

    r149 r153  
    22#define PS_BIT_MASK_H
    33
    4 /* Type for a big bitmask */
    5 /* Set to long int for now */
     4/** Type for a big bitmask.  Set to long int for now. */
    65typedef long int psBitMask;
    76
    87
    9 /* Set a bit mask */
     8/** Set a bit mask */
    109psBitMask *
    11 psSetBitMask(psBitMask *outMask,        // Output bit mask or NULL
    12              const psBitMask *myMask,   // Input bit mask
    13              int bit                    // Bit to set
     10psSetBitMask(psBitMask *outMask,        //!< Output bit mask or NULL
     11             const psBitMask *myMask,   //!< Input bit mask
     12             int bit                    //!< Bit to set
    1413    );
    1514
    16 /* Check a bit mask.  Returns true or false */
     15/** Check a bit mask.  Returns true or false */
    1716int
    18 psCheckBitMask(const psBitMask *checkMask, // Bit mask to check
    19                int bit                  // Bit to check
     17psCheckBitMask(const psBitMask *checkMask, //!< Bit mask to check
     18               int bit                  //!< Bit to check
    2019    );
    2120
    22 /* OR two bit masks */
     21/** OR two bit masks */
    2322psBitMask *
    24 psOrBitMasks(psBitMask *outMask,        // Output bit mask or NULL
    25              const psBitMask *restrict inMask1, // Input bit mask 1
    26              const psBitMask *restrict inMask2 // Input bit mask 2
     23psOrBitMasks(psBitMask *outMask,        //!< Output bit mask or NULL
     24             const psBitMask *restrict inMask1, //!< Input bit mask 1
     25             const psBitMask *restrict inMask2 //!< Input bit mask 2
    2726    );
    2827
    29 /* AND two bit masks */
     28/** AND two bit masks */
    3029psBitMask *
    31 psAndBitMasks(psBitMask *outMask,       // Output bit mask or NULL
    32              const psBitMask *restrict inMask1, // Input bit mask 1
    33              const psBitMask *restrict inMask2 // Input bit mask 2
     30psAndBitMasks(psBitMask *outMask,       //!< Output bit mask or NULL
     31             const psBitMask *restrict inMask1, //!< Input bit mask 1
     32             const psBitMask *restrict inMask2 //!< Input bit mask 2
    3433    );
    3534

  • trunk/archive/pslib/include/psColour.h

    r149 r153  
    22#define PS_COLOUR_H
    33
    4 /* Colour References */
    54
    6 /*
    7  * Reference colours are roughly appropriate for a G5V star.  I get, with an arbitrary zero point, on the AB
    8  * system the following rough magnitudes: g = 1.36 mag, r = 0.84 mag, i = 0.72 mag, z = 0.69 mag, y = 0.69
    9  * mag, w = 0.80 mag
     5/** Colour References.  Reference colours are roughly appropriate for a G5V star.  I get, with an arbitrary
     6 * zero point, on the AB system the following rough magnitudes: g = 1.36 mag, r = 0.84 mag, i = 0.72 mag, z =
     7 * 0.69 mag, y = 0.69 mag, w = 0.80 mag
    108 */
    119enum {
    12     PS_COLOUR_NO_INFO,                  // No colour information
    13     PS_COLOUR_G_MINUS_R,                // Reference is g-r = 0.5 mag
    14     PS_COLOUR_R_MINUS_I,                // Reference is r-i = 0.1 mag
    15     PS_COLOUR_I_MINUS_Z,                // Reference is i-z = 0.0 mag
    16     PS_COLOUR_Z_MINUS_Y,                // Reference is z-y = 0.0 mag
    17     PS_COLOUR_R_MINUS_W                 // Reference is r-w = 0.0 mag
     10    PS_COLOUR_NO_INFO,                  //!< No colour information
     11    PS_COLOUR_G_MINUS_R,                //!< Reference is g-r = 0.5 mag
     12    PS_COLOUR_R_MINUS_I,                //!< Reference is r-i = 0.1 mag
     13    PS_COLOUR_I_MINUS_Z,                //!< Reference is i-z = 0.0 mag
     14    PS_COLOUR_Z_MINUS_Y,                //!< Reference is z-y = 0.0 mag
     15    PS_COLOUR_R_MINUS_W                 //!< Reference is r-w = 0.0 mag
    1816} psColourRef;
    1917

  • trunk/archive/pslib/include/psComplexArrays.h

    r149 r153  
    66/* Complex number arrays */
    77
    8 /* Multiplication of two complex number arrays */
    9 /* Purposely leave these NOT restrict-ed, so that the multiplication may be done in-place */
     8/** Multiplication of two complex number arrays.  Purposely leave these NOT restrict-ed, so that the
     9 * multiplication may be done in-place
     10 */
    1011psComplexArray *
    11 psComplexMultiply(psComplexArray *out, // Output array to be returned; may be NULL
    12                   const psComplexArray *complex1, // Input complex array 1
    13                   const psComplexArray *complex2 // Input complex array 2
     12psComplexMultiply(psComplexArray *out, //!< Output array to be returned; may be NULL
     13                  const psComplexArray *complex1, //!< Input complex array 1
     14                  const psComplexArray *complex2 //!< Input complex array 2
    1415                  );
    1516
    16 /* Division of two complex number arrays */
    17 /* Purposely leave these NOT restrict-ed, so that the division may be done in-place */
     17/** Division of two complex number arrays.  Purposely leave these NOT restrict-ed, so that the division
     18 * may be done in-place
     19 */
    1820psComplexArray *
    19 psComplexDivide(psComplexArray *out,    // Output array to be returned; may be NULL
    20                 const psComplexArray *complex1, // Input complex array 1
    21                 const psComplexArray *complex2 // Input complex array 2
     21psComplexDivide(psComplexArray *out,    //!< Output array to be returned; may be NULL
     22                const psComplexArray *complex1, //!< Input complex array 1
     23                const psComplexArray *complex2 //!< Input complex array 2
    2224                );
    2325
    24 /* Complex conjugates for a complex number array */
    25 /* Purposely leave these NOT restrict-ed, so that the operation may be done in-place */
     26/** Complex conjugates for a complex number array. Purposely leave these NOT restrict-ed, so that the
     27 * operation may be done in-place
     28 */
    2629psComplexArray *
    27 psComplexConjugate(psComplexArray *out, // Output array to be returned; may be NULL
    28                    const psComplexArray *myComplexNumbers // Input complex number array
     30psComplexConjugate(psComplexArray *out, //!< Output array to be returned; may be NULL
     31                   const psComplexArray *myComplexNumbers //!< Input complex number array
    2932                   );
    3033
    31 /* Moduli for a complex number array */
     34/** Moduli for a complex number array */
    3235psFloatArray *
    33 psComplexModulus(const psComplex *restrict myComplexNumbers // Input complex number array
     36psComplexModulus(const psComplex *restrict myComplexNumbers //!< Input complex number array
    3437                 );
    3538

  • trunk/archive/pslib/include/psDateTime.h

    r149 r153  
    44/* Dates and Times */
    55
    6 /* Get current MJD, for a timestamp */
     6/** Get current MJD, for a timestamp */
    77float
    88psGetMJD(void);
    99
    10 /* Convert MJD to Human-readable date/time string */
     10/** Convert MJD to Human-readable date/time string */
    1111char *
    12 psMJDToTime(float mjd                   // Input MJD
     12psMJDToTime(float mjd                   //!< Input MJD
    1313            );
    1414
    15 /* Get Sidereal time */
     15/** Get Sidereal time */
    1616float
    17 psGetSidereal(float mjd,                // MJD
    18               float longitude           // Longitude
     17psGetSidereal(float mjd,                //!< MJD
     18              float longitude           //!< Longitude
    1919              );
    2020

  • trunk/archive/pslib/include/psFFT.h

    r149 r153  
    66/* Fourier Transform functions */
    77
    8 /* Return Fourier Transform of an array */
     8/** Return Fourier Transform of an array */
    99psComplexArray *
    10 psRealFFT(psComplexArray *restrict out, // Output array to be returned; may be NULL
    11           const psFloatArray *restrict myArray // Input array
     10psRealFFT(psComplexArray *restrict out, //!< Output array to be returned; may be NULL
     11          const psFloatArray *restrict myArray //!< Input array
    1212          );
    1313
    14 /* Return [inverse?] Fourier Transform of a complex array */
    15 /* May NOT be done in-place (restrict-ed) */
     14/** Return [inverse?] Fourier Transform of a complex array.  May NOT be done in-place (restrict-ed) */
    1615psComplexArray *
    17 psComplexFFT(psComplexArray *restrict out, // Output array to be returned; may be NULL
    18              const psComplexArray *restrict myArray, // Input array
    19              int sign                   // +1 or -1 to indicate direction of FT
     16psComplexFFT(psComplexArray *restrict out, //!< Output array to be returned; may be NULL
     17             const psComplexArray *restrict myArray, //!< Input array
     18             int sign                   //!< +1 or -1 to indicate direction of FT
    2019             );
    2120
    22 /* Return Power spectrum of a array */
     21/** Return Power spectrum of a array */
    2322psFloatArray *
    24 psPowerSpec(psFloatArray *restrict out, // Output array to be returned
    25             const psFloatArray *restrict myArray // Input array
     23psPowerSpec(psFloatArray *restrict out, //!< Output array to be returned
     24            const psFloatArray *restrict myArray //!< Input array
    2625            );
    2726

  • trunk/archive/pslib/include/psFilter.h

    r149 r153  
    22#define PS_FILTER_H
    33
     4/** Filters */
    45enum {
    5     PS_FILTER_G,                        // g band
    6     PS_FILTER_R,                        // r band
    7     PS_FILTER_I,                        // i band
    8     PS_FILTER_Z,                        // z band
    9     PS_FILTER_Y,                        // y band
    10     PS_FILTER_W                         // w band
     6    PS_FILTER_G,                        //!< g band
     7    PS_FILTER_R,                        //!< r band
     8    PS_FILTER_I,                        //!< i band
     9    PS_FILTER_Z,                        //!< z band
     10    PS_FILTER_Y,                        //!< y band
     11    PS_FILTER_W                         //!< w band
    1112} psFilter;
    1213

  • trunk/archive/pslib/include/psFunctions.h

    r149 r153  
    66/* Standard Functions */
    77
    8 /* Gaussian */
    9 /* Note that this is not a Gaussian deviate */
     8/** Gaussian.  Note that this is not a Gaussian deviate */
    109float
    11 psGaussian(float x,                     // Value at which to evaluate
    12            float mean,                  // Mean for the Gaussian
    13            float stddev                 // Standard deviation for the Gaussian
     10psGaussian(float x,                     //!< Value at which to evaluate
     11           float mean,                  //!< Mean for the Gaussian
     12           float stddev                 //!< Standard deviation for the Gaussian
    1413           );
    1514
    16 /* Polynomial: one dimension */
     15/** Polynomial: one dimension */
    1716float
    18 psPolynomial1d(float x,                 // Value at which to evaluate
    19                const psFloatArray *restrict coeffs // Coefficients for the polynomial
     17psPolynomial1d(float x,                 //!< Value at which to evaluate
     18               const psFloatArray *restrict coeffs //!< Coefficients for the polynomial
    2019               );
    2120
    22 /* Polynomial: two dimensions */
     21/** Polynomial: two dimensions */
    2322float
    24 psPolynomial2d(float x,                 // Value x at which to evaluate
    25                float y,                 // Value y at which to evaluate
    26                int orderx,              // Polynomial order in x
    27                int ordery,              // Polynomial order in y
    28                const psFloatArray *coeffs // Coefficients for the polynomial
     23psPolynomial2d(float x,                 //!< Value x at which to evaluate
     24               float y,                 //!< Value y at which to evaluate
     25               int orderx,              //!< Polynomial order in x
     26               int ordery,              //!< Polynomial order in y
     27               const psFloatArray *coeffs //!< Coefficients for the polynomial
    2928               );
    3029

  • trunk/archive/pslib/include/psMatrix.h

    r149 r153  
    22#define PS_MATRIX_H
    33
    4 /* A matrix */
     4/** A matrix */
    55typedef struct {
    6     int xSize, ySize;                   // Dimensions in x and y
    7     float *restrict *restrict value;    // Values in matrix
     6    int xSize, ySize;                   //!< Dimensions in x and y
     7    float *restrict *restrict value;    //!< Values in matrix
    88} psMatrix;
    99
    10 /* Constructor */
     10/** Constructor */
    1111psMatrix *
    12 psMatrixNew(int Xdimen,                 // x dimension of new matrix
    13             int Ydimen                  // y dimension of new matrix
     12psMatrixNew(int Xdimen,                 //!< x dimension of new matrix
     13            int Ydimen                  //!< y dimension of new matrix
    1414            );
    1515
    16 /* Destructor */
     16/** Destructor */
    1717void
    18 psMatrixDel(psMatrix *restrict myMatrix // Matrix to destroy
     18psMatrixDel(psMatrix *restrict myMatrix //!< Matrix to destroy
    1919            );
    2020
    … …  
    2323/* Linear Algebra */
    2424
    25 /* Invert matrix */
    26 /* Not using restrict, to allow inversion to be done in-place */
     25/** Invert matrix.  Not using restrict, to allow inversion to be done in-place */
    2726psMatrix *
    28 psInvertMatrix(psMatrix *out,           // Matrix to return, or NULL
    29                const psMatrix *myMatrix, // Matrix to be inverted
    30                float *restrict determinant // Determinant to return, or NULL
     27psInvertMatrix(psMatrix *out,           //!< Matrix to return, or NULL
     28               const psMatrix *myMatrix, //!< Matrix to be inverted
     29               float *restrict determinant //!< Determinant to return, or NULL
    3130               );
    3231
    33 /* Matrix determinant */
     32/** Matrix determinant */
    3433float
    35 psDeterminant(const psMatrix *restrict myMatrix // Matrix to get determinant for
     34psDeterminant(const psMatrix *restrict myMatrix //!< Matrix to get determinant for
    3635              );
    3736
    38 /* Matrix Multiplication */
    39 /* Not using restrict, to allow matrix1 == matrix2, and to do multiplication in-place */
     37/** Matrix Multiplication.  Not using restrict, to allow matrix1 == matrix2, and to do multiplication
     38 * in-place
     39 */
    4040psMatrix
    41 psMatrixMultiply(psMatrix *out,         // Matrix to return, or NULL
    42                  const psMatrix *matrix1, // Matrix 1
    43                  const psMatrix *matrix2 // Matrix 2
     41psMatrixMultiply(psMatrix *out,         //!< Matrix to return, or NULL
     42                 const psMatrix *matrix1, //!< Matrix 1
     43                 const psMatrix *matrix2 //!< Matrix 2
    4444                 );
    4545

  • trunk/archive/pslib/include/psMinimise.h

    r149 r153  
    77/* Minimisation */
    88
    9 /* Minimise a particular function */
     9/** Minimise a particular function */
    1010psFloatArray *
    11 psMinimise(float (*myFunction)(const psFloatArray *restrict),   // Function to minimise
    12            psFloatArray *restrict initialGuess // Initial guess
     11psMinimise(float (*myFunction)(const psFloatArray *restrict),   //!< Function to minimise
     12           psFloatArray *restrict initialGuess //!< Initial guess
    1313           );
    1414
    1515
    16 /* Minimise chi^2 for input data */
     16/** Minimise chi^2 for input data */
    1717psFloatArray *
    1818psMinimiseChi2(float (*evalModel)(const psFloatArray *restrict,
    19                                   const psFloatArray *restrict), // Model to fit; receives domain and
    20                                                                    // parameters
    21                const psFloatArray *restrict domain, // The domain values for the corresponding measurements
    22                const psFloatArray *restrict data, // Data to fit
    23                const psFloatArray *restrict errors, // Errors in the data
    24                psFloatArray *restrict initialGuess, // Initial guess
    25                const psIntArray *restrict guessMask // 1 = fit for parameter, 0 = hold parameter constant
     19                                  const psFloatArray *restrict), //!< Model to fit; receives domain and
     20                                                                 //!< parameters
     21               const psFloatArray *restrict domain, //!< The domain values for the corresponding measurements
     22               const psFloatArray *restrict data, //!< Data to fit
     23               const psFloatArray *restrict errors, //!< Errors in the data
     24               psFloatArray *restrict initialGuess, //!< Initial guess
     25               const psIntArray *restrict guessMask //!< 1 = fit for parameter, 0 = hold parameter constant
    2626               );
    2727
    28 /* Derive a polynomial that goes through the points --- can be done analytically */
     28/** Derive a polynomial that goes through the points --- can be done analytically */
    2929psFloatArray *
    30 psGetArrayPolynomial(const psFloatArray *restrict ord, // Ordinates (or NULL to just use the indices)
    31                      const psFloatArray *restrict coord // Coordinates
     30psGetArrayPolynomial(const psFloatArray *restrict ord, //!< Ordinates (or NULL to just use the indices)
     31                     const psFloatArray *restrict coord //!< Coordinates
    3232    );
    3333

  • trunk/archive/pslib/include/psObjects.h

    r149 r153  
    2020/***********************************************************************************************************/
    2121
    22 /* Object definition, to handle both objects we detect, and catalogues */
     22/** Object definition, to handle both objects we detect, and catalogues */
    2323typedef struct {
    24     psOTAPos *otaPos;                   // Centre position on OTA, with associated error
    25     psSkyPos *skyPos;                   // Position on the sky, with associated error
    26     float mag, magErr;                  // Magnitude and associated error
    27     float isoMag, isoMagErr;            // Isophotal magnitude and associated error
    28     float fwhm, fwhmErr;                // FWHM and associated error
    29     float ellipA, ellipB;               // Elliptical semi-major (A) and semi-minor (B) axes
    30     float ellipAngle;                   // Ellipse position angle
    31     float sky, skyErr;                  // Local sky level, and associated error
    32     float colour, colourErr;            // Colour and associated error, if known
    33     enum psColourRef colourRef;         // Colour reference
    34     psBitMask *quality;                 // Bit mask for quality information
     24    psOTAPos *otaPos;                   //!< Centre position on OTA, with associated error
     25    psSkyPos *skyPos;                   //!< Position on the sky, with associated error
     26    float mag, magErr;                  //!< Magnitude and associated error
     27    float isoMag, isoMagErr;            //!< Isophotal magnitude and associated error
     28    float fwhm, fwhmErr;                //!< FWHM and associated error
     29    float ellipA, ellipB;               //!< Elliptical semi-major (A) and semi-minor (B) axes
     30    float ellipAngle;                   //!< Ellipse position angle
     31    float sky, skyErr;                  //!< Local sky level, and associated error
     32    float colour, colourErr;            //!< Colour and associated error, if known
     33    enum psColourRef colourRef;         //!< Colour reference
     34    psBitMask *quality;                 //!< Bit mask for quality information
    3535} psObject;
    3636
    37 /* Constructor */
     37/** Constructor */
    3838psObject *
    3939psObjectNew(void);
    4040
    41 /* Destructor */
     41/** Destructor */
    4242void
    4343psObjectDel(psObject *restrict myObject);
    … …  
    4545/***********************************************************************************************************/
    4646
    47 /* An assembly of objects */
     47/** An assembly of objects */
    4848PS_DECLARE_ARRAY_TYPE(psObject);
    4949PS_CREATE_ARRAY_TYPE(psObject);
    … …  
    5151/***********************************************************************************************************/
    5252
    53 /* Associates objects on an image with the image */
     53/** Associates objects on an image with the image */
    5454typedef struct {
    55     const psImage *image;               // Image that produced the objects, which has metadata we need
    56     psObjectArray *objects;             // The objects
     55    const psImage *image;               //!< Image that produced the objects, which has metadata we need
     56    psObjectArray *objects;             //!< The objects
    5757} psImageObjects;
    5858
    59 /* Constructor */
     59/** Constructor */
    6060psImageObjects *
    61 psImageObjectsNew(const psImage *image, // Image that produced the objects, which has metadata we need
    62                   psObjectArray *objects // The objects
     61psImageObjectsNew(const psImage *image, //!< Image that produced the objects, which has metadata we need
     62                  psObjectArray *objects //!< The objects
    6363                  );
    6464
    65 /* Destructor */
     65/** Destructor */
    6666void
    67 psImageObjectsDel(psImageObjects *restrict myImageObjects // Object to destroy
     67psImageObjectsDel(psImageObjects *restrict myImageObjects //!< Object to destroy
    6868                  );
    6969
    7070/***********************************************************************************************************/
    7171
    72 /* Objects from a catalogue */
     72/** Objects from a catalogue */
    7373typedef struct {
    74     enum psCatalogue catalogue;         // Source catalogue from which objects come
    75     psObjectArray *object;              // The objects
     74    enum psCatalogue catalogue;         //!< Source catalogue from which objects come
     75    psObjectArray *object;              //!< The objects
    7676} psCatalogueObjects;
    7777
    78 /* Constructor */
     78/** Constructor */
    7979psCatalogueObjects *
    80 psCatalogueObjectsNew(enum psCatalogue *catalogue, // Source catalogue
    81                       psObjectArray *objects // The objects
     80psCatalogueObjectsNew(enum psCatalogue *catalogue, //!< Source catalogue
     81                      psObjectArray *objects //!< The objects
    8282                      );
    8383
    84 /* Destructor */
     84/** Destructor */
    8585void
    86 psCatalogueObjectsDel(psCatalogeObjects *restrict myCatalogueObjects // Object to destroy
     86psCatalogueObjectsDel(psCatalogeObjects *restrict myCatalogueObjects //!< Object to destroy
    8787                      );
    8888
    8989/***********************************************************************************************************/
    9090
    91 /* A "super" object --- an object with multiple detections in different images */
     91/** A "super" object --- an object with multiple detections in different images */
    9292typedef struct {
    93     const psImageArray *images;         // Images that provided the different measurements
    94     const psObjectArray *objects;       // Individual object measurements
     93    const psImageArray *images;         //!< Images that provided the different measurements
     94    const psObjectArray *objects;       //!< Individual object measurements
    9595
    9696    /* Derived quantities */
    97     psSkyPos *meanSkyPos;               // Mean position on the sky
    98     double pmRA, pmDec;                 // Proper motion in RA and Dec
    99     double pmRAErr, pmDecErr;           // Errors in proper motion
    100     float posChi2;                      // chi^2 for position
     97    psSkyPos *meanSkyPos;               //!< Mean position on the sky
     98    double pmRA, pmDec;                 //!< Proper motion in RA and Dec
     99    double pmRAErr, pmDecErr;           //!< Errors in proper motion
     100    float posChi2;                      //!< chi^2 for position
    101101} psSuperObject;
    102102
    103 /* Constructor */
     103/** Constructor */
    104104psSuperObject *
    105 psSuperObjectNew(const psImageArray *images, // The images with the measurements
    106                  const psObjectArray *objects // Object measurements
     105psSuperObjectNew(const psImageArray *images, //!< The images with the measurements
     106                 const psObjectArray *objects //!< Object measurements
    107107                 );
    108108
    109 /* Destructor */
     109/** Destructor */
    110110void
    111 psSuperObjectDel(psSuperObject *restrict mySuperObject // Object to destroy
     111psSuperObjectDel(psSuperObject *restrict mySuperObject //!< Object to destroy
    112112                 );
    113113
    … …  
    118118
    119119
    120 /* Correlate two OTA object arrays */
    121 /*
     120/** Correlate two OTA object arrays.
    122121 * Returns an array with the indices of the object in the second bunch that matched the corresponding object
    123122 * in the first bunch, or -1 if none that match.
    124123 */
    125124psIntArray *
    126 psCorrelateObjects(const psObjectArray *restrict myObjects1, // First bunch of objects
    127                    const psObjectArray *restrict myObjects2, // Second bunch of objects
    128                    const psOTADescription *myOTA1, // OTA description for first bunch of objects, or NULL for
    129                                                    // sky
    130                    const psOTADescription *myOTA2 // OTA description for second bunch of objects, or NULL for
    131                                                   // sky
     125psCorrelateObjects(const psObjectArray *restrict myObjects1, //!< First bunch of objects
     126                   const psObjectArray *restrict myObjects2, //!< Second bunch of objects
     127                   const psOTADescription *myOTA1, //!< OTA description for first bunch of objects, or NULL for
     128                                                   //!< sky
     129                   const psOTADescription *myOTA2 //!< OTA description for second bunch of objects, or NULL for
     130                                                  //!< sky
    132131                   );
    133132
    134133
    135 /* Get matched lists from a correlated index array */
    136 /* Returns a status number, and matched1 and matched2 are manipulated to contain matches */
     134/** Get matched lists from a correlated index array Returns a status number, and matched1 and matched2
     135 * are manipulated to contain matches
     136 */
    137137int
    138 psGetCorrelatedMatches(const psIntArray matches, // Index array specifying matches */
    139                        const psObjectArray *restrict myObjects1, // First bunch of objects
    140                        const psObjectArray *restrict myObjects2, // Second bunch of objects
    141                        psObjectArray *matched1, // Matched objects in first bunch
    142                        psObjectArray *matched2 // Matched objects in second bunch
     138psGetCorrelatedMatches(const psIntArray matches, //!< Index array specifying matches */
     139                       const psObjectArray *restrict myObjects1, //!< First bunch of objects
     140                       const psObjectArray *restrict myObjects2, //!< Second bunch of objects
     141                       psObjectArray *matched1, //!< Matched objects in first bunch
     142                       psObjectArray *matched2 //!< Matched objects in second bunch
    143143                       );
    144144
    … …  
    147147/* Object selection */
    148148
    149 /* Get objects within a particular magnitude range */
     149/** Get objects within a particular magnitude range */
    150150psObjectArray *
    151 psSelectObjectMag(psObjectArray *restrict myArray, // Bunch of objects to select from
    152                   float magLower,       // Lower bound for magnitude
    153                   float magUpper        // Upper bound for magnitude
     151psSelectObjectMag(psObjectArray *restrict myArray, //!< Bunch of objects to select from
     152                  float magLower,       //!< Lower bound for magnitude
     153                  float magUpper        //!< Upper bound for magnitude
    154154                  );
    155155
    156 /* Get objects within a radius on the sky */
     156/** Get objects within a radius on the sky */
    157157psObjectArray *
    158 psSelectObjectSkyDist(psObjectArray *restrict myArray, // Bunch of objects to select from
    159                       psSkyPos *skyPos, // Position on the sky
    160                       float radius,     // Radius of search
    161                       int circleOrSquare // Circle = 1, Square = 2
     158psSelectObjectSkyDist(psObjectArray *restrict myArray, //!< Bunch of objects to select from
     159                      psSkyPos *skyPos, //!< Position on the sky
     160                      float radius,     //!< Radius of search
     161                      int circleOrSquare //!< Circle = 1, Square = 2
    162162                      );
    163163
    164 /* Get objects within a particular colour range */
     164/** Get objects within a particular colour range */
    165165psObjectArray *
    166 psSelectObjectColour(psObjectArray *restrict myArray, // Bunch of objects to select from
    167                      float magLower,    // Lower bound for colour
    168                      float magUpper,    // Upper bound for colour
    169                      enum psColourRef colourRef // Only select those with this colour reference
     166psSelectObjectColour(psObjectArray *restrict myArray, //!< Bunch of objects to select from
     167                     float magLower,    //!< Lower bound for colour
     168                     float magUpper,    //!< Upper bound for colour
     169                     enum psColourRef colourRef //!< Only select those with this colour reference
    170170                     );
    171171

  • trunk/archive/pslib/include/psPosition.h

    r149 r153  
    77/***********************************************************************************************************/
    88
    9 /* Magic values for errors */
     9/** Magic values for errors */
    1010enum {
    11     PS_NO_VALUE = -111.0,               // Corresponding value not yet measured
    12     PS_NO_ERROR = -222.0                // Corresponding value has no error
     11    PS_NO_VALUE = -111.0,               //!< Corresponding value not yet measured
     12    PS_NO_ERROR = -222.0                //!< Corresponding value has no error
    1313};
    1414
    1515/***********************************************************************************************************/
    1616
    17 /* Planets */
     17/** Planets */
    1818enum {
    1919    PS_MERCURY = 1,
    … …  
    2727} psPlanetNum;
    2828
    29 /* Catalogues */
     29/** Catalogues */
    3030enum {
    31     PS_PANSTARRS,                       // Pan-STARRS object catalogue
    32     PS_USNO,                            // USNO-B1 catalogue
    33     PS_2MASS,                           // 2MASS catalogue
    34     PS_TYCHO,                           // Tycho catalogue
    35     UCAC2 = 4                           // UCAC2 catalogue
     31    PS_PANSTARRS,                       //!< Pan-STARRS object catalogue
     32    PS_USNO,                            //!< USNO-B1 catalogue
     33    PS_2MASS,                           //!< 2MASS catalogue
     34    PS_TYCHO,                           //!< Tycho catalogue
     35    PS_UCAC2 = 4                        //!< UCAC2 catalogue
    3636} psCatalogue;
    3737
    3838/***********************************************************************************************************/
    3939
    40 /* A position on a detector */
     40/** A position on a detector */
    4141typedef struct {
    42     int chip;                           // Chip number
    43     float x;                            // x position
    44     float xErr;                         // Error in x position
    45     float y;                            // y position
    46     float yErr;                         // Error in y position
     42    int chip;                           //!< Chip number
     43    float x;                            //!< x position
     44    float xErr;                         //!< Error in x position
     45    float y;                            //!< y position
     46    float yErr;                         //!< Error in y position
    4747} psOTAPos;
    4848
    49 /* Constructor */
     49/** Constructor */
    5050psOTAPos *
    5151psOTAPosNew(void);
    5252
    53 /* Destructor */
     53/** Destructor */
    5454void
    55 psOTAPosDel(psOTAPos *restrict myOTAPos // Object to destroy
     55psOTAPosDel(psOTAPos *restrict myOTAPos //!< Object to destroy
    5656    );
    5757
    5858/***********************************************************************************************************/
    5959
    60 /* An array of detector positions */
     60/** An array of detector positions */
    6161PS_DECLARE_ARRAY_TYPE(psOTAPos);
    6262PS_CREATE_ARRAY_TYPE(psOTAPos);
    … …  
    6464/***********************************************************************************************************/
    6565
    66 /* A simple RA/Dec position on the sky, default system is ICRS. */
    67 /* Double precision needed for milli-arcsec */
     66/*
     67 * \brief A simple RA/Dec position on the sky, default system is ICRS.  Double precision needed for
     68 * milli-arcsec.
     69 */
    6870typedef struct {
    69     double ra;                          // Right Ascension
    70     double raErr;                       // Error in RA
    71     double dec;                         // Declination
    72     double decErr;                      // Error in Dec
     71    double ra;                          //!< Right Ascension
     72    double raErr;                       //!< Error in RA
     73    double dec;                         //!< Declination
     74    double decErr;                      //!< Error in Dec
    7375} psSkyPos;
    7476
    75 /* Constructor */
     77/** Constructor */
    7678psSkyPos *
    7779psSkyPosNew(void);
    7880
    79 /* Destructor */
     81/** Destructor */
    8082void
    81 psSkyPosDel(psSkyPos *restrict mySkyPos // Object to destroy
     83psSkyPosDel(psSkyPos *restrict mySkyPos //!< Object to destroy
    8284    );
    8385
    8486/***********************************************************************************************************/
    8587
    86 /* An array of sky positions */
     88/** An array of sky positions */
    8789PS_DECLARE_ARRAY_TYPE(psSkyPos);
    8890PS_CREATE_ARRAY_TYPE(psSkyPos);
    … …  
    9092/***********************************************************************************************************/
    9193
    92 /* Latitude and Longitude. */
    93 /* Double precision needed for milli-arcsec */
     94/** Latitude and Longitude.  Double precision needed for milli-arcsec */
    9495typedef struct {
    95     double lat;                         // Latitude
    96     double latErr;                      // Error in Latitude
    97     double lng;                         // Longitude (can't use "long")
    98     double lngErr;                      // Error in Longitude
     96    double lat;                         //!< Latitude
     97    double latErr;                      //!< Error in Latitude
     98    double lng;                         //!< Longitude (can't use "long")
     99    double lngErr;                      //!< Error in Longitude
    99100} psLatLong;
    100101
    101 /* Constructor */
     102/** Constructor */
    102103psLatLong *
    103104psLatLongNew(void);
    104105
    105 /* Destructor */
     106/** Destructor */
    106107void
    107 psLatLongDel(psLatLong *restrict myLatLong // Object to destroy
     108psLatLongDel(psLatLong *restrict myLatLong //!< Object to destroy
    108109    );
    109110
    … …  
    112113/* Offsets */
    113114
    114 /* Get offset (RA,Dec) on the sky between two positions */
    115 /* position1 and position2 may not be identical */
     115/** Get offset (RA,Dec) on the sky between two positions position1 and position2 may not be identical */
    116116psSkyPos *
    117 psGetOffset(const psSkyPos *restrict position1, // Position 1
    118             const psSkyPos *restrict position2 // Position 2
     117psGetOffset(const psSkyPos *restrict position1, //!< Position 1
     118            const psSkyPos *restrict position2 //!< Position 2
    119119            );
    120120
    121 /* Apply an offset to a position */
     121/** Apply an offset to a position */
    122122psSkyPos *
    123 psApplyOffset(const psSkyPos *restrict position, // Position
    124               const psSkyPos *restrict offset // Offset
     123psApplyOffset(const psSkyPos *restrict position, //!< Position
     124              const psSkyPos *restrict offset //!< Offset
    125125              );
    126126
    … …  
    129129/* Positions of well-known objects */
    130130
    131 /* Get Sun Position */
     131/** Get Sun Position */
    132132psSkyPos *
    133 psGetSunPos(float mjd                   // MJD to get position for
     133psGetSunPos(float mjd                   //!< MJD to get position for
    134134            );
    135135
    136 /* Get Moon position */
     136/** Get Moon position */
    137137psSkyPos *
    138 psGetMoonPos(float mjd,                 // MJD to get position for
    139              double latitude,           // Latitude for apparent position
    140              double longitude           // Longitude for apparent position
     138psGetMoonPos(float mjd,                 //!< MJD to get position for
     139             double latitude,           //!< Latitude for apparent position
     140             double longitude           //!< Longitude for apparent position
    141141             );
    142142
    143 /* Get Moon phase */
     143/** Get Moon phase */
    144144float
    145 psGetMoonPhase(float mjd                // MJD to get phase for
     145psGetMoonPhase(float mjd                //!< MJD to get phase for
    146146               );
    147147
    148 /* Get Planet positions */
     148/** Get Planet positions */
    149149psSkyPos *
    150 psGetPlanetPos(enum psPlanetNum myPlanetNum, // Number for planet
    151                float mjd                // MJD to get position for
     150psGetPlanetPos(enum psPlanetNum myPlanetNum, //!< Number for planet
     151               float mjd                //!< MJD to get position for
    152152               );
    153153
    154 /* Get star list from catalogue */
     154/** Get star list from catalogue */
    155155psObjectArray *
    156 psReadStarCatalogue(double ra,          // RA of centre of search
    157                     double dec,         // Declination of centre of search
    158                     float radius,       // Radius of search for stars in catalogue
    159                     float mjd,          // The epoch (in MJD) for which to get positions
    160                     enum psCatalogue myCatalogue // The catalogue to use
     156psReadStarCatalogue(double ra,          //!< RA of centre of search
     157                    double dec,         //!< Declination of centre of search
     158                    float radius,       //!< Radius of search for stars in catalogue
     159                    float mjd,          //!< The epoch (in MJD) for which to get positions
     160                    enum psCatalogue myCatalogue //!< The catalogue to use
    161161    );
    162162
    … …  
    165165/* Celestial coordinate conversions */
    166166
    167 /* Convert ICRS to Ecliptic */
     167/** Convert ICRS to Ecliptic */
    168168psLatLong *
    169 psCoordinatesItoE(const psSkyPos *restrict coordinates // ICRS coordinates to convert
     169psCoordinatesItoE(const psSkyPos *restrict coordinates //!< ICRS coordinates to convert
    170170                  );
    171171
    172 /* Convert Ecliptic to ICRS */
     172/** Convert Ecliptic to ICRS */
    173173psSkyPos *
    174 psCoordinatesEtoI(const psLatLong *restrict coordinates // Ecliptic coordinates to convert
     174psCoordinatesEtoI(const psLatLong *restrict coordinates //!< Ecliptic coordinates to convert
    175175                  );
    176176
    177 /* Convert ICRS to Galactic */
     177/** Convert ICRS to Galactic */
    178178psLatLong *
    179 psCoordinatesItoG(const psSkyPos *restrict coordinates // ICRS coordinates to convert
     179psCoordinatesItoG(const psSkyPos *restrict coordinates //!< ICRS coordinates to convert
    180180                  );
    181181
    182 /* Convert Galactic to ICRS */
     182/** Convert Galactic to ICRS */
    183183psSkyPos *
    184 psCoordinatesGtoI(const psLatLong *restrict coordinates // Galactic coordinates to convert
     184psCoordinatesGtoI(const psLatLong *restrict coordinates //!< Galactic coordinates to convert
    185185                  );
    186186

  • trunk/archive/pslib/include/psSort.h

    r149 r153  
    66/* Sorting */
    77
    8 /* Sort an array */
    9 /* Inputs not restrict-ed to allow sort in place */
     8/** Sort an array. Inputs not restrict-ed to allow sort in place */
    109psFloatArray *
    11 psSort(psFloatArray *out,               // Sorted array to return. May be NULL
    12        const psFloatArray *myArray      // Array to sort
     10psSort(psFloatArray *out,               //!< Sorted array to return. May be NULL
     11       const psFloatArray *myArray      //!< Array to sort
    1312       );
    1413
    15 /* Sort an array, along with some other stuff */
    16 /* Returns an index array */
     14/** Sort an array, along with some other stuff.  Returns an index array */
    1715psIntArray *
    18 psCoSort(psIntArray *restrict out;      // Output index array (may be NULL)
    19          const psFloatArray *restrict myArray // Array to sort
     16psCoSort(psIntArray *restrict out;      //!< Output index array (may be NULL)
     17         const psFloatArray *restrict myArray //!< Array to sort
    2018         );
    2119

  • trunk/archive/pslib/include/psStats.h

    r149 r153  
    55#include "psStdArrays.h"
    66
    7 /* Do Statistics on an array.  Returns a status value. */
     7/** Do Statistics on an array.  Returns a status value. */
    88int
    9 psArrayStats(const psFloatArray *restrict myArray, // Array to be analysed
    10              const psIntArray *restrict maskArray, // Ignore elements where (maskArray & maskVal) != 0
    11                                                    // May be NULL
    12              unsigned int maskVal,      // Only mask elements with one of these bits set in maskArray
    13              int numIter,               // Number of clipping iterations (0 not to clip)
    14              float numSD,               // Number of s.d. to clip at
    15              float *restrict mean,      // Mean of array (or NULL)
    16              float *restrict sd,        // Standard deviation (or NULL)
    17              float *restrict med        // Median (or NULL)
     9psArrayStats(const psFloatArray *restrict myArray, //!< Array to be analysed
     10             const psIntArray *restrict maskArray, //!< Ignore elements where (maskArray & maskVal) != 0
     11                                                   //!< May be NULL
     12             unsigned int maskVal,      //!< Only mask elements with one of these bits set in maskArray
     13             int numIter,               //!< Number of clipping iterations (0 not to clip)
     14             float numSD,               //!< Number of s.d. to clip at
     15             float *restrict mean,      //!< Mean of array (or NULL)
     16             float *restrict sd,        //!< Standard deviation (or NULL)
     17             float *restrict med        //!< Median (or NULL)
    1818             );
    1919
    2020/***********************************************************************************************************/
    2121
    22 /* Histograms */
     22/** Histograms */
    2323typedef struct {
    24     const psFloatArray *restrict lower, *restrict upper; // Lower and upper bounds for the bins
    25     psIntArray *nums;                   // Number in each of the bins
    26     const float minVal, maxVal;         // Minimum and maximum values
    27     int minNum, maxNum;                 // Number below the minimum and above the maximum
     24    const psFloatArray *restrict lower, *restrict upper; //!< Lower and upper bounds for the bins
     25    psIntArray *nums;                   //!< Number in each of the bins
     26    const float minVal, maxVal;         //!< Minimum and maximum values
     27    int minNum, maxNum;                 //!< Number below the minimum and above the maximum
    2828} psHistogram;
    2929
    3030
    31 /* Constructor */
     31/** Constructor */
    3232psHistogram *
    33 psHistogramNew(float lower,             // Lower limit for the bins
    34                float upper,             // Upper limit for the bins
    35                float size               // Size of the bins
     33psHistogramNew(float lower,             //!< Lower limit for the bins
     34               float upper,             //!< Upper limit for the bins
     35               float size               //!< Size of the bins
    3636    );
    3737
    38 /* Generic constructor */
     38/** Generic constructor */
    3939psHistogram *
    40 psHistogramNewGeneric(const psFloatArray *restrict lower, // Lower bounds for the bins
    41                       const psFloatArray *restrict upper, // Upper bounds for the bins
    42                       float minVal,     // Minimum value
    43                       float maxVal      // Maximum value
     40psHistogramNewGeneric(const psFloatArray *restrict lower, //!< Lower bounds for the bins
     41                      const psFloatArray *restrict upper, //!< Upper bounds for the bins
     42                      float minVal,     //!< Minimum value
     43                      float maxVal      //!< Maximum value
    4444    );
    4545
    46 /* Destructor */
     46/** Destructor */
    4747void
    48 psHistogramDel(psHistogram *restrict myHist // Histogram to destroy
     48psHistogramDel(psHistogram *restrict myHist //!< Histogram to destroy
    4949    );
    5050
    5151
    52 /* Calculate a histogram */
     52/** Calculate a histogram */
    5353psHistogram *
    54 psGetArrayHistogram(psHistogram *restrict myHist, // Histogram data
    55                     const psFloatArray *restrict myArray // Array to analyse
     54psGetArrayHistogram(psHistogram *restrict myHist, //!< Histogram data
     55                    const psFloatArray *restrict myArray //!< Array to analyse
    5656    );
    5757

  • trunk/archive/pslib/include/psStdArrays.h

    r149 r153  
    44#include "psArray.h"
    55
    6 /* ps- typedefs so that array names comply with the standard naming convention */
    7 /* These should not be used generally. */
     6/**
     7 * ps- typedefs so that array names comply with the standard naming convention. These should NOT be used
     8 * generally.
     9 */
    810typedef float psFloat;
    911typedef int psInt;
    … …  
    1113typedef double psDouble;
    1214
    13 /* An array of real numbers */
     15/** An array of real numbers */
    1416PS_DECLARE_ARRAY_TYPE(psFloat);
    1517PS_CREATE_ARRAY_TYPE(psFloat);
    1618
    17 /* An array of complex numbers */
     19/** An array of complex numbers */
    1820PS_DECLARE_ARRAY_TYPE(psComplex);
    1921PS_CREATE_ARRAY_TYPE(psComplex);
    2022
    21 /* An array of integers */
     23/** An array of integers */
    2224PS_DECLARE_ARRAY_TYPE(psInt);
    2325PS_CREATE_ARRAY_TYPE(psInt);
    2426
    25 /* An array of double-precision real numbers */
     27/** An array of double-precision real numbers */
    2628PS_DECLARE_ARRAY_TYPE(psDouble);
    2729PS_CREATE_ARRAY_TYPE(psDouble);
Note: See TracChangeset for help on using the changeset viewer.