├── .gitignore
├── 2D_elastic_RTM
    ├── elastic_2D_kernel_2.cu
    ├── elastic_2D_kernel_3.cu
    ├── viscoelastic_equation.cu
    └── zzzzz
├── 3D_elastic_RTM
    ├── 3D_elastic_modeling_parameter
    ├── 3D_elastic_modeling_parameter_sh
    ├── 3D_elastic_modeling_typedef_struct
    ├── 3D_forward_or_back_together.cu
    ├── 3D_output_file.cu
    ├── 3D_zzzzz
    ├── log_old.txt
    ├── makefile
    ├── smooth_3d
    └── zzzzz
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | *.i
2 | *.ii
3 | *.gpu
4 | *.ptx
5 | *.cubin
6 | *.fatbin
7 | 


--------------------------------------------------------------------------------
/2D_elastic_RTM/elastic_2D_kernel_3.cu:
--------------------------------------------------------------------------------
  1 | __constant__ const int BDIMX3=32;
  2 | __constant__ const int BDIMY3=16;
  3 | __constant__ const int radius3=6;
  4 | __constant__ const float pai1=3.1415926;
  5 | 
  6 | __global__ void caculate_ex_amp_time(float *p_d,float *ex_amp_d,float *ex_time_d,int it,int dimx,int dimz)
  7 | {
  8 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
  9 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
 10 | 		int in_idx;
 11 | 
 12 | 		if(ix<dimx&&iz<dimz)
 13 | 		{
 14 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
 15 | 				ix=ix+radius;iz=iz+radius;
 16 | 				in_idx=ix*dimz+iz;
 17 | 			/*if(ex_amp_d[in_idx]<p_d[in_idx]) 
 18 | 				{			
 19 | 					ex_time_d[in_idx]=it;
 20 | 					ex_amp_d[in_idx]=p_d[in_idx];///////emphasize  fabs(p_d[in_idx]);
 21 | 				}*/
 22 | 			if(fabs(ex_amp_d[in_idx])<fabs(p_d[in_idx]))	
 23 | 				{
 24 | 					ex_time_d[in_idx]=it;
 25 | 					ex_amp_d[in_idx]=fabs(p_d[in_idx]);
 26 | 				}
 27 | 		}
 28 | }
 29 | 
 30 | __global__ void caculate_ex_amp_time_new(float *vxp_d,float *vzp_d,float *ex_amp_d,float *ex_time_d,int it,int dimx,int dimz)
 31 | {
 32 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
 33 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
 34 | 		int in_idx;
 35 | 
 36 | 		if(ix<dimx&&iz<dimz)
 37 | 		{
 38 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
 39 | 				ix=ix+radius;iz=iz+radius;
 40 | 				in_idx=ix*dimz+iz;
 41 | 
 42 | 			if(fabs(ex_amp_d[in_idx])<sqrt(vxp_d[in_idx]*vxp_d[in_idx]+vzp_d[in_idx]*vzp_d[in_idx]))	
 43 | 				{
 44 | 					ex_time_d[in_idx]=it;
 45 | 					ex_amp_d[in_idx]=sqrt(vxp_d[in_idx]*vxp_d[in_idx]+vzp_d[in_idx]*vzp_d[in_idx]);
 46 | 				}
 47 | 		}
 48 | }
 49 | 
 50 | __global__ void caculate_ex_tp_time_new(float *tp1_d,float *ex_amp_d,float *ex_tp_time_d,int it,int dimx,int dimz)
 51 | //caculate_ex_tp_time_new<<<dimGrid,dimBlock>>>(tp1_d,ex_amp_tp_d,ex_tp_time_d,it-wavelet_half,nx_append_radius,nz_append_radius);
 52 | {
 53 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
 54 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
 55 | 		int in_idx;
 56 | 
 57 | 		if(ix<dimx&&iz<dimz)
 58 | 		{
 59 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
 60 | 				ix=ix+radius;iz=iz+radius;
 61 | 				in_idx=ix*dimz+iz;
 62 | 
 63 | 			if(fabs(ex_amp_d[in_idx])<fabs(tp1_d[in_idx]))	
 64 | 				{
 65 | 					ex_tp_time_d[in_idx]=it;
 66 | 					ex_amp_d[in_idx]=tp1_d[in_idx];
 67 | 				}
 68 | 		}
 69 | }
 70 | 
 71 | __global__ void caculate_ex_x_z(float *ex_amp_x_d,float *ex_amp_z_d,float *vxp_d,float *vzp_d,float *ex_time_d,int it,int dimx,int dimz)
 72 | {
 73 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
 74 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
 75 | 		int in_idx;
 76 | 
 77 | 		if(ix<dimx&&iz<dimz)
 78 | 		{
 79 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
 80 | 				ix=ix+radius;iz=iz+radius;
 81 | 				in_idx=ix*dimz+iz;
 82 | 
 83 | 				if(it==ex_time_d[in_idx])
 84 | 				{
 85 | 					ex_amp_x_d[in_idx]=vxp_d[in_idx];
 86 | 					ex_amp_z_d[in_idx]=vzp_d[in_idx];
 87 | 				}
 88 | 		}
 89 | }
 90 | 
 91 | __global__ void caculate_ex_x_z_new(float *ex_amp_x_d,float *ex_amp_z_d,float *vxp_d,float *vzp_d,float *ex_time_d,int it,int dimx,int dimz)
 92 | {
 93 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
 94 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
 95 | 		int in_idx;
 96 | 
 97 | 		if(ix<dimx&&iz<dimz)
 98 | 		{
 99 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
100 | 				ix=ix+radius;iz=iz+radius;
101 | 				in_idx=ix*dimz+iz;
102 | 
103 | 				if(it==ex_time_d[in_idx])
104 | 				{
105 | 					ex_amp_x_d[in_idx]=vxp_d[in_idx];
106 | 					ex_amp_z_d[in_idx]=1.0*(vzp_d[in_idx+1]+vzp_d[in_idx-1]+vzp_d[in_idx+dimz]+vzp_d[in_idx-dimz])/4.0;
107 | 				}
108 | 		}
109 | }
110 | 
111 | __global__ void caculate_ex_angle(float *ex_angle1_d,float *angle_pp_d,float *ex_time_d,int it,int dimx,int dimz)
112 | {
113 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
114 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
115 | 		int in_idx;
116 | 
117 | 		if(ix<dimx&&iz<dimz)
118 | 		{
119 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
120 | 				ix=ix+radius;iz=iz+radius;
121 | 				in_idx=ix*dimz+iz;
122 | 
123 | 				if(it==ex_time_d[in_idx])
124 | 					ex_angle1_d[in_idx]=angle_pp_d[in_idx];
125 | 					/*{	
126 | 						if(angle_pp_d[in_idx]>0)	ex_angle1_d[in_idx]=int(angle_pp_d[in_idx]+0.5);
127 | 						if(angle_pp_d[in_idx]<=0)	ex_angle1_d[in_idx]=int(angle_pp_d[in_idx]-0.5);
128 | 					}*/
129 | 		}
130 | }
131 | 
132 | __global__ void caculate_ex_angle_pp_only_RTM(float *angle_pp_d,float *poyn_px_d,float *poyn_pz_d,float *ex_time_d,int it,int dimx,int dimz)
133 | {
134 | 		__shared__ float s_data1[BDIMY3+2*radius3][BDIMX3+2*radius3];
135 | 		__shared__ float s_data2[BDIMY3+2*radius3][BDIMX3+2*radius3];
136 | 
137 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
138 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
139 | 		int in_idx;
140 | 		double sumx=0.0,sumz=0.0;
141 | 		int m,n;
142 | 		
143 | 		int tx = threadIdx.x+radius3;
144 | 		int tz = threadIdx.y+radius3;
145 | 		s_data1[tz][tx]=0.0;
146 | 		s_data1[threadIdx.y][threadIdx.x]=0.0;
147 | 		s_data1[BDIMY3+2*radius3-1-threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
148 | 		s_data1[threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
149 | 		s_data1[BDIMY3+2*radius3-1-threadIdx.y][threadIdx.x]=0.0;
150 | 
151 | 		s_data2[tz][tx]=0.0;
152 | 		s_data2[threadIdx.y][threadIdx.x]=0.0;
153 | 		s_data2[BDIMY3+2*radius3-1-threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
154 | 		s_data2[threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
155 | 		s_data2[BDIMY3+2*radius3-1-threadIdx.y][threadIdx.x]=0.0;
156 | 
157 | 		if(ix<dimx&&iz<dimz)
158 | 		{
159 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
160 | 				ix=ix+radius;iz=iz+radius;
161 | 				in_idx=ix*dimz+iz;
162 | 
163 | 				__syncthreads();				
164 | 
165 | 				s_data1[tz][tx]=poyn_px_d[in_idx];
166 | 				s_data2[tz][tx]=poyn_pz_d[in_idx];
167 | 
168 | 				if(threadIdx.y<radius3)
169 | 				{
170 | 					s_data1[threadIdx.y][threadIdx.x]=poyn_px_d[in_idx-radius3-radius3*dimz];//up
171 | 					s_data1[threadIdx.y][threadIdx.x+2*radius3]=poyn_px_d[in_idx-radius3+radius3*dimz];//up
172 | 					s_data1[threadIdx.y+BDIMY3+radius3][threadIdx.x]=poyn_px_d[in_idx+BDIMY3-radius3*dimz];//down
173 | 					s_data1[threadIdx.y+BDIMY3+radius3][threadIdx.x+2*radius3]=poyn_px_d[in_idx+BDIMY3+radius3*dimz];//down
174 | 
175 | 
176 | 					s_data2[threadIdx.y][threadIdx.x]=poyn_pz_d[in_idx-radius3-radius3*dimz];//up
177 | 					s_data2[threadIdx.y][threadIdx.x+2*radius3]=poyn_pz_d[in_idx-radius3+radius3*dimz];//up
178 | 					s_data2[threadIdx.y+BDIMY3+radius3][threadIdx.x]=poyn_pz_d[in_idx+BDIMY3-radius3*dimz];//down
179 | 					s_data2[threadIdx.y+BDIMY3+radius3][threadIdx.x+2*radius3]=poyn_pz_d[in_idx+BDIMY3+radius3*dimz];//down
180 | 
181 | 				}
182 | 				if(threadIdx.x<radius3)
183 | 				{
184 | 					s_data1[tz][threadIdx.x]=poyn_px_d[in_idx-radius3*dimz];//g_input[in_idx-radius3];//left
185 | 					s_data1[tz][threadIdx.x+BDIMX3+radius3]=poyn_px_d[in_idx+BDIMX3*dimz];//g_input[in_idx+BDIMX3];//right
186 | 				
187 | 					s_data2[tz][threadIdx.x]=poyn_pz_d[in_idx-radius3*dimz];//g_input[in_idx-radius3];//left
188 | 					s_data2[tz][threadIdx.x+BDIMX3+radius3]=poyn_pz_d[in_idx+BDIMX3*dimz];//g_input[in_idx+BDIMX3];//right
189 | 				}
190 | 
191 | 				__syncthreads();
192 | ///note that  x/z
193 | //least_square size of scale	 
194 | 				if(it==ex_time_d[in_idx])
195 | 				{ 
196 | 				
197 | 					for(m=-2;m<=+2;m++)
198 | 						for(n=-2;n<=+2;n++)
199 | 							{
200 | 								sumx=sumx+1.0*s_data1[tz+m][tx+n]*s_data2[tz+m][tx+n];
201 | 
202 | 								sumz=sumz+1.0*s_data2[tz+m][tx+n]*s_data2[tz+m][tx+n];
203 | 							}
204 | 					if(sumz!=0)	angle_pp_d[in_idx]=float(atan(double(sumx*1.0/sumz)))*180/pai1;
205 | 				}
206 | 		}
207 | }
208 | 
209 | __global__ void caculate_ex_angle_rp_only_RTM(float *angle_pp_d,float *poyn_px_d,float *poyn_pz_d,float *ex_time_d,int it,int dimx,int dimz)
210 | //caculate_ex_angle_rp_only_RTM<<<dimGrid,dimBlock>>>(ex_angle_rpp_d,poyn_rpx_d,poyn_rpz_d,ex_time_d,it,nx_append_radius,nz_append_radius);
211 | {
212 | 		__shared__ float s_data1[BDIMY3+2*radius3][BDIMX3+2*radius3];
213 | 		__shared__ float s_data2[BDIMY3+2*radius3][BDIMX3+2*radius3];
214 | 
215 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
216 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
217 | 		int in_idx;
218 | 		double sumx=0.0,sumz=0.0;
219 | 		int m=0,n=0;
220 | 		
221 | 		int tx = threadIdx.x+radius3;
222 | 		int tz = threadIdx.y+radius3;
223 | 		s_data1[tz][tx]=0.0;
224 | 		s_data1[threadIdx.y][threadIdx.x]=0.0;
225 | 		s_data1[BDIMY3+2*radius3-1-threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
226 | 		s_data1[threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
227 | 		s_data1[BDIMY3+2*radius3-1-threadIdx.y][threadIdx.x]=0.0;
228 | 
229 | 		s_data2[tz][tx]=0.0;
230 | 		s_data2[threadIdx.y][threadIdx.x]=0.0;
231 | 		s_data2[BDIMY3+2*radius3-1-threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
232 | 		s_data2[threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
233 | 		s_data2[BDIMY3+2*radius3-1-threadIdx.y][threadIdx.x]=0.0;
234 | 
235 | 		if(ix<dimx&&iz<dimz)
236 | 		{
237 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
238 | 				ix=ix+radius;iz=iz+radius;
239 | 				in_idx=ix*dimz+iz;
240 | 
241 | 				__syncthreads();				
242 | 
243 | 				s_data1[tz][tx]=poyn_px_d[in_idx];
244 | 				s_data2[tz][tx]=poyn_pz_d[in_idx];
245 | 
246 | 				if(threadIdx.y<radius3)
247 | 				{
248 | 					s_data1[threadIdx.y][threadIdx.x]=poyn_px_d[in_idx-radius3-radius3*dimz];//up
249 | 					s_data1[threadIdx.y][threadIdx.x+2*radius3]=poyn_px_d[in_idx-radius3+radius3*dimz];//up
250 | 					s_data1[threadIdx.y+BDIMY3+radius3][threadIdx.x]=poyn_px_d[in_idx+BDIMY3-radius3*dimz];//down
251 | 					s_data1[threadIdx.y+BDIMY3+radius3][threadIdx.x+2*radius3]=poyn_px_d[in_idx+BDIMY3+radius3*dimz];//down
252 | 
253 | 					s_data2[threadIdx.y][threadIdx.x]=poyn_pz_d[in_idx-radius3-radius3*dimz];//up
254 | 					s_data2[threadIdx.y][threadIdx.x+2*radius3]=poyn_pz_d[in_idx-radius3+radius3*dimz];//up
255 | 					s_data2[threadIdx.y+BDIMY3+radius3][threadIdx.x]=poyn_pz_d[in_idx+BDIMY3-radius3*dimz];//down
256 | 					s_data2[threadIdx.y+BDIMY3+radius3][threadIdx.x+2*radius3]=poyn_pz_d[in_idx+BDIMY3+radius3*dimz];//down
257 | 
258 | 				}
259 | 				if(threadIdx.x<radius3)
260 | 				{
261 | 					s_data1[tz][threadIdx.x]=poyn_px_d[in_idx-radius3*dimz];//g_input[in_idx-radius3];//left
262 | 					s_data1[tz][threadIdx.x+BDIMX3+radius3]=poyn_px_d[in_idx+BDIMX3*dimz];//g_input[in_idx+BDIMX3];//right
263 | 				
264 | 					s_data2[tz][threadIdx.x]=poyn_pz_d[in_idx-radius3*dimz];//g_input[in_idx-radius3];//left
265 | 					s_data2[tz][threadIdx.x+BDIMX3+radius3]=poyn_pz_d[in_idx+BDIMX3*dimz];//g_input[in_idx+BDIMX3];//right
266 | 				}
267 | 
268 | 				__syncthreads();
269 | ///note that  x/z
270 | //least_square size of scale	 
271 | 				if(it==ex_time_d[in_idx])
272 | 				{ 
273 | 				
274 | 					for(m=-4;m<=+4;m++)
275 | 						for(n=-4;n<=+4;n++)
276 | 							{
277 | 								sumx=sumx+1.0*s_data1[tz+m][tx+n]*s_data2[tz+m][tx+n];
278 | 
279 | 								sumz=sumz+1.0*s_data2[tz+m][tx+n]*s_data2[tz+m][tx+n];
280 | 							}
281 | 					if(sumz!=0)	angle_pp_d[in_idx]=float(atan(double(sumx*1.0/sumz)))*180/pai1;
282 | 				}
283 | 		}
284 | }
285 | 
286 | __global__ void caculate_ex_angle_new(float *ex_angle_d,float *angle_pp_d,float *normal_angle_d,float *poyn_px_d,float *poyn_pz_d,float *ex_time_d,int it,int dimx,int dimz)
287 | {
288 | 		__shared__ float s_data1[BDIMY3+2*radius3][BDIMX3+2*radius3];
289 | 		__shared__ float s_data2[BDIMY3+2*radius3][BDIMX3+2*radius3];
290 | 
291 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
292 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
293 | 		int in_idx;
294 | 		double sumx=0.0,sumz=0.0;
295 | 		int m,n;
296 | 		
297 | 		int tx = threadIdx.x+radius3;
298 | 		int tz = threadIdx.y+radius3;
299 | 		s_data1[tz][tx]=0.0;
300 | 		s_data1[threadIdx.y][threadIdx.x]=0.0;
301 | 		s_data1[BDIMY3+2*radius3-1-threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
302 | 		s_data1[threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
303 | 		s_data1[BDIMY3+2*radius3-1-threadIdx.y][threadIdx.x]=0.0;
304 | 
305 | 		s_data2[tz][tx]=0.0;
306 | 		s_data2[threadIdx.y][threadIdx.x]=0.0;
307 | 		s_data2[BDIMY3+2*radius3-1-threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
308 | 		s_data2[threadIdx.y][BDIMX3+2*radius3-1-threadIdx.x]=0.0;
309 | 		s_data2[BDIMY3+2*radius3-1-threadIdx.y][threadIdx.x]=0.0;
310 | 
311 | 		if(ix<dimx&&iz<dimz)
312 | 		{
313 | 				dimx=dimx+2*radius;dimz=dimz+2*radius;
314 | 				ix=ix+radius;iz=iz+radius;
315 | 				in_idx=ix*dimz+iz;
316 | 
317 | 				__syncthreads();				
318 | 
319 | 				s_data1[tz][tx]=poyn_px_d[in_idx];
320 | 				s_data2[tz][tx]=poyn_pz_d[in_idx];
321 | 
322 | 				if(threadIdx.y<radius3)
323 | 				{
324 | 					s_data1[threadIdx.y][threadIdx.x]=poyn_px_d[in_idx-radius3-radius3*dimz];//up
325 | 					s_data1[threadIdx.y][threadIdx.x+2*radius3]=poyn_px_d[in_idx-radius3+radius3*dimz];//up
326 | 
327 | 					s_data1[threadIdx.y+BDIMY3+radius3][threadIdx.x]=poyn_px_d[in_idx+BDIMY3-radius3*dimz];//down
328 | 					s_data1[threadIdx.y+BDIMY3+radius3][threadIdx.x+2*radius3]=poyn_px_d[in_idx+BDIMY3+radius3*dimz];//down
329 | 
330 | 					s_data2[threadIdx.y][threadIdx.x]=poyn_pz_d[in_idx-radius3-radius3*dimz];//up
331 | 					s_data2[threadIdx.y][threadIdx.x+2*radius3]=poyn_pz_d[in_idx-radius3+radius3*dimz];//up
332 | 					s_data2[threadIdx.y+BDIMY3+radius3][threadIdx.x]=poyn_pz_d[in_idx+BDIMY3-radius3*dimz];//down
333 | 					s_data2[threadIdx.y+BDIMY3+radius3][threadIdx.x+2*radius3]=poyn_pz_d[in_idx+BDIMY3+radius3*dimz];//down
334 | 
335 | 				}
336 | 				if(threadIdx.x<radius3)
337 | 				{
338 | 					s_data1[tz][threadIdx.x]=poyn_px_d[in_idx-radius3*dimz];//g_input[in_idx-radius3];//left
339 | 					s_data1[tz][threadIdx.x+BDIMX3+radius3]=poyn_px_d[in_idx+BDIMX3*dimz];//g_input[in_idx+BDIMX3];//right
340 | 				
341 | 					s_data2[tz][threadIdx.x]=poyn_pz_d[in_idx-radius3*dimz];//g_input[in_idx-radius3];//left
342 | 					s_data2[tz][threadIdx.x+BDIMX3+radius3]=poyn_pz_d[in_idx+BDIMX3*dimz];//g_input[in_idx+BDIMX3];//right
343 | 				}
344 | 
345 | 				__syncthreads();
346 | ///note that  x/z
347 | //least_square size of scale	 
348 | 				if(it==ex_time_d[in_idx])
349 | 				{ 
350 | 				
351 | 					for(m=-2;m<=+2;m++)
352 | 						for(n=-2;n<=+2;n++)
353 | 							{
354 | 								sumx=sumx+1.0*s_data1[tz+m][tx+n]*s_data2[tz+m][tx+n];
355 | 
356 | 								sumz=sumz+1.0*s_data2[tz+m][tx+n]*s_data2[tz+m][tx+n];
357 | 							}
358 | 					if(sumz!=0)	angle_pp_d[in_idx]=float(atan(double(sumx*1.0/sumz)))*180/pai1;	
359 | 					
360 | 					ex_angle_d[in_idx]=angle_pp_d[in_idx]-normal_angle_d[in_idx];
361 | 
362 | 				}
363 | 		}
364 | }
365 | 
366 | __global__ void imaging_ex(float *rimageup1_d,float *ex_amp_d,float *ex_time_d,float *rp_d,int it,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left)
367 | {
368 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
369 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
370 | 		int in_idx;
371 | 
372 | 		if(ix<nx&&iz<nz)
373 | 		{
374 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
375 | 			if(it==ex_time_d[in_idx])
376 | 			rimageup1_d[ix*nz+iz]=rp_d[in_idx]*1.0/fabs(ex_amp_d[in_idx]);
377 | 		}
378 | }
379 | 
380 | __global__ void imaging_ex_for_xxzz(float *rimageup1_d,float *ex_amp_d,float *ex_time_d,float *rvxp1_d,float *rvzp1_d,int it,int source_x_cord,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left,float average)
381 | {
382 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
383 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
384 | 		int in_idx;
385 | 		int sign=1;
386 | 
387 | 		//if(ix<nx&&iz<nz&&iz>50)
388 | 		if(ix<nx&&iz<nz&&iz>50&&iz>0.8*(ix-source_x_cord)&&iz>0.8*(source_x_cord-ix))
389 | 		{
390 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
391 | 			if(ex_amp_d[in_idx]<0)	sign=-1;
392 | 
393 | 			if(it==ex_time_d[in_idx])
394 | 			{
395 | 				if(fabs(ex_amp_d[in_idx])>average)	rimageup1_d[ix*nz+iz]=(rvxp1_d[in_idx]+rvzp1_d[in_idx])*1.0/ex_amp_d[in_idx];
396 | 				
397 | 				if(fabs(ex_amp_d[in_idx])<=average)	rimageup1_d[ix*nz+iz]=(rvxp1_d[in_idx]+rvzp1_d[in_idx])*1.0/average*sign;
398 | 			}
399 | 		}
400 | }	
401 | 
402 | __global__ void imaging_ex_new(float *rimageup1_d,float *ex_amp_d,float *ex_time_d,float *rp_d,int it,int source_x_cord,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left)
403 | {
404 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
405 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
406 | 		int in_idx;
407 | 
408 | 		//if(ix<nx&&iz<nz&&iz>50)
409 | 		if(ix<nx&&iz<nz&&iz>50&&iz>1.2*(ix-source_x_cord)&&iz>1.2*(source_x_cord-ix))
410 | 		{
411 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
412 | 			if(it==ex_time_d[in_idx])
413 | 			rimageup1_d[ix*nz+iz]=rp_d[in_idx]*1.0/fabs(ex_amp_d[in_idx]);
414 | 		}
415 | }
416 | 
417 | __global__ void imaging_ex_new_average(float *rimageup1_d,float *ex_amp_d,float *ex_time_d,float *rp_d,int it,int source_x_cord,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left,float average)
418 | {
419 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
420 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
421 | 		int in_idx;
422 | 		int sign=1;
423 | 
424 | 		//if(ix<nx&&iz<nz&&iz>50)
425 | 		if(ix<nx&&iz<nz&&iz>50&&iz>1.2*(ix-source_x_cord)&&iz>1.2*(source_x_cord-ix))
426 | 		{
427 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
428 | 			if(ex_amp_d[in_idx]<0)	sign=-1;
429 | 
430 | 			if(it==ex_time_d[in_idx])
431 | 			{
432 | 				if(fabs(ex_amp_d[in_idx])>average)	rimageup1_d[ix*nz+iz]=rp_d[in_idx]*1.0/ex_amp_d[in_idx];
433 | 				
434 | 				if(fabs(ex_amp_d[in_idx])<=average)	rimageup1_d[ix*nz+iz]=rp_d[in_idx]*1.0/average*sign;
435 | 			}
436 | 		}
437 | }
438 | 
439 | __global__ void imaging_ex_correlation(float *rimageup1_d,float *ex_amp_d,float *ex_time_d,float *rp_d,int it,int source_x_cord,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left)
440 | //image_npp_xx_d,ex_amp1_x_d,ex_time1_d,rvxp1_d,it,source_x_cord[ishot]-receiver_x_cord[ishot],imaging_size[0],nz,nx_append,nz_append,boundary_up,boundary_left
441 | {
442 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
443 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
444 | 		int in_idx;
445 | 
446 | 		//if(ix<nx&&iz<nz&&iz>50)
447 | 		if(ix<nx&&iz<nz&&iz>50&&iz>1.2*(ix-source_x_cord)&&iz>1.2*(source_x_cord-ix))
448 | 		{
449 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
450 | 
451 | 			if(it==ex_time_d[in_idx])
452 | 			{
453 | 				rimageup1_d[ix*nz+iz]=rp_d[in_idx]*1.0*ex_amp_d[in_idx];
454 | 			}
455 | 		}
456 | }
457 | 
458 | __global__ void imaging_ex_ps(float *rimageup1_d,float *ex_amp_d,float *ex_time_d,float *rs_d,float *ex_angle_d,int it,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left)
459 | {
460 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
461 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
462 | 		int in_idx;
463 | 
464 | 		if(ix<nx&&iz<nz)
465 | 		{
466 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
467 | 			if(it==ex_time_d[in_idx])
468 | 				{
469 | 					if(ex_angle_d[in_idx]>0)	rimageup1_d[ix*nz+iz]=1.0*rs_d[in_idx]/fabs(ex_amp_d[in_idx]);
470 | 					if(ex_angle_d[in_idx]<=0)	rimageup1_d[ix*nz+iz]=-1.0*rs_d[in_idx]/fabs(ex_amp_d[in_idx]);
471 | 				}
472 | 		}
473 | }
474 | 
475 | __global__ void imageing_after_correcting(float *rimageup1_d,float *ex_angle_d,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left)
476 | {
477 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
478 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
479 | 		int in_idx;
480 | 
481 | 		if(ix<nx&&iz<nz)
482 | 		{
483 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
484 | 			
485 | 			if(ex_angle_d[in_idx]<=0)	rimageup1_d[ix*nz+iz]=-1*rimageup1_d[ix*nz+iz];
486 | 		}
487 | }
488 | 
489 | __global__ void set_adcigs_for_ex(float *r_adcigs_pp_d,float *image_d,float *ex_angle_d,int source_x_cord,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left,int angle_num,int dangle)
490 | //(r_adcigs_pp_d,image_pp_du_d,ex_angle_d,source_x_cord[ishot]-receiver_x_cord[ishot],imaging_size[0],nz,nx_append,nz_append,boundary_up,boundary_left,angle_num,dangle)
491 | {
492 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
493 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
494 | 		int in_idx;
495 | 		int set;
496 | 		int r_angle;
497 | 
498 | 		//if(ix<nx&&iz<nz&&iz>50)
499 | 		if(ix<nx&&iz<nz&&iz>50&&iz>1.2*(ix-source_x_cord)&&iz>1.2*(source_x_cord-ix))
500 | 		{
501 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;	
502 | 			
503 | 			r_angle=int((fabs(ex_angle_d[in_idx])+0.5)/dangle);
504 | 
505 | 			set=r_angle*nx*nz+ix*nz+iz;
506 | 
507 | 			if(r_angle<angle_num&&ex_angle_d[in_idx]>=0) r_adcigs_pp_d[angle_num*nx*nz+set]+=image_d[ix*nz+iz];//*exp(-(fabs(ex_angle_d[in_idx])-r_angle*dangle)*(fabs(ex_angle_d[in_idx])-r_angle*dangle)/8);
508 | 			if(r_angle<angle_num&&ex_angle_d[in_idx]<0) r_adcigs_pp_d[(angle_num-r_angle)*nx*nz+ix*nz+iz]+=image_d[ix*nz+iz];//*exp(-(fabs(ex_angle_d[in_idx])-r_angle*dangle)*(fabs(ex_angle_d[in_idx])-r_angle*dangle)/8);
509 | 		}
510 | }
511 | 
512 | 
513 | __global__ void set_value_a_to_b(float *angle_pp_d,float *angle_pp1_d,int dimx,int dimz)
514 | {
515 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
516 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
517 | 		int in_idx;
518 | 
519 | 		if(ix<dimx&&iz<dimz)
520 | 		{
521 | 			dimx=dimx+2*radius;dimz=dimz+2*radius;
522 | 			ix=ix+radius;iz=iz+radius;
523 | 			in_idx=ix*dimz+iz;
524 | 
525 | 			angle_pp1_d[in_idx]=angle_pp_d[in_idx];
526 | 		}
527 | }
528 | 
529 | __global__ void sum_image1_and_image2(float *image1_d,float *image2_d,float *image3_d,int nx,int nz)
530 | {
531 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
532 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
533 | 		int in_idx;
534 | 
535 | 		if(ix<nx&&iz<nz)
536 | 		{
537 | 			in_idx=ix*nz+iz;
538 | 
539 | 			image1_d[in_idx]=image2_d[in_idx]+image3_d[in_idx];
540 | 		}
541 | }
542 | __global__ void imaging_correlation_ex_2D(float *ex_resulttp_d,float *ex_amp_d,float *ex_tp_time_d,float *rtp2_d,int nx,int nz,int dimz,int boundary_up,int boundary_left,float *max,int it)
543 | //imaging_correlation_ex_2D<<<dimGrid,dimBlock>>>(ex_result_tp_d,ex_amp_tp_d,ex_tp_time_d,rtp2_d,nx_size,nz,nz_append,boundary_up,boundary_left,&para_max_d[0],it);
544 | {
545 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
546 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
547 | 		int in_idx;
548 | 
549 | 		if(ix<nx&&iz<nz)
550 | 		{
551 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
552 | 			if(it==ex_tp_time_d[in_idx])
553 | 			{
554 | 				ex_resulttp_d[ix*nz+iz]=1.0*rtp2_d[in_idx]/ex_amp_d[in_idx];
555 | 				//ex_resulttp_d[ix*nz+iz]=1.0*rtp2_d[in_idx]/(ex_amp_d[in_idx]+0.00000000001*(*max));
556 | 			}
557 | 		}
558 | }
559 | __global__ void imaging_inner_product_ex_2D(float *ex_vresult_pp_d,float *ex_amp_d,float *ex_amp_x_d,float *ex_amp_z_d,float *ex_time_d,float *rvxp2_d,float *rvzp2_d,int nx,int nz,int dimz,int boundary_up,int boundary_left,float *max,int it)
560 | ///imaging_inner_product_ex_2D<<<dimGrid,dimBlock>>>(ex_vresultpp_d,ex_amp_d,ex_amp_x_d,ex_amp_z_d,ex_time_d,rvxp2_d,rvzp2_d,nx_size,nz,nz_append,boundary_up,boundary_left,&para_max_d[1],it);
561 | {
562 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
563 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
564 | 		int idx;
565 | 
566 | 		if(ix<nx&&iz<nz)
567 | 		{
568 | 			idx=(ix+boundary_left)*dimz+iz+boundary_up;
569 | 			if(it==ex_time_d[idx])
570 | 			{
571 | 				float molecular=ex_amp_x_d[idx]*rvxp2_d[idx]+ex_amp_z_d[idx]*rvzp2_d[idx];
572 | 
573 | 				float denominator=ex_amp_x_d[idx]*ex_amp_x_d[idx]+ex_amp_z_d[idx]*ex_amp_z_d[idx];
574 | 
575 | 				ex_vresult_pp_d[ix*nz+iz]=molecular*1.0/(denominator);
576 | 				//ex_vresult_pp_d[ix*nz+iz]=molecular*1.0/(denominator+0.0000000000001*(*max));
577 | 				
578 | 			}
579 | 		}
580 | }
581 | 
582 | __global__ void imaging_inner_product_ex_2D_new(float *ex_vresult_pp_d,float *ex_amp_d,float *ex_amp_x_d,float *ex_amp_z_d,float *ex_time_d,float *rvxp2_d,float *rvzp2_d,int nx,int nz,int dimz,int boundary_up,int boundary_left,float *max,int it)
583 | ///imaging_inner_product_ex_2D<<<dimGrid,dimBlock>>>(ex_vresultpp_d,ex_amp_d,ex_amp_x_d,ex_amp_z_d,ex_time_d,rvxp2_d,rvzp2_d,nx_size,nz,nz_append,boundary_up,boundary_left,&para_max_d[1],it);
584 | {
585 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
586 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
587 | 		int idx;
588 | 
589 | 		if(ix<nx&&iz<nz)
590 | 		{
591 | 			idx=(ix+boundary_left)*dimz+iz+boundary_up;
592 | 			if(it==ex_time_d[idx])
593 | 			{
594 | 				float change_rpz=1.0*(rvzp2_d[idx+1]+rvzp2_d[idx-1]+rvzp2_d[idx+dimz]+rvzp2_d[idx-dimz])/4.0;
595 | 
596 | 				float molecular=ex_amp_x_d[idx]*rvxp2_d[idx]+ex_amp_z_d[idx]*change_rpz;
597 | 
598 | 				float denominator=ex_amp_x_d[idx]*ex_amp_x_d[idx]+ex_amp_z_d[idx]*ex_amp_z_d[idx];
599 | 
600 | 				ex_vresult_pp_d[ix*nz+iz]=molecular*1.0/(denominator);
601 | 				//ex_vresult_pp_d[ix*nz+iz]=molecular*1.0/(denominator+0.0000000000001*(*max));
602 | 				
603 | 			}
604 | 		}
605 | }
606 | 
607 | __global__ void imaging_correlation_for_xxzz(float *vxp1_d,float *vxs1_d,float *rvxp1_d,float *rvxs1_d,float *resultxx_d,int nx,int nz,int dimz,int boundary_up,int boundary_left)
608 | //imaging_correlation_for_xxzz<<<dimGrid,dimBlock>>>(vxp1_d,vxs1_d,rvxp1_d,rvxs1_d,resultxx_d,nx_size,nz,nz_append,boundary_up,boundary_left);
609 | {
610 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
611 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
612 | 		int in_idx;
613 | 
614 | 		if(ix<nx&&iz<nz)
615 | 		{
616 | 			in_idx=(ix+boundary_left)*dimz+iz+boundary_up;
617 | 			
618 | 			resultxx_d[ix*nz+iz]=resultxx_d[ix*nz+iz]+1.0*(vxp1_d[in_idx]+vxs1_d[in_idx])*(rvxp1_d[in_idx]+rvxs1_d[in_idx]);			
619 | 		}
620 | }
621 | 
622 | __global__ void imaging_pp_compensate_dependent_angle_2D(float *ex_angle_pp_d,float *ex_angle_rpp_d,float *com_ex_vresultpp_d,float *ex_vresultpp_d,float *ex_time_d,int nx,int nz,int dimz,int boundary_up,int boundary_left,int it)
623 | //imaging_pp_compensate_dependent_angle_2D<<<dimGrid,dimBlock>>>(ex_angle_pp_d,ex_angle_rpp_d,com_ex_vresultpp_d,ex_vresultpp_d,ex_time_d,nx_size,nz,nz_append,boundary_up,boundary_left,it);
624 | {
625 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
626 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
627 | 		int idx;
628 | 		float com=0.0;
629 | 		float denominrator=0.0;
630 | 
631 | 		if(ix<nx&&iz<nz)
632 | 		{
633 | 			idx=(ix+boundary_left)*dimz+iz+boundary_up;
634 | 			if(it==ex_time_d[idx])
635 | 			{
636 | 				com=ex_angle_pp_d[idx]-ex_angle_rpp_d[idx];
637 | 
638 | 				if(fabs(com)>=87.5&&fabs(com)<=92.5)	denominrator=0.1;
639 | 
640 | 				else				denominrator=float(cos(1.0*com*pai1/180.0));
641 | 
642 | 				com_ex_vresultpp_d[ix*nz+iz]=ex_vresultpp_d[ix*nz+iz]/(1.0*denominrator+0.0001);
643 | 
644 | 				//ex_angle_rpp_d[idx]=com;
645 | 				ex_angle_rpp_d[idx]=ex_angle_pp_d[idx]-ex_angle_rpp_d[idx];	
646 | 			}
647 | 		}
648 | }
649 | 
650 | __global__ void imaging_ps_compensate_dependent_angle_2D(float *ex_angle_pp_d,float *ex_angle_rpp_d,float *com_ex_vresultpp_d,float *ex_vresultpp_d,float *ex_time_d,int nx,int nz,int dimz,int boundary_up,int boundary_left,int it)
651 | {
652 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
653 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
654 | 		int idx;
655 | 		float com=0.0;
656 | 		float denominrator=0.0;
657 | 
658 | 		if(ix<nx&&iz<nz)
659 | 		{
660 | 			idx=(ix+boundary_left)*dimz+iz+boundary_up;
661 | 			if(it==ex_time_d[idx])
662 | 			{
663 | 				com=ex_angle_pp_d[idx]-ex_angle_rpp_d[idx];
664 | 
665 | 				if(fabs(com)<=2.5)	denominrator=0.1;
666 | 
667 | 				else			denominrator=float(sin(fabs(1.0*com*pai1/180.0)));
668 | 
669 | 				com_ex_vresultpp_d[ix*nz+iz]=ex_vresultpp_d[ix*nz+iz]/(1.0*denominrator+0.0001);
670 | 
671 | 				//ex_angle_rpp_d[idx]=com;
672 | 				ex_angle_rpp_d[idx]=ex_angle_pp_d[idx]-ex_angle_rpp_d[idx];				
673 | 			}
674 | 		}
675 | }
676 | 
677 | 
678 | __global__ void caculate_ex_open_pp_ps(float *ex_open_pp1_d,float *ex_angle_pp1_d,float *ex_angle_rpp1_d,int nx,int nz,int dimx,int dimz,int boundary_up,int boundary_left,int it,float *ex_time_d)
679 | //caculate_ex_open_pp_ps<<<dimGrid,dimBlock>>>(ex_open_pp_d,ex_angle_pp_d,ex_angle_rpp_d,nx_size,nz,nx_append,nz_append,boundary_up,boundary_left,it,ex_time_d);
680 | {
681 | 		
682 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
683 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
684 | 		int in_idx;
685 | 
686 | 		if(ix<dimx&&iz<dimz)
687 | 		{
688 | 				//dimx=dimx+2*radius;dimz=dimz+2*radius;
689 | 				//ix=ix+radius;iz=iz+radius;
690 | 				in_idx=ix*dimz+iz;
691 | 
692 | 				if(it==ex_time_d[in_idx])
693 | 				{
694 | 					ex_open_pp1_d[in_idx]=ex_angle_pp1_d[in_idx]-ex_angle_rpp1_d[in_idx];
695 | 				} 
696 | 		}
697 | }
698 | __global__ void cuda_ex_com_pp_ps_sign(float *ex_com_pp_sign_d,float *ex_open_pp_d,int nx,int nz,int dimx,int dimz,int mark)
699 | //cuda_ex_com_pp_ps_sign<<<dimGrid,dimBlock>>>(ex_com_pp_sign_d,ex_open_pp1_d,nx_size,nz,nx_append,nz_append,0);
700 | {		
701 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
702 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
703 | 		int in_idx;
704 | 
705 | 		if(ix<dimx&&iz<dimz)
706 | 		{
707 | 				//dimx=dimx+2*radius;dimz=dimz+2*radius;
708 | 				//ix=ix+radius;iz=iz+radius;
709 | 				in_idx=ix*dimz+iz;
710 | 
711 | 				if(mark==0)	ex_com_pp_sign_d[in_idx]=1.0*cos(1.0*ex_open_pp_d[in_idx]*pai1/180.0);///pp
712 | 
713 | 				if(mark==1)	ex_com_pp_sign_d[in_idx]=fabs(1.0*sin(1.0*ex_open_pp_d[in_idx]*pai1/180.0));///ps
714 | 		}
715 | }
716 | 
717 | __global__ void imaging_pp_compensate_dependent_angle_2D_new(float *ex_open_pp1_d,float *ex_com_pp_sign_d,float *com_ex_vresultpp_d,float *ex_vresultpp_d,float *ex_time_d,int nx,int nz,int dimz,int boundary_up,int boundary_left)
718 | //imaging_pp_compensate_dependent_angle_2D_new<<<dimGrid,dimBlock>>>(ex_open_pp1_d,ex_com_pp_sign_d,com_ex_vresultpp_d,ex_vresultpp_d,ex_time_d,nx_size,nz,nz_append,boundary_up,boundary_left);
719 | {
720 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
721 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
722 | 		int idx;
723 | 		float denominrator=0.0;
724 | 
725 | 		if(ix<nx&&iz<nz)
726 | 		{
727 | 			idx=(ix+boundary_left)*dimz+iz+boundary_up;
728 | 			
729 | 			//if(fabs(ex_open_ps1_d[idx])>=87.5&&fabs(ex_open_ps1_d[idx])<=92.5)	denominrator=0.001;			
730 | 
731 | 			denominrator=ex_com_pp_sign_d[idx];//+0.01;
732 | 
733 | 			//if(denominrator!=0)	com_ex_vresultpp_d[ix*nz+iz]=1.0*ex_vresultpp_d[ix*nz+iz]/denominrator;
734 | 
735 | 			if(denominrator<=0)		com_ex_vresultpp_d[ix*nz+iz]=-1.0*ex_vresultpp_d[ix*nz+iz];
736 | 
737 | 			if(denominrator>0)		com_ex_vresultpp_d[ix*nz+iz]=1.0*ex_vresultpp_d[ix*nz+iz];
738 | 
739 | 			com_ex_vresultpp_d[ix*nz+iz]=-1.0*com_ex_vresultpp_d[ix*nz+iz]/(fabs(denominrator)+0.03);
740 | 		}
741 | }
742 | 
743 | __global__ void imaging_ps_compensate_dependent_angle_2D_new(float *ex_open_ps1_d,float *ex_com_ps_sign_d,float *com_ex_vresultps_d,float *ex_vresultps_d,float *ex_time_d,int nx,int nz,int dimz,int boundary_up,int boundary_left)
744 | //imaging_ps_compensate_dependent_angle_2D_new<<<dimGrid,dimBlock>>>(ex_open_pp1_d,ex_com_ps_sign_d,com_ex_vresultps_d,ex_vresultps_d,ex_time_d,nx_size,nz,nz_append,boundary_up,boundary_left);
745 | {
746 | 		int ix = blockIdx.x*blockDim.x+threadIdx.x;
747 | 		int iz = blockIdx.y*blockDim.y+threadIdx.y;
748 | 		int idx;
749 | 		float denominrator=0.0;
750 | 
751 | 		if(ix<nx&&iz<nz)
752 | 		{
753 | 			idx=(ix+boundary_left)*dimz+iz+boundary_up;
754 | 			
755 | 			//if(fabs(ex_open_ps1_d[idx])<=2.5)	denominrator=0.001;			
756 | 
757 | 			denominrator=fabs(ex_com_ps_sign_d[idx])+0.1;
758 | 
759 | 			if(denominrator!=0)	com_ex_vresultps_d[ix*nz+iz]=-1.0*ex_vresultps_d[ix*nz+iz]/denominrator;
760 | 		}
761 | }
762 | 


--------------------------------------------------------------------------------
/2D_elastic_RTM/zzzzz:
--------------------------------------------------------------------------------
   1 | void set_zero_1d(float *matrix,int nx)
   2 | {
   3 | 	int ix;
   4 | 	for(ix=0;ix<nx;ix++)
   5 | 		matrix[ix]=0.0;
   6 | }
   7 | 
   8 | void set_zero_2d(float **matrix,int nx,int nz)
   9 | {
  10 | 	int ix,iz;
  11 | 	for(ix=0;ix<nx;ix++)
  12 | 		for(iz=0;iz<nz;iz++)
  13 | 			matrix[iz][ix]=0.0;
  14 | }
  15 | 
  16 | void set_zero_3d(float ***matrix,int nx,int ny,int nz)
  17 | {
  18 | 	int ix,iy,iz;
  19 | 	
  20 | 	for(ix=0;ix<nx;ix++)
  21 | 		for(iy=0;iy<ny;iy++)
  22 | 			for(iz=0;iz<nz;iz++)
  23 | 				matrix[iz][iy][ix]=0.0;
  24 | }
  25 | 
  26 | void set_zero_1d_complex(complex *matrix,int nx)
  27 | {
  28 | 	int ix;
  29 | 	for(ix=0;ix<nx;ix++)
  30 | 		{
  31 | 			matrix[ix].r=0.0;
  32 | 			matrix[ix].i=0.0;
  33 | 		}
  34 | }
  35 | 
  36 | void set_zero_2d_complex(complex **matrix,int nx,int nz)
  37 | {
  38 | 	int ix,iz;
  39 | 	for(ix=0;ix<nx;ix++)
  40 | 		for(iz=0;iz<nz;iz++)
  41 | 			{
  42 | 				matrix[iz][ix].r=0.0;
  43 | 				matrix[iz][ix].i=0.0;
  44 | 			}
  45 | }
  46 | 
  47 | void set_zero_3d_complex(complex ***matrix,int nx,int ny,int nz)
  48 | {
  49 | 	int ix,iy,iz;
  50 | 	
  51 | 	for(ix=0;ix<nx;ix++)
  52 | 		for(iy=0;iy<ny;iy++)
  53 | 			for(iz=0;iz<nz;iz++)
  54 | 				{
  55 | 					matrix[iz][iy][ix].r=0.0;
  56 | 					matrix[iz][iy][ix].i=0.0;
  57 | 				}
  58 | }
  59 | void write_file_1d(float *matrix,int nx,char *name)
  60 | {
  61 | 	FILE *fp;
  62 | 	if((fp=fopen(name,"wb+"))==NULL)
  63 | 	{	
  64 | 		printf("Can not oen this file : %s\n",name);
  65 | 		exit(0);
  66 | 	}
  67 | 	
  68 | 	
  69 | 	//fp=fopen(name,"wb+");
  70 | 		fwrite(matrix,sizeof(float),nx,fp);
  71 | 		fclose(fp);
  72 | }
  73 | 
  74 | void write_file_2d(float **matrix,int nx,int nz,char *name)
  75 | {
  76 | 	int ix,iz;
  77 | 
  78 | 	FILE *fp;
  79 | 	if((fp=fopen(name,"wb+"))==NULL)
  80 | 	{	
  81 | 		printf("Can not oen this file : %s\n",name);
  82 | 		exit(0);
  83 | 	}
  84 | 	
  85 | 	
  86 | 	//fp=fopen(name,"wb+");
  87 | 	for(ix=0;ix<nx;ix++)
  88 | 		for(iz=0;iz<nz;iz++)
  89 | 	fwrite(&matrix[iz][ix],sizeof(float),1,fp);
  90 | 	fclose(fp);
  91 | }
  92 | 
  93 | void write_file_3d(float ***matrix,int nx,int ny,int nz,char *name)
  94 | {
  95 | 	int ix,iy,iz;
  96 | 
  97 | 	FILE *fp;
  98 | 	if((fp=fopen(name,"wb+"))==NULL)
  99 | 	{	
 100 | 		printf("Can not oen this file : %s\n",name);
 101 | 		exit(0);
 102 | 	}
 103 | 	
 104 | 	
 105 | 	//fp=fopen(name,"wb+");
 106 | 	for(ix=0;ix<nx;ix++)
 107 | 		for(iy=0;iy<ny;iy++)
 108 | 			for(iz=0;iz<nz;iz++)
 109 | 			fwrite(&matrix[iz][iy][ix],sizeof(float),1,fp);
 110 | 			fclose(fp);
 111 | }
 112 | 
 113 | void fread_file_1d(float *matrix,int nx,int nz,char *name)
 114 | {
 115 | 	int ix,iz;
 116 | 	FILE *fp;
 117 | 	if((fp=fopen(name,"rb"))==NULL)
 118 | 	{	
 119 | 		printf("Can not oen this file : %s\n",name);
 120 | 		exit(0);
 121 | 	}
 122 | 	
 123 | 	
 124 | 	//fp=fopen(name,"rb");
 125 | 	for(ix=0;ix<nx;ix++)
 126 | 		for(iz=0;iz<nz;iz++)
 127 | 			fread(&matrix[ix*nz+iz],sizeof(float),1,fp);
 128 | 		fclose(fp);
 129 | }
 130 | 
 131 | void fread_file_2d(float **matrix,int nx,int nz,char *name)
 132 | {
 133 | 	int ix,iz;
 134 | 
 135 | 	FILE *fp;
 136 | 	if((fp=fopen(name,"rb"))==NULL)
 137 | 	{	
 138 | 		printf("Can not oen this file : %s\n",name);
 139 | 		exit(0);
 140 | 	}
 141 | 	
 142 | 	
 143 | 	//fp=fopen(name,"rb");
 144 | 	for(ix=0;ix<nx;ix++)
 145 | 		for(iz=0;iz<nz;iz++)
 146 | 			fread(&matrix[iz][ix],sizeof(float),1,fp);
 147 | 				fclose(fp);
 148 | }
 149 | 
 150 | void fread_file_3d(float ***matrix,int nx,int ny,int nz,char *name)
 151 | {
 152 | 	int ix,iy,iz;
 153 | 	
 154 | 	FILE *fp;
 155 | 	if((fp=fopen(name,"rb"))==NULL)
 156 | 	{	
 157 | 		printf("Can not oen this file : %s\n",name);
 158 | 		exit(0);
 159 | 	}
 160 | 	
 161 | 	
 162 | 	//fp=fopen(name,"rb");
 163 | 	for(ix=0;ix<nx;ix++)
 164 | 		for(iy=0;iy<ny;iy++)
 165 | 			for(iz=0;iz<nz;iz++)
 166 | 				fread(&matrix[iz][iy][ix],sizeof(float),1,fp);
 167 | 					fclose(fp);
 168 | }
 169 | 
 170 | 
 171 | 
 172 | 
 173 | /////zzzzz:get ricker wave by two methods
 174 | float * make_ricker_new(float freq,float dt,int *Npoint)
 175 | {
 176 | 	float Bpar,t,u,*ricker;
 177 | 	int Np1,N;
 178 | 	
 179 | 	if(freq==0.0) freq=30.0;
 180 | 	if(dt==0.0) dt=0.004;
 181 | 	Bpar=sqrt(6.0)/(PI*freq);
 182 | 	N=(int)(ceil(1.35*Bpar/dt));
 183 | 	Np1=N;
 184 | 	*Npoint=2*N+1;
 185 | 	 
 186 | 	ricker=alloc1float(*Npoint);
 187 | 	ricker[Np1]=1.0;
 188 | 	for(int i=1;i<=N;i++)
 189 | 	{
 190 | 		t=dt*(float)i;
 191 | 		u=2.0*sqrt(6.0)*t/Bpar;
 192 | 		ricker[Np1+i]=ricker[Np1-i]=0.5*(2.0-u*u)*exp(-u*u/4.0);
 193 | 	}
 194 | 	return ricker;
 195 | }
 196 | 
 197 | void make_ricker_initial(float *ricker,float frmain,float dt,int wave_length)
 198 | {
 199 | 	float sdt,time,tp1,tp2;
 200 | 	int it;
 201 | 	sdt=dt*0.001;
 202 | 	for(it=0;it<wave_length;it++)
 203 |         {
 204 | 		time=(it+1)*sdt-(wave_length/2.0)*sdt;
 205 | 		tp1=PI*frmain*time;
 206 | 		tp2=tp1*tp1;
 207 | 		ricker[it]=(1.0-2.0*tp2)*exp(-tp2);
 208 |         }
 209 | }
 210 | 
 211 | void make_ricker_better(float *ricker,float frmain,float dt,int wave_length)
 212 | {
 213 | 	float sdt,time,tp1,tp2;
 214 | 	int it;
 215 | 	sdt=dt*0.001;
 216 | 	for(it=0;it<wave_length;it++)
 217 |         {
 218 | 		time=((it+1)*sdt-1.0/frmain)*sdt;
 219 | 		tp1=PI*frmain*time;
 220 | 		tp2=tp1*tp1;
 221 | 		ricker[it]=(1.0-2.0*tp2)*exp(-tp2);
 222 |         }
 223 | }
 224 | /*__global__ void cuda_ricker_wavelet(float *wlt, float amp, float fm, float dt, int nt)
 225 | {
 226 | 	int it=threadIdx.x+blockDim.x*blockIdx.x;
 227 |     	if (it<nt)
 228 | 	{
 229 | 	    	float tmp = PI*fm*(it*dt-1.0/fm);
 230 | 	    	tmp *=tmp;
 231 | 		wlt[it]=amp*(1.0-2.0*tmp)*expf(-tmp);
 232 | 	}
 233 | }*/
 234 | 
 235 | 
 236 | /////zzzzz:get one or two order difference coefficient
 237 | void make_coe_optimized_new(float *coe)
 238 | {
 239 | 		//*****optimized*********
 240 | 		coe[1]=1.2213363647;
 241 | 	      coe[2]=-0.096931457519;
 242 | 		coe[3]=0.017447662353;
 243 |             coe[4]=-0.0029672895159;
 244 |             coe[5]=0.00035900539822;
 245 | 		coe[6]=-0.00002184781161;////first-order derivative
 246 | 
 247 | 		/*coe[1]=1.2112426;
 248 |      		coe[2]=-0.0897216;
 249 |       	coe[3]=0.0138427;
 250 |      		coe[4]=-0.0017656;
 251 |       	coe[5]=0.0001186;
 252 | 		coe[6]=0.0;*/
 253 | 		//*****optimized end***********/
 254 | }
 255 | 
 256 | void make_coe_optimized1_new(float *coe)
 257 | {
 258 | 		//*****optimized*********
 259 | 		coe[0]= 0.0000;
 260 | 		coe[1]=+0.83333;
 261 | 		coe[2]=-0.23810;
 262 | 		coe[3]=+0.059524;
 263 | 		coe[4]=-0.0099206;
 264 | 		coe[5]=+0.0008038;///// second-order derivative
 265 | 		coe[6]= 0.0000;
 266 | 		//*****optimized end***********/
 267 | }
 268 | 
 269 | 
 270 | 
 271 | 
 272 | /////zzzzz:make_attenuation_new , read velocity_new , <<< get_current_shot_velocity_new  and  extend velocity >>>
 273 | void make_attenuation_new(float *attenuation,int nx,int nz,int boundary_up,int boundary_down,int boundary_left,int boundary_right,float coe_attenuation)
 274 | {
 275 | 	float *att_up,*att_down,*att_left,*att_right;
 276 | 	if(boundary_up!=0) 
 277 | 		{	
 278 | 			att_up=alloc1float(boundary_up);
 279 | 			memset((void *) (att_up), 0, boundary_up* sizeof (float));
 280 | 		}
 281 | 	att_down=alloc1float(boundary_down);
 282 | 	att_left=alloc1float(boundary_left);
 283 | 	att_right=alloc1float(boundary_right);
 284 | 	memset((void *) (att_down), 0, boundary_down* sizeof (float));
 285 | 	memset((void *) (att_left), 0, boundary_left* sizeof (float));
 286 | 	memset((void *) (att_right), 0, boundary_right* sizeof (float));
 287 | 	
 288 | 	float xxx;
 289 | 		
 290 | 	if(boundary_up!=0)
 291 | 	{
 292 | 			for(int iz=0;iz<boundary_up;iz++)
 293 | 			{
 294 | 					xxx=(boundary_up-1.0-iz)/(boundary_up-1.0);
 295 | 					att_up[iz]=coe_attenuation*pow(xxx*1.0,3.0);
 296 | 					//att_up[iz]=coe_attenuation*(1.0-cos(PI/2*(boundary_up-iz-1)/(boundary_up-1)));//cos
 297 | 					//att_up[iz]=coe_attenuation*((boundary_up-1.0-iz)*(boundary_up-1.0-iz)*(boundary_up-1.0-iz)/((boundary_up-1.0)*(boundary_up-1.0)*(boundary_up-1.0)));//NPML
 298 | 			}
 299 | 	}
 300 | 
 301 | 			for(int iz=0;iz<boundary_down;iz++)
 302 | 			{
 303 | 					xxx=iz/(boundary_down-1.0);
 304 | 					att_down[iz]=coe_attenuation*pow(xxx*1.0,3.0);
 305 | 					//att_down[iz]=coe_attenuation*(1.0-cos(PI/2*iz/(boundary_down-1)));//cos
 306 | 					//att_down[iz]=coe_attenuation*(iz*iz*iz*1.0/((boundary_up-1.0)*(boundary_up-1.0)*(boundary_up-1.0)));//NPML
 307 | 			}
 308 | 
 309 | 			for(int ix=0;ix<boundary_left;ix++)
 310 | 			{
 311 | 					xxx=(boundary_left-1.0-ix)/(boundary_left-1.0);
 312 | 					att_left[ix]=coe_attenuation*pow(xxx*1.0,3.0);
 313 | 
 314 | 					//att_left[ix]=coe_attenuation*(1.0-cos(PI/2*(boundary_left-ix-1)/(boundary_left-1)));//cos
 315 | 					//att_left[ix]=coe_attenuation*((boundary_left-1.0-ix)*(boundary_left-1.0-ix)*(boundary_left-1.0-ix)/((boundary_left-1.0)*(boundary_left-1.0)*(boundary_left-1.0)));//NPML
 316 | 			}
 317 | 
 318 | 			for(int ix=0;ix<boundary_right;ix++)
 319 | 			{
 320 | 					xxx=ix/(boundary_right-1.0);
 321 | 					att_right[ix]=coe_attenuation*pow(xxx*1.0,3.0);
 322 | 					//att_right[ix]=coe_attenuation*(1.0-cos(PI/2*ix/(boundary_right-1)));//cos
 323 | 					//att_right[ix]=coe_attenuation*(ix*ix*ix*1.0/((boundary_right-1.0)*(boundary_right-1.0)*(boundary_right-1.0)));//NPML					
 324 | 			}
 325 | 
 326 | 	int nx_append=boundary_left+nx+boundary_right;
 327 | 	int nz_append=boundary_up+nz+boundary_down;
 328 | //u
 329 | 	if(boundary_up!=0)
 330 | 	{
 331 | 		for(int iz=0;iz<boundary_up;iz++)
 332 | 			for(int ix=0;ix<nx_append;ix++)
 333 | 			{
 334 | 					attenuation[ix*nz_append+iz]=att_up[iz];
 335 | 			}
 336 | 	}
 337 | //l
 338 | 		for(int iz=0;iz<nz_append;iz++)
 339 | 			for(int ix=0;ix<boundary_left;ix++)
 340 | 			{
 341 | 					attenuation[ix*nz_append+iz]+=att_left[ix];
 342 | 			}
 343 | //d
 344 | 		for(int iz=boundary_up+nz;iz<nz_append;iz++)
 345 | 			for(int ix=0;ix<nx_append;ix++)
 346 | 			{
 347 | 					attenuation[ix*nz_append+iz]+=att_down[iz-(boundary_up+nz)];
 348 | 			}
 349 | //r
 350 | 		for(int iz=0;iz<nz_append;iz++)
 351 | 			for(int ix=boundary_left+nx;ix<boundary_left+nx+boundary_right;ix++)
 352 | 			{
 353 | 					attenuation[ix*nz_append+iz]+=att_right[ix-(boundary_left+nx)];
 354 | 			}
 355 | 
 356 | 	if(boundary_up!=0) free1float(att_up);
 357 | 	free1float(att_down);
 358 | 	free1float(att_left);
 359 | 	free1float(att_right);
 360 | }
 361 | 
 362 | void read_velocity_new(float *velocity,int nx,int nz,int boundary_up,int boundary_down,int boundary_left,int boundary_right,char *filename)
 363 | ////read  all velocity mode 
 364 | {
 365 | 	FILE *velocity_fp;
 366 | 	
 367 | 	if((velocity_fp=fopen(filename,"rb"))==NULL)
	{	
		printf("Can not oen this file : %s\n",filename);
		exit(0);
	}
 368 | 
 369 | 	//velocity_fp=fopen(filename,"rb");
 370 | 
 371 | 	int nx_append=boundary_left+nx+boundary_right;
 372 | 	int nz_append=boundary_up+nz+boundary_down;
 373 | 	for(int ix=0;ix<nx_append;ix++)
 374 | 	{
 375 | 			if(ix<boundary_left)
 376 | 					fseek(velocity_fp,0,0);
 377 | 			else if(ix<boundary_left+nx)
 378 | 					fseek(velocity_fp,(ix-boundary_left)*sizeof(float)*nz,0);
 379 | 			else
 380 | 					fseek(velocity_fp,(nx-1)*sizeof(float)*nz,0);
 381 | 			fread((velocity+ix*nz_append+boundary_up),sizeof(float),nz,velocity_fp);
 382 | 
 383 | 			for(int iz=0;iz<boundary_up;iz++)
 384 | 			{
 385 | 					velocity[ix*nz_append+iz]=velocity[ix*nz_append+boundary_up];
 386 | 			}
 387 | 			for(int iz=boundary_up+nz;iz<nz_append;iz++)
 388 | 			{
 389 | 					velocity[ix*nz_append+iz]=velocity[ix*nz_append+boundary_up+nz-1];
 390 | 			}
 391 | 	}
 392 | 	
 393 | 	fclose(velocity_fp);
 394 | }
 395 | 
 396 | void get_partly_mode(float *velocity_all,float *velocity_current,int nx,int nz,int receiver_x_cord,int receiver_interval,int receiver_num)
 397 | {
 398 | 	int ix,iz;
 399 | 	
 400 | 	int nnx;
 401 | 	nnx=receiver_interval*receiver_num;
 402 | 	
 403 | 	for(ix=0;ix<nnx;ix++)
 404 | 		for(iz=0;iz<nz;iz++)
 405 | 	  		velocity_current[ix*nz+iz]=velocity_all[(receiver_x_cord+ix)*nz+iz];	
 406 | }
 407 | 
 408 | void get_current_shot_velocity_new(float *velocity_current,int nx,int nz,int receiver_x_cord,int receiver_interval,int receiver_num,char *filename)
 409 | ////read some part velocity mode 
 410 | {
 411 | 	int ix,iz;
 412 | 	float *velocity_all;
 413 | 	velocity_all=alloc1float(nx*nz);
 414 | 	set_zero_1d(velocity_all,nx*nz);
 415 | 	fread_file_1d(velocity_all,nx,nz,filename);
 416 | 	//write_file_1d(velocity_all,nx*nz,"vel");
 417 | 	
 418 | 	int nnx;
 419 | 	nnx=receiver_interval*receiver_num;
 420 | 	
 421 | 	for(ix=0;ix<nnx;ix++)
 422 | 		for(iz=0;iz<nz;iz++)
 423 | 	  		velocity_current[ix*nz+iz]=velocity_all[(receiver_x_cord+ix)*nz+iz];	
 424 | }
 425 | 
 426 | void extend_velocity_new(float *velocity_input_1d,float *velocity_output_1d,int nx_append,int nz_append,int nx,int nz,int boundary_left,int boundary_up,int boundary_right,int boundary_down)
 427 | ////extend_velocity  nx=nx+apert nz=nz+apert
 428 | {
 429 | //the input is the size: nx * nz                              	
 430 | //the output is the size: nx_append * nz_append				
 431 | 	int ix,iz;
 432 | 	int du,dl,dr,dd;
 433 | 	du=boundary_up;
 434 | 	dd=boundary_down;
 435 | 	dl=boundary_left;
 436 | 	dr=boundary_right;
 437 | 	
 438 | 	/*int nx_append,nz_append;
 439 | 	nx_append=nx+dl+dr;
 440 | 	nz_append=nz+du+dd;*/
 441 | 	
 442 | 	float **velocity_output,**velocity_input;
 443 | 	velocity_output=alloc2float(nx_append,nz_append);
 444 | 	velocity_input=alloc2float(nx,nz);
 445 | 	set_zero_2d(velocity_output,nx_append,nz_append);
 446 | 	set_zero_2d(velocity_output,nx,nz);
 447 | 	
 448 | //set value for input_1d
 449 | 	for(ix=0;ix<nx;ix++)
 450 | 	for(iz=0;iz<nz;iz++)
 451 | 		{		
 452 | 			velocity_input[iz][ix]=velocity_input_1d[ix*nz+iz];
 453 | 		}
 454 | 		
 455 | //up
 456 | 	for(iz=0;iz<du;iz++)
 457 | 	for(ix=0;ix<nx;ix++)
 458 | 		{		
 459 | 			velocity_output[iz][ix+dl]=velocity_input[0][ix];
 460 | 		}
 461 | //down
 462 | 	for(iz=0;iz<dd;iz++)
 463 | 	for(ix=0;ix<nx;ix++)
 464 | 		{		
 465 | 			velocity_output[iz+du+nz][ix+dl]=velocity_input[nz-1][ix];
 466 | 		}
 467 | //left
 468 | 	for(iz=0;iz<nz;iz++)
 469 | 	for(ix=0;ix<dl;ix++)
 470 | 		{	
 471 | 			velocity_output[iz+du][ix]=velocity_input[iz][0];
 472 | 		}
 473 | //rigt
 474 | 	for(iz=0;iz<nz;iz++)
 475 | 	for(ix=0;ix<dr;ix++)
 476 | 		{	
 477 | 			velocity_output[iz+du][ix+dl+nx]=velocity_input[iz][nx-1];
 478 | 		}
 479 | //four corner
 480 | 
 481 | //ul
 482 | 	for(iz=0;iz<du;iz++)			
 483 | 	for(ix=0;ix<dl;ix++)
 484 | 		{
 485 | 			velocity_output[iz][ix]=velocity_input[0][0];
 486 | 		}
 487 | 
 488 | //ur
 489 | 	for(iz=0;iz<du;iz++)			
 490 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 491 | 		{
 492 | 			velocity_output[iz][ix]=velocity_input[0][nx-1];
 493 | 		}
 494 | 
 495 | //dl
 496 | 	for(iz=nz+du-1;iz<du+nz+dd;iz++)			
 497 | 	for(ix=0;ix<dl;ix++)
 498 | 		{
 499 | 			velocity_output[iz][ix]=velocity_input[nz-1][0];
 500 | 		}
 501 | 
 502 | //dr
 503 | 	for(iz=du+nz-1;iz<du+nz+dd;iz++)			
 504 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 505 | 		{
 506 | 			velocity_output[iz][ix]=velocity_input[nz-1][nx-1];
 507 | 		}
 508 | //med
 509 | 	for(iz=du;iz<du+nz;iz++)
 510 | 	for(ix=dl;ix<dl+nx;ix++)
 511 | 		{
 512 | 			velocity_output[iz][ix]=velocity_input[iz-du][ix-dl];
 513 | 		}
 514 | 		
 515 | //set vaule for ouput 1d
 516 | 	
 517 | 	for(ix=0;ix<nx_append;ix++)
 518 | 	for(iz=0;iz<nz_append;iz++)
 519 | 		{
 520 | 			velocity_output_1d[ix*nz_append+iz]=velocity_output[iz][ix];
 521 | 		}		
 522 | 
 523 | }
 524 | /////		extend_boundary_new:::   the destionation is extended boundary value to added boundary
 525 | void extend_boundary_new(float *input,int nx_append,int nz_append,int nx,int nz,int boundary_left,int boundary_up,int boundary_right,int boundary_down)
 526 | {
 527 | 	int ix,iz;
 528 | 	int du,dl,dr,dd;
 529 | 	du=boundary_up;
 530 | 	dd=boundary_down;
 531 | 	dl=boundary_left;
 532 | 	dr=boundary_right;
 533 | 	
 534 | 	float **v2,**v2pml;
 535 | 	v2=alloc2float(nx,nz);
 536 | 	v2pml=alloc2float(nx_append,nz_append);
 537 | 	
 538 | 	for(ix=0;ix<nx;ix++)
 539 | 		for(iz=0;iz<nz;iz++)
 540 | 			v2[iz][ix]=input[(ix+boundary_left)*nz_append+iz+boundary_up];	
 541 | //up
 542 | 	for(iz=0;iz<du;iz++)
 543 | 	for(ix=0;ix<nx;ix++)
 544 | 		{
 545 | 			
 546 | 			v2pml[iz][ix+dl]=v2[0][ix];
 547 | 		}
 548 | //down
 549 | 	for(iz=0;iz<dd;iz++)
 550 | 	for(ix=0;ix<nx;ix++)
 551 | 		{
 552 | 			
 553 | 			v2pml[iz+du+nz][ix+dl]=v2[nz-1][ix];
 554 | 		}
 555 | //left
 556 | 	for(iz=0;iz<nz;iz++)
 557 | 	for(ix=0;ix<dl;ix++)
 558 | 		{
 559 | 			
 560 | 			v2pml[iz+du][ix]=v2[iz][0];
 561 | 		}
 562 | //rigt
 563 | 	for(iz=0;iz<nz;iz++)
 564 | 	for(ix=0;ix<dr;ix++)
 565 | 		{
 566 | 			
 567 | 			v2pml[iz+du][ix+dl+nx]=v2[iz][nx-1];
 568 | 		}
 569 | //four corner
 570 | 
 571 | //ul
 572 | 	for(iz=0;iz<du;iz++)			
 573 | 	for(ix=0;ix<dl;ix++)
 574 | 		{
 575 | 			v2pml[iz][ix]=v2[0][0];
 576 | 		}
 577 | 
 578 | //ur
 579 | 	for(iz=0;iz<du;iz++)			
 580 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 581 | 		{
 582 | 			v2pml[iz][ix]=v2[0][nx-1];
 583 | 		}
 584 | 
 585 | //dl
 586 | 	for(iz=nz+du-1;iz<du+nz+dd;iz++)			
 587 | 	for(ix=0;ix<dl;ix++)
 588 | 		{
 589 | 			v2pml[iz][ix]=v2[nz-1][0];
 590 | 		}
 591 | 
 592 | //dr
 593 | 	for(iz=du+nz-1;iz<du+nz+dd;iz++)			
 594 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 595 | 		{
 596 | 			v2pml[iz][ix]=v2[nz-1][nx-1];
 597 | 		}
 598 | //med
 599 | 	for(iz=du;iz<du+nz;iz++)
 600 | 	for(ix=dl;ix<dl+nx;ix++)
 601 | 		{
 602 | 			v2pml[iz][ix]=v2[iz-du][ix-dl];
 603 | 		}
 604 | 	
 605 | 	for(ix=0;ix<nx_append;ix++)
 606 | 		for(iz=0;iz<nz_append;iz++)
 607 | 			input[ix*nz_append+iz]=v2pml[iz][ix];
 608 | 			
 609 | 	free2float(v2);
 610 | 	free2float(v2pml);
 611 | }
 612 | 
 613 | void read_resultpp_new(float *resultpp,int nx,int nz,int boundary_up,int boundary_down,int boundary_left,int boundary_right,char *filename)
 614 | {
 615 | 	
 616 | 	int ix,iz,nx_append,nz_append;
 617 | 	nx_append=nx+boundary_left+boundary_right;
 618 | 	nz_append=nz+boundary_up+boundary_down;
 619 | 	
 620 | 	float **v2;
 621 | 	v2=alloc2float(nx,nz);
 622 | 	set_zero_2d(v2,nx,nz);
 623 | 	
 624 | 	FILE *fp;
 625 | 	if((fp=fopen(filename,"rb"))==NULL)
 626 | 	{	
 627 | 		printf("Can not oen this file : %s\n",filename);
 628 | 		exit(0);
 629 | 	}
 630 | 
 631 | 	//fp=fopen(filename,"rb");
 632 | 	for(ix=0;ix<nx;ix++)
 633 | 		for(iz=0;iz<nz;iz++)
 634 | 			fread(&v2[iz][ix],4,1,fp);
 635 | 		fclose(fp);
 636 | 		
 637 | 	float **v2pml;
 638 | 	v2pml=alloc2float(nx_append,nz_append);
 639 | 	set_zero_2d(v2pml,nx_append,nz_append);
 640 | 	
 641 | 	int du,dl,dr,dd;
 642 | 	du=boundary_up;
 643 | 	dd=boundary_down;
 644 | 	dl=boundary_left;
 645 | 	dr=boundary_right;
 646 | 		
 647 | //up	
 648 | 	for(ix=0;ix<nx;ix++)
 649 | 	for(iz=0;iz<du;iz++)
 650 | 		{
 651 | 			
 652 | 			v2pml[iz][ix+dl]=v2[0][ix];
 653 | 		}
 654 | //down	
 655 | 	for(ix=0;ix<nx;ix++)
 656 | 	for(iz=0;iz<dd;iz++)
 657 | 		{
 658 | 			
 659 | 			v2pml[iz+du+nz][ix+dl]=v2[nz-1][ix];
 660 | 		}
 661 | //left	
 662 | 	for(ix=0;ix<dl;ix++)
 663 | 		for(iz=0;iz<nz;iz++)
 664 | 		{
 665 | 			
 666 | 			v2pml[iz+du][ix]=v2[iz][0];
 667 | 		}
 668 | //rigt
 669 | 	for(ix=0;ix<dr;ix++)
 670 | 	for(iz=0;iz<nz;iz++)
 671 | 	
 672 | 		{			
 673 | 			v2pml[iz+du][ix+dl+nx]=v2[iz][nx-1];
 674 | 		}
 675 | //four corner
 676 | 
 677 | //ul
 678 | 	for(iz=0;iz<du;iz++)			
 679 | 	for(ix=0;ix<dl;ix++)
 680 | 		{
 681 | 			v2pml[iz][ix]=v2[0][0];
 682 | 		}
 683 | 
 684 | //ur
 685 | 	for(iz=0;iz<du;iz++)			
 686 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 687 | 		{
 688 | 			v2pml[iz][ix]=v2[0][nx-1];
 689 | 		}
 690 | 
 691 | //dl
 692 | 	for(iz=nz+du-1;iz<du+nz+dd;iz++)			
 693 | 	for(ix=0;ix<dl;ix++)
 694 | 		{
 695 | 			v2pml[iz][ix]=v2[nz-1][0];
 696 | 		}
 697 | 
 698 | //dr
 699 | 	for(iz=du+nz-1;iz<du+nz+dd;iz++)			
 700 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 701 | 		{
 702 | 			v2pml[iz][ix]=v2[nz-1][nx-1];
 703 | 		}
 704 | //med
 705 | 	for(iz=du;iz<du+nz;iz++)
 706 | 	for(ix=dl;ix<dl+nx;ix++)
 707 | 		{
 708 | 			v2pml[iz][ix]=v2[iz-du][ix-dl];
 709 | 		}
 710 | 	
 711 | 	for(ix=0;ix<nx_append;ix++)
 712 | 		for(iz=0;iz<nz_append;iz++)
 713 | 			resultpp[ix*nz_append+iz]=v2pml[iz][ix];
 714 | 	
 715 | 	free2float(v2);
 716 | 	free2float(v2pml);	
 717 | }
 718 | 
 719 | 
 720 | 
 721 | 
 722 | ///multiple time smooth velocity // multiple time smooth imagingdown
 723 | void cpu_smooth_velocity(float *velocity,int nx_append,int nz_append,int times)
 724 | {
 725 | 	int ix,iz,i;
 726 | 	float *matrix,*wf_append;
 727 | 	matrix=alloc1float(nx_append*nz_append);
 728 | 	wf_append=alloc1float(nx_append*nz_append);	
 729 | 	memset((void *) (matrix), 0, nx_append*nz_append * sizeof (float));
 730 | 	memset((void *) (wf_append), 0, nx_append*nz_append * sizeof (float));
 731 | 		
 732 | 	for(ix=0;ix<nx_append;ix++)
 733 | 		for(iz=0;iz<nz_append;iz++)
 734 | 			wf_append[ix*nz_append+iz]=velocity[ix*nz_append+iz];
 735 | 		
 736 | 		
 737 | 	for(i=0;i<times;i++)
 738 | 	{
 739 | //exchange
 740 | 	for(ix=0;ix<nx_append;ix++)
 741 | 		for(iz=0;iz<nz_append;iz++)
 742 | 				wf_append[ix*nz_append+iz]=velocity[ix*nz_append+iz];
 743 | //smooth
 744 | 		for(ix=1;ix<nx_append-1;ix++)
 745 | 			for(iz=1;iz<nz_append-1;iz++)
 746 | 				matrix[ix*nz_append+iz]=(wf_append[ix*nz_append+iz]+wf_append[(ix+1)*nz_append+iz]+wf_append[(ix-1)*nz_append+iz]+wf_append[ix*nz_append+iz+1]+wf_append[ix*nz_append+iz-1])*1.0/5;
 747 | 		for(ix=1;ix<nx_append-1;ix++)
 748 | 			for(iz=1;iz<nz_append-1;iz++)
 749 | 				wf_append[ix*nz_append+iz]=matrix[ix*nz_append+iz];
 750 | //exchange
 751 | 	for(ix=0;ix<nx_append;ix++)
 752 | 		for(iz=0;iz<nz_append;iz++)
 753 | 				velocity[ix*nz_append+iz]=wf_append[ix*nz_append+iz];
 754 | 	}
 755 | 
 756 | 		free1float(matrix);
 757 | 		free1float(wf_append);
 758 | }
 759 | 
 760 | void smooth_imagingdown(float *wf,int nx,int nz,int smooth_denominator_time)
 761 | {
 762 | 		int ix,iz,itime;
 763 | 		float *wf1,*wf2;
 764 | 		wf1=alloc1float(nx*nz);
 765 | 		wf2=alloc1float(nx*nz);
 766 | 		memset((void *) (wf1), 0, nx*nz * sizeof (float));
 767 | 		memset((void *) (wf2), 0, nx*nz * sizeof (float));
 768 | //exchange
 769 | 		for(int ix=0;ix<nx;ix++)
 770 | 			for(int iz=0;iz<nz;iz++)
 771 | 				{
 772 | 					wf1[ix*nz+iz]=wf[ix*nz+iz];
 773 | 					wf2[ix*nz+iz]=wf[ix*nz+iz];
 774 | 				}
 775 | //smooth	imagingdown
 776 | 
 777 | 		for(itime=0;itime<smooth_denominator_time;itime++)
 778 | 			{
 779 | 				for(ix=2;ix<nx-2;ix++)
 780 | 					for(iz=2;iz<nz-2;iz++)
 781 | 						{
 782 | 							wf1[ix*nz+iz]=(wf2[ix*nz+iz]+wf2[(ix+1)*nz+iz]+wf2[(ix+2)*nz+iz]+wf2[(ix-2)*nz+iz]+wf2[(ix-1)*nz+iz])/5;			
 783 | 						}
 784 | 				for(ix=2;ix<nx-2;ix++)
 785 | 					for(iz=2;iz<nz-2;iz++)	
 786 | 						wf2[ix*nz+iz]=wf1[ix*nz+iz];
 787 | 		}	
 788 | //exchange
 789 | 		for(int ix=0;ix<nx;ix++)
 790 | 			for(int iz=0;iz<nz;iz++)
 791 | 				wf[ix*nz+iz]=wf2[ix*nz+iz];
 792 | 
 793 | 		free1float(wf1);
 794 | 		free1float(wf2);
 795 | 
 796 | }
 797 | 
 798 | 
 799 | 
 800 | ////  caculate max or min or average
 801 | float caculate_average(float *matrix,int nx,int nz)
 802 | {
 803 | 	float average;
 804 | 	float sum;
 805 | 	sum=0;
 806 | 	int ix,iz;
 807 | 	for(ix=0;ix<nx;ix++)
 808 | 		for(iz=10;iz<nz;iz++)
 809 | 			{
 810 | 				sum+=matrix[ix*nz+iz];
 811 | 			}
 812 | 
 813 | 	average=sum*1.0/(nz-10)/nx;
 814 | 	
 815 | 	return(average);	
 816 | }
 817 | 
 818 | float caculate_average_new(float *matrix,int nx,int nz)
 819 | {
 820 | 	float average;
 821 | 	float sum;
 822 | 	sum=0;
 823 | 	int ix,iz;
 824 | 	for(ix=0;ix<nx;ix++)
 825 | 		for(iz=0;iz<nz;iz++)
 826 | 			{
 827 | 				sum+=matrix[ix*nz+iz];
 828 | 			}
 829 | 
 830 | 	average=sum*1.0/nz/nx;
 831 | 	
 832 | 	return(average);	
 833 | }
 834 | 
 835 | float cpu_caculate_max(float *shotgather,int nx,int nz)
 836 | {
 837 | 	float max;
 838 | 	int ix,iz;
 839 | 	int in_idx;
 840 | 	max=0;
 841 | 	for(ix=0;ix<nx;ix++)
 842 | 		for(iz=0;iz<nz;iz++)
 843 | 			{
 844 | 				in_idx=ix*nz+iz;
 845 | 				if(shotgather[in_idx]>max)	max=shotgather[in_idx];
 846 | 			}
 847 | 			
 848 | 	return(max);
 849 | }
 850 | 
 851 | float cpu_caculate_min(float *shotgather,int nx,int nz)
 852 | {
 853 | 	float min;
 854 | 	int ix,iz;
 855 | 	int in_idx;
 856 | 	min=0;
 857 | 	for(ix=0;ix<nx;ix++)
 858 | 		for(iz=0;iz<nz;iz++)
 859 | 		{
 860 | 			in_idx=ix*nz+iz;
 861 | 			if(shotgather[in_idx]<min)	min=shotgather[in_idx];
 862 | 		}
 863 | 			
 864 | 	return(min);
 865 | }
 866 | 
 867 | 
 868 | ///// sort one/two dimension array along x or z direction
 869 | void sort_x(float *shotgather,int nx,int nz,int location_x,char *filename)
 870 | {
 871 | 	
 872 | 	float *matrix;
 873 | 	matrix=alloc1float(nz);
 874 | 
 875 | 	int iz;
 876 | 	for(iz=0;iz<nz;iz++)
 877 | 		matrix[iz]=shotgather[location_x*nz+iz];
 878 | 
 879 | 	write_file_1d(matrix,nz,filename);
 880 | 	
 881 | 	free1float(matrix);
 882 | }
 883 | 
 884 | void sort_x_2d(float **shotgather,int nx,int nz,int location_x,char *filename)
 885 | {
 886 | 	
 887 | 	float *matrix;
 888 | 	matrix=alloc1float(nz);
 889 | 
 890 | 	int iz;
 891 | 	for(iz=0;iz<nz;iz++)
 892 | 		matrix[iz]=shotgather[iz][location_x];
 893 | 
 894 | 	write_file_1d(matrix,nz,filename);
 895 | 	
 896 | 	free1float(matrix);
 897 | }
 898 | 
 899 | void sort_z(float *shotgather,int nx,int nz,int location_z,char *filename)
 900 | {
 901 | 	
 902 | 	float *matrix;
 903 | 	matrix=alloc1float(nx);
 904 | 
 905 | 	int ix;
 906 | 	for(ix=0;ix<nx;ix++)
 907 | 		matrix[ix]=shotgather[ix*nz+location_z];
 908 | 
 909 | 	write_file_1d(matrix,nx,filename);
 910 | 	
 911 | 	free1float(matrix);
 912 | }
 913 | 
 914 | void sort_z_2d(float **shotgather,int nx,int nz,int location_z,char *filename)
 915 | {
 916 | 	
 917 | 	float *matrix;
 918 | 	matrix=alloc1float(nx);
 919 | 
 920 | 	int ix;
 921 | 	for(ix=0;ix<nx;ix++)
 922 | 		matrix[ix]=shotgather[location_z][ix];
 923 | 
 924 | 	write_file_1d(matrix,nx,filename);
 925 | 	
 926 | 	free1float(matrix);
 927 | }
 928 | 
 929 | 
 930 | 
 931 | 
 932 | ////zzzzz: the following is one dimesion Fourier transform  or reversal Fourier transform  and  suhilbt transform
 933 | void DFT_real_to_complex_2d(float **result,complex **datanw,int nx,int nt,float dx,float dt)
 934 | {
 935 | 	int ix,it,iw,nw;
 936 | 	nw=nt;
 937 | 	double change;
 938 | 	
 939 | 	for(ix=0;ix<nx;ix++)
 940 | 		for(iw=0;iw<nw;iw++)
 941 | 		{
 942 | 			datanw[iw][ix].r=0;
 943 | 			datanw[iw][ix].i=0;
 944 | 			for(it=0;it<nt;it++)
 945 | 			{
 946 | 				//dataout[i].r=dataout[i].r+tempc1[j]*cos(i*dk*offset[j])*space[j];
 947 | 				//dataout[i].i=dataout[i].i-tempc1[j]*sin(i*dk*offset[j])*space[j];
 948 | 				change=iw*it*2*PI/nt*1.0;
 949 | 				datanw[iw][ix].r=datanw[iw][ix].r+result[it][ix]*cos(change);
 950 | 				datanw[iw][ix].i=datanw[iw][ix].i-result[it][ix]*sin(change);
 951 | 			}
 952 | 		}
 953 | }
 954 | 
 955 | void DFT_complex_to_complex_2d(complex **result,complex **datanw,int nx,int nt,float dx,float dt)
 956 | {
 957 | 	int ix,it,iw,nw;
 958 | 	nw=nt;
 959 | 	double change;
 960 | 
 961 | 	for(ix=0;ix<nx;ix++)
 962 | 		for(iw=0;iw<nw;iw++)
 963 | 		{
 964 | 			datanw[iw][ix].r=0;
 965 | 			datanw[iw][ix].i=0;
 966 | 			for(it=0;it<nt;it++)
 967 | 			{
 968 | 				//dataout[i].r=dataout[i].r+tempc1[j]*cos(i*dk*offset[j])*space[j];
 969 | 				//dataout[i].i=dataout[i].i-tempc1[j]*sin(i*dk*offset[j])*space[j];
 970 | 				change=iw*it*2*PI/nt*1.0;
 971 | 				datanw[iw][ix].r=datanw[iw][ix].r+(result[it][ix].r*cos(change)+result[it][ix].i*sin(change));
 972 | 				datanw[iw][ix].i=datanw[iw][ix].i+(result[it][ix].i*cos(change)-result[it][ix].r*sin(change));
 973 | 			}
 974 | 		}
 975 | }
 976 | 
 977 | void NDFT_complex_to_real_2d(float **result,complex **datanw,int nx,int nt,float dx,float dt)
 978 | {
 979 | 	int ix,it,iw,nw;
 980 | 	nw=nt;
 981 | 	double change;
 982 | 	
 983 | 	for(ix=0;ix<nx;ix++)
 984 | 		for(it=0;it<nt;it++)
 985 | 		{
 986 | 			result[it][ix]=0.0;
 987 | 			for(iw=0;iw<nw;iw++)
 988 | 			{	
 989 | 				change=iw*it*2*PI/nt*1.0;
 990 | 			
 991 | 				result[it][ix]=result[it][ix]+(datanw[iw][ix].r*cos(change)-datanw[iw][ix].i*sin(change));
 992 | 			}
 993 | 		}
 994 | 		
 995 | 	for(ix=0;ix<nx;ix++)
 996 | 		for(it=0;it<nt;it++)
 997 | 			result[it][ix]=result[it][ix]*1.0/nt;
 998 | }
 999 | 
1000 | void DFT_real_to_complex_1d(float *result_old,complex *result_nw,int nt,int nw,float dt)
1001 | {
1002 | 	int it,iw;
1003 | 	
1004 | 	double change;
1005 | 		
1006 | 	for(iw=0;iw<nw;iw++)
1007 | 		{
1008 | 			result_nw[iw].r=0;
1009 | 			result_nw[iw].i=0;
1010 | 			for(it=0;it<nt;it++)
1011 | 			{
1012 | 				change=iw*it*2*PI/nt*1.0;
1013 | 				result_nw[iw].r=result_nw[iw].r+result_old[it]*cos(change);
1014 | 				result_nw[iw].i=result_nw[iw].i-result_old[it]*sin(change);
1015 | 			}
1016 | 		}
1017 | }
1018 | 
1019 | void DFT_complex_to_complex_1d(complex *result_old,complex *result_nw,int nt,int nw,float dt)
1020 | {
1021 | 	int it,iw;
1022 | 	
1023 | 	double change;
1024 | 	
1025 | 		for(iw=0;iw<nw;iw++)
1026 | 		{
1027 | 			result_nw[iw].r=0;
1028 | 			result_nw[iw].i=0;
1029 | 			for(it=0;it<nt;it++)
1030 | 			{			
1031 | 				change=iw*it*2*PI/nt*1.0;
1032 | 				
1033 | 				result_nw[iw].r=result_nw[iw].r+(result_old[it].r*cos(change)+result_old[it].i*sin(change));
1034 | 				
1035 | 				result_nw[iw].i=result_nw[iw].i+(result_old[it].i*cos(change)-result_old[it].r*sin(change));
1036 | 			}
1037 | 		}
1038 | }
1039 | 
1040 | void NDFT_complex_to_real_1d(float *result_old,complex *result_nw,int nt,int nw,float dt)
1041 | {
1042 | 	int it,iw;
1043 | 
1044 | 	double change;
1045 | 	
1046 | 	for(it=0;it<nt;it++)
1047 | 		{
1048 | 			result_old[it]=0.0;
1049 | 			for(iw=0;iw<nw;iw++)
1050 | 			{	
1051 | 				change=iw*it*2*PI/nt*1.0;
1052 | 			
1053 | 				result_old[it]=result_old[it]+(result_nw[iw].r*cos(change)-result_nw[iw].i*sin(change));
1054 | 			}
1055 | 		}
1056 | 		
1057 | 	for(it=0;it<nt;it++)
1058 | 		result_old[it]=result_old[it]*1.0/nt;
1059 | }
1060 | 
1061 | void suhilbt(float *result_old,float *result_h,int nx_append,int nz_append,int nx,int nz,int boundary_left,int boundary_up,float dx,float dz)
1062 | {
1063 | 	int ix,iz,iw;
1064 | 	int nw,nt;
1065 | 	nt=nz;
1066 | 	
1067 | 	float **result;
1068 | 	result=alloc2float(nx,nz);
1069 | 	
1070 | 	for(ix=0;ix<nx;ix++)
1071 | 		for(iz=0;iz<nz;iz++)
1072 | 			result[iz][ix]=result_old[(ix+boundary_left)*nz_append+iz+boundary_up];
1073 | 					
1074 | //for convenience we use it replace with iz
1075 | 	nw=nt;
1076 | 	
1077 | 	complex **datanw;
1078 | 	datanw=alloc2complex(nx,nw);
1079 | 	
1080 | 	DFT_real_to_complex_2d(result,datanw,nx,nt,dx,dz);
1081 | 	
1082 | //hilbert transform
1083 | 	float change_r,change_i;
1084 | 		
1085 | 	for(ix=0;ix<nx;ix++)
1086 | 		for(iw=0;iw<nw/2;iw++)
1087 | 			{
1088 | 				change_r=datanw[iw][ix].r;change_i=datanw[iw][ix].i;
1089 | 				datanw[iw][ix].r=change_i;
1090 | 				datanw[iw][ix].i=-1*change_r;
1091 | 			}
1092 | 	for(ix=0;ix<nx;ix++)
1093 | 		for(iw=nw/2;iw<nw;iw++)
1094 | 			{
1095 | 				change_r=datanw[iw][ix].r;change_i=datanw[iw][ix].i;
1096 | 				datanw[iw][ix].r=-1*change_i;
1097 | 				datanw[iw][ix].i=change_r;
1098 | 			}
1099 | 
1100 | 	NDFT_complex_to_real_2d(result,datanw,nx,nt,dx,dz);
1101 | 	
1102 | 	for(ix=0;ix<nx;ix++)
1103 | 		for(iz=0;iz<nz;iz++)
1104 | 			result_h[(ix+boundary_left)*nz_append+iz+boundary_up]=result[iz][ix];	
1105 | 	
1106 | 	free2float(result);
1107 | 	free2complex(datanw);	
1108 | 
1109 | }
1110 | 
1111 | 
1112 | 
1113 | 
1114 | ///intergrating_seismic  and derivation 
1115 | void intergrating_seismic(float *shotgather,int lt,int receiver_num)
1116 | {
1117 | 		int ix,it;
1118 | 		int i,j;
1119 | 		float *exchange;
1120 | 		exchange=alloc1float(lt);
1121 | 		set_zero_1d(exchange,lt);
1122 | 
1123 | 		for(ix=0;ix<receiver_num;ix++)	
1124 | 		{
1125 | 			for(it=0;it<lt;it++)				
1126 | 				exchange[it]=shotgather[ix*lt+it];
1127 | 			for(i=0;i<lt;i++)
1128 | 				for(j=0;j<i;j++)
1129 | 					shotgather[ix*lt+i]+=exchange[j];	
1130 | 		}		
1131 | 			
1132 | 		free1float(exchange);
1133 | }
1134 | 
1135 | void derivation(float *wavelet,int wavelet_length,float *coe)
1136 | {
1137 | 	int ix;
1138 | 	float *matrix;
1139 | 	matrix=alloc1float(wavelet_length);
1140 | 	set_zero_1d(matrix,wavelet_length);
1141 | 
1142 | 	for(ix=6;ix<wavelet_length;ix++)
1143 | 		matrix[ix]=matrix[ix]+coe[1]*(wavelet[ix]-wavelet[ix-1])+coe[2]*(wavelet[ix+1]-wavelet[ix-2])+coe[3]*(wavelet[ix+2]-wavelet[ix-3])+coe[4]*(wavelet[ix+3]-wavelet[ix-4])+coe[5]*(wavelet[ix+4]-wavelet[ix-5])+coe[6]*(wavelet[ix+5]-wavelet[ix-6]);
1144 | 	
1145 | 	for(ix=6;ix<wavelet_length;ix++)
1146 | 		wavelet[ix]=matrix[ix];
1147 | }
1148 | 
1149 | 
1150 | 
1151 | 
1152 | /////laplace based on two or four order
1153 | void laplace(float *result,float *velocity,int nx,int nz,int nx_append,int nz_append,int boundary_left,int boundary_up,float dx,float dz)
1154 | {
1155 | 	int ix,iz,in_idx;
1156 | 	float v;
1157 | 	float *result1;
1158 | 	result1=alloc1float(nx*nz);
1159 | 	memset((void *)(result1),0,nx*nz*sizeof (float));
1160 | 
1161 | 	for(ix=0;ix<nx;ix++)
1162 | 		for(iz=0;iz<nz;iz++)
1163 | 			{
1164 | 				in_idx=ix*nz+iz;
1165 | 				if(ix==0||iz==0||ix==nx-1||iz==nz-1)	result1[in_idx]=-1*result[in_idx];
1166 | 				//t[iz][ix]=-(r[iz][ix+1]+r[iz][ix-1]-2*r[iz][ix])/dx2 - (r[iz+1][ix]+r[iz-1][ix]-2*r[iz][ix])/dz2;
1167 | 				else	result1[in_idx]=-1*((result[in_idx+nz]+result[in_idx-nz]-2*result[in_idx])/dx/dx+(result[in_idx+1]+result[in_idx-1]-2*result[in_idx])/dz/dz);
1168 | 				//t[iz][ix]=-(r[iz][ix+1]+r[iz][ix-1]+r[iz+1][ix]+r[iz-1][ix]-4*r[iz][ix])/dx2 - (r[iz][ix+1]+r[iz][ix-1]+r[iz+1][ix]+r[iz-1][ix]-4*r[iz][ix])/dz2
1169 | 				//else	result1[in_idx]=-1*((result[in_idx+nz]+result[in_idx-nz]+result[in_idx+1]+result[in_idx-1]-4*result[in_idx])/dx/dx+(result[in_idx+nz]+result[in_idx-nz]+result[in_idx+1]+result[in_idx-1]-4*result[in_idx])/dz/dz);
1170 | 			}
1171 | ////it's purpose to avoid boundary effect	
1172 | 	
1173 | 		for(iz=0;iz<nz;iz++)
1174 | 		{
1175 | 				result1[iz]=result1[nz+iz];
1176 | 				result1[(nx-1)*nz+iz]=result1[(nx-2)*nz+iz];
1177 | 				result1[iz*nz]=result1[iz*nz+1];
1178 | 				result1[iz*nz+nz-1]=result1[iz*nz+nz-2];
1179 | 		}
1180 | 			
1181 | 	for(ix=0;ix<nx;ix++)
1182 | 		for(iz=0;iz<nz;iz++)
1183 | 			{
1184 | 				v=velocity[(ix+boundary_left)*nz_append+iz+boundary_up];
1185 | 				result[ix*nz+iz]=v*v*result1[ix*nz+iz]/4;		
1186 | 			}
1187 | 			
1188 | 			
1189 | 	free1float(result1);
1190 | }
1191 | 
1192 | 
1193 | 
1194 | 
1195 | ///two program for extracting angle domain image gathers
1196 | void linear_interpolation(float *initial1,int nx,int nz,int angle_radius)
1197 | {
1198 | 	int ix,iz;
1199 | 
1200 | 	float **result1,**result2;;
1201 | 	result1=alloc2float(nx,nz);
1202 | 	result2=alloc2float(nx,nz);
1203 | 	for(ix=0;ix<nx;ix++)
1204 | 		for(iz=0;iz<nz;iz++)
1205 | 			{
1206 | 				result1[iz][ix]=initial1[ix*nz+iz];
1207 | 				result2[iz][ix]=initial1[ix*nz+iz];
1208 | 			}
1209 | 	for(ix=2;ix<nx-2;ix++)
1210 | 		for(iz=2;iz<nz-2;iz++)
1211 | 			{
1212 | 				if(result1[iz][ix]==0&&ix!=angle_radius-1)	result2[iz][ix]=(result1[iz][ix+1]+result1[iz][ix-1]+result1[iz][ix+2]+result1[iz][ix-2])/4.0;
1213 | 			}
1214 | 						
1215 | 	for(ix=0;ix<nx;ix++)
1216 | 		for(iz=0;iz<nz;iz++)
1217 | 			initial1[ix*nz+iz]=result2[iz][ix];
1218 | 
1219 | 	free2float(result1);
1220 | 	free2float(result2);
1221 | }
1222 | 
1223 | void add_cdp(float *r_adcigs,float *sum_cdp_pp,int nx,int nz,int id,int cdp_num,int angle_radius)
1224 | {
1225 | 	int ix,iz;
1226 | 	for(ix=0;ix<nx;ix++)
1227 | 		for(iz=0;iz<nz;iz++)
1228 | 			sum_cdp_pp[(ix+id*nx)*nz+iz]=r_adcigs[ix*nz+iz];
1229 | }
1230 | 
1231 | 
1232 | 
1233 | 
1234 | ////exchange to reduce nx_append to nx ///// nz_append to nz
1235 | void exchange(float *matrix1,float *matrix2,int nx,int nz,int nx_append,int nz_append,int boundary_left,int boundary_up)
1236 | {
1237 | 	int ix,iz;
1238 | 	for(ix=0;ix<nx;ix++)
1239 | 		for(iz=0;iz<nz;iz++)
1240 | 			matrix2[ix*nz+iz]=matrix1[(ix+boundary_left)*nz_append+iz+boundary_up];
1241 | }
1242 | /////  accumulation
1243 | void sum_result(float *result,float *wf,int nx,int nz)
1244 | {
1245 | 	int ix,iz;
1246 | 	for(ix=0;ix<nx;ix++)
1247 | 		for(iz=0;iz<nz;iz++)
1248 | 			result[ix*nz+iz]+=wf[ix*nz+iz];
1249 | }
1250 | 
1251 | void sum_result_new(float *result,float *wf,int nx,int nz,int imaging_size,int imaging_start)
1252 | {
1253 | 	int ix,iz;
1254 | 	for(ix=0;ix<imaging_size;ix++)
1255 | 		for(iz=0;iz<nz;iz++)
1256 | 			result[(ix+imaging_start)*nz+iz]+=wf[ix*nz+iz];
1257 | }
1258 | void sum_adcigs_new(float *adcigs_pp,float *r_adcigs_pp,int nx,int nz,int angle_num,int imaging_size,int imaging_start)
1259 | {
1260 | 	int ix,iz,iangle;
1261 | 	for(iangle=0;iangle<angle_num*2;iangle++)
1262 | 		for(ix=0;ix<imaging_size;ix++)
1263 | 			for(iz=0;iz<nz;iz++)		
1264 | 				adcigs_pp[iangle*nx*nz+(ix+imaging_start)*nz+iz]+=r_adcigs_pp[iangle*nx*nz+ix*nz+iz];		
1265 | }
1266 | 
1267 | void cpu_output_cdp(float *adcigs_pp,float *cdp_all,float *cdp_radius,int cdp_location,int angle_num,int angle_radius,int nx,int nz)
1268 | /////cpu_output_cdp(	   adcigs_pp,	  cdp_all,	      cdp_radius,   cdp_location[id],angle_num,	   angle_radius,    nx,    nz);
1269 | {
1270 | 	int iz,iangle;
1271 | 	
1272 | 	for(iangle=0;iangle<angle_num*2;iangle++)
1273 | 		for(iz=0;iz<nz;iz++)
1274 | 			cdp_all[iangle*nz+iz]=adcigs_pp[iangle*nx*nz+cdp_location*nz+iz];
1275 | 			
1276 | 	for(iangle=angle_num-angle_radius;iangle<angle_num+angle_radius;iangle++)	
1277 | 		for(iz=0;iz<nz;iz++)
1278 | 			cdp_all[iangle*nz+iz]=adcigs_pp[iangle*nx*nz+cdp_location*nz+iz];	
1279 | }
1280 | 
1281 | void sum_cpu_output_cdp(float *cdp_all,float *cdp_radius,float *sum_cdp_ps_all,float *sum_cdp_ps_radius,int angle_num,int angle_radius,int nz,int id,int cdp_num)
1282 | /////sum_cpu_output_cdp		 cdp_all,	    cdp_radius,	    sum_cdp_ps_all,	  sum_cdp_ps_radius,	angle_num,	  angle_radius,	 nz,	  id,	   cdp_num)
1283 | {
1284 | 	int ix,iz;
1285 | 	for(ix=0;ix<2*angle_num;ix++)
1286 | 		for(iz=0;iz<nz;iz++)
1287 | 			sum_cdp_ps_all[(ix+id*2*angle_num)*nz+iz]=cdp_all[ix*nz+iz];
1288 | 
1289 | 	for(ix=0;ix<2*angle_radius;ix++)
1290 | 		for(iz=0;iz<nz;iz++)
1291 | 			sum_cdp_ps_radius[(ix+id*2*angle_radius)*nz+iz]=cdp_all[ix*nz+iz];
1292 | }
1293 | 
1294 | void cpu_replace(float *velocity,float *s_velocity,int nx_append,int nz_append)
1295 | {
1296 | 	int ix,iz;
1297 | 	for(ix=0;ix<nx_append;ix++)
1298 | 		for(iz=0;iz<nz_append;iz++)
1299 | 		{
1300 | 			s_velocity[ix*nz_append+iz]=velocity[ix*nz_append+iz];
1301 | 		}
1302 | }
1303 | 
1304 | void vp_set_vs(float *velocity,float *velocity1,int nx_append,int nz_append)
1305 | {
1306 | 	int ix,iz;
1307 | 	
1308 | 	for(ix=0;ix<nx_append;ix++)
1309 | 		for(iz=0;iz<nz_append;iz++)
1310 | 		{
1311 | 			velocity1[ix*nz_append+iz]=velocity[ix*nz_append+iz]/sqrt(3)*1.0;
1312 | 		}
1313 | }
1314 | 
1315 | void vp_set_density(float *velocity,float *s_density,int nx_append,int nz_append)
1316 | {
1317 | 	int ix,iz;
1318 | 	
1319 | 	for(ix=0;ix<nx_append;ix++)
1320 | 		for(iz=0;iz<nz_append;iz++)
1321 | 		{
1322 | 			s_density[ix*nz_append+iz]=1000*0.23*sqrt(sqrt(velocity[ix*nz_append+iz]));
1323 | 	
1324 | 			//s_density[ix*nz_append+iz]=1000;
1325 | 		
1326 | 			//s_density[ix*nz_append+iz]=1500;
1327 | 
1328 | 			//s_density[ix*nz_append+iz]=1;
1329 | 		}
1330 | }
1331 | 
1332 | void vp_set_density_acousitc(float *velocity,float *s_density,int nx_append,int nz_append)
1333 | {
1334 | 	int ix,iz;
1335 | 	
1336 | 	for(ix=0;ix<nx_append;ix++)
1337 | 		for(iz=0;iz<nz_append;iz++)
1338 | 		{
1339 | 			s_density[ix*nz_append+iz]=1000*0.23*sqrt(sqrt(velocity[ix*nz_append+iz]));
1340 | 			
1341 | 			//s_density[ix*nz_append+iz]=1000;
1342 | 		}
1343 | }
1344 | 
1345 | void cpu_cal_perturb_velocity_to_velocity(float *velocity,float *velocity1,float *density,float *s_velocity,float *s_velocity1,float *s_density,int nx,int nz,int nx_append,int nz_append,int boundary_left,int boundary_up,int p_vp,int p_vs,int p_density,int mark)
1346 | {
1347 | 		int ix,iz;
1348 | 		int id;	
1349 | 		for(ix=0;ix<nx_append;ix++)
1350 | 		for(iz=0;iz<nz_append;iz++)
1351 | 		{
1352 | 			id=ix*nz_append+iz;	
1353 | 			s_velocity[id]=velocity[id];
1354 | 			s_velocity1[id]=velocity1[id];
1355 | 			s_density[id]=density[id];
1356 | 		}
1357 | 
1358 | 		if(mark==1)
1359 | 		{	
1360 | 			id=(boundary_left+nx/2)*nz_append+boundary_up+2*nz/4;	
1361 | 			s_velocity[id]=s_velocity[id]+p_vp;		
1362 | 		}
1363 | 
1364 | 		if(mark==2)
1365 | 		{	
1366 | 			id=(boundary_left+nx/2)*nz_append+boundary_up+2*nz/4;	
1367 | 			s_velocity1[id]=s_velocity1[id]+p_vs;				
1368 | 		}
1369 | 
1370 | 		if(mark==3)
1371 | 		{	
1372 | 			id=(boundary_left+nx/2)*nz_append+boundary_up+2*nz/4;	
1373 | 			s_density[id]=s_density[id]+p_density;
1374 | 		}
1375 | 
1376 | 
1377 | }
1378 | 
1379 | 
1380 | void cal_cpu_error_random(float *error_random,int amplitude_error_number,int receiver_num,int receiver_interval)
1381 | {
1382 | 		srand((unsigned)time(NULL));
1383 | 
1384 | 		int ix;
1385 | 
1386 | 		int change;
1387 | 
1388 | 		int count1=0,count2=0;
1389 | 
1390 | 		int *ranc;
1391 | 		ranc=alloc1int(amplitude_error_number);
1392 | 
1393 | 		//float *ranc1;
1394 | 		//ranc1=alloc1float(amplitude_error_number);
1395 | 		
1396 | 		int *ranc1;
1397 | 		ranc1=alloc1int(amplitude_error_number);
1398 | 
1399 | 
1400 | 		for(ix=0;ix<amplitude_error_number;ix++)
1401 | 		{
1402 | 			ranc[ix]=rand()%receiver_num;
1403 | 			
1404 | 			//printf("ranc[ix]=%d\n",ranc[ix]);
1405 | 		}
1406 | 
1407 | 		for(ix=0;ix<amplitude_error_number;ix++)
1408 | 		{
1409 | 			ranc1[ix]=rand()%100;
1410 | 
1411 | 			ranc1[ix]=ranc1[ix]%2;
1412 | 			
1413 | 			//printf("ranc[ix]=%d\n",ranc1[ix]);
1414 | 		}
1415 | 
1416 | 		for(ix=0;ix<amplitude_error_number;ix++)
1417 | 		{
1418 | 			change=int(ranc[ix]);
1419 | 
1420 | 			//error_random[change]=ranc1[ix];
1421 | 
1422 | 			if(ranc1[ix]==1)	
1423 | 			{
1424 | 				error_random[change]=6;
1425 | 				count1++;
1426 | 			}
1427 | 
1428 | 			if(ranc1[ix]!=1)
1429 | 			{
1430 | 				error_random[change]=1.0/6;//////1.0/6  is important
1431 | 				count2++;
1432 | 			}
1433 | 		}
1434 | 
1435 | 		for(ix=0;ix<receiver_num;ix++)
1436 | 		{
1437 | 			if(error_random[ix]==0)		error_random[ix]=1.0;
1438 | 		}
1439 | 
1440 | 		printf("count1=%d\n",count1);
1441 | 		printf("count2=%d\n",count2);
1442 | 		
1443 | 		free1int(ranc);
1444 | 		//free1float(ranc1);
1445 | 		free1int(ranc1);
1446 | }
1447 | 
1448 | void cal_cpu_shot_scale(float *shot_scale_h,int shot_num,int shot_scale)
1449 | {
1450 | 		srand((unsigned)time(NULL));
1451 | 
1452 | 		int ix;
1453 | 
1454 | 		//int change;
1455 | 
1456 | 		int *ranc;
1457 | 		ranc=alloc1int(shot_num);
1458 | 
1459 | 		//float *ranc1;
1460 | 		//ranc1=alloc1float(amplitude_error_number);
1461 | 
1462 | 
1463 | 		for(ix=0;ix<shot_num;ix++)
1464 | 		{
1465 | 			ranc[ix]=rand()%(shot_scale)+1;
1466 | 		}
1467 | 
1468 | 		
1469 | 		for(ix=0;ix<shot_num;ix++)
1470 | 		{
1471 | 			shot_scale_h[ix]=ranc[ix];
1472 | 
1473 | 			printf("shot_scale_h[ix]=%f\n",shot_scale_h[ix]);
1474 | 		}	
1475 | 		
1476 | 		free1int(ranc);
1477 | 		//free1float(ranc1);
1478 | 		//free1int(ranc1);
1479 | 
1480 | 
1481 | }
1482 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/3D_elastic_modeling_parameter:
--------------------------------------------------------------------------------
  1 | 
  2 | //////////////////////GPU_switch  GPU_start GPU_N
  3 | 		int RTM;
  4 | 		int GPU_switch,GPU_N,GPU_start;
  5 | 		int exchange_device_bool;
  6 | 
  7 | ///////////////////////one half of space-domain
  8 | 		//int radius;
  9 | 		
 10 | ///////////////////////lt dt freq
 11 | 		int lt;		
 12 | 		float dt,freq;
 13 | 
 14 | 
 15 | ////////////////////////if or else join model parameter
 16 | 		char *infile_shot_name;
 17 | 		int join_vs,join_den,join_shot,join_wavefield,wavefield_interval;
 18 | 
 19 | 
 20 | /////////////////////model parameter
 21 | 		int nx,ny,nz;
 22 | 		float dx,dy,dz;
 23 | 
 24 | 
 25 | /////////////////////shot parameter
 26 | 		int shot_num_x,shot_num_y,shot_num_z;
 27 | 		int shot_start_x,shot_interval_x;
 28 | 		int shot_start_y,shot_interval_y;
 29 | 		int shot_start_z,shot_interval_z;
 30 | 
 31 | 		
 32 | /////////////////////receiver parameter
 33 | 		int receiver_num_x,receiver_num_y,receiver_num_z;
 34 | 		int receiver_start_x,receiver_interval_x;
 35 | 		int receiver_start_y,receiver_interval_y;
 36 | 		int receiver_start_z,receiver_interval_z;
 37 | 		int receiver_offset,receiver_mark;
 38 | 
 39 | 	
 40 | /////////////////////boundary parameter
 41 | 		int bu,bd,bl,br,bf,bb;
 42 | 		//int boundary_up,boundary_down,boundary_left,boundary_right,boundary_front,boundary_back;
 43 | 		float coe_att;
 44 | 
 45 | 		
 46 | /////////////////////velocity and density parameter
 47 | 		float velocity_multiple,smooth_time_vp,smooth_time_vs,smooth_time_density;
 48 | 	
 49 | 
 50 | 		char *velocity_name;	
 51 | 
 52 | 		char *velocity1_name;		
 53 | 
 54 | 		char *density_name;
 55 | 
 56 | 				
 57 | 		char *s_velocity_name;
 58 | 		
 59 | 		char *s_velocity1_name;
 60 | 	
 61 | 		char *s_density_name;
 62 | 		
 63 | //////////////////////some precondition operation
 64 | 
 65 | 		int add_receiver_bool;
 66 | 		int cut_direct_wave;
 67 | 		int laplace,laplace_compensate;
 68 | 		int vsp,vsp_precon;
 69 | 		int precon,precon_z1,precon_z2;	
 70 | 
 71 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 72 | ////////////////////////////////////////////////The below space don't need to input in sh program////////////////////////////////////////////////////
 73 | ////////////////////////////////////////////////The below space don't need to input in sh program////////////////////////////////////////////////////		
 74 | ////////////////////////////////////////////////The below space don't need to input in sh program////////////////////////////////////////////////////
 75 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 76 | 
 77 | #define MAX_GPU_COUNT 6
 78 | #define radius 6
 79 | #define pai 3.1415926
 80 | #define Block_Size  512	/* vector computation blocklength */
 81 | #define scale 9
 82 | 
 83 | /////record time 
 84 | 
 85 | 		clock_t first_time,end_time;
 86 | 		double duration_time;
 87 | 
 88 | 		float mstimer=0.0,totaltime_Modeling=0.0,totaltime_RTM=0.0;
 89 | 
 90 | ///////filenmae
 91 | 		char filename[500],filename1[500],filename2[500];
 92 | 
 93 | 		FILE *logfile=NULL,*openfile=NULL;
 94 | 
 95 | /////////////////GPU
 96 | 		int GPU_Read;
 97 | 		int gpuid[MAX_GPU_COUNT];
 98 | 
 99 | /////////////////array
100 | 		int wavelet_length,wavelet_half;
101 | 		float *wavelet,*wavelet_integral;
102 | 		
103 | 		float *coe_opt;
104 | 
105 | 		float *velocity_pml,*velocity1_pml,*density_pml;
106 | 		float *att_pml;
107 | 
108 | 		float *shot_xy_id;
109 | 				
110 | 		float *wf_3d;
111 | ////////////////int or float 
112 | 
113 | 		float coe_x,coe_y,coe_z;
114 | 
115 | 		int nnx,nny,nnz;
116 | 		
117 | 		int nnz_device,nnz_device_append,nnz_residual;
118 | 
119 | 		int nnx_radius,nny_radius,nnz_radius;
120 | 
121 | 
122 | 		
123 | 		int ix,iy,iz;
124 | 		int it,izz;
125 | 
126 | 		float gpu_memory_size;
127 | 
128 | 
129 | 		int is,isx,isy,isz;
130 | 		int sx,sy,sz;
131 | 		int sx_real,sy_real,sz_real;
132 | 		int choose_ns;
133 | 
134 | 		int rx_max,ry_max,rz_max;
135 | 		int choose_re;
136 | 
137 | 		float ***obs_shot_x_all,***obs_shot_y_all,***obs_shot_z_all;
138 | 		
139 | 		float amp_max=0,tp_max=0;
140 | 		int amp_max_idx=0,tp_max_idx=0;
141 | 		int wavefield_mul;
142 | 
143 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/3D_elastic_modeling_parameter_sh:
--------------------------------------------------------------------------------
  1 | 
  2 | void elastic_modeling_parameter_input()
  3 | {
  4 | ///////////////////////GPU_switch  GPU_start GPU_N
  5 | 		//int GPU_switch,GPU_N,GPU_start;
  6 | 		if(!getparint("RTM",&RTM))								err("RTM is not set!");
  7 | 		if(!getparint("GPU_switch",&GPU_switch))						err("GPU_switch is not set!");
  8 | 		if(!getparint("GPU_N",&GPU_N))							err("GPU_N is not set!");
  9 | 		if(!getparint("GPU_start",&GPU_start))						err("GPU_start is not set!");
 10 | 		if(!getparint("exchange_device_bool",&exchange_device_bool))			err("exchange_device_bool is not set!");
 11 | 
 12 | ///////////////////////one half of space-domain
 13 | 		//int radius;
 14 | 		//if(!getparint("radius",&radius))				err("radius is not set!");///radius  radius radius radius radius
 15 | 
 16 | ///////////////////////lt dt freq
 17 | 		//int lt;		
 18 | 		//float dt,freq;
 19 | 
 20 | 		if(!getparint("lt",&lt))					err("lt is not set!");
 21 | 		if(!getparfloat("dt",&dt))					err("dt is not set!");
 22 | 		if(!getparfloat("freq",&freq))				err("freq is not set!");
 23 | 
 24 | 
 25 | //////////////////////if or else
 26 | 		//int join_vs,join_den,join_shot,join_wavefield,wavefield_interval;
 27 | 
 28 | 		if(!getparint("join_vs",&join_vs))				err("join_vs is not set!");////join_vs=1 denote input s wave velocity(velocity1)
 29 | 		if(!getparint("join_den",&join_den))			err("join_den is not set!");////join_den=1 denote input density
 30 | 		if(!getparint("join_shot",&join_shot))			err("join_shot is not set!");////join_shot=1 denote obs_x_shot and obs_z_shot has gotten
 31 | 		if(!getparint("join_wavefield",&join_wavefield))		err("join_wavefield is not set!");////join_shot=1 denote obs_x_shot and obs_z_shot has gotten
 32 | 		if(!getparint("wavefield_interval",&wavefield_interval))	err("wavefield_interval is not set!");////join_shot=1 denote obs_x_shot and obs_z_shot has gotten
 33 | 		if(!getparstring("infile_shot_name",&infile_shot_name))	err("infile_shot_name is not set!");////join_shot=1 denote obs_x_shot and obs_z_shot has gotten
 34 | /////////////////////model parameter
 35 | 		//int nx,ny,nz;
 36 | 		//float dx,dy,dz;
 37 | 
 38 | 		if(!getparint("nx",&nx))					err("nx is not set!");
 39 | 		if(!getparint("ny",&ny))					err("ny is not set!");
 40 | 		if(!getparint("nz",&nz))					err("nz is not set!");
 41 | 
 42 | 		if(!getparfloat("dx",&dx))					err("dx is not set!");
 43 | 		if(!getparfloat("dy",&dy))					err("dy is not set!");
 44 | 		if(!getparfloat("dz",&dz))					err("dz is not set!");
 45 | 
 46 | /////////////////////shot parameter
 47 | 		//int shot_num_x,shot_num_y,shot_num_z;
 48 | 		//int shot_start_x,shot_interval_x;
 49 | 		//int shot_start_y,shot_interval_y;
 50 | 		//int shot_start_z,shot_interval_z;
 51 | 
 52 | 		if(!getparint("shot_num_x",&shot_num_x))				err("shot_num_x is not set!");
 53 | 		if(!getparint("shot_num_y",&shot_num_y))				err("shot_num_y is not set!");
 54 | 		if(!getparint("shot_num_z",&shot_num_z))				err("shot_num_z is not set!");
 55 | 
 56 | 		if(!getparint("shot_start_x",&shot_start_x))			err("shot_start_x is not set!");
 57 | 		if(!getparint("shot_interval_x",&shot_interval_x))			err("shot_interval_x is not set!");
 58 | 
 59 | 		if(!getparint("shot_start_y",&shot_start_y))			err("shot_start_y is not set!");
 60 | 		if(!getparint("shot_interval_y",&shot_interval_y))			err("shot_interval_y is not set!");
 61 | 
 62 | 		if(!getparint("shot_start_z",&shot_start_z))			err("shot_start_z is not set!");
 63 | 		if(!getparint("shot_interval_z",&shot_interval_z))			err("shot_interval_z is not set!");
 64 | 
 65 | 		
 66 | /////////////////////receiver parameter
 67 | 		//int receiver_num_x,receiver_num_y,receiver_num_z;
 68 | 		//int receiver_start_x,receiver_interval_x;
 69 | 		//int receiver_start_y,receiver_interval_y;
 70 | 		//int receiver_start_z,receiver_interval_z;
 71 | 		//int receiver_offset,receiver_mark;
 72 | 
 73 | 		if(!getparint("receiver_num_x",&receiver_num_x))			err("receiver_num_x is not set!");
 74 | 		if(!getparint("receiver_num_y",&receiver_num_y))			err("receiver_num_y is not set!");
 75 | 		if(!getparint("receiver_num_z",&receiver_num_z))			err("receiver_num_z is not set!");
 76 | 
 77 | 		if(!getparint("receiver_start_x",&receiver_start_x))		err("receiver_start_x is not set!");
 78 | 		if(!getparint("receiver_interval_x",&receiver_interval_x))	err("receiver_interval_x is not set!");
 79 | 
 80 | 		if(!getparint("receiver_start_y",&receiver_start_y))		err("receiver_start_y is not set!");
 81 | 		if(!getparint("receiver_interval_y",&receiver_interval_y))	err("receiver_interval_y is not set!");
 82 | 
 83 | 		if(!getparint("receiver_start_z",&receiver_start_z))		err("receiver_start_z is not set!");
 84 | 		if(!getparint("receiver_interval_z",&receiver_interval_z))	err("receiver_interval_z is not set!");
 85 | 		
 86 | 		if(!getparint("receiver_offset",&receiver_offset))			err("receiver_offset is not set!");
 87 | 		if(!getparint("receiver_mark",&receiver_mark))			err("receiver_mark is not set!");
 88 | 
 89 | /////////////////////boundary parameter
 90 | 		//int boundary_up,boundary_down,boundary_left,boundary_right,boundary_front,boundary_back;
 91 | 		//float coe_att;
 92 | 
 93 | 		if(!getparint("boundary_up",&bu))				err("boundary_up is not set!");
 94 | 		if(!getparint("boundary_down",&bd))				err("boundary_down is not set!");
 95 | 
 96 | 		if(!getparint("boundary_left",&bl))				err("boundary_left is not set!");
 97 | 		if(!getparint("boundary_right",&br))			err("boundary_right is not set!");
 98 | 
 99 | 		if(!getparint("boundary_front",&bf))			err("boundary_front is not set!");
100 | 		if(!getparint("boundary_back",&bb))				err("boundary_back is not set!");
101 | 
102 | 		if(!getparfloat("coe_attenuation",&coe_att))		err("coe_attenuation is not set!");
103 | 
104 | /////////////////////velocity and density parameter
105 | 		//float velocity_multiple,smooth_time_vp,smooth_time_vs,smooth_time_density;
106 | 
107 | 		if(!getparfloat("velocity_multiple",&velocity_multiple))		err("velocity_multiple is not set!");///velocity smooth 2017年08月15日 星期二 09时57分09秒
108 | 
109 | 		if(!getparfloat("smooth_time_vp",&smooth_time_vp))			err("smooth_time_vp is not set!");///velocity smooth 2017年08月15日 星期二 09时57分09秒 
110 | 
111 | 		if(!getparfloat("smooth_time_vs",&smooth_time_vs))			err("smooth_time_vs is not set!");///velocity smooth 2017年08月15日 星期二 09时57分09秒
112 | 
113 | 		if(!getparfloat("smooth_time_density",&smooth_time_density))	err("smooth_time_density is not set!");///velocity smooth 2017年08月15日 星期二 09时57分09秒
114 | 
115 | 		//char *velocity_name;
116 | 		if(!getparstring("velocity",&velocity_name))			err("can not read vp model!");
117 | 
118 | 		//char *velocity1_name;
119 | 		if(!getparstring("velocity1",&velocity1_name))			err("can not read vs model!");
120 | 
121 | 		//char *density_name;
122 | 		if(!getparstring("density",&density_name))				err("can not read density model!");		
123 | 
124 | 		//////////2017年03月07日 星期二 21时46分03秒 
125 | 		//char *s_velocity_name;
126 | 		if(smooth_time_vp==0)
127 | 		{		
128 | 			if(!getparstring("s_velocity",&s_velocity_name))		err("can not read s_vp model!");
129 | 
130 | 		}///velocity smooth 2017年08月15日 星期二 09时57分09秒
131 | 
132 | 		//char *s_velocity1_name;
133 | 		if(smooth_time_vs==0)
134 | 		{
135 | 			if(!getparstring("s_velocity1",&s_velocity1_name))		err("can not read s_vs model!");
136 | 		}///velocity smooth 2017年08月15日 星期二 09时57分09秒
137 | 
138 | 		//char *s_density_name;
139 | 		if(smooth_time_density==0)
140 | 		{	
141 | 			if(!getparstring("s_density",&s_density_name))		err("can not read s_density model!");
142 | 		}///velocity smooth 2017年08月15日 星期二 09时57分09秒
143 | 
144 | 
145 | //////////////////////some precondition operation
146 | 		//int  add_receiver_bool;
147 | 		//int laplace,laplace_compensate;
148 | 		//int vsp,vsp_precon;
149 | 
150 | 		if(!getparint("add_receiver_bool",&add_receiver_bool))			err("add_receiver_bool is not set!");
151 | 
152 | 		if(!getparint("cut_direct_wave",&cut_direct_wave))				err("cut_direct_wave is not set!");	
153 | 
154 | 		if(!getparint("laplace",&laplace))						err("laplace is not set!");
155 | 		if(!getparint("laplace_compensate",&laplace_compensate))			err("laplace_compensate is not set!");
156 | 		
157 | 		if(!getparint("vsp",&vsp))							err("vsp is not set!");
158 | 		if(!getparint("vsp_precon",&vsp_precon))					err("vsp_precon is not set!");/////////for vsp???/////////////////for vsp.............2017年03月14日 星期二 08时32分25秒
159 | 
160 | 		if(!getparint("precon",&precon))						err("precon is not set!");
161 | 		if(!getparint("precon_z1",&precon_z1))					err("precon_z1 is not set!");
162 | 		if(!getparint("precon_z2",&precon_z2))					err("precon_z2 is not set!");
163 | 
164 | }
165 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/3D_elastic_modeling_typedef_struct:
--------------------------------------------------------------------------------
  1 | typedef struct
  2 | {
  3 | 		float *vx1_d,*vy1_d,*vz1_d;
  4 | 		float *vx2_d,*vy2_d,*vz2_d;////6
  5 | 
  6 | 
  7 | 		float *txx1_d,*tyy1_d,*tzz1_d;
  8 | 		float *txx2_d,*tyy2_d,*tzz2_d;///6
  9 | 
 10 | 
 11 | 		float *txy1_d,*txz1_d,*tyz1_d;
 12 | 		float *txy2_d,*txz2_d,*tyz2_d;///6
 13 | 
 14 | 
 15 | 		float *tp1_d,*vxp1_d,*vyp1_d,*vzp1_d,*vxs1_d,*vys1_d,*vzs1_d;
 16 | 		float *tp2_d,*vxp2_d,*vyp2_d,*vzp2_d,*vxs2_d,*vys2_d,*vzs2_d;///14
 17 | 
 18 | 
 19 | 
 20 | 		float *velocity_d,*velocity1_d,*density_d;
 21 | 		float *s_velocity_d,*s_velocity1_d,*s_density_d;///6
 22 | 
 23 | 
 24 | 		float *velocity_h,*velocity1_h,*density_h;		
 25 | 		float *s_velocity_h,*s_velocity1_h,*s_density_h;
 26 | 
 27 | 
 28 | 
 29 | 		float *obs_shot_x_d,*obs_shot_y_d,*obs_shot_z_d;
 30 | 		float *obs_shot_x_h,*obs_shot_y_h,*obs_shot_z_h;
 31 | 
 32 | 		float *coe_d;
 33 | 		float *wavelet_d;
 34 | 		float *att_h,*att_d;////////////4
 35 | 
 36 | 
 37 | 		float *rep;
 38 | 
 39 | 		float *wf_h,*wf0_h,*wf1_h,*wf2_h,*wf3_h,*wf4_h;
 40 | 		
 41 | 	
 42 | 		cudaStream_t stream;
 43 | 
 44 | /////////////////////////////////////////////for RTM:
 45 | 		float *ex_time_d,*ex_amp_d,*ex_tp_d,*ex_vxp_d,*ex_vyp_d,*ex_vzp_d;
 46 | 
 47 | 		float *vresult_tp_d,*vresult_pp_d,*vresult_ps_d;
 48 | 
 49 | //////////////////////////to calculate angle for compensate cos(2a) or cos(a+b) or extract angle domain common imaging gathers in 2D and 3D
 50 | 		float *poyn_px_d,*poyn_py_d,*poyn_pz_d;
 51 | 		float *poyn_rpx_d,*poyn_rpy_d,*poyn_rpz_d;
 52 | 		float *poyn_rsx_d,*poyn_rsy_d,*poyn_rsz_d;
 53 | 		float *angle_pp_d,*angle_ps_d;
 54 | 
 55 | } GPUdevice;
 56 | 
 57 | void allocate_typedef_struct(GPUdevice *mgdevice,int i)
 58 | {
 59 | //////////////////////////开辟正传的波场变量。
 60 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vx1_d,nnx*nny*nnz_device_append*sizeof(float)));
 61 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vy1_d,nnx*nny*nnz_device_append*sizeof(float)));
 62 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vz1_d,nnx*nny*nnz_device_append*sizeof(float)));
 63 | 
 64 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vx2_d,nnx*nny*nnz_device_append*sizeof(float)));
 65 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vy2_d,nnx*nny*nnz_device_append*sizeof(float)));
 66 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vz2_d,nnx*nny*nnz_device_append*sizeof(float)));
 67 | 
 68 | 
 69 | 
 70 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].txx1_d,nnx*nny*nnz_device_append*sizeof(float)));
 71 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tyy1_d,nnx*nny*nnz_device_append*sizeof(float)));
 72 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tzz1_d,nnx*nny*nnz_device_append*sizeof(float)));
 73 | 
 74 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].txx2_d,nnx*nny*nnz_device_append*sizeof(float)));
 75 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tyy2_d,nnx*nny*nnz_device_append*sizeof(float)));
 76 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tzz2_d,nnx*nny*nnz_device_append*sizeof(float)));
 77 | 
 78 | 
 79 | 
 80 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].txy1_d,nnx*nny*nnz_device_append*sizeof(float)));
 81 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].txz1_d,nnx*nny*nnz_device_append*sizeof(float)));		
 82 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tyz1_d,nnx*nny*nnz_device_append*sizeof(float)));
 83 | 
 84 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].txy2_d,nnx*nny*nnz_device_append*sizeof(float)));
 85 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].txz2_d,nnx*nny*nnz_device_append*sizeof(float)));		
 86 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tyz2_d,nnx*nny*nnz_device_append*sizeof(float)));
 87 | 
 88 | 	
 89 | 	
 90 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tp1_d,nnx*nny*nnz_device_append*sizeof(float)));
 91 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vxp1_d,nnx*nny*nnz_device_append*sizeof(float)));
 92 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vyp1_d,nnx*nny*nnz_device_append*sizeof(float)));
 93 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vzp1_d,nnx*nny*nnz_device_append*sizeof(float)));
 94 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vxs1_d,nnx*nny*nnz_device_append*sizeof(float)));
 95 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vys1_d,nnx*nny*nnz_device_append*sizeof(float)));
 96 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vzs1_d,nnx*nny*nnz_device_append*sizeof(float)));
 97 | 
 98 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].tp2_d,nnx*nny*nnz_device_append*sizeof(float)));
 99 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vxp2_d,nnx*nny*nnz_device_append*sizeof(float)));
