Index: /trunk/archive/conv_variance/fake.c
===================================================================
--- /trunk/archive/conv_variance/fake.c	(revision 23258)
+++ /trunk/archive/conv_variance/fake.c	(revision 23259)
@@ -47,5 +47,5 @@
     psFree(weight);
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
 
     psImage *bright = psImageAlloc(IMAGE_SIZE, IMAGE_SIZE, PS_TYPE_F32);
Index: /trunk/archive/conv_variance/phot.c
===================================================================
--- /trunk/archive/conv_variance/phot.c	(revision 23258)
+++ /trunk/archive/conv_variance/phot.c	(revision 23259)
@@ -52,5 +52,5 @@
 
     psStats *bgStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
     psImageBackground(bgStats, NULL, image, mask, maskVal, rng);
     double bg = bgStats->robustMedian;
Index: /trunk/ippTools/src/dettool.c
===================================================================
--- /trunk/ippTools/src/dettool.c	(revision 23258)
+++ /trunk/ippTools/src/dettool.c	(revision 23259)
@@ -578,5 +578,5 @@
       // generate a random-valued vector, return an index sorted by the random values
       psVector *randomVector = psVectorAlloc(detrendExps->n, PS_TYPE_F32); // random values
-      psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+      psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
       for (int i = 0; i < randomVector->n; i++) {
         randomVector->data.F32[i] = psRandomUniform(rng);
Index: /trunk/ppImage/src/ppImageLoop.c
===================================================================
--- /trunk/ppImage/src/ppImageLoop.c	(revision 23258)
+++ /trunk/ppImage/src/ppImageLoop.c	(revision 23259)
@@ -25,11 +25,6 @@
     }
 
-    psString dump_file = psMetadataLookupStr(&status, config->arguments, "DUMP_CONFIG");
-    if (dump_file) {
-        pmConfigCamerasCull(config, NULL);
-        pmConfigRecipesCull(config, "PPIMAGE,PPSTATS,PSPHOT,MASKS,PSASTRO,JPEG");
-
-        pmConfigDump(config, input->fpa, dump_file);
-    }
+    pmConfigCamerasCull(config, NULL);
+    pmConfigRecipesCull(config, "PPIMAGE,PPSTATS,PSPHOT,MASKS,PSASTRO,JPEG");
 
     pmFPAview *view = pmFPAviewAlloc(0);// View for level of interest
@@ -220,4 +215,10 @@
     psFree(view);
 
+    // Dump configuration
+    psString dump_file = psMetadataLookupStr(&status, config->arguments, "DUMP_CONFIG");
+    if (dump_file) {
+        pmConfigDump(config, input->fpa, dump_file);
+    }
+
     // Write out summary statistics
     if (options->doStats) {
Index: /trunk/ppMerge/src/ppMergeMask.c
===================================================================
--- /trunk/ppMerge/src/ppMergeMask.c	(revision 23258)
+++ /trunk/ppMerge/src/ppMergeMask.c	(revision 23259)
@@ -369,5 +369,5 @@
 
     pmFPAview *view = pmFPAviewAlloc(0); ///< View to component of interest
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); ///< Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); ///< Random number generator
 
     psMetadata *stats = NULL;           ///< Statistics for output
Index: /trunk/ppMerge/src/ppMergeScaleZero.c
===================================================================
--- /trunk/ppMerge/src/ppMergeScaleZero.c	(revision 23258)
+++ /trunk/ppMerge/src/ppMergeScaleZero.c	(revision 23259)
@@ -51,5 +51,5 @@
         break;
     }
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); ///< Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); ///< Random number generator
     pmFPAview *view = NULL;             ///< View into FPA
 
Index: /trunk/ppSim/src/ppSimBadPixels.c
===================================================================
--- /trunk/ppSim/src/ppSimBadPixels.c	(revision 23258)
+++ /trunk/ppSim/src/ppSimBadPixels.c	(revision 23259)
@@ -74,5 +74,5 @@
     }
 
-    psRandom *pseudoRNG = psRandomAlloc(PS_RANDOM_TAUS, seed); // Pseudo-random number generator
+    psRandom *pseudoRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, seed); // Pseudo-random number generator
 
     psImage *image = readout->image;    // Image of interest
Index: /trunk/ppSim/src/ppSimLoop.c
===================================================================
--- /trunk/ppSim/src/ppSimLoop.c	(revision 23258)
+++ /trunk/ppSim/src/ppSimLoop.c	(revision 23259)
@@ -25,5 +25,5 @@
     psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, PPSIM_RECIPE); // Recipe
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
 
     char *typeStr = psMetadataLookupStr(NULL, recipe, "IMAGE.TYPE"); // Type of image to simulate
Index: /trunk/ppSim/src/ppSimSequence.c
===================================================================
--- /trunk/ppSim/src/ppSimSequence.c	(revision 23258)
+++ /trunk/ppSim/src/ppSimSequence.c	(revision 23259)
@@ -133,12 +133,10 @@
     if (ppsim_recipe) psStringAppend (&ppSimCommand, " -recipe PPSIM %s", ppsim_recipe);
 
-    unsigned long seed = psMetadataLookupS32 (&status, config, "RND_SEED");
-    if (!status) seed = 0;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
 
     psMetadataItem *item = psMetadataLookup (config, "SEQUENCE");
     if (item == NULL) {
         psLogMsg ("ppSimSequence", PS_LOG_WARN, "missing SEQUENCE description");
-        exit (1);
+        exit (PS_EXIT_CONFIG_ERROR);
     }
 
@@ -170,14 +168,14 @@
         }
 
