double* generate_random_constraints(char* seed, int N, int n, double* R)
{
// struct mt19937p state;
// sgenrand(seed, &state);
int i, j;
initialize();
int seed1, seed2;
phrtsd(seed, &seed1, &seed2);
set_initial_seed(seed1, seed2);
// for (int i = 0; i < 10; i++)
// printf("Random N(0,1): %g\n", gennor(0, 1));
float meanv[n];
float varv[n];
for (i = 0; i < n; i++) {
float EY = 1.06 + 0.1*(pow(i, 1.1) / (n-1));
float VarY = pow(0.05 + 0.45*(pow(i, 1.15) / (n-1)), 2);
varv[i] = log(1 + (VarY / pow(EY,2)));
meanv[i] = log(EY) - (varv[i] / 2);
// meanv[i] = 0.057157648387530194;
// varv[i] = 0.0022225194728912752;
}
// float varv[n];
// for (int i = 0; i < n; i++) {
// varv[i] = 1;
// }
// float* covm = setcov(n, varv, 0);
float covm[n*n];
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if (i == j) {
covm[i+j*n] = varv[i];
}
else{
covm[i+j*n] = 0;
}
}
}
float parm[n*(n+3)/2+1];
setgmn(meanv, covm, n, parm);
// Row major layout
float* mvn;
for (i = 0; i < N; i++) {
float* mvn = genmn(parm);
for (j = 0; j < n; j++) {
R[i*n + j] = exp(mvn[j]);
// R[i*n + j] = 1.0 + 0.1*genrand(&state) + 0.01; // [1.01, 1.11]
}
free(mvn);
}
return R;
}
/************************ end self doc ***********************************/
void main (int argc, char **argv)
{
/* declaration of variables */
FILE *fp; /* file pointer */
char *covarFile = " "; /* covariance file */
char *MAPFile = " "; /* MAP model file */
int i, j, k; /* counters */
int nL; /* number of layers */
int cl; /* correlation length */
int pWave; /* P-wave flag */
int sWave; /* S-wave flag */
int density; /* density flag */
int nVar; /* dimension of the problem */
int seed; /* input seed */
int lim[2]; /* integer limits for target zone */
int exponential; /* exponential flag */
int impedance; /* impedance flag */
int verbose; /* dialogue flag */
int nPar; /* number of active parameters */
int shift, shift1; /* used in simulation of more than one */
/* parameter */
long seed1, seed2; /* seed for random generator */
float limZ[2]; /* depth limits of target zone */
float *thick, *alpha, *beta, *rho;
/* medium parameters */
float *buffer; /* working buffer */
float aux1, aux2; /* auxiliar variables */
float *parm; /* paramter vector */
float *mean; /* mean vector */
float *work; /* working area */
float **covar; /* correlation matrix */
float **covarExp; /* exponential correlation matrix */
float *deviate; /* random gaussian realization */
float dz; /* depth discretization level */
float depth; /* current depth */
/* input parameters */
initargs(argc, argv);
requestdoc(0);
/* dimension of the problem */
if (!getparstring("covariance", &covarFile)) covarFile = "covar";
if (!getparstring("mean", &MAPFile)) MAPFile = "mean";
if (!getparint("exponential", &exponential)) exponential = 0;
if (!getparint("impedance", &impedance)) impedance = 0;
if (!getparint("p", &pWave)) pWave = 1;
if (!getparint("s", &sWave)) sWave = 1;
if (!getparint("r", &density)) density = 1;
if (!getparfloat("dz", &dz)) dz = .5;
nPar = pWave + sWave + density;
if (!getparfloat("targetbeg", &limZ[0])) limZ[0] = 0.5;
if (!getparfloat("targetend", &limZ[1])) limZ[1] = 1.0;
if (!getparint("verbose", &verbose)) verbose = 0;
/* random generator seeding */
seed = getpid();
fp = fopen(MAPFile, "r");
if (fp == NULL) err("No model file!\n");
nL = 0;
while (fscanf(fp, "%f %f %f %f %f %f\n",
&aux1, &aux1, &aux1, &aux1, &aux1, &aux1) != EOF)
nL++;
nL--;
rewind(fp);
/* memory allocation */
alpha = alloc1float(nL + 1);
beta = alloc1float(nL + 1);
rho = alloc1float(nL + 1);
thick = alloc1float(nL + 1);
if (verbose)
fprintf(stderr," Thickness rho vP qP vS qS\n");
for (k = 0; k < nL + 1; k++)
{
fscanf(fp, "%f %f %f %f %f %f\n", &thick[k], &rho[k], &alpha[k],
&aux1, &beta[k], &aux2);
if (verbose)
fprintf(stderr," %7.4f %4.3f %3.2f %5.1f %3.2f %5.1f\n",
thick[k], rho[k], alpha[k], aux1, beta[k], aux2);
if (impedance)
{
alpha[k] *= rho[k];
beta[k] *= rho[k];
}
}
fclose(fp);
/* setting lim[0] and lim[1] */
for (depth = thick[0], i = 1; i <= nL; depth += thick[i], i++)
{
if (NINT(depth / dz) <= NINT(limZ[0] / dz)) lim[0] = i;
if (NINT(depth / dz) < NINT(limZ[1] / dz)) lim[1] = i;
}
/* total dimension */
nVar = nPar * (lim[1] - lim[0] + 1);
if (verbose)
fprintf(stderr, "Total dimension of the problem: %d\n", nVar);
/* more memory allocation */
covar = alloc2float(nVar, nVar);
covarExp = alloc2float(nVar, nVar);
parm = alloc1float(nVar * (nVar + 3) / 2 + 1);
work = alloc1float(nVar);
mean = alloc1float(nVar);
deviate = alloc1float(nVar);
buffer = alloc1float(nPar * (nL + 1));
fp = fopen(covarFile, "r");
if (fp == NULL) err("No covariance file!\n");
fread(&covar[0][0], sizeof(float), nVar * nVar, fp);
fclose(fp);
/* building the mean */
shift = 0;
if (pWave)
{
for (k = 0, i = lim[0]; i <= lim[1]; i++, k++)
mean[k] = alpha[i];
shift = nVar / nPar;
}
if (sWave)
{
for (k = 0, i = lim[0]; i <= lim[1]; i++, k++)
mean[k + shift] = beta[i];
shift += nVar / nPar;
}
if (density)
{
for (k = 0, i = lim[0]; i <= lim[1]; i++, k++)
mean[k + shift] = beta[i];
}
/* fitting an exponential model */
if (exponential)
{
for (i = 0; i < nVar; i++)
for (j = 0; j < nVar; j++)
covarExp[i][j] = 0;
for (i = 0; i < nVar; i++)
{
for (cl = 0, j = i; j < nVar; j++, cl++)
{
if (covar[i][j] / covar[i][i] < 1. / EULER) break;
}
for (j = 0; j < nVar; j++)
{
covarExp[i][j] += .5 * covar[i][i] *
exp(-(float) ABS(i - j) / (float) cl);
}
for (j = 0; j < nVar; j++)
{
covarExp[j][i] += .5 * covar[i][i] *
exp(-(float) ABS(i - j) / (float) cl);
}
}
for (i = 0; i < nVar; i++)
for (j = 0; j < nVar; j++)
covar[i][j] = covarExp[i][j];
}
/* reseting */
for (i = 0; i < nVar * (nVar + 3) / 2 + 1; i++)
{
parm[i] = 0;
if (i < nVar)
{
work[i] = 0;
deviate[i] = 0;
}
}
/* input data for generating realization of the multivariate */
/* gaussian */
setgmn(mean, covar[0], nVar, parm);
seed1 = (long) seed; seed2 = (long) seed * seed;
setall(seed1, seed2);
/* generating the realization */
genmn(parm, deviate, work);
/* copying to buffer */
shift = 0;
shift1 = 0;
if (pWave)
{
for (j = 0; j < lim[0]; j++)
buffer[j] = alpha[j];
for (k = 0, j = lim[0]; j <= lim[1]; j++, k++)
buffer[j] = deviate[k];
for (j = lim[1]; j < nL + 1; j++)
buffer[j] = alpha[j];
shift = nL;
shift1 = nVar / nPar;
}
if (sWave)
{
for (j = 0; j < lim[0]; j++)
buffer[j + shift] = beta[j];
for (k = 0, j = lim[0]; j <= lim[1]; j++, k++)
buffer[j + shift] = deviate[k + shift1];
for (j = lim[1]; j < nL + 1; j++)
buffer[j + shift] = beta[j];
shift += nL;
shift1 += nVar / nPar;
}
if (density)
{
for (j = 0; j < lim[0]; j++)
buffer[j + shift] = rho[j];
for (k = 0, j = lim[0]; j <= lim[1]; j++, k++)
buffer[j + shift] = deviate[k + shift1];
for (j = lim[1]; j < nL + 1; j++)
buffer[j + shift] = rho[j];
}
/* outputting */
fwrite(buffer, sizeof(float), nPar * (nL + 1), stdout);
}
