IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 23259


Ignore:
Timestamp:
Mar 10, 2009, 4:53:42 PM (17 years ago)
Author:
Paul Price
Message:

Changing API for psRandomAlloc() to make it easier to be deterministic. psRandomAlloc() now takes only a single argument, which is the generator type (only PS_RANDOM_TAUS is currently supported; others could easily be added). The seed used by the generator is set by psRandomSeed(). This allows us to use the same seed for the random number generator over multiple calls, which means that we can be deterministic by setting the seed. The old API for psRandomAlloc() is available using psRandomAllocSpecific(). Added to the configuration setup in psModules to include recording the random seed, and setting if desired. Updated all our products to use this API. Some fixes and updates to the configuration run-time information dumping. ppImage now dumps the configuration at the end, allowing the list of files in the run-time information to be set.

Location:
trunk
Files:
56 edited

Legend:

Unmodified
Added
Removed

  • trunk/archive/conv_variance/fake.c

    r20210 r23259  
    4747    psFree(weight);
    4848
    49     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     49    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    5050
    5151    psImage *bright = psImageAlloc(IMAGE_SIZE, IMAGE_SIZE, PS_TYPE_F32);

  • trunk/archive/conv_variance/phot.c

    r20210 r23259  
    5252
    5353    psStats *bgStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
    54     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     54    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    5555    psImageBackground(bgStats, NULL, image, mask, maskVal, rng);
    5656    double bg = bgStats->robustMedian;

  • trunk/ippTools/src/dettool.c

    r21402 r23259  
    578578      // generate a random-valued vector, return an index sorted by the random values
    579579      psVector *randomVector = psVectorAlloc(detrendExps->n, PS_TYPE_F32); // random values
    580       psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     580      psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    581581      for (int i = 0; i < randomVector->n; i++) {
    582582        randomVector->data.F32[i] = psRandomUniform(rng);

  • trunk/ppImage/src/ppImageLoop.c

    r23174 r23259  
    2525    }
    2626
    27     psString dump_file = psMetadataLookupStr(&status, config->arguments, "DUMP_CONFIG");
    28     if (dump_file) {
    29         pmConfigCamerasCull(config, NULL);
    30         pmConfigRecipesCull(config, "PPIMAGE,PPSTATS,PSPHOT,MASKS,PSASTRO,JPEG");
    31 
    32         pmConfigDump(config, input->fpa, dump_file);
    33     }
     27    pmConfigCamerasCull(config, NULL);
     28    pmConfigRecipesCull(config, "PPIMAGE,PPSTATS,PSPHOT,MASKS,PSASTRO,JPEG");
    3429
    3530    pmFPAview *view = pmFPAviewAlloc(0);// View for level of interest
    … …  
    220215    psFree(view);
    221216
     217    // Dump configuration
     218    psString dump_file = psMetadataLookupStr(&status, config->arguments, "DUMP_CONFIG");
     219    if (dump_file) {
     220        pmConfigDump(config, input->fpa, dump_file);
     221    }
     222
    222223    // Write out summary statistics
    223224    if (options->doStats) {

  • trunk/ppMerge/src/ppMergeMask.c

    r23166 r23259  
    369369
    370370    pmFPAview *view = pmFPAviewAlloc(0); ///< View to component of interest
    371     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); ///< Random number generator
     371    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); ///< Random number generator
    372372
    373373    psMetadata *stats = NULL;           ///< Statistics for output

  • trunk/ppMerge/src/ppMergeScaleZero.c

    r21365 r23259  
    5151        break;
    5252    }
    53     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); ///< Random number generator
     53    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); ///< Random number generator
    5454    pmFPAview *view = NULL;             ///< View into FPA
    5555

  • trunk/ppSim/src/ppSimBadPixels.c

    r20910 r23259  
    7474    }
    7575
    76     psRandom *pseudoRNG = psRandomAlloc(PS_RANDOM_TAUS, seed); // Pseudo-random number generator
     76    psRandom *pseudoRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, seed); // Pseudo-random number generator
    7777
    7878    psImage *image = readout->image;    // Image of interest

  • trunk/ppSim/src/ppSimLoop.c

    r21365 r23259  
    2525    psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, PPSIM_RECIPE); // Recipe
    2626
    27     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     27    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
    2828
    2929    char *typeStr = psMetadataLookupStr(NULL, recipe, "IMAGE.TYPE"); // Type of image to simulate

  • trunk/ppSim/src/ppSimSequence.c

    r19315 r23259  
    133133    if (ppsim_recipe) psStringAppend (&ppSimCommand, " -recipe PPSIM %s", ppsim_recipe);
    134134
    135     unsigned long seed = psMetadataLookupS32 (&status, config, "RND_SEED");
    136     if (!status) seed = 0;
    137     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
     135    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    138136
    139137    psMetadataItem *item = psMetadataLookup (config, "SEQUENCE");
    140138    if (item == NULL) {
    141139        psLogMsg ("ppSimSequence", PS_LOG_WARN, "missing SEQUENCE description");
    142         exit (1);
     140        exit (PS_EXIT_CONFIG_ERROR);
    143141    }
    144142
    … …  
    170168        }
    171169
    172         // determine the camera for the sequence and define the ppSim command
    173         if (camera == NULL) {
    174             camera = psMetadataLookupStr (&status, sequence, "CAMERA");
    175         }
    176 
    177         psString injectCommandReal = NULL;
    178         psString ppSimCommandReal = NULL;
    179 
    180         psStringAppend (&injectCommandReal, "%s --camera %s", injectCommand, camera);
    181         psStringAppend (&ppSimCommandReal, "%s -camera %s", ppSimCommand, camera);
     170        // determine the camera for the sequence and define the ppSim command
     171        if (camera == NULL) {
     172            camera = psMetadataLookupStr (&status, sequence, "CAMERA");
     173        }
     174
     175        psString injectCommandReal = NULL;
     176        psString ppSimCommandReal = NULL;
     177
     178        psStringAppend (&injectCommandReal, "%s --camera %s", injectCommand, camera);
     179        psStringAppend (&ppSimCommandReal, "%s -camera %s", ppSimCommand, camera);
    182180
    183181        if (!strcasecmp (type, "BIAS")) {

  • trunk/ppStack/src/ppStackLoop.c

    r23242 r23259  
    415415    psArray *subKernels = psArrayAlloc(num); // Subtraction kernels --- required in the stacking
    416416    psArray *subRegions = psArrayAlloc(num); // Subtraction regions --- required in the stacking
    417     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     417    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
    418418    int numGood = 0;                    // Number of good frames
    419419    int numCols = 0, numRows = 0;       // Size of image

  • trunk/ppStack/src/ppStackPhotometry.c

    r23242 r23259  
    5050
    5151    // Measure background
    52     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     52    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
    5353    psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV); // Statistics
    5454    if (!psImageBackground(stats, NULL, image, mask, maskVal, rng)) {

  • trunk/ppSub/src/ppSubVarianceFactors.c

    r21524 r23259  
    6565
    6666    psStats *vfStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); // Statistics
    67     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     67    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
    6868
    6969    // mask these values when examining the background

  • trunk/ppSub/test/fake.c

    r18591 r23259  
    8989int main(int argc, char *argv[])
    9090{
    91     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     91    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
    9292
    9393    // Images to generate

  • trunk/psLib/src/fits/psFitsScale.c

    r21183 r23259  
    112112    // psImageBackground automatically excludes pixels that are non-finite, so we don't need to bother about a
    113113    // mask.
    114     psU64 seed = p_psRandomGetSystemSeed(false);
    115     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
     114    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    116115    psStats *stats = psStatsAlloc(MEAN_STAT | STDEV_STAT); // Statistics object
    117116    if (!psImageBackground(stats, NULL, image, mask, maskVal, rng)) {
    … …  
    290289    if (!psMemIncrRefCounter(rng) && options->fuzz) {
    291290        // Don't blab about which seed we're going to get --- it's not necessary for this purpose
    292         psU64 seed = p_psRandomGetSystemSeed(false);
    293         rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
     291        rng = psRandomAlloc(PS_RANDOM_TAUS);
    294292    }
    295293

  • trunk/psLib/src/math/psRandom.c

    r20547 r23259  
    2929#include <inttypes.h>
    3030
     31#include "psAbort.h"
    3132#include "psMemory.h"
    3233#include "psRandom.h"
    … …  
    3839
    3940
     41unsigned long seed = 0;                 // Seed for RNG
     42
     43
    4044psU64 p_psRandomGetSystemSeed(bool log)
    4145{
    42     FILE*  fd;
    43     psU64  seedVal = 0;
    44     time_t timeVal;
     46    psU64 seedVal = 0;                  // Seed value to return
    4547
    46     fd = fopen("/dev/urandom","r");
    47     if(fd == NULL) {
    48         // Read system clock to get seed
    49         seedVal = (psU64)time(&timeVal);
    50     } else {
    51         // Read urandom to get seed
    52         if (fread(&seedVal, sizeof(psU64),1,fd)) {;} // ignore return value
    53         // Close file
    54         fclose(fd);
     48    // Since zero is a special value in our context, don't allow the final value chosen to be zero
     49    while (seedVal == 0) {
     50        FILE *fd = fopen("/dev/urandom", "r");
     51        if (fd) {
     52            // Read urandom to get seed
     53            if (fread(&seedVal, sizeof(psU64), 1, fd)) {;} // ignore return value
     54            // Close file
     55            fclose(fd);
     56        } else {
     57            // Read system clock to get seed
     58            time_t timeVal;                 // Time value
     59            seedVal = (psU64)time(&timeVal);
     60        }
    5561    }
    5662
    … …  
    6369}
    6470
    65 psRandom *psRandomAlloc(psRandomType type,
    66                         unsigned long seed)
     71psU64 psRandomSeed(psU64 value)
    6772{
    68     gsl_rng   *r      = NULL;
    69     psRandom  *myRNG  = NULL;
     73    while (value == 0) {
     74        value = p_psRandomGetSystemSeed(true);
     75    }
     76    seed = value;
     77    return seed;
     78}
    7079
     80// Destructor for psRandom
     81static void randomFree(psRandom *rng)
     82{
     83    if (rng->gsl) {
     84        gsl_rng_free(rng->gsl);
     85    }
     86    return;
     87}
     88
     89// Constructor for psRandom
     90static psRandom *randomAlloc(psRandomType type)
     91{
     92    psRandom *rng = psAlloc(sizeof(psRandom)); // Random number generator to return
     93    psMemSetDeallocator(rng, (psFreeFunc)randomFree);
     94
     95    rng->type = type;
     96
     97    const gsl_rng_type *gslType;        // Type of RNG according to GSL
    7198    switch (type) {
    72     case PS_RANDOM_TAUS:
    73         myRNG = (psRandom*)psAlloc(sizeof(psRandom));
    74         r = gsl_rng_alloc(gsl_rng_taus);
    75         myRNG->gsl = r;
    76         if(seed == 0) {
    77             gsl_rng_set(myRNG->gsl, p_psRandomGetSystemSeed(true));
    78         } else {
    79             gsl_rng_set(myRNG->gsl, seed);
    80         }
    81         myRNG->type = type;
     99      case PS_RANDOM_TAUS:
     100        gslType = gsl_rng_taus;
    82101        break;
    83 
    84     default:
    85         psError(PS_ERR_UNEXPECTED_NULL, true, _("Unknown Random Number Generator Type"));
     102      default:
     103        psAbort("Unknown Random Number Generator Type: %x", type);
    86104        break;
    87105    }
    88106
    89     return(myRNG);
     107    rng->gsl = gsl_rng_alloc(gslType);
     108    return rng;
    90109}
    91110
    92 void psRandomReset(psRandom *rand,
    93                    unsigned long seed)
     111psRandom *psRandomAlloc(psRandomType type)
    94112{
    95     // Check null psRandom
    96     if(rand==NULL) {
    97         psError(PS_ERR_UNEXPECTED_NULL,
    98                 true,
    99                 _("Random variable is NULL."));
    100     } else {
    101         // Check seed value to see if system seed should be used
    102         if(seed == 0) {
    103             gsl_rng_set(rand->gsl,p_psRandomGetSystemSeed(true));
    104         } else {
    105             gsl_rng_set(rand->gsl, seed);
    106         }
     113    psRandom *rng = randomAlloc(type);
     114    psRandomReset(rng);
     115
     116    return rng;
     117}
     118
     119psRandom *psRandomAllocSpecific(psRandomType type, psU64 specificSeed)
     120{
     121    psRandom *rng = randomAlloc(type);
     122    if (specificSeed == 0) {
     123        specificSeed = p_psRandomGetSystemSeed(true);
    107124    }
     125    gsl_rng_set(rng->gsl, specificSeed);
     126    return rng;
     127}
     128
     129bool psRandomReset(psRandom *rand)
     130{
     131    PS_ASSERT_RANDOM_NON_NULL(rand, false);
     132    if (seed == 0) {
     133        seed = p_psRandomGetSystemSeed(true);
     134    }
     135    gsl_rng_set(rand->gsl, seed);
     136    return true;
    108137}
    109138
    110139double psRandomUniform(const psRandom *r)
    111140{
    112     // Check null psRandom variable
    113     if(r == NULL) {
    114         psError(PS_ERR_UNEXPECTED_NULL,
    115                 true,
    116                 _("Random variable is NULL."));
    117         return(0);
    118     } else {
    119         return(gsl_rng_uniform(r->gsl));
    120     }
     141    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
     142    return gsl_rng_uniform(r->gsl);
    121143}
    122144
    123145double psRandomGaussian(const psRandom *r)
    124146{
    125     // Check null psRandom variable
    126     if(r == NULL) {
    127         psError(PS_ERR_UNEXPECTED_NULL,
    128                 true,
    129                 _("Random variable is NULL."));
    130         return(0);
    131     } else {
    132         // XXX: What should sigma be?
    133         return(gsl_ran_gaussian(r->gsl, 1.0));
    134     }
     147    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
     148    return gsl_ran_gaussian(r->gsl, 1.0);
    135149}
    136150
    137151double p_psRandomGaussian(const psRandom *r, double sigma)
    138152{
    139     // Check null psRandom variable
    140     if(r == NULL) {
    141         psError(PS_ERR_UNEXPECTED_NULL,
    142                 true,
    143                 _("Random variable is NULL."));
    144         return(0);
    145     } else {
    146         return(gsl_ran_gaussian(r->gsl, sigma));
    147     }
     153    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
     154    return gsl_ran_gaussian(r->gsl, sigma);
    148155}
    149156
    150157double psRandomPoisson(const psRandom *r, double mean)
    151158{
    152     // Check null psRandom variable
    153     if(r == NULL) {
    154         psError(PS_ERR_UNEXPECTED_NULL,
    155                 true,
    156                 _("Random variable is NULL."));
    157         return(0);
    158     } else {
    159         return((psF64) gsl_ran_poisson(r->gsl, mean));
    160     }
     159    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
     160    return gsl_ran_poisson(r->gsl, mean);
    161161}
    162162

  • trunk/psLib/src/math/psRandom.h

    r15627 r23259  
    2929#include <gsl/gsl_randist.h>
    3030
    31 /** Enumeration containing a flag for psRandom types.  */
     31/// Random number generator types
    3232typedef enum {
    3333    PS_RANDOM_TAUS                     ///< A maximally equidistributed combined Tausworthe generator.
    3434} psRandomType;
    3535
    36 /** Data structure for psRandom.
    37  *  Contains information on the psRandom type and GNU Scientific Library random number generator.
    38  */
     36/// Random number generator
    3937typedef struct {
    4038    psRandomType type;                 ///< The type of RNG
    … …  
    4846    );
    4947
    50 /** Allocates a psRandom struct.
    51  *
    52  *  @return psRandom*:    A new psRandom structure.
    53  */
     48/// Set the seed to use for random number generators.
     49///
     50/// A seed value of zero indicates that the seed is to be generated from the system.
     51/// The new seed value is returned
     52psU64 psRandomSeed(psU64 seed           ///< Seed for RNG
     53                   );
     54
     55/// Allocate a random number generator
     56///
     57/// The currently defined seed (via psRandomSeed) is used
    5458psRandom *psRandomAlloc(
    55     psRandomType type,                 ///< The type of RNG
    56     unsigned long seed                 ///< Known value with which to seed the RNG
     59    psRandomType type                   ///< The type of RNG
    5760) PS_ATTR_MALLOC;
    5861
    59 /** Resets an existing psRandom struct.
    60  *
    61  *  @return void
    62  */
    63 void psRandomReset(
    64     psRandom *rand,                    ///< Existing psRandom struct to reset
    65     unsigned long seed                 ///< Known value with which to seed the RNG
     62/// Allocate a random number generator with a specific seed
     63///
     64/// A seed value of zero indicates that the seed is to be generated from the system.
     65psRandom *psRandomAllocSpecific(psRandomType type, ///< The type of RNG
     66                                psU64 specificSeed ///< The specific seed to use
     67    );
     68
     69/// Resets an existing random number generator
     70bool psRandomReset(
     71    psRandom *rand                      ///< Random number generator to reset
    6672);
    6773
    … …  
    7278 */
    7379double psRandomUniform(
    74     const psRandom *r                  ///< psRandom struct for RNG
     80    const psRandom *r                  ///< Random number generator
    7581);
    7682
    … …  
    8187 */
    8288double psRandomGaussian(
    83     const psRandom *r                  ///< psRandom struct for RNG
     89    const psRandom *r                  ///< Random number generator
    8490);
    8591
    86 /** Random number generator based on a Gaussian deviate, N(0,1).
     92/** Random number generator based on a Gaussian deviate with specified standard deviation.
    8793 *  Uses gsl_ran_gaussian.
    88  *
    89  *  XXX: I created this since the above psLib spec for p_psRandomGaussian
    90  *  had no argument for sigma.  Verify that with IfA.
    9194 *
    9295 *  @return double:     Random number.
    9396 */
    9497double p_psRandomGaussian(
    95     const psRandom *r,                  ///< psRandom struct for RNG
     98    const psRandom *r,                  ///< Random number generator
    9699    double sigma
    97100);
    … …  
    103106 */
    104107double psRandomPoisson(
    105     const psRandom *r,                 ///< psRandom struct for RNG
     108    const psRandom *r,                  ///< Random number generator
    106109    double mean                         ///< Mean value
    107110);

  • trunk/psLib/test/fits/tap_psFitsImage.c

    r19382 r23259  
    1212static psImage *generateImage(void)
    1313{
    14     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345); // Random number generator
     14    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345); // Random number generator
    1515    psImage *image = psImageAlloc(NUMCOLS, NUMROWS, PS_TYPE_F32); // Generated image
    1616    for (int y = 0; y < NUMROWS; y++) {

  • trunk/psLib/test/imageops/convolutionBench.c

    r17320 r23259  
    6868int main(int argc, char *argv[])
    6969{
    70     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     70    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0); // Random number generator
    7171
    7272    printf("#%14s%16s        %8s        %8s\n", "Image", "Kernel", "Direct", "FFT");

  • trunk/psLib/test/imageops/tap_psImageInterpolate2.c

    r21465 r23259  
    7777    psImage *variance = NULL; // generateVariance(xSize, ySize, type);
    7878    psImage *mask = NULL; // generateMask(xSize, ySize);
    79     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);
     79    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);
    8080
    8181    psImageInterpolation *interp = psImageInterpolationAlloc(mode, image, variance, mask, 0, NAN, NAN,

  • trunk/psLib/test/math/tap_psMinimizeLMM.c

    r13124 r23259  
    9595    {
    9696        psMemId id = psMemGetId();
    97         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     97        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
    9898        psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
    9999        psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);
    … …  
    203203    {
    204204        psMemId id = psMemGetId();
    205         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     205        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
    206206        psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
    207207        psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);

  • trunk/psLib/test/math/tap_psPolyFit1D.c

    r13337 r23259  
    109109    psVector *xTruth = psVectorAlloc(numData, PS_TYPE_F64);
    110110    psVector *fTruth = psVectorAlloc(numData, PS_TYPE_F64);
    111     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using a known seed
     111    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using a known seed
    112112    for (int i = 0; i < numData; i++) {
    113113        xTruth->data.F64[i] = (flags & TS00_X_NULL) ? i : 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tap_psPolyFit2D.c

    r17567 r23259  
    108108    yTruth->n = numData;
    109109    fTruth->n = numData;
    110     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
     110    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
    111111    for (int i = 0; i < numData; i++) {
    112112        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tap_psPolyFit3D.c

    r17567 r23259  
    108108    zTruth->n = numData;
    109109    fTruth->n = numData;
    110     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
     110    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
    111111    for (int i = 0; i < numData; i++) {
    112112        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tap_psPolyFit4D.c

    r17567 r23259  
    132132    tTruth->n = numData;
    133133    fTruth->n = numData;
    134     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
     134    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
    135135    for (int i = 0; i < numData; i++) {
    136136        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tap_psRandom.c

    r13123 r23259  
    33work properly.
    44 
    5     ensure that psRandom structs are properly allocated by psRandomAlloc().
     5    ensure that psRandom structs are properly allocated by psRandomAllocSpecific().
    66    ensure that psRandomUniform() produces a sequence of numbers with
    77        proper mean and stdev.
    … …  
    4747    plan_tests(34);
    4848
    49     // ensure that psRandom structs are properly allocated by psRandomAlloc()
     49    // ensure that psRandom structs are properly allocated by psRandomAllocSpecific()
    5050    {
    5151        psMemId id = psMemGetId();
    5252        // Valid type allocation
    53         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    54         ok(myRNG != NULL, "psRandom struct was allocated properly");
    55         skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
    56         ok(myRNG->type == PS_RANDOM_TAUS, "psRandomAlloc() set type properly");
     53        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     54        ok(myRNG != NULL, "psRandom struct was allocated properly");
     55        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
     56        ok(myRNG->type == PS_RANDOM_TAUS, "psRandomAllocSpecific() set type properly");
    5757        psFree(myRNG);
    5858        skip_end();
    … …  
    6363    {
    6464        psMemId id = psMemGetId();
    65         psRandom *myRNG = psRandomAlloc(100,SEED);
    66         ok(myRNG == NULL, "psRandomAlloc() refused to generate psRandom with unallowed type");
     65        psRandom *myRNG = psRandomAllocSpecific(100,SEED);
     66        ok(myRNG == NULL, "psRandomAllocSpecific() refused to generate psRandom with unallowed type");
    6767        psFree(myRNG);
    6868        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    7272    {
    7373        psMemId id = psMemGetId();
    74         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS,-5);
    75         ok(myRNG != NULL, "psRandomAlloc() allows negative seed");
     74        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS,-5);
     75        ok(myRNG != NULL, "psRandomAllocSpecific() allows negative seed");
    7676        psFree(myRNG);
    7777        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    8585        rans->n = rans->nalloc;
    8686        psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    87         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    88         ok(myRNG != NULL, "psRandom struct was allocated properly");
    89         skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
     87        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     88        ok(myRNG != NULL, "psRandom struct was allocated properly");
     89        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
    9090
    9191        // Initialize vector data with random number
    … …  
    125125        rans->n = rans->nalloc;
    126126        psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    127         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    128         ok(myRNG != NULL, "psRandom struct was allocated properly");
    129         skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
     127        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     128        ok(myRNG != NULL, "psRandom struct was allocated properly");
     129        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
    130130
    131131        // Initialize vector with random data
    … …  
    167167        rans->n = rans->nalloc;
    168168        psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    169         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    170         ok(myRNG != NULL, "psRandom struct was allocated properly");
    171         skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
     169        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     170        ok(myRNG != NULL, "psRandom struct was allocated properly");
     171        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
    172172
    173173        // Initialize vector with random data
    … …  
    210210        rans02->n = rans02->nalloc;
    211211
    212         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    213         ok(myRNG != NULL, "psRandom struct was allocated properly");
    214         skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
     212        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     213        ok(myRNG != NULL, "psRandom struct was allocated properly");
     214        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
    215215
    216216
    … …  
    252252    if (0) {
    253253        psRandom *myRNG1 = NULL;
    254         myRNG1 = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     254        myRNG1 = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    255255        //    psLogSetDestination("dest:stderr");
    256256        psLogSetDestination(0);
    … …  
    275275        rans02->n = rans02->nalloc;
    276276
    277         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    278         ok(myRNG != NULL, "psRandom struct was allocated properly");
    279         skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
     277        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     278        ok(myRNG != NULL, "psRandom struct was allocated properly");
     279        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
    280280
    281281
    … …  
    325325        rans02->n = rans02->nalloc;
    326326
    327         psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    328         ok(myRNG != NULL, "psRandom struct was allocated properly");
    329         skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
     327        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     328        ok(myRNG != NULL, "psRandom struct was allocated properly");
     329        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
    330330
    331331        // Initialize vectors with random data

  • trunk/psLib/test/math/tap_psStats07.c

    r12247 r23259  
    5858    PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
    5959
    60     //    psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, p_psRandomGetSystemSeed());
    61     psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, PS_XXX_GAUSSIAN_SEED);
     60    //    psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, p_psRandomGetSystemSeed());
     61    psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, PS_XXX_GAUSSIAN_SEED);
    6262    psVector* gauss = psVectorAlloc(Npts, PS_TYPE_F32);
    6363    for (unsigned int i = 0; i < Npts; i++) {

  • trunk/psLib/test/math/tap_psStats09.c

    r12783 r23259  
    5252    srand(SEED);
    5353
    54     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     54    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
    5555    psVector *truth = psVectorAlloc(numData, PS_TYPE_F64);
    5656    for (long i = 0; i < numData; i++) {

  • trunk/psLib/test/math/tap_psStatsTiming.c

    r12513 r23259  
    2020
    2121    // build a gauss-deviate vector (mean = 0.0, sigma = 1.0) for tests
    22     psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
     22    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
    2323    psVector *rnd = psVectorAlloc (1000, PS_TYPE_F32);
    2424    for (int i = 0; i < rnd->n; i++) {

  • trunk/psLib/test/math/tst_psMinimizeLMM.c

    r11686 r23259  
    6666    psBool testStatus = true;
    6767
    68     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     68    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
    6969    psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
    7070    psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);

  • trunk/psLib/test/math/tst_psPolyFit1D.c

    r11686 r23259  
    101101    xTruth->n = numData;
    102102    fTruth->n = numData;
    103     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using a known seed
     103    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using a known seed
    104104    for (int i = 0; i < numData; i++) {
    105105        xTruth->data.F64[i] = (flags & TS00_X_NULL) ? i : 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tst_psPolyFit2D.c

    r11686 r23259  
    100100    yTruth->n = numData;
    101101    fTruth->n = numData;
    102     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
     102    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
    103103    for (int i = 0; i < numData; i++) {
    104104        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tst_psPolyFit3D.c

    r11686 r23259  
    103103    zTruth->n = numData;
    104104    fTruth->n = numData;
    105     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
     105    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
    106106    for (int i = 0; i < numData; i++) {
    107107        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tst_psPolyFit4D.c

    r11686 r23259  
    124124    tTruth->n = numData;
    125125    fTruth->n = numData;
    126     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
     126    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
    127127    for (int i = 0; i < numData; i++) {
    128128        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;

  • trunk/psLib/test/math/tst_psRandom.c

    r6484 r23259  
    33work properly.
    44 
    5     t00(): ensure that psRandom structs are properly allocated by psRandomAlloc().
     5    t00(): ensure that psRandom structs are properly allocated by psRandomAllocSpecific().
    66    t01(): ensure that psRandomUniform() produces a sequence of numbers with
    77    proper mean and stdev.
    … …  
    4545
    4646testDescription tests[] = {
    47                               {testRandomAlloc,000,"psRandomAlloc",0,false},
     47                              {testRandomAlloc,000,"psRandomAllocSpecific",0,false},
    4848                              {testRandomUniform,000,"psRandomUniform",0,false},
    4949                              {testRandomGaussian,000,"psRandomGaussian",0,false},
    … …  
    7070
    7171    // Valid type allocation
    72     myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     72    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    7373    if (myRNG == NULL) {
    7474        psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
    … …  
    8585    //    psLogSetDestination("file:seed_msglog1.txt");
    8686    psLogSetDestination(fd1);
    87     myRNG = psRandomAlloc(PS_RANDOM_TAUS, 0);
     87    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    8888    //    psLogSetDestination("dest:stderr");
    8989    psLogSetDestination(2);
    … …  
    100100    // Invalid type allocation
    101101    psLogMsg(__func__,PS_LOG_INFO,"Invalid type, should generate error message");
    102     myRNG = psRandomAlloc(100,SEED);
     102    myRNG = psRandomAllocSpecific(100,SEED);
    103103    if (myRNG != NULL) {
    104104        psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type");
    … …  
    107107
    108108    // Negative seed value
    109     myRNG = psRandomAlloc(PS_RANDOM_TAUS,-5);
     109    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS,-5);
    110110    if(myRNG == NULL) {
    111111        psError(PS_ERR_UNKNOWN,true,"Did not return allocated psRandom");
    … …  
    125125    psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    126126
    127     myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     127    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    128128    if (myRNG == NULL) {
    129129        psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
    … …  
    171171    psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    172172
    173     myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     173    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    174174    if (myRNG == NULL) {
    175175        psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
    … …  
    219219    psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    220220
    221     myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     221    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    222222    if (myRNG == NULL) {
    223223        psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
    … …  
    268268    rans02->n = rans02->nalloc;
    269269
    270     myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     270    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    271271    if (myRNG == NULL) {
    272272        psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
    … …  
    302302
    303303    psRandom *myRNG1 = NULL;
    304     myRNG1 = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     304    myRNG1 = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    305305    //    psLogSetDestination("dest:stderr");
    306306    psLogSetDestination(0);
    … …  
    326326    rans02->n = rans02->nalloc;
    327327
    328     myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     328    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    329329    if (myRNG == NULL) {
    330330        psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
    … …  
    372372    rans02->n = rans02->nalloc;
    373373
    374     myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
     374    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
    375375    if (myRNG == NULL) {
    376376        psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");

  • trunk/psLib/test/math/tst_psStats09.c

    r11686 r23259  
    5252    printPositiveTestHeader(stdout, "psMathUtils functions", "psVectorStats Clipped Stats Routine");
    5353
    54     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     54    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
    5555    psVector *truth = psVectorAlloc(numData, PS_TYPE_F64);
    5656    truth->n = numData;

  • trunk/psLib/test/mathtypes/tap_psVectorSelect.c

    r18333 r23259  
    1717    psVector *vector = psVectorAlloc(size, PS_TYPE_F32);
    1818    psVectorInit(vector, 0.0);
    19     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);
     19    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);
    2020    for (long i = 0; i < numNonzero; i++) {
    2121        long index = psRandomUniform(rng) * size;
    … …  
    5252    psVector *vector = psVectorAlloc(size, PS_TYPE_F32);
    5353    psVectorInit(vector, 0.0);
    54     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);
     54    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);
    5555    for (long i = 0; i < numNonzero; i++) {
    5656        long index = psRandomUniform(rng) * size;

  • trunk/psLib/test/types/tap_psTree.c

    r18145 r23259  
    1616        psVector *y = psVectorAlloc(NUM, PS_TYPE_F64);
    1717
    18         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     18        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    1919        for (int i = 0; i < NUM; i++) {
    2020            x->data.F64[i] = 2.0 * psRandomUniform(rng) - 1.0;

  • trunk/psModules/src/camera/pmFPAMaskWeight.c

    r21363 r23259  
    331331
    332332    if (!psMemIncrRefCounter(rng)) {
    333         rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     333        rng = psRandomAlloc(PS_RANDOM_TAUS);
    334334    }
    335335
    … …  
    371371
    372372    if (!psMemIncrRefCounter(rng)) {
    373         rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     373        rng = psRandomAlloc(PS_RANDOM_TAUS);
    374374    }
    375375
    … …  
    532532
    533533    if (!psMemIncrRefCounter(rng)) {
    534         rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     534        rng = psRandomAlloc(PS_RANDOM_TAUS);
    535535    }
    536536

  • trunk/psModules/src/camera/pmFPA_JPEG.c

    r21183 r23259  
    154154
    155155    // measure the image statistics for scaling
    156     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     156    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    157157    psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
    158158    stats->nSubsample = 10000;

  • trunk/psModules/src/config/pmConfig.c

    r23215 r23259  
    1313
    1414#include <stdio.h>
     15#include <stdlib.h>
    1516#include <string.h>
    1617#include <strings.h>            /* for strn?casecmp */
    … …  
    2425#include <pslib.h>
    2526
    26 #include "pmConfig.h"
    2727#include "pmErrorCodes.h"
    2828#include "pmFPALevel.h"
    2929#include "pmConfigRecipes.h"
    3030#include "pmConfigCamera.h"
     31#include "pmConfigRun.h"
     32
     33#include "pmConfig.h"
    3134
    3235#ifdef HAVE_NEBCLIENT
    … …  
    432435    // variable will contain the name of the configuration file.
    433436
    434     char *configFile = NULL;
    435     //
     437    char *configFile = NULL;            // Name of configuration file
     438
    436439    // First, try command line
    437     //
    438440    psS32 argNum = psArgumentGet(*argc, argv, "-ipprc");
    439441    if (argNum != 0) {
    … …  
    447449        }
    448450    }
    449     //
     451
    450452    // Next, try environment variable
    451     //
    452453    if (!configFile) {
    453454        configFile = getenv(IPPRC_ENV);
    454455        if (configFile) {
    455             configFile = psStringCopy (configFile);
    456         }
    457     }
    458 
    459     //
     456            configFile = psStringCopy(configFile);
     457        }
     458    }
     459
    460460    // Last chance is ~/.ipprc
    461     //
    462461    if (!configFile) {
    463462        char *home = getenv("HOME");
    … …  
    466465    }
    467466
    468     // We have the configuration filename; now we read and parse the config
    469     // file and store in psMetadata struct user.
     467    // Read and parse the config file and store in struct user.
    470468    // XXX move this section to pmConfigReadUser.c ?
    471 
    472469    if (!pmConfigFileRead(&config->user, configFile, "user")) {
    473470        psFree(config);
    … …  
    477474    psFree(configFile);
    478475
    479     // XXX why was this being called here?  Is someone calling pmConfigRead multiple times?
    480     // pmConfigDone();
    481     assert (configPath == NULL);
     476    pmConfigRunCommand(config, *argc, argv);
    482477
    483478    // define the config-file search path (configPath).
     479    psAssert(configPath == NULL, "Configuration path is already defined.");
    484480    psString path = psMetadataLookupStr(NULL, config->user, "PATH");
    485     pmConfigSet (path);
     481    pmConfigSet(path);
    486482
    487483    // read the SITE file
    … …  
    525521            psLogSetLevel(logLevel);
    526522        }
    527 
    528523
    529524        // Set logging format
    … …  
    646641            psTimeInit(timeName);
    647642        }
     643    }
     644
     645    // Set the random number generator seed
     646    {
     647        psU64 seed = 0;                 // RNG seed
     648        int argNum = psArgumentGet(*argc, argv, "-seed"); // Argument number
     649        if (argNum > 0) {
     650            psArgumentRemove(argNum, argc, argv);
     651            if (argNum >= *argc) {
     652                psWarning("-seed command-line switch provided without the required seed value --- ignored.");
     653            } else {
     654                char *end = NULL;       // Pointer to end of consumed string
     655                seed = strtoll(argv[argNum], &end, 0);
     656                if (strlen(end) > 0) {
     657                    psError(PS_ERR_IO, true, "Unable to read random number generator seed: %s", argv[argNum]);
     658                    psFree(config);
     659                    return NULL;
     660                }
     661                psArgumentRemove(argNum, argc, argv);
     662            }
     663        }
     664        pmConfigRunSeed(config, seed);
    648665    }
    649666

  • trunk/psModules/src/config/pmConfigCamera.c

    r22700 r23259  
    213213    psStringAppend(&newName, "_%s-SKYCELL", name);
    214214    if (psMetadataLookup(oldCameras, newName)) {
     215        psFree(newName);
    215216        return true;
    216217    }
    … …  
    469470    psStringAppend(&newName, "_%s-%s", name, mosaicLevel == PM_FPA_LEVEL_CHIP ? "CHIP" : "FPA");
    470471    if (psMetadataLookup(oldCameras, newName)) {
     472        psFree(newName);
    471473        return true;
    472474    }

  • trunk/psModules/src/config/pmConfigRecipes.h

    r12916 r23259  
    11/*  @file pmConfigRecipes.h
    22 *  @brief Configuration Recipe functions
    3  * 
     3 *
    44 *  @author ?, MHPCC
    55 *  @author Paul Price, IfA
    66 *  @author Eugene Magnier, IfA
    7  * 
     7 *
    88 *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    99 *  @date $Date: 2007-04-19 02:10:12 $
    … …  
    1313#ifndef PM_CONFIG_RECIPES_H
    1414#define PM_CONFIG_RECIPES_H
     15
     16#include <pmConfig.h>
    1517
    1618/// @addtogroup Config Configuration System
    … …  
    2628
    2729
    28 bool pmConfigLoadRecipeArguments (int *argc, char **argv, pmConfig *config);
    29 bool pmConfigLoadRecipeOptions (int *argc, char **argv, pmConfig *config, char *flag);
    30 psMetadata *pmConfigRecipeOptions (pmConfig *config, char *recipe);
     30bool pmConfigLoadRecipeArguments(int *argc, char **argv, pmConfig *config);
     31bool pmConfigLoadRecipeOptions(int *argc, char **argv, pmConfig *config, char *flag);
     32psMetadata *pmConfigRecipeOptions(pmConfig *config, char *recipe);
    3133
    3234/// @}

  • trunk/psModules/src/config/pmConfigRun.c

    r23244 r23259  
    7272
    7373
    74 bool pmConfigRunCommand(pmConfig *config, int argc, const char **argv)
     74bool pmConfigRunCommand(pmConfig *config, int argc, char **argv)
    7575{
    7676    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    8181    psString command = NULL;
    8282    for (int i = 0; i < argc; i++) {
    83         psStringAppend(&command, "%s", argv[i]);
     83        psStringAppend(&command, "%s ", argv[i]);
    8484    }
    8585
    … …  
    8989    return true;
    9090}
     91
     92
     93bool pmConfigRunSeed(pmConfig *config, psU64 seed)
     94{
     95    PS_ASSERT_PTR_NON_NULL(config, false);
     96
     97    psMetadata *run = configRun(config);// Run-time information
     98    psAssert(run, "Require run-time information");
     99
     100    if (!seed) {
     101        bool mdok;                          // Status of MD lookup
     102        seed = psMetadataLookupU64(&mdok, run, "SEED");
     103    }
     104    if (!seed) {
     105        bool mdok;                          // Status of MD lookup
     106        seed = psMetadataLookupU64(&mdok, config->user, "SEED");
     107    }
     108
     109    // seed may still be zero by this point
     110    seed = psRandomSeed(seed);
     111    return psMetadataAddU64(run, PS_LIST_TAIL, "SEED", PS_META_REPLACE, "Random number generator seed", seed);
     112}
     113

  • trunk/psModules/src/config/pmConfigRun.h

    r23243 r23259  
    44#include <pslib.h>
    55#include <pmConfig.h>
     6#include <pmFPAfile.h>
    67
    78/// Add a file to the list of files used in the run-time information
    … …  
    1213
    1314/// Add the command line to the run-time information
    14 bool pmConfigRunCommand(pmConfig *config, ///< Configuration
    15                         int argc, const char **argv ///< Command line arguments
     15bool pmConfigRunCommand(
     16    pmConfig *config,                   ///< Configuration
     17    int argc, char **argv               ///< Command line arguments
     18    );
     19
     20/// Record the random number generator seed in the run-time information
     21bool pmConfigRunSeed(
     22    pmConfig *config,                   ///< Configuration
     23    psU64 seed                          ///< RNG seed
    1624    );
    1725

  • trunk/psModules/src/detrend/pmFringeStats.c

    r21183 r23259  
    6565        rng = psMemIncrRefCounter(random);
    6666    } else {
    67         rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     67        rng = psRandomAlloc(PS_RANDOM_TAUS);
    6868    }
    6969

  • trunk/psModules/src/detrend/pmRemnance.c

    r21183 r23259  
    2828    int numCols = image->numCols, numRows = image->numRows; // Size of image
    2929
    30     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     30    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
    3131
    3232    psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV); // Statistics

  • trunk/psModules/src/detrend/pmShutterCorrection.c

    r21457 r23259  
    911911    psStats *stats = psStatsAlloc(meanStat | stdevStat); // Statistics to apply
    912912    if (!rng) {
    913         rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     913        rng = psRandomAlloc(PS_RANDOM_TAUS);
    914914    } else {
    915915        psMemIncrRefCounter(rng);

  • trunk/psModules/src/imcombine/pmSubtractionMatch.c

    r21422 r23259  
    214214    int numCols = ro1->image->numCols, numRows = ro1->image->numRows; // Image dimensions
    215215
    216     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
     216    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
    217217
    218218    memCheck("start");

  • trunk/psModules/test/detrend/tap_pmMaskBadPixels.c

    r15160 r23259  
    282282        pmCell *cell = generateSimpleCell(NULL);
    283283        pmReadout *in = generateSimpleReadout(cell);
    284         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     284        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    285285
    286286        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with NULL input pmReadout");
    … …  
    301301        psFree(in->image);
    302302        in->image = NULL;
    303         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     303        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    304304        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with NULL input pmReadout->image");
    305305        psFree(rng);
    … …  
    319319        psFree(in->image);
    320320        in->image = psImageAlloc(0, 0, PS_TYPE_F32);
    321         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     321        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    322322        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with empty input pmReadout->image");
    323323        psFree(rng);
    … …  
    337337        psFree(in->image);
    338338        in->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_S32);
    339         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     339        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    340340        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect type for pmReadout->image");
    341341        psFree(rng);
    … …  
    355355        psFree(in->mask);
    356356        in->mask = psImageAlloc(0, 0, PS_TYPE_MASK);
    357         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     357        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    358358        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect type for pmReadout->image");
    359359        psFree(rng);
    … …  
    373373        psFree(in->mask);
    374374        in->mask = psImageAlloc(TEST_NUM_COLS/2, TEST_NUM_ROWS/2, PS_TYPE_MASK);
    375         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     375        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    376376        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with bad size for in->mask");
    377377        psFree(rng);
    … …  
    391391        psFree(in->mask);
    392392        in->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_S32);
    393         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     393        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    394394        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with bad type for in->mask");
    395395        psFree(rng);
    … …  
    407407        pmCell *cell = generateSimpleCell(NULL);
    408408        pmReadout *in = generateSimpleReadout(cell);
    409         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     409        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    410410        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with empty out image");
    411411        psFree(rng);
    … …  
    423423        pmCell *cell = generateSimpleCell(NULL);
    424424        pmReadout *in = generateSimpleReadout(cell);
    425         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     425        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    426426        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect type for out image");
    427427        psFree(rng);
    … …  
    439439        pmCell *cell = generateSimpleCell(NULL);
    440440        pmReadout *in = generateSimpleReadout(cell);
    441         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     441        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    442442        ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect size for out image");
    443443        psFree(rng);
    … …  
    455455        pmCell *cell = generateSimpleCell(NULL);
    456456        pmReadout *in = generateSimpleReadout(cell);
    457         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     457        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    458458
    459459        ok(!pmMaskFlagSuspectPixels(out, in, 0.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with rej input <= 0.0");
    … …  
    472472        pmCell *cell = generateSimpleCell(NULL);
    473473        pmReadout *in = generateSimpleReadout(cell);
    474         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     474        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
    475475
    476476        ok(!pmMaskFlagSuspectPixels(out, in, 1.0, 1, -1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with frac input < 0.0");

  • trunk/psModules/test/imcombine/tap_pmImageCombine.c

    r11118 r23259  
    99psArray *generate_images(void)
    1010{
    11     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);   // Random Number Generator
     11    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);   // Random Number Generator
    1212
    1313    // Generate images

  • trunk/psModules/test/objects/tap_pmFringe.c

    r15726 r23259  
    8989        ok(fringe != NULL, "pmFringeRegionsAlloc() returned non-NULL");
    9090        psImage *img = psImageAlloc(NUM_COLS, NUM_ROWS, PS_TYPE_F32);
    91         psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 10);
     91        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 10);
    9292        fringe->x = psVectorAlloc(NUM_FRINGE_PNTS/2, PS_TYPE_F32);
    9393        fringe->y = psVectorAlloc(NUM_FRINGE_PNTS/2, PS_TYPE_F32);

  • trunk/psModules/test/objects/tap_pmSourceFitModel.c

    r14654 r23259  
    2727
    2828    // build a gauss-deviate vector (mean = 0.0, sigma = 1.0)
    29     psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
     29    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
    3030
    3131    static float radius[] = {3.0, 5.0, 7.0, 10.0, 15.0, 25.0};

  • trunk/psModules/test/objects/tap_pmSourceFitModel_Delta.c

    r14654 r23259  
    2323
    2424    // build a gauss-deviate vector (mean = 0.0, sigma = 1.0)
    25     psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
     25    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
    2626
    2727    // noise vector to noise up the image
    … …  
    167167
    168168    // build a gauss-deviate vector (mean = 0.0, sigma = 1.0)
    169     psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
     169    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
    170170
    171171    static float radius[] = {3.0, 5.0, 7.0, 10.0, 15.0, 25.0};

  • trunk/psphot/src/psphotModelBackground.c

    r21183 r23259  
    4949    assert (maskVal);
    5050
    51     // user supplied seed, if available
    52     unsigned long seed = psMetadataLookupS32 (&status, recipe, "IMSTATS_SEED");
    53     if (!status) {
    54         seed = 0;
    55     }
    56     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
     51    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    5752
    5853    // subtract this amount extra from the sky

  • trunk/psphot/src/psphotVisual.c

    r23242 r23259  
    3232
    3333    psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV);
    34     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     34    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    3535    if (!psImageBackground(stats, NULL, inImage, NULL, 0, rng)) {
    3636        fprintf (stderr, "failed to get background values\n");
    … …  
    7878
    7979    psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV);
    80     psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     80    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    8181    if (!psImageBackground(stats, NULL, inImage, NULL, 0, rng)) {
    8282        fprintf (stderr, "failed to get background values\n");

  • trunk/pstest/src/tst_psPolynomial.c

    r5873 r23259  
    289289            fillVectors(x, f, NORD, NPTS, type[k]);
    290290            psTime *now = psTimeGetNow(PS_TIME_UTC);
    291             const psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, now->sec);
     291            const psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, now->sec);
    292292            for (int i = 0; i < NPTS; i++) {
    293293                double errgen = psRandomGaussian(r);
    … …  
    361361            // add random errors to the vector
    362362            psTime *now = psTimeGetNow(PS_TIME_UTC);
    363             const psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, now->sec);
     363            const psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, now->sec);
    364364            for (int i = 0; i < NPTS; i++) {
    365365                double errgen = psRandomGaussian(r);
    … …  
    464464            fillVectors(x, f, NORD, NPTS, type[k]);
    465465            psTime *now = psTimeGetNow(PS_TIME_UTC);
    466             const psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, now->sec);
     466            const psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, now->sec);
    467467            for (int i = 0; i < NPTS; i++) {
    468468                double errgen = psRandomGaussian(r);
Note: See TracChangeset for help on using the changeset viewer.