-	// determine the camera for the sequence and define the ppSim command
-	if (camera == NULL) {
-	    camera = psMetadataLookupStr (&status, sequence, "CAMERA");
-	}
-
-	psString injectCommandReal = NULL;
-	psString ppSimCommandReal = NULL;
-
-	psStringAppend (&injectCommandReal, "%s --camera %s", injectCommand, camera);
-	psStringAppend (&ppSimCommandReal, "%s -camera %s", ppSimCommand, camera);
+        // determine the camera for the sequence and define the ppSim command
+        if (camera == NULL) {
+            camera = psMetadataLookupStr (&status, sequence, "CAMERA");
+        }
+
+        psString injectCommandReal = NULL;
+        psString ppSimCommandReal = NULL;
+
+        psStringAppend (&injectCommandReal, "%s --camera %s", injectCommand, camera);
+        psStringAppend (&ppSimCommandReal, "%s -camera %s", ppSimCommand, camera);
 
         if (!strcasecmp (type, "BIAS")) {
Index: /trunk/ppStack/src/ppStackLoop.c
===================================================================
--- /trunk/ppStack/src/ppStackLoop.c	(revision 23258)
+++ /trunk/ppStack/src/ppStackLoop.c	(revision 23259)
@@ -415,5 +415,5 @@
     psArray *subKernels = psArrayAlloc(num); // Subtraction kernels --- required in the stacking
     psArray *subRegions = psArrayAlloc(num); // Subtraction regions --- required in the stacking
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
     int numGood = 0;                    // Number of good frames
     int numCols = 0, numRows = 0;       // Size of image
Index: /trunk/ppStack/src/ppStackPhotometry.c
===================================================================
--- /trunk/ppStack/src/ppStackPhotometry.c	(revision 23258)
+++ /trunk/ppStack/src/ppStackPhotometry.c	(revision 23259)
@@ -50,5 +50,5 @@
 
     // Measure background
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
     psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV); // Statistics
     if (!psImageBackground(stats, NULL, image, mask, maskVal, rng)) {
Index: /trunk/ppSub/src/ppSubVarianceFactors.c
===================================================================
--- /trunk/ppSub/src/ppSubVarianceFactors.c	(revision 23258)
+++ /trunk/ppSub/src/ppSubVarianceFactors.c	(revision 23259)
@@ -65,5 +65,5 @@
 
     psStats *vfStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); // Statistics
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
 
     // mask these values when examining the background