100 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vyp2_d,nnx*nny*nnz_device_append*sizeof(float)));
101 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vzp2_d,nnx*nny*nnz_device_append*sizeof(float)));
102 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vxs2_d,nnx*nny*nnz_device_append*sizeof(float)));
103 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vys2_d,nnx*nny*nnz_device_append*sizeof(float)));
104 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vzs2_d,nnx*nny*nnz_device_append*sizeof(float)));
105 | 
106 | 
107 | 
108 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].velocity_d,nnx*nny*nnz_device_append*sizeof(float)));
109 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].velocity1_d,nnx*nny*nnz_device_append*sizeof(float)));
110 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].density_d,nnx*nny*nnz_device_append*sizeof(float)));
111 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].s_velocity_d,nnx*nny*nnz_device_append*sizeof(float)));
112 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].s_velocity1_d,nnx*nny*nnz_device_append*sizeof(float)));
113 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].s_density_d,nnx*nny*nnz_device_append*sizeof(float)));
114 | 		
115 | 		cudaMemsetAsync(mgdevice[i].velocity_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
116 | 		cudaMemsetAsync(mgdevice[i].velocity1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
117 | 		cudaMemsetAsync(mgdevice[i].density_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
118 | 		cudaMemsetAsync(mgdevice[i].s_velocity_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
119 | 		cudaMemsetAsync(mgdevice[i].s_velocity1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
120 | 		cudaMemsetAsync(mgdevice[i].s_density_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
121 | 	
122 | 
123 | 
124 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].velocity_h,nnx*nny*nnz_device_append*sizeof(float)));
125 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].velocity1_h,nnx*nny*nnz_device_append*sizeof(float)));
126 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].density_h,nnx*nny*nnz_device_append*sizeof(float)));
127 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].s_velocity_h,nnx*nny*nnz_device_append*sizeof(float)));
128 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].s_velocity1_h,nnx*nny*nnz_device_append*sizeof(float)));
129 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].s_density_h,nnx*nny*nnz_device_append*sizeof(float)));
130 | 
131 | 		cudaMemsetAsync(mgdevice[i].velocity_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
132 | 		cudaMemsetAsync(mgdevice[i].velocity1_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
133 | 		cudaMemsetAsync(mgdevice[i].density_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
134 | 		cudaMemsetAsync(mgdevice[i].s_velocity_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
135 | 		cudaMemsetAsync(mgdevice[i].s_velocity1_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
136 | 		cudaMemsetAsync(mgdevice[i].s_density_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
137 | 
138 | 
139 | 
140 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].obs_shot_x_d,receiver_num_x*receiver_num_y*sizeof(float)));
141 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].obs_shot_y_d,receiver_num_x*receiver_num_y*sizeof(float)));
142 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].obs_shot_z_d,receiver_num_x*receiver_num_y*sizeof(float)));
143 | 		cudaMemsetAsync(mgdevice[i].obs_shot_x_d,0,receiver_num_x*receiver_num_y*sizeof(float),mgdevice[i].stream);
144 | 		cudaMemsetAsync(mgdevice[i].obs_shot_y_d,0,receiver_num_x*receiver_num_y*sizeof(float),mgdevice[i].stream);
145 | 		cudaMemsetAsync(mgdevice[i].obs_shot_z_d,0,receiver_num_x*receiver_num_y*sizeof(float),mgdevice[i].stream);
146 | 
147 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].obs_shot_x_h,receiver_num_x*receiver_num_y*sizeof(float)));
148 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].obs_shot_y_h,receiver_num_x*receiver_num_y*sizeof(float)));
149 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].obs_shot_z_h,receiver_num_x*receiver_num_y*sizeof(float)));
150 | 		cudaMemsetAsync(mgdevice[i].obs_shot_x_h,0,receiver_num_x*receiver_num_y*sizeof(float),mgdevice[i].stream);
151 | 		cudaMemsetAsync(mgdevice[i].obs_shot_y_h,0,receiver_num_x*receiver_num_y*sizeof(float),mgdevice[i].stream);
152 | 		cudaMemsetAsync(mgdevice[i].obs_shot_z_h,0,receiver_num_x*receiver_num_y*sizeof(float),mgdevice[i].stream);
153 | 
154 | 
155 | 		
156 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].coe_d,(radius+1)*sizeof(float)));
157 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].wavelet_d,wavelet_length*sizeof(float)));/////给每一块卡，分配炮记录，差分系数，子波的空间
158 | 		cudaMemsetAsync(mgdevice[i].coe_d,0,(radius+1)*sizeof(float),mgdevice[i].stream);
159 | 		cudaMemsetAsync(mgdevice[i].wavelet_d,0,wavelet_length*sizeof(float),mgdevice[i].stream);
160 | 
161 | 
162 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].att_h,nnx*nny*nnz_device_append*sizeof(float)));
163 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].att_d,nnx*nny*nnz_device_append*sizeof(float)));
164 | 		
165 | 		cudaMemsetAsync(&mgdevice[i].att_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
166 | 		cudaMemsetAsync(&mgdevice[i].att_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
167 | 
168 | 
169 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].wf_h,nnx*nny*nnz_device_append*sizeof(float)));
170 | 		cudaMemsetAsync(&mgdevice[i].wf_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
171 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].wf0_h,nnx*nny*nnz_device_append*sizeof(float)));
172 | 		cudaMemsetAsync(&mgdevice[i].wf0_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
173 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].wf1_h,nnx*nny*nnz_device_append*sizeof(float)));
174 | 		cudaMemsetAsync(&mgdevice[i].wf1_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
175 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].wf2_h,nnx*nny*nnz_device_append*sizeof(float)));
176 | 		cudaMemsetAsync(&mgdevice[i].wf2_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
177 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].wf3_h,nnx*nny*nnz_device_append*sizeof(float)));
178 | 		cudaMemsetAsync(&mgdevice[i].wf3_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
179 | 		checkCudaErrors(cudaMallocHost(&mgdevice[i].wf4_h,nnx*nny*nnz_device_append*sizeof(float)));
180 | 		cudaMemsetAsync(&mgdevice[i].wf4_h,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
181 | 
182 | /////////////////////////////////////////////for RTM: float *ex_time_d,*ex_tp_d,*ex_vxp_d,*ex_vy_d,*ex_vzp_d;
183 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].ex_time_d,nnx*nny*nnz_device_append*sizeof(float)));
184 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].ex_amp_d,nnx*nny*nnz_device_append*sizeof(float)));
185 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].ex_tp_d,nnx*nny*nnz_device_append*sizeof(float)));
186 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].ex_vxp_d,nnx*nny*nnz_device_append*sizeof(float)));
187 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].ex_vyp_d,nnx*nny*nnz_device_append*sizeof(float)));
188 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].ex_vzp_d,nnx*nny*nnz_device_append*sizeof(float)));
189 | 
190 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vresult_tp_d,nnx*nny*nnz_device_append*sizeof(float)));
191 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vresult_pp_d,nnx*nny*nnz_device_append*sizeof(float)));
192 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].vresult_ps_d,nnx*nny*nnz_device_append*sizeof(float)));
193 | 
194 | //////////////////////////to calculate angle for compensate cos(2a) or cos(a+b) or extract angle domain common imaging gathers in 2D and 3D
195 | 		/*checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_px_d,nnx*nny*nnz_device_append*sizeof(float)));
196 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_py_d,nnx*nny*nnz_device_append*sizeof(float)));
197 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_pz_d,nnx*nny*nnz_device_append*sizeof(float)));
198 | 
199 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_rpx_d,nnx*nny*nnz_device_append*sizeof(float)));
200 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_rpy_d,nnx*nny*nnz_device_append*sizeof(float)));
201 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_rpz_d,nnx*nny*nnz_device_append*sizeof(float)));
202 | 
203 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_rsx_d,nnx*nny*nnz_device_append*sizeof(float)));
204 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_rsy_d,nnx*nny*nnz_device_append*sizeof(float)));
205 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].poyn_rsz_d,nnx*nny*nnz_device_append*sizeof(float)));
206 | 
207 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].angle_pp_d,nnx*nny*nnz_device_append*sizeof(float)));
208 | 		checkCudaErrors(cudaMalloc(&mgdevice[i].angle_ps_d,nnx*nny*nnz_device_append*sizeof(float)));*/
209 | 		
210 | }
211 | 
212 | void set_zero_typedef_struct_wavefield(GPUdevice *mgdevice,int i)
213 | {
214 | //////////////////////////set zero for wavefield
215 | 		cudaMemsetAsync(mgdevice[i].vx1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
216 | 		cudaMemsetAsync(mgdevice[i].vy1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
217 | 		cudaMemsetAsync(mgdevice[i].vz1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
218 | 
219 | 		cudaMemsetAsync(mgdevice[i].vx2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
220 | 		cudaMemsetAsync(mgdevice[i].vy2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
221 | 		cudaMemsetAsync(mgdevice[i].vz2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
222 | 
223 | 
224 | 
225 | 		cudaMemsetAsync(mgdevice[i].txx1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
226 | 		cudaMemsetAsync(mgdevice[i].tyy1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
227 | 		cudaMemsetAsync(mgdevice[i].tzz1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
228 | 
229 | 		cudaMemsetAsync(mgdevice[i].txx2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
230 | 		cudaMemsetAsync(mgdevice[i].tyy2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
231 | 		cudaMemsetAsync(mgdevice[i].tzz2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
232 | 
233 | 	
234 | 
235 | 		cudaMemsetAsync(mgdevice[i].txy1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
236 | 		cudaMemsetAsync(mgdevice[i].txz1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
237 | 		cudaMemsetAsync(mgdevice[i].tyz1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
238 | 
239 | 		cudaMemsetAsync(mgdevice[i].txy2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
240 | 		cudaMemsetAsync(mgdevice[i].txz2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
241 | 		cudaMemsetAsync(mgdevice[i].tyz2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
242 | 
243 | 
244 | 
245 | 		cudaMemsetAsync(mgdevice[i].tp1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
246 | 		cudaMemsetAsync(mgdevice[i].vxp1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
247 | 		cudaMemsetAsync(mgdevice[i].vyp1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
248 | 		cudaMemsetAsync(mgdevice[i].vzp1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
249 | 		cudaMemsetAsync(mgdevice[i].vxs1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
250 | 		cudaMemsetAsync(mgdevice[i].vys1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
251 | 		cudaMemsetAsync(mgdevice[i].vzs1_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
252 | 
253 | 		cudaMemsetAsync(mgdevice[i].tp2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
254 | 		cudaMemsetAsync(mgdevice[i].vxp2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
255 | 		cudaMemsetAsync(mgdevice[i].vyp2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
256 | 		cudaMemsetAsync(mgdevice[i].vzp2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
257 | 		cudaMemsetAsync(mgdevice[i].vxs2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
258 | 		cudaMemsetAsync(mgdevice[i].vys2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
259 | 		cudaMemsetAsync(mgdevice[i].vzs2_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
260 | }
261 | void set_zero_typedef_struct_excitation(GPUdevice *mgdevice,int i)
262 | {
263 | /////////////////////////////////////////////for RTM: float *ex_time_d,*ex_tp_d,*ex_vxp_d,*ex_vy_d,*ex_vzp_d;
264 | 		cudaMemsetAsync(mgdevice[i].ex_time_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
265 | 		cudaMemsetAsync(mgdevice[i].ex_amp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
266 | 		cudaMemsetAsync(mgdevice[i].ex_tp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
267 | 		cudaMemsetAsync(mgdevice[i].ex_vxp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
268 | 		cudaMemsetAsync(mgdevice[i].ex_vyp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
269 | 		cudaMemsetAsync(mgdevice[i].ex_vzp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
270 | 
271 | 		cudaMemsetAsync(mgdevice[i].vresult_tp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
272 | 		cudaMemsetAsync(mgdevice[i].vresult_pp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
273 | 		cudaMemsetAsync(mgdevice[i].vresult_ps_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
274 | }
275 | 
276 | void set_zero_typedef_struct_poyn(GPUdevice *mgdevice,int i)
277 | {
278 | //////////////////////////to calculate angle for compensate cos(2a) or cos(a+b) or extract angle domain common imaging gathers in 2D and 3D
279 | 		cudaMemsetAsync(mgdevice[i].poyn_px_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
280 | 		cudaMemsetAsync(mgdevice[i].poyn_py_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
281 | 		cudaMemsetAsync(mgdevice[i].poyn_pz_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
282 | 
283 | 		cudaMemsetAsync(mgdevice[i].poyn_rpx_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
284 | 		cudaMemsetAsync(mgdevice[i].poyn_rpy_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
285 | 		cudaMemsetAsync(mgdevice[i].poyn_rpz_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
286 | 
287 | 		cudaMemsetAsync(mgdevice[i].poyn_rsx_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
288 | 		cudaMemsetAsync(mgdevice[i].poyn_rsy_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
289 | 		cudaMemsetAsync(mgdevice[i].poyn_rsz_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
290 | 
291 | 		cudaMemsetAsync(mgdevice[i].angle_pp_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
292 | 		cudaMemsetAsync(mgdevice[i].angle_ps_d,0,nnx*nny*nnz_device_append*sizeof(float),mgdevice[i].stream);
293 | }
294 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/3D_forward_or_back_together.cu:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | 
  4 | 
  5 | ///////////////////////////////////////////////////////////////////////**********************************************///////////////////////////////////////////////////////
  6 | ///////////////////////////////////////////////////////////////////////**********************************************//////////////////////////////////////////////////////
  7 | ///////////////////////////////////////////////////////////////////////**********************************************///////////////////////////////////////////////////////
  8 | ///////////////////////////////////////////////////////////////////////**********************************************//////////////////////////////////////////////////////
  9 | void forward_together_using_real_model(GPUdevice *mgdevice)
 10 | {
 11 | 
 12 | 
 13 | 		dim3 dimBlock(32,16);
 14 | 
 15 | 		dim3 dimGridwf_append((nnx+dimBlock.x-1)/dimBlock.x,(nny+dimBlock.y-1)/dimBlock.y,nnz_device_append);//////单块卡的整个空间
 16 | 		
 17 | 		dim3 dimGridwf_radius((nnx_radius+dimBlock.x-1)/dimBlock.x,(nny_radius+dimBlock.y-1)/dimBlock.y,nnz_radius);///单块卡的整个空间减去半径
 18 | 		
 19 | 		dim3 dimGrid_rec_lt_x_y((receiver_num_x+dimBlock.x-1)/dimBlock.x,(receiver_num_y+dimBlock.y-1)/dimBlock.y);
 20 | 
 21 | 		dim3 dimGrid_rec_lt_x_z((receiver_num_x+dimBlock.x-1)/dimBlock.x,(receiver_num_z+dimBlock.y-1)/dimBlock.y);///seismic process and receive
 22 | 
 23 | 
 24 | 
 25 | 					for(it=0;it<lt;it++)
 26 | 						{
 27 | 							if(fmod(it+1.0,1000.0)==1)	
 28 | 							{
 29 | 								warn("forward for modeling,isx=%d,isy=%d,isz=%d,it=%d",isx+1,isy+1,isz+1,it);
 30 | 							}
 31 | 
 32 | 							if(it<wavelet_length)
 33 | 							{
 34 | 								checkCudaErrors(cudaSetDevice(gpuid[choose_ns]));
 35 | 
 36 | 								add_source_3D<<<1,1,0,mgdevice[choose_ns].stream>>>(mgdevice[choose_ns].txx1_d,mgdevice[choose_ns].wavelet_d,nnx,nny,nnz_device_append,nnz_device,it,sx_real,sy_real,sz_real,bl,bb,bu);
 37 | 								add_source_3D<<<1,1,0,mgdevice[choose_ns].stream>>>(mgdevice[choose_ns].tyy1_d,mgdevice[choose_ns].wavelet_d,nnx,nny,nnz_device_append,nnz_device,it,sx_real,sy_real,sz_real,bl,bb,bu);
 38 | 								add_source_3D<<<1,1,0,mgdevice[choose_ns].stream>>>(mgdevice[choose_ns].tzz1_d,mgdevice[choose_ns].wavelet_d,nnx,nny,nnz_device_append,nnz_device,it,sx_real,sy_real,sz_real,bl,bb,bu);
 39 | 							}
 40 | 
 41 | 							checkCudaErrors(cudaDeviceSynchronize());
 42 | 							//if(fmod(it+1.0,1000.0)==1)	warn("add_source_3D is passing");
 43 | 
 44 | 							exchange_device_nz_kernel_txxyyzz(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
 45 | 							
 46 | 							checkCudaErrors(cudaDeviceSynchronize());
 47 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_txxyyzz is passing");
 48 | 
 49 | 
 50 | 							if((fmod(it+1.0,wavefield_interval)==0)&&join_wavefield!=0)
 51 | 							//if((it==500)&&join_wavefield!=0)
 52 | 							{
 53 | 								system("mkdir wavefield");
 54 | 								output_3d_wavefiled_tao(mgdevice,it+1);
 55 | 								checkCudaErrors(cudaDeviceSynchronize());
 56 | 
 57 | 								output_3d_wavefiled_vx(mgdevice,it+1);
 58 | 								checkCudaErrors(cudaDeviceSynchronize());
 59 | 
 60 | 								output_3d_wavefiled_vz(mgdevice,it+1);
 61 | 								checkCudaErrors(cudaDeviceSynchronize());
 62 | 
 63 | 								output_3d_wavefiled_vzp(mgdevice,it+1);
 64 | 								checkCudaErrors(cudaDeviceSynchronize());
 65 | 
 66 | 								output_3d_wavefiled_vzs(mgdevice,it+1);
 67 | 								checkCudaErrors(cudaDeviceSynchronize());
 68 | 
 69 | 								if(((it+1.0)/wavefield_interval)==(lt/wavefield_interval))
 70 | 								{
 71 | 									system("rm -r wavefield1");
 72 | 									system("mv wavefield wavefield1");
 73 | 								}
 74 | 							}
 75 | 					
 76 | 							checkCudaErrors(cudaDeviceSynchronize());
 77 | 							//if(fmod(it+1.0,1000.0)==1)	warn("output_3d_wavefiled is passing");
 78 | 
 79 | 							for(int i=0;i<GPU_N;i++)
 80 | 							{
 81 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
 82 | 
 83 | 								fwd_txxzzxzpp_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].tp2_d,mgdevice[i].tp1_d,mgdevice[i].txx2_d,mgdevice[i].txx1_d,mgdevice[i].tyy2_d,mgdevice[i].tyy1_d,mgdevice[i].tzz2_d,mgdevice[i].tzz1_d,mgdevice[i].txy2_d,mgdevice[i].txy1_d,mgdevice[i].txz2_d,mgdevice[i].txz1_d,mgdevice[i].tyz2_d,mgdevice[i].tyz1_d,mgdevice[i].vx1_d,mgdevice[i].vy1_d,mgdevice[i].vz1_d,mgdevice[i].velocity_d,mgdevice[i].velocity1_d,mgdevice[i].density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);							
 84 | 							}
 85 | 					
 86 | 							checkCudaErrors(cudaDeviceSynchronize());
 87 | 							//if(fmod(it+1.0,1000.0)==1)	warn("fwd_txxzzxzpp_3D is passing");
 88 | 
 89 | 							exchange_device_nz_kernel_tao2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///		
 90 | 
 91 | 							exchange_device_nz_kernel_taop2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
 92 | 							
 93 | 							checkCudaErrors(cudaDeviceSynchronize());
 94 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_tao2 taop2 is passing");
 95 | 
 96 | 							for(int i=0;i<GPU_N;i++)
 97 | 							{
 98 | 								cudaSetDevice(gpuid[i]);
 99 | 
100 | 								fwd_vx_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vx2_d,mgdevice[i].vx1_d,mgdevice[i].txx2_d,mgdevice[i].txy2_d,mgdevice[i].txz2_d,mgdevice[i].velocity_d,mgdevice[i].velocity1_d,mgdevice[i].density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
101 | 
102 | 								fwd_vy_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vy2_d,mgdevice[i].vy1_d,mgdevice[i].txy2_d,mgdevice[i].tyy2_d,mgdevice[i].tyz2_d,mgdevice[i].velocity_d,mgdevice[i].velocity1_d,mgdevice[i].density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
103 | 
104 | 								fwd_vz_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vz2_d,mgdevice[i].vz1_d,mgdevice[i].txz2_d,mgdevice[i].tyz2_d,mgdevice[i].tzz2_d,mgdevice[i].velocity_d,mgdevice[i].velocity1_d,mgdevice[i].density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
105 | 							}
106 | 
107 | 							checkCudaErrors(cudaDeviceSynchronize());
108 | 							//if(fmod(it+1.0,1000.0)==1)	warn("fwd_vx_3D fwd_vy_3D fwd_vz_3D is passing");
109 | 					
110 | 							exchange_device_nz_kernel_vx_vy_vz2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
111 | 							checkCudaErrors(cudaDeviceSynchronize());
112 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_vx_vy_vz2 is passing");
113 | 
114 | 							for(int i=0;i<GPU_N;i++)
115 | 							{
116 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
117 | 
118 | 								fwd_vxp_vzp_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vxp2_d,mgdevice[i].vxp1_d,mgdevice[i].vyp2_d,mgdevice[i].vyp1_d,mgdevice[i].vzp2_d,mgdevice[i].vzp1_d,mgdevice[i].tp2_d,mgdevice[i].vxs2_d,mgdevice[i].vys2_d,mgdevice[i].vzs2_d,mgdevice[i].vx2_d,mgdevice[i].vy2_d,mgdevice[i].vz2_d,mgdevice[i].velocity_d,mgdevice[i].velocity1_d,mgdevice[i].density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);	
119 | 							}
120 | 
121 | 							checkCudaErrors(cudaDeviceSynchronize());
122 | 							//if(fmod(it+1.0,1000.0)==1)	warn("fwd_vxp_vzp_3D is passing");
123 | 																		
124 | 							{
125 | 								checkCudaErrors(cudaSetDevice(gpuid[choose_re]));
126 | 
127 | 								write_or_add_shot_3D_surface_three<<<dimGrid_rec_lt_x_y,dimBlock,0,mgdevice[choose_re].stream>>>(mgdevice[choose_re].obs_shot_x_d,mgdevice[choose_re].obs_shot_y_d,mgdevice[choose_re].obs_shot_z_d,mgdevice[choose_re].vx2_d,mgdevice[choose_re].vy2_d,mgdevice[choose_re].vz2_d,nnx,nny,nnz_device_append,nnz_device,bl,bb,bu,receiver_start_x,receiver_num_x,receiver_interval_x,receiver_start_y,receiver_num_y,receiver_interval_y,receiver_start_z,receiver_num_z,receiver_interval_z,0);
128 | 
129 | 								checkCudaErrors(cudaDeviceSynchronize());
130 | 								//if(fmod(it+1.0,1000.0)==1)	warn("write_or_add_shot_3D_surface_three is passing");
131 | 	
132 | 								if(vsp==0)
133 | 								{
134 | 									//cut_direct_shot_3D_surface_three<<<dimGrid_rec_lt_x_y,dimBlock,0,mgdevice[choose_re].stream>>>(mgdevice[choose_re].obs_shot_x_d,mgdevice[choose_re].obs_shot_y_d,mgdevice[choose_re].obs_shot_z_d,mgdevice[choose_re].velocity_d,nnx,nny,nnz_device,bl,bb,bu,receiver_start_x,receiver_num_x,receiver_interval_x,receiver_start_y,receiver_num_y,receiver_interval_y,receiver_start_z,receiver_num_z,receiver_interval_z,sx_real,sy_real,sz_real,it,wavelet_length,dx,dy,dz,dt);
135 | 									cut_direct_shot_3D_surface_three_new<<<dimGrid_rec_lt_x_y,dimBlock,0,mgdevice[choose_re].stream>>>(mgdevice[choose_re].obs_shot_x_d,mgdevice[choose_re].obs_shot_y_d,mgdevice[choose_re].obs_shot_z_d,mgdevice[choose_re].velocity_d,nnx,nny,nnz_device,bl,bb,bu,receiver_start_x,receiver_num_x,receiver_interval_x,receiver_start_y,receiver_num_y,receiver_interval_y,receiver_start_z,receiver_num_z,receiver_interval_z,sx_real,sy_real,sz_real,it,wavelet_length,dx,dy,dz,dt,cut_direct_wave);												
136 | 								}
137 | 								checkCudaErrors(cudaDeviceSynchronize());
138 | 								//if(fmod(it+1.0,1000.0)==1)	warn("cut_direct_shot_3D_surface is passing");
139 | 															
140 | 								transfer_gpu_to_cpu_multicomponent_seismic(mgdevice,it,0);
141 | 
142 | 								checkCudaErrors(cudaDeviceSynchronize());
143 | 								//if(fmod(it+1.0,1000.0)==1)	warn("transfer_gpu_to_cpu_multicomponent_seismic is passing");	
144 | 							}
145 | 
146 | 							checkCudaErrors(cudaDeviceSynchronize());
147 | 							//if(fmod(it+1.0,1000.0)==1)	warn("write_shot is passing");
148 | 
149 | 							exchange_wavefiled_new(mgdevice);//////////////////change wavefield_new
150 | 							//exchange_wavefiled_old(mgdevice);//////////////////change wavefield_old	
151 | 
152 | 							checkCudaErrors(cudaDeviceSynchronize());		
153 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_wavefiled is passing");
154 | 						}
155 | }
156 | 
157 | ///////////////////////////////////////////////////////////////////////**********************************************///////////////////////////////////////////////////////
158 | ///////////////////////////////////////////////////////////////////////**********************************************//////////////////////////////////////////////////////
159 | ///////////////////////////////////////////////////////////////////////**********************************************///////////////////////////////////////////////////////
160 | ///////////////////////////////////////////////////////////////////////**********************************************//////////////////////////////////////////////////////
161 | void forward_together_using_smoothed_model(GPUdevice *mgdevice)
162 | {
163 | 		dim3 dimBlock(32,16);
164 | 
165 | 		dim3 dimGridwf_append((nnx+dimBlock.x-1)/dimBlock.x,(nny+dimBlock.y-1)/dimBlock.y,nnz_device_append);//////单块卡的整个空间
166 | 		
167 | 		dim3 dimGridwf_radius((nnx_radius+dimBlock.x-1)/dimBlock.x,(nny_radius+dimBlock.y-1)/dimBlock.y,nnz_radius);///单块卡的整个空间减去半径
168 | 		
169 | 		dim3 dimGrid_rec_lt_x_y((receiver_num_x+dimBlock.x-1)/dimBlock.x,(receiver_num_y+dimBlock.y-1)/dimBlock.y);
170 | 
171 | 		dim3 dimGrid_rec_lt_x_z((receiver_num_x+dimBlock.x-1)/dimBlock.x,(receiver_num_z+dimBlock.y-1)/dimBlock.y);///seismic process and receive
172 | 
173 | 					for(it=0;it<2*lt/3;it++)
174 | 						{
175 | 							if(fmod(it+1.0,1000.0)==1)	
176 | 							{
177 | 								warn("forward for Elastic RTM,isx=%d,isy=%d,isz=%d,it=%d",isx+1,isy+1,isz+1,it);
178 | 							}
179 | 
180 | 							if(it<wavelet_length)
181 | 							{
182 | 								checkCudaErrors(cudaSetDevice(gpuid[choose_ns]));
183 | 
184 | 								add_source_3D<<<1,1,0,mgdevice[choose_ns].stream>>>(mgdevice[choose_ns].txx1_d,mgdevice[choose_ns].wavelet_d,nnx,nny,nnz_device_append,nnz_device,it,sx_real,sy_real,sz_real,bl,bb,bu);
185 | 								add_source_3D<<<1,1,0,mgdevice[choose_ns].stream>>>(mgdevice[choose_ns].tyy1_d,mgdevice[choose_ns].wavelet_d,nnx,nny,nnz_device_append,nnz_device,it,sx_real,sy_real,sz_real,bl,bb,bu);
186 | 								add_source_3D<<<1,1,0,mgdevice[choose_ns].stream>>>(mgdevice[choose_ns].tzz1_d,mgdevice[choose_ns].wavelet_d,nnx,nny,nnz_device_append,nnz_device,it,sx_real,sy_real,sz_real,bl,bb,bu);
187 | 							}
188 | 
189 | 							checkCudaErrors(cudaDeviceSynchronize());
190 | 							//if(fmod(it+1.0,1000.0)==1)	warn("add_source_3D is passing");
191 | 
192 | 							exchange_device_nz_kernel_txxyyzz(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
193 | 							
194 | 							checkCudaErrors(cudaDeviceSynchronize());
195 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_txxyyzz is passing");
196 | 
197 | 
198 | 							if((fmod(it+1.0,wavefield_interval)==0)&&join_wavefield!=0)
199 | 							//if((it==500)&&join_wavefield!=0)
200 | 							{
201 | 								system("mkdir wavefield");
202 | 								output_3d_wavefiled_tao(mgdevice,it+1);
203 | 								checkCudaErrors(cudaDeviceSynchronize());
204 | 
205 | 								output_3d_wavefiled_vx(mgdevice,it+1);
206 | 								checkCudaErrors(cudaDeviceSynchronize());
207 | 
208 | 								output_3d_wavefiled_vz(mgdevice,it+1);
209 | 								checkCudaErrors(cudaDeviceSynchronize());
210 | 
211 | 								output_3d_wavefiled_vzp(mgdevice,it+1);
212 | 								checkCudaErrors(cudaDeviceSynchronize());
213 | 
214 | 								output_3d_wavefiled_vzs(mgdevice,it+1);
215 | 								checkCudaErrors(cudaDeviceSynchronize());
216 | 
217 | 								if(((it+1.0)/wavefield_interval)==((2*lt/3)/wavefield_interval))
218 | 								{
219 | 									system("rm -r wavefield2");
220 | 									system("mv wavefield wavefield2");
221 | 								}
222 | 							}
223 | 					
224 | 							checkCudaErrors(cudaDeviceSynchronize());
225 | 							//if(fmod(it+1.0,1000.0)==1)	warn("output_3d_wavefiled is passing");
226 | 
227 | 							for(int i=0;i<GPU_N;i++)
228 | 							{
229 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
230 | 
231 | 								fwd_txxzzxzpp_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].tp2_d,mgdevice[i].tp1_d,mgdevice[i].txx2_d,mgdevice[i].txx1_d,mgdevice[i].tyy2_d,mgdevice[i].tyy1_d,mgdevice[i].tzz2_d,mgdevice[i].tzz1_d,mgdevice[i].txy2_d,mgdevice[i].txy1_d,mgdevice[i].txz2_d,mgdevice[i].txz1_d,mgdevice[i].tyz2_d,mgdevice[i].tyz1_d,mgdevice[i].vx1_d,mgdevice[i].vy1_d,mgdevice[i].vz1_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);							
232 | 							}
233 | 					
234 | 							checkCudaErrors(cudaDeviceSynchronize());
235 | 							//if(fmod(it+1.0,1000.0)==1)	warn("fwd_txxzzxzpp_3D is passing");
236 | 
237 | 							exchange_device_nz_kernel_tao2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///		
238 | 
239 | 							exchange_device_nz_kernel_taop2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
240 | 							
241 | 							checkCudaErrors(cudaDeviceSynchronize());
242 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_tao2 taop2 is passing");
243 | 
244 | 							for(int i=0;i<GPU_N;i++)
245 | 							{
246 | 								cudaSetDevice(gpuid[i]);
247 | 
248 | 								fwd_vx_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vx2_d,mgdevice[i].vx1_d,mgdevice[i].txx2_d,mgdevice[i].txy2_d,mgdevice[i].txz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
249 | 
250 | 								fwd_vy_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vy2_d,mgdevice[i].vy1_d,mgdevice[i].txy2_d,mgdevice[i].tyy2_d,mgdevice[i].tyz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
251 | 
252 | 								fwd_vz_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vz2_d,mgdevice[i].vz1_d,mgdevice[i].txz2_d,mgdevice[i].tyz2_d,mgdevice[i].tzz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
253 | 							}
254 | 
255 | 							checkCudaErrors(cudaDeviceSynchronize());
256 | 							//if(fmod(it+1.0,1000.0)==1)	warn("fwd_vx_3D fwd_vy_3D fwd_vz_3D is passing");
257 | 					
258 | 							exchange_device_nz_kernel_vx_vy_vz2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
259 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_vx_vy_vz2 is passing");
260 | 
261 | 							for(int i=0;i<GPU_N;i++)
262 | 							{
263 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
264 | 
265 | 								fwd_vxp_vzp_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vxp2_d,mgdevice[i].vxp1_d,mgdevice[i].vyp2_d,mgdevice[i].vyp1_d,mgdevice[i].vzp2_d,mgdevice[i].vzp1_d,mgdevice[i].tp2_d,mgdevice[i].vxs2_d,mgdevice[i].vys2_d,mgdevice[i].vzs2_d,mgdevice[i].vx2_d,mgdevice[i].vy2_d,mgdevice[i].vz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);	
266 | 							}
267 | 
268 | 							checkCudaErrors(cudaDeviceSynchronize());
269 | 							//if(fmod(it+1.0,1000.0)==1)	warn("fwd_vxp_vzp_3D is passing");							
270 | 
271 | 							exchange_wavefiled_new(mgdevice);//////////////////change wavefield_new
272 | 							//exchange_wavefiled_old(mgdevice);//////////////////change wavefield_old	
273 | 
274 | 							checkCudaErrors(cudaDeviceSynchronize());
275 | 							//if(fmod(it+1.0,1000.0)==1)	warn("exchange_wavefiled_new is passing");
276 | 
277 | 							for(int i=0;i<GPU_N;i++)
278 | 							{
279 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
280 | 
281 | 								//cuda_cal_excitation_amp_time<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].ex_time_d,mgdevice[i].ex_tp_d,mgdevice[i].tp2_d,mgdevice[i].ex_vxp_d,mgdevice[i].vxp2_d,mgdevice[i].ex_vyp_d,mgdevice[i].vyp2_d,mgdevice[i].ex_vzp_d,mgdevice[i].vzp2_d,nnx,nny,nnz_device_append,it);
282 | 								cuda_cal_excitation_amp_time_new<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].ex_time_d,mgdevice[i].ex_amp_d,mgdevice[i].ex_tp_d,mgdevice[i].tp2_d,mgdevice[i].ex_vxp_d,mgdevice[i].vxp2_d,mgdevice[i].ex_vyp_d,mgdevice[i].vyp2_d,mgdevice[i].ex_vzp_d,mgdevice[i].vzp2_d,nnx,nny,nnz_device_append,it);
283 | 								//cuda_cal_source_poyn_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].poyn_px_d,mgdevice[i].poyn_py_d,mgdevice[i].poyn_pz_d,mgdevice[i].ex_time_d,mgdevice[i].vxp2_d,mgdevice[i].vyp2_d,mgdevice[i].vzp2_d,mgdevice[i].tp2_d,nnx,nny,nnz_device_append,it);
284 | 							}
285 | 
286 | 							checkCudaErrors(cudaDeviceSynchronize());
287 | 							//if(fmod(it+1.0,1000.0)==1)	warn("cuda_cal_excitation_amp_time_new is passing");
288 | 						
289 | 						}
290 | }
291 | 
292 | ///////////////////////////////////////////////////////////////////////**********************************************///////////////////////////////////////////////////////
293 | ///////////////////////////////////////////////////////////////////////**********************************************//////////////////////////////////////////////////////
294 | ///////////////////////////////////////////////////////////////////////**********************************************///////////////////////////////////////////////////////
295 | ///////////////////////////////////////////////////////////////////////**********************************************//////////////////////////////////////////////////////
296 | void backward_together_using_smoothed_model(GPUdevice *mgdevice)
297 | {
298 | 
299 | 		dim3 dimBlock(32,16);
300 | 
301 | 		dim3 dimGridwf_append((nnx+dimBlock.x-1)/dimBlock.x,(nny+dimBlock.y-1)/dimBlock.y,nnz_device_append);//////单块卡的整个空间
302 | 		
303 | 		dim3 dimGridwf_radius((nnx_radius+dimBlock.x-1)/dimBlock.x,(nny_radius+dimBlock.y-1)/dimBlock.y,nnz_radius);///单块卡的整个空间减去半径
304 | 		
305 | 		dim3 dimGrid_rec_lt_x_y((receiver_num_x+dimBlock.x-1)/dimBlock.x,(receiver_num_y+dimBlock.y-1)/dimBlock.y);
306 | 
307 | 		dim3 dimGrid_rec_lt_x_z((receiver_num_x+dimBlock.x-1)/dimBlock.x,(receiver_num_z+dimBlock.y-1)/dimBlock.y);///seismic process and receive
308 | 
309 | 
310 | 						for(it=lt-1;it>=0;it--)
311 | 						{
312 | 							if(fmod(it+1.0,1000.0)==1)	
313 | 							{
314 | 								warn("backward for Elastic RTM,isx=%d,isy=%d,isz=%d,it=%d",isx+1,isy+1,isz+1,it);
315 | 							}
316 | 							
317 | 							{
318 | 								transfer_gpu_to_cpu_multicomponent_seismic(mgdevice,it,1);
319 | 
320 | 								checkCudaErrors(cudaDeviceSynchronize());
321 | 								//if(fmod(it+1.0,1000.0)==1)	warn("transfer_gpu_to_cpu_multicomponent_seismic is passing");			
322 | 							}
323 | 
324 | 
325 | 							{
326 | 								checkCudaErrors(cudaSetDevice(gpuid[choose_re]));
327 | 
328 | 								write_or_add_shot_3D_surface_three<<<dimGrid_rec_lt_x_y,dimBlock,0,mgdevice[choose_re].stream>>>(mgdevice[choose_re].obs_shot_x_d,mgdevice[choose_re].obs_shot_y_d,mgdevice[choose_re].obs_shot_z_d,mgdevice[choose_re].vx1_d,mgdevice[choose_re].vy1_d,mgdevice[choose_re].vz1_d,nnx,nny,nnz_device_append,nnz_device,bl,bb,bu,receiver_start_x,receiver_num_x,receiver_interval_x,receiver_start_y,receiver_num_y,receiver_interval_y,receiver_start_z,receiver_num_z,receiver_interval_z,add_receiver_bool);	
329 | 
330 | 								checkCudaErrors(cudaDeviceSynchronize());
331 | 								//if(fmod(it+1.0,1000.0)==1)	warn("write_or_add_shot_3D_surface_three is passing");
332 | 							}
333 | 								
334 | 							{
335 | 								exchange_device_nz_kernel_vx_vy_vz1(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
336 | 
337 | 								checkCudaErrors(cudaDeviceSynchronize());
338 | 								//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_vx_vy_vz1 is passing");
339 | 							}
340 | 
341 | 							if((fmod(it+1.0,wavefield_interval)==0)&&join_wavefield!=0)
342 | 							//if((it==500)&&join_wavefield!=0)
343 | 							{
344 | 								system("mkdir wavefield");
345 | 								output_3d_wavefiled_tao(mgdevice,it+1);
346 | 								checkCudaErrors(cudaDeviceSynchronize());
347 | 
348 | 								output_3d_wavefiled_vx(mgdevice,it+1);
349 | 								checkCudaErrors(cudaDeviceSynchronize());
350 | 
351 | 								output_3d_wavefiled_vz(mgdevice,it+1);
352 | 								checkCudaErrors(cudaDeviceSynchronize());
353 | 
354 | 								output_3d_wavefiled_vzp(mgdevice,it+1);
355 | 								checkCudaErrors(cudaDeviceSynchronize());
356 | 
357 | 								output_3d_wavefiled_vzs(mgdevice,it+1);
358 | 								checkCudaErrors(cudaDeviceSynchronize());
359 | 
360 | 								if(((it+1.0)/wavefield_interval)==(lt/wavefield_interval))
361 | 								{
362 | 									system("rm -r wavefield3");
363 | 									system("mv wavefield wavefield3");
364 | 								}
365 | 							}
366 | 					
367 | 								checkCudaErrors(cudaDeviceSynchronize());
368 | 								//if(fmod(it+1.0,1000.0)==1)	warn("output_3d_wavefiled is passing");
369 | 
370 | 							for(int i=0;i<GPU_N;i++)
371 | 							{
372 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
373 | 
374 | 								fwd_txxzzxzpp_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].tp2_d,mgdevice[i].tp1_d,mgdevice[i].txx2_d,mgdevice[i].txx1_d,mgdevice[i].tyy2_d,mgdevice[i].tyy1_d,mgdevice[i].tzz2_d,mgdevice[i].tzz1_d,mgdevice[i].txy2_d,mgdevice[i].txy1_d,mgdevice[i].txz2_d,mgdevice[i].txz1_d,mgdevice[i].tyz2_d,mgdevice[i].tyz1_d,mgdevice[i].vx1_d,mgdevice[i].vy1_d,mgdevice[i].vz1_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);							
375 | 							}
376 | 					
377 | 								checkCudaErrors(cudaDeviceSynchronize());
378 | 								//if(fmod(it+1.0,1000.0)==1)	warn("fwd_txxzzxzpp_3D is passing");
379 | 
380 | 							{
381 | 								exchange_device_nz_kernel_tao2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
382 | 
383 | 								exchange_device_nz_kernel_taop2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
384 | 								
385 | 								checkCudaErrors(cudaDeviceSynchronize());
386 | 								//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_tao2 taop2 is passing");
387 | 							}
388 | 
389 | 							for(int i=0;i<GPU_N;i++)
390 | 							{
391 | 								cudaSetDevice(gpuid[i]);
392 | 
393 | 								fwd_vx_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vx2_d,mgdevice[i].vx1_d,mgdevice[i].txx2_d,mgdevice[i].txy2_d,mgdevice[i].txz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
394 | 
395 | 								fwd_vy_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vy2_d,mgdevice[i].vy1_d,mgdevice[i].txy2_d,mgdevice[i].tyy2_d,mgdevice[i].tyz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
396 | 
397 | 								fwd_vz_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vz2_d,mgdevice[i].vz1_d,mgdevice[i].txz2_d,mgdevice[i].tyz2_d,mgdevice[i].tzz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);
398 | 							}
399 | 
400 | 								checkCudaErrors(cudaDeviceSynchronize());
401 | 								//if(fmod(it+1.0,1000.0)==1)	warn("fwd_vx_3D fwd_vy_3D fwd_vz_3D is passing");
402 | 					
403 | 							{
404 | 								exchange_device_nz_kernel_vx_vy_vz2(mgdevice,exchange_device_bool);//////////////gpu_i exchange  gpu_i+1;///
405 | 
406 | 								checkCudaErrors(cudaDeviceSynchronize());
407 | 								//if(fmod(it+1.0,1000.0)==1)	warn("exchange_device_nz_kernel_vx_vy_vz2 is passing");
408 | 							}
409 | 
410 | 							for(int i=0;i<GPU_N;i++)
411 | 							{
412 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
413 | 
414 | 								fwd_vxp_vzp_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].vxp2_d,mgdevice[i].vxp1_d,mgdevice[i].vyp2_d,mgdevice[i].vyp1_d,mgdevice[i].vzp2_d,mgdevice[i].vzp1_d,mgdevice[i].tp2_d,mgdevice[i].vxs2_d,mgdevice[i].vys2_d,mgdevice[i].vzs2_d,mgdevice[i].vx2_d,mgdevice[i].vy2_d,mgdevice[i].vz2_d,mgdevice[i].s_velocity_d,mgdevice[i].s_velocity1_d,mgdevice[i].s_density_d,mgdevice[i].att_d,mgdevice[i].coe_d,nnx,nny,nnz_device_append,dt,coe_x,coe_y,coe_z);	
415 | 							}
416 | 
417 | 								checkCudaErrors(cudaDeviceSynchronize());
418 | 								//if(fmod(it+1.0,1000.0)==1)	warn("fwd_vxp_vzp_3D is passing");							
419 | 
420 | 							{
421 | 								exchange_wavefiled_new(mgdevice);//////////////////change wavefield_new
422 | 								//exchange_wavefiled_old(mgdevice);//////////////////change wavefield_old	
423 | 
424 | 								checkCudaErrors(cudaDeviceSynchronize());
425 | 								//if(fmod(it+1.0,1000.0)==1)	warn("exchange_wavefiled_new is passing");	
426 | 							}
427 | 
428 | 							for(int i=0;i<GPU_N;i++)
429 | 							{
430 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
431 | 
432 | 								//cuda_cal_receiver_poyn_3D<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].poyn_rpx_d,mgdevice[i].poyn_rpy_d,mgdevice[i].poyn_rpz_d,mgdevice[i].poyn_rsx_d,mgdevice[i].poyn_rsy_d,mgdevice[i].poyn_rsz_d,mgdevice[i].ex_time_d,mgdevice[i].vxp2_d,mgdevice[i].vyp2_d,mgdevice[i].vzp2_d,mgdevice[i].vxs2_d,mgdevice[i].vys2_d,mgdevice[i].vzs2_d,mgdevice[i].tp2_d,mgdevice[i].txx2_d,mgdevice[i].tyy2_d,mgdevice[i].tzz2_d,mgdevice[i].txy2_d,mgdevice[i].txz2_d,mgdevice[i].tyz2_d,nnx,nny,nnz_device_append,it);
433 | 							}	
434 | 					
435 | 								checkCudaErrors(cudaDeviceSynchronize());
436 | 								//if(fmod(it+1.0,1000.0)==1)	warn("cuda_cal_receiver_poyn_3D is passing");
437 | 
438 | 							for(int i=0;i<GPU_N;i++)
439 | 							{
440 | 								checkCudaErrors(cudaSetDevice(gpuid[i]));
441 | 
442 | 								imaging_correlation_ex<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].ex_time_d,mgdevice[i].ex_tp_d,mgdevice[i].tp2_d,mgdevice[i].vresult_tp_d,nnx,nny,nnz_device_append,it,amp_max,precon_z1);
443 | 
444 | 								imaging_inner_product_ex<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].ex_time_d,mgdevice[i].ex_vxp_d,mgdevice[i].ex_vyp_d,mgdevice[i].ex_vzp_d,mgdevice[i].vxp2_d,mgdevice[i].vyp2_d,mgdevice[i].vzp2_d,mgdevice[i].vresult_pp_d,nnx,nny,nnz_device_append,it,tp_max,precon_z1);
445 | 
446 | 								imaging_inner_product_ex<<<dimGridwf_append,dimBlock,0,mgdevice[i].stream>>>(mgdevice[i].ex_time_d,mgdevice[i].ex_vxp_d,mgdevice[i].ex_vyp_d,mgdevice[i].ex_vzp_d,mgdevice[i].vxs2_d,mgdevice[i].vys2_d,mgdevice[i].vzs2_d,mgdevice[i].vresult_ps_d,nnx,nny,nnz_device_append,it,tp_max,precon_z1);
447 | 							}
448 | 
449 | 								checkCudaErrors(cudaDeviceSynchronize());
450 | 								//if(fmod(it+1.0,1000.0)==1)	warn("imaging_inner_product_ex is passing");
451 | 
452 | 						}
453 | }
454 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/3D_output_file.cu:
--------------------------------------------------------------------------------
  1 | 
  2 | void output_3d_wavefiled_tao(GPUdevice *mgdevice,int it)
  3 | {
  4 | 		for(int i=0;i<GPU_N;i++)
  5 | 		{
  6 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
  7 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].tp1_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
  8 | 
  9 | 			sprintf(filename,"./wavefield/tp-%d-%d",i,it);
 10 | 			output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
 11 | 		}
 12 | 
 13 | 			checkCudaErrors(cudaDeviceSynchronize());
 14 | 		
 15 | 			
 16 | 						
 17 | 		for(int i=0;i<GPU_N;i++)
 18 | 		{
 19 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
 20 | 
 21 | 			seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
 22 | 		}
 23 | 
 24 | 			checkCudaErrors(cudaDeviceSynchronize());
 25 | 
 26 | 		sprintf(filename,"./wavefield/tp-%d",it);
 27 | 		output_file_xyz(filename,wf_3d,nnx,nny,nnz);
 28 | 		sprintf(filename,"./wavefield/cut-tp-%d",it);
 29 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
 30 | }
 31 | 
 32 | void output_3d_wavefiled_vx(GPUdevice *mgdevice,int it)
 33 | {
 34 | 		for(int i=0;i<GPU_N;i++)
 35 | 		{
 36 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
 37 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vx1_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
 38 | 
 39 | 			sprintf(filename,"./wavefield/vx-%d-%d",i,it);
 40 | 			output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
 41 | 		}
 42 | 
 43 | 			checkCudaErrors(cudaDeviceSynchronize());
 44 | 		
 45 | 			
 46 | 						
 47 | 		for(int i=0;i<GPU_N;i++)
 48 | 		{
 49 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
 50 | 
 51 | 			seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
 52 | 		}
 53 | 
 54 | 			checkCudaErrors(cudaDeviceSynchronize());
 55 | 
 56 | 		sprintf(filename,"./wavefield/vx-%d",it);
 57 | 		output_file_xyz(filename,wf_3d,nnx,nny,nnz);
 58 | 		sprintf(filename,"./wavefield/cut-vx-%d",it);
 59 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
 60 | }
 61 | 
 62 | void output_3d_wavefiled_vz(GPUdevice *mgdevice,int it)
 63 | {
 64 | 		for(int i=0;i<GPU_N;i++)
 65 | 		{
 66 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
 67 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vz1_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
 68 | 
 69 | 			sprintf(filename,"./wavefield/vz-%d-%d",i,it);
 70 | 			output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
 71 | 		}
 72 | 
 73 | 			checkCudaErrors(cudaDeviceSynchronize());
 74 | 		
 75 | 			
 76 | 						
 77 | 		for(int i=0;i<GPU_N;i++)
 78 | 		{
 79 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
 80 | 
 81 | 			seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
 82 | 		}
 83 | 
 84 | 			checkCudaErrors(cudaDeviceSynchronize());
 85 | 
 86 | 		sprintf(filename,"./wavefield/vz-%d",it);
 87 | 		output_file_xyz(filename,wf_3d,nnx,nny,nnz);
 88 | 		sprintf(filename,"./wavefield/cut-vz-%d",it);
 89 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
 90 | }
 91 | 
 92 | 
 93 | void output_3d_wavefiled_vzp(GPUdevice *mgdevice,int it)
 94 | {
 95 | 		for(int i=0;i<GPU_N;i++)
 96 | 		{
 97 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
 98 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vzp1_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
 99 | 
100 | 			sprintf(filename,"./wavefield/vzp-%d-%d",i,it);
101 | 			output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
102 | 		}
103 | 
104 | 			checkCudaErrors(cudaDeviceSynchronize());
105 | 		
106 | 			
107 | 						
108 | 		for(int i=0;i<GPU_N;i++)
109 | 		{
110 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
111 | 
112 | 			seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
113 | 		}
114 | 
115 | 			checkCudaErrors(cudaDeviceSynchronize());
116 | 
117 | 		sprintf(filename,"./wavefield/vzp-%d",it);
118 | 		output_file_xyz(filename,wf_3d,nnx,nny,nnz);
119 | 		sprintf(filename,"./wavefield/cut-vzp-%d",it);
120 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
121 | }
122 | 
123 | void output_3d_wavefiled_vzs(GPUdevice *mgdevice,int it)
124 | {
125 | 		for(int i=0;i<GPU_N;i++)
126 | 		{
127 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
128 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vzs1_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
129 | 
130 | 			sprintf(filename,"./wavefield/vzs-%d-%d",i,it);
131 | 			output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
132 | 		}
133 | 
134 | 			checkCudaErrors(cudaDeviceSynchronize());
135 | 		
136 | 			
137 | 						
138 | 		for(int i=0;i<GPU_N;i++)
139 | 		{
140 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
141 | 
142 | 			seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
143 | 		}
144 | 
145 | 			checkCudaErrors(cudaDeviceSynchronize());
146 | 
147 | 		sprintf(filename,"./wavefield/vzs-%d",it);
148 | 		output_file_xyz(filename,wf_3d,nnx,nny,nnz);
149 | 		sprintf(filename,"./wavefield/cut-vzs-%d",it);
150 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
151 | }
152 | 
153 | 
154 | 
155 | void output_3d_wavefiled_excitation_amp_time(GPUdevice *mgdevice,int isx,int isy,int isz)
156 | {
157 | 		for(int i=0;i<GPU_N;i++)
158 | 		{
159 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
160 | 
161 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].ex_time_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
162 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf0_h,mgdevice[i].ex_amp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
163 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf1_h,mgdevice[i].ex_tp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
164 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf2_h,mgdevice[i].ex_vxp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
165 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf3_h,mgdevice[i].ex_vyp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
166 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf4_h,mgdevice[i].ex_vzp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
167 | 
168 | 			//sprintf(filename,"./wavefield/ex-time-%d-%d",i,it);
169 | 			//output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
170 | 		}
171 | 			checkCudaErrors(cudaDeviceSynchronize());
172 | 		
173 | 			
174 | 						
175 | 		for(int i=0;i<GPU_N;i++)
176 | 		{
177 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
178 | 
179 | 			seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
180 | 		}
181 | 
182 | 			checkCudaErrors(cudaDeviceSynchronize());
183 | 
184 | 		sprintf(filename,"./someoutput/ex-time-%d-%d",sy_real,sx_real);
185 | 		output_file_xyz(filename,wf_3d,nnx,nny,nnz);
186 | 		sprintf(filename,"./someoutput/cut-ex-time-%d-%d",sy_real,sx_real);
187 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
188 | 
189 | //////////////////////////////////amp=vx*vx+vy*vy+vz*vz
190 | 		for(int i=0;i<GPU_N;i++)
191 | 		{
192 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
193 | 
194 | 			seperate_or_togather_vel_att2(mgdevice[i].wf0_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
195 | 		}
196 | 
197 | 			checkCudaErrors(cudaDeviceSynchronize());
198 | 		sprintf(filename,"./someoutput/cut-ex-amp-%d-%d",sy_real,sx_real);
199 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
200 | 
201 | //////////////////////////////////tp
202 | 		for(int i=0;i<GPU_N;i++)
203 | 		{
204 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
205 | 
206 | 			seperate_or_togather_vel_att2(mgdevice[i].wf1_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
207 | 		}
208 | 
209 | 			checkCudaErrors(cudaDeviceSynchronize());
210 | 		sprintf(filename,"./someoutput/cut-ex-tp-%d-%d",sy_real,sx_real);
211 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
212 | 
213 | //////////////////////////////////vx
214 | 		for(int i=0;i<GPU_N;i++)
215 | 		{
216 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
217 | 
218 | 			seperate_or_togather_vel_att2(mgdevice[i].wf2_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
219 | 		}
220 | 
221 | 			checkCudaErrors(cudaDeviceSynchronize());
222 | 		sprintf(filename,"./someoutput/cut-ex-vxp-%d-%d",sy_real,sx_real);
223 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
224 | 
225 | 
226 | //////////////////////////////////vy
227 | 		for(int i=0;i<GPU_N;i++)
228 | 		{
229 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
230 | 
231 | 			seperate_or_togather_vel_att2(mgdevice[i].wf3_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
232 | 		}
233 | 
234 | 			checkCudaErrors(cudaDeviceSynchronize());
235 | 		sprintf(filename,"./someoutput/cut-ex-vyp-%d-%d",sy_real,sx_real);
236 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
237 | 
238 | 
239 | //////////////////////////////////vz
240 | 		for(int i=0;i<GPU_N;i++)
241 | 		{
242 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
243 | 
244 | 			seperate_or_togather_vel_att2(mgdevice[i].wf4_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
245 | 		}
246 | 
247 | 			checkCudaErrors(cudaDeviceSynchronize());
248 | 		sprintf(filename,"./someoutput/cut-ex-vzp-%d-%d",sy_real,sx_real);
249 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
250 | }
251 | 
252 | void output_3d_poyn_p(GPUdevice *mgdevice,int isx,int isy,int isz)
253 | {
254 | 		for(int i=0;i<GPU_N;i++)
255 | 		{
256 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
257 | 
258 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf2_h,mgdevice[i].poyn_px_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
259 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf3_h,mgdevice[i].poyn_py_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
260 | 			checkCudaErrors(cudaMemcpy(mgdevice[i].wf4_h,mgdevice[i].poyn_pz_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
261 | 
262 | 			//sprintf(filename,"./wavefield/ex-time-%d-%d",i,it);
263 | 			//output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
264 | 		}
265 | 			checkCudaErrors(cudaDeviceSynchronize());
266 | 		
267 | 			
268 | //////////////////////////////////vx
269 | 		for(int i=0;i<GPU_N;i++)
270 | 		{
271 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
272 | 
273 | 			seperate_or_togather_vel_att2(mgdevice[i].wf2_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
274 | 		}
275 | 
276 | 			checkCudaErrors(cudaDeviceSynchronize());
277 | 		sprintf(filename,"./someoutput/cut-px-%d-%d",sy_real,sx_real);
278 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
279 | 
280 | 
281 | //////////////////////////////////vy
282 | 		for(int i=0;i<GPU_N;i++)
283 | 		{
284 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
285 | 
286 | 			seperate_or_togather_vel_att2(mgdevice[i].wf3_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
287 | 		}
288 | 
289 | 			checkCudaErrors(cudaDeviceSynchronize());
290 | 		sprintf(filename,"./someoutput/cut-py-%d-%d",sy_real,sx_real);
291 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
292 | 
293 | 
294 | //////////////////////////////////vz
295 | 		for(int i=0;i<GPU_N;i++)
296 | 		{
297 | 			checkCudaErrors(cudaSetDevice(gpuid[i]));
298 | 
299 | 			seperate_or_togather_vel_att2(mgdevice[i].wf4_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
300 | 		}
301 | 
302 | 			checkCudaErrors(cudaDeviceSynchronize());
303 | 		sprintf(filename,"./someoutput/cut-pz-%d-%d",sy_real,sx_real);
304 | 		output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
305 | }
306 | 
307 | 
308 | 
309 | void output_3d_result(GPUdevice *mgdevice,int isx,int isy,int isz)
310 | {
311 | 		if(vsp==0)
312 | 		{
313 | 			for(int i=0;i<GPU_N;i++)
314 | 			{
315 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
316 | 
317 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vresult_tp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
318 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf1_h,mgdevice[i].vresult_pp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
319 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf2_h,mgdevice[i].vresult_ps_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
320 | 				
321 | 				//sprintf(filename,"./wavefield/ex-time-%d-%d",i,it);
322 | 				//output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
323 | 			}
324 | 				checkCudaErrors(cudaDeviceSynchronize());
325 | 			
326 | 				
327 | 							
328 | 			for(int i=0;i<GPU_N;i++)
329 | 			{
330 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
331 | 
332 | 				seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
333 | 			}
334 | 
335 | 				checkCudaErrors(cudaDeviceSynchronize());
336 | 
337 | 			//sprintf(filename,"./result/result-tp-%d-%d",sy_real,sx_real);
338 | 			//output_file_xyz(filename,wf_3d,nnx,nny,nnz);
339 | 			sprintf(filename,"./result/result-tp-%d-%d",sy_real,sx_real);
340 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
341 | 
342 | 	//////////////////////////////////tp
343 | 			for(int i=0;i<GPU_N;i++)
344 | 			{
345 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
346 | 
347 | 				seperate_or_togather_vel_att2(mgdevice[i].wf1_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
348 | 			}
349 | 
350 | 				checkCudaErrors(cudaDeviceSynchronize());
351 | 			
352 | 			sprintf(filename,"./result/result-pp-%d-%d",sy_real,sx_real);
353 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
354 | 
355 | 	//////////////////////////////////vx
356 | 			for(int i=0;i<GPU_N;i++)
357 | 			{
358 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
359 | 
360 | 				seperate_or_togather_vel_att2(mgdevice[i].wf2_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
361 | 			}
362 | 
363 | 				checkCudaErrors(cudaDeviceSynchronize());
364 | 
365 | 			sprintf(filename,"./result/result-ps-%d-%d",sy_real,sx_real);
366 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
367 | 		}
368 | 
369 | 		else
370 | 		{
371 | 			for(int i=0;i<GPU_N;i++)
372 | 			{
373 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
374 | 
375 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vresult_tp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
376 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf1_h,mgdevice[i].vresult_pp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
377 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf2_h,mgdevice[i].vresult_ps_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
378 | 				
379 | 				//sprintf(filename,"./wavefield/ex-time-%d-%d",i,it);
380 | 				//output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
381 | 			}
382 | 				checkCudaErrors(cudaDeviceSynchronize());
383 | 			
384 | 				
385 | 							
386 | 			for(int i=0;i<GPU_N;i++)
387 | 			{
388 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
389 | 
390 | 				seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
391 | 			}
392 | 
393 | 				checkCudaErrors(cudaDeviceSynchronize());
394 | 
395 | 			//sprintf(filename,"./result/result-tp-%d",sz_real);
396 | 			//output_file_xyz(filename,wf_3d,nnx,nny,nnz);
397 | 			sprintf(filename,"./result/result-tp-%d",sz_real);
398 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
399 | 
400 | 	//////////////////////////////////tp
401 | 			for(int i=0;i<GPU_N;i++)
402 | 			{
403 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
404 | 
405 | 				seperate_or_togather_vel_att2(mgdevice[i].wf1_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
406 | 			}
407 | 
408 | 				checkCudaErrors(cudaDeviceSynchronize());
409 | 			
410 | 			sprintf(filename,"./result/result-pp-%d",sz_real);
411 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
412 | 
413 | 	//////////////////////////////////vx
414 | 			for(int i=0;i<GPU_N;i++)
415 | 			{
416 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
417 | 
418 | 				seperate_or_togather_vel_att2(mgdevice[i].wf2_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
419 | 			}
420 | 
421 | 				checkCudaErrors(cudaDeviceSynchronize());
422 | 
423 | 			sprintf(filename,"./result/result-ps-%d",sz_real);
424 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
425 | 		}
426 | 
427 | 
428 | }
429 | 
430 | void output_3d_result_compensate(GPUdevice *mgdevice,int isx,int isy,int isz)
431 | {
432 | 		if(vsp==0)
433 | 		{
434 | 			for(int i=0;i<GPU_N;i++)
435 | 			{
436 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
437 | 
438 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vresult_tp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
439 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf1_h,mgdevice[i].vresult_pp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
440 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf2_h,mgdevice[i].vresult_ps_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
441 | 				
442 | 				//sprintf(filename,"./wavefield/ex-time-%d-%d",i,it);
443 | 				//output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
444 | 			}
445 | 				checkCudaErrors(cudaDeviceSynchronize());
446 | 			
447 | 				
448 | 							
449 | 			for(int i=0;i<GPU_N;i++)
450 | 			{
451 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
452 | 
453 | 				seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
454 | 			}
455 | 
456 | 				checkCudaErrors(cudaDeviceSynchronize());
457 | 
458 | 			//sprintf(filename,"./result/result-tp-%d-%d",sy_real,sx_real);
459 | 			//output_file_xyz(filename,wf_3d,nnx,nny,nnz);
460 | 			sprintf(filename,"./result/compensate-result-tp-%d-%d",sy_real,sx_real);
461 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
462 | 
463 | //////////////////////////////////pp
464 | 			for(int i=0;i<GPU_N;i++)
465 | 			{
466 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
467 | 
468 | 				seperate_or_togather_vel_att2(mgdevice[i].wf1_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
469 | 			}
470 | 
471 | 				checkCudaErrors(cudaDeviceSynchronize());
472 | 			
473 | 			sprintf(filename,"./result/compensate-result-pp-%d-%d",sy_real,sx_real);
474 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
475 | 
476 | //////////////////////////////////ps
477 | 			for(int i=0;i<GPU_N;i++)
478 | 			{
479 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
480 | 
481 | 				seperate_or_togather_vel_att2(mgdevice[i].wf2_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
482 | 			}
483 | 
484 | 				checkCudaErrors(cudaDeviceSynchronize());
485 | 
486 | 			sprintf(filename,"./result/compensate-result-ps-%d-%d",sy_real,sx_real);
487 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
488 | 		}
489 | 
490 | 		else
491 | 		{
492 | 			for(int i=0;i<GPU_N;i++)
493 | 			{
494 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
495 | 
496 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf_h,mgdevice[i].vresult_tp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
497 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf1_h,mgdevice[i].vresult_pp_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
498 | 				checkCudaErrors(cudaMemcpy(mgdevice[i].wf2_h,mgdevice[i].vresult_ps_d,nnx*nny*nnz_device_append*sizeof(float),cudaMemcpyDefault));
499 | 				
500 | 				//sprintf(filename,"./wavefield/ex-time-%d-%d",i,it);
501 | 				//output_file_xyz(filename,mgdevice[i].wf_h,nnx,nny,nnz_device_append);
502 | 			}
503 | 				checkCudaErrors(cudaDeviceSynchronize());
504 | 			
505 | 				
506 | 							
507 | 			for(int i=0;i<GPU_N;i++)
508 | 			{
509 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
510 | 
511 | 				seperate_or_togather_vel_att2(mgdevice[i].wf_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
512 | 			}
513 | 
514 | 				checkCudaErrors(cudaDeviceSynchronize());
515 | 
516 | 			//sprintf(filename,"./result/result-tp-%d",sz_real);
517 | 			//output_file_xyz(filename,wf_3d,nnx,nny,nnz);
518 | 			sprintf(filename,"./result/compensate-result-tp-%d",sz_real);
519 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
520 | 
521 | //////////////////////////////////pp
522 | 			for(int i=0;i<GPU_N;i++)
523 | 			{
524 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
525 | 
526 | 				seperate_or_togather_vel_att2(mgdevice[i].wf1_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
527 | 			}
528 | 
529 | 				checkCudaErrors(cudaDeviceSynchronize());
530 | 			
531 | 			sprintf(filename,"./result/compensate-result-pp-%d",sz_real);
532 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
533 | 
534 | //////////////////////////////////ps
535 | 			for(int i=0;i<GPU_N;i++)
536 | 			{
537 | 				checkCudaErrors(cudaSetDevice(gpuid[i]));
538 | 
539 | 				seperate_or_togather_vel_att2(mgdevice[i].wf2_h,wf_3d,nnx,nny,nnz,nnz_device,i,radius,1);
540 | 			}
541 | 
542 | 				checkCudaErrors(cudaDeviceSynchronize());
543 | 
544 | 			sprintf(filename,"./result/compensate-result-ps-%d",sz_real);
545 | 			output_file_xyz_boundary(filename,wf_3d,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
546 | 		}
547 | 
548 | 
549 | }
550 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/3D_zzzzz:
--------------------------------------------------------------------------------
  1 | #define pai 3.1415926
  2 | 
  3 | void input_file_xyz_boundary(char *filename,float *data,int nx,int ny,int nz,int bl,int bf,int bu,int nxb,int nyb,int nzb)
  4 | //input_file_xyz_boundary(velocity_name,velocity_pml,nx,ny,nz,bl,bf,bu,nnx,nny,nnz);
  5 | {
  6 | 	FILE *fp;
  7 | 	int ix,iy,iz;
  8 | 	if((fp=fopen(filename,"rb"))==NULL)
  9 | 	{	
 10 | 		printf("Can not oen this file : %s\n",filename);
 11 | 		exit(0);
 12 | 	}
 13 | 
 14 | 	fp=fopen(filename,"rb");
 15 | 	for(ix=0;ix<nx;ix++)
 16 | 	{
 17 | 		for(iy=0;iy<ny;iy++)
 18 | 		{
 19 | 			for(iz=0;iz<nz;iz++)
 20 | 			{
 21 | 				fread(&data[(iz+bu)*nxb*nyb+(iy+bf)*nxb+ix+bl],sizeof(float),1,fp);
 22 | 			}
 23 | 		}
 24 | 	}
 25 | 	fclose(fp);
 26 | }
 27 | 
 28 | void input_file_xyz(char *filename,float *data,int nxb,int nyb,int nzb)
 29 | //input_file_xyz("./someoutput/s_vp.bin",velocity_pml,nnx,nny,nnz);
 30 | {
 31 | 	FILE *fp;
 32 | 	int ix,iy,iz;
 33 | 	if((fp=fopen(filename,"rb"))==NULL)
 34 | 	{	
 35 | 		printf("Can not oen this file : %s\n",filename);
 36 | 		exit(0);
 37 | 	}
 38 | 
 39 | 	fp=fopen(filename,"rb");
 40 | 	for(ix=0;ix<nxb;ix++)
 41 | 	{
 42 | 		for(iy=0;iy<nyb;iy++)
 43 | 		{
 44 | 			for(iz=0;iz<nzb;iz++)
 45 | 			{
 46 | 				fread(&data[(iz)*nxb*nyb+(iy)*nxb+ix],sizeof(float),1,fp);
 47 | 			}
 48 | 		}
 49 | 	}
 50 | 	fclose(fp);
 51 | }
 52 | 
 53 | 
 54 | void output_file_xyz_boundary(char *filename,float *data,int nx,int ny,int nz,int bl,int bf,int bu,int nxb,int nyb,int nzb)
 55 | {
 56 | 	FILE *fp;
 57 | 	int ix,iy,iz;
 58 | 	if((fp=fopen(filename,"wb+"))==NULL)
 59 | 	{	
 60 | 		printf("Can not oen this file : %s\n",filename);
 61 | 		exit(0);
 62 | 	}
 63 | 
 64 | 	fp=fopen(filename,"wb+");
 65 | 	for(ix=0;ix<nx;ix++)
 66 | 	{
 67 | 		for(iy=0;iy<ny;iy++)
 68 | 		{
 69 | 			for(iz=0;iz<nz;iz++)
 70 | 			{
 71 | 				fwrite(&data[(iz+bu)*nxb*nyb+(iy+bf)*nxb+ix+bl],sizeof(float),1,fp);
 72 | 			}
 73 | 		}
 74 | 	}
 75 | 	fclose(fp);
 76 | }
 77 | 
 78 | void output_file_xyz(char *filename,float *data,int nxb,int nyb,int nzb)
 79 | {
 80 | 	FILE *fp;
 81 | 	int ix,iy,iz;
 82 | 	if((fp=fopen(filename,"wb+"))==NULL)
 83 | 	{	
 84 | 		printf("Can not oen this file : %s\n",filename);
 85 | 		exit(0);
 86 | 	}
 87 | 
 88 | 	fp=fopen(filename,"wb+");
 89 | 	for(ix=0;ix<nxb;ix++)
 90 | 	{
 91 | 		for(iy=0;iy<nyb;iy++)
 92 | 		{
 93 | 			for(iz=0;iz<nzb;iz++)
 94 | 			{
 95 | 				fwrite(&data[iz*nyb*nxb+iy*nxb+ix],sizeof(float),1,fp);
 96 | 			}
 97 | 		}
 98 | 	}
 99 | 	fclose(fp);
100 | }
101 | 
102 | void output_3d(char *filename,float *Array1d,int nx,int ny,int nz)
103 | {
104 | 	FILE *fp;
105 | 	int ix,iy,iz;
106 | 	fp=fopen(filename,"wb+");
107 | 	for(ix=0;ix<nx;ix++)
108 | 	{
109 | 		for(iy=0;iy<ny;iy++)
110 | 		{
111 | 			for(iz=0;iz<nz;iz++)
112 | 			{
113 | 				fwrite(&Array1d[iz*nx*ny+iy*nx+ix],sizeof(float),1,fp);
114 | 			}
115 | 		}
116 | 	}
117 | 	fclose(fp);
118 | 
119 | }
120 | 
121 | 
122 | void output_3d_cut_boundary(char *filename,float *Array1d,int nx,int ny,int nz,int bl,int bf,int bu,int nxb,int nyb)
123 | {
124 | 	FILE *fp;
125 | 	int ix,iy,iz;
126 | 	fp=fopen(filename,"wb+");
127 | 	for(ix=0;ix<nx;ix++)
128 | 	{
129 | 		for(iy=0;iy<ny;iy++)
130 | 		{
131 | 			for(iz=0;iz<nz;iz++)
132 | 			{
133 | 				fwrite(&Array1d[(iz+bu)*nxb*nyb+(iy+bf)*nxb+ix+bl],sizeof(float),1,fp);
134 | 			}
135 | 		}
136 | 	}
137 | 	fclose(fp);
138 | 
139 | }
140 | 
141 | void add_pml_layers_v_h(float *v_h,int nx,int ny,int nz,int bl,int bf,int bu,int nxb,int nyb,int nzb)
142 | {
143 | 	int ix,iy,iz;
144 | //l	3
145 | 
146 | 	for(iy=bf;iy<ny+bf;iy++)
147 | 	for(ix=0;ix<bl;ix++)
148 | 	for(iz=bu;iz<nz+bu;iz++)
149 | 	{
150 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+iy*nxb+bl];
151 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][iy][bl];
152 | 	}
153 | 
154 | //r	4
155 | 	for(iy=bf;iy<ny+bf;iy++)
156 | 	for(ix=bl+nx;ix<nxb;ix++)
157 | 	for(iz=bu;iz<nz+bu;iz++)
158 | 	{
159 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+iy*nxb+bl+nx-1];
160 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][iy][bl+nx-1];
161 | 	}
162 | 
163 | //f	5
164 | 	for(iy=0;iy<bf;iy++)
165 | 	for(ix=bl;ix<nx+bl;ix++)
166 | 	for(iz=bu;iz<nz+bu;iz++)
167 | 	{
168 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+bf*nxb+ix];
169 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][bf][ix];
170 | 	}
171 | 
172 | 
173 | //b	6
174 | 
175 | 	for(iy=bf+ny;iy<nyb;iy++)
176 | 	for(ix=bl;ix<nx+bl;ix++)
177 | 	for(iz=bu;iz<nz+bu;iz++)
178 | 	{
179 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+(bf+ny-1)*nxb+ix];
180 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][bf+ny-1][ix];
181 | 	}
182 | 
183 | 
184 | 
185 | 
186 | 
187 | //fl	11
188 | 	for(iy=0;iy<bf;iy++)
189 | 	for(ix=0;ix<bl;ix++)
190 | 	for(iz=bu;iz<nz+bu;iz++)
191 | 	{
192 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+bf*nxb+bl];
193 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][bf][bl];
194 | 	}
195 | 
196 | 
197 | //fr	12
198 | 
199 | 	for(iy=0;iy<bf;iy++)
200 | 	for(ix=bl+nx;ix<nxb;ix++)
201 | 	for(iz=bu;iz<nz+bu;iz++)
202 | 	{
203 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+bf*nxb+bl+nx-1];
204 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][bf][bl+nx-1];
205 | 	}
206 | 
207 | 
208 | 
209 | 
210 | //bl	13
211 | 
212 | 	for(iy=bf+ny;iy<nyb;iy++)
213 | 	for(ix=0;ix<bl;ix++)
214 | 	for(iz=bu;iz<nz+bu;iz++)
215 | 	{
216 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+(bf+ny-1)*nxb+bl];
217 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][bf+ny-1][bl];
218 | 	}
219 | 
220 | 
221 | 
222 | 
223 | //br	14
224 | 
225 | 
226 | 
227 | 	for(iy=bf+ny;iy<nyb;iy++)
228 | 	for(ix=bl+nx;ix<nxb;ix++)
229 | 	for(iz=bu;iz<nz+bu;iz++)
230 | 	{
231 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz*nyb*nxb+(bf+ny-1)*nxb+bl+nx-1];
232 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[iz][bf+ny-1][bl+nx-1];
233 | 	}
234 | 
235 | 
236 | 
237 | //u_all
238 | 
239 | 
240 | 	for(iy=0;iy<nyb;iy++)
241 | 	for(ix=0;ix<nxb;ix++)
242 | 	for(iz=0;iz<bu;iz++)
243 | 	{
244 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[bu*nyb*nxb+iy*nxb+ix];
245 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[bu][iy][ix];
246 | 	}
247 | 
248 | 
249 | //d_all
250 | 
251 | 
252 | 	for(iy=0;iy<nyb;iy++)
253 | 	for(ix=0;ix<nxb;ix++)
254 | 	for(iz=bu+nz;iz<nzb;iz++)
255 | 	{
256 | 	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[(bu+nz-1)*nyb*nxb+iy*nxb+ix];
257 | //	v_h[iz*nyb*nxb+iy*nxb+ix]=v_h[bu+nz-1][iy][ix];
258 | 	}
259 | }
260 | 
261 | void coe_attenuation_3d_new2(float *att_h,int nx,int ny,int nz,int bu,int bd,int bl,int br,int bf,int bb,float att_coe)
262 | {
263 | 	int ix,iy,iz,i,nxb,nyb,nzb;
264 | 	//int ran;
265 | 	//ran=0;
266 | 	//float temp;
267 | 
268 | 	nxb=nx+bl+br;
269 | 	nyb=ny+bf+bb;
270 | 	nzb=nz+bu+bd;
271 | 	
272 | 	float *distance_u,*distance_d,*distance_l,*distance_r,*distance_f,*distance_b;
273 | 
274 | 	distance_u=alloc1float(bu);
275 | 	distance_d=alloc1float(bd);
276 | 	distance_l=alloc1float(bl);
277 | 	distance_r=alloc1float(br);
278 | 	distance_f=alloc1float(bf);
279 | 	distance_b=alloc1float(bb);
280 | 
281 | 
282 | 	for(i=0;i<bu;i++)
283 | 	{
284 | 		distance_u[i]=att_coe*(1.0-cos((pai/2*(bu-i-1)/(bu-1))));
285 | 	}
286 | 
287 | 
288 | 	for(i=0;i<bd;i++)
289 | 	{
290 | 		distance_d[i]=att_coe*(1.0-cos((pai/2*i/(bd-1))));
291 | 	}
292 | 
293 | 	for(i=0;i<bl;i++)
294 | 	{
295 | 		distance_l[i]=att_coe*(1.0-cos((pai/2*(bl-i-1)/(bl-1))));
296 | 	}
297 | 
298 | 
299 | 	for(i=0;i<br;i++)
300 | 	{
301 | 		distance_r[i]=att_coe*(1.0-cos((pai/2*i/(br-1))));
302 | 	}
303 | 
304 | 	for(i=0;i<bf;i++)
305 | 	{
306 | 		distance_f[i]=att_coe*(1.0-cos((pai/2*(bf-i-1)/(bf-1))));
307 | 	}
308 | 	for(i=0;i<bb;i++)
309 | 	{
310 | 		distance_b[i]=att_coe*(1.0-cos((pai/2*i/(bb-1))));
311 | 	}
312 | 
313 | 	//temp=1;
314 | 	
315 | //u
316 | 	for(iy=0;iy<nyb;iy++)
317 | 	for(ix=0;ix<nxb;ix++)
318 | 	for(iz=0;iz<bu;iz++) 
319 | 	{
320 | 		att_h[iz*nxb*nyb+iy*nxb+ix]+=distance_u[iz];
321 | 	}
322 | 
323 | //d
324 | 	for(iy=0;iy<nyb;iy++)
325 | 	for(ix=0;ix<nxb;ix++)
326 | 	for(iz=0;iz<bd;iz++) 
327 | 	{
328 | 		att_h[(bu+nz+iz)*nxb*nyb+iy*nxb+ix]+=distance_d[iz];//att_h[iy*nzb*nxb+ix*nzb+iz]*distance_d[nzb-iz-1];
329 | 	}
330 | 
331 | //l
332 | 	for(iy=0;iy<nyb;iy++)
333 | 	for(ix=0;ix<bl;ix++)
334 | 	for(iz=0;iz<nzb;iz++)
335 | 	{
336 | 		att_h[iz*nxb*nyb+iy*nxb+ix]+=distance_l[ix];//att_h[iy*nzb*nxb+ix*nzb+iz]*distance_l[ix];
337 | 	}
338 | //r
339 | 	for(iy=0;iy<nyb;iy++)
340 | 	for(ix=0;ix<br;ix++) 
341 | 	for(iz=0;iz<nzb;iz++)
342 | 	{
343 | 		att_h[iz*nxb*nyb+iy*nxb+bl+nx+ix]+=distance_r[ix];//att_h[iy*nzb*nxb+ix*nzb+iz]*distance_r[nxb-ix-1];
344 | 	}
345 | 
346 | //f
347 | 	for(iy=0;iy<bf;iy++)
348 | 	for(ix=0;ix<nxb;ix++)
349 | 	for(iz=0;iz<nzb;iz++)
350 | 	{
351 | 		att_h[iz*nxb*nyb+iy*nxb+ix]+=distance_f[iy];//att_h[iy*nzb*nxb+ix*nzb+iz]*distance_f[iy];
352 | 	}
353 | 
354 | //b
355 | 	for(iy=0;iy<bb;iy++) 
356 | 	for(ix=0;ix<nxb;ix++)
357 | 	for(iz=0;iz<nzb;iz++)
358 | 	{
359 | 		att_h[iz*nxb*nyb+(bf+ny+iy)*nxb+ix]+=distance_b[iy];//att_h[iy*nzb*nxb+ix*nzb+iz]*distance_b[nyb-iy-1];
360 | 	}
361 | 
362 | 
363 | 	free1float(distance_u);
364 | 	free1float(distance_d);
365 | 	free1float(distance_l);
366 | 	free1float(distance_r);
367 | 	free1float(distance_f);
368 | 	free1float(distance_b);
369 | }
370 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/log_old.txt:
--------------------------------------------------------------------------------
1 | vs has not been joined,thus they can be obtained by empirical formula
2 | den has not been joined,thus they can be obtained by empirical formula
3 | nnx=378,nny=378,nnz=241
4 | ,gpu_memory_size of one wavefield=131.359268
5 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/makefile:
--------------------------------------------------------------------------------
 1 | #! /bin/sh
 2 | 
 3 | INCLUDES = /usr/local/cuda-5.5/samples/common/inc
 4 |  INC=${CWPROOT}/include
 5 |  LIK=${CWPROOT}/lib
 6 |  LIB=-lsu -lpar -lcwp -lm -lcublas
 7 | 
 8 | 
 9 | ALL:3D_elastic_modeling
10 | 
11 | 
12 | 3D_elastic_modeling:3D_elastic_modeling.o
13 | 	nvcc -o 3D_elastic_modeling_gpu -g 3D_elastic_modeling.o -lm -O3 -I$(INC) -L$(LIK) $(LIB)
14 | 
15 | 3D_elastic_modeling.o:3D_elastic_modeling.cu
16 | 	nvcc -c 3D_elastic_modeling.cu -I$(INCLUDES) -O3 -I$(INC) -L$(LIK) $(LIB)
17 | 
18 | clean:
19 | 	rm *.o
20 | 
21 | #b:
22 | #	nvcc -o b -c b.cu -lm -I$(INCLUDES)
23 | 
24 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/smooth_3d:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | smooth3d< ./someoutput/den_all.bin n1=251 n2=388 n3=388 r1=30.000000 r2=30.000000 r3=30.000000 >./someoutput/s_den.bin 
3 | 


--------------------------------------------------------------------------------
/3D_elastic_RTM/zzzzz:
--------------------------------------------------------------------------------
   1 | void set_zero_1d(float *matrix,int nx)
   2 | {
   3 | 	int ix;
   4 | 	for(ix=0;ix<nx;ix++)
   5 | 		matrix[ix]=0.0;
   6 | }
   7 | 
   8 | void set_zero_2d(float **matrix,int nx,int nz)
   9 | {
  10 | 	int ix,iz;
  11 | 	for(ix=0;ix<nx;ix++)
  12 | 		for(iz=0;iz<nz;iz++)
  13 | 			matrix[iz][ix]=0.0;
  14 | }
  15 | 
  16 | void set_zero_3d(float ***matrix,int nx,int ny,int nz)
  17 | {
  18 | 	int ix,iy,iz;
  19 | 	
  20 | 	for(ix=0;ix<nx;ix++)
  21 | 		for(iy=0;iy<ny;iy++)
  22 | 			for(iz=0;iz<nz;iz++)
  23 | 				matrix[iz][iy][ix]=0.0;
  24 | }
  25 | 
  26 | void set_zero_1d_complex(complex *matrix,int nx)
  27 | {
  28 | 	int ix;
  29 | 	for(ix=0;ix<nx;ix++)
  30 | 		{
  31 | 			matrix[ix].r=0.0;
  32 | 			matrix[ix].i=0.0;
  33 | 		}
  34 | }
  35 | 
  36 | void set_zero_2d_complex(complex **matrix,int nx,int nz)
  37 | {
  38 | 	int ix,iz;
  39 | 	for(ix=0;ix<nx;ix++)
  40 | 		for(iz=0;iz<nz;iz++)
  41 | 			{
  42 | 				matrix[iz][ix].r=0.0;
  43 | 				matrix[iz][ix].i=0.0;
  44 | 			}
  45 | }
  46 | 
  47 | void set_zero_3d_complex(complex ***matrix,int nx,int ny,int nz)
  48 | {
  49 | 	int ix,iy,iz;
  50 | 	
  51 | 	for(ix=0;ix<nx;ix++)
  52 | 		for(iy=0;iy<ny;iy++)
  53 | 			for(iz=0;iz<nz;iz++)
  54 | 				{
  55 | 					matrix[iz][iy][ix].r=0.0;
  56 | 					matrix[iz][iy][ix].i=0.0;
  57 | 				}
  58 | }
  59 | void write_file_1d(float *matrix,int nx,char *name)
  60 | {
  61 | 	FILE *fp;
  62 | 	fp=fopen(name,"wb+");
  63 | 		fwrite(matrix,sizeof(float),nx,fp);
  64 | 		fclose(fp);
  65 | }
  66 | 
  67 | void write_file_2d(float **matrix,int nx,int nz,char *name)
  68 | {
  69 | 	int ix,iz;
  70 | 
  71 | 	FILE *fp;
  72 | 	fp=fopen(name,"wb+");
  73 | 	for(ix=0;ix<nx;ix++)
  74 | 		for(iz=0;iz<nz;iz++)
  75 | 	fwrite(&matrix[iz][ix],sizeof(float),1,fp);
  76 | 	fclose(fp);
  77 | }
  78 | 
  79 | void write_file_3d(float ***matrix,int nx,int ny,int nz,char *name)
  80 | {
  81 | 	int ix,iy,iz;
  82 | 
  83 | 	FILE *fp;
  84 | 	fp=fopen(name,"wb+");
  85 | 	for(ix=0;ix<nx;ix++)
  86 | 		for(iy=0;iy<ny;iy++)
  87 | 			for(iz=0;iz<nz;iz++)
  88 | 			fwrite(&matrix[iz][iy][ix],sizeof(float),1,fp);
  89 | 			fclose(fp);
  90 | }
  91 | 
  92 | void fread_file_1d(float *matrix,int nx,int nz,char *name)
  93 | {
  94 | 	int ix,iz;
  95 | 	FILE *fp;
  96 | 	fp=fopen(name,"rb");
  97 | 	for(ix=0;ix<nx;ix++)
  98 | 		for(iz=0;iz<nz;iz++)
  99 | 			fread(&matrix[ix*nz+iz],sizeof(float),1,fp);
 100 | 		fclose(fp);
 101 | }
 102 | 
 103 | void fread_file_2d(float **matrix,int nx,int nz,char *name)
 104 | {
 105 | 	int ix,iz;
 106 | 
 107 | 	FILE *fp;
 108 | 	fp=fopen(name,"rb");
 109 | 	for(ix=0;ix<nx;ix++)
 110 | 		for(iz=0;iz<nz;iz++)
 111 | 			fread(&matrix[iz][ix],sizeof(float),1,fp);
 112 | 				fclose(fp);
 113 | }
 114 | 
 115 | void fread_file_3d(float ***matrix,int nx,int ny,int nz,char *name)
 116 | {
 117 | 	int ix,iy,iz;
 118 | 	FILE *fp;
 119 | 
 120 | 	if((fp=fopen(name,"rb"))==NULL)
 121 | 	{	
 122 | 		printf("Can not oen this file : %s\n",name);
 123 | 		exit(0);
 124 | 	}
 125 | 	
 126 | 	
 127 | 	fp=fopen(name,"rb");
 128 | 	for(ix=0;ix<nx;ix++)
 129 | 		for(iy=0;iy<ny;iy++)
 130 | 			for(iz=0;iz<nz;iz++)
 131 | 				fread(&matrix[iz][iy][ix],sizeof(float),1,fp);
 132 | 					fclose(fp);
 133 | }
 134 | 
 135 | 
 136 | 
 137 | 
 138 | /////zzzzz:get ricker wave by two methods
 139 | float * make_ricker_new(float freq,float dt,int *Npoint)
 140 | {
 141 | 	float Bpar,t,u,*ricker;
 142 | 	int Np1,N;
 143 | 	
 144 | 	if(freq==0.0) freq=30.0;
 145 | 	if(dt==0.0) dt=0.004;
 146 | 	Bpar=sqrt(6.0)/(PI*freq);
 147 | 	N=(int)(ceil(1.35*Bpar/dt));
 148 | 	Np1=N;
 149 | 	*Npoint=2*N+1;
 150 | 	 
 151 | 	ricker=alloc1float(*Npoint);
 152 | 	ricker[Np1]=1.0;
 153 | 	for(int i=1;i<=N;i++)
 154 | 	{
 155 | 		t=dt*(float)i;
 156 | 		u=2.0*sqrt(6.0)*t/Bpar;
 157 | 		ricker[Np1+i]=ricker[Np1-i]=0.5*(2.0-u*u)*exp(-u*u/4.0);
 158 | 	}
 159 | 	return ricker;
 160 | }
 161 | 
 162 | void make_ricker_initial(float *ricker,float frmain,float dt,int wave_length)
 163 | {
 164 | 	float sdt,time,tp1,tp2;
 165 | 	int it;
 166 | 	sdt=dt*0.001;
 167 | 	for(it=0;it<wave_length;it++)
 168 |         {
 169 | 		time=(it+1)*sdt-(wave_length/2.0)*sdt;
 170 | 		tp1=PI*frmain*time;
 171 | 		tp2=tp1*tp1;
 172 | 		ricker[it]=(1.0-2.0*tp2)*exp(-tp2);
 173 |         }
 174 | }
 175 | 
 176 | void make_ricker_better(float *ricker,float frmain,float dt,int wave_length)
 177 | {
 178 | 	float sdt,time,tp1,tp2;
 179 | 	int it;
 180 | 	sdt=dt*0.001;
 181 | 	for(it=0;it<wave_length;it++)
 182 |         {
 183 | 		time=((it+1)*sdt-1.0/frmain)*sdt;
 184 | 		tp1=PI*frmain*time;
 185 | 		tp2=tp1*tp1;
 186 | 		ricker[it]=(1.0-2.0*tp2)*exp(-tp2);
 187 |         }
 188 | }
 189 | /*__global__ void cuda_ricker_wavelet(float *wlt, float amp, float fm, float dt, int nt)
 190 | {
 191 | 	int it=threadIdx.x+blockDim.x*blockIdx.x;
 192 |     	if (it<nt)
 193 | 	{
 194 | 	    	float tmp = PI*fm*(it*dt-1.0/fm);
 195 | 	    	tmp *=tmp;
 196 | 		wlt[it]=amp*(1.0-2.0*tmp)*expf(-tmp);
 197 | 	}
 198 | }*/
 199 | 
 200 | 
 201 | /////zzzzz:get one or two order difference coefficient
 202 | void make_coe_optimized_new(float *coe)
 203 | {
 204 | 		//*****optimized*********
 205 | 		coe[1]=1.2213363647;
 206 | 	      coe[2]=-0.096931457519;
 207 | 		coe[3]=0.017447662353;
 208 |             coe[4]=-0.0029672895159;
 209 |             coe[5]=0.00035900539822;
 210 | 		coe[6]=-0.00002184781161;////first-order derivative
 211 | 
 212 | 		/*coe[1]=1.2112426;
 213 |      		coe[2]=-0.0897216;
 214 |       	coe[3]=0.0138427;
 215 |      		coe[4]=-0.0017656;
 216 |       	coe[5]=0.0001186;
 217 | 		coe[6]=0.0;*/
 218 | 		//*****optimized end***********/
 219 | }
 220 | 
 221 | void make_coe_optimized1_new(float *coe)
 222 | {
 223 | 		//*****optimized*********
 224 | 		coe[0]= 0.0000;
 225 | 		coe[1]=+0.83333;
 226 | 		coe[2]=-0.23810;
 227 | 		coe[3]=+0.059524;
 228 | 		coe[4]=-0.0099206;
 229 | 		coe[5]=+0.0008038;///// second-order derivative
 230 | 		coe[6]= 0.0000;
 231 | 		//*****optimized end***********/
 232 | }
 233 | 
 234 | 
 235 | 
 236 | 
 237 | /////zzzzz:make_attenuation_new , read velocity_new , <<< get_current_shot_velocity_new  and  extend velocity >>>
 238 | void make_attenuation_new(float *attenuation,int nx,int nz,int boundary_up,int boundary_down,int boundary_left,int boundary_right,float coe_attenuation)
 239 | {
 240 | 	float *att_up,*att_down,*att_left,*att_right;
 241 | 	if(boundary_up!=0) 
 242 | 		{	
 243 | 			att_up=alloc1float(boundary_up);
 244 | 			memset((void *) (att_up), 0, boundary_up* sizeof (float));
 245 | 		}
 246 | 	att_down=alloc1float(boundary_down);
 247 | 	att_left=alloc1float(boundary_left);
 248 | 	att_right=alloc1float(boundary_right);
 249 | 	memset((void *) (att_down), 0, boundary_down* sizeof (float));
 250 | 	memset((void *) (att_left), 0, boundary_left* sizeof (float));
 251 | 	memset((void *) (att_right), 0, boundary_right* sizeof (float));
 252 | 	
 253 | 	float xxx;
 254 | 		
 255 | 	if(boundary_up!=0)
 256 | 	{
 257 | 			for(int iz=0;iz<boundary_up;iz++)
 258 | 			{
 259 | 					xxx=(boundary_up-1.0-iz)/(boundary_up-1.0);
 260 | 					att_up[iz]=coe_attenuation*pow(xxx*1.0,3.0);
 261 | 					//att_up[iz]=coe_attenuation*(1.0-cos(PI/2*(boundary_up-iz-1)/(boundary_up-1)));//cos
 262 | 					//att_up[iz]=coe_attenuation*((boundary_up-1.0-iz)*(boundary_up-1.0-iz)*(boundary_up-1.0-iz)/((boundary_up-1.0)*(boundary_up-1.0)*(boundary_up-1.0)));//NPML
 263 | 			}
 264 | 	}
 265 | 
 266 | 			for(int iz=0;iz<boundary_down;iz++)
 267 | 			{
 268 | 					xxx=iz/(boundary_down-1.0);
 269 | 					att_down[iz]=coe_attenuation*pow(xxx*1.0,3.0);
 270 | 					//att_down[iz]=coe_attenuation*(1.0-cos(PI/2*iz/(boundary_down-1)));//cos
 271 | 					//att_down[iz]=coe_attenuation*(iz*iz*iz*1.0/((boundary_up-1.0)*(boundary_up-1.0)*(boundary_up-1.0)));//NPML
 272 | 			}
 273 | 
 274 | 			for(int ix=0;ix<boundary_left;ix++)
 275 | 			{
 276 | 					xxx=(boundary_left-1.0-ix)/(boundary_left-1.0);
 277 | 					att_left[ix]=coe_attenuation*pow(xxx*1.0,3.0);
 278 | 
 279 | 					//att_left[ix]=coe_attenuation*(1.0-cos(PI/2*(boundary_left-ix-1)/(boundary_left-1)));//cos
 280 | 					//att_left[ix]=coe_attenuation*((boundary_left-1.0-ix)*(boundary_left-1.0-ix)*(boundary_left-1.0-ix)/((boundary_left-1.0)*(boundary_left-1.0)*(boundary_left-1.0)));//NPML
 281 | 			}
 282 | 
 283 | 			for(int ix=0;ix<boundary_right;ix++)
 284 | 			{
 285 | 					xxx=ix/(boundary_right-1.0);
 286 | 					att_right[ix]=coe_attenuation*pow(xxx*1.0,3.0);
 287 | 					//att_right[ix]=coe_attenuation*(1.0-cos(PI/2*ix/(boundary_right-1)));//cos
 288 | 					//att_right[ix]=coe_attenuation*(ix*ix*ix*1.0/((boundary_right-1.0)*(boundary_right-1.0)*(boundary_right-1.0)));//NPML					
 289 | 			}
 290 | 
 291 | 	int nx_append=boundary_left+nx+boundary_right;
 292 | 	int nz_append=boundary_up+nz+boundary_down;
 293 | //u
 294 | 	if(boundary_up!=0)
 295 | 	{
 296 | 		for(int iz=0;iz<boundary_up;iz++)
 297 | 			for(int ix=0;ix<nx_append;ix++)
 298 | 			{
 299 | 					attenuation[ix*nz_append+iz]=att_up[iz];
 300 | 			}
 301 | 	}
 302 | //l
 303 | 		for(int iz=0;iz<nz_append;iz++)
 304 | 			for(int ix=0;ix<boundary_left;ix++)
 305 | 			{
 306 | 					attenuation[ix*nz_append+iz]+=att_left[ix];
 307 | 			}
 308 | //d
 309 | 		for(int iz=boundary_up+nz;iz<nz_append;iz++)
 310 | 			for(int ix=0;ix<nx_append;ix++)
 311 | 			{
 312 | 					attenuation[ix*nz_append+iz]+=att_down[iz-(boundary_up+nz)];
 313 | 			}
 314 | //r
 315 | 		for(int iz=0;iz<nz_append;iz++)
 316 | 			for(int ix=boundary_left+nx;ix<boundary_left+nx+boundary_right;ix++)
 317 | 			{
 318 | 					attenuation[ix*nz_append+iz]+=att_right[ix-(boundary_left+nx)];
 319 | 			}
 320 | 
 321 | 	if(boundary_up!=0) free1float(att_up);
 322 | 	free1float(att_down);
 323 | 	free1float(att_left);
 324 | 	free1float(att_right);
 325 | }
 326 | 
 327 | void read_velocity_new(float *velocity,int nx,int nz,int boundary_up,int boundary_down,int boundary_left,int boundary_right,char *filename)
 328 | ////read  all velocity mode 
 329 | {
 330 | 	FILE *velocity_fp;
 331 | 	
 332 | 	velocity_fp=fopen(filename,"rb");
 333 | 
 334 | 	int nx_append=boundary_left+nx+boundary_right;
 335 | 	int nz_append=boundary_up+nz+boundary_down;
 336 | 	for(int ix=0;ix<nx_append;ix++)
 337 | 	{
 338 | 			if(ix<boundary_left)
 339 | 					fseek(velocity_fp,0,0);
 340 | 			else if(ix<boundary_left+nx)
 341 | 					fseek(velocity_fp,(ix-boundary_left)*sizeof(float)*nz,0);
 342 | 			else
 343 | 					fseek(velocity_fp,(nx-1)*sizeof(float)*nz,0);
 344 | 			fread((velocity+ix*nz_append+boundary_up),sizeof(float),nz,velocity_fp);
 345 | 
 346 | 			for(int iz=0;iz<boundary_up;iz++)
 347 | 			{
 348 | 					velocity[ix*nz_append+iz]=velocity[ix*nz_append+boundary_up];
 349 | 			}
 350 | 			for(int iz=boundary_up+nz;iz<nz_append;iz++)
 351 | 			{
 352 | 					velocity[ix*nz_append+iz]=velocity[ix*nz_append+boundary_up+nz-1];
 353 | 			}
 354 | 	}
 355 | 	
 356 | 	fclose(velocity_fp);
 357 | }
 358 | 
 359 | void get_partly_mode(float *velocity_all,float *velocity_current,int nx,int nz,int receiver_x_cord,int receiver_interval,int receiver_num)
 360 | {
 361 | 	int ix,iz;
 362 | 	
 363 | 	int nnx;
 364 | 	nnx=receiver_interval*receiver_num;
 365 | 	
 366 | 	for(ix=0;ix<nnx;ix++)
 367 | 		for(iz=0;iz<nz;iz++)
 368 | 	  		velocity_current[ix*nz+iz]=velocity_all[(receiver_x_cord+ix)*nz+iz];	
 369 | }
 370 | 
 371 | void get_current_shot_velocity_new(float *velocity_current,int nx,int nz,int receiver_x_cord,int receiver_interval,int receiver_num,char *filename)
 372 | ////read some part velocity mode 
 373 | {
 374 | 	int ix,iz;
 375 | 	float *velocity_all;
 376 | 	velocity_all=alloc1float(nx*nz);
 377 | 	set_zero_1d(velocity_all,nx*nz);
 378 | 	fread_file_1d(velocity_all,nx,nz,filename);
 379 | 	//write_file_1d(velocity_all,nx*nz,"vel");
 380 | 	
 381 | 	int nnx;
 382 | 	nnx=receiver_interval*receiver_num;
 383 | 	
 384 | 	for(ix=0;ix<nnx;ix++)
 385 | 		for(iz=0;iz<nz;iz++)
 386 | 	  		velocity_current[ix*nz+iz]=velocity_all[(receiver_x_cord+ix)*nz+iz];	
 387 | }
 388 | 
 389 | void extend_velocity_new(float *velocity_input_1d,float *velocity_output_1d,int nx_append,int nz_append,int nx,int nz,int boundary_left,int boundary_up,int boundary_right,int boundary_down)
 390 | ////extend_velocity  nx=nx+apert nz=nz+apert
 391 | {
 392 | //the input is the size: nx * nz                              	
 393 | //the output is the size: nx_append * nz_append				
 394 | 	int ix,iz;
 395 | 	int du,dl,dr,dd;
 396 | 	du=boundary_up;
 397 | 	dd=boundary_down;
 398 | 	dl=boundary_left;
 399 | 	dr=boundary_right;
 400 | 	
 401 | 	/*int nx_append,nz_append;
 402 | 	nx_append=nx+dl+dr;
 403 | 	nz_append=nz+du+dd;*/
 404 | 	
 405 | 	float **velocity_output,**velocity_input;
 406 | 	velocity_output=alloc2float(nx_append,nz_append);
 407 | 	velocity_input=alloc2float(nx,nz);
 408 | 	set_zero_2d(velocity_output,nx_append,nz_append);
 409 | 	set_zero_2d(velocity_output,nx,nz);
 410 | 	
 411 | //set value for input_1d
 412 | 	for(ix=0;ix<nx;ix++)
 413 | 	for(iz=0;iz<nz;iz++)
 414 | 		{		
 415 | 			velocity_input[iz][ix]=velocity_input_1d[ix*nz+iz];
 416 | 		}
 417 | 		
 418 | //up
 419 | 	for(iz=0;iz<du;iz++)
 420 | 	for(ix=0;ix<nx;ix++)
 421 | 		{		
 422 | 			velocity_output[iz][ix+dl]=velocity_input[0][ix];
 423 | 		}
 424 | //down
 425 | 	for(iz=0;iz<dd;iz++)
 426 | 	for(ix=0;ix<nx;ix++)
 427 | 		{		
 428 | 			velocity_output[iz+du+nz][ix+dl]=velocity_input[nz-1][ix];
 429 | 		}
 430 | //left
 431 | 	for(iz=0;iz<nz;iz++)
 432 | 	for(ix=0;ix<dl;ix++)
 433 | 		{	
 434 | 			velocity_output[iz+du][ix]=velocity_input[iz][0];
 435 | 		}
 436 | //rigt
 437 | 	for(iz=0;iz<nz;iz++)
 438 | 	for(ix=0;ix<dr;ix++)
 439 | 		{	
 440 | 			velocity_output[iz+du][ix+dl+nx]=velocity_input[iz][nx-1];
 441 | 		}
 442 | //four corner
 443 | 
 444 | //ul
 445 | 	for(iz=0;iz<du;iz++)			
 446 | 	for(ix=0;ix<dl;ix++)
 447 | 		{
 448 | 			velocity_output[iz][ix]=velocity_input[0][0];
 449 | 		}
 450 | 
 451 | //ur
 452 | 	for(iz=0;iz<du;iz++)			
 453 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 454 | 		{
 455 | 			velocity_output[iz][ix]=velocity_input[0][nx-1];
 456 | 		}
 457 | 
 458 | //dl
 459 | 	for(iz=nz+du-1;iz<du+nz+dd;iz++)			
 460 | 	for(ix=0;ix<dl;ix++)
 461 | 		{
 462 | 			velocity_output[iz][ix]=velocity_input[nz-1][0];
 463 | 		}
 464 | 
 465 | //dr
 466 | 	for(iz=du+nz-1;iz<du+nz+dd;iz++)			
 467 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 468 | 		{
 469 | 			velocity_output[iz][ix]=velocity_input[nz-1][nx-1];
 470 | 		}
 471 | //med
 472 | 	for(iz=du;iz<du+nz;iz++)
 473 | 	for(ix=dl;ix<dl+nx;ix++)
 474 | 		{
 475 | 			velocity_output[iz][ix]=velocity_input[iz-du][ix-dl];
 476 | 		}
 477 | 		
 478 | //set vaule for ouput 1d
 479 | 	
 480 | 	for(ix=0;ix<nx_append;ix++)
 481 | 	for(iz=0;iz<nz_append;iz++)
 482 | 		{
 483 | 			velocity_output_1d[ix*nz_append+iz]=velocity_output[iz][ix];
 484 | 		}		
 485 | 
 486 | }
 487 | /////		extend_boundary_new:::   the destionation is extended boundary value to added boundary
 488 | void extend_boundary_new(float *input,int nx_append,int nz_append,int nx,int nz,int boundary_left,int boundary_up,int boundary_right,int boundary_down)
 489 | {
 490 | 	int ix,iz;
 491 | 	int du,dl,dr,dd;
 492 | 	du=boundary_up;
 493 | 	dd=boundary_down;
 494 | 	dl=boundary_left;
 495 | 	dr=boundary_right;
 496 | 	
 497 | 	float **v2,**v2pml;
 498 | 	v2=alloc2float(nx,nz);
 499 | 	v2pml=alloc2float(nx_append,nz_append);
 500 | 	
 501 | 	for(ix=0;ix<nx;ix++)
 502 | 		for(iz=0;iz<nz;iz++)
 503 | 			v2[iz][ix]=input[(ix+boundary_left)*nz_append+iz+boundary_up];	
 504 | //up
 505 | 	for(iz=0;iz<du;iz++)
 506 | 	for(ix=0;ix<nx;ix++)
 507 | 		{
 508 | 			
 509 | 			v2pml[iz][ix+dl]=v2[0][ix];
 510 | 		}
 511 | //down
 512 | 	for(iz=0;iz<dd;iz++)
 513 | 	for(ix=0;ix<nx;ix++)
 514 | 		{
 515 | 			
 516 | 			v2pml[iz+du+nz][ix+dl]=v2[nz-1][ix];
 517 | 		}
 518 | //left
 519 | 	for(iz=0;iz<nz;iz++)
 520 | 	for(ix=0;ix<dl;ix++)
 521 | 		{
 522 | 			
 523 | 			v2pml[iz+du][ix]=v2[iz][0];
 524 | 		}
 525 | //rigt
 526 | 	for(iz=0;iz<nz;iz++)
 527 | 	for(ix=0;ix<dr;ix++)
 528 | 		{
 529 | 			
 530 | 			v2pml[iz+du][ix+dl+nx]=v2[iz][nx-1];
 531 | 		}
 532 | //four corner
 533 | 
 534 | //ul
 535 | 	for(iz=0;iz<du;iz++)			
 536 | 	for(ix=0;ix<dl;ix++)
 537 | 		{
 538 | 			v2pml[iz][ix]=v2[0][0];
 539 | 		}
 540 | 
 541 | //ur
 542 | 	for(iz=0;iz<du;iz++)			
 543 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 544 | 		{
 545 | 			v2pml[iz][ix]=v2[0][nx-1];
 546 | 		}
 547 | 
 548 | //dl
 549 | 	for(iz=nz+du-1;iz<du+nz+dd;iz++)			
 550 | 	for(ix=0;ix<dl;ix++)
 551 | 		{
 552 | 			v2pml[iz][ix]=v2[nz-1][0];
 553 | 		}
 554 | 
 555 | //dr
 556 | 	for(iz=du+nz-1;iz<du+nz+dd;iz++)			
 557 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 558 | 		{
 559 | 			v2pml[iz][ix]=v2[nz-1][nx-1];
 560 | 		}
 561 | //med
 562 | 	for(iz=du;iz<du+nz;iz++)
 563 | 	for(ix=dl;ix<dl+nx;ix++)
 564 | 		{
 565 | 			v2pml[iz][ix]=v2[iz-du][ix-dl];
 566 | 		}
 567 | 	
 568 | 	for(ix=0;ix<nx_append;ix++)
 569 | 		for(iz=0;iz<nz_append;iz++)
 570 | 			input[ix*nz_append+iz]=v2pml[iz][ix];
 571 | 			
 572 | 	free2float(v2);
 573 | 	free2float(v2pml);
 574 | }
 575 | 
 576 | void read_resultpp_new(float *resultpp,int nx,int nz,int boundary_up,int boundary_down,int boundary_left,int boundary_right,char *filename)
 577 | {
 578 | 	
 579 | 	int ix,iz,nx_append,nz_append;
 580 | 	nx_append=nx+boundary_left+boundary_right;
 581 | 	nz_append=nz+boundary_up+boundary_down;
 582 | 	
 583 | 	float **v2;
 584 | 	v2=alloc2float(nx,nz);
 585 | 	set_zero_2d(v2,nx,nz);
 586 | 	
 587 | 	FILE *fp;
 588 | 	fp=fopen(filename,"rb");
 589 | 	for(ix=0;ix<nx;ix++)
 590 | 		for(iz=0;iz<nz;iz++)
 591 | 			fread(&v2[iz][ix],4,1,fp);
 592 | 		fclose(fp);
 593 | 		
 594 | 	float **v2pml;
 595 | 	v2pml=alloc2float(nx_append,nz_append);
 596 | 	set_zero_2d(v2pml,nx_append,nz_append);
 597 | 	
 598 | 	int du,dl,dr,dd;
 599 | 	du=boundary_up;
 600 | 	dd=boundary_down;
 601 | 	dl=boundary_left;
 602 | 	dr=boundary_right;
 603 | 		
 604 | //up	
 605 | 	for(ix=0;ix<nx;ix++)
 606 | 	for(iz=0;iz<du;iz++)
 607 | 		{
 608 | 			
 609 | 			v2pml[iz][ix+dl]=v2[0][ix];
 610 | 		}
 611 | //down	
 612 | 	for(ix=0;ix<nx;ix++)
 613 | 	for(iz=0;iz<dd;iz++)
 614 | 		{
 615 | 			
 616 | 			v2pml[iz+du+nz][ix+dl]=v2[nz-1][ix];
 617 | 		}
 618 | //left	
 619 | 	for(ix=0;ix<dl;ix++)
 620 | 		for(iz=0;iz<nz;iz++)
 621 | 		{
 622 | 			
 623 | 			v2pml[iz+du][ix]=v2[iz][0];
 624 | 		}
 625 | //rigt
 626 | 	for(ix=0;ix<dr;ix++)
 627 | 	for(iz=0;iz<nz;iz++)
 628 | 	
 629 | 		{			
 630 | 			v2pml[iz+du][ix+dl+nx]=v2[iz][nx-1];
 631 | 		}
 632 | //four corner
 633 | 
 634 | //ul
 635 | 	for(iz=0;iz<du;iz++)			
 636 | 	for(ix=0;ix<dl;ix++)
 637 | 		{
 638 | 			v2pml[iz][ix]=v2[0][0];
 639 | 		}
 640 | 
 641 | //ur
 642 | 	for(iz=0;iz<du;iz++)			
 643 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 644 | 		{
 645 | 			v2pml[iz][ix]=v2[0][nx-1];
 646 | 		}
 647 | 
 648 | //dl
 649 | 	for(iz=nz+du-1;iz<du+nz+dd;iz++)			
 650 | 	for(ix=0;ix<dl;ix++)
 651 | 		{
 652 | 			v2pml[iz][ix]=v2[nz-1][0];
 653 | 		}
 654 | 
 655 | //dr
 656 | 	for(iz=du+nz-1;iz<du+nz+dd;iz++)			
 657 | 	for(ix=dl+nx-1;ix<dl+nx+dr;ix++)
 658 | 		{
 659 | 			v2pml[iz][ix]=v2[nz-1][nx-1];
 660 | 		}
 661 | //med
 662 | 	for(iz=du;iz<du+nz;iz++)
 663 | 	for(ix=dl;ix<dl+nx;ix++)
 664 | 		{
 665 | 			v2pml[iz][ix]=v2[iz-du][ix-dl];
 666 | 		}
 667 | 	
 668 | 	for(ix=0;ix<nx_append;ix++)
 669 | 		for(iz=0;iz<nz_append;iz++)
 670 | 			resultpp[ix*nz_append+iz]=v2pml[iz][ix];
 671 | 	
 672 | 	free2float(v2);
 673 | 	free2float(v2pml);	
 674 | }
 675 | 
 676 | 
 677 | 
 678 | 
 679 | ///multiple time smooth velocity // multiple time smooth imagingdown
 680 | void cpu_smooth_velocity(float *velocity,int nx_append,int nz_append,int times)
 681 | {
 682 | 	int ix,iz,i;
 683 | 	float *matrix,*wf_append;
 684 | 	matrix=alloc1float(nx_append*nz_append);
 685 | 	wf_append=alloc1float(nx_append*nz_append);	
 686 | 	memset((void *) (matrix), 0, nx_append*nz_append * sizeof (float));
 687 | 	memset((void *) (wf_append), 0, nx_append*nz_append * sizeof (float));
 688 | 		
 689 | 	for(ix=0;ix<nx_append;ix++)
 690 | 		for(iz=0;iz<nz_append;iz++)
 691 | 			wf_append[ix*nz_append+iz]=velocity[ix*nz_append+iz];
 692 | 		
 693 | 		
 694 | 	for(i=0;i<times;i++)
 695 | 	{
 696 | //exchange
 697 | 	for(ix=0;ix<nx_append;ix++)
 698 | 		for(iz=0;iz<nz_append;iz++)
 699 | 				wf_append[ix*nz_append+iz]=velocity[ix*nz_append+iz];
 700 | //smooth
 701 | 		for(ix=1;ix<nx_append-1;ix++)
 702 | 			for(iz=1;iz<nz_append-1;iz++)
 703 | 				matrix[ix*nz_append+iz]=(wf_append[ix*nz_append+iz]+wf_append[(ix+1)*nz_append+iz]+wf_append[(ix-1)*nz_append+iz]+wf_append[ix*nz_append+iz+1]+wf_append[ix*nz_append+iz-1])*1.0/5;
 704 | 		for(ix=1;ix<nx_append-1;ix++)
 705 | 			for(iz=1;iz<nz_append-1;iz++)
 706 | 				wf_append[ix*nz_append+iz]=matrix[ix*nz_append+iz];
 707 | //exchange
 708 | 	for(ix=0;ix<nx_append;ix++)
 709 | 		for(iz=0;iz<nz_append;iz++)
 710 | 				velocity[ix*nz_append+iz]=wf_append[ix*nz_append+iz];
 711 | 	}
 712 | 
 713 | 		free1float(matrix);
 714 | 		free1float(wf_append);
 715 | }
 716 | 
 717 | void smooth_imagingdown(float *wf,int nx,int nz,int smooth_denominator_time)
 718 | {
 719 | 		int ix,iz,itime;
 720 | 		float *wf1,*wf2;
 721 | 		wf1=alloc1float(nx*nz);
 722 | 		wf2=alloc1float(nx*nz);
 723 | 		memset((void *) (wf1), 0, nx*nz * sizeof (float));
 724 | 		memset((void *) (wf2), 0, nx*nz * sizeof (float));
 725 | //exchange
 726 | 		for(int ix=0;ix<nx;ix++)
 727 | 			for(int iz=0;iz<nz;iz++)
 728 | 				{
 729 | 					wf1[ix*nz+iz]=wf[ix*nz+iz];
 730 | 					wf2[ix*nz+iz]=wf[ix*nz+iz];
 731 | 				}
 732 | //smooth	imagingdown
 733 | 
 734 | 		for(itime=0;itime<smooth_denominator_time;itime++)
 735 | 			{
 736 | 				for(ix=2;ix<nx-2;ix++)
 737 | 					for(iz=2;iz<nz-2;iz++)
 738 | 						{
 739 | 							wf1[ix*nz+iz]=(wf2[ix*nz+iz]+wf2[(ix+1)*nz+iz]+wf2[(ix+2)*nz+iz]+wf2[(ix-2)*nz+iz]+wf2[(ix-1)*nz+iz])/5;			
 740 | 						}
 741 | 				for(ix=2;ix<nx-2;ix++)
 742 | 					for(iz=2;iz<nz-2;iz++)	
 743 | 						wf2[ix*nz+iz]=wf1[ix*nz+iz];
 744 | 		}	
 745 | //exchange
 746 | 		for(int ix=0;ix<nx;ix++)
 747 | 			for(int iz=0;iz<nz;iz++)
 748 | 				wf[ix*nz+iz]=wf2[ix*nz+iz];
 749 | 
 750 | 		free1float(wf1);
 751 | 		free1float(wf2);
 752 | 
 753 | }
 754 | 
 755 | 
 756 | 
 757 | ////  caculate max or min or average
 758 | float caculate_average(float *matrix,int nx,int nz)
 759 | {
 760 | 	float average;
 761 | 	float sum;
 762 | 	sum=0;
 763 | 	int ix,iz;
 764 | 	for(ix=0;ix<nx;ix++)
 765 | 		for(iz=10;iz<nz;iz++)
 766 | 			{
 767 | 				sum+=matrix[ix*nz+iz];
 768 | 			}
 769 | 
 770 | 	average=sum*1.0/(nz-10)/nx;
 771 | 	
 772 | 	return(average);	
 773 | }
 774 | 
 775 | float caculate_average_new(float *matrix,int nx,int nz)
 776 | {
 777 | 	float average;
 778 | 	float sum;
 779 | 	sum=0;
 780 | 	int ix,iz;
 781 | 	for(ix=0;ix<nx;ix++)
 782 | 		for(iz=0;iz<nz;iz++)
 783 | 			{
 784 | 				sum+=matrix[ix*nz+iz];
 785 | 			}
 786 | 
 787 | 	average=sum*1.0/nz/nx;
 788 | 	
 789 | 	return(average);	
 790 | }
 791 | 
 792 | float cpu_caculate_max(float *shotgather,int nx,int nz)
 793 | {
 794 | 	float max;
 795 | 	int ix,iz;
 796 | 	int in_idx;
 797 | 	max=0;
 798 | 	for(ix=0;ix<nx;ix++)
 799 | 		for(iz=0;iz<nz;iz++)
 800 | 			{
 801 | 				in_idx=ix*nz+iz;
 802 | 				if(shotgather[in_idx]>max)	max=shotgather[in_idx];
 803 | 			}
 804 | 			
 805 | 	return(max);
 806 | }
 807 | 
 808 | float cpu_caculate_min(float *shotgather,int nx,int nz)
 809 | {
 810 | 	float min;
 811 | 	int ix,iz;
 812 | 	int in_idx;
 813 | 	min=0;
 814 | 	for(ix=0;ix<nx;ix++)
 815 | 		for(iz=0;iz<nz;iz++)
 816 | 		{
 817 | 			in_idx=ix*nz+iz;
 818 | 			if(shotgather[in_idx]<min)	min=shotgather[in_idx];
 819 | 		}
 820 | 			
 821 | 	return(min);
 822 | }
 823 | 
 824 | 
 825 | ///// sort one/two dimension array along x or z direction
 826 | void sort_x(float *shotgather,int nx,int nz,int location_x,char *filename)
 827 | {
 828 | 	
 829 | 	float *matrix;
 830 | 	matrix=alloc1float(nz);
 831 | 
 832 | 	int iz;
 833 | 	for(iz=0;iz<nz;iz++)
 834 | 		matrix[iz]=shotgather[location_x*nz+iz];
 835 | 
 836 | 	write_file_1d(matrix,nz,filename);
 837 | 	
 838 | 	free1float(matrix);
 839 | }
 840 | 
 841 | void sort_x_2d(float **shotgather,int nx,int nz,int location_x,char *filename)
 842 | {
 843 | 	
 844 | 	float *matrix;
 845 | 	matrix=alloc1float(nz);
 846 | 
 847 | 	int iz;
 848 | 	for(iz=0;iz<nz;iz++)
 849 | 		matrix[iz]=shotgather[iz][location_x];
 850 | 
 851 | 	write_file_1d(matrix,nz,filename);
 852 | 	
 853 | 	free1float(matrix);
 854 | }
 855 | 
 856 | void sort_z(float *shotgather,int nx,int nz,int location_z,char *filename)
 857 | {
 858 | 	
 859 | 	float *matrix;
 860 | 	matrix=alloc1float(nx);
 861 | 
 862 | 	int ix;
 863 | 	for(ix=0;ix<nx;ix++)
 864 | 		matrix[ix]=shotgather[ix*nz+location_z];
 865 | 
 866 | 	write_file_1d(matrix,nx,filename);
 867 | 	
 868 | 	free1float(matrix);
 869 | }
 870 | 
 871 | void sort_z_2d(float **shotgather,int nx,int nz,int location_z,char *filename)
 872 | {
 873 | 	
 874 | 	float *matrix;
 875 | 	matrix=alloc1float(nx);
 876 | 
 877 | 	int ix;
 878 | 	for(ix=0;ix<nx;ix++)
 879 | 		matrix[ix]=shotgather[location_z][ix];
 880 | 
 881 | 	write_file_1d(matrix,nx,filename);
 882 | 	
 883 | 	free1float(matrix);
 884 | }
 885 | 
 886 | 
 887 | 
 888 | 
 889 | ////zzzzz: the following is one dimesion Fourier transform  or reversal Fourier transform  and  suhilbt transform
 890 | void DFT_real_to_complex_2d(float **result,complex **datanw,int nx,int nt,float dx,float dt)
 891 | {
 892 | 	int ix,it,iw,nw;
 893 | 	nw=nt;
 894 | 	double change;
 895 | 	
 896 | 	for(ix=0;ix<nx;ix++)
 897 | 		for(iw=0;iw<nw;iw++)
 898 | 		{
 899 | 			datanw[iw][ix].r=0;
 900 | 			datanw[iw][ix].i=0;
 901 | 			for(it=0;it<nt;it++)
 902 | 			{
 903 | 				//dataout[i].r=dataout[i].r+tempc1[j]*cos(i*dk*offset[j])*space[j];
 904 | 				//dataout[i].i=dataout[i].i-tempc1[j]*sin(i*dk*offset[j])*space[j];
 905 | 				change=iw*it*2*PI/nt*1.0;
 906 | 				datanw[iw][ix].r=datanw[iw][ix].r+result[it][ix]*cos(change);
 907 | 				datanw[iw][ix].i=datanw[iw][ix].i-result[it][ix]*sin(change);
 908 | 			}
 909 | 		}
 910 | }
 911 | 
 912 | void DFT_complex_to_complex_2d(complex **result,complex **datanw,int nx,int nt,float dx,float dt)
 913 | {
 914 | 	int ix,it,iw,nw;
 915 | 	nw=nt;
 916 | 	double change;
 917 | 
 918 | 	for(ix=0;ix<nx;ix++)
 919 | 		for(iw=0;iw<nw;iw++)
 920 | 		{
 921 | 			datanw[iw][ix].r=0;
 922 | 			datanw[iw][ix].i=0;
 923 | 			for(it=0;it<nt;it++)
 924 | 			{
 925 | 				//dataout[i].r=dataout[i].r+tempc1[j]*cos(i*dk*offset[j])*space[j];
 926 | 				//dataout[i].i=dataout[i].i-tempc1[j]*sin(i*dk*offset[j])*space[j];
 927 | 				change=iw*it*2*PI/nt*1.0;
 928 | 				datanw[iw][ix].r=datanw[iw][ix].r+(result[it][ix].r*cos(change)+result[it][ix].i*sin(change));
 929 | 				datanw[iw][ix].i=datanw[iw][ix].i+(result[it][ix].i*cos(change)-result[it][ix].r*sin(change));
 930 | 			}
 931 | 		}
 932 | }
 933 | 
 934 | void NDFT_complex_to_real_2d(float **result,complex **datanw,int nx,int nt,float dx,float dt)
 935 | {
 936 | 	int ix,it,iw,nw;
 937 | 	nw=nt;
 938 | 	double change;
 939 | 	
 940 | 	for(ix=0;ix<nx;ix++)
 941 | 		for(it=0;it<nt;it++)
 942 | 		{
 943 | 			result[it][ix]=0.0;
 944 | 			for(iw=0;iw<nw;iw++)
 945 | 			{	
 946 | 				change=iw*it*2*PI/nt*1.0;
 947 | 			
 948 | 				result[it][ix]=result[it][ix]+(datanw[iw][ix].r*cos(change)-datanw[iw][ix].i*sin(change));
 949 | 			}
 950 | 		}
 951 | 		
 952 | 	for(ix=0;ix<nx;ix++)
 953 | 		for(it=0;it<nt;it++)
 954 | 			result[it][ix]=result[it][ix]*1.0/nt;
 955 | }
 956 | 
 957 | void DFT_real_to_complex_1d(float *result_old,complex *result_nw,int nt,int nw,float dt)
 958 | {
 959 | 	int it,iw;
 960 | 	
 961 | 	double change;
 962 | 		
 963 | 	for(iw=0;iw<nw;iw++)
 964 | 		{
 965 | 			result_nw[iw].r=0;
 966 | 			result_nw[iw].i=0;
 967 | 			for(it=0;it<nt;it++)
 968 | 			{
 969 | 				change=iw*it*2*PI/nt*1.0;
 970 | 				result_nw[iw].r=result_nw[iw].r+result_old[it]*cos(change);
 971 | 				result_nw[iw].i=result_nw[iw].i-result_old[it]*sin(change);
 972 | 			}
 973 | 		}
 974 | }
 975 | 
 976 | void DFT_complex_to_complex_1d(complex *result_old,complex *result_nw,int nt,int nw,float dt)
 977 | {
 978 | 	int it,iw;
 979 | 	
 980 | 	double change;
 981 | 	
 982 | 		for(iw=0;iw<nw;iw++)
 983 | 		{
 984 | 			result_nw[iw].r=0;
 985 | 			result_nw[iw].i=0;
 986 | 			for(it=0;it<nt;it++)
 987 | 			{			
 988 | 				change=iw*it*2*PI/nt*1.0;
 989 | 				
 990 | 				result_nw[iw].r=result_nw[iw].r+(result_old[it].r*cos(change)+result_old[it].i*sin(change));
 991 | 				
 992 | 				result_nw[iw].i=result_nw[iw].i+(result_old[it].i*cos(change)-result_old[it].r*sin(change));
 993 | 			}
 994 | 		}
 995 | }
 996 | 
 997 | void NDFT_complex_to_real_1d(float *result_old,complex *result_nw,int nt,int nw,float dt)
 998 | {
 999 | 	int it,iw;
1000 | 
1001 | 	double change;
1002 | 	
1003 | 	for(it=0;it<nt;it++)
1004 | 		{
1005 | 			result_old[it]=0.0;
1006 | 			for(iw=0;iw<nw;iw++)
1007 | 			{	
1008 | 				change=iw*it*2*PI/nt*1.0;
1009 | 			
1010 | 				result_old[it]=result_old[it]+(result_nw[iw].r*cos(change)-result_nw[iw].i*sin(change));
1011 | 			}
1012 | 		}
1013 | 		
1014 | 	for(it=0;it<nt;it++)
1015 | 		result_old[it]=result_old[it]*1.0/nt;
1016 | }
1017 | 
1018 | void suhilbt(float *result_old,float *result_h,int nx_append,int nz_append,int nx,int nz,int boundary_left,int boundary_up,float dx,float dz)
1019 | {
1020 | 	int ix,iz,iw;
1021 | 	int nw,nt;
1022 | 	nt=nz;
1023 | 	
1024 | 	float **result;
1025 | 	result=alloc2float(nx,nz);
1026 | 	
1027 | 	for(ix=0;ix<nx;ix++)
1028 | 		for(iz=0;iz<nz;iz++)
1029 | 			result[iz][ix]=result_old[(ix+boundary_left)*nz_append+iz+boundary_up];
1030 | 					
1031 | //for convenience we use it replace with iz
1032 | 	nw=nt;
1033 | 	
1034 | 	complex **datanw;
1035 | 	datanw=alloc2complex(nx,nw);
1036 | 	
1037 | 	DFT_real_to_complex_2d(result,datanw,nx,nt,dx,dz);
1038 | 	
1039 | //hilbert transform
1040 | 	float change_r,change_i;
1041 | 		
1042 | 	for(ix=0;ix<nx;ix++)
1043 | 		for(iw=0;iw<nw/2;iw++)
1044 | 			{
1045 | 				change_r=datanw[iw][ix].r;change_i=datanw[iw][ix].i;
1046 | 				datanw[iw][ix].r=change_i;
1047 | 				datanw[iw][ix].i=-1*change_r;
1048 | 			}
1049 | 	for(ix=0;ix<nx;ix++)
1050 | 		for(iw=nw/2;iw<nw;iw++)
1051 | 			{
1052 | 				change_r=datanw[iw][ix].r;change_i=datanw[iw][ix].i;
1053 | 				datanw[iw][ix].r=-1*change_i;
1054 | 				datanw[iw][ix].i=change_r;
1055 | 			}
1056 | 
1057 | 	NDFT_complex_to_real_2d(result,datanw,nx,nt,dx,dz);
1058 | 	
1059 | 	for(ix=0;ix<nx;ix++)
1060 | 		for(iz=0;iz<nz;iz++)
1061 | 			result_h[(ix+boundary_left)*nz_append+iz+boundary_up]=result[iz][ix];	
1062 | 	
1063 | 	free2float(result);
1064 | 	free2complex(datanw);	
1065 | 
1066 | }
1067 | 
1068 | 
1069 | 
1070 | 
1071 | ///intergrating_seismic  and derivation 
1072 | void intergrating_seismic(float *shotgather,int lt,int receiver_num)
1073 | {
1074 | 		int ix,it;
1075 | 		int i,j;
1076 | 		float *exchange;
1077 | 		exchange=alloc1float(lt);
1078 | 		set_zero_1d(exchange,lt);
1079 | 
1080 | 		for(ix=0;ix<receiver_num;ix++)	
1081 | 		{
1082 | 			for(it=0;it<lt;it++)				
1083 | 				exchange[it]=shotgather[ix*lt+it];
1084 | 			for(i=0;i<lt;i++)
1085 | 				for(j=0;j<i;j++)
1086 | 					shotgather[ix*lt+i]+=exchange[j];	
1087 | 		}		
1088 | 			
1089 | 		free1float(exchange);
1090 | }
1091 | 
1092 | void derivation(float *wavelet,int wavelet_length,float *coe)
1093 | {
1094 | 	int ix;
1095 | 	float *matrix;
1096 | 	matrix=alloc1float(wavelet_length);
1097 | 	set_zero_1d(matrix,wavelet_length);
1098 | 
1099 | 	for(ix=6;ix<wavelet_length;ix++)
1100 | 		matrix[ix]=matrix[ix]+coe[1]*(wavelet[ix]-wavelet[ix-1])+coe[2]*(wavelet[ix+1]-wavelet[ix-2])+coe[3]*(wavelet[ix+2]-wavelet[ix-3])+coe[4]*(wavelet[ix+3]-wavelet[ix-4])+coe[5]*(wavelet[ix+4]-wavelet[ix-5])+coe[6]*(wavelet[ix+5]-wavelet[ix-6]);
1101 | 	
1102 | 	for(ix=6;ix<wavelet_length;ix++)
1103 | 		wavelet[ix]=matrix[ix];
1104 | }
1105 | 
1106 | 
1107 | 
1108 | 
1109 | /////cpu_laplace based on two or four order
1110 | void cpu_laplace(float *result,float *velocity,int nx,int nz,int nx_append,int nz_append,int boundary_left,int boundary_up,float dx,float dz)
1111 | {
1112 | 	int ix,iz,in_idx;
1113 | 	float v;
1114 | 	float *result1;
1115 | 	result1=alloc1float(nx*nz);
1116 | 	memset((void *)(result1),0,nx*nz*sizeof (float));
1117 | 
1118 | 	for(ix=0;ix<nx;ix++)
1119 | 		for(iz=0;iz<nz;iz++)
1120 | 			{
1121 | 				in_idx=ix*nz+iz;
1122 | 				if(ix==0||iz==0||ix==nx-1||iz==nz-1)	result1[in_idx]=-1*result[in_idx];
1123 | 				//t[iz][ix]=-(r[iz][ix+1]+r[iz][ix-1]-2*r[iz][ix])/dx2 - (r[iz+1][ix]+r[iz-1][ix]-2*r[iz][ix])/dz2;
1124 | 				else	result1[in_idx]=-1*((result[in_idx+nz]+result[in_idx-nz]-2*result[in_idx])/dx/dx+(result[in_idx+1]+result[in_idx-1]-2*result[in_idx])/dz/dz);
1125 | 				//t[iz][ix]=-(r[iz][ix+1]+r[iz][ix-1]+r[iz+1][ix]+r[iz-1][ix]-4*r[iz][ix])/dx2 - (r[iz][ix+1]+r[iz][ix-1]+r[iz+1][ix]+r[iz-1][ix]-4*r[iz][ix])/dz2
1126 | 				//else	result1[in_idx]=-1*((result[in_idx+nz]+result[in_idx-nz]+result[in_idx+1]+result[in_idx-1]-4*result[in_idx])/dx/dx+(result[in_idx+nz]+result[in_idx-nz]+result[in_idx+1]+result[in_idx-1]-4*result[in_idx])/dz/dz);
1127 | 			}
1128 | ////it's purpose to avoid boundary effect	
1129 | 	
1130 | 		for(iz=0;iz<nz;iz++)
1131 | 		{
1132 | 				result1[iz]=result1[nz+iz];
1133 | 				result1[(nx-1)*nz+iz]=result1[(nx-2)*nz+iz];
1134 | 				result1[iz*nz]=result1[iz*nz+1];
1135 | 				result1[iz*nz+nz-1]=result1[iz*nz+nz-2];
1136 | 		}
1137 | 			
1138 | 	for(ix=0;ix<nx;ix++)
1139 | 		for(iz=0;iz<nz;iz++)
1140 | 			{
1141 | 				v=velocity[(ix+boundary_left)*nz_append+iz+boundary_up];
1142 | 				result[ix*nz+iz]=v*v*result1[ix*nz+iz]/4;		
1143 | 			}
1144 | 			
1145 | 			
1146 | 	free1float(result1);
1147 | }
1148 | 
1149 | 
1150 | 
1151 | 
1152 | ///two program for extracting angle domain image gathers
1153 | void linear_interpolation(float *initial1,int nx,int nz,int angle_radius)
1154 | {
1155 | 	int ix,iz;
1156 | 
1157 | 	float **result1,**result2;;
1158 | 	result1=alloc2float(nx,nz);
1159 | 	result2=alloc2float(nx,nz);
1160 | 	for(ix=0;ix<nx;ix++)
1161 | 		for(iz=0;iz<nz;iz++)
1162 | 			{
1163 | 				result1[iz][ix]=initial1[ix*nz+iz];
1164 | 				result2[iz][ix]=initial1[ix*nz+iz];
1165 | 			}
1166 | 	for(ix=2;ix<nx-2;ix++)
1167 | 		for(iz=2;iz<nz-2;iz++)
1168 | 			{
1169 | 				if(result1[iz][ix]==0&&ix!=angle_radius-1)	result2[iz][ix]=(result1[iz][ix+1]+result1[iz][ix-1]+result1[iz][ix+2]+result1[iz][ix-2])/4.0;
1170 | 			}
1171 | 						
1172 | 	for(ix=0;ix<nx;ix++)
1173 | 		for(iz=0;iz<nz;iz++)
1174 | 			initial1[ix*nz+iz]=result2[iz][ix];
1175 | 
1176 | 	free2float(result1);
1177 | 	free2float(result2);
1178 | }
1179 | 
1180 | void add_cdp(float *r_adcigs,float *sum_cdp_pp,int nx,int nz,int id,int cdp_num,int angle_radius)
1181 | {
1182 | 	int ix,iz;
1183 | 	for(ix=0;ix<nx;ix++)
1184 | 		for(iz=0;iz<nz;iz++)
1185 | 			sum_cdp_pp[(ix+id*nx)*nz+iz]=r_adcigs[ix*nz+iz];
1186 | }
1187 | 
1188 | 
1189 | 
1190 | 
1191 | ////exchange to reduce nx_append to nx ///// nz_append to nz
1192 | void exchange(float *matrix1,float *matrix2,int nx,int nz,int nx_append,int nz_append,int boundary_left,int boundary_up)
1193 | {
1194 | 	int ix,iz;
1195 | 	for(ix=0;ix<nx;ix++)
1196 | 		for(iz=0;iz<nz;iz++)
1197 | 			matrix2[ix*nz+iz]=matrix1[(ix+boundary_left)*nz_append+iz+boundary_up];
1198 | }
1199 | /////  accumulation
1200 | void sum_result(float *result,float *wf,int nx,int nz)
1201 | {
1202 | 	int ix,iz;
1203 | 	for(ix=0;ix<nx;ix++)
1204 | 		for(iz=0;iz<nz;iz++)
1205 | 			result[ix*nz+iz]+=wf[ix*nz+iz];
1206 | }
1207 | 
1208 | void sum_result_new(float *result,float *wf,int nx,int nz,int imaging_size,int imaging_start)
1209 | {
1210 | 	int ix,iz;
1211 | 	for(ix=0;ix<imaging_size;ix++)
1212 | 		for(iz=0;iz<nz;iz++)
1213 | 			result[(ix+imaging_start)*nz+iz]+=wf[ix*nz+iz];
1214 | }
1215 | void sum_adcigs_new(float *adcigs_pp,float *r_adcigs_pp,int nx,int nz,int angle_num,int imaging_size,int imaging_start)
1216 | {
1217 | 	int ix,iz,iangle;
1218 | 	for(iangle=0;iangle<angle_num*2;iangle++)
1219 | 		for(ix=0;ix<imaging_size;ix++)
1220 | 			for(iz=0;iz<nz;iz++)		
1221 | 				adcigs_pp[iangle*nx*nz+(ix+imaging_start)*nz+iz]+=r_adcigs_pp[iangle*nx*nz+ix*nz+iz];		
1222 | }
1223 | 
1224 | void cpu_output_cdp(float *adcigs_pp,float *cdp_all,float *cdp_radius,int cdp_location,int angle_num,int angle_radius,int nx,int nz)
1225 | /////cpu_output_cdp(	   adcigs_pp,	  cdp_all,	      cdp_radius,   cdp_location[id],angle_num,	   angle_radius,    nx,    nz);
1226 | {
1227 | 	int iz,iangle;
1228 | 	
1229 | 	for(iangle=0;iangle<angle_num*2;iangle++)
1230 | 		for(iz=0;iz<nz;iz++)
1231 | 			cdp_all[iangle*nz+iz]=adcigs_pp[iangle*nx*nz+cdp_location*nz+iz];
1232 | 			
1233 | 	for(iangle=angle_num-angle_radius;iangle<angle_num+angle_radius;iangle++)	
1234 | 		for(iz=0;iz<nz;iz++)
1235 | 			cdp_all[iangle*nz+iz]=adcigs_pp[iangle*nx*nz+cdp_location*nz+iz];	
1236 | }
1237 | 
1238 | void sum_cpu_output_cdp(float *cdp_all,float *cdp_radius,float *sum_cdp_ps_all,float *sum_cdp_ps_radius,int angle_num,int angle_radius,int nz,int id,int cdp_num)
1239 | /////sum_cpu_output_cdp		 cdp_all,	    cdp_radius,	    sum_cdp_ps_all,	  sum_cdp_ps_radius,	angle_num,	  angle_radius,	 nz,	  id,	   cdp_num)
1240 | {
1241 | 	int ix,iz;
1242 | 	for(ix=0;ix<2*angle_num;ix++)
1243 | 		for(iz=0;iz<nz;iz++)
1244 | 			sum_cdp_ps_all[(ix+id*2*angle_num)*nz+iz]=cdp_all[ix*nz+iz];
1245 | 
1246 | 	for(ix=0;ix<2*angle_radius;ix++)
1247 | 		for(iz=0;iz<nz;iz++)
1248 | 			sum_cdp_ps_radius[(ix+id*2*angle_radius)*nz+iz]=cdp_all[ix*nz+iz];
1249 | }
1250 | 
1251 | void cpu_replace(float *velocity,float *s_velocity,int nx_append,int nz_append)
1252 | {
1253 | 	int ix,iz;
1254 | 	for(ix=0;ix<nx_append;ix++)
1255 | 		for(iz=0;iz<nz_append;iz++)
1256 | 		{
1257 | 			s_velocity[ix*nz_append+iz]=velocity[ix*nz_append+iz];
1258 | 		}
1259 | }
1260 | 
1261 | void vp_set_vs(float *velocity,float *velocity1,int nx_append,int nz_append)
1262 | {
1263 | 	int ix,iz;
1264 | 	
1265 | 	for(ix=0;ix<nx_append;ix++)
1266 | 		for(iz=0;iz<nz_append;iz++)
1267 | 		{
1268 | 			velocity1[ix*nz_append+iz]=velocity[ix*nz_append+iz]/sqrt(3)*1.0;
1269 | 		}
1270 | }
1271 | 
1272 | void vp_set_density(float *velocity,float *s_density,int nx_append,int nz_append)
1273 | {
1274 | 	int ix,iz;
1275 | 	
1276 | 	for(ix=0;ix<nx_append;ix++)
1277 | 		for(iz=0;iz<nz_append;iz++)
1278 | 		{
1279 | 			s_density[ix*nz_append+iz]=1000*0.23*sqrt(sqrt(velocity[ix*nz_append+iz]));
1280 | 	
1281 | 			//s_density[ix*nz_append+iz]=1000;
1282 | 		
1283 | 			//s_density[ix*nz_append+iz]=1500;
1284 | 
1285 | 			//s_density[ix*nz_append+iz]=1;
1286 | 		}
1287 | }
1288 | 
1289 | void vp_set_density_acousitc(float *velocity,float *s_density,int nx_append,int nz_append)
1290 | {
1291 | 	int ix,iz;
1292 | 	
1293 | 	for(ix=0;ix<nx_append;ix++)
1294 | 		for(iz=0;iz<nz_append;iz++)
1295 | 		{
1296 | 			s_density[ix*nz_append+iz]=1000*0.23*sqrt(sqrt(velocity[ix*nz_append+iz]));
1297 | 			
1298 | 			//s_density[ix*nz_append+iz]=1000;
1299 | 		}
1300 | }
1301 | 
1302 | void cpu_cal_perturb_velocity_to_velocity(float *velocity,float *velocity1,float *density,float *s_velocity,float *s_velocity1,float *s_density,int nx,int nz,int nx_append,int nz_append,int boundary_left,int boundary_up,int p_vp,int p_vs,int p_density,int mark)
1303 | {
1304 | 		int ix,iz;
1305 | 		int id;	
1306 | 		for(ix=0;ix<nx_append;ix++)
1307 | 		for(iz=0;iz<nz_append;iz++)
1308 | 		{
1309 | 			id=ix*nz_append+iz;	
1310 | 			s_velocity[id]=velocity[id];
1311 | 			s_velocity1[id]=velocity1[id];
1312 | 			s_density[id]=density[id];
1313 | 		}
1314 | 
1315 | 		if(mark==1)
1316 | 		{	
1317 | 			id=(boundary_left+nx/2)*nz_append+boundary_up+2*nz/4;	
1318 | 			s_velocity[id]=s_velocity[id]+p_vp;		
1319 | 		}
1320 | 
1321 | 		if(mark==2)
1322 | 		{	
1323 | 			id=(boundary_left+nx/2)*nz_append+boundary_up+2*nz/4;	
1324 | 			s_velocity1[id]=s_velocity1[id]+p_vs;				
1325 | 		}
1326 | 
1327 | 		if(mark==3)
1328 | 		{	
1329 | 			id=(boundary_left+nx/2)*nz_append+boundary_up+2*nz/4;	
1330 | 			s_density[id]=s_density[id]+p_density;
1331 | 		}
1332 | 
1333 | 
1334 | }
1335 | 
1336 | 
1337 | void cal_cpu_error_random(float *error_random,int amplitude_error_number,int receiver_num,int receiver_interval)
1338 | {
1339 | 		srand((unsigned)time(NULL));
1340 | 
1341 | 		int ix;
1342 | 
1343 | 		int change;
1344 | 
1345 | 		int count1=0,count2=0;
1346 | 
1347 | 		int *ranc;
1348 | 		ranc=alloc1int(amplitude_error_number);
1349 | 
1350 | 		//float *ranc1;
1351 | 		//ranc1=alloc1float(amplitude_error_number);
1352 | 		
1353 | 		int *ranc1;
1354 | 		ranc1=alloc1int(amplitude_error_number);
1355 | 
1356 | 
1357 | 		for(ix=0;ix<amplitude_error_number;ix++)
1358 | 		{
1359 | 			ranc[ix]=rand()%receiver_num;
1360 | 			
1361 | 			//printf("ranc[ix]=%d\n",ranc[ix]);
1362 | 		}
1363 | 
1364 | 		for(ix=0;ix<amplitude_error_number;ix++)
1365 | 		{
1366 | 			ranc1[ix]=rand()%100;
1367 | 
1368 | 			ranc1[ix]=ranc1[ix]%2;
1369 | 			
1370 | 			//printf("ranc[ix]=%d\n",ranc1[ix]);
1371 | 		}
1372 | 
1373 | 		for(ix=0;ix<amplitude_error_number;ix++)
1374 | 		{
1375 | 			change=int(ranc[ix]);
1376 | 
1377 | 			//error_random[change]=ranc1[ix];
1378 | 
1379 | 			if(ranc1[ix]==1)	
1380 | 			{
1381 | 				error_random[change]=6;
1382 | 				count1++;
1383 | 			}
1384 | 
1385 | 			if(ranc1[ix]!=1)
1386 | 			{
1387 | 				error_random[change]=1.0/6;//////1.0/6  is important
1388 | 				count2++;
1389 | 			}
1390 | 		}
1391 | 
1392 | 		for(ix=0;ix<receiver_num;ix++)
1393 | 		{
1394 | 			if(error_random[ix]==0)		error_random[ix]=1.0;
1395 | 		}
1396 | 
1397 | 		printf("count1=%d\n",count1);
1398 | 		printf("count2=%d\n",count2);
1399 | 		
1400 | 		free1int(ranc);
1401 | 		//free1float(ranc1);
1402 | 		free1int(ranc1);
1403 | }
1404 | 
1405 | void cal_cpu_shot_scale(float *shot_scale_h,int shot_num,int shot_scale)
1406 | {
1407 | 		srand((unsigned)time(NULL));
1408 | 
1409 | 		int ix;
1410 | 
1411 | 		//int change;
1412 | 
1413 | 		int *ranc;
1414 | 		ranc=alloc1int(shot_num);
1415 | 
1416 | 		//float *ranc1;
1417 | 		//ranc1=alloc1float(amplitude_error_number);
1418 | 
1419 | 
1420 | 		for(ix=0;ix<shot_num;ix++)
1421 | 		{
1422 | 			ranc[ix]=rand()%(shot_scale)+1;
1423 | 		}
1424 | 
1425 | 		
1426 | 		for(ix=0;ix<shot_num;ix++)
1427 | 		{
1428 | 			shot_scale_h[ix]=ranc[ix];
1429 | 
1430 | 			printf("shot_scale_h[ix]=%f\n",shot_scale_h[ix]);
1431 | 		}	
1432 | 		
1433 | 		free1int(ranc);
1434 | 		//free1float(ranc1);
1435 | 		//free1int(ranc1);
1436 | 
1437 | 
1438 | }
1439 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 2D_and_3D_elastic_reverse_time_migration
2 | 2D and 3D elastic reverse time migration using wavefield decomposition and vector-based excitation amplitude imaging condition.  
3 | I utilize the GPUs to speed up all the elastic wavefield extrapolations and application of the imaging conditions in the 3D case.
4 | 
5 | Note:
6 |      2D_elastic_RTM program can also implement elastic and viscoelastic LSRTM
7 | 


--------------------------------------------------------------------------------