void taper_grad(float ** waveconv,float ** taper_coeff, float **srcpos, int nshots, int **recpos, int ntr, int sws)
{
/* extern variables */
extern float DH;
extern int FREE_SURF, NX, NY, NXG, NYG;
extern int NPROCX, NPROCY, MYID, POS[3];
extern FILE *FP;
/* local variables */
int i, j, h, ifw, ii, jj, n, xb, yb, xe, ye, taperlength,taperlength2, VTON, SRTON;
int ijc, iy, ix, iii, jjj, xx, yy, srctaper_gridpt, i1, j1;
extern int GRADT1, GRADT2, GRADT3, GRADT4;
float amp, a, *window, grad_tap, **waveconvtmp;
char modfile[STRING_SIZE];
extern float SRTRADIUS;
extern int SRTSHAPE, FILTSIZE;
float **m, **edgemat, **mm, **msum, minm, maxm, x, y, rad, **taper_coeff_glob;
float maxrad;
float EXP_TAPER_GRAD_HOR;
FILE *fp_taper;
/*SRTSHAPE=2;
SRTRADIUS=25.0;
filtsize=2;*/
EXP_TAPER_GRAD_HOR = 2.0; /* TAPER TEST */
/* =============== */
/* Vertical taper */
/* =============== */
if(sws==1){
/* define taper geometry */
taperlength=GRADT2-GRADT1;
taperlength2=GRADT4-GRADT3;
ifw = GRADT4-GRADT1;
/*printf("%d \t %d \t %d \t %d \n",GRADT1, GRADT2, GRADT3, GRADT4);
printf("%d \t %d \t %d \n",taperlength, taperlength2,ifw);*/
if (MYID==0)
{
fprintf(FP,"\n **Message from taper_grad (printed by PE %d):\n",MYID);
fprintf(FP," Coefficients for gradient taper are now calculated.\n");
}
waveconvtmp = matrix(0,NY+1,0,NX+1);
window=vector(1,ifw);
/* Gaussian window */
a=3; /* damping coefficient */
for (i=1;i<=ifw;i++){
window[i] = 1.0;
if(i<=taperlength){
window[i] = exp(-(1.0/2.0)*(a*(i-taperlength)/(taperlength/2.0))*(a*(i-taperlength)/(taperlength/2.0)));
}
if(i>=(ifw-taperlength2)){
window[i] = exp(-(1.0/2.0)*(a*(i-(ifw-taperlength2))/(taperlength2/2.0))*(a*(i-(ifw-taperlength2))/(taperlength2/2.0)));
}
}
/* loop over global grid */
for (j=1;j<=NYG;j++){
h=1;
for (i=1;i<=NXG;i++){
grad_tap=0.0;
if((i>GRADT1)&&(i<GRADT4)){
grad_tap=window[h];
h++;
}
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
taper_coeff[jj][ii]=grad_tap;
}
}
}
/* apply taper on local gradient */
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i]*=taper_coeff[j][i];
waveconvtmp[j][i] = waveconv[j][i];
}
}
/* apply filter at shot and receiver points */
for (n=1;n<=nshots;n++)
{
i = iround(srcpos[1][n]/DH);
j = iround(srcpos[2][n]/DH);
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii = i-POS[1]*NX;
jj = j-POS[2]*NY;
/*waveconvtmp[jj][ii] = 1*waveconv[jj][ii]
+ 8*(waveconv[jj-1][ii] + waveconv[jj+1][ii] + waveconv[jj][ii-1] + waveconv[jj][ii+1])
+ 4*(waveconv[jj-1][ii-1] + waveconv[jj-1][ii+1] + waveconv[jj+1][ii+1] + waveconv[jj+1][ii-1]);
waveconvtmp[jj][ii] = waveconvtmp[jj][ii]/49;*/
waveconvtmp[jj][ii] = 0.0;
}
}
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i] = waveconvtmp[j][i];
}
}
for (n=1;n<=ntr;n++)
{
i = recpos[1][n];
j = recpos[2][n];
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii = i-POS[1]*NX;
jj = j-POS[2]*NY;
/*waveconvtmp[jj][ii] = 1*waveconv[jj][ii]
+ 8*(waveconv[jj-1][ii] + waveconv[jj+1][ii] + waveconv[jj][ii-1] + waveconv[jj][ii+1])
+ 4*(waveconv[jj-1][ii-1] + waveconv[jj-1][ii+1] + waveconv[jj+1][ii+1] + waveconv[jj+1][ii-1]);
waveconvtmp[jj][ii] = waveconvtmp[jj][ii]/49;*/
waveconvtmp[jj][ii] = 0.0;
}
}
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i] = waveconvtmp[j][i];
}
}
sprintf(modfile,"taper_coeff_vert.bin");
writemod(modfile,taper_coeff,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
free_vector(window,1,ifw);
free_matrix(waveconvtmp,0,NX+1,0,NY+1);
}
/* ======================== */
/* Horizontal Taper */
/* ======================== */
if(sws==2){
/* define taper geometry */
taperlength=GRADT2-GRADT1;
taperlength2=GRADT4-GRADT3;
ifw = GRADT2-GRADT1+1;
printf("%d \t %d \t %d \t %d \n",GRADT1, GRADT2, GRADT3, GRADT4);
printf("%d \t %d \t %d \n",taperlength, taperlength2,ifw);
if (MYID==0)
{
fprintf(FP,"\n **Message from taper_grid (printed by PE %d):\n",MYID);
fprintf(FP," Coefficients for gradient taper are now calculated.\n");
}
waveconvtmp = matrix(0,NY+1,0,NX+1);
window=vector(1,ifw);
/* Gaussian window */
a=3; /* damping coefficient */
for (i=1;i<=ifw;i++){
window[i] = 1.0;
if(i<=taperlength){
window[i] = exp(-(1.0/2.0)*(a*(i-taperlength)/(taperlength/2.0))*(a*(i-taperlength)/(taperlength/2.0)));
}
}
/* loop over global grid */
h=1;
for (j=1;j<=NYG;j++){
for (i=1;i<=NXG;i++){
grad_tap=0.0;
if((j>=GRADT1)&&(j<=GRADT2)){
grad_tap=window[h];
}
if(j>GRADT2){
/*grad_tap=((float)(j*DH))*((float)(j*DH))*((float)(j*DH));*/
/*grad_tap=((float)(j*DH))*((float)(j*DH));*/
/*grad_tap=(float)(j*DH);*/
/*grad_tap=((float)((j*DH)/(GRADT2*DH)));*/
/*grad_tap=1.0;*/
grad_tap=pow((float)(j*DH),EXP_TAPER_GRAD_HOR);
}
/*grad_tap=((float)(j*DH));*/
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
taper_coeff[jj][ii]=grad_tap;
}
}
if(j>=GRADT1){h++;}
}
/* apply taper on local gradient */
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i]*=taper_coeff[j][i];
waveconvtmp[j][i] = waveconv[j][i];
}
}
/* apply filter at shot and receiver points */
/*for (n=1;n<=nshots;n++)
{
i = iround(srcpos[1][n]/DH);
j = iround(srcpos[2][n]/DH);
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii = i-POS[1]*NX;
jj = j-POS[2]*NY;
waveconvtmp[jj][ii] = 1*waveconv[jj][ii]
+ 8*(waveconv[jj-1][ii] + waveconv[jj+1][ii] + waveconv[jj][ii-1] + waveconv[jj][ii+1])
+ 4*(waveconv[jj-1][ii-1] + waveconv[jj-1][ii+1] + waveconv[jj+1][ii+1] + waveconv[jj+1][ii-1]);
waveconvtmp[jj][ii] = waveconvtmp[jj][ii]/49;
}
}
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i] = waveconvtmp[j][i];
}
}
for (n=1;n<=ntr;n++)
{
i = recpos[1][n];
j = recpos[2][n];
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii = i-POS[1]*NX;
jj = j-POS[2]*NY;
waveconvtmp[jj][ii] = 1*waveconv[jj][ii]
+ 8*(waveconv[jj-1][ii] + waveconv[jj+1][ii] + waveconv[jj][ii-1] + waveconv[jj][ii+1])
+ 4*(waveconv[jj-1][ii-1] + waveconv[jj-1][ii+1] + waveconv[jj+1][ii+1] + waveconv[jj+1][ii-1]);
waveconvtmp[jj][ii] = waveconvtmp[jj][ii]/49;
}
}
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i] = waveconvtmp[j][i];
}
}*/
sprintf(modfile,"taper_coeff_hor.bin");
writemod(modfile,taper_coeff,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
free_vector(window,1,ifw);
free_matrix(waveconvtmp,0,NX+1,0,NY+1);
} /* end of sws==2 */
/* =================================== */
/* taper source and receiver positions */
/* =================================== */
if(sws==3) {
/* Convert from meters to gridpoints -> minimum 5x5 gridpoints */
srctaper_gridpt = (int)(ceil(2.0*SRTRADIUS/DH));
if (srctaper_gridpt<5) srctaper_gridpt = 5;
m = matrix(1,srctaper_gridpt,1,srctaper_gridpt);
edgemat = matrix(1,4,1,1);
mm = matrix(1,NYG,1,NXG);
msum = matrix(1,NYG,1,NXG);
taper_coeff_glob= matrix(1,NYG,1,NXG);
waveconvtmp = matrix(0,NY+1,0,NX+1);
for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++) msum[iy][ix] = 1.0;
MPI_Barrier(MPI_COMM_WORLD);
/*****************************/
/* Taper at source positions */
/*****************************/
a = 1.0;
maxrad = sqrt(2.0*SRTRADIUS*SRTRADIUS);
for (j=1;j<=srctaper_gridpt;j++) {
for (i=1;i<=srctaper_gridpt;i++) {
x = ((float)i-((float)srctaper_gridpt)/2.0-0.5)*DH;
y = ((float)j-((float)srctaper_gridpt)/2.0-0.5)*DH;
rad = sqrt(x*x+y*y);
switch (SRTSHAPE) {
case 1:
m[j][i] = erf(a*rad/maxrad);
break;
case 2:
if (rad>0) m[j][i] = log(rad);
else m[j][i] = 0.0;
break;
}
}
}
/* generate local taper matrix */
minm = minimum_m(m,srctaper_gridpt,srctaper_gridpt);
for (j=1;j<=srctaper_gridpt;j++)
for (i=1;i<=srctaper_gridpt;i++) m[j][i] -= minm;
/* normalize taper matrix to max of values at the centre of all 4 taper area edges, */
/* not the global maximum, which is located at the corners */
edgemat[1][1] = m[1][srctaper_gridpt/2];
edgemat[2][1] = m[srctaper_gridpt/2][1];
edgemat[3][1] = m[srctaper_gridpt/2][srctaper_gridpt];
edgemat[4][1] = m[srctaper_gridpt][srctaper_gridpt/2];
maxm = maximum_m(edgemat,1,4);
for (j=1;j<=srctaper_gridpt;j++)
for (i=1;i<=srctaper_gridpt;i++) {
m[j][i] /= maxm;
if (m[j][i]>1.0) m[j][i] = 1.0;
}
/* get central position within the taper */
ijc = (int)(ceil((float)srctaper_gridpt/2));
/*********************/
/* loop over sources */
for (n=1;n<=nshots;n++) {
for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++) mm[iy][ix] = 1.0;
i = iround(srcpos[1][n]/DH);
j = iround(srcpos[2][n]/DH);
for (iy=1;iy<=srctaper_gridpt;iy++) {
for (ix=1;ix<=srctaper_gridpt;ix++) {
xx = i + ix - ijc;
yy = j + iy - ijc;
if ((xx<1) || (xx>NXG) || (yy<1) || (yy>NYG)) continue;
mm[yy][xx] = m[iy][ix];
}
}
/* for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++) msum[iy][ix] += mm[iy][ix];
*/
for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++)
if (msum[iy][ix] > mm[iy][ix])
msum[iy][ix] = mm[iy][ix];
}
/***********************/
/* loop over receivers */
/*for (n=1;n<=ntr;n++) {
for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++) mm[iy][ix] = 1.0;
i = recpos[1][n];
j = recpos[2][n];
for (iy=1;iy<=srctaper_gridpt;iy++) {
for (ix=1;ix<=srctaper_gridpt;ix++) {
xx = i + ix - ijc;
yy = j + iy - ijc;
if ((xx<1) || (xx>NXG) || (yy<1) || (yy>NYG)) continue;
mm[yy][xx] = m[iy][ix];
}
}*/
/* for (iy=1;iy<=NYG;iy++) Die kommenden zwei Zeilen wurden von Daniel auskommentiert.
for (ix=1;ix<=NXG;ix++) msum[iy][ix] += mm[iy][ix];
*/
/* for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++)
if (msum[iy][ix] > mm[iy][ix])
msum[iy][ix] = mm[iy][ix];
}*/
minm = minimum_m(msum,NXG,NYG);
for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++) msum[iy][ix] -= minm;
maxm = maximum_m(msum,NXG,NYG);
for (iy=1;iy<=NYG;iy++)
for (ix=1;ix<=NXG;ix++) {
taper_coeff_glob[iy][ix] = msum[iy][ix]/maxm;
if ((POS[1]==((ix-1)/NX)) && (POS[2]==((iy-1)/NY))){
ii = ix-POS[1]*NX;
jj = iy-POS[2]*NY;
/*Diese Zeile wurde von Daniel auskommentiert: taper_coeff[jj][ii] = taper_coeff_glob[iy][ix] * ((float)(iy*DH));*/
/*taper_coeff[jj][ii] = ((float)(iy*DH)) * ((float)(iy*DH)) * ((float)(iy*DH));*/
taper_coeff[jj][ii]=msum[iy][ix]/maxm;
}
}
/* apply taper on local gradient */
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i]*=taper_coeff[j][i];
waveconvtmp[j][i] = waveconv[j][i];
}
}
/* apply filter at shot and receiver points */
for (n=1;n<=nshots;n++)
{
i1 = iround(srcpos[1][n]/DH);
j1 = iround(srcpos[2][n]/DH);
for (i=i1-FILTSIZE;i<=i1+FILTSIZE;i++){
for (j=j1-FILTSIZE;j<=j1+FILTSIZE;j++){
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii = i-POS[1]*NX;
jj = j-POS[2]*NY;
/*waveconvtmp[jj][ii] = 1*waveconv[jj][ii]
+ 8*(waveconv[jj-1][ii] + waveconv[jj+1][ii] + waveconv[jj][ii-1] + waveconv[jj][ii+1])
+ 4*(waveconv[jj-1][ii-1] + waveconv[jj-1][ii+1] + waveconv[jj+1][ii+1] + waveconv[jj+1][ii-1]);
waveconvtmp[jj][ii] = waveconvtmp[jj][ii]/49;*/
if (jj>0){
waveconvtmp[jj][ii] = 0.0;
taper_coeff[jj][ii] = 0.0;
}
}
}
}
}
/*for (n=1;n<=ntr;n++)
{
i1 = recpos[1][n];
j1 = recpos[2][n];
for (i=i1-FILTSIZE;i<=i1+FILTSIZE;i++){
for (j=j1-FILTSIZE;j<=j1+FILTSIZE;j++){
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii = i-POS[1]*NX;
jj = j-POS[2]*NY; */
/* Die kommenden 4 Zeilen wurden von Daniel auskommentiert. waveconvtmp[jj][ii] = 1*waveconv[jj][ii]
+ 8*(waveconv[jj-1][ii] + waveconv[jj+1][ii] + waveconv[jj][ii-1] + waveconv[jj][ii+1])
+ 4*(waveconv[jj-1][ii-1] + waveconv[jj-1][ii+1] + waveconv[jj+1][ii+1] + waveconv[jj+1][ii-1]);
waveconvtmp[jj][ii] = waveconvtmp[jj][ii]/49;*/
/* waveconvtmp[jj][ii] = 0.0;
}
}
}
}*/
/* apply taper on local gradient */
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i] = waveconvtmp[j][i];
}
}
free_matrix(m,1,srctaper_gridpt,1,srctaper_gridpt);
free_matrix(edgemat,1,4,1,1);
free_matrix(mm,1,NYG,1,NXG);
free_matrix(msum,1,NYG,1,NXG);
free_matrix(taper_coeff_glob,1,NYG,1,NXG);
free_matrix(waveconvtmp,0,NX+1,0,NY+1);
MPI_Barrier(MPI_COMM_WORLD);
sprintf(modfile,"taper_coeff_sources.bin");
writemod(modfile,taper_coeff,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
}
/* ======================== */
/* Read Taper from file */
/* ======================== */
if((sws>=4)&&(sws<=6)){
if (MYID==0)
{
fprintf(FP,"\n **Message from taper_grid (printed by PE %d):\n",MYID);
fprintf(FP," Coefficients for gradient taper are now calculated.\n");
}
if(sws==4){fp_taper=fopen("taper.bin","r");}
if(sws==5){fp_taper=fopen("taper_u.bin","r");}
if(sws==6){fp_taper=fopen("taper_rho.bin","r");}
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
fread(&grad_tap, sizeof(float), 1, fp_taper);
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
taper_coeff[jj][ii]=grad_tap;
}
}
}
for (j=1;j<=NY;j++){
for (i=1;i<=NX;i++){
waveconv[j][i]*=taper_coeff[j][i];
}
}
fclose(fp_taper);
sprintf(modfile,"taper_coeff_file.bin");
writemod(modfile,taper_coeff,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
}
}
void model_elastic(float ** rho, float ** pi, float ** u){
/*--------------------------------------------------------------------------*/
/* extern variables */
extern int NX, NY, NXG, NYG, POS[3], L, MYID;
extern char MFILE[STRING_SIZE];
extern char INV_MODELFILE[STRING_SIZE];
extern float DH;
/* local variables */
float vp, vs, rhov, grad1, grad2, grad3, y;
int i, j, ii, jj;
char modfile[STRING_SIZE];
/* parameters for layer 1 */
const float vp1=500.0, vs1=300.0, rho1=1800.0, h=15.0;
/* parameters for layer 2 due to calculation of grad1, grad2 and grad3*/
const float vp2=1200.0, vs2=700.0, rho2=2000.0;
/*-----------------------------------------------------------------------*/
y=h/DH;
if(y==NYG) err(" \n y is equal NYG !! see src/model_grad.c \n ");
grad1=(vp2-vp1)/y;
grad2=(vs2-vs1)/y;
grad3=(rho2-rho1)/y;
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
if(j<=y){
vp=vp1+(j*grad1);
vs=vs1+(j*grad2);
rhov=rho1+(j*grad3);
}
else{
vp=vp2;
vs=vs2;
rhov=rho2;
}
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
u[jj][ii]=vs;
rho[jj][ii]=rhov;
pi[jj][ii]=vp;
}
}
}
sprintf(modfile,"%s_rho_it_0.bin",INV_MODELFILE);
writemod(modfile,rho,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vs_it_0.bin",INV_MODELFILE);
writemod(modfile,u,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vp_it_0.bin",INV_MODELFILE);
writemod(modfile,pi,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
}
void model_elastic_TTI(float ** rho, float ** c11, float ** c13, float ** c33, float ** c44, float ** theta){
/*--------------------------------------------------------------------------*/
/* global variables */
extern int NX, NY, NXG, NYG, POS[3], MYID;
extern char MFILE[STRING_SIZE], INV_MODELFILE[STRING_SIZE];
extern float DH;
/* local variables */
int i, j, ii, jj;
char filename[STRING_SIZE];
float y;
/* anisotropic parameters in the layers */
float vp0, vsv, rhoh, delta, epsilon, thetah;
/* 1st layer: isotropic acoustic water layer */
float vp01 = 1500.0, vsv1 = 0.0, rhoh1 = 1000.0, delta1 = 0.0, epsilon1 = 0.0, thetah1 = 0.0;
/* 2nd layer: anisotropic VTI medium */
float vp02 = 1800.0, vsv2 = 1040.0, rhoh2 = 2000.0, delta2 = 0.0, epsilon2 = 0.0, thetah2 = 0.0;
/* 3rd layer: anisotropic TTI medium */
float vp03 = 2200.0, vsv3 = 1270.0, rhoh3 = 2000.0, delta3 = 0.0, epsilon3 = 0.0, thetah3 = 0.0;
/* 4th layer: anisotropic TTI medium */
float vp04 = 2800.0, vsv4 = 1620.0, rhoh4 = 2000.0, delta4 = 0.0, epsilon4 = 0.0, thetah4 = 0.0;
/* transform Thomsen's parameters to elastic tensor components */
float c33h, c44h, c11h, c13h;
float d1=300.0, d2=450.0, d3=1100.0;
/*-----------------------------------------------------------------------*/
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
/* properties of the first layer */
vp0 = vp01; vsv = vsv1; rhoh = rhoh1; delta = delta1; epsilon = epsilon1; thetah = thetah1;
/* calculate depth */
y = j*DH;
if(y > d1){vp0 = vp02; vsv = vsv2; rhoh = rhoh2; delta = delta2; epsilon = epsilon2; thetah = thetah2;}
if(y > d2){vp0 = vp03; vsv = vsv3; rhoh = rhoh3; delta = delta3; epsilon = epsilon3; thetah = thetah3;}
if(y > d3){vp0 = vp04; vsv = vsv4; rhoh = rhoh4; delta = delta4; epsilon = epsilon4; thetah = thetah4;}
/* transform Thomsen's parameters to elastic tensor components */
c33h = rhoh * vp0 * vp0;
c44h = rhoh * vsv * vsv;
c11h = c33h * (1 + 2.0 * epsilon);
c13h = sqrt((c33h-c44h) * (c33h-c44h) + 2.0 * delta * c33h * (c33h - c44h)) - c44h;
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
c11[jj][ii]=c11h;
c13[jj][ii]=c13h;
c33[jj][ii]=c33h;
c44[jj][ii]=c44h;
theta[jj][ii]=thetah * M_PI / 180.0;
rho[jj][ii]=rhoh;
}
}
}
/* each PE writes his model to disk and PE 0 merges model files */
sprintf(filename,"%s.denise.c11",MFILE);
writemod(filename,c11,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename,3);
sprintf(filename,"%s.denise.c13",MFILE);
writemod(filename,c13,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename,3);
sprintf(filename,"%s.denise.c33",MFILE);
writemod(filename,c33,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename,3);
sprintf(filename,"%s.denise.c44",MFILE);
writemod(filename,c44,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename,3);
sprintf(filename,"%s.denise.theta",MFILE);
writemod(filename,theta,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename,3);
/* clean up temporary files */
MPI_Barrier(MPI_COMM_WORLD);
sprintf(filename,"%s.denise.c11.%i%i",MFILE,POS[1],POS[2]);
remove(filename);
sprintf(filename,"%s.denise.c13.%i%i",MFILE,POS[1],POS[2]);
remove(filename);
sprintf(filename,"%s.denise.c33.%i%i",MFILE,POS[1],POS[2]);
remove(filename);
sprintf(filename,"%s.denise.c44.%i%i",MFILE,POS[1],POS[2]);
remove(filename);
sprintf(filename,"%s.denise.theta.%i%i",MFILE,POS[1],POS[2]);
remove(filename);
}
void model(float ** rho, float ** pi, float ** u, float ** taus, float ** taup, float * eta){
/*--------------------------------------------------------------------------*/
/* extern variables */
extern int NX, NY, NXG, NYG, POS[3], L, MYID;
extern char MFILE[STRING_SIZE];
extern char INV_MODELFILE[STRING_SIZE];
extern float DH, *FL, TAU, DT;
/* local variables */
float vp, vs, rhov, ts, tp, muv, piv, *pts;
int i, j, ii, jj, l;
char modfile[STRING_SIZE];
FILE *flfile;
int nodes;
char cline[256];
float *fldepth, *flrho, *flvp, *flvs;
/*-----------------------------------------------------------------------*/
nodes=7;
fldepth=vector(1,nodes);
flrho=vector(1,nodes);
flvp=vector(1,nodes);
flvs=vector(1,nodes);
pts=vector(1,L);
for (l=1;l<=L;l++) {
pts[l]=1.0/(2.0*PI*FL[l]);
eta[l]=DT/pts[l];
}
/*read FL nodes from File*/
flfile=fopen("model_true/model4.fl.dat","r");
if (flfile==NULL) err(" FL-file could not be opened !");
for (l=1;l<=nodes;l++){
fgets(cline,255,flfile);
if (cline[0]!='#'){
sscanf(cline,"%f%f%f%f",&fldepth[l], &flrho[l], &flvp[l], &flvs[l]);
}
else l=l-1;
}
if(MYID==0){
printf(" ------------------------------------------------------------------ \n\n");
printf(" Information of FL nodes: \n\n");
printf(" \t depth \t rho \t vp \t vs \n\n");
for (l=1;l<=nodes;l++){
printf(" \t %f \t %f \t %f \t %f \n\n",fldepth[l],flrho[l],flvp[l],flvs[l]);
}
printf(" ------------------------------------------------------------------ \n\n");
}
/*-----------------------------------------------------------------------*/
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (l=1;l<nodes;l++){
for(j=(int)(fldepth[l]/DH)+1;j<=(int)(fldepth[l+1]/DH);j++){
vp=0.0;
vs=0.0;
rhov=0.0;
vp=(DH*(j-1)-fldepth[l])*(flvp[l+1]-flvp[l])/(fldepth[l+1]-fldepth[l])+flvp[l];
vp=vp*1000.0;
vs=(DH*(j-1)-fldepth[l])*(flvs[l+1]-flvs[l])/(fldepth[l+1]-fldepth[l])+flvs[l];
vs=vs*1000.0;
rhov=(DH*(j-1)-fldepth[l])*(flrho[l+1]-flrho[l])/(fldepth[l+1]-fldepth[l])+flrho[l];
rhov=rhov*1000.0;
muv=vs;
piv=vp;
ts=TAU;
tp=TAU;
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
u[jj][ii]=muv;
rho[jj][ii]=rhov;
pi[jj][ii]=piv;
taus[jj][ii]=ts;
taup[jj][ii]=tp;
}
}
for (j=(int)(fldepth[nodes]/DH)+1;j<=NYG;j++){
vp=0.0; vs=0.0; rhov=0.0;
vp=flvp[nodes]*1000.0; vs=flvs[nodes]*1000.0; rhov=flrho[nodes]*1000.0;
muv=vs;
piv=vp;
ts=TAU;
tp=TAU;
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
u[jj][ii]=muv;
rho[jj][ii]=rhov;
pi[jj][ii]=piv;
taus[jj][ii]=ts;
taup[jj][ii]=tp;
}
}
}
}
sprintf(modfile,"%s_rho_it_0.bin",INV_MODELFILE);
writemod(modfile,rho,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vs_it_0.bin",INV_MODELFILE);
writemod(modfile,u,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vp_it_0.bin",INV_MODELFILE);
writemod(modfile,pi,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
free_vector(fldepth,1,nodes);
free_vector(flrho,1,nodes);
free_vector(flvp,1,nodes);
free_vector(flvs,1,nodes);
free_vector(pts,1,L);
}
void model(float ** rho, float ** pi, float ** u,
float ** taus, float ** taup, float * eta){
/*--------------------------------------------------------------------------*/
/* extern variables */
extern float DT, *FL, TAU, DH;
extern int NX, NY, NXG, NYG, POS[3], L, MYID;
extern char MFILE[STRING_SIZE];
/* local variables */
float rhov, muv, piv, vp, vs, y;
float *pts, ts, tp, sumu, sumpi, ws;
int i, j, l, ii, jj;
char modfile[STRING_SIZE];
/* parameters for layer 1 */
const float vp1=500.0, vs1=300.0, rho1=1800.0, h=2.0;
/* parameters for layer 2 */
const float vp2=500.0, vs2=300.0, rho2=1800.0;
/*-----------------------------------------------------------------------*/
/* vector for maxwellbodies */
pts=vector(1,L);
for (l=1;l<=L;l++) {
pts[l]=1.0/(2.0*PI*FL[l]);
eta[l]=DT/pts[l];
}
ts=TAU;
tp=TAU;
ws=2.0*PI*FL[1];
sumu=0.0;
sumpi=0.0;
for (l=1;l<=L;l++){
sumu=sumu+((ws*ws*pts[l]*pts[l]*ts)/(1.0+ws*ws*pts[l]*pts[l]));
sumpi=sumpi+((ws*ws*pts[l]*pts[l]*tp)/(1.0+ws*ws*pts[l]*pts[l]));
}
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
y=(float)j*DH;
if (y<=h){
vp=vp1; vs=vs1; rhov=rho1; }
else{
vp=vp2; vs=vs2; rhov=rho2; }
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
taus[jj][ii]=ts;
taup[jj][ii]=tp;
u[jj][ii]=vs;
rho[jj][ii]=rhov;
pi[jj][ii]=vp;
}
}
}
/* each PE writes his model to disk */
sprintf(modfile,"%s.u",MFILE);
writemod(modfile,u,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
/*sprintf(modfile,"%s.pi",MFILE);
writemod(modfile,pi,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s.rho",MFILE);
writemod(modfile,rho,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s.taup",MFILE);
writemod(modfile,taup,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s.taus",MFILE);
writemod(modfile,taus,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);*/
free_vector(pts,1,L);
}
void model(float ** rho, float ** pi, float ** u, float ** taus, float ** taup, float * eta){
/*--------------------------------------------------------------------------*/
/* extern variables */
extern int NX, NY, NXG, NYG, POS[3], L, MYID;
extern char MFILE[STRING_SIZE];
extern char INV_MODELFILE[STRING_SIZE];
extern float DH, *FL, TAU, DT;
/* local variables */
float vp, vs, rhov, grad1, grad2, grad3, x, ts, tp, muv, piv, *pts, lkappa, lmu;
float Qp, Qs, Qpinv, llambda;
int i, j, ii, jj, l;
char modfile[STRING_SIZE];
/* parameters for homogenous half-space */
/* perfect model parameters */
float vp1=2700.0, vs1=1776.0, rho1=2120.0, Qmu=20.0, Qkappa=10000.0;
/*float vs2=1551.0;*/
float vs2=1400;
/* calculate lateral linear gradient */
float x1 = 0.208;
float b = vs1;
float a = (vs2-vs1)/(x1-DH);
/*-----------------------------------------------------------------------*/
pts=vector(1,L);
for (l=1;l<=L;l++) {
pts[l]=1.0/(2.0*PI*FL[l]);
eta[l]=DT/pts[l];
}
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
vp=vp1;
rhov=rho1;
/* x-coordinate on FD-grid */
x = i*DH;
/* calculate Vs */
vs = a*x + b;
if(x>=x1){vs = vs2;}
if(x<x1){vs = vs1;}
/* calculate kappa and mu*/
/*lmu=vs*vs*rhov;
llambda = rhov*(vp*vp*rhov - 2.0*lmu);
lkappa = llambda + ((2.0/3.0)*lmu);
Qpinv = (1.0/Qmu) + (lkappa/(lkappa+(4.0*lmu/3.0)))*((1.0/Qkappa)-(1.0/Qmu));
Qp = 1.0/Qpinv;*/
Qp = Qkappa;
Qs = Qmu;
ts=2.0/Qs;
tp=2.0/Qp;
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
u[jj][ii]=vs;
rho[jj][ii]=rhov;
pi[jj][ii]=vp;
taus[jj][ii]=ts;
taup[jj][ii]=tp;
}
}
}
sprintf(modfile,"%s_rho_it_0.bin",INV_MODELFILE);
writemod(modfile,rho,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vs_it_0.bin",INV_MODELFILE);
writemod(modfile,u,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vp_it_0.bin",INV_MODELFILE);
writemod(modfile,pi,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
free_vector(pts,1,L);
}
void model_elastic(float ** rho, float ** pi, float ** u){
/*--------------------------------------------------------------------------*/
/* extern variables */
extern float DT, DH;
extern int NX, NY, NXG, NYG, POS[3], MYID;
extern char MFILE[STRING_SIZE];
/* local variables */
float rhov, muv, piv, vp, vs, y, t, de, zplat1, zplat2, rplat;
float *pts, ts, tp, sumu, sumpi, ws, *ri, *d, *ti, *dl, *vsl, z, r;
float **checkp, **checks, **checkrho;
int i, j, l, ii, jj, nk, k, nl;
char filename_mu[STRING_SIZE];
char filename_rho[STRING_SIZE];
char filename_pi[STRING_SIZE];
sprintf(filename_mu,"%s.mu",MFILE);
sprintf(filename_rho,"%s.rho",MFILE);
sprintf(filename_pi,"%s.pi",MFILE);
/*-----------------------------------------------------------------------*/
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
y = j*DH;
vs = 1150.0;
vp = 2000.0;
rhov = 1800.0;
if(y<0.01){
vs = 2310.0;
vp = 4000.0;
rhov = 1800.0;
}
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) && (POS[2]==((j-1)/NY))){
ii = i-POS[1]*NX;
jj = j-POS[2]*NY;
u[jj][ii] = vs;
rho[jj][ii] = rhov;
pi[jj][ii] = vp;
}
}
}
/* each PE writes his model to disk */
writemod(filename_rho,rho,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename_rho,3);
/* each PE writes his model to disk */
writemod(filename_pi,pi,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename_pi,3);
/* each PE writes his model to disk */
writemod(filename_mu,u,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(filename_mu,3);
}
void model_elastic(float ** rho, float ** pi, float ** u){
/*--------------------------------------------------------------------------*/
/* extern variables */
extern float DH;
extern int NX, NY, NXG, NYG, POS[3], L, MYID;
extern char MFILE[STRING_SIZE];
extern char INV_MODELFILE[STRING_SIZE];
/* local variables */
float vp, vs, rhov, y;
int i, j, ii, jj;
/* parameters for layer 1 */
const float vp1=680.0, vs1=320.0, rho1=1700.0, h=3.0;
/* parameters for layer 2 */
const float vp2=1000.0, vs2=590.0, rho2=2000.0;
char modfile[STRING_SIZE];
/*-----------------------------------------------------------------------*/
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
/* calculate coordinate in m */
y=(float)j*DH;
/* two layer case */
if (y<=h){
vp=vp1; vs=vs1; rhov=rho1; }
else{
vp=vp2; vs=vs2; rhov=rho2; }
/*muv=vs1*vs1*rho1;
piv=vp1*vp1*rho1;
*/
/* only the PE which belongs to the current global gridpoint
is saving model parameters in his local arrays */
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
u[jj][ii]=vs;
rho[jj][ii]=rhov;
pi[jj][ii]=vp;
}
}
}
sprintf(modfile,"%s_rho_it_0.bin",INV_MODELFILE);
writemod(modfile,rho,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vs_it_0.bin",INV_MODELFILE);
writemod(modfile,u,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"%s_vp_it_0.bin",INV_MODELFILE);
writemod(modfile,pi,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
}
void model_elastic(float ** rho, float ** pi, float ** u){
/*--------------------------------------------------------------------------*/
FILE *FP1, *FP2, *FP3;
/* extern variables */
extern float DH;
extern int NX, NY, NXG, NYG, POS[3], MYID;
/* local variables */
float Rho, Vp, Vs, Vpnm1, x, y, undf, r;
float aund, ampund, FW, shiftx;
int i, j, ii, jj;
char modfile[STRING_SIZE];
/* parameters for background */
const float vp2=2000.0, vs2=vp2/sqrt(3.0), rho2=1000.0*0.31*pow(vp2,(1.0/4.0));
/* parameters for sphere 1 and 2 */
const float vp3=1500.0, vs3=vp3/sqrt(3.0), rho3=1000.0*0.31*pow(vp3,(1.0/4.0));
/* location of the spheres */
const float X01 = 80.0;
const float Y01 = 130.0;
/* radii of spheres */
float A0, A1, A3, A4, lambda0, lambda1, lambda3, lambda4;
float y0, y1, y2, y3, y4, y5, undy0, undy1, undy3, undy4;
lambda0=1600.0;
A0=50.0;
y0=1200.0;
lambda1=lambda0/2.0;
A1=100.0;
y1=1000.0;
y2=800.0;
lambda3=lambda0/2.0;
A3=150.0;
y3=600.0;
lambda4=lambda0/2.0;
A4=50.0;
y4=410.0;
y5=100.0;
FP1=fopen("/fastfs/koehn/DENISE_backup/par/start/crase_smooth_model_vp.dat","r");
FP2=fopen("/fastfs/koehn/DENISE_backup/par/start/crase_smooth_model_vs.dat","r");
FP3=fopen("/fastfs/koehn/DENISE_backup/par/start/crase_smooth_model_rho.dat","r");
/* loop over global grid */
for (i=1;i<=NXG;i++){
for (j=1;j<=NYG;j++){
fscanf(FP1,"%e\n",&Vp);
fscanf(FP2,"%e\n",&Vs);
fscanf(FP3,"%e\n",&Rho);
if ((POS[1]==((i-1)/NX)) &&
(POS[2]==((j-1)/NY))){
ii=i-POS[1]*NX;
jj=j-POS[2]*NY;
u[jj][ii]=Vs*Vs*Rho;
rho[jj][ii]=Rho;
pi[jj][ii] = Vp*Vp*Rho - 2.0 * u[jj][ii];
/*if(j==NYG){pi[jj][ii] = pi[jj-1][ii];}*/
}
}
}
/* each PE writes his model to disk */
sprintf(modfile,"model/waveform_test_model_u.bin");
writemod(modfile,u,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"model/waveform_test_model_pi.bin");
writemod(modfile,pi,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
sprintf(modfile,"model/waveform_test_model_rho.bin");
writemod(modfile,rho,3);
MPI_Barrier(MPI_COMM_WORLD);
if (MYID==0) mergemod(modfile,3);
fclose(FP1);
fclose(FP2);
fclose(FP3);
}
// USAGE FROM PYTHON: modelcomp(IF, nui, opts) (see Python code for info).
static PyObject *modelcomp(PyObject *self, PyObject *args)
{
void *status;
double totChi=0.0;
int i,j;
int nparsq = npar*npar;
/* Parse the input tuple */
if (!PyArg_ParseTuple(args, "iii",&cIF,&nui,&mode)){printf("FAILED modelcomp!\n"); fflush(stdout); return NULL;};
//printf("Setting memory %i \n",NCPU);
// Zero the workers memory:
for (i=0; i<NCPU; i++) {
for(j=0;j<nparsq;j++){WorkHess[i][j] = 0.0;};
for(j=0;j<npar;j++){WorkGrad[i][j] = 0.0;};
};
if (NCPU>1) {
/* Code for the case NCPU>1.
Define the workers and perform the parallel task. */
pthread_t MyThreads[NCPU];
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for (i=0; i<NCPU; i++){
// printf("Creating thread %i \n",i);
pthread_create(&MyThreads[i], &attr, writemod, (void *)&worker[i]);
};
pthread_attr_destroy(&attr);
for(i=0; i<NCPU; i++){
pthread_join(MyThreads[i], &status);
};
} else {
/* Case of one single process (NCPU=1).
Now, the master will do all the work. */
master.t0[cIF] = 0;
master.t1[cIF] = nt[cIF];
master.Iam = -1;
writemod((void *)&master);
};
/* Add-up the Chi square, the error vector, and the Hessian */
for (i=0 ; i<NCPU; i++) {
totChi += Chi2[i];
for (j=0;j<npar;j++){
Gradient[j] += WorkGrad[i][j];
};
for(j=0;j<nparsq;j++){
Hessian[j] += WorkHess[i][j];
};
};
/* Update references and set the return value */
PyObject *ret = Py_BuildValue("d", totChi);
return ret;
}