Index: /trunk/ppSub/test/fake.c
===================================================================
--- /trunk/ppSub/test/fake.c	(revision 23258)
+++ /trunk/ppSub/test/fake.c	(revision 23259)
@@ -89,5 +89,5 @@
 int main(int argc, char *argv[])
 {
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
 
     // Images to generate
Index: /trunk/psLib/src/fits/psFitsScale.c
===================================================================
--- /trunk/psLib/src/fits/psFitsScale.c	(revision 23258)
+++ /trunk/psLib/src/fits/psFitsScale.c	(revision 23259)
@@ -112,6 +112,5 @@
     // psImageBackground automatically excludes pixels that are non-finite, so we don't need to bother about a
     // mask.
-    psU64 seed = p_psRandomGetSystemSeed(false);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
     psStats *stats = psStatsAlloc(MEAN_STAT | STDEV_STAT); // Statistics object
     if (!psImageBackground(stats, NULL, image, mask, maskVal, rng)) {
@@ -290,6 +289,5 @@
     if (!psMemIncrRefCounter(rng) && options->fuzz) {
         // Don't blab about which seed we're going to get --- it's not necessary for this purpose
-        psU64 seed = p_psRandomGetSystemSeed(false);
-        rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
+        rng = psRandomAlloc(PS_RANDOM_TAUS);
     }
 
Index: /trunk/psLib/src/math/psRandom.c
===================================================================
--- /trunk/psLib/src/math/psRandom.c	(revision 23258)
+++ /trunk/psLib/src/math/psRandom.c	(revision 23259)
@@ -29,4 +29,5 @@
 #include <inttypes.h>
 
+#include "psAbort.h"
 #include "psMemory.h"
 #include "psRandom.h"
@@ -38,19 +39,24 @@
 
 
+unsigned long seed = 0;                 // Seed for RNG
+
+
 psU64 p_psRandomGetSystemSeed(bool log)
 {
-    FILE*  fd;
-    psU64  seedVal = 0;
-    time_t timeVal;
+    psU64 seedVal = 0;                  // Seed value to return
 
-    fd = fopen("/dev/urandom","r");
-    if(fd == NULL) {
-        // Read system clock to get seed
-        seedVal = (psU64)time(&timeVal);
-    } else {
-        // Read urandom to get seed
-        if (fread(&seedVal, sizeof(psU64),1,fd)) {;} // ignore return value
-        // Close file
-        fclose(fd);
+    // Since zero is a special value in our context, don't allow the final value chosen to be zero
+    while (seedVal == 0) {
+        FILE *fd = fopen("/dev/urandom", "r");
+        if (fd) {
+            // Read urandom to get seed
+            if (fread(&seedVal, sizeof(psU64), 1, fd)) {;} // ignore return value
+            // Close file
+            fclose(fd);
+        } else {
+            // Read system clock to get seed
+            time_t timeVal;                 // Time value
+            seedVal = (psU64)time(&timeVal);
+        }
     }
 
@@ -63,100 +69,94 @@
 }
 
-psRandom *psRandomAlloc(psRandomType type,
-                        unsigned long seed)
+psU64 psRandomSeed(psU64 value)
 {
-    gsl_rng   *r      = NULL;
-    psRandom  *myRNG  = NULL;
+    while (value == 0) {
+        value = p_psRandomGetSystemSeed(true);
+    }
+    seed = value;
+    return seed;
+}
 
+// Destructor for psRandom
+static void randomFree(psRandom *rng)
+{
+    if (rng->gsl) {
+        gsl_rng_free(rng->gsl);
+    }
+    return;
+}
+
+// Constructor for psRandom
+static psRandom *randomAlloc(psRandomType type)
+{
+    psRandom *rng = psAlloc(sizeof(psRandom)); // Random number generator to return
+    psMemSetDeallocator(rng, (psFreeFunc)randomFree);
+
+    rng->type = type;
+
+    const gsl_rng_type *gslType;        // Type of RNG according to GSL
     switch (type) {
-    case PS_RANDOM_TAUS:
-        myRNG = (psRandom*)psAlloc(sizeof(psRandom));
-        r = gsl_rng_alloc(gsl_rng_taus);
-        myRNG->gsl = r;
-        if(seed == 0) {
-            gsl_rng_set(myRNG->gsl, p_psRandomGetSystemSeed(true));
-        } else {
-            gsl_rng_set(myRNG->gsl, seed);
-        }
-        myRNG->type = type;
+      case PS_RANDOM_TAUS:
+        gslType = gsl_rng_taus;
         break;
-
-    default:
-        psError(PS_ERR_UNEXPECTED_NULL, true, _("Unknown Random Number Generator Type"));
+      default:
+        psAbort("Unknown Random Number Generator Type: %x", type);
         break;
     }
 
-    return(myRNG);
+    rng->gsl = gsl_rng_alloc(gslType);
+    return rng;
 }
 
-void psRandomReset(psRandom *rand,
-                   unsigned long seed)
+psRandom *psRandomAlloc(psRandomType type)
 {
-    // Check null psRandom
-    if(rand==NULL) {
-        psError(PS_ERR_UNEXPECTED_NULL,
-                true,
-                _("Random variable is NULL."));
-    } else {
-        // Check seed value to see if system seed should be used
-        if(seed == 0) {
-            gsl_rng_set(rand->gsl,p_psRandomGetSystemSeed(true));
-        } else {
-            gsl_rng_set(rand->gsl, seed);
-        }
+    psRandom *rng = randomAlloc(type);
+    psRandomReset(rng);
+
+    return rng;
+}
+
+psRandom *psRandomAllocSpecific(psRandomType type, psU64 specificSeed)
+{
+    psRandom *rng = randomAlloc(type);
+    if (specificSeed == 0) {
+        specificSeed = p_psRandomGetSystemSeed(true);
     }
+    gsl_rng_set(rng->gsl, specificSeed);
+    return rng;
+}
+
+bool psRandomReset(psRandom *rand)
+{
+    PS_ASSERT_RANDOM_NON_NULL(rand, false);
+    if (seed == 0) {
+        seed = p_psRandomGetSystemSeed(true);
+    }
+    gsl_rng_set(rand->gsl, seed);
+    return true;
 }
 
 double psRandomUniform(const psRandom *r)
 {
-    // Check null psRandom variable
-    if(r == NULL) {
-        psError(PS_ERR_UNEXPECTED_NULL,
-                true,
-                _("Random variable is NULL."));
-        return(0);
-    } else {
-        return(gsl_rng_uniform(r->gsl));
-    }
+    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
+    return gsl_rng_uniform(r->gsl);
 }
 
 double psRandomGaussian(const psRandom *r)
 {
-    // Check null psRandom variable
-    if(r == NULL) {
-        psError(PS_ERR_UNEXPECTED_NULL,
-                true,
-                _("Random variable is NULL."));
-        return(0);
-    } else {
-        // XXX: What should sigma be?
-        return(gsl_ran_gaussian(r->gsl, 1.0));
-    }
+    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
+    return gsl_ran_gaussian(r->gsl, 1.0);
 }
 
 double p_psRandomGaussian(const psRandom *r, double sigma)
 {
-    // Check null psRandom variable
-    if(r == NULL) {
-        psError(PS_ERR_UNEXPECTED_NULL,
-                true,
-                _("Random variable is NULL."));
-        return(0);
-    } else {
-        return(gsl_ran_gaussian(r->gsl, sigma));
-    }
+    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
+    return gsl_ran_gaussian(r->gsl, sigma);
 }
 
 double psRandomPoisson(const psRandom *r, double mean)
 {
-    // Check null psRandom variable
-    if(r == NULL) {
-        psError(PS_ERR_UNEXPECTED_NULL,
-                true,
-                _("Random variable is NULL."));
-        return(0);
-    } else {
-        return((psF64) gsl_ran_poisson(r->gsl, mean));
-    }
+    PS_ASSERT_RANDOM_NON_NULL(r, NAN);
+    return gsl_ran_poisson(r->gsl, mean);
 }
 
Index: /trunk/psLib/src/math/psRandom.h
===================================================================
--- /trunk/psLib/src/math/psRandom.h	(revision 23258)
+++ /trunk/psLib/src/math/psRandom.h	(revision 23259)
@@ -29,12 +29,10 @@
 #include <gsl/gsl_randist.h>
 
-/** Enumeration containing a flag for psRandom types.  */
+/// Random number generator types
 typedef enum {
     PS_RANDOM_TAUS                     ///< A maximally equidistributed combined Tausworthe generator.
 } psRandomType;
 
-/** Data structure for psRandom.
- *  Contains information on the psRandom type and GNU Scientific Library random number generator.
- */
+/// Random number generator
 typedef struct {
     psRandomType type;                 ///< The type of RNG
@@ -48,20 +46,28 @@
     );
 
-/** Allocates a psRandom struct.
- *
- *  @return psRandom*:    A new psRandom structure.
- */
+/// Set the seed to use for random number generators.
+///
+/// A seed value of zero indicates that the seed is to be generated from the system.
+/// The new seed value is returned
+psU64 psRandomSeed(psU64 seed           ///< Seed for RNG
+                   );
+
+/// Allocate a random number generator
+///
+/// The currently defined seed (via psRandomSeed) is used
 psRandom *psRandomAlloc(
-    psRandomType type,                 ///< The type of RNG
-    unsigned long seed                 ///< Known value with which to seed the RNG
+    psRandomType type                   ///< The type of RNG
 ) PS_ATTR_MALLOC;
 
-/** Resets an existing psRandom struct.
- *
- *  @return void
- */
-void psRandomReset(
-    psRandom *rand,                    ///< Existing psRandom struct to reset
-    unsigned long seed                 ///< Known value with which to seed the RNG
+/// Allocate a random number generator with a specific seed
+///
+/// A seed value of zero indicates that the seed is to be generated from the system.
+psRandom *psRandomAllocSpecific(psRandomType type, ///< The type of RNG
+                                psU64 specificSeed ///< The specific seed to use
+    );
+
+/// Resets an existing random number generator
+bool psRandomReset(
+    psRandom *rand                      ///< Random number generator to reset
 );
 
@@ -72,5 +78,5 @@
  */
 double psRandomUniform(
-    const psRandom *r                  ///< psRandom struct for RNG
+    const psRandom *r                  ///< Random number generator
 );
 
@@ -81,17 +87,14 @@
  */
 double psRandomGaussian(
-    const psRandom *r                  ///< psRandom struct for RNG
+    const psRandom *r                  ///< Random number generator
 );
 
-/** Random number generator based on a Gaussian deviate, N(0,1).
+/** Random number generator based on a Gaussian deviate with specified standard deviation.
  *  Uses gsl_ran_gaussian.
- *
- *  XXX: I created this since the above psLib spec for p_psRandomGaussian
- *  had no argument for sigma.  Verify that with IfA.
  *
  *  @return double:     Random number.
  */
 double p_psRandomGaussian(
-    const psRandom *r,                  ///< psRandom struct for RNG
+    const psRandom *r,                  ///< Random number generator
     double sigma
 );
@@ -103,5 +106,5 @@
  */
 double psRandomPoisson(
-    const psRandom *r,                 ///< psRandom struct for RNG
+    const psRandom *r,                  ///< Random number generator
     double mean                         ///< Mean value
 );
Index: /trunk/psLib/test/fits/tap_psFitsImage.c
===================================================================
--- /trunk/psLib/test/fits/tap_psFitsImage.c	(revision 23258)
+++ /trunk/psLib/test/fits/tap_psFitsImage.c	(revision 23259)
@@ -12,5 +12,5 @@
 static psImage *generateImage(void)
 {
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345); // Random number generator
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345); // Random number generator
     psImage *image = psImageAlloc(NUMCOLS, NUMROWS, PS_TYPE_F32); // Generated image
     for (int y = 0; y < NUMROWS; y++) {
Index: /trunk/psLib/test/imageops/convolutionBench.c
===================================================================
--- /trunk/psLib/test/imageops/convolutionBench.c	(revision 23258)
+++ /trunk/psLib/test/imageops/convolutionBench.c	(revision 23259)
@@ -68,5 +68,5 @@
 int main(int argc, char *argv[])
 {
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0); // Random number generator
 
     printf("#%14s%16s        %8s        %8s\n", "Image", "Kernel", "Direct", "FFT");
Index: /trunk/psLib/test/imageops/tap_psImageInterpolate2.c
===================================================================
--- /trunk/psLib/test/imageops/tap_psImageInterpolate2.c	(revision 23258)
+++ /trunk/psLib/test/imageops/tap_psImageInterpolate2.c	(revision 23259)
@@ -77,5 +77,5 @@
     psImage *variance = NULL; // generateVariance(xSize, ySize, type);
     psImage *mask = NULL; // generateMask(xSize, ySize);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);
 
     psImageInterpolation *interp = psImageInterpolationAlloc(mode, image, variance, mask, 0, NAN, NAN,
Index: /trunk/psLib/test/math/tap_psMinimizeLMM.c
===================================================================
--- /trunk/psLib/test/math/tap_psMinimizeLMM.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psMinimizeLMM.c	(revision 23259)
@@ -95,5 +95,5 @@
     {
         psMemId id = psMemGetId();
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
         psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
         psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);
@@ -203,5 +203,5 @@
     {
         psMemId id = psMemGetId();
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
         psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
         psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);
Index: /trunk/psLib/test/math/tap_psPolyFit1D.c
===================================================================
--- /trunk/psLib/test/math/tap_psPolyFit1D.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psPolyFit1D.c	(revision 23259)
@@ -109,5 +109,5 @@
     psVector *xTruth = psVectorAlloc(numData, PS_TYPE_F64);
     psVector *fTruth = psVectorAlloc(numData, PS_TYPE_F64);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = (flags & TS00_X_NULL) ? i : 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tap_psPolyFit2D.c
===================================================================
--- /trunk/psLib/test/math/tap_psPolyFit2D.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psPolyFit2D.c	(revision 23259)
@@ -108,5 +108,5 @@
     yTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tap_psPolyFit3D.c
===================================================================
--- /trunk/psLib/test/math/tap_psPolyFit3D.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psPolyFit3D.c	(revision 23259)
@@ -108,5 +108,5 @@
     zTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tap_psPolyFit4D.c
===================================================================
--- /trunk/psLib/test/math/tap_psPolyFit4D.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psPolyFit4D.c	(revision 23259)
@@ -132,5 +132,5 @@
     tTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tap_psRandom.c
===================================================================
--- /trunk/psLib/test/math/tap_psRandom.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psRandom.c	(revision 23259)
@@ -3,5 +3,5 @@
 work properly.
  
-    ensure that psRandom structs are properly allocated by psRandomAlloc().
+    ensure that psRandom structs are properly allocated by psRandomAllocSpecific().
     ensure that psRandomUniform() produces a sequence of numbers with
         proper mean and stdev.
@@ -47,12 +47,12 @@
     plan_tests(34);
 
-    // ensure that psRandom structs are properly allocated by psRandomAlloc()
+    // ensure that psRandom structs are properly allocated by psRandomAllocSpecific()
     {
         psMemId id = psMemGetId();
         // Valid type allocation
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
-        ok(myRNG->type == PS_RANDOM_TAUS, "psRandomAlloc() set type properly");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
+        ok(myRNG->type == PS_RANDOM_TAUS, "psRandomAllocSpecific() set type properly");
         psFree(myRNG);
         skip_end();
@@ -63,6 +63,6 @@
     {
         psMemId id = psMemGetId();
-        psRandom *myRNG = psRandomAlloc(100,SEED);
-        ok(myRNG == NULL, "psRandomAlloc() refused to generate psRandom with unallowed type");
+        psRandom *myRNG = psRandomAllocSpecific(100,SEED);
+        ok(myRNG == NULL, "psRandomAllocSpecific() refused to generate psRandom with unallowed type");
         psFree(myRNG);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
@@ -72,6 +72,6 @@
     {
         psMemId id = psMemGetId();
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS,-5);
-        ok(myRNG != NULL, "psRandomAlloc() allows negative seed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS,-5);
+        ok(myRNG != NULL, "psRandomAllocSpecific() allows negative seed");
         psFree(myRNG);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
@@ -85,7 +85,7 @@
         rans->n = rans->nalloc;
         psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vector data with random number
@@ -125,7 +125,7 @@
         rans->n = rans->nalloc;
         psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vector with random data
@@ -167,7 +167,7 @@
         rans->n = rans->nalloc;
         psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vector with random data
@@ -210,7 +210,7 @@
         rans02->n = rans02->nalloc;
 
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
 
 
@@ -252,5 +252,5 @@
     if (0) {
         psRandom *myRNG1 = NULL;
-        myRNG1 = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+        myRNG1 = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
         //    psLogSetDestination("dest:stderr");
         psLogSetDestination(0);
@@ -275,7 +275,7 @@
         rans02->n = rans02->nalloc;
 
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
 
 
@@ -325,7 +325,7 @@
         rans02->n = rans02->nalloc;
 
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vectors with random data
Index: /trunk/psLib/test/math/tap_psStats07.c
===================================================================
--- /trunk/psLib/test/math/tap_psStats07.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psStats07.c	(revision 23259)
@@ -58,6 +58,6 @@
     PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
 
-    //    psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, p_psRandomGetSystemSeed());
-    psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, PS_XXX_GAUSSIAN_SEED);
+    //    psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, p_psRandomGetSystemSeed());
+    psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, PS_XXX_GAUSSIAN_SEED);
     psVector* gauss = psVectorAlloc(Npts, PS_TYPE_F32);
     for (unsigned int i = 0; i < Npts; i++) {
Index: /trunk/psLib/test/math/tap_psStats09.c
===================================================================
--- /trunk/psLib/test/math/tap_psStats09.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psStats09.c	(revision 23259)
@@ -52,5 +52,5 @@
     srand(SEED);
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     psVector *truth = psVectorAlloc(numData, PS_TYPE_F64);
     for (long i = 0; i < numData; i++) {
Index: /trunk/psLib/test/math/tap_psStatsTiming.c
===================================================================
--- /trunk/psLib/test/math/tap_psStatsTiming.c	(revision 23258)
+++ /trunk/psLib/test/math/tap_psStatsTiming.c	(revision 23259)
@@ -20,5 +20,5 @@
 
     // build a gauss-deviate vector (mean = 0.0, sigma = 1.0) for tests
-    psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
+    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
     psVector *rnd = psVectorAlloc (1000, PS_TYPE_F32);
     for (int i = 0; i < rnd->n; i++) {
Index: /trunk/psLib/test/math/tst_psMinimizeLMM.c
===================================================================
--- /trunk/psLib/test/math/tst_psMinimizeLMM.c	(revision 23258)
+++ /trunk/psLib/test/math/tst_psMinimizeLMM.c	(revision 23259)
@@ -66,5 +66,5 @@
     psBool testStatus = true;
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
     psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);
Index: /trunk/psLib/test/math/tst_psPolyFit1D.c
===================================================================
--- /trunk/psLib/test/math/tst_psPolyFit1D.c	(revision 23258)
+++ /trunk/psLib/test/math/tst_psPolyFit1D.c	(revision 23259)
@@ -101,5 +101,5 @@
     xTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = (flags & TS00_X_NULL) ? i : 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tst_psPolyFit2D.c
===================================================================
--- /trunk/psLib/test/math/tst_psPolyFit2D.c	(revision 23258)
+++ /trunk/psLib/test/math/tst_psPolyFit2D.c	(revision 23259)
@@ -100,5 +100,5 @@
     yTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tst_psPolyFit3D.c
===================================================================
--- /trunk/psLib/test/math/tst_psPolyFit3D.c	(revision 23258)
+++ /trunk/psLib/test/math/tst_psPolyFit3D.c	(revision 23259)
@@ -103,5 +103,5 @@
     zTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tst_psPolyFit4D.c
===================================================================
--- /trunk/psLib/test/math/tst_psPolyFit4D.c	(revision 23258)
+++ /trunk/psLib/test/math/tst_psPolyFit4D.c	(revision 23259)
@@ -124,5 +124,5 @@
     tTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: /trunk/psLib/test/math/tst_psRandom.c
===================================================================
--- /trunk/psLib/test/math/tst_psRandom.c	(revision 23258)
+++ /trunk/psLib/test/math/tst_psRandom.c	(revision 23259)
@@ -3,5 +3,5 @@
 work properly.
  
-    t00(): ensure that psRandom structs are properly allocated by psRandomAlloc().
+    t00(): ensure that psRandom structs are properly allocated by psRandomAllocSpecific().
     t01(): ensure that psRandomUniform() produces a sequence of numbers with
     proper mean and stdev.
@@ -45,5 +45,5 @@
 
 testDescription tests[] = {
-                              {testRandomAlloc,000,"psRandomAlloc",0,false},
+                              {testRandomAlloc,000,"psRandomAllocSpecific",0,false},
                               {testRandomUniform,000,"psRandomUniform",0,false},
                               {testRandomGaussian,000,"psRandomGaussian",0,false},
@@ -70,5 +70,5 @@
 
     // Valid type allocation
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -85,5 +85,5 @@
     //    psLogSetDestination("file:seed_msglog1.txt");
     psLogSetDestination(fd1);
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, 0);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
     //    psLogSetDestination("dest:stderr");
     psLogSetDestination(2);
@@ -100,5 +100,5 @@
     // Invalid type allocation
     psLogMsg(__func__,PS_LOG_INFO,"Invalid type, should generate error message");
-    myRNG = psRandomAlloc(100,SEED);
+    myRNG = psRandomAllocSpecific(100,SEED);
     if (myRNG != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type");
@@ -107,5 +107,5 @@
 
     // Negative seed value
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS,-5);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS,-5);
     if(myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Did not return allocated psRandom");
@@ -125,5 +125,5 @@
     psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -171,5 +171,5 @@
     psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -219,5 +219,5 @@
     psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -268,5 +268,5 @@
     rans02->n = rans02->nalloc;
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -302,5 +302,5 @@
 
     psRandom *myRNG1 = NULL;
-    myRNG1 = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG1 = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     //    psLogSetDestination("dest:stderr");
     psLogSetDestination(0);
@@ -326,5 +326,5 @@
     rans02->n = rans02->nalloc;
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -372,5 +372,5 @@
     rans02->n = rans02->nalloc;
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
Index: /trunk/psLib/test/math/tst_psStats09.c
===================================================================
--- /trunk/psLib/test/math/tst_psStats09.c	(revision 23258)
+++ /trunk/psLib/test/math/tst_psStats09.c	(revision 23259)
@@ -52,5 +52,5 @@
     printPositiveTestHeader(stdout, "psMathUtils functions", "psVectorStats Clipped Stats Routine");
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     psVector *truth = psVectorAlloc(numData, PS_TYPE_F64);
     truth->n = numData;
Index: /trunk/psLib/test/mathtypes/tap_psVectorSelect.c
===================================================================
--- /trunk/psLib/test/mathtypes/tap_psVectorSelect.c	(revision 23258)
+++ /trunk/psLib/test/mathtypes/tap_psVectorSelect.c	(revision 23259)
@@ -17,5 +17,5 @@
     psVector *vector = psVectorAlloc(size, PS_TYPE_F32);
     psVectorInit(vector, 0.0);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);
     for (long i = 0; i < numNonzero; i++) {
         long index = psRandomUniform(rng) * size;
@@ -52,5 +52,5 @@
     psVector *vector = psVectorAlloc(size, PS_TYPE_F32);
     psVectorInit(vector, 0.0);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);
     for (long i = 0; i < numNonzero; i++) {
         long index = psRandomUniform(rng) * size;
Index: /trunk/psLib/test/types/tap_psTree.c
===================================================================
--- /trunk/psLib/test/types/tap_psTree.c	(revision 23258)
+++ /trunk/psLib/test/types/tap_psTree.c	(revision 23259)
@@ -16,5 +16,5 @@
         psVector *y = psVectorAlloc(NUM, PS_TYPE_F64);
 
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         for (int i = 0; i < NUM; i++) {
             x->data.F64[i] = 2.0 * psRandomUniform(rng) - 1.0;
Index: /trunk/psModules/src/camera/pmFPAMaskWeight.c
===================================================================
--- /trunk/psModules/src/camera/pmFPAMaskWeight.c	(revision 23258)
+++ /trunk/psModules/src/camera/pmFPAMaskWeight.c	(revision 23259)
@@ -331,5 +331,5 @@
 
     if (!psMemIncrRefCounter(rng)) {
-        rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        rng = psRandomAlloc(PS_RANDOM_TAUS);
     }
 
@@ -371,5 +371,5 @@
 
     if (!psMemIncrRefCounter(rng)) {
-        rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        rng = psRandomAlloc(PS_RANDOM_TAUS);
     }
 
@@ -532,5 +532,5 @@
 
     if (!psMemIncrRefCounter(rng)) {
-        rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        rng = psRandomAlloc(PS_RANDOM_TAUS);
     }
 
Index: /trunk/psModules/src/camera/pmFPA_JPEG.c
===================================================================
--- /trunk/psModules/src/camera/pmFPA_JPEG.c	(revision 23258)
+++ /trunk/psModules/src/camera/pmFPA_JPEG.c	(revision 23259)
@@ -154,5 +154,5 @@
 
     // measure the image statistics for scaling
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
     psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
     stats->nSubsample = 10000;
Index: /trunk/psModules/src/config/pmConfig.c
===================================================================
--- /trunk/psModules/src/config/pmConfig.c	(revision 23258)
+++ /trunk/psModules/src/config/pmConfig.c	(revision 23259)
@@ -13,4 +13,5 @@
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <strings.h>            /* for strn?casecmp */
@@ -24,9 +25,11 @@
 #include <pslib.h>
 
-#include "pmConfig.h"
 #include "pmErrorCodes.h"
 #include "pmFPALevel.h"
 #include "pmConfigRecipes.h"
 #include "pmConfigCamera.h"
+#include "pmConfigRun.h"
+
+#include "pmConfig.h"
 
 #ifdef HAVE_NEBCLIENT
@@ -432,8 +435,7 @@
     // variable will contain the name of the configuration file.
 
-    char *configFile = NULL;
-    //
+    char *configFile = NULL;            // Name of configuration file
+
     // First, try command line
-    //
     psS32 argNum = psArgumentGet(*argc, argv, "-ipprc");
     if (argNum != 0) {
@@ -447,17 +449,14 @@
         }
     }
-    //
+
     // Next, try environment variable
-    //
     if (!configFile) {
         configFile = getenv(IPPRC_ENV);
         if (configFile) {
-            configFile = psStringCopy (configFile);
-        }
-    }
-
-    //
+            configFile = psStringCopy(configFile);
+        }
+    }
+
     // Last chance is ~/.ipprc
-    //
     if (!configFile) {
         char *home = getenv("HOME");
@@ -466,8 +465,6 @@
     }
 
-    // We have the configuration filename; now we read and parse the config
-    // file and store in psMetadata struct user.
+    // Read and parse the config file and store in struct user.
     // XXX move this section to pmConfigReadUser.c ?
-
     if (!pmConfigFileRead(&config->user, configFile, "user")) {
         psFree(config);
@@ -477,11 +474,10 @@
     psFree(configFile);
 
-    // XXX why was this being called here?  Is someone calling pmConfigRead multiple times?
-    // pmConfigDone();
-    assert (configPath == NULL);
+    pmConfigRunCommand(config, *argc, argv);
 
     // define the config-file search path (configPath).
+    psAssert(configPath == NULL, "Configuration path is already defined.");
     psString path = psMetadataLookupStr(NULL, config->user, "PATH");
-    pmConfigSet (path);
+    pmConfigSet(path);
 
     // read the SITE file
@@ -525,5 +521,4 @@
             psLogSetLevel(logLevel);
         }
-
 
         // Set logging format
@@ -646,4 +641,26 @@
             psTimeInit(timeName);
         }
+    }
+
+    // Set the random number generator seed
+    {
+        psU64 seed = 0;                 // RNG seed
+        int argNum = psArgumentGet(*argc, argv, "-seed"); // Argument number
+        if (argNum > 0) {
+            psArgumentRemove(argNum, argc, argv);
+            if (argNum >= *argc) {
+                psWarning("-seed command-line switch provided without the required seed value --- ignored.");
+            } else {
+                char *end = NULL;       // Pointer to end of consumed string
+                seed = strtoll(argv[argNum], &end, 0);
+                if (strlen(end) > 0) {
+                    psError(PS_ERR_IO, true, "Unable to read random number generator seed: %s", argv[argNum]);
+                    psFree(config);
+                    return NULL;
+                }
+                psArgumentRemove(argNum, argc, argv);
+            }
+        }
+        pmConfigRunSeed(config, seed);
     }
 
Index: /trunk/psModules/src/config/pmConfigCamera.c
===================================================================
--- /trunk/psModules/src/config/pmConfigCamera.c	(revision 23258)
+++ /trunk/psModules/src/config/pmConfigCamera.c	(revision 23259)
@@ -213,4 +213,5 @@
     psStringAppend(&newName, "_%s-SKYCELL", name);
     if (psMetadataLookup(oldCameras, newName)) {
+        psFree(newName);
         return true;
     }
@@ -469,4 +470,5 @@
     psStringAppend(&newName, "_%s-%s", name, mosaicLevel == PM_FPA_LEVEL_CHIP ? "CHIP" : "FPA");
     if (psMetadataLookup(oldCameras, newName)) {
+        psFree(newName);
         return true;
     }
Index: /trunk/psModules/src/config/pmConfigRecipes.h
===================================================================
--- /trunk/psModules/src/config/pmConfigRecipes.h	(revision 23258)
+++ /trunk/psModules/src/config/pmConfigRecipes.h	(revision 23259)
@@ -1,9 +1,9 @@
 /*  @file pmConfigRecipes.h
  *  @brief Configuration Recipe functions
- * 
+ *
  *  @author ?, MHPCC
  *  @author Paul Price, IfA
  *  @author Eugene Magnier, IfA
- * 
+ *
  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2007-04-19 02:10:12 $
@@ -13,4 +13,6 @@
 #ifndef PM_CONFIG_RECIPES_H
 #define PM_CONFIG_RECIPES_H
+
+#include <pmConfig.h>
 
 /// @addtogroup Config Configuration System
@@ -26,7 +28,7 @@
 
 
-bool pmConfigLoadRecipeArguments (int *argc, char **argv, pmConfig *config);
-bool pmConfigLoadRecipeOptions (int *argc, char **argv, pmConfig *config, char *flag);
-psMetadata *pmConfigRecipeOptions (pmConfig *config, char *recipe);
+bool pmConfigLoadRecipeArguments(int *argc, char **argv, pmConfig *config);
+bool pmConfigLoadRecipeOptions(int *argc, char **argv, pmConfig *config, char *flag);
+psMetadata *pmConfigRecipeOptions(pmConfig *config, char *recipe);
 
 /// @}
Index: /trunk/psModules/src/config/pmConfigRun.c
===================================================================
--- /trunk/psModules/src/config/pmConfigRun.c	(revision 23258)
+++ /trunk/psModules/src/config/pmConfigRun.c	(revision 23259)
@@ -72,5 +72,5 @@
 
 
-bool pmConfigRunCommand(pmConfig *config, int argc, const char **argv)
+bool pmConfigRunCommand(pmConfig *config, int argc, char **argv)
 {
     PS_ASSERT_PTR_NON_NULL(config, false);
@@ -81,5 +81,5 @@
     psString command = NULL;
     for (int i = 0; i < argc; i++) {
-        psStringAppend(&command, "%s", argv[i]);
+        psStringAppend(&command, "%s ", argv[i]);
     }
 
@@ -89,2 +89,25 @@
     return true;
 }
+
+
+bool pmConfigRunSeed(pmConfig *config, psU64 seed)
+{
+    PS_ASSERT_PTR_NON_NULL(config, false);
+
+    psMetadata *run = configRun(config);// Run-time information
+    psAssert(run, "Require run-time information");
+
+    if (!seed) {
+        bool mdok;                          // Status of MD lookup
+        seed = psMetadataLookupU64(&mdok, run, "SEED");
+    }
+    if (!seed) {
+        bool mdok;                          // Status of MD lookup
+        seed = psMetadataLookupU64(&mdok, config->user, "SEED");
+    }
+
+    // seed may still be zero by this point
+    seed = psRandomSeed(seed);
+    return psMetadataAddU64(run, PS_LIST_TAIL, "SEED", PS_META_REPLACE, "Random number generator seed", seed);
+}
+
Index: /trunk/psModules/src/config/pmConfigRun.h
===================================================================
--- /trunk/psModules/src/config/pmConfigRun.h	(revision 23258)
+++ /trunk/psModules/src/config/pmConfigRun.h	(revision 23259)
@@ -4,4 +4,5 @@
 #include <pslib.h>
 #include <pmConfig.h>
+#include <pmFPAfile.h>
 
 /// Add a file to the list of files used in the run-time information
@@ -12,6 +13,13 @@
 
 /// Add the command line to the run-time information
-bool pmConfigRunCommand(pmConfig *config, ///< Configuration
-                        int argc, const char **argv ///< Command line arguments
+bool pmConfigRunCommand(
+    pmConfig *config,                   ///< Configuration
+    int argc, char **argv               ///< Command line arguments
+    );
+
+/// Record the random number generator seed in the run-time information
+bool pmConfigRunSeed(
+    pmConfig *config,                   ///< Configuration
+    psU64 seed                          ///< RNG seed
     );
 
Index: /trunk/psModules/src/detrend/pmFringeStats.c
===================================================================
--- /trunk/psModules/src/detrend/pmFringeStats.c	(revision 23258)
+++ /trunk/psModules/src/detrend/pmFringeStats.c	(revision 23259)
@@ -65,5 +65,5 @@
         rng = psMemIncrRefCounter(random);
     } else {
-        rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        rng = psRandomAlloc(PS_RANDOM_TAUS);
     }
 
Index: /trunk/psModules/src/detrend/pmRemnance.c
===================================================================
--- /trunk/psModules/src/detrend/pmRemnance.c	(revision 23258)
+++ /trunk/psModules/src/detrend/pmRemnance.c	(revision 23259)
@@ -28,5 +28,5 @@
     int numCols = image->numCols, numRows = image->numRows; // Size of image
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
 
     psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV); // Statistics
Index: /trunk/psModules/src/detrend/pmShutterCorrection.c
===================================================================
--- /trunk/psModules/src/detrend/pmShutterCorrection.c	(revision 23258)
+++ /trunk/psModules/src/detrend/pmShutterCorrection.c	(revision 23259)
@@ -911,5 +911,5 @@
     psStats *stats = psStatsAlloc(meanStat | stdevStat); // Statistics to apply
     if (!rng) {
-        rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        rng = psRandomAlloc(PS_RANDOM_TAUS);
     } else {
         psMemIncrRefCounter(rng);
Index: /trunk/psModules/src/imcombine/pmSubtractionMatch.c
===================================================================
--- /trunk/psModules/src/imcombine/pmSubtractionMatch.c	(revision 23258)
+++ /trunk/psModules/src/imcombine/pmSubtractionMatch.c	(revision 23259)
@@ -214,5 +214,5 @@
     int numCols = ro1->image->numCols, numRows = ro1->image->numRows; // Image dimensions
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
 
     memCheck("start");
Index: /trunk/psModules/test/detrend/tap_pmMaskBadPixels.c
===================================================================
--- /trunk/psModules/test/detrend/tap_pmMaskBadPixels.c	(revision 23258)
+++ /trunk/psModules/test/detrend/tap_pmMaskBadPixels.c	(revision 23259)
@@ -282,5 +282,5 @@
         pmCell *cell = generateSimpleCell(NULL);
         pmReadout *in = generateSimpleReadout(cell);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
 
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with NULL input pmReadout");
@@ -301,5 +301,5 @@
         psFree(in->image);
         in->image = NULL;
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with NULL input pmReadout->image");
         psFree(rng);
@@ -319,5 +319,5 @@
         psFree(in->image);
         in->image = psImageAlloc(0, 0, PS_TYPE_F32);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with empty input pmReadout->image");
         psFree(rng);
@@ -337,5 +337,5 @@
         psFree(in->image);
         in->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_S32);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect type for pmReadout->image");
         psFree(rng);
@@ -355,5 +355,5 @@
         psFree(in->mask);
         in->mask = psImageAlloc(0, 0, PS_TYPE_MASK);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect type for pmReadout->image");
         psFree(rng);
@@ -373,5 +373,5 @@
         psFree(in->mask);
         in->mask = psImageAlloc(TEST_NUM_COLS/2, TEST_NUM_ROWS/2, PS_TYPE_MASK);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with bad size for in->mask");
         psFree(rng);
@@ -391,5 +391,5 @@
         psFree(in->mask);
         in->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_S32);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with bad type for in->mask");
         psFree(rng);
@@ -407,5 +407,5 @@
         pmCell *cell = generateSimpleCell(NULL);
         pmReadout *in = generateSimpleReadout(cell);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with empty out image");
         psFree(rng);
@@ -423,5 +423,5 @@
         pmCell *cell = generateSimpleCell(NULL);
         pmReadout *in = generateSimpleReadout(cell);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect type for out image");
         psFree(rng);
@@ -439,5 +439,5 @@
         pmCell *cell = generateSimpleCell(NULL);
         pmReadout *in = generateSimpleReadout(cell);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
         ok(!pmMaskFlagSuspectPixels(out, NULL, 1.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with incorrect size for out image");
         psFree(rng);
@@ -455,5 +455,5 @@
         pmCell *cell = generateSimpleCell(NULL);
         pmReadout *in = generateSimpleReadout(cell);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
 
         ok(!pmMaskFlagSuspectPixels(out, in, 0.0, 1, 1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with rej input <= 0.0");
@@ -472,5 +472,5 @@
         pmCell *cell = generateSimpleCell(NULL);
         pmReadout *in = generateSimpleReadout(cell);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
 
         ok(!pmMaskFlagSuspectPixels(out, in, 1.0, 1, -1.0, rng), "pmMaskFlagSuspectPixels() returned NULL with frac input < 0.0");
Index: /trunk/psModules/test/imcombine/tap_pmImageCombine.c
===================================================================
--- /trunk/psModules/test/imcombine/tap_pmImageCombine.c	(revision 23258)
+++ /trunk/psModules/test/imcombine/tap_pmImageCombine.c	(revision 23259)
@@ -9,5 +9,5 @@
 psArray *generate_images(void)
 {
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 12345);   // Random Number Generator
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 12345);   // Random Number Generator
 
     // Generate images
Index: /trunk/psModules/test/objects/tap_pmFringe.c
===================================================================
--- /trunk/psModules/test/objects/tap_pmFringe.c	(revision 23258)
+++ /trunk/psModules/test/objects/tap_pmFringe.c	(revision 23259)
@@ -89,5 +89,5 @@
         ok(fringe != NULL, "pmFringeRegionsAlloc() returned non-NULL");
         psImage *img = psImageAlloc(NUM_COLS, NUM_ROWS, PS_TYPE_F32);
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 10);
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 10);
         fringe->x = psVectorAlloc(NUM_FRINGE_PNTS/2, PS_TYPE_F32);
         fringe->y = psVectorAlloc(NUM_FRINGE_PNTS/2, PS_TYPE_F32);
Index: /trunk/psModules/test/objects/tap_pmSourceFitModel.c
===================================================================
--- /trunk/psModules/test/objects/tap_pmSourceFitModel.c	(revision 23258)
+++ /trunk/psModules/test/objects/tap_pmSourceFitModel.c	(revision 23259)
@@ -27,5 +27,5 @@
 
     // build a gauss-deviate vector (mean = 0.0, sigma = 1.0)
-    psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
+    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
 
     static float radius[] = {3.0, 5.0, 7.0, 10.0, 15.0, 25.0};
Index: /trunk/psModules/test/objects/tap_pmSourceFitModel_Delta.c
===================================================================
--- /trunk/psModules/test/objects/tap_pmSourceFitModel_Delta.c	(revision 23258)
+++ /trunk/psModules/test/objects/tap_pmSourceFitModel_Delta.c	(revision 23259)
@@ -23,5 +23,5 @@
 
     // build a gauss-deviate vector (mean = 0.0, sigma = 1.0)
-    psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
+    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
 
     // noise vector to noise up the image
@@ -167,5 +167,5 @@
 
     // build a gauss-deviate vector (mean = 0.0, sigma = 1.0)
-    psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
+    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
 
     static float radius[] = {3.0, 5.0, 7.0, 10.0, 15.0, 25.0};
Index: /trunk/psphot/src/psphotModelBackground.c
===================================================================
--- /trunk/psphot/src/psphotModelBackground.c	(revision 23258)
+++ /trunk/psphot/src/psphotModelBackground.c	(revision 23259)
@@ -49,10 +49,5 @@
     assert (maskVal);
 
-    // user supplied seed, if available
-    unsigned long seed = psMetadataLookupS32 (&status, recipe, "IMSTATS_SEED");
-    if (!status) {
-        seed = 0;
-    }
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, seed);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
 
     // subtract this amount extra from the sky
Index: /trunk/psphot/src/psphotVisual.c
===================================================================
--- /trunk/psphot/src/psphotVisual.c	(revision 23258)
+++ /trunk/psphot/src/psphotVisual.c	(revision 23259)
@@ -32,5 +32,5 @@
 
     psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
     if (!psImageBackground(stats, NULL, inImage, NULL, 0, rng)) {
         fprintf (stderr, "failed to get background values\n");
@@ -78,5 +78,5 @@
 
     psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
     if (!psImageBackground(stats, NULL, inImage, NULL, 0, rng)) {
         fprintf (stderr, "failed to get background values\n");
Index: /trunk/pstest/src/tst_psPolynomial.c
===================================================================
--- /trunk/pstest/src/tst_psPolynomial.c	(revision 23258)
+++ /trunk/pstest/src/tst_psPolynomial.c	(revision 23259)
@@ -289,5 +289,5 @@
 	    fillVectors(x, f, NORD, NPTS, type[k]);
 	    psTime *now = psTimeGetNow(PS_TIME_UTC);
-	    const psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, now->sec);
+	    const psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, now->sec);
 	    for (int i = 0; i < NPTS; i++) {
 		double errgen = psRandomGaussian(r);
@@ -361,5 +361,5 @@
 	    // add random errors to the vector
 	    psTime *now = psTimeGetNow(PS_TIME_UTC);
-	    const psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, now->sec);
+	    const psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, now->sec);
 	    for (int i = 0; i < NPTS; i++) {
 		double errgen = psRandomGaussian(r);
@@ -464,5 +464,5 @@
 	    fillVectors(x, f, NORD, NPTS, type[k]);
 	    psTime *now = psTimeGetNow(PS_TIME_UTC);
-	    const psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, now->sec);
+	    const psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, now->sec);
 	    for (int i = 0; i < NPTS; i++) {
 		double errgen = psRandomGaussian(r);