float modeling() { /* declaration of variables */ FILE *fp; /* to report results */ int iF, iF1, iR, offset, iT1, iT2, iS, iProc, i, k; /* counters */ int wL; /* window length */ int die; /* die processor flag */ int FReceived; /* number of frequencies processed */ int apl_pid; /* PVM process id control */ int pid; /* process id */ int processControl; /* monitoring PVM start */ int FInfo[2]; /* frequency delimiters */ float wallcpu; /* wall clock time */ float oF; /* value of the objective function */ float residue; /* data residue */ float wdw; /* windowing purposes */ float *buffer, *bufferRCD; /* auxiliary buffers */ /* upgoing waves */ complex **dataS; /* synthethics in the frequency domain */ complex *bufferC; /* auxiliary buffer */ complex **freqPart; /* frequency arrays sent by the slaves */ /* Clean up log files */ CleanLog(); /* Reseting synchronization flags */ for (i = 0; i < nFreqPart; i++) { statusFreq[i][2] = 0; } /* allocating some memory */ dataS = alloc2complex(info->nF, info->nR); buffer = alloc1float(info->nSamples); bufferRCD = alloc1float(info->nSamples); bufferC = alloc1complex(info->nSamples / 2 + 1); freqPart = alloc2complex(info->nFreqProc, info->nR); /* reseting */ for (iF = 0; iF < info->nSamples / 2 + 1; iF++) bufferC[iF] = zeroC; for (iS = 0; iS < info->nSamples; iS++) { buffer[iS] = 0; bufferRCD[iS] = 0; } /* DD fprintf(stderr, "nF -> %d\n", info->nF);*/ fprintf(stderr, "Starting communication with PVM for modeling\n"); /* starting communication with PVM */ if ((apl_pid = pvm_mytid()) < 0) { pvm_perror("Error enrolling master process"); exit(-1); } processControl = CreateSlaves(processes, PROCESS_MODELING, nProc); if (processControl != nProc) { fprintf(stderr,"Problem starting PVM daemons\n"); exit(-1); } /* converting to velocities */ if (IMPEDANCE) { for (i = 0; i < info->nL + 1; i++) { alpha[i] /= rho[i]; beta[i] /= rho[i]; } } /* Broadcasting all processes common information */ BroadINFO(info, 1, processes, nProc, GENERAL_INFORMATION); /* sending all profiles */ BroadFloat(thick, info->nL + 1, processes, nProc, THICKNESS); BroadFloat(rho, info->nL + 1, processes, nProc, DENSITY); BroadFloat(alpha, info->nL + 1, processes, nProc, ALPHAS); BroadFloat(qP, info->nL + 1, processes, nProc, QALPHA); BroadFloat(beta, info->nL + 1, processes, nProc, BETAS); BroadFloat(qS, info->nL + 1, processes, nProc, QBETA); /* sending frequency partitions for each process */ for (iProc = 0; iProc < nProc; iProc++) { FInfo[0] = statusFreq[iProc][0]; FInfo[1] = statusFreq[iProc][1]; if (info->verbose) fprintf(stderr, "Master sending frequencies [%d, %d] out of %d to slave Modeling %d [id:%d]\n", FInfo[0], FInfo[1], info->nF, iProc, processes[iProc]); procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1]; SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS); statusFreq[iProc][2] = 1; } /* waiting modelled frequencies */ /* master process will send more frequencies if there's more work to do */ /* measuring elapsed time */ wallcpu = walltime(); /* reseting frequency counter */ FReceived = 0; while (FOREVER) { pid = RecvCplx(freqPart[0], info->nR * info->nFreqProc, -1, FREQUENCY_PARTITION); /* finding the frequency limits of this process */ /* DD fprintf(stderr, "Master finding the frequency limits of this process\n"); */ iProc = 0; while (pid != processes[iProc]) iProc++; /* DD fprintf(stderr, "iProc %d pid %d\n", iProc, pid);*/ /* copying into proper place of the total frequency array */ for (iR = 0; iR < info->nR; iR++) { for (k = 0, i = procInfo[iProc][0]; i <= procInfo[iProc][1]; i++, k++) { dataS[iR][i - initF] = freqPart[iR][k]; } } /* summing frequencies that are done */ FReceived += procInfo[iProc][1] - procInfo[iProc][0] + 1; if (info->verbose) fprintf(stderr, "Master received %d frequencies, remaining %d\n", FReceived, info->nF - FReceived); /* defining new frequency limits */ i = 0; while (i < nFreqPart && statusFreq[i][2]) i++; /* DD fprintf(stderr, "i %d nFreqPart %d\n", i, nFreqPart);*/ if (i < nFreqPart) { /* there is still more work to be done */ /* tell this process to not die */ die = 0; SendInt(&die, 1, processes[iProc], DIE); FInfo[0] = statusFreq[i][0]; FInfo[1] = statusFreq[i][1]; if (info->verbose) fprintf(stderr, "Master sending frequencies [%d, %d] to slave %d\n", FInfo[0], FInfo[1], processes[iProc]); procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1]; SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS); statusFreq[i][2] = 1; } else { /* tell this process to die since there is no more work to do */ if (info->verbose) fprintf(stderr, "Master ''killing'' slave %d\n", processes[iProc]); die = 1; SendInt(&die, 1, processes[iProc], DIE); } /* a check to get out the loop */ if (FReceived >= info->nF) break; } /* quitting PVM */ EndOfMaster(); /* getting elapsed time */ wallcpu = walltime() - wallcpu; fprintf(stderr, "Modeling wall clock time = %f seconds\n", wallcpu); /* back to impedances*/ if (IMPEDANCE) { for (i = 0; i < info->nL + 1; i++) { alpha[i] *= rho[i]; beta[i] *= rho[i]; } } /* computing the objective function for the time window */ for (oF = 0, residue = 0, iR = 0; iR < info->nR; iR++) { /* windowing as it was done to the input data */ iT1 = NINT(info->f1 / info->dF); iT2 = NINT(info->f2 / info->dF); wL = info->nF * PERC_WINDOW / 2; wL = 2 * wL + 1; for (iS = 0, iF = 0; iF < info->nSamples / 2 + 1; iF++) { if (iF < iT1 || iF >= iT2) { bufferC[iF] = cmplx(0, 0); } else if (iF - iT1 < (wL - 1) / 2) { wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) + .08 * cos(4 * PI * (float) iS / ((float) (wL - 1))); bufferC[iF].r = dataS[iR][iF - iT1].r * wdw; bufferC[iF].i = dataS[iR][iF - iT1].i * wdw; iS++; } else if (iF - iT1 >= info->nF - (wL - 1) / 2) { iS++; wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) + .08 * cos(4 * PI * (float) iS / ((float) (wL - 1))); bufferC[iF].r = dataS[iR][iF - iT1].r * wdw; bufferC[iF].i = dataS[iR][iF - iT1].i * wdw; } else { bufferC[iF] = dataS[iR][iF - iT1]; } } /* going to time domain */ /* DD fprintf(stderr, "going to time domain \n");*/ pfacr(1, info->nSamples, bufferC, buffer); /* muting ? */ if (MUTE) { for (iS = 0; iS <= NINT(t1Mute[iR] / dt); iS++) { buffer[iS] = 0; } } /* and computing data misfit and likelihood function */ iS = NINT(t1 / dt); for (iT1 = 0; iT1 < nDM; iT1++) { bufferRCD[iT1 + iS] = 0; for (offset = iT1, iT2 = 0; iT2 < nDM; iT2++) { bufferRCD[iT1 + iS] += (buffer[iT2 + iS] - dataObs[iR][iT2]) * CD[offset]; offset += MAX(SGN0(iT1 - iT2) * (nDM - 1 - iT2), 1); } oF += (buffer[iT1 + iS] - dataObs[iR][iT1]) * bufferRCD[iT1 + iS]; residue += (buffer[iT1 + iS] - dataObs[iR][iT1]) * (buffer[iT1 + iS] - dataObs[iR][iT1]); /* DD fprintf(stdout, "%d %f %f %f %f %f %d %f %f\n", nTotalSamples, oF, dt, auxm1, info->tau, residue, iT1, buffer[iT1], dataObs[iR][iT1 - NINT(t1 / dt)]); */ } /* windowing bufferRCD */ iT1 = NINT(t1 / dt); iT2 = NINT(t2 / dt); wL = nDM * PERC_WINDOW / 2; wL = 2 * wL + 1; for (iS = 0, iF = 0; iF < info->nSamples; iF++) { if (iF < iT1 || iF >= iT2) { bufferRCD[iF] = 0; } else if (iF - iT1 < (wL - 1) / 2) { wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) + .08 * cos(4 * PI * (float) iS / ((float) (wL - 1))); bufferRCD[iF] *= wdw; iS++; } else if (iF - iT1 >= nDM - (wL - 1) / 2) { iS++; wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) + .08 * cos(4 * PI * (float) iS / ((float) (wL - 1))); bufferRCD[iF] *= wdw; } } /* going back to Fourier domain */ pfarc(-1, info->nSamples, bufferRCD, bufferC); for (iF1 = 0, iF = NINT(info->f1 / info->dF); iF <= NINT(info->f2 / info->dF); iF++, iF1++) { resCD[iR][iF1] = bufferC[iF]; } } /* considering the .5 factor of the exponent of the Gaussian */ /* and normalizing the likelihood by the number of samples */ oF /= (2 * nTotalSamples); /* freeing some memory */ /* allocating some memory */ free2complex(dataS); free1float(buffer); free1float(bufferRCD); free1complex(bufferC); free2complex(freqPart); /* considering the regularizaton or model covariance term */ if (PRIOR) { auxm1 = 1. / (float) (numberPar * limRange); /* normalization */ for (auxm2 = 0, iF = 0; iF < limRange; iF++) { for (offset = iF, iF1 = 0; iF1 < limRange; iF1++) { if (vpFrechet) { auxm2 += (alpha[iF + lim[0]] - alphaMean[iF + lim[0]]) * CMvP[offset] * auxm1 * (alpha[iF1 + lim[0]] - alphaMean[iF1 + lim[0]]); } if (vsFrechet) { auxm2 += (beta[iF + lim[0]] - betaMean[iF + lim[0]]) * CMvS[offset] * auxm1 * (beta[iF1 + lim[0]] - betaMean[iF1 + lim[0]]); } if (rhoFrechet) { auxm2 += (rho[iF + lim[0]] - rhoMean[iF + lim[0]]) * CMrho[offset] * auxm1 * (rho[iF1 + lim[0]] - rhoMean[iF1 + lim[0]]); } offset += MAX(SGN0(iF - iF1) * (limRange - 1 - iF1), 1); } } } /* getting normalization factor */ fp = fopen("report", "a"); fprintf(fp,"-----------------------\n"); if (modCount == 0) { oFNorm = oF; fprintf(fp,">> Normalization constant for objective function: %f <<\n", oFNorm); } /* normalizing residue */ residue /= (nTotalSamples); if (!DATACOV && noiseVar == 0) noiseVar = residue / 10.; if (PRIOR) { fprintf(fp, "residue at iteration [%d] : Data residue variance %f , Noise variance %f , Likelihood %f , Prior %f\n", modCount, residue, noiseVar, oF / oFNorm, auxm2 / oFNorm); } else { fprintf(fp,"residue at iteration [%d] : Data residue variance %f , Noise variance %f , Likelihood %f , No Prior\n", modCount, residue, noiseVar, oF / oFNorm); } /* checking if we reached noise variance with the data residue */ if (residue / noiseVar <= 1) { /* DATA IS FIT, stop the procedure */ fprintf(fp, "[][][][][][][][][][][][][][][][][][][][]\n"); fprintf(fp, "DATA WAS FIT UP TO 1 VARIANCE!\n"); fprintf(fp, "[][][][][][][][][][][][][][][][][][][][]\n"); exit(0); } /* adding Likelihood and Prior */ if (PRIOR) oF += auxm2 / 2; fprintf(fp,"TOTAL residue at iteration [%d] : %f\n", modCount, oF / oFNorm); fprintf(fp,"-----------------------\n"); fclose(fp); /* returning objective function value */ return(oF / oFNorm); }
void gradient(float *grad) { /* declaration of variables */ int i, iF, iR, iProc, iDer, iL, iU, offset; /* counters */ int FReceived; /* number of frequencies processed */ int die; /* die processor flag */ int apl_pid; /* PVM process id control */ int pid; /* process id */ int masterId; /* master id */ int processControl; /* monitoring PVM start */ int FInfo[2]; /* frequency delimiters */ float wallcpu; /* wall clock time */ float *gradPart; /* partition of gradients */ complex **resCDPart; /* partition of resCD */ /* Clean up log files */ CleanLog(); /* Reseting synchronization flags */ for (i = 0; i < nFreqPart; i++) { statusFreq[i][2] = 0; } /* allocating some memory */ gradPart = alloc1float(numberPar * limRange); for (i = 0; i < numberPar * limRange; i++) { grad[i] = 0; } fprintf(stderr, "Starting communication with PVM for derivatives\n"); /* starting communication with PVM */ if ((apl_pid = pvm_mytid()) < 0) { pvm_perror("Error enrolling master process"); exit(-1); } processControl = CreateSlaves(processes, PROCESS_FRECHET, nProc); if (processControl != nProc) { fprintf(stderr,"Problem starting PVM daemons\n"); exit(-1); } /* converting to velocities */ if (IMPEDANCE) { for (i = 0; i < info->nL + 1; i++) { alpha[i] /= rho[i]; beta[i] /= rho[i]; } } /* Broadcasting all processes common information */ BroadINFO(info, 1, processes, nProc, GENERAL_INFORMATION); /* sending all profiles */ BroadFloat(thick, info->nL + 1, processes, nProc, THICKNESS); BroadFloat(rho, info->nL + 1, processes, nProc, DENSITY); BroadFloat(alpha, info->nL + 1, processes, nProc, ALPHAS); BroadFloat(qP, info->nL + 1, processes, nProc, QALPHA); BroadFloat(beta, info->nL + 1, processes, nProc, BETAS); BroadFloat(qS, info->nL + 1, processes, nProc, QBETA); /* sending frequency partitions for each process */ for (iProc = 0; iProc < nProc; iProc++) { FInfo[0] = statusFreq[iProc][0]; FInfo[1] = statusFreq[iProc][1]; if (info->verbose) fprintf(stderr, "Master sending frequencies [%d, %d] out of %d to slave Frechet %d [id:%d]\n", FInfo[0], FInfo[1], info->nF, iProc, processes[iProc]); procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1]; SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS); statusFreq[iProc][2] = 1; /* and sending the appropriate correlation chunk */ /* allocating some memory */ resCDPart = alloc2complex(FInfo[1] - FInfo[0] + 1, info->nR); for (iR = 0; iR < info->nR; iR++) { for (i = 0, iF = FInfo[0]; iF <= FInfo[1]; iF++, i++) { resCDPart[iR][i] = resCD[iR][iF - initF]; /* fprintf(stderr, "iR %d iF %d [%f %f]\n", iR, iF, resCDPart[iR][i].r, resCDPart[iR][i].i);*/ } } /* sending frequency partition to the slave process */ SendCplx(resCDPart[0], (FInfo[1] - FInfo[0] + 1) * info->nR, processes[iProc], COVARIANCE_PARTITION); free2complex(resCDPart); } /* waiting modelled frequencies */ /* master process will send more frequencies if there's more work to do */ /* measuring elapsed time */ wallcpu = walltime(); /* reseting frequency counter */ FReceived = 0; while (FOREVER) { pid = RecvFloat(gradPart, info->numberPar * info->limRange, -1, PARTIAL_GRADIENT); /* finding the frequency limits of this process */ /* DD fprintf(stderr, "Master finding the frequency limits of this process\n"); */ iProc = 0; while (pid != processes[iProc]) iProc++; /* stacking gradient */ for (i = 0; i < info->numberPar * info->limRange; i++) { grad[i] += gradPart[i]; /* DD fprintf(stderr, "i %d grad %f gradPart %f\n", i, grad[i], gradPart[i]);*/ } /* summing frequencies that are done */ FReceived += procInfo[iProc][1] - procInfo[iProc][0] + 1; if (info->verbose) fprintf(stderr, "Master received %d frequencies, remaining %d\n", FReceived, info->nF - FReceived); /* defining new frequency limits */ i = 0; while (i < nFreqPart && statusFreq[i][2]) i++; /* DD fprintf(stderr, "i %d nFreqPart %d\n", i, nFreqPart);*/ if (i < nFreqPart) { /* there is still more work to be done */ /* tell this process to not die */ die = 0; SendInt(&die, 1, processes[iProc], DIE); FInfo[0] = statusFreq[i][0]; FInfo[1] = statusFreq[i][1]; if (info->verbose) fprintf(stderr, "Master sending frequencies [%d, %d] to slave %d\n", FInfo[0], FInfo[1], processes[iProc]); procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1]; SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS); statusFreq[i][2] = 1; /* sending covariance partition */ /* allocating some memory */ resCDPart = alloc2complex(FInfo[1] - FInfo[0] + 1, info->nR); for (iR = 0; iR < info->nR; iR++) { for (i = 0, iF = FInfo[0]; iF <= FInfo[1]; iF++, i++) { resCDPart[iR][i] = resCD[iR][iF - initF]; } } /* sending frequency partition to the slave process */ SendCplx(resCDPart[0], (FInfo[1] - FInfo[0] + 1) * info->nR, processes[iProc], COVARIANCE_PARTITION); free2complex(resCDPart); } else { /* tell this process to die since there is no more work to do */ if (info->verbose) fprintf(stderr, "Master ''killing'' slave %d\n", processes[iProc]); die = 1; SendInt(&die, 1, processes[iProc], DIE); } /* a check to get out the loop */ if (FReceived >= info->nF) break; } /* getting elapsed time */ wallcpu = walltime() - wallcpu; fprintf(stderr, "Frechet derivative wall clock time = %f seconds\n\n", wallcpu); /* back to impedances*/ if (IMPEDANCE) { for (i = 0; i < info->nL + 1; i++) { alpha[i] *= rho[i]; beta[i] *= rho[i]; } } /* finally the gradient, the 2 is due Parseval */ for (iDer = 0; iDer < numberPar * limRange; iDer++) { grad[iDer] *= 2 / (float) (nTotalSamples * oFNorm); } /* getting gradient in impedance domain */ if (IMPEDANCE) { offset = 0; for (i = lim[0], iL = 0; iL < limRange; iL++, i++) { if (vpFrechet) { grad[iL] /= rho[i]; offset = limRange; } if (vsFrechet) { grad[iL + offset] /= rho[i]; offset += limRange; } if (rhoFrechet) { grad[iL + offset] = - alpha[i] * grad[iL] - beta[i] * grad[iL + limRange] + grad[iL + 2 * limRange]; } } } if (PRIOR) { auxm1 = 1. / (float) (numberPar * limRange); /* normalization */ /* considering the regularization or model covariance term */ for (i = 0; i < limRange; i++) { for (offset = i, iL = 0; iL < limRange; iL++) { iU = 0; if (vpFrechet) { grad[iL] += (alpha[i + lim[0]] - alphaMean[i + lim[0]]) * CMvP[offset] * auxm1; iU = limRange; /* used as offset in gradient vector */ } if (vsFrechet) { grad[iL + iU] += (beta[i + lim[0]] - betaMean[i + lim[0]]) * CMvS[offset] * auxm1; iU += limRange; } if (rhoFrechet) { grad[iL + iU] += (rho[i + lim[0]] - rhoMean[i + lim[0]]) * CMrho[offset] * auxm1; } offset += MAX(SGN0(i - iL) * (limRange - 1 - iL), 1); } } } /* normalizing gradient normalize(grad, numberPar * limRange);*/ /* freeing memory */ free1float(gradPart); }
main (int argc, char **argv) { /* declaration of variables */ FILE *fp; /* file pointer */ char *auxChar; /* auxiliar character */ char *modelFile = " "; /* elastic model file */ /* THICK - RHO - VP - QP - VS - QS */ int i, k, iProc, iR; /* counters */ int initF, lastF; /* initial and final frequencies */ int apl_pid; /* PVM process id control */ int nSamplesOrig; /* time series length */ int die; /* flag used to kill processes */ int pid; /* process id */ int nProc; /* number of processes */ int processControl; /* monitoring PVM start */ int *processes; /* array with process ids */ int FReceived; /* number of frequencies processed */ int nFreqProc; /* number of frequencies per process */ int nFreqPart; /* number of frequency partitions */ int **statusFreq; /* monitors processed frequencies */ int FInfo[2]; /* frequency delimiters */ int **procInfo; /* frequency limits for each processor */ float wallcpu; /* wall clock time */ float dt; /* time sampling interval */ float f; /* current frequency */ float fR; /* reference frequency */ float tMax; /* maximum recording time */ float *thick, *alpha, *beta, *rho, *qP, *qS; /* elastic constants and thickness */ complex **freqPart; /* frequency arrays sent by the slaves */ complex **uRF, **uZF; /* final frequency components */ INFO info[1]; /* basic information for slaves */ /* Logging information */ /* CleanLog(); */ /* getting input */ initargs(argc, argv); requestdoc(0); if (!getparstring("model", &modelFile)) modelFile = "model"; if (!getparstring("recfile", &auxChar)) auxChar = " "; sprintf(info->recFile, "%s", auxChar); if (!getparint("directwave", &info->directWave)) info->directWave = 1; if (!getparfloat("r1", &info->r1)) info->r1 = 0; if (!getparint("nr", &info->nR)) info->nR = 148; if (!getparfloat("dr", &info->dR)) info->dR = .025; if (!getparfloat("zs", &info->zs)) info->zs = 0.001; if (info->zs <= 0) info->zs = 0.001; if (!getparfloat("u1", &info->u1)) info->u1 = 0.0002; if (!getparfloat("u2", &info->u2)) info->u2 = 1.; if (!getparint("nu", &info->nU)) info->nU = 1000; if (!getparfloat("f1", &info->f1)) info->f1 = 2; if (!getparfloat("f2", &info->f2)) info->f2 = 50; if (!getparfloat("dt", &dt)) dt = 0.004; if (!getparfloat("tmax", &tMax)) tMax = 8; if (!getparfloat("F1", &info->F1)) info->F1 = 0; if (!getparfloat("F2", &info->F2)) info->F2 = 0; if (!getparfloat("F3", &info->F3)) info->F3 = 1; if (!getparint("hanning", &info->hanningFlag)) info->hanningFlag = 0; if (!getparfloat("wu", &info->percU)) info->percU = 5; info->percU /= 100; if (!getparfloat("ww", &info->percW)) info->percW = 5; info->percW /= 100; if (!getparfloat("fr", &fR)) fR = 1; info->wR = 2 * PI * fR; if (!getparfloat("tau", &info->tau)) info->tau = 50; if (!getparint("nproc", &nProc)) nProc = 1; if (!getparint("nfreqproc", &nFreqProc) || nProc == 1) nFreqProc = 0; if (!getparint("verbose", &info->verbose)) info->verbose = 0; /* how many layers */ fp = fopen(modelFile,"r"); if (fp == NULL) err("No model file!\n"); info->nL = 0; while (fscanf(fp, "%f %f %f %f %f %f\n", &f, &f, &f, &f, &f, &f) != EOF) info->nL++; info->nL--; fclose(fp); if (info->verbose) fprintf(stderr,"Number of layers in model %s : %d\n", modelFile, info->nL + 1); /* if specific geometry, count number of receivers */ fp = fopen(info->recFile, "r"); if (fp != NULL) { info->nR = 0; while (fscanf(fp, "%f\n", &f) != EOF) info->nR++; } fclose(fp); /* memory allocation */ alpha = alloc1float(info->nL + 1); beta = alloc1float(info->nL + 1); rho = alloc1float(info->nL + 1); qP = alloc1float(info->nL + 1); qS = alloc1float(info->nL + 1); thick = alloc1float(info->nL + 1); processes = alloc1int(nProc); procInfo = alloc2int(2, nProc); /* reading the file */ fp = fopen(modelFile,"r"); if (info->verbose) fprintf(stderr,"Thickness rho vP qP vS qS\n"); for (i = 0; i < info->nL + 1; i++) { fscanf(fp, "%f %f %f %f %f %f\n", &thick[i], &rho[i], &alpha[i], &qP[i], &beta[i], &qS[i]); if (info->verbose) fprintf(stderr," %7.4f %4.3f %3.2f %5.1f %3.2f %5.1f\n", thick[i], rho[i], alpha[i], qP[i], beta[i], qS[i]); } fclose(fp); /* computing frequency interval */ info->nSamples = NINT(tMax / dt) + 1; nSamplesOrig = info->nSamples; info->nSamples = npfar(info->nSamples); /* slowness increment */ info->dU = (info->u2 - info->u1) / (float) info->nU; /* computing more frequency related quatities */ tMax = dt * (info->nSamples - 1); info->dF = 1. / (tMax); f = info->dF; while (f < info->f1) f += info->dF; info->f1 = f; while (f < info->f2) f += info->dF; info->f2 = f; initF = NINT(info->f1 / info->dF); lastF = NINT(info->f2 / info->dF); info->nF = lastF - initF + 1; if (info->nF%2 == 0) { info->nF++; lastF++; } /* attenuation of wrap-around */ info->tau = log(info->tau) / tMax; if (info->tau > TAUMAX) info->tau = TAUMAX; if (info->verbose) fprintf(stderr, "Discrete frequency range to model: [%d, %d]\n", initF, lastF); if (nFreqProc == 0) nFreqProc = NINT((float) info->nF / (float) nProc + .5); else while (nFreqProc > info->nF) nFreqProc /= 2; nFreqPart = NINT((float) info->nF / (float) nFreqProc + .5); /* memory allocation for frequency arrays */ uRF = alloc2complex(info->nSamples / 2 + 1, info->nR); uZF = alloc2complex(info->nSamples / 2 + 1, info->nR); freqPart = alloc2complex(nFreqProc, info->nR); statusFreq = alloc2int(3, nFreqPart); /* defining frequency partitions */ for (k = initF, i = 0; i < nFreqPart; i++, k += nFreqProc) { statusFreq[i][0] = k; statusFreq[i][1] = MIN(k + nFreqProc - 1, lastF); statusFreq[i][2] = 0; } if (info->verbose) fprintf(stderr, "Starting communication with PVM\n"); /* starting communication with PVM */ if ((apl_pid = pvm_mytid()) < 0) { err("Error enrolling master process"); /* exit(-1); */ } fprintf(stderr, "Starting %d slaves ... ", nProc); processControl = CreateSlaves(processes, PROCESS, nProc); if (processControl != nProc) { err("Problem starting Slaves (%s)\n", PROCESS); /* exit(-1); */ } fprintf(stderr, " Ready \n"); info->nFreqProc = nFreqProc; /* Broadcasting all processes common information */ BroadINFO(info, 1, processes, nProc, GENERAL_INFORMATION); if (info->verbose) { fprintf(stderr, "Broadcasting model information to all slaves\n"); fflush(stderr); } /* sending all profiles */ BroadFloat(thick, info->nL + 1, processes, nProc, THICKNESS); BroadFloat(rho, info->nL + 1, processes, nProc, DENSITY); BroadFloat(alpha, info->nL + 1, processes, nProc, ALPHA); BroadFloat(qP, info->nL + 1, processes, nProc, QALPHA); BroadFloat(beta, info->nL + 1, processes, nProc, BETA); BroadFloat(qS, info->nL + 1, processes, nProc, QBETA); /* freeing memory */ free1float(thick); free1float(rho); free1float(alpha); free1float(qP); free1float(beta); free1float(qS); /* sending frequency partitions for each process */ for (iProc = 0; iProc < nProc; iProc++) { FInfo[0] = statusFreq[iProc][0]; FInfo[1] = statusFreq[iProc][1]; if (info->verbose) { fprintf(stderr, "Master sending frequencies [%d, %d] out of %d to slave %d [id:%d]\n" ,FInfo[0], FInfo[1], info->nF, iProc, processes[iProc]); fflush(stderr); } procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1]; SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS); statusFreq[iProc][2] = 1; } /* waiting modelled frequencies */ /* master process will send more frequencies if there's more work to do */ /* measuring elapsed time */ wallcpu = walltime(); /* reseting frequency counter */ FReceived = 0; while (FOREVER) { pid = RecvCplx(freqPart[0], info->nR * nFreqProc, -1, FREQUENCY_PARTITION_VERTICAL); /* finding the frequency limits of this process */ iProc = 0; while (pid != processes[iProc]) iProc++; /* copying into proper place of the total frequency array */ for (iR = 0; iR < info->nR; iR++) { for (k = 0, i = procInfo[iProc][0]; i <= procInfo[iProc][1]; i++, k++) { uZF[iR][i] = freqPart[iR][k]; } } pid = RecvCplx(freqPart[0], info->nR * nFreqProc, -1, FREQUENCY_PARTITION_RADIAL); /* finding the frequency limits of this process */ iProc = 0; while (pid != processes[iProc]) iProc++; /* copying into proper place of the total frequency array */ for (iR = 0; iR < info->nR; iR++) { for (k = 0, i = procInfo[iProc][0]; i <= procInfo[iProc][1]; i++, k++) { uRF[iR][i] = freqPart[iR][k]; } } /* summing frequencies that are done */ FReceived += procInfo[iProc][1] - procInfo[iProc][0] + 1; if (info->verbose) fprintf(stderr, "Master received %d frequencies, remaining %d\n", FReceived, info->nF - FReceived); /* if (FReceived >= info->nF) break; */ /* defining new frequency limits */ i = 0; while (i < nFreqPart && statusFreq[i][2]) i++; if (i < nFreqPart) { /* there is still more work to be done */ /* tell this process to not die */ die = 0; SendInt(&die, 1, processes[iProc], DIE); FInfo[0] = statusFreq[i][0]; FInfo[1] = statusFreq[i][1]; if (info->verbose) fprintf(stderr, "Master sending frequencies [%d, %d] to slave %d\n", FInfo[0], FInfo[1], processes[iProc]); procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1]; SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS); statusFreq[i][2] = 1; } else { /* tell this process to die since there is no more work to do */ if (info->verbose) fprintf(stderr, "Master ''killing'' slave %d\n", processes[iProc]); die = 1; SendInt(&die, 1, processes[iProc], DIE); } /* a check to get out the loop */ if (FReceived >= info->nF) break; } if (info->verbose) fprintf(stderr, "Master ''killing'' remaining slaves\n"); /* getting elapsed time */ wallcpu = walltime() - wallcpu; fprintf(stderr, "Wall clock time = %f seconds\n", wallcpu); /* going to time domain */ memset( (void *) &trZ, (int) '\0', sizeof(trZ)); memset( (void *) &trR, (int) '\0', sizeof(trR)); trZ.dt = dt * 1000000; trZ.ns = nSamplesOrig; trR.dt = dt * 1000000; trR.ns = nSamplesOrig; /* z component */ for (iR = 0; iR < info->nR; iR++) { trZ.tracl = iR + 1; /* inverse FFT */ pfacr(1, info->nSamples, uZF[iR], trZ.data); for (i = 0; i < info->nSamples; i++) { /* compensating for the complex frequency */ trZ.data[i] *= exp(info->tau * i * dt); } puttr(&trZ); } /* r component */ for (iR = 0; iR < info->nR; iR++) { trR.tracl = info->nR + iR + 1; /* inverse FFT */ pfacr(1, info->nSamples, uRF[iR], trR.data); for (i = 0; i < info->nSamples; i++) { /* compensating for the complex frequency */ trR.data[i] *= exp(info->tau * i * dt); } puttr(&trR); } return(EXIT_SUCCESS); }