kk/3D_EDFM_SIM-X
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
xinxiao
2026-03-13 11:24:41 +08:00
commit 04e2bb29c7
238 changed files with 29102 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
generic extended/GenerateNode_final_new.m
+90
View File
@@ -0,0 +1,90 @@
function [coordinates, nodes, nP, nE, dxv, dyv,dzv,zm,vm,xrao,yrao,zrao] = GenerateNode_final_new(dx, dy,dz ,nx,ny,nz,NTG)
% coordinates xy cordinate，即每个节点的x,y坐标
% nodes connection，即每个子区域对应的八个节点数
% nP numbers of point，即节点数量
% nE numbers of element，即子区域数量
nP = (nx + 1) * (ny + 1)*(nz+1);%计算节点数量
nE = nx * ny*nz;%子区域数量计算
% dx=dx*ones(nx,1);%此处是为了暂时妥协
% dy=dy*ones(nx,1);
% dz=dz*ones(nx,1);
dxv = zeros(nE, 1);%每个子区域x方向上尺寸矩阵
dyv = zeros(nE, 1);%每个子区域y方向上尺寸矩阵
dzv = zeros(nE, 1);
zm=zeros(nE, 1);%基质网格计算深度（以下平面为基准计算得到的高度，值为正数）
%给每个子区域的x方向和y方向赋尺寸
vm=zeros(nE, 1);%基质网格体积
for k=1:nz
for i = 1 : nx
for j = 1 : ny
dxv(i+(j-1)*nx+nx*ny*(k-1)) = dx(i);
dyv(i+(j-1)*nx+nx*ny*(k-1)) = dy(j);
dzv(i+(j-1)*nx+nx*ny*(k-1))=dz(k);
vm(i+(j-1)*nx+nx*ny*(k-1))=dx(i)*dy(j)*dz(k)*NTG(i+(j-1)*nx+nx*ny*(k-1));
end
end
end
coordinates = zeros(nP, 3);%初始化每个节点的x,y坐标矩阵
nodes = zeros(nE, 8);%初始化每个子区域对应的八个节点数的矩阵
%计算每个节点的坐标
x0 = zeros(nx+1,1);
y0 = zeros(ny+1,1);
z0=zeros(nz+1,1);
sumx = 0;
sumy = 0;
sumz=0;
for i = 1 : nx
sumx = sumx+dx(i);
x0(i+1) = sumx;
end
for i = 1 : ny
sumy = sumy+dy(i);
y0(i+1) = sumy;
end
for i = 1 : nz
sumz = sumz+dz(i);
z0(i+1) = sumz;
end
for k=1:nz+1
for j = 1 : ny + 1
for i = 1 : nx + 1
coordinates(i + (j - 1) * (nx + 1)+(nx+1)*(ny+1)*(k-1), 1) = x0(i);%(i,j）节点的x坐标赋值
coordinates(i + (j - 1) * (nx + 1)+(nx+1)*(ny+1)*(k-1), 2) = y0(j);%(i,j）节点的y坐标赋值
coordinates(i + (j - 1) * (nx + 1)+(nx+1)*(ny+1)*(k-1), 3) = z0(k);
end
end
end
%计算每个子区域的八个顶点(节点）对应的节点编号
for k=1:nz
for j = 1 : ny
for i = 1 : nx
nodes(i + (j - 1) * nx+nx*ny*(k-1), 1) = i + (j - 1) * (nx + 1)+(k-1)*(nx+1)*(ny+1);
nodes(i + (j - 1) * nx+nx*ny*(k-1), 2) = nodes(i + (j - 1) * nx+nx*ny*(k-1), 1) + 1;
nodes(i + (j - 1) * nx+nx*ny*(k-1), 3) = nodes(i + (j - 1) * nx+nx*ny*(k-1), 1) + nx + 1;
nodes(i + (j - 1) * nx+nx*ny*(k-1), 4) = nodes(i + (j - 1) * nx+nx*ny*(k-1), 1) + nx + 2;
nodes(i + (j - 1) * nx+nx*ny*(k-1), 5) = nodes(i + (j - 1) * nx+nx*ny*(k-1), 1)+(nx+1)*(ny+1);
nodes(i + (j - 1) * nx+nx*ny*(k-1), 6) = nodes(i + (j - 1) * nx+nx*ny*(k-1), 5) + 1;
nodes(i + (j - 1) * nx+nx*ny*(k-1), 7) = nodes(i + (j - 1) * nx+nx*ny*(k-1), 5) + nx + 1;
nodes(i + (j - 1) * nx+nx*ny*(k-1), 8) = nodes(i + (j - 1) * nx+nx*ny*(k-1), 5) + nx + 2;
zm(i+(j-1)*nx+nx*ny*(k-1))=sum(coordinates(nodes(i + (j - 1) * nx+nx*ny*(k-1), :),3))/8;
end
end
end
xrao=[0];
for i=1:nx
xxiang=sum(dx(1,1:i));
xrao=[xrao xxiang];
end
yrao=[0];
for i=1:ny
yxiang=sum(dy(1,1:i));
yrao=[yrao yxiang];
end
zrao=[0];
for i=1:nz
zxiang=sum(dz(1,1:i));
zrao=[zrao zxiang];
end
end
generic extended/GridProp_new.asv
+510
View File
@@ -0,0 +1,510 @@
function r = GridProp_new(modelflag,nx, ny, nz, dx, dy, dz, kx, ky, kz, f, frac_information, fellip, Kf, Wf, pori, prpor, cpor, Porf, prporf, cporf, cf, ca,co,NTG)
tic;
%% 基质网格参数及网格参数计算、存储
r.modelflag=modelflag;
r.nx = nx;
r.ny = ny;
r.nz = nz;
r.dx = dx;
r.dy = dy;
r.dz = dz;
r.kx = kx;
r.ky = ky;
r.kz = kz;
r.Kf = Kf;%裂缝面对应的渗透率，非裂缝单元
r.Wf = Wf;%裂缝面对应的缝宽，非裂缝单元
r.cf = cf;
r.ca = ca;
r.co=co;
r.cpor=cpor;
r.cporf=cporf;
r.NTG=NTG;
r.frac_information = frac_information;
[coordinates, nodes, nP, nE, dxv, dyv,dzv,zm,vm,xrao,yrao,zrao,cell_mid_xy_coordinates] = GenerateNode_final(dx, dy,dz ,nx,ny,nz,NTG);
r.coordinates = coordinates;
r.nodes = nodes;
nmc=nE;
r.nmc =nmc;
r.dxv = dxv;
r.dyv = dyv;
r.dzv = dzv;
r.vm=vm;
r.cell_mid_coordinates=cell_mid_xy_coordinates;
%% 求解裂缝与基质网格连接情况
%% 关键参数矩阵初始化
m=size(f,1);
n=size(fellip,1);
nfr=m/5;%矩形规则裂缝条数
nfir=n/5;%不规则裂缝条数（当然包含椭圆）
r.nfr=nfr; r.nfir=nfir;
nf=nfr+nfir;
r.nf=nf;
if (nfir~=0) && (nfr~=0)
f=[f;fellip];
else if nfr~=0
f=f;
else if nfir~=0
f=fellip;
else error('Dr Rao reminds you that there is no information about fractures');
end
end
end
%d3intersection=-1000*ones(1000,3);%用-1000做标识
raopoint=cell(nfr+nfir,2);%利用元胞数组存储每条裂缝与基质网格线的交点，
%第一列是三维坐标形式，即d3intersection
%第二列是裂缝面参数形式，即anothersection
pointvsregion=cell(nfr+nfir,3);%利用元胞数组存储interarea函数的结果numofmesh, numvspoint,numofregion
fracrossfra=cell(nfr+nfir,nfr+nfir-1);%判断裂缝之间两交点坐标
fratmaxfra=zeros(nfr+nfir,nfr+nfir-1);%判断裂缝之间交线参数的最大值
fratminfra=zeros(nfr+nfir,nfr+nfir-1);%判断裂缝之间交线参数的最小值
fracturemesh=cell(nf,1);%每一行是一条裂缝面上的网格剖分情况
%% 计算裂缝与基质网格相交情况
for i=1:nfr
raopoint{i,1}= intersectionsolve_new_modified_r(f((5*i-4):(5*i),:),dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
raopoint{i,2}= anosection( f((5*i-4):(5*i),:),raopoint{i,1} );
[ pointvsregion{i,1},pointvsregion{i,2} ,pointvsregion{i,3}] = interarea( raopoint{i,1},dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
end
% 不规则缝计算
if nfir>0
for i=1:nfir
raopoint{nfr+i,1}= intersectionsolve_new_modified_irr(fellip((5*i-4):(5*i),:),dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
raopoint{nfr+i,2}= anosection( f((5*(nfr+i)-4):(5*(nfr+i)),:),raopoint{nfr+i,1} );
[ pointvsregion{nfr+i,1},pointvsregion{nfr+i,2} ,pointvsregion{nfr+i,3}] = interarea( raopoint{nfr+i,1},dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
end
end
%% 计算裂缝之间相交线情况
for i=1:nf
for j=1:nf
if i>nfr || j>nfr cross=zeros(2,3);tmax=0;tmin=0;
else
% [ cross,tmax,tmin ]=frac_cross_frac( f((5*i-4):(5*i),:),f((5*j-4):(5*j),:) );
cross=zeros(2,3);tmax=0;tmin=0;
end
fracrossfra{i,j}=cross;fratmaxfra(i,j)=tmax;fratminfra(i,j)=tmin;
end
end
%% 计算裂缝被基质网格、其它裂缝与之相交后的网格分布情况,绘制二维裂缝平面参数坐标系上的网格分布情况
% figure('color','w');
addflag=zeros(nf,1);%乘2的幂次，防止因为裂缝条数较多，造成矩阵太大
for i=1:nf
d3intersection=raopoint{i,1};anothersection=raopoint{i,2};
[ mesh ] = frac_mat_mesh( d3intersection,anothersection,pointvsregion{i,2},pointvsregion{i,1} );
% for j=1:nf
% [ mesh,d3intersection,anothersection,add_flag ]= frac_frac_mesh_modified(xrao,yrao,zrao,mesh,f(5*i-4,:),f(5*i-3,:),f(5*i-2,:),fracrossfra{i,j},fratmaxfra(i,j),fratminfra(i,j),d3intersection,anothersection,pointvsregion{i,2},pointvsregion{i,1} );
% addflag(j,1)=addflag(j,1)+add_flag;
% end
raopoint{i,1} = d3intersection; raopoint{i,2} = anothersection;%由原来裂缝与网格的交点不断更新加入其它裂缝与该裂缝的交点
fracturemesh{i,1}=mesh;subplot(nf,1,i);color_fill={'y','r','b','g'};
plotmesh2D(mesh,raopoint{i,2},color_fill{1,mod(i,4)+1});
end
%% 绘制三维背景网格（基质网格）及裂缝网格分布
%figure(2)
%network3D(dx,dy,dz,nx,ny,nz );
%hold on;
figure('color','w');
% plot_reservoir_3D(max(xrao),max(yrao),dz(1),1,1,nz);
% plot_reservoir_3D(dx(1),dy(1),dz(1),nx,ny,nz);
network3D(dx(1),dy(1),dz(1),nx,ny,nz);
hold on;
% network3D_arbitrary(dx,dy,dz,nx,ny,nz);
hold on;
% refine;
% hold on;
for i=1:nf
% color_fill={'y','r','b','g','c','m'};
% color_fill={'y','r','b','g'};
% plotmesh3D( fracturemesh{i,1},raopoint{i,1},color_fill{1,mod(i,4)+1});hold on;
if i <= 30
color_fill='b'; %流动屏障
% elseif i <=19
% color_fill='b'; %压裂缝
if i == 2 || i == 9
rnf
elseif
color_fill='r'; %天然裂缝
end
% plotmesh3D( fracturemesh{i,1},raopoint{i,1},color_fill{1,mod(i,4)+1});hold on;
plotmesh3D( fracturemesh{i,1},raopoint{i,1},color_fill);hold on;
end
% % % basic_node_coord = [0,0,0];
% % % x_length = 700;
% % % y_length = 800;
% % % z_length = 10;
% % % nodes_domain = [basic_node_coord;]
% % % fill3(x,y,z,'w');
refine1;
% refine_chengjiepaper;
% refine;
% plot_reservoir_3D(max(xrao),max(yrao),dz(1),1,1,nz);
% plot_reservoir_3D(dx(1),dy(1),dz(1),nx,ny,nz);
xlabel('x, m','FontSize',12);
ylabel('y, m','FontSize',12);
zlabel('z, m','FontSize',12);
%
zticks([0, 5]);
% yticks(-1:0.5:1);
% 设置x轴和y轴的刻度标签
zticklabels({'-2005', '-2000'});
% yticklabels({'-1', '-0.5', '0', '0.5', '1'});
% 关闭刻度标签的旋转
% xticklabels('Rotation', 0);
% yticklabels('Rotation', 0);
axis equal;
% refine;
% hold on
% network3D(dx(1),dy(1),dz(1),nx,ny,nz);
% network3D(max(xrao),max(yrao),max(zrao),1,1,1 );
% network3D(10,10,10,2,1,1 );
% network3D(10,10,10,6,1,2 );
alpha(1)
view(2)
% axis([min(xrao),max(xrao),min(yrao),max(yrao),min(zrao),max(zrao)]);
% axis equal
% % hold off;
%% 确定裂缝编号及连接情况，计算传导系数
if modelflag==1 %表示用2014, Monifar
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,cell_divided_by_fracture_flag ] = connections_2014( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,pori,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.T_convection=T_convection;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
r.mat_frac=mat_frac;
r.cell_divided_by_fracture_flag = cell_divided_by_fracture_flag;
elseif modelflag==4 %表示用 PEDFM
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff ] = connections_PEDFM_new( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag,frac_information, coordinates);
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
elseif modelflag==5 % 表示实用型PEDFM
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff ] = connections_PEDFM_new_new( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,pori,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag,frac_information, coordinates);
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
elseif modelflag==6 % 表示基于非结构网格pEDFM的validation model
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag] = connections_unstructured_EDFM( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
r.number_of_adding=number_of_adding;
nmc = nmc+number_of_adding;
r.nmc = nmc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.T_convection=T_convection;
r.vf=vf;
% 劈分或增加
vm_the_added_cell = vm(cell_divided_by_fracture_flag)*1/2;
vm(cell_divided_by_fracture_flag) = vm(cell_divided_by_fracture_flag)*1/2;
vm = [vm; vm_the_added_cell];
r.V=[vm;vf];
pori = [pori; pori(cell_divided_by_fracture_flag)];
r.cell_divided_by_fracture_flag = cell_divided_by_fracture_flag;
r.porf=porf;
r.fcff=fcff;
r.mat_frac=mat_frac;
elseif modelflag==7
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff ] = connections_PEDFM_EX1_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag,frac_information, coordinates);
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
elseif modelflag==8 % 表示基于非结构网格pEDFM的validation model
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio,fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX1_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
r.number_of_adding=number_of_adding;
nmc = nmc+number_of_adding;
r.nmc = nmc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.T_convection=T_convection;
r.vf=vf;
r.fractureCell_matrixCell_addedMatrixCell = fractureCell_matrixCell_addedMatrixCell;
r.volume_ratio=volume_ratio;
% 劈分或增加
vm_the_added_cell = vm(cell_divided_by_fracture_flag).*volume_ratio;
vm(cell_divided_by_fracture_flag) = vm(cell_divided_by_fracture_flag).*(1-volume_ratio);
vm = [vm; vm_the_added_cell];
r.V=[vm;vf];
pori = [pori; pori(cell_divided_by_fracture_flag)];
r.cell_divided_by_fracture_flag = cell_divided_by_fracture_flag;
r.porf=porf;
r.fcff=fcff;
r.mat_frac=mat_frac;
elseif modelflag==9 % EX2 不同情况下 pEDFM 解
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff ] = connections_PEDFM_EX2_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag,frac_information, coordinates);
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
elseif modelflag==10 % 表示基于非结构网格pEDFM的 EX2 参考解
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio,fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX2_1to3_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
r.number_of_adding=number_of_adding;
nmc = nmc+number_of_adding;
r.nmc = nmc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.T_convection=T_convection;
r.vf=vf;
r.fractureCell_matrixCell_addedMatrixCell = fractureCell_matrixCell_addedMatrixCell;
r.volume_ratio=volume_ratio;
% 劈分或增加
vm_the_added_cell = vm(cell_divided_by_fracture_flag).*volume_ratio;
vm(cell_divided_by_fracture_flag) = vm(cell_divided_by_fracture_flag).*(1-volume_ratio);
vm = [vm; vm_the_added_cell];
r.V=[vm;vf];
pori = [pori; pori(cell_divided_by_fracture_flag)];
r.cell_divided_by_fracture_flag = cell_divided_by_fracture_flag;
r.porf=porf;
r.fcff=fcff;
r.mat_frac=mat_frac;
elseif modelflag==11 % 表示基于非结构网格pEDFM的 EX2 参考解
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio,fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX2_1to2_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
r.number_of_adding=number_of_adding;
nmc = nmc+number_of_adding;
r.nmc = nmc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.T_convection=T_convection;
r.vf=vf;
r.fractureCell_matrixCell_addedMatrixCell = fractureCell_matrixCell_addedMatrixCell;
r.volume_ratio=volume_ratio;
% 劈分或增加
vm_the_added_cell = vm(cell_divided_by_fracture_flag).*volume_ratio;
vm(cell_divided_by_fracture_flag) = vm(cell_divided_by_fracture_flag).*(1-volume_ratio);
vm = [vm; vm_the_added_cell];
r.V=[vm;vf];
pori = [pori; pori(cell_divided_by_fracture_flag)];
r.cell_divided_by_fracture_flag = cell_divided_by_fracture_flag;
r.porf=porf;
r.fcff=fcff;
r.mat_frac=mat_frac;
elseif modelflag==12 % 表示基于非结构网格pEDFM的 EX2 参考解
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio,fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX2_1to4_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
r.number_of_adding=number_of_adding;
nmc = nmc+number_of_adding;
r.nmc = nmc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.T_convection=T_convection;
r.vf=vf;
r.fractureCell_matrixCell_addedMatrixCell = fractureCell_matrixCell_addedMatrixCell;
r.volume_ratio=volume_ratio;
% 劈分或增加
vm_the_added_cell = vm(cell_divided_by_fracture_flag).*volume_ratio;
vm(cell_divided_by_fracture_flag) = vm(cell_divided_by_fracture_flag).*(1-volume_ratio);
vm = [vm; vm_the_added_cell];
r.V=[vm;vf];
pori = [pori; pori(cell_divided_by_fracture_flag)];
r.cell_divided_by_fracture_flag = cell_divided_by_fracture_flag;
r.porf=porf;
r.fcff=fcff;
r.mat_frac=mat_frac;
elseif modelflag==13 % 表示基于非结构网格pEDFM的 EX2 参考解
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff ] = connections_PEDFM_TPFA_MFD( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,perm,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag,frac_information, coordinates);
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
elseif modelflag==14 %表示用 PEDFM
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff ] = connections_PEDFM_new_twofractures( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag,frac_information, coordinates);
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
else
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff ] = connections( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,Kf,Wf,Porf,dxv,dyv,dzv,NTG );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
%% 计算传导系数
% dxvector=ones(1,nx);dyvector=ones(1,ny);dzvector=ones(1,nz);
% [ transmatrix,transfracture ] = trans(dxvector,dyvector,dzvector ,nx,ny,nz,nf,fracnumber,lengthvsfra,disvsfra,fracstart,connect_infrac,corevsfra,matrixvsfra,raopoint,f );
%% 计算基质与裂缝之间窜流的相关系数
if modelflag==2 %表示用2018, Rao
[ G,Gfm,Gff,Gf,Ap,Apf ]=interflowmf1(r,dxv,dyv,dzv,matrixvsfra,connectmf,fracstart,fracnumber,raopoint,f,nodes,coordinates,nf,corevsfra );
[Ka, M, F2M , MF_coef] = transFunc_aniso(nc,coordinates, nodes, connectmf,Ap,Apf, matrixvsfra,N,T,kx, ky,kz);
r.Ka = Ka;
r.M = M;
r.F2M = F2M;
r.MF_coef = MF_coef;
elseif modelflag==5 %表示用 Modified Rao, steady, 2018
[ G,Gfm,Gff,Gf,Ap,Apf ] = interflowmf_MODIFIED(r,dxv,dyv,dzv,matrixvsfra,connectmf,fracstart,fracnumber,raopoint,f,nodes,coordinates,nf,corevsfra );
[Ka, M, F2M , MF_coef] = transFunc_aniso_MODIFIED(nc,coordinates, nodes, connectmf,Ap,Apf, matrixvsfra,N,T,kx, ky,kz);
r.Ka = Ka;
r.M = M;
r.F2M = F2M;
r.MF_coef = MF_coef;
% [ G,Gfm,Gff,Gf,Ap,Apf,Apmt,Apft ]=interflowmf1_transient(dxv,dyv,dzv,matrixvsfra,connectmf,fracstart,fracnumber,raopoint,f,nodes,coordinates,nf,corevsfra );
end
% [ G,Gfm,Gff,Gf,Ap,Apf ]=interflowmf1(dxv,dyv,dzv,matrixvsfra,connectmf,fracstart,fracnumber,raopoint,f,nodes,coordinates,nf,corevsfra );
%%
% r.MF_deltt=MF_deltt;
end
%% 计算深度（以下平面为基准计算得到的高度，值为正数）
z=[zm;zf];
r.z=z;
rpt = [ones(nmc, 1); zeros(nfc, 1)];
r.rpt = rpt;
r.Porf = Porf;
pori = [pori; porf];
r.pori = pori;
r.por = @(p)por(p, prpor, pori, cpor, prporf, cporf, r.rpt);
tpre=toc;
r.tpre=tpre;
generic extended/GridProp_new.m
+230
View File
@@ -0,0 +1,230 @@
function r = GridProp_new(modelflag, r, kx, ky, kz, f, frac_information, fellip, Kf, Wf, pori, prpor, cpor, Porf, prporf, cporf, cf, ca, valid_grids)
tic;
%% 基质网格参数及网格参数读取
nx = r.nx;
ny = r.ny;
nz = r.nz;
dx = r.dx;
dy = r.dy;
dz = r.dz;
NTG = r.NTG;
coordinates = r.coordinates;
nodes = r.nodes;
nP = r.nP;
nmc = r.nmc;
dxv = r.dxv;
dyv = r.dyv;
dzv = r.dzv;
zm = r.zm;
vm = r.vm;
xrao = r.xrao;
yrao = r.yrao;
zrao = r.zrao;
cell_mid_coords = r.cell_mid_coords;
%
kx(valid_grids==0)=1e-12;
ky(valid_grids==0)=1e-12;
kz(valid_grids==0)=1e-12;
%
r.modelflag=modelflag;
r.kx = kx;
r.ky = ky;
r.kz = kz;
r.Kf = Kf;%裂缝面对应的渗透率，非裂缝单元
r.Wf = Wf;%裂缝面对应的缝宽，非裂缝单元
r.cf = cf;
r.ca = ca;
% r.co=co;
r.cpor=cpor;
r.cporf=cporf;
r.frac_information = frac_information;
% % % [coordinates, nodes, nP, nE, dxv, dyv,dzv,zm,vm,xrao,yrao,zrao,cell_mid_coordinates] = GenerateNode_final(dx, dy,dz ,nx,ny,nz,NTG);
% % % r.coordinates = coordinates;
% % % r.nodes = nodes;
% % % nmc=nE;
% % % r.nmc =nmc;
% % % r.dxv = dxv;
% % % r.dyv = dyv;
% % % r.dzv = dzv;
% % % r.vm=vm;
% % % r.cell_mid_coordinates=cell_mid_coordinates;
%% 求解裂缝与基质网格连接情况
%% 关键参数矩阵初始化
m=size(f,1);
n=size(fellip,1);
nfr=m/5;%矩形规则裂缝条数
nfir=n/5;%不规则裂缝条数（当然包含椭圆）
r.nfr=nfr; r.nfir=nfir;
nf=nfr+nfir;
r.nf=nf;
if (nfir~=0) && (nfr~=0)
f=[f;fellip];
else if nfr~=0
f=f;
else if nfir~=0
f=fellip;
else error('Dr Rao reminds you that there is no information about fractures');
end
end
end
%d3intersection=-1000*ones(1000,3);%用-1000做标识
raopoint=cell(nfr+nfir,2);%利用元胞数组存储每条裂缝与基质网格线的交点，
%第一列是三维坐标形式，即d3intersection
%第二列是裂缝面参数形式，即anothersection
pointvsregion=cell(nfr+nfir,3);%利用元胞数组存储interarea函数的结果numofmesh, numvspoint,numofregion
fracrossfra=cell(nfr+nfir,nfr+nfir-1);%判断裂缝之间两交点坐标
fratmaxfra=zeros(nfr+nfir,nfr+nfir-1);%判断裂缝之间交线参数的最大值
fratminfra=zeros(nfr+nfir,nfr+nfir-1);%判断裂缝之间交线参数的最小值
fracturemesh=cell(nf,1);%每一行是一条裂缝面上的网格剖分情况
%% 计算裂缝与基质网格相交情况
for i=1:nfr
raopoint{i,1}= intersectionsolve_new_modified_r(f((5*i-4):(5*i),:),dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
raopoint{i,2}= anosection( f((5*i-4):(5*i),:),raopoint{i,1} );
[ pointvsregion{i,1},pointvsregion{i,2} ,pointvsregion{i,3}] = interarea( raopoint{i,1},dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
end
% 不规则缝计算
if nfir>0
for i=1:nfir
raopoint{nfr+i,1}= intersectionsolve_new_modified_irr(fellip((5*i-4):(5*i),:),dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
raopoint{nfr+i,2}= anosection( f((5*(nfr+i)-4):(5*(nfr+i)),:),raopoint{nfr+i,1} );
[ pointvsregion{nfr+i,1},pointvsregion{nfr+i,2} ,pointvsregion{nfr+i,3}] = interarea( raopoint{nfr+i,1},dx,dy,dz,nx,ny,nz,xrao,yrao,zrao );
end
end
%% 计算裂缝之间相交线情况
for i=1:nf
for j=1:nf
if i>nfr || j>nfr cross=zeros(2,3);tmax=0;tmin=0;
else
% [ cross,tmax,tmin ]=frac_cross_frac( f((5*i-4):(5*i),:),f((5*j-4):(5*j),:) );
cross=zeros(2,3);tmax=0;tmin=0;
end
fracrossfra{i,j}=cross;fratmaxfra(i,j)=tmax;fratminfra(i,j)=tmin;
end
end
%% 计算裂缝被基质网格、其它裂缝与之相交后的网格分布情况,绘制二维裂缝平面参数坐标系上的网格分布情况
% figure('color','w');
addflag=zeros(nf,1);%乘2的幂次，防止因为裂缝条数较多，造成矩阵太大
for i=1:nf
d3intersection=raopoint{i,1};anothersection=raopoint{i,2};
[ mesh ] = frac_mat_mesh( d3intersection,anothersection,pointvsregion{i,2},pointvsregion{i,1} );
% for j=1:nf
% [ mesh,d3intersection,anothersection,add_flag ]= frac_frac_mesh_modified(xrao,yrao,zrao,mesh,f(5*i-4,:),f(5*i-3,:),f(5*i-2,:),fracrossfra{i,j},fratmaxfra(i,j),fratminfra(i,j),d3intersection,anothersection,pointvsregion{i,2},pointvsregion{i,1} );
% addflag(j,1)=addflag(j,1)+add_flag;
% end
raopoint{i,1} = d3intersection; raopoint{i,2} = anothersection;%由原来裂缝与网格的交点不断更新加入其它裂缝与该裂缝的交点
fracturemesh{i,1}=mesh;
% subplot(nf,1,i);color_fill={'y','r','b','g'};
% plotmesh2D(mesh,raopoint{i,2},color_fill{1,mod(i,4)+1});
end
%% 绘制三维背景网格（基质网格）及裂缝网格分布
%figure(2)
%network3D(dx,dy,dz,nx,ny,nz );
%hold on;
figure('color','w');
% plot_reservoir_3D(max(xrao),max(yrao),dz(1),1,1,nz);
% plot_reservoir_3D(dx(1),dy(1),dz(1),nx,ny,nz);
network3D(dx(1),dy(1),dz(1),nx,ny,nz);
% network3D(1000,700,10,1,1,1);
% network3D(800,300,10,1,1,1);
hold on;
% network3D_arbitrary(dx,dy,dz,nx,ny,nz);
% refine;
% hold on;
for i=1:nf
% color_fill={'y','r','b','g','c','m'};
% color_fill={'y','r','b','g'};
% plotmesh3D( fracturemesh{i,1},raopoint{i,1},color_fill{1,mod(i,4)+1});hold on;
if i <= 100
color_fill='b'; %流动屏障
% elseif i <=19
% color_fill='b'; %压裂缝
% if i == 2 || i == 9
% color_fill='r';
% end
else
color_fill='k'; %天然裂缝
end
% plotmesh3D( fracturemesh{i,1},raopoint{i,1},color_fill{1,mod(i,4)+1});hold on;
plotmesh3D( fracturemesh{i,1},raopoint{i,1},color_fill);hold on;
end
% % % basic_node_coord = [0,0,0];
% % % x_length = 700;
% % % y_length = 800;
% % % z_length = 10;
% % % nodes_domain = [basic_node_coord;]
% % % fill3(x,y,z,'w');
% refine1;
% refine_chengjiepaper;
% refine;
% plot_reservoir_3D(max(xrao),max(yrao),dz(1),1,1,nz);
% plot_reservoir_3D(dx(1),dy(1),dz(1),nx,ny,nz);
xlabel('x, m','FontSize',14);
ylabel('y, m','FontSize',14);
zlabel('z, m','FontSize',14);
ax = gca;
ax.FontSize = 14;
%
% zticks([0, 5]);
% yticks(-1:0.5:1);
% 设置x轴和y轴的刻度标签
% zticklabels({'-2005', '-2000'});
% yticklabels({'-1', '-0.5', '0', '0.5', '1'});
% 关闭刻度标签的旋转
% xticklabels('Rotation', 0);
% yticklabels('Rotation', 0);
% axis equal;
% refine;
% hold on
% network3D(dx(1),dy(1),dz(1),nx,ny,nz);
% network3D(max(xrao),max(yrao),max(zrao),1,1,1 );
% network3D(10,10,10,2,1,1 );
% network3D(10,10,10,6,1,2 );
alpha(1)
view(3)
% axis([min(xrao),max(xrao),min(yrao),max(yrao),min(zrao),max(zrao)]);
% axis equal
% % hold off;
%% 确定裂缝编号及连接情况，计算传导系数
if modelflag==1 %表示用2014, Monifar
[ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac, N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,cell_divided_by_fracture_flag, flowArea, perm, matrixflag, T_diff ] = connections_2014( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,pori,Kf,Wf,Porf,dxv,dyv,dzv,coordinates,nodes,NTG,addflag,valid_grids );
nfc=size(fracnumber,1);
nex=size(T,1);
r.nfc=nfc;
nc=nfc+nmc;
r.nc=nc;%基质网格和裂缝单元总数
r.nex=nex;%具有流体交换的总数
kf=Kf(fcinff);
wf=Wf(fcinff);
r.kf=kf;%裂缝单元对应的渗透率
r.wf=wf;%裂缝单元对应的缝宽
r.N=N;
r.T=T;
r.T_convection=T_convection;
r.T_diff = T_diff;
r.vf=vf;
r.V=[vm;vf];
r.porf=porf;
r.fcff=fcff;
r.mat_frac=mat_frac;
r.cell_divided_by_fracture_flag = cell_divided_by_fracture_flag;
r.flowArea=flowArea;
r.perm=perm;
r.matrixflag=matrixflag;
end
%% 计算深度（以下平面为基准计算得到的高度，值为正数）
z=[zm;zf];
r.z=z;
rpt = [ones(nmc, 1); zeros(nfc, 1)];
r.rpt = rpt;
r.Porf = Porf;
pori = [pori; porf];
r.pori = pori;
r.por = @(p)por(p, prpor, pori, cpor, prporf, cporf, r.rpt);
tpre=toc;
r.tpre=tpre;
generic extended/calculate_relative_errors.m
+35
View File
@@ -0,0 +1,35 @@
function [ relative_errors ] = calculate_relative_errors( results_EDFM_matrix, results_pEDFM_case1, results_pEDFM_case2, r_EDFMs)
%CALCULATE_RELATIVE_ERRORS 此处显示有关此函数的摘要
% 此处显示详细说明
% % % EDFM_result = results_EDFM_matrix(:,1);
% % % pEDFM_result_case1 = results_pEDFM_case1(:,2);
% % % modified_EDFM_result = results_pEDFM_case2(:,3);
% % % new_EDFM_result = results_EDFMs_matrix(:,4);
% % % LGR_result = results_LGR(:,1);
EDFMs_cell_mid_point_coordinates = r_EDFMs.cell_mid_coordinates;
% LGR_cell_mid_point_coordinates = r_LGR.cell_mid_coordinates;
num_of_cells = size(EDFMs_cell_mid_point_coordinates,1);
% the_reference_solution_for_comparison = zeros(num_of_cells,1);
% % % for i = 1:num_of_cells
% % % [a,b]=min((LGR_cell_mid_point_coordinates(:,1)- EDFMs_cell_mid_point_coordinates(i,1)).^2+(LGR_cell_mid_point_coordinates(:,2)- EDFMs_cell_mid_point_coordinates(i,2)).^2);
% % % the_reference_solution_for_comparison(i,1) = LGR_result(b(1),1);
% % % end
% 相对误差计算
fracture_perm = [ 100, 700, 4000, 20000, 100000];
relative_errors = zeros(2,5);
for j = 1:5
relative_errors(1,j) = norm(results_EDFM_matrix(1:num_of_cells,j)-results_pEDFM_case2(1:num_of_cells,j))/norm(results_pEDFM_case2(1:num_of_cells,j));
relative_errors(2,j) = norm(results_pEDFM_case1(1:num_of_cells,j)-results_pEDFM_case2(1:num_of_cells,j))/norm(results_pEDFM_case2(1:num_of_cells,j));
% relative_errors(1,2) = norm(pEDFM_result(1:num_of_cells,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
% relative_errors(1,3) = norm(modified_EDFM_result(1:num_of_cells,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
% relative_errors(1,4) = norm(new_EDFM_result(1:num_of_cells,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
end
% relative_errors(1,5) = norm(LGR_result(:,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
end
generic extended/calculate_relative_errors_vs_cellsize.m
+72
View File
@@ -0,0 +1,72 @@
function [ relative_errors ] = calculate_relative_errors_vs_cellsize( results_EDFM_matrix, results_pEDFM_case1, results_pEDFM_case2, results_reference, r_0_5m, r_1m, r_2m, r_4m)
% r_EDFMs_0_25, r_EDFMs_0_5, r_EDFMs_1, r_EDFMs_2, r_EDFMs_4
%CALCULATE_RELATIVE_ERRORS 此处显示有关此函数的摘要
% 此处显示详细说明
% % % EDFM_result = results_EDFM_matrix(:,1);
% % % pEDFM_result_case1 = results_pEDFM_case1(:,2);
% % % modified_EDFM_result = results_pEDFM_case2(:,3);
% % % new_EDFM_result = results_EDFMs_matrix(:,4);
% % % LGR_result = results_LGR(:,1);
% EDFMs_cell_mid_point_coordinates = r_EDFMs.cell_mid_coordinates;
% % LGR_cell_mid_point_coordinates = r_LGR.cell_mid_coordinates;
%
% num_of_cells = size(EDFMs_cell_mid_point_coordinates,1);
% the_reference_solution_for_comparison = zeros(num_of_cells,1);
% % % for i = 1:num_of_cells
% % % [a,b]=min((LGR_cell_mid_point_coordinates(:,1)- EDFMs_cell_mid_point_coordinates(i,1)).^2+(LGR_cell_mid_point_coordinates(:,2)- EDFMs_cell_mid_point_coordinates(i,2)).^2);
% % % the_reference_solution_for_comparison(i,1) = LGR_result(b(1),1);
% % % end
% 相对误差计算
x_data = [0.5, 1, 2, 5];
relative_errors = zeros(2,4);
for j = 1:4
% if j == 1 r_EDFMs = r_EDFMs_0_25; end;
% if j == 2 r_EDFMs = r_EDFMs_0_5; end;
% if j == 3 r_EDFMs = r_EDFMs_1; end;
% if j == 4 r_EDFMs = r_EDFMs_2; end;
% if j == 5 r_EDFMs = r_EDFMs_4; end;
if j == 1 r_EDFMs = r_0_5m; end;
if j == 2 r_EDFMs = r_1m; end;
if j == 3 r_EDFMs = r_2m; end;
if j == 4 r_EDFMs = r_4m; end;
% if j == 5 r_EDFMs = r_EDFMs_4; end;
EDFMs_cell_mid_point_coordinates = r_EDFMs.cell_mid_coordinates;
% LGR_cell_mid_point_coordinates = r_LGR.cell_mid_coordinates;
num_of_cells = size(EDFMs_cell_mid_point_coordinates,1);
the_numnering = (1:(r_EDFMs.nx*r_EDFMs.ny*r_EDFMs.nz))';
the_numnering(r_EDFMs.cell_divided_by_fracture_flag)=[];
% relative_errors(1,j) = norm(results_EDFM_matrix(1:num_of_cells,j)-results_pEDFM_case2(1:num_of_cells,j))/norm(results_pEDFM_case2(1:num_of_cells,j));
% relative_errors(2,j) = norm(results_pEDFM_case1(1:num_of_cells,j)-results_pEDFM_case2(1:num_of_cells,j))/norm(results_pEDFM_case2(1:num_of_cells,j));
% relative_errors(1,j) = sqrt(sum((results_EDFM_matrix(the_numnering,j)-results_reference(the_numnering,j)).^2)/size(the_numnering,1));
% relative_errors(2,j) = sqrt(sum((results_pEDFM_case1(the_numnering,j)-results_reference(the_numnering,j)).^2)/size(the_numnering,1));
% relative_errors(3,j) = sqrt(sum((results_pEDFM_case2(the_numnering,j)-results_reference(the_numnering,j)).^2)/size(the_numnering,1));
%
relative_errors(1,j) = norm(results_EDFM_matrix(the_numnering,j)-results_reference(the_numnering,j))/norm(1-results_reference(the_numnering,j));
relative_errors(2,j) = norm(results_pEDFM_case1(the_numnering,j)-results_reference(the_numnering,j))/norm(1-results_reference(the_numnering,j));
relative_errors(3,j) = norm(results_pEDFM_case2(the_numnering,j)-results_reference(the_numnering,j))/norm(1-results_reference(the_numnering,j));
% relative_errors(1,2) = norm(pEDFM_result(1:num_of_cells,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
% relative_errors(1,3) = norm(modified_EDFM_result(1:num_of_cells,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
% relative_errors(1,4) = norm(new_EDFM_result(1:num_of_cells,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
end
% relative_errors(1,5) = norm(LGR_result(:,1)-the_reference_solution_for_comparison(:,1))/norm(the_reference_solution_for_comparison(:,1));
figure('color','w');
plot(x_data,relative_errors(1,:),'k^-');
hold on;
plot(x_data,relative_errors(2,:),'rs-');
hold on;
plot(x_data,relative_errors(3,:),'bo-');
hold on;
plot(x_data,relative_errors(3,:),'gv-');
hold off;
xlabel('grid size, m');
ylabel('L_2 relative error, dimensionless');
legend('EDFM', 'pEDFM-SDP', 'pEDFM-MTM', 'pEDFM-continuous');
end
generic extended/connections_PEDFM_EX1_solutions.m
+642
View File
@@ -0,0 +1,642 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff] = connections_PEDFM_EX1_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag,frac_information,coordinates)
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
%
fractureCellType = zeros(q-1,1);
theNumber = 3;
fractureCellType = repmat((1:theNumber)',(q-1)/theNumber,1);
%
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,1);%裂缝网格渗透率
Wf=zeros(q-1,1);%裂缝单元缝宽
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Wf(i,1)=wf(k-1);
Kf(i,1)=kf(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
end
end
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex=find(lengthvsfra(i,:)~=0);
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if Kf(j)==0 || Kf(k)==0
hartran=0;
else
tran1=Kf(j)*wf(i)*lengthcat/disk;
tran2=Kf(k)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均的一半
hartran=tran1*tran2/(tran1+tran2);
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
S_ex=zeros(nmm,1);% 流体交换面面积
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
% 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)/(Kx(index)*dxv(indexn) + Kx(indexn)*dxv(index));
S_ex(c)=dzv(index)*dyv(index);
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
S_ex(c)=dzv(index)*dxv(index);
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
S_ex(c)=dxv(index)*dyv(index);
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
for i=1:nx*ny*nz %基质网格编号
for j=1:10
if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Knnc=kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
Annc=areavsfra(matrixvsfra(i,j));% 此处与原始嵌入式不一样，原始是两倍
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
% 为论文做修改
% Dn=0.9;
% Dn=2.5;
raoT=Knnc*Annc/Dn;
Tinterflow=[Tinterflow;raoT];
end
end
end
%% 投影嵌入式处理
nmc=size(matrixvsfra,1);
%基质网格流体交换面上的裂缝单元投影面之和
S_p=zeros(nmm,1);
% 因为投影处理新加的F-M connections
Nmf_projection=[];
Tmf_projection=[];
for i=1:nmc
matnodes=nodes(i,:);
dx_grid=dxv(i);
dy_grid=dyv(i);
dz_grid=dzv(i);
grid_core=mean(coord(matnodes,:));%该基质网格中心
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>=1) %先仅考虑n=1时的情况
selected_face=zeros(1,3);
the_frac_cell=matrixvsfra(i,indice);%该裂缝单元编号
% if Kf(the_frac_cell) <= (kx(i)*ky(i)*kz(i))^(1/3);%
% else
which_frac=fcff{1,2}(the_frac_cell,1);%该裂缝单元所在的裂缝面
core_frac_cell=fcff{1,4}(the_frac_cell,1:3);%该裂缝单元的中心坐标
area_frac_cell=fcff{1,8}(the_frac_cell,1);%该裂缝单元面积
rao_struct=[i,the_frac_cell+nmc];
pos_rao=find_row(rao_struct,Ninterflow);
%该裂缝面法向量
D_value=core_frac_cell-grid_core;% 向量OF
vector_1=f(5*which_frac-3,:);
vector_2=f(5*which_frac-2,:);
n_vector_1=cross(vector_1,vector_2);
n_vector_2=-cross(vector_1,vector_2);
if (dot(n_vector_1,D_value))>=0
n_vector=n_vector_1;
else
n_vector=n_vector_2;
end
% 方向投影面积
area_frac_cell_x=abs(area_frac_cell*dot([1,0,0],n_vector)/norm(n_vector));
area_frac_cell_y=abs(area_frac_cell*dot([0,1,0],n_vector)/norm(n_vector));
area_frac_cell_z=abs(area_frac_cell*dot([0,0,1],n_vector)/norm(n_vector));
%% ----------------------% 根据fractureCellType选取投影面--------------------------------------
% selected_face(1)=4; nei_grid_x=i+1;
% selected_face(2)=5; nei_grid_y=i+nx;
% selected_face(3)=6;nei_grid_z=i+nx*ny;
%% 选择哪种方法
selectedMethod = 1;
%% method 1
if selectedMethod == 1
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i-1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 3
nei_grid_x=i+1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
%% method 2
if selectedMethod == 2
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 3
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
%% method 3
if selectedMethod == 3
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,i];% 相当于没有
struc_z=[i,nei_grid_z];
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];area_frac_cell_y = area_frac_cell_y*2;% 加上了fractureCellType(the_frac_cell) == 1时的area_frac_cell_y
struc_z=[i,nei_grid_z];
end
if fractureCellType(the_frac_cell) == 3
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
end
%% ----------------------% 各方向投影面积叠加及传导率计算---------------------------------------------------------------
%% x direction
% struc_x=[i,nei_grid_x];
pos=find_row(struc_x,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_x;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_x)*ky(nei_grid_x)*kz(nei_grid_x))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_x,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_x/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_x/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_x,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
%% y direction
% struc_y=[i,nei_grid_y];
pos=find_row(struc_y,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_y;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_y)*ky(nei_grid_y)*kz(nei_grid_y))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_y,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_y/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_y/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0.002;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_y,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
%% z direction
% struc_z=[i,nei_grid_z];
pos=find_row(struc_z,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_z;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_z)*ky(nei_grid_z)*kz(nei_grid_z))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_z,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_z/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_z/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0.0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_z,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
end
end
end
%% 额外添加的改进
im_N=[];
im_T=[];
% % % q=length(Kf)+1;
% % % for i=1:(q-1)/2%q-1是裂缝单元数量
% % % for j=(q-1)/2+1:(q-1)
% % % if abs(corevsfra(j,2)-corevsfra(i,2))<=1e-2
% % % im_N=[im_N;i+nmc,j+nmc];
% % % % im_T=[im_T;0];
% % % % im_T=[im_T;0.0039604];
% % % % im_T=[im_T;(((Kf(i))^(-1)+(1e-3)^(-1)+(1e-3)^(-1)+(Kf(j))^(-1))/4)^(-1)*2*2/0.4];
% % % im_T=[im_T;(((Kf(i))^(-1)+(1e-3)^(-1)+(1e-3)^(-1)+(Kf(j))^(-1))/4)^(-1)*0.5*2/0.4];
% % % %
% % % end
% % % end
% % % end
%% 用投影面积修正基质网格间传导
for i=1:nmm
% 为避免数值误差，导致没有真正封堵住，故
if (S_ex(i)-S_p(i))/S_ex(i)<=1e-2
T(i)=0;
else
T(i)= T(i)*(S_ex(i)-S_p(i))/S_ex(i);
end
end
%% 实用型pEDFM额外处理
% % % num_frac = size(frac_information,1)/3;
% % % for i = 1:num_frac
% % % if frac_information(3*i,1) <= (kx(1)*ky(1)*kz(1))^(1/3)
% % % % 裂缝的两端点
% % % one_end = frac_information(3*i-2,:);
% % % the_other_end = frac_information(3*i-1,:);
% % % % 两网格之间的连接
% % % for j = 1:size(N,1)
% % % added_matnodes_1=nodes(N(j,1),:);
% % % one_node_connect=mean(coord(added_matnodes_1,:));%该基质网格中心
% % % added_matnodes_2=nodes(N(j,2),:);
% % % the_other_node_connect=mean(coord(added_matnodes_2,:));
% % % coef_matrix = [
% % % the_other_end(1)-one_end(1),-(the_other_node_connect(1)-one_node_connect(1));
% % % the_other_end(2)-one_end(2),-(the_other_node_connect(2)-one_node_connect(2));];
% % % coef_vector = [one_node_connect(1)-one_end(1);one_node_connect(2)-one_end(2);];
% % % if abs(det(coef_matrix))<=1e-12
% % % else
% % % parameters = coef_matrix\coef_vector;
% % % if parameters(1)>=0 && parameters(1)<=1 && parameters(2)>=0 && parameters(2)<=1
% % % T(j) = (T(j)^-1 + frac_information(3*i,1)^-1)^-1;
% % % end
% % % end
% % % end
% % % end
% % % end
%% 把上述三种情况的矩阵分别叠加起来
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection;im_N];
T = [T; Tmff; Tff;Tinterflow;Tmf_projection;im_T];
% N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection];
% T = [T; Tmff; Tff;Tinterflow;Tmf_projection];
nex=size(N,1);
end
generic extended/connections_PEDFM_EX2_solutions.m
+707
View File
@@ -0,0 +1,707 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff] = connections_PEDFM_EX2_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag,frac_information,coordinates)
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
%
numberFractureCells = q-1;
%
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,1);%裂缝网格渗透率
Wf=zeros(q-1,1);%裂缝单元缝宽
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Wf(i,1)=wf(k-1);
Kf(i,1)=kf(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
end
end
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex=find(lengthvsfra(i,:)~=0);
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if Kf(j)==0 || Kf(k)==0
hartran=0;
else
tran1=Kf(j)*wf(i)*lengthcat/disk;
tran2=Kf(k)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均的一半
hartran=tran1*tran2/(tran1+tran2);
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
S_ex=zeros(nmm,1);% 流体交换面面积
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
% 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)/(Kx(index)*dxv(indexn) + Kx(indexn)*dxv(index));
S_ex(c)=dzv(index)*dyv(index);
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
S_ex(c)=dzv(index)*dxv(index);
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
S_ex(c)=dxv(index)*dyv(index);
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
for i=1:nx*ny*nz %基质网格编号
for j=1:10
if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Knnc=kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
Annc=areavsfra(matrixvsfra(i,j));% 此处与原始嵌入式不一样，原始是两倍
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
% 为论文做修改
% Dn=0.9;
% Dn=2.5;
raoT=Knnc*Annc/Dn;
Tinterflow=[Tinterflow;raoT];
end
end
end
%% 投影嵌入式处理
nmc=size(matrixvsfra,1);
%基质网格流体交换面上的裂缝单元投影面之和
S_p=zeros(nmm,1);
% 因为投影处理新加的F-M connections
Nmf_projection=[];
Tmf_projection=[];
for i=1:nmc
matnodes=nodes(i,:);
dx_grid=dxv(i);
dy_grid=dyv(i);
dz_grid=dzv(i);
grid_core=mean(coord(matnodes,:));%该基质网格中心
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>=1) %先仅考虑n=1时的情况
selected_face=zeros(1,3);
the_frac_cell=matrixvsfra(i,indice);%该裂缝单元编号
% if Kf(the_frac_cell) <= (kx(i)*ky(i)*kz(i))^(1/3);%
% else
which_frac=fcff{1,2}(the_frac_cell,1);%该裂缝单元所在的裂缝面
core_frac_cell=fcff{1,4}(the_frac_cell,1:3);%该裂缝单元的中心坐标
area_frac_cell=fcff{1,8}(the_frac_cell,1);%该裂缝单元面积
rao_struct=[i,the_frac_cell+nmc];
pos_rao=find_row(rao_struct,Ninterflow);
%该裂缝面法向量
D_value=core_frac_cell-grid_core;% 向量OF
vector_1=f(5*which_frac-3,:);
vector_2=f(5*which_frac-2,:);
n_vector_1=cross(vector_1,vector_2);
n_vector_2=-cross(vector_1,vector_2);
if (dot(n_vector_1,D_value))>=0
n_vector=n_vector_1;
else
n_vector=n_vector_2;
end
% 方向投影面积
area_frac_cell_x=abs(area_frac_cell*dot([1,0,0],n_vector)/norm(n_vector));
area_frac_cell_y=abs(area_frac_cell*dot([0,1,0],n_vector)/norm(n_vector));
area_frac_cell_z=abs(area_frac_cell*dot([0,0,1],n_vector)/norm(n_vector));
%% ----------------------% 根据fractureCellType选取投影面--------------------------------------
% selected_face(1)=4; nei_grid_x=i+1;
% selected_face(2)=5; nei_grid_y=i+nx;
% selected_face(3)=6;nei_grid_z=i+nx*ny;
%% 哪种类型？ 1：2 1：3 1：4
fractureCellType = zeros(numberFractureCells,1);
theNumber = 2;
fractureCellType = repmat((1:theNumber)',numberFractureCells/theNumber,1);
%% 选择哪种方法
selectedMethod = 2;
%% when number = 2
if theNumber == 2
% method 1
if selectedMethod == 1
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i+1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
% method 2
if selectedMethod == 2
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
end
%% when number = 3
if theNumber == 3
% method 1
if selectedMethod == 1
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 3
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
% method 2
if selectedMethod == 2
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,i];% 相当于没有
struc_z=[i,nei_grid_z];
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];area_frac_cell_y = area_frac_cell_y*2;% 加上了fractureCellType(the_frac_cell) == 1时的area_frac_cell_y
struc_z=[i,nei_grid_z];
end
if fractureCellType(the_frac_cell) == 3
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
end
end
%% when number = 4
if theNumber == 4
% method 1
if selectedMethod == 1
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 3
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
if fractureCellType(the_frac_cell) == 4
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
end
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];
struc_z=[i,nei_grid_z];
end
% method 2
if selectedMethod == 2
if fractureCellType(the_frac_cell) == 1
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,i];
struc_z=[i,nei_grid_z];
end
if fractureCellType(the_frac_cell) == 2
nei_grid_x=i-1;nei_grid_y=i+nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];area_frac_cell_y = area_frac_cell_y*2;
struc_z=[i,nei_grid_z];
end
if fractureCellType(the_frac_cell) == 3
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,nei_grid_y];area_frac_cell_y = area_frac_cell_y*2;
struc_z=[i,nei_grid_z];
end
if fractureCellType(the_frac_cell) == 4
nei_grid_x=i+1;nei_grid_y=i-nx;nei_grid_z=i+nx*ny;
struc_x=[i,nei_grid_x];
struc_y=[i,i];
struc_z=[i,nei_grid_z];
end
end
end
%% ----------------------% 各方向投影面积叠加及传导率计算---------------------------------------------------------------
%% x direction
% struc_x=[i,nei_grid_x];
pos=find_row(struc_x,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_x;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_x)*ky(nei_grid_x)*kz(nei_grid_x))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_x,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_x/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_x/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_x,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
%% y direction
% struc_y=[i,nei_grid_y];
pos=find_row(struc_y,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_y;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_y)*ky(nei_grid_y)*kz(nei_grid_y))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_y,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_y/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_y/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0.002;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_y,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
%% z direction
% struc_z=[i,nei_grid_z];
pos=find_row(struc_z,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_z;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_z)*ky(nei_grid_z)*kz(nei_grid_z))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_z,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_z/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_z/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0.0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_z,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
end
end
end
%% 额外添加的改进
im_N=[];
im_T=[];
% % % q=length(Kf)+1;
% % % for i=1:(q-1)/2%q-1是裂缝单元数量
% % % for j=(q-1)/2+1:(q-1)
% % % if abs(corevsfra(j,2)-corevsfra(i,2))<=1e-2
% % % im_N=[im_N;i+nmc,j+nmc];
% % % % im_T=[im_T;0];
% % % % im_T=[im_T;0.0039604];
% % % % im_T=[im_T;(((Kf(i))^(-1)+(1e-3)^(-1)+(1e-3)^(-1)+(Kf(j))^(-1))/4)^(-1)*2*2/0.4];
% % % im_T=[im_T;(((Kf(i))^(-1)+(1e-3)^(-1)+(1e-3)^(-1)+(Kf(j))^(-1))/4)^(-1)*0.5*2/0.4];
% % % %
% % % end
% % % end
% % % end
%% 用投影面积修正基质网格间传导
for i=1:nmm
% 为避免数值误差，导致没有真正封堵住，故
if (S_ex(i)-S_p(i))/S_ex(i)<=1e-2
T(i)=0;
else
T(i)= T(i)*(S_ex(i)-S_p(i))/S_ex(i);
end
end
%% 实用型pEDFM额外处理
% % % num_frac = size(frac_information,1)/3;
% % % for i = 1:num_frac
% % % if frac_information(3*i,1) <= (kx(1)*ky(1)*kz(1))^(1/3)
% % % % 裂缝的两端点
% % % one_end = frac_information(3*i-2,:);
% % % the_other_end = frac_information(3*i-1,:);
% % % % 两网格之间的连接
% % % for j = 1:size(N,1)
% % % added_matnodes_1=nodes(N(j,1),:);
% % % one_node_connect=mean(coord(added_matnodes_1,:));%该基质网格中心
% % % added_matnodes_2=nodes(N(j,2),:);
% % % the_other_node_connect=mean(coord(added_matnodes_2,:));
% % % coef_matrix = [
% % % the_other_end(1)-one_end(1),-(the_other_node_connect(1)-one_node_connect(1));
% % % the_other_end(2)-one_end(2),-(the_other_node_connect(2)-one_node_connect(2));];
% % % coef_vector = [one_node_connect(1)-one_end(1);one_node_connect(2)-one_end(2);];
% % % if abs(det(coef_matrix))<=1e-12
% % % else
% % % parameters = coef_matrix\coef_vector;
% % % if parameters(1)>=0 && parameters(1)<=1 && parameters(2)>=0 && parameters(2)<=1
% % % T(j) = (T(j)^-1 + frac_information(3*i,1)^-1)^-1;
% % % end
% % % end
% % % end
% % % end
% % % end
%% 把上述三种情况的矩阵分别叠加起来
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection;im_N];
T = [T; Tmff; Tff;Tinterflow;Tmf_projection;im_T];
% N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection];
% T = [T; Tmff; Tff;Tinterflow;Tmf_projection];
nex=size(N,1);
end
generic extended/connections_PEDFM_new.m
+735
View File
@@ -0,0 +1,735 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff] = connections_PEDFM_new( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag,frac_information,coordinates)
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,1);%裂缝网格渗透率
Wf=zeros(q-1,1);%裂缝单元缝宽
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if i == 41
flag = 1;
end
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j = 1:1:(rx-1)
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
end
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Wf(i,1)=wf(k-1);
Kf(i,1)=kf(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
% corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
end
end
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex=find(lengthvsfra(i,:)~=0);
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if Kf(j)==0 || Kf(k)==0
hartran=0;
else
tran1=Kf(j)*wf(i)*lengthcat/disk;
tran2=Kf(k)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均的一半
hartran=tran1*tran2/(tran1+tran2);
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
S_ex=zeros(nmm,1);% 流体交换面面积
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
% 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)/(Kx(index)*dxv(indexn) + Kx(indexn)*dxv(index));
S_ex(c)=dzv(index)*dyv(index);
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
S_ex(c)=dzv(index)*dxv(index);
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
S_ex(c)=dxv(index)*dyv(index);
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
for i=1:nx*ny*nz %基质网格编号
for j=1:10
if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Knnc=kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
Annc=areavsfra(matrixvsfra(i,j));% 此处与原始嵌入式不一样，原始是两倍
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
% 为论文做修改
% Dn=0.9;
% Dn=2.5;
% raoT=Knnc*Annc/Dn;
raoT1 = kcell*Annc/Dn;
raoT2 = Kf(matrixvsfra(i,j))*Annc/(Wf(matrixvsfra(i,j))/2);
raoT = (raoT1^-1+raoT2^-1)^-1;
Tinterflow=[Tinterflow;raoT];
end
end
end
%% 投影嵌入式处理
nmc=size(matrixvsfra,1);
%基质网格流体交换面上的裂缝单元投影面之和
S_p=zeros(nmm,1);
% 因为投影处理新加的F-M connections
Nmf_projection=[];
Tmf_projection=[];
for i=1:nmc
matnodes=nodes(i,:);
dx_grid=dxv(i);
dy_grid=dyv(i);
dz_grid=dzv(i);
grid_core=mean(coord(matnodes,:));%该基质网格中心
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n==1) %先仅考虑n=1时的情况
selected_face=zeros(1,3);
the_frac_cell=matrixvsfra(i,indice);%该裂缝单元编号
% if Kf(the_frac_cell) <= (kx(i)*ky(i)*kz(i))^(1/3);%
% else
which_frac=fcff{1,2}(the_frac_cell,1);%该裂缝单元所在的裂缝面
core_frac_cell=fcff{1,4}(the_frac_cell,1:3);%该裂缝单元的中心坐标
area_frac_cell=fcff{1,8}(the_frac_cell,1);%该裂缝单元面积
rao_struct=[i,the_frac_cell+nmc];
pos_rao=find_row(rao_struct,Ninterflow);
D_value=core_frac_cell-grid_core;% 向量OF
vector_1=f(5*which_frac-3,:);
vector_2=f(5*which_frac-2,:);
n_vector_1=cross(vector_1,vector_2);
n_vector_2=-cross(vector_1,vector_2);
if (dot(n_vector_1,D_value))>=0
n_vector=n_vector_1;
else
n_vector=n_vector_2;
end
%该裂缝面法向量
% x方向投影面积
area_frac_cell_x=abs(area_frac_cell*dot([1,0,0],n_vector)/norm(n_vector));
area_frac_cell_y=abs(area_frac_cell*dot([0,1,0],n_vector)/norm(n_vector));
area_frac_cell_z=abs(area_frac_cell*dot([0,0,1],n_vector)/norm(n_vector));
% %% 为valid case修改
% area_frac_cell_x=10*10;
% area_frac_cell_y=10*10;
% area_frac_cell_z=10*10;
%将裂缝中心沿法向量做微小平移，此时再按照距离最近原则判断，可以保证得到符合物理意义的情况
new_core=core_frac_cell+1e-6*n_vector;
% 裂缝单元中心相对于基质网格中心的向矢
%x direction
D_value_new=new_core-grid_core;
if D_value_new(1)<=0
selected_face(1)=3;nei_grid_x=i-1;
else selected_face(1)=4; nei_grid_x=i+1;
end
%% ----------------------% 为了做测试实用型pEDFM，人为加处理--------------------------------------
% 为了做测试实用型pEDFM，人为加处理
% selected_face(1)=4; nei_grid_x=i+1;
%% ----------------------% 人为处理结束---------------------------------------------------------------
struc_x=[i,nei_grid_x];
pos=find_row(struc_x,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_x;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_x)*ky(nei_grid_x)*kz(nei_grid_x))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_x,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_x/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_x/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_x,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
%y direction
if D_value_new(2)<=0
selected_face(2)=2;nei_grid_y=i-nx;
else selected_face(2)=5;nei_grid_y=i+nx;
end
%% ----------------------% 为了做测试实用型pEDFM，人为加处理--------------------------------------
% 为了做测试实用型pEDFM，人为加处理
% selected_face(2)=5; nei_grid_y=i+nx;
%% ----------------------% 人为处理结束---------------------------------------------------------------
struc_y=[i,nei_grid_y];
pos=find_row(struc_y,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_y;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_y)*ky(nei_grid_y)*kz(nei_grid_y))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_y,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_y/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_y/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0.002;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_y,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
% z direction
if D_value_new(3)<=0
selected_face(3)=1;nei_grid_z=i-nx*ny;
else selected_face(3)=6;nei_grid_z=i+nx*ny;
end
%% ----------------------% 为了做测试实用型pEDFM，人为加处理--------------------------------------
% 为了做测试实用型pEDFM，人为加处理
% selected_face(3)=6;nei_grid_z=i+nx*ny;
%% ----------------------% 人为处理结束---------------------------------------------------------------
% nei_grid_z=i-nx*ny;
struc_z=[i,nei_grid_z];
pos=find_row(struc_z,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_z;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_z)*ky(nei_grid_z)*kz(nei_grid_z))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_z,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_z/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_z/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0.0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_z,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
end
% %% 例二添加的
% if D_value_new(1)>0
% selected_face(1)=3;nei_grid_x=i-1;
% else selected_face(1)=4; nei_grid_x=i+1;
% end
% struc_x=[i,nei_grid_x];
% pos=find_row(struc_x,N);
% if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
% S_p(pos)=S_p(pos)+area_frac_cell_x;
% kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
% knei=(kx(nei_grid_x)*ky(nei_grid_x)*kz(nei_grid_x))^(1/3);%相邻那个基质网格渗透率
% added_matnodes=nodes(nei_grid_x,:);
% nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% % Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% % dis_added=norm(nei_grid_core-core_frac_cell);
% % T_added=Knnc*area_frac_cell_x/dis_added;
% % 采用另一种方式计算几何因子
% dis_added=norm(nei_grid_core-core_frac_cell);
% if Kf(the_frac_cell)==0
% T_added=0;
% else
% % 单独裂缝单元几何因子
% Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% % 单独相邻基质网格向裂缝单元几何因子
% Geofnei=knei*area_frac_cell_x/dis_added;
% % 单独该基质网格向裂缝单元几何因子
% Geofcell=Tinterflow(pos_rao,1);
%
% T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% % T_added=0;%特殊情况
% % T_added=0;%特殊情况
% % T_added=0.0039604;%特殊情况
% end
% Nmf_projection=[Nmf_projection;nei_grid_x,the_frac_cell+nmc];
% Tmf_projection=[Tmf_projection;T_added];
% end
%
% %y direction
% if D_value_new(2)>0
% selected_face(1)=2;nei_grid_y=i-nx;
% else selected_face(1)=5;nei_grid_y=i+nx;
% end
% struc_y=[i,nei_grid_y];
% pos=find_row(struc_y,N);
% if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
% S_p(pos)=S_p(pos)+area_frac_cell_y;
% kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
% knei=(kx(nei_grid_y)*ky(nei_grid_y)*kz(nei_grid_y))^(1/3);%相邻那个基质网格渗透率
% added_matnodes=nodes(nei_grid_y,:);
% nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% % Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% % dis_added=norm(nei_grid_core-core_frac_cell);
% % T_added=Knnc*area_frac_cell_y/dis_added;
% % 采用另一种方式计算几何因子
% dis_added=norm(nei_grid_core-core_frac_cell);
% if Kf(the_frac_cell)==0
% T_added=0;
% else
% % 单独裂缝单元几何因子
% Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% % 单独相邻基质网格向裂缝单元几何因子
% Geofnei=knei*area_frac_cell_y/dis_added;
% % 单独该基质网格向裂缝单元几何因子
% Geofcell=Tinterflow(pos_rao,1);
%
% T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% % T_added=0;%特殊情况
% % T_added=0.002;%特殊情况
% % T_added=0.0039604;%特殊情况
% end
% Nmf_projection=[Nmf_projection;nei_grid_y,the_frac_cell+nmc];
% Tmf_projection=[Tmf_projection;T_added];
% end
%
%
% % z direction
% if D_value_new(3)>0
% selected_face(1)=1;nei_grid_z=i-nx*ny;
% else selected_face(1)=6;nei_grid_z=i+nx*ny;
% end
% % nei_grid_z=i-nx*ny;
% struc_z=[i,nei_grid_z];
% pos=find_row(struc_z,N);
% if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
% S_p(pos)=S_p(pos)+area_frac_cell_z;
% kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
% knei=(kx(nei_grid_z)*ky(nei_grid_z)*kz(nei_grid_z))^(1/3);%相邻那个基质网格渗透率
% added_matnodes=nodes(nei_grid_z,:);
% nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% % Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% % dis_added=norm(nei_grid_core-core_frac_cell);
% % T_added=Knnc*area_frac_cell_z/dis_added;
% % 采用另一种方式计算几何因子
% dis_added=norm(nei_grid_core-core_frac_cell);
% if Kf(the_frac_cell)==0
% T_added=0;
% else
% % 单独裂缝单元几何因子
% Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% % 单独相邻基质网格向裂缝单元几何因子
% Geofnei=knei*area_frac_cell_z/dis_added;
% % 单独该基质网格向裂缝单元几何因子
% Geofcell=Tinterflow(pos_rao,1);
%
% T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% % T_added=0;%特殊情况
% % T_added=0.0;%特殊情况
% % T_added=0.0039604;%特殊情况
% end
% Nmf_projection=[Nmf_projection;nei_grid_z,the_frac_cell+nmc];
% Tmf_projection=[Tmf_projection;T_added];
% end
% end
end
end
end
%% 额外添加的改进
im_N=[];
im_T=[];
% q=length(Kf)+1;
% for i=1:(q-1)/2%q-1是裂缝单元数量
% for j=(q-1)/2+1:(q-1)
% if norm(corevsfra(j,:)-corevsfra(i,:))<=3*1e-1
% im_N=[im_N;i+nmc,j+nmc];
% % im_T=[im_T;0];
% % im_T=[im_T;0.0039604];
% % im_T=[im_T;(((Kf(i))^(-1)+(1e-3)^(-1)+(1e-3)^(-1)+(Kf(j))^(-1))/4)^(-1)*2*2/0.4];
% % im_T=[im_T;(((Kf(i))^(-1)+(1e-3)^(-1)+(1e-3)^(-1)+(Kf(j))^(-1))/4)^(-1)*0.5*2/0.4];
% im_T=[im_T;((Kf(i)*1*2/0.005)^-1+(Kf(j)*1*2/0.005)^-1+(5*1e-3*1*2/0.1)^-1+(5*1e-3*1*2/0.1)^-1)^-1];
% %
% end
% end
% end
%% 用投影面积修正基质网格间传导
for i=1:nmm
% 为避免数值误差，导致没有真正封堵住，故
if (S_ex(i)-S_p(i))/S_ex(i)<=1e-2
T(i)=0;
else
T(i)= T(i)*(S_ex(i)-S_p(i))/S_ex(i);
end
end
%% 实用型pEDFM额外处理
% % % num_frac = size(frac_information,1)/3;
% % % for i = 1:num_frac
% % % if frac_information(3*i,1) <= (kx(1)*ky(1)*kz(1))^(1/3)
% % % % 裂缝的两端点
% % % one_end = frac_information(3*i-2,:);
% % % the_other_end = frac_information(3*i-1,:);
% % % % 两网格之间的连接
% % % for j = 1:size(N,1)
% % % added_matnodes_1=nodes(N(j,1),:);
% % % one_node_connect=mean(coord(added_matnodes_1,:));%该基质网格中心
% % % added_matnodes_2=nodes(N(j,2),:);
% % % the_other_node_connect=mean(coord(added_matnodes_2,:));
% % % coef_matrix = [
% % % the_other_end(1)-one_end(1),-(the_other_node_connect(1)-one_node_connect(1));
% % % the_other_end(2)-one_end(2),-(the_other_node_connect(2)-one_node_connect(2));];
% % % coef_vector = [one_node_connect(1)-one_end(1);one_node_connect(2)-one_end(2);];
% % % if abs(det(coef_matrix))<=1e-12
% % % else
% % % parameters = coef_matrix\coef_vector;
% % % if parameters(1)>=0 && parameters(1)<=1 && parameters(2)>=0 && parameters(2)<=1
% % % T(j) = (T(j)^-1 + frac_information(3*i,1)^-1)^-1;
% % % end
% % % end
% % % end
% % % end
% % % end
%% 把上述三种情况的矩阵分别叠加起来
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection;im_N];
T = [T; Tmff; Tff;Tinterflow;Tmf_projection;im_T];
% N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection];
% T = [T; Tmff; Tff;Tinterflow;Tmf_projection];
nex=size(N,1);
end
generic extended/connections_PEDFM_new_new.m
+714
View File
@@ -0,0 +1,714 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff, flowArea, perm, matrixflag] = connections_PEDFM_new_new( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,pori,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag,frac_information,coordinates)
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
cell_center_coordinates = zeros(nx*ny*nz, 3); % 裂缝网格中心在该矩阵基础上添加
for j = 1:nx*ny*nz
nodes_of_the_cell = nodes(j,:);
cell_center_coordinates(j,:) = mean(coord(nodes_of_the_cell,:));%该基质网格中心
end
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
number_fracture_cells = q-1;
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,1);%裂缝网格渗透率
Wf=zeros(q-1,1);%裂缝单元缝宽
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
fracFaceArea=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
avfracFaceArea=zeros(q-1,1);
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j = 1:1:(rx-1)
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
end
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Wf(i,1)=wf(k-1);
Kf(i,1)=kf(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
% corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
fracFaceArea(i,j)=wf(k-1)*lengthvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
avfracFaceArea(i)=sum(fracFaceArea(i,:))/(rx-1);
end
end
% 包含基质网格各和裂缝网格的中心：
cell_center_coordinates = [cell_center_coordinates; corevsfra];
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex= lengthvsfra(i,:)~=0;
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
perm_ff = zeros(1,1);
flowArea_ff = zeros(1,1);
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if Kf(j)==0 || Kf(k)==0
hartran=0;
kij = 0;
else
tran1=Kf(j)*wf(i)*lengthcat/disk;
tran2=Kf(k)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均的一半
hartran=tran1*tran2/(tran1+tran2);
kij = 2*(Kf(j)^(-1)+Kf(k)^(-1))^(-1);
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
perm_ff = [perm_ff; kij];
flowArea_ff = [flowArea_ff; wf(i)*lengthcat];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
perm_ff(1,:)=[];
flowArea_ff(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
perm_mff=zeros(1,1);
flowArea_mff=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0]; perm_mff=[perm_mff;0];flowArea_mff=[flowArea_mff;(avfracFaceArea(fc1)+avfracFaceArea(fc2))/2];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
perm_mff=[perm_mff;(Kf(fc1)^(-1)+Kf(fc2)^(-1))^(-1)];
flowArea_mff=[flowArea_mff;(avfracFaceArea(fc1)+avfracFaceArea(fc2))/2];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
perm_mff(1,:)=[];
flowArea_mff(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
S_ex=zeros(nmm,1);% 流体交换面面积
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
perm = zeros(nmm, 1);
flowArea = zeros(nmm, 1);
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
% 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)/(Kx(index)*dxv(indexn) + Kx(indexn)*dxv(index));
S_ex(c)=dzv(index)*dyv(index);
perm(c)=2*Kx(index)*Kx(indexn)/(Kx(index) + Kx(indexn));
flowArea(c)=dzv(index)*dyv(index);
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
S_ex(c)=dzv(index)*dxv(index);
perm(c)=2*Ky(index)*Ky(indexn)/(Ky(index) + Ky(indexn));
flowArea(c)=dzv(index)*dxv(index);
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
S_ex(c)=dxv(index)*dyv(index);
perm(c)=2*Kz(index)*Kz(indexn)/(Kz(index) + Kz(indexn));
flowArea(c)=dxv(index)*dyv(index);
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
perm_interflow=[];
flowArea_interflow=[];
for i=1:nx*ny*nz %基质网格编号
for j=1:10
% if matrixvsfra(i,j)~=0
if matrixvsfra(i,j)~=0 && (matrixvsfra(i,j) <= number_fracture_cells) %this matrix cell contains a fracture cell
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Annc=areavsfra(matrixvsfra(i,j));% 此处与原始嵌入式不一样，原始是两倍
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
% Dn=0.9;
% Dn=0.15;
% Dn = (5-0.5)/2;
raoT1 = kcell*Annc/Dn;
raoT2 = Kf(matrixvsfra(i,j))*Annc/(Wf(matrixvsfra(i,j))/2);
raoT = (raoT1^-1+raoT2^-1)^-1;
% raoT=Knnc*Annc/Dn;
Tinterflow=[Tinterflow;raoT];
perm_mf_this = kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
perm_interflow = [perm_interflow; perm_mf_this];
flowArea_interflow = [flowArea_interflow; Annc];
end
end
end
%% 投影嵌入式处理
nmc=size(matrixvsfra,1);
%基质网格流体交换面上的裂缝单元投影面之和
S_p=zeros(nmm,1);
% 因为投影处理新加的F-M connections
Nmf_projection=[];
Tmf_projection=[];
perm_projection=[];
flowArea_projection=[];
for i=1:nmc
matnodes=nodes(i,:);
dx_grid=dxv(i);
dy_grid=dyv(i);
dz_grid=dzv(i);
grid_core=mean(coord(matnodes,:));%该基质网格中心
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
% if (n>=1)
the_frac_cells=matrixvsfra(i,indice);%该裂缝单元编号
if (n>=1) %先仅考虑n=1时的情况
selected_face=zeros(1,3);
if n>1
flag =1;
end
for haihaihai = 1:length(the_frac_cells)
the_frac_cell = the_frac_cells(haihaihai);
if Kf(the_frac_cell) <= (kx(i)*ky(i)*kz(i))^(1/3) %
else
which_frac=fcff{1,2}(the_frac_cell,1);%该裂缝单元所在的裂缝面
core_frac_cell=fcff{1,4}(the_frac_cell,1:3);%该裂缝单元的中心坐标
area_frac_cell=fcff{1,8}(the_frac_cell,1);%该裂缝单元面积
rao_struct=[i,the_frac_cell+nmc];
pos_rao=find_row(rao_struct,Ninterflow);
D_value=core_frac_cell-grid_core;% 向量OF
vector_1=f(5*which_frac-3,:);
vector_2=f(5*which_frac-2,:);
n_vector_1=cross(vector_1,vector_2);
n_vector_2=-cross(vector_1,vector_2);
if (dot(n_vector_1,D_value))>=0
n_vector=n_vector_1;
else
n_vector=n_vector_2;
end
%该裂缝面法向量
% x方向投影面积
area_frac_cell_x=abs(area_frac_cell*dot([1,0,0],n_vector)/norm(n_vector));
area_frac_cell_y=abs(area_frac_cell*dot([0,1,0],n_vector)/norm(n_vector));
area_frac_cell_z=abs(area_frac_cell*dot([0,0,1],n_vector)/norm(n_vector));
% %% 为valid case修改
% area_frac_cell_x=10*10;
% area_frac_cell_y=10*10;
% area_frac_cell_z=10*10;
%将裂缝中心沿法向量做微小平移，此时再按照距离最近原则判断，可以保证得到符合物理意义的情况
new_core=core_frac_cell+1e-4*n_vector;
% 裂缝单元中心相对于基质网格中心的向矢
%x direction
D_value_new=new_core-grid_core;
if D_value_new(1)<=0
selected_face(1)=3;nei_grid_x=i-1;
else selected_face(1)=4; nei_grid_x=i+1;
end
%% ----------------------% 为了做测试实用型pEDFM，人为加处理--------------------------------------
% 为了做测试实用型pEDFM，人为加处理
% selected_face(1)=4; nei_grid_x=i+1;
%% ----------------------% 人为处理结束---------------------------------------------------------------
struc_x=[i,nei_grid_x];
pos=find_row(struc_x,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_x;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_x)*ky(nei_grid_x)*kz(nei_grid_x))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_x,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_x/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
% dis_added = (5+0.5)/2;
Geofnei=knei*area_frac_cell_x/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
T_added = 1/(1/Geofnei+1/Geof);
% T_added=0;%特殊情况
% T_added=0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_x,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
perm_projection =[perm_projection;knei];
flowArea_projection = [flowArea_projection;area_frac_cell_x];
end
%y direction
if D_value_new(2)<=0
selected_face(2)=2;nei_grid_y=i-nx;
else selected_face(2)=5;nei_grid_y=i+nx;
end
%% ----------------------% 为了做测试实用型pEDFM，人为加处理--------------------------------------
% 为了做测试实用型pEDFM，人为加处理
% selected_face(2)=5; nei_grid_y=i+nx;
%% ----------------------% 人为处理结束---------------------------------------------------------------
struc_y=[i,nei_grid_y];
pos=find_row(struc_y,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_y;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_y)*ky(nei_grid_y)*kz(nei_grid_y))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_y,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_y/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_y/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
T_added = 1/(1/Geofnei+1/Geof);
% T_added=0;%特殊情况
% T_added=0.002;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_y,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
perm_projection =[perm_projection;knei];
flowArea_projection = [flowArea_projection;area_frac_cell_y];
end
% z direction
if D_value_new(3)<=0
selected_face(3)=1;nei_grid_z=i-nx*ny;
else selected_face(3)=6;nei_grid_z=i+nx*ny;
end
%% ----------------------% 为了做测试实用型pEDFM，人为加处理--------------------------------------
% 为了做测试实用型pEDFM，人为加处理
% selected_face(3)=6;nei_grid_z=i+nx*ny;
%% ----------------------% 人为处理结束---------------------------------------------------------------
% nei_grid_z=i-nx*ny;
struc_z=[i,nei_grid_z];
pos=find_row(struc_z,N);
if size(pos,1)==1 %说明需要削减这两个基质网格间的传导系数
S_p(pos)=S_p(pos)+area_frac_cell_z;
kcell=(kx(i)*ky(i)*kz(i))^(1/3);%基质网格渗透率
knei=(kx(nei_grid_z)*ky(nei_grid_z)*kz(nei_grid_z))^(1/3);%相邻那个基质网格渗透率
added_matnodes=nodes(nei_grid_z,:);
nei_grid_core=mean(coord(added_matnodes,:));%该基质网格中心
% Knnc=2*kcell*Kf(the_frac_cell)/(kcell+Kf(the_frac_cell));%调和平均后
% dis_added=norm(nei_grid_core-core_frac_cell);
% T_added=Knnc*area_frac_cell_z/dis_added;
% 采用另一种方式计算几何因子
dis_added=norm(nei_grid_core-core_frac_cell);
if Kf(the_frac_cell)==0
T_added=0;
else
% 单独裂缝单元几何因子
Geof=Kf(the_frac_cell)*area_frac_cell/(Wf(the_frac_cell)/2);
% 单独相邻基质网格向裂缝单元几何因子
Geofnei=knei*area_frac_cell_z/dis_added;
% 单独该基质网格向裂缝单元几何因子
Geofcell=Tinterflow(pos_rao,1);
T_added=1/(1/Geofnei+1/Geofcell+1/Geof);
% T_added=0;%特殊情况
% T_added=0.0;%特殊情况
% T_added=0.0039604;%特殊情况
end
Nmf_projection=[Nmf_projection;nei_grid_z,the_frac_cell+nmc];
Tmf_projection=[Tmf_projection;T_added];
perm_projection =[perm_projection;knei];
flowArea_projection = [flowArea_projection;area_frac_cell_z];
end
end
end
end
end
end
%% 额外添加的改进
im_N=[];
im_T=[];
% q=length(Kf)+1;
% for i=1:(q-1)/2%q-1是裂缝单元数量
% for j=(q-1)/2+1:(q-1)
% if abs(corevsfra(j,1)-corevsfra(i,1))<=1e-2
% im_N=[im_N;i+nmc,j+nmc];
% % im_T=[im_T;0];
% im_T=[im_T;0.0039604];
% % im_T=[im_T;(((Kf(i))^(-1)+(1e-3)^(-1)+(1e-3)^(-1)+(Kf(j))^(-1))/4)^(-1)*2*2/0.4];
% %
% end
% end
% end
%% 用投影面积修正基质网格间传导
num_weaken = 0;
for i=1:nmm
% 为避免数值误差，导致没有真正封堵住，故
if (S_ex(i)-S_p(i))/S_ex(i)<=1e-2
T(i)=0;
num_weaken = num_weaken+1;
else
T(i)= T(i)*(S_ex(i)-S_p(i))/S_ex(i);
end
end
% % % %% 实用型pEDFM额外处理
% % % num_frac = size(frac_information,1)/3;
% % % for i = 1:num_frac
% % % if frac_information(3*i,1) <= (kx(1)*ky(1)*kz(1))^(1/3)
% % % % 裂缝的两端点
% % % one_end = frac_information(3*i-2,:);
% % % the_other_end = frac_information(3*i-1,:);
% % % % 两网格之间的连接
% % % for j = 1:size(N,1)
% % % added_matnodes_1=nodes(N(j,1),:);
% % % one_node_connect=mean(coord(added_matnodes_1,:));%该基质网格中心
% % % added_matnodes_2=nodes(N(j,2),:);
% % % the_other_node_connect=mean(coord(added_matnodes_2,:));
% % % coef_matrix = [
% % % the_other_end(1)-one_end(1),-(the_other_node_connect(1)-one_node_connect(1));
% % % the_other_end(2)-one_end(2),-(the_other_node_connect(2)-one_node_connect(2));];
% % % coef_vector = [one_node_connect(1)-one_end(1);one_node_connect(2)-one_end(2);];
% % % if abs(det(coef_matrix))<=1e-12
% % % else
% % % parameters = coef_matrix\coef_vector;
% % % if parameters(1)>=0 && parameters(1)<=1 && parameters(2)>=0 && parameters(2)<=1
% % % T(j) = (T(j)^-1 + frac_information(3*i,1)^-1)^-1;
% % % end
% % % end
% % % end
% % % end
% % % end
%% 把上述三种情况的矩阵分别叠加起来
matrixflag = [ones(size(T,1),1); zeros(size(Tmff,1),1); zeros(size(Tff,1),1); ones(size(Tinterflow,1),1); ones(size(Tmf_projection,1),1); ones(size(im_T,1),1)];
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection;im_N];
% Tmff = Tmff*0;
T = [T; Tmff; Tff;Tinterflow;Tmf_projection;im_T];
perm = [perm; perm_mff; perm_ff;perm_interflow; perm_projection];
flowArea = [flowArea; flowArea_mff; flowArea_ff;flowArea_interflow; flowArea_projection+0.0001];
% N = [N; Nmff+nmc; Nff+nmc;Ninterflow;Nmf_projection];
% T = [T; Tmff; Tff;Tinterflow;Tmf_projection];
nex=size(N,1);
%% 实用型pEDFM额外处理
num_frac = size(frac_information,1)/3;
for i = 1:num_frac
if frac_information(3*i,1) <= (kx(1)*ky(1)*kz(1))^(1/3) % 此处为做算例简化编写代码的, || i == 2
% 裂缝的两端点
one_end = frac_information(3*i-2,:);
the_other_end = frac_information(3*i-1,:);
% 两网格之间的连接
for j = 1:size(N,1)
% added_matnodes_1=nodes(N(j,1),:);
% one_node_connect=mean(coord(added_matnodes_1,:));%该基质网格中心
% added_matnodes_2=nodes(N(j,2),:);
% the_other_node_connect=mean(coord(added_matnodes_2,:));
one_node_connect = cell_center_coordinates(N(j,1),:);
the_other_node_connect = cell_center_coordinates(N(j,2),:);
coef_matrix = [
the_other_end(1)-one_end(1),-(the_other_node_connect(1)-one_node_connect(1));
the_other_end(2)-one_end(2),-(the_other_node_connect(2)-one_node_connect(2));];
coef_vector = [one_node_connect(1)-one_end(1);one_node_connect(2)-one_end(2);];
if abs(det(coef_matrix))<=1e-12
else
parameters = coef_matrix\coef_vector;
if parameters(1)>=0 && parameters(1)<=1 && parameters(2)>=0 && parameters(2)<=1
disp('a T modfification in the new pEDFM');
disp(T(j));
if T(j) > 0.006
flag = 1;
end
T(j) = (T(j)^-1 + (frac_information(3*i,1)/(frac_information(3*i,2)/2))^-1)^-1;
% T(j) = 0.005;
disp(T(j));
end
end
end
end
end
%% 转到CMG或者ECLIPSE进行计算
% [ Data_for_ECLIPSE ] = pEDFM_to_CMG_horizontalFractureWell(dxv,dyv,dzv,kx,ky,kz,pori,Kf,Wf,vf,porf,N,T);
% [ Data_for_ECLIPSE ] = pEDFM_to_CMG_horizontalFractureWell_net_pay(dxv,dyv,dzv,kx,ky,kz,pori,Kf,Wf,vf,porf,N,T);
end
generic extended/connections_unstructured_EDFM_EX1_solutions.m
+629
View File
@@ -0,0 +1,629 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio, fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX1_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag )
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
% m=floor((i+(2^nf)-1)/(2^nf));
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
mat_frac=[];
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
mat_frac=[mat_frac;i];
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
% Kffl=funtion_data.Kffl;
% Dffl=funtion_data.Dffl;
% kffl=zeros(q-1,1);
% dffl=zeros(q-1,1);
fractureCellFlag = (1:q-1)';
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,10);%裂缝网格渗透率
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
ave_disvsfra=zeros(q-1,1);
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Kf(i,1)=kf(k-1);
% kffl(i,1)=Kffl(k-1);
% dffl(i,1)=Dffl(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
ave_disvsfra(i)=sum(disvsfra(i,:))/(rx-1);
end
end
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex=find(lengthvsfra(i,:)~=0);
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
Tff_convection=zeros(1,1); %对流项
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if kf(i)==0 hartran=0;hartran_convection=0;
else
tran1=kf(i)*wf(i)*lengthcat/disk;
tran2=kf(i)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均
hartran=tran1*tran2/(tran1+tran2);
k_harmony= kf(i);
hartran_convection=kf(i)/(disk+disj)^2;
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
Tff_convection=[Tff_convection;hartran_convection];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
Tff_convection(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
Tmff_convection=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0];Tmff_convection=[Tmff_convection;0];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
Tmff_convection(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
T_convection = zeros(nmm, 1);
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
T_convection(c) = 2/(1/Kx(index)+1/Kx(indexn))/(dxv(indexn)+dxv(index));
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
T_convection(c) = 2/(1/Ky(index)+1/Ky(indexn))/(dyv(indexn)+dyv(index));
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
T_convection(c) = 2/(1/Kz(index)+1/Kz(indexn))/(dzv(indexn)+dzv(index));
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
Tinterflow_convection=[];
matrix_cells_containing_fracture_cells = [];
volume_ratio = [];
fractureMatrixFlag = zeros(size(fractureCellFlag,1),2);
numberInGroup = 3;
for i=1:nx*ny*nz %基质网格编号
for j=1:10
if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
fractureMatrixFlag(matrixvsfra(i,j),:) = [matrixvsfra(i,j),i];
matrix_cells_containing_fracture_cells = [matrix_cells_containing_fracture_cells; i];
if mod(matrixvsfra(i,j),numberInGroup) == 1 volume_ratio = [volume_ratio; 5/6];end
if mod(matrixvsfra(i,j),numberInGroup) == 2 volume_ratio = [volume_ratio; 1/2];end
if mod(matrixvsfra(i,j),numberInGroup) == 0 volume_ratio = [volume_ratio; 1/6];end
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Knnc=kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
Annc=2*areavsfra(matrixvsfra(i,j));
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
raoT=Knnc*Annc/Dn;
raoT_convection=2*Knnc/Dn^2;
Tinterflow=[Tinterflow;raoT];
Tinterflow_convection=[Tinterflow_convection;raoT_convection];
end
end
end
%% 额外处理，此处并未通用化，有待进一步开展
nfc=size(fracnumber,1);
the_added_matrix_cells = [];
nmc=nx * ny*nz;
the_added_mf_connec = [];
the_added_mf_T = [];
number_of_adding = 0;
cell_divided_by_fracture_flag = matrix_cells_containing_fracture_cells;
% 记录基质网格被分成了哪两个网格,并删除原有的与这些基质网格相关的连接
matrixCellsDivided = zeros(size(matrix_cells_containing_fracture_cells,1),2);
deletedFlag = [];
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
number_of_adding = number_of_adding+1;
the_new_cell = number_of_adding+nmc;
the_added_matrix_cells = [the_added_matrix_cells; the_new_cell];
matrixCellsDivided(i,:) = [the_matrix_cell, the_new_cell];
% m-m连接
for j = 1:size(N,1)
if N(j,1) == the_matrix_cell || N(j,2) == the_matrix_cell
deletedFlag = [deletedFlag; j];
end
% % % if N(j,2) == the_matrix_cell+1
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,2) == the_matrix_cell-nx
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell+1
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell-nx
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
end
end
deletedFlag = unique(deletedFlag);
N(deletedFlag,:) = [];
T(deletedFlag,:) = [];
% 构建裂缝网格-基质网格-添加基质网格的对应矩阵，按照裂缝网格顺序排列，方便后续处理
fractureCell_matrixCell_addedMatrixCell = zeros(size(fractureCellFlag,1),3);
for xiang = 1:size(fractureCellFlag,1)
theFractureCell = fractureCellFlag(xiang,1);
aaa = find(fractureMatrixFlag(:,1) == theFractureCell);
theMatrixCell = fractureMatrixFlag(aaa,2);
bbb = find(matrixCellsDivided(:,1) == theMatrixCell);
theAddedMatrixCells = matrixCellsDivided(bbb,2);
fractureCell_matrixCell_addedMatrixCell(theFractureCell,:) = [theFractureCell, theMatrixCell, theAddedMatrixCells];
end
% 添加这些基质网格的真实连接
relatedN = [];
relatedT = [];
for xiang = 1:size(fractureCellFlag,1)/numberInGroup
addedNSs =[
% 左侧原有基质网格 x方向上的连接
fractureCell_matrixCell_addedMatrixCell(3*xiang-2,2)-1, fractureCell_matrixCell_addedMatrixCell(3*xiang-2,2);
fractureCell_matrixCell_addedMatrixCell(3*xiang-1,2)-1, fractureCell_matrixCell_addedMatrixCell(3*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(3*xiang-0,2)-1, fractureCell_matrixCell_addedMatrixCell(3*xiang-0,2);
% 右侧添加基质网格 x方向上的连接
fractureCell_matrixCell_addedMatrixCell(3*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(3*xiang-2,2)+1;
fractureCell_matrixCell_addedMatrixCell(3*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(3*xiang-1,2)+1;
fractureCell_matrixCell_addedMatrixCell(3*xiang-0,3), fractureCell_matrixCell_addedMatrixCell(3*xiang-0,2)+1;
% 左侧原有基质网格 y方向上的连接
fractureCell_matrixCell_addedMatrixCell(3*xiang-2,2), fractureCell_matrixCell_addedMatrixCell(3*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(3*xiang-1,2), fractureCell_matrixCell_addedMatrixCell(3*xiang-0,2);
fractureCell_matrixCell_addedMatrixCell(3*xiang-0,2), fractureCell_matrixCell_addedMatrixCell(3*xiang-0,2)+nx;
% 右侧添加基质网格 y方向上的连接
fractureCell_matrixCell_addedMatrixCell(3*xiang-2,2)-nx, fractureCell_matrixCell_addedMatrixCell(3*xiang-2,3);
fractureCell_matrixCell_addedMatrixCell(3*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(3*xiang-1,3);
fractureCell_matrixCell_addedMatrixCell(3*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(3*xiang-0,3);
];
relatedN = [relatedN;
addedNSs
];
% 计算传导率
addedTs = [];
for dai = 1:size(addedNSs,1)
the_matrix_cell1 = addedNSs(dai,1); the_matrix_cell2 = addedNSs(dai,2);
if the_matrix_cell1> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell1);
the_matrix_cell1 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
if the_matrix_cell2> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell2);
the_matrix_cell2 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
if dai == 1
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/6))^(-1))^(-1);
end
if dai == 2
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/4))^(-1))^(-1);
end
if dai == 3
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*5/12))^(-1))^(-1);
end
if dai == 4
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 5
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/4))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 6
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/6))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 7
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 8
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 9
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 10
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 11
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 12
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/4))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/6))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
addedTs = [addedTs; theT];
end
relatedT = [relatedT;addedTs];
end
N = [N; relatedN];
T = [T; relatedT];
%
Ninterflow(:,2) = Ninterflow(:,2)+ number_of_adding;
ori_nmc = nmc;
nmc = ori_nmc +number_of_adding;
% m-f连接
% number_of_adding = 0;
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,2) == the_matrix_cell);
the_new_cell = fractureCell_matrixCell_addedMatrixCell(aaa,3);
the_fracture_cell_flag = fractureCell_matrixCell_addedMatrixCell(aaa,1);
% number_of_adding = number_of_adding+1;
% the_new_cell = number_of_adding+ori_nmc;
for j = 1:size(Ninterflow,1)
if Ninterflow(j,1) == the_matrix_cell
the_added_mf_connec = [the_added_mf_connec;the_new_cell,Ninterflow(j,2)];
if mod(the_fracture_cell_flag, numberInGroup) == 1
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((1+2/3)/2))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((0+1/3)/2));
end
if mod(the_fracture_cell_flag, numberInGroup) == 2
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2];
Tinterflow(j) = Tinterflow(j)/2;
end
if mod(the_fracture_cell_flag, numberInGroup) == 0
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((0+1/3)/2))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((1+2/3)/2));
end
end
end
end
Ninterflow = [Ninterflow; the_added_mf_connec];
Tinterflow = [Tinterflow; the_added_mf_T];
%% 按照2014年的方法，将窜流处理为与上述相似的形式
% syms x y z;
% Ninterflow=[];
% Tinterflow=[];
% for i=1:nx*ny*nz %基质网格编号
% for j=1:10
% if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
% Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
% kcell=(kx(i)*ky(i)*kz(i))^(1/3);
% K1=Kf(matrixvsfra(i,j));d1=Wf(matrixvsfra(i,j));
% K2=kffl(matrixvsfra(i,j));d2=dffl(matrixvsfra(i,j));
% Annc=2*areavsfra(matrixvsfra(i,j));
% fracore=corevsfra(matrixvsfra(i,j),:);
% matnodes=nodes(i,:);
% verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
% matcore=mean(verco);d0=matcore-fracore;
% dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% % dn=abs(dn);%影响数值积分效率
% dn=sqrt(dn^2);
% dn=matlabFunction(dn);
% if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
% Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(2)~=0
% Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(3)~=0
% Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0 && norvec(3)~=0
% Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0
% Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0
% Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(3)~=0
% Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% end
% end
% end
% end
% end
% end
% end
% raoT=((Kcell*Annc/(Dn-d2))^(-1)+(K2*Annc/d2)^(-1)+(K1*Annc/d1)^(-1))^(-1);
% Tinterflow=[Tinterflow;raoT];
% end
% end
% end
%% 把上述三种情况的矩阵分别叠加起来
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;];
T = [T; Tmff; Tff;Tinterflow;];
T_convection = [T_convection;Tmff_convection; Tff_convection;Tinterflow_convection;];
nex=size(N,1);
end
generic extended/connections_unstructured_EDFM_EX2_1to2_solutions.m
+638
View File
@@ -0,0 +1,638 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio, fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX2_1to2_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag )
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
% m=floor((i+(2^nf)-1)/(2^nf));
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
mat_frac=[];
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
mat_frac=[mat_frac;i];
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
% Kffl=funtion_data.Kffl;
% Dffl=funtion_data.Dffl;
% kffl=zeros(q-1,1);
% dffl=zeros(q-1,1);
fractureCellFlag = (1:q-1)';
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,10);%裂缝网格渗透率
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
ave_disvsfra=zeros(q-1,1);
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Kf(i,1)=kf(k-1);
% kffl(i,1)=Kffl(k-1);
% dffl(i,1)=Dffl(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
ave_disvsfra(i)=sum(disvsfra(i,:))/(rx-1);
end
end
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex=find(lengthvsfra(i,:)~=0);
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
Tff_convection=zeros(1,1); %对流项
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if kf(i)==0 hartran=0;hartran_convection=0;
else
tran1=kf(i)*wf(i)*lengthcat/disk;
tran2=kf(i)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均
hartran=tran1*tran2/(tran1+tran2);
k_harmony= kf(i);
hartran_convection=kf(i)/(disk+disj)^2;
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
Tff_convection=[Tff_convection;hartran_convection];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
Tff_convection(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
Tmff_convection=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0];Tmff_convection=[Tmff_convection;0];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
Tmff_convection(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
T_convection = zeros(nmm, 1);
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
T_convection(c) = 2/(1/Kx(index)+1/Kx(indexn))/(dxv(indexn)+dxv(index));
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
T_convection(c) = 2/(1/Ky(index)+1/Ky(indexn))/(dyv(indexn)+dyv(index));
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
T_convection(c) = 2/(1/Kz(index)+1/Kz(indexn))/(dzv(indexn)+dzv(index));
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
Tinterflow_convection=[];
matrix_cells_containing_fracture_cells = [];
volume_ratio = [];
fractureMatrixFlag = zeros(size(fractureCellFlag,1),2);
%% -------------------------------------------------------------------------此处是修改之重---------------------------------------------------------------
numberInGroup = 2;
%% -------------------------------------------------------------------------上方修改结束---------------------------------------------------------------
for i=1:nx*ny*nz %基质网格编号
for j=1:10
if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
fractureMatrixFlag(matrixvsfra(i,j),:) = [matrixvsfra(i,j),i];
matrix_cells_containing_fracture_cells = [matrix_cells_containing_fracture_cells; i];
%% -------------------------------------------------------------------------此处是修改之重---------------------------------------------------------------
if mod(matrixvsfra(i,j),numberInGroup) == 1 volume_ratio = [volume_ratio; 3/4];end % 右侧重新编号网格所占体积比例
% if mod(matrixvsfra(i,j),numberInGroup) == 2 volume_ratio = [volume_ratio; 1/2];end
if mod(matrixvsfra(i,j),numberInGroup) == 0 volume_ratio = [volume_ratio; 1/4];end
%% -------------------------------------------------------------------------上方修改结束---------------------------------------------------------------
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Knnc=kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
Annc=2*areavsfra(matrixvsfra(i,j));
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
raoT=Knnc*Annc/Dn;
raoT_convection=2*Knnc/Dn^2;
Tinterflow=[Tinterflow;raoT];
Tinterflow_convection=[Tinterflow_convection;raoT_convection];
end
end
end
%% 额外处理，此处并未通用化，有待进一步开展
nfc=size(fracnumber,1);
the_added_matrix_cells = [];
nmc=nx * ny*nz;
the_added_mf_connec = [];
the_added_mf_T = [];
number_of_adding = 0;
cell_divided_by_fracture_flag = matrix_cells_containing_fracture_cells;
% 记录基质网格被分成了哪两个网格,并删除原有的与这些基质网格相关的连接
matrixCellsDivided = zeros(size(matrix_cells_containing_fracture_cells,1),2);
deletedFlag = [];
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
number_of_adding = number_of_adding+1;
the_new_cell = number_of_adding+nmc;
the_added_matrix_cells = [the_added_matrix_cells; the_new_cell];
matrixCellsDivided(i,:) = [the_matrix_cell, the_new_cell];
% m-m连接
for j = 1:size(N,1)
if N(j,1) == the_matrix_cell || N(j,2) == the_matrix_cell
deletedFlag = [deletedFlag; j];
end
% % % if N(j,2) == the_matrix_cell+1
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,2) == the_matrix_cell-nx
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell+1
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell-nx
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
end
end
deletedFlag = unique(deletedFlag);
N(deletedFlag,:) = [];
T(deletedFlag,:) = [];
% 构建裂缝网格-基质网格-添加基质网格的对应矩阵，按照裂缝网格顺序排列，方便后续处理
fractureCell_matrixCell_addedMatrixCell = zeros(size(fractureCellFlag,1),3);
for xiang = 1:size(fractureCellFlag,1)
theFractureCell = fractureCellFlag(xiang,1);
aaa = find(fractureMatrixFlag(:,1) == theFractureCell);
theMatrixCell = fractureMatrixFlag(aaa,2);
bbb = find(matrixCellsDivided(:,1) == theMatrixCell);
theAddedMatrixCells = matrixCellsDivided(bbb,2);
fractureCell_matrixCell_addedMatrixCell(theFractureCell,:) = [theFractureCell, theMatrixCell, theAddedMatrixCells];
end
% 添加这些基质网格的真实连接
relatedN = [];
relatedT = [];
for xiang = 1:size(fractureCellFlag,1)/numberInGroup
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
addedNSs =[
% 左侧原有基质网格 x方向上的连接
% fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2);
% 右侧添加基质网格 x方向上的连接
% fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2)+1;
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2)+1;
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)+1;
% 左侧原有基质网格 y方向上的连接
% fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)+nx;
% 右侧添加基质网格 y方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2)-nx, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3);
% fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,3);
];
%% --------------------------------------------------------------此处修改结束-----------------------------------------------------------------
relatedN = [relatedN;
addedNSs
];
% 计算传导率
addedTs = [];
for dai = 1:size(addedNSs,1)
the_matrix_cell1 = addedNSs(dai,1); the_matrix_cell2 = addedNSs(dai,2);
if the_matrix_cell1> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell1);
the_matrix_cell1 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
if the_matrix_cell2> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell2);
the_matrix_cell2 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
% if dai == 1
% theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/6))^(-1))^(-1);
% end
if dai == 1
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*1/8))^(-1))^(-1);
end
if dai == 2
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*3/8))^(-1))^(-1);
end
% if dai == 4
% theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% end
if dai == 3
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*3/8))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 4
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/8))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
% if dai == 7
% theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% end
if dai == 5
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/2/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/2/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 6
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/2/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/2/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 7
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/2/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/2/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
% if dai == 11
% theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% end
if dai == 8
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/2/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/2/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
%% -------------------------------------------------------------------------此处修改结束-----------------------------------------------------------------------
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/4))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/6))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
addedTs = [addedTs; theT];
end
relatedT = [relatedT;addedTs];
end
N = [N; relatedN];
T = [T; relatedT];
%
Ninterflow(:,2) = Ninterflow(:,2)+ number_of_adding;
ori_nmc = nmc;
nmc = ori_nmc +number_of_adding;
% m-f连接
% number_of_adding = 0;
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,2) == the_matrix_cell);
the_new_cell = fractureCell_matrixCell_addedMatrixCell(aaa,3);
the_fracture_cell_flag = fractureCell_matrixCell_addedMatrixCell(aaa,1);
% number_of_adding = number_of_adding+1;
% the_new_cell = number_of_adding+ori_nmc;
for j = 1:size(Ninterflow,1)
if Ninterflow(j,1) == the_matrix_cell
the_added_mf_connec = [the_added_mf_connec;the_new_cell,Ninterflow(j,2)];
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
if mod(the_fracture_cell_flag, numberInGroup) == 1
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((1+1/2)/4))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((2-1-1/2)/4));
end
% % % if mod(the_fracture_cell_flag, numberInGroup) == 2
% % % the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2];
% % % Tinterflow(j) = Tinterflow(j)/2;
% % % end
if mod(the_fracture_cell_flag, numberInGroup) == 0
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((1/2+0)/4))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((1/2+0)/4));
end
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
end
end
end
Ninterflow = [Ninterflow; the_added_mf_connec];
Tinterflow = [Tinterflow; the_added_mf_T];
%% 按照2014年的方法，将窜流处理为与上述相似的形式
% syms x y z;
% Ninterflow=[];
% Tinterflow=[];
% for i=1:nx*ny*nz %基质网格编号
% for j=1:10
% if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
% Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
% kcell=(kx(i)*ky(i)*kz(i))^(1/3);
% K1=Kf(matrixvsfra(i,j));d1=Wf(matrixvsfra(i,j));
% K2=kffl(matrixvsfra(i,j));d2=dffl(matrixvsfra(i,j));
% Annc=2*areavsfra(matrixvsfra(i,j));
% fracore=corevsfra(matrixvsfra(i,j),:);
% matnodes=nodes(i,:);
% verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
% matcore=mean(verco);d0=matcore-fracore;
% dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% % dn=abs(dn);%影响数值积分效率
% dn=sqrt(dn^2);
% dn=matlabFunction(dn);
% if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
% Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(2)~=0
% Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(3)~=0
% Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0 && norvec(3)~=0
% Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0
% Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0
% Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(3)~=0
% Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% end
% end
% end
% end
% end
% end
% end
% raoT=((Kcell*Annc/(Dn-d2))^(-1)+(K2*Annc/d2)^(-1)+(K1*Annc/d1)^(-1))^(-1);
% Tinterflow=[Tinterflow;raoT];
% end
% end
% end
%% 把上述三种情况的矩阵分别叠加起来
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;];
T = [T; Tmff; Tff;Tinterflow;];
T_convection = [T_convection;Tmff_convection; Tff_convection;Tinterflow_convection;];
nex=size(N,1);
end
generic extended/connections_unstructured_EDFM_EX2_1to3_solutions.m
+638
View File
@@ -0,0 +1,638 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio, fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX2_1to3_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag )
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
% m=floor((i+(2^nf)-1)/(2^nf));
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
mat_frac=[];
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
mat_frac=[mat_frac;i];
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
% Kffl=funtion_data.Kffl;
% Dffl=funtion_data.Dffl;
% kffl=zeros(q-1,1);
% dffl=zeros(q-1,1);
fractureCellFlag = (1:q-1)';
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,10);%裂缝网格渗透率
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
ave_disvsfra=zeros(q-1,1);
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Kf(i,1)=kf(k-1);
% kffl(i,1)=Kffl(k-1);
% dffl(i,1)=Dffl(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
ave_disvsfra(i)=sum(disvsfra(i,:))/(rx-1);
end
end
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex=find(lengthvsfra(i,:)~=0);
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
Tff_convection=zeros(1,1); %对流项
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if kf(i)==0 hartran=0;hartran_convection=0;
else
tran1=kf(i)*wf(i)*lengthcat/disk;
tran2=kf(i)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均
hartran=tran1*tran2/(tran1+tran2);
k_harmony= kf(i);
hartran_convection=kf(i)/(disk+disj)^2;
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
Tff_convection=[Tff_convection;hartran_convection];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
Tff_convection(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
Tmff_convection=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0];Tmff_convection=[Tmff_convection;0];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
Tmff_convection(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
T_convection = zeros(nmm, 1);
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
T_convection(c) = 2/(1/Kx(index)+1/Kx(indexn))/(dxv(indexn)+dxv(index));
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
T_convection(c) = 2/(1/Ky(index)+1/Ky(indexn))/(dyv(indexn)+dyv(index));
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
T_convection(c) = 2/(1/Kz(index)+1/Kz(indexn))/(dzv(indexn)+dzv(index));
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
Tinterflow_convection=[];
matrix_cells_containing_fracture_cells = [];
volume_ratio = [];
fractureMatrixFlag = zeros(size(fractureCellFlag,1),2);
%% -------------------------------------------------------------------------此处是修改之重---------------------------------------------------------------
numberInGroup = 3;
%% -------------------------------------------------------------------------上方修改结束---------------------------------------------------------------
for i=1:nx*ny*nz %基质网格编号
for j=1:10
if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
fractureMatrixFlag(matrixvsfra(i,j),:) = [matrixvsfra(i,j),i];
matrix_cells_containing_fracture_cells = [matrix_cells_containing_fracture_cells; i];
%% -------------------------------------------------------------------------此处是修改之重---------------------------------------------------------------
if mod(matrixvsfra(i,j),numberInGroup) == 1 volume_ratio = [volume_ratio; 5/6];end % 右侧重新编号网格所占体积比例
if mod(matrixvsfra(i,j),numberInGroup) == 2 volume_ratio = [volume_ratio; 1/2];end
if mod(matrixvsfra(i,j),numberInGroup) == 0 volume_ratio = [volume_ratio; 1/6];end
%% -------------------------------------------------------------------------上方修改结束---------------------------------------------------------------
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Knnc=kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
Annc=2*areavsfra(matrixvsfra(i,j));
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
raoT=Knnc*Annc/Dn;
raoT_convection=2*Knnc/Dn^2;
Tinterflow=[Tinterflow;raoT];
Tinterflow_convection=[Tinterflow_convection;raoT_convection];
end
end
end
%% 额外处理，此处并未通用化，有待进一步开展
nfc=size(fracnumber,1);
the_added_matrix_cells = [];
nmc=nx * ny*nz;
the_added_mf_connec = [];
the_added_mf_T = [];
number_of_adding = 0;
cell_divided_by_fracture_flag = matrix_cells_containing_fracture_cells;
% 记录基质网格被分成了哪两个网格,并删除原有的与这些基质网格相关的连接
matrixCellsDivided = zeros(size(matrix_cells_containing_fracture_cells,1),2);
deletedFlag = [];
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
number_of_adding = number_of_adding+1;
the_new_cell = number_of_adding+nmc;
the_added_matrix_cells = [the_added_matrix_cells; the_new_cell];
matrixCellsDivided(i,:) = [the_matrix_cell, the_new_cell];
% m-m连接
for j = 1:size(N,1)
if N(j,1) == the_matrix_cell || N(j,2) == the_matrix_cell
deletedFlag = [deletedFlag; j];
end
% % % if N(j,2) == the_matrix_cell+1
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,2) == the_matrix_cell-nx
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell+1
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell-nx
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
end
end
deletedFlag = unique(deletedFlag);
N(deletedFlag,:) = [];
T(deletedFlag,:) = [];
% 构建裂缝网格-基质网格-添加基质网格的对应矩阵，按照裂缝网格顺序排列，方便后续处理
fractureCell_matrixCell_addedMatrixCell = zeros(size(fractureCellFlag,1),3);
for xiang = 1:size(fractureCellFlag,1)
theFractureCell = fractureCellFlag(xiang,1);
aaa = find(fractureMatrixFlag(:,1) == theFractureCell);
theMatrixCell = fractureMatrixFlag(aaa,2);
bbb = find(matrixCellsDivided(:,1) == theMatrixCell);
theAddedMatrixCells = matrixCellsDivided(bbb,2);
fractureCell_matrixCell_addedMatrixCell(theFractureCell,:) = [theFractureCell, theMatrixCell, theAddedMatrixCells];
end
% 添加这些基质网格的真实连接
relatedN = [];
relatedT = [];
for xiang = 1:size(fractureCellFlag,1)/numberInGroup
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
addedNSs =[
% 左侧原有基质网格 x方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2)-1, fractureCell_matrixCell_addedMatrixCell(3*xiang-2,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2);
% 右侧添加基质网格 x方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2)+1;
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2)+1;
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)+1;
% 左侧原有基质网格 y方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)+nx;
% 右侧添加基质网格 y方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2)-nx, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,3);
];
%% --------------------------------------------------------------此处修改结束-----------------------------------------------------------------
relatedN = [relatedN;
addedNSs
];
% 计算传导率
addedTs = [];
for dai = 1:size(addedNSs,1)
the_matrix_cell1 = addedNSs(dai,1); the_matrix_cell2 = addedNSs(dai,2);
if the_matrix_cell1> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell1);
the_matrix_cell1 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
if the_matrix_cell2> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell2);
the_matrix_cell2 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
if dai == 1
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/12))^(-1))^(-1);
end
if dai == 2
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/4))^(-1))^(-1);
end
if dai == 3
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*5/12))^(-1))^(-1);
end
if dai == 4
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 5
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/4))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 6
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 7
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 8
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 9
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 10
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 11
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 12
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
%% -------------------------------------------------------------------------此处修改结束-----------------------------------------------------------------------
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/4))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/6))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
addedTs = [addedTs; theT];
end
relatedT = [relatedT;addedTs];
end
N = [N; relatedN];
T = [T; relatedT];
%
Ninterflow(:,2) = Ninterflow(:,2)+ number_of_adding;
ori_nmc = nmc;
nmc = ori_nmc +number_of_adding;
% m-f连接
% number_of_adding = 0;
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,2) == the_matrix_cell);
the_new_cell = fractureCell_matrixCell_addedMatrixCell(aaa,3);
the_fracture_cell_flag = fractureCell_matrixCell_addedMatrixCell(aaa,1);
% number_of_adding = number_of_adding+1;
% the_new_cell = number_of_adding+ori_nmc;
for j = 1:size(Ninterflow,1)
if Ninterflow(j,1) == the_matrix_cell
the_added_mf_connec = [the_added_mf_connec;the_new_cell,Ninterflow(j,2)];
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
if mod(the_fracture_cell_flag, numberInGroup) == 1
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((1+2/3)/2))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((0+1/3)/2));
end
if mod(the_fracture_cell_flag, numberInGroup) == 2
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2];
Tinterflow(j) = Tinterflow(j)/2;
end
if mod(the_fracture_cell_flag, numberInGroup) == 0
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((0+1/3)/2))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((1+2/3)/2));
end
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
end
end
end
Ninterflow = [Ninterflow; the_added_mf_connec];
Tinterflow = [Tinterflow; the_added_mf_T];
%% 按照2014年的方法，将窜流处理为与上述相似的形式
% syms x y z;
% Ninterflow=[];
% Tinterflow=[];
% for i=1:nx*ny*nz %基质网格编号
% for j=1:10
% if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
% Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
% kcell=(kx(i)*ky(i)*kz(i))^(1/3);
% K1=Kf(matrixvsfra(i,j));d1=Wf(matrixvsfra(i,j));
% K2=kffl(matrixvsfra(i,j));d2=dffl(matrixvsfra(i,j));
% Annc=2*areavsfra(matrixvsfra(i,j));
% fracore=corevsfra(matrixvsfra(i,j),:);
% matnodes=nodes(i,:);
% verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
% matcore=mean(verco);d0=matcore-fracore;
% dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% % dn=abs(dn);%影响数值积分效率
% dn=sqrt(dn^2);
% dn=matlabFunction(dn);
% if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
% Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(2)~=0
% Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(3)~=0
% Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0 && norvec(3)~=0
% Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0
% Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0
% Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(3)~=0
% Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% end
% end
% end
% end
% end
% end
% end
% raoT=((Kcell*Annc/(Dn-d2))^(-1)+(K2*Annc/d2)^(-1)+(K1*Annc/d1)^(-1))^(-1);
% Tinterflow=[Tinterflow;raoT];
% end
% end
% end
%% 把上述三种情况的矩阵分别叠加起来
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;];
T = [T; Tmff; Tff;Tinterflow;];
T_convection = [T_convection;Tmff_convection; Tff_convection;Tinterflow_convection;];
nex=size(N,1);
end
generic extended/connections_unstructured_EDFM_EX2_1to4_solutions.m
+663
View File
@@ -0,0 +1,663 @@
function [ matrixvsfra,connectmf,fracnumber,fracstart,corevsfra,connect_infrac,N,T,zf,fcinff,vf,porf,fcff,T_convection,mat_frac,number_of_adding,cell_divided_by_fracture_flag,volume_ratio, fractureCell_matrixCell_addedMatrixCell] = connections_unstructured_EDFM_EX2_1to4_solutions( fracturemesh,pointvsregion,raopoint,f,nf,nx,ny,nz,kx,ky,kz,kf,wf,Porf,dxv,dyv,dzv,coord,nodes,NTG,addflag )
% 该函数用以给裂缝面网格编号，并存储网格间的连接关系及传导率，是前处理的关键步骤
% 不同于二维嵌入式离散裂缝模型，三维模型中，裂缝是二维平面，网格之间连接关系复杂，
%不能简单得从基质网格来判定，若所处基质网格不相邻，则裂缝网格必不相邻，若所处基质网格相邻，裂缝网格却不一定相邻
%上述原则无助于我们去确定connections，故拟采取以下方案：
%第一步:按照xink矩阵去掉零行后，按照行数依次给某裂缝面网格编号，同时存储裂缝网格所在的基质网格序号
%第二步:存储每个裂缝网格的面积，边界，边界长度，中心点坐标，中心点到各边界的距离，为后续操作做准备
%第三步:按照裂缝网格序号顺序，按照边界进行搜索，如果有相同的边界，则两个裂缝网格是相邻的
%matrixvsfra矩阵代表基质网格中包含裂缝网格编号的情况
%fracnumber矩阵，行序号表示该裂缝网格编号，行内容表示该网格包含的点序号
%areavsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的面积
%每相邻两列是一条边，然后将顺序反过来，又是两列一条边
%lengthvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的各边长度
%corevsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心坐标
%disvsfra矩阵，行序号表示该裂缝网格编号，行内容表示该裂缝网格的重心到各边的距离
matrixvsfra=zeros(nx*ny*nz,10);%为了减少该矩阵的大小，考虑实际情况，一个基质网格中，一般不会有超过10个裂缝网格
fracnumber=zeros(1000,20);%根据实际情况，裂缝网格一般不会超过1000个，也可根据实际情况改变
%m=size(xink,1);
rownum=zeros(nf,1);
for i=1:nf
rownum(i)=size(fracturemesh{i,1},1);
end
%% 将所有裂缝面网格连起来一起编号，并将编号扔给相应的基质网格
q=1;
fracstart=zeros(nf+1,1);%这个表示在总编号中，每条裂缝起始的号码
for j=1:nf
fracstart(j)=q;
numofmesh=pointvsregion{j,1};
for i=1:1:rownum(j)
if(norm(fracturemesh{j,1}(i,:))~=0)
raoindice=size(fracturemesh{j,1}(i,:),2);
fracnumber(q,1:raoindice)=fracturemesh{j,1}(i,:);%q即是该裂缝编号
% m=floor((i+(2^nf)-1)/(2^nf));
m=floor((i+(2^addflag(j)-1))/(2^addflag(j)));
indice=find(matrixvsfra(numofmesh(m),:)~=0);
% indice=find(matrixvsfra(numofmesh(i),:)~=0);
if (size(indice,2)==0) xiang=1;
else
rao=max(indice');
xiang=rao(1)+1;
end
matrixvsfra(numofmesh(m),xiang)=q;%将裂缝编号附给相应的基质网格
q=q+1;
end
end
end
fracstart(nf+1)=q;%裂缝网格总数量+1
fracnumber(q:1000,:)=[];
%% 将包含有裂缝单元的基质网格筛选出来,并进行处理
m=size(matrixvsfra,1);
mat_frac=[];
connectmf=cell(1,4);
% for i=1:m
% if (norm(matrixvsfra(i,:))~=0)
% ConnecS = cell(1,4);
cc = 0;
cl = 1;
for i = 1 : m
%筛选出包含裂缝的基质网格
% if ~isempty(matrixvsfra(i,:))
if (norm(matrixvsfra(i,:)))~=0
cc = cc + 1;
%存储该基质网格编号
connectmf{cc,1} = i;
mat_frac=[mat_frac;i];
%给这些裂缝点/裂缝单元按顺序编号
A=matrixvsfra(i,:);
A(A==0)=[];
connectmf{cc,2} =A;
end
end
%% 一条条裂缝计算裂缝网格面积、边界等等
% edgevsfra=cell(nf,1);
% Kffl=funtion_data.Kffl;
% Dffl=funtion_data.Dffl;
% kffl=zeros(q-1,1);
% dffl=zeros(q-1,1);
fractureCellFlag = (1:q-1)';
normalvec=zeros(q-1,3);%unit 法向量
areavsfra=zeros(q-1,1);%q-1即裂缝网格总数
lengthvsfra=zeros(q-1,10);
Kf=zeros(q-1,10);%裂缝网格渗透率
corevsfra=zeros(q-1,3);
disvsfra=zeros(q-1,10);
tran=zeros(q-1,10);
avtran=zeros(q-1,1);%裂缝网格平均传导，用于后续的简化计算
ave_disvsfra=zeros(q-1,1);
fcinff=zeros(q-1,1);%表示裂缝单元所在的裂缝面序号
zf=zeros(q-1,1);%裂缝单元高度（以下表面为基准）
vf=zeros(q-1,1);%裂缝单元的体积
porf=zeros(q-1,1);%裂缝单元的孔隙度
for i=1:1:q-1 %对裂缝网格进行操作
if(norm(fracnumber(i,:))==0) break;
else
for k=2:(nf+1)
if(i<fracstart(k)) fcinff(i)=k-1; break;%判断该点处在哪个裂缝平面上,k-1号裂缝面
end
end
d3intersection=raopoint{k-1,1};
anothersection=raopoint{k-1,2};
fraindice=find(fracnumber(i,:)~=0);
rx=size(fraindice,2);
for j=1:1:(rx-1)
%edgevsfra(i,(4*j-3):(4*j))=[fracnumber(i,j),fracnumber(i,j+1),fracnumber(i,j+1),fracnumber(i,j)];%完成对edgevsfra矩阵赋值
%%因为是凸多边形，因此只要代表裂缝网格的两个行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格；如果小于两个，则没有共有的边线
normalvec(i,:)=cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:))/norm(cross(f(5*(k-1)-3,:),f(5*(k-1)-2,:)));
areavsfra(i)=area(anothersection(fracnumber(i,1:(rx-1))',:) ,f(5*(k-1)-3,:),f(5*(k-1)-2,:) );%计算出每个裂缝网格的面积
vf(i)=areavsfra(i)*wf(k-1);
porf(i)=Porf(k-1);
Kf(i,1)=kf(k-1);
% kffl(i,1)=Kffl(k-1);
% dffl(i,1)=Dffl(k-1);
lengthvsfra(i,j)=norm(d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:));%计算裂缝网格每条边的长度
corevsfra(i,:)=1/(rx-1)*d3intersection(fracnumber(i,j),:)+corevsfra(i,:);%计算每个裂缝网格重心的坐标
zf(i)=corevsfra(i,3);%裂缝网格计算深度（以下平面为基准计算得到的高度，值为正数）
rao1=corevsfra(i,:)-d3intersection(fracnumber(i,j),:);
rao2=d3intersection(fracnumber(i,j+1),:)-d3intersection(fracnumber(i,j),:);
disvsfra(i,j)=norm(cross(rao1',rao2'))/norm(rao2);%计算出每个裂缝网格重心到每条边的距离
tran(i,j)=kf(k-1)*wf(k-1)*lengthvsfra(i,j)./disvsfra(i,j);
end
avtran(i)=sum(tran(i,:))/(rx-1);
ave_disvsfra(i)=sum(disvsfra(i,:))/(rx-1);
end
end
% %% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
% fcff=cell(1,8);
% fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 为了防止出现某裂缝网格面积相对过小，引起计算出错，故将面积很小的裂缝网格给去掉
maxarea=max(areavsfra,2);
% minlength=min(lengthvsfra,[],2);
% maxlength=max(lengthvsfra,[],2);
newnum=zeros(q-1,1);
[deindex1,~]=find(areavsfra<0*maxarea);
deindex2=[];
for i=1:(q-1)
zeroindex=find(lengthvsfra(i,:)~=0);
minlength=min(lengthvsfra(i,zeroindex));
maxlength=max(lengthvsfra(i,:));
if minlength<0*maxlength
deindex2=[deindex2;i];
end
end
deindex=[deindex1;deindex2];
deindex=unique(deindex);
deindex=sort(deindex);
hui=length(deindex);
if hui>0
for i=1:(q-1)
[dogindex,~]=find(deindex==i);
if length(dogindex)~=0
newnum(i)=0;
else
[catindex,~]=find(deindex<i);
rao=length(catindex);
newnum(i)=i-rao;
end
end
fracnumber(deindex,:)=[];
fcinff(deindex,:)=[];
lengthvsfra(deindex,:)=[];
corevsfra(deindex,:)=[];
disvsfra(deindex,:)=[];
tran(deindex,:)=[];
avtran(deindex,:)=[];
areavsfra(deindex,:)=[];
zf(deindex,:)=[];
vf(deindex,:)=[];
porf(deindex,:)=[];
% change matrixvsfra
for i=1:m%matrixvsfra矩阵的行数
for j=1:10
if matrixvsfra(i,j)~=0
matrixvsfra(i,j)=newnum(matrixvsfra(i,j));
end
end
end
% change fracstart
fracstart(nf+1,1)=length(fracnumber)+1;
for i=1:nf
[daiindex,~]=find(deindex<fracstart(i,1));
dai=length(daiindex);
fracstart(i)=fracstart(i)-dai;
end
end
%% 生成裂缝单元及所在裂缝面的cell数组及其它形状信息
fcff=cell(1,8);
fcff{1,1}=fracnumber; fcff{1,2}=fcinff;fcff{1,3}=lengthvsfra;fcff{1,4}=corevsfra;fcff{1,5}=disvsfra;fcff{1,6}=tran;fcff{1,7}=avtran;fcff{1,8}=areavsfra;
%% 裂缝单元的连接情况
%% 在同一裂缝面上，裂缝单元的连接情况及传导率计算(不包含在同一基质网格中的相邻裂缝单元）
connect_infrac=cell(nf,1);
Nff=zeros(1,2); %记录同一裂缝面上的网格相邻情况，第一列和第二列分别是相邻网格的编号
Tff=zeros(1,1); %记录相应的传导系数
Tff_convection=zeros(1,1); %对流项
for i=1:nf
p=1;
raoconnect=zeros(fracstart(i+1)-fracstart(i),10);%一般来说，裂缝网格不超过10条边
d3intersection=raopoint{i,1};
anothersection=raopoint{i,2};
for j=fracstart(i):((fracstart(i+1)-1)-1)%第i条裂缝的编号范围
q=1;
for k=j:(fracstart(i+1)-1)
A=fracnumber(j,:);
B=fracnumber(k,:);
%将两个向量很可能都有的0去掉，这个0没有什么意义
A(A==0)=[];
B(B==0)=[];
[a,~]=find(matrixvsfra==j); [b,~]=find(matrixvsfra==k);
if length(a)~=1
heihei=1;
end
raoflag=intersect(A,B);
if((size(raoflag,2)>2)||((size(raoflag,2)<2))) continue;%因为是凸多边形，因此只要代表裂缝网格的行向量的共有元素有2个，即有公共边；
%如果多于2个，则是相同的裂缝网格，因为如果不是，则必有一个是凹多边形，矛盾，证毕；如果小于两个，则没有共有的边线
else if (a==b) continue; %说明这两个裂缝单元在同一个基质网格中，因此不应该算在此类中
else
raoconnect(p,q)=k;q=q+1;
lengthcat=norm(d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:));%计算裂缝单元公共边长度
rao1k=corevsfra(k,:)-d3intersection(raoflag(1),:);
rao1j=corevsfra(j,:)-d3intersection(raoflag(1),:);
rao2=d3intersection(raoflag(1),:)-d3intersection(raoflag(2),:);
%分别计算两裂缝单元中心到公共边的距离
disk=norm(cross(rao1k',rao2'))/norm(rao2);
disj=norm(cross(rao1j',rao2'))/norm(rao2);
if kf(i)==0 hartran=0;hartran_convection=0;
else
tran1=kf(i)*wf(i)*lengthcat/disk;
tran2=kf(i)*wf(i)*lengthcat/disj;
% hartran=length/(disk+disj);%取调和平均
hartran=tran1*tran2/(tran1+tran2);
k_harmony= kf(i);
hartran_convection=kf(i)/(disk+disj)^2;
end
Nff=[Nff; j,k];
Tff=[Tff;hartran];
Tff_convection=[Tff_convection;hartran_convection];
%计算出每个裂缝网格重心到每条边的距离
end
end
p=p+1;
end
connect_infrac{i,1}=raoconnect;
end
end
Nff(1,:)=[]; %去除第一行的零行
Tff(1,:)=[];
Tff_convection(1,:)=[];
%% 在同一基质网格中的裂缝单元连接情况及传导率计算
nmc=size(matrixvsfra,1);
Nmff=zeros(1,2);
Tmff=zeros(1,1);
Tmff_convection=zeros(1,1);
for i=1:nmc
if(norm(matrixvsfra(i,:))~=0)
indice=find(matrixvsfra(i,:)~=0);
n=size(indice,2);
if (n>1) %此时表明要采取下述的简化算法
% lengthvsfra(matrixvsfra(i,indice))./disvsfra(matrixvsfra(i,indice))
for j=1:n-1
for k=(j+1):n
Nmff=[Nmff;matrixvsfra(i,indice(j)), matrixvsfra(i,indice(k))];
% 此时的计算方式是先求每个裂缝网格的算术平均，再算包含在该基质网格中的所有裂缝单元的算术平均
fc1=matrixvsfra(i,indice(j)); fc2=matrixvsfra(i,indice(k));
allfc=matrixvsfra(i,1:n); sumtran=sum(fcff{1,7}(allfc));
if sumtran==0 Tmff=[Tmff; 0];Tmff_convection=[Tmff_convection;0];
else
Tmff=[Tmff; fcff{1,7}(fc1)*fcff{1,7}(fc2)/sumtran];
end
end
end
end
end
end
Nmff(1,:)=[]; %去掉开头的零行
Tmff(1,:)=[];
Tmff_convection(1,:)=[];
% N = [N; Nmff+nmc];
% T = [T; Tmff];
%% 基质网格的连接情况及传导系数计算
nmc=nx * ny*nz;%基质网格数目
nfc=size(fracnumber,1);%裂缝单元数目
rpt = [ones(nmc, 1); zeros(nfc, 1)];
% r.rpt = rpt;
nmm = (nx-1)*ny*nz+(ny-1)*nx*nz+(nz-1)*nx*ny;%nmm是基质网格之间存在流体交换的总数
% r.nf = nmm + nff;%nff是裂缝单元之间存在流体交换的总数
Kx=kx.*ones(nmc,1);
Ky=ky.*ones(nmc,1);
Kz=kz.*ones(nmc,1);
N = zeros(nmm, 2);%存储基质网格之间存在流体交换的网格编号
T = zeros(nmm, 1);%存储对应与N矩阵的传导系数
T_convection = zeros(nmm, 1);
c = 0;
for k= 1 : nz
for j = 1 : ny
for i = 1 : nx - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + 1;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dyv(index)*Kx(index)*Kx(indexn)*NTG(index)*NTG(indexn)/(Kx(index)*dxv(indexn)*NTG(index) + Kx(indexn)*dxv(index)*NTG(indexn));
T_convection(c) = 2/(1/Kx(index)+1/Kx(indexn))/(dxv(indexn)+dxv(index));
end
end
end
for k= 1 : nz
for i = 1 : nx
for j = 1 : ny - 1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx;
N(c, :) = [index, indexn];
T(c) = 2 * dzv(index)*dxv(index)*Ky(index)*Ky(indexn)/(Ky(index)*dyv(indexn) + Ky(indexn)*dyv(index));
T_convection(c) = 2/(1/Ky(index)+1/Ky(indexn))/(dyv(indexn)+dyv(index));
end
end
end
for i = 1 : nx
for j = 1 : ny
for k= 1: nz-1
c = c + 1;
index = i + (j - 1) * nx + (k - 1) * nx * ny;
indexn = index + nx * ny;
N(c, :) = [index, index + nx*ny];
T(c) = 2 * dxv(index)*dyv(index)*Kz(index)*Kz(indexn)/(Kz(index)*dzv(indexn) + Kz(indexn)*dzv(index));
T_convection(c) = 2/(1/Kz(index)+1/Kz(indexn))/(dzv(indexn)+dzv(index));
end
end
end
%% 按照2014年的方法，将窜流处理为与上述相似的形式
syms x y z;
Ninterflow=[];
Tinterflow=[];
Tinterflow_convection=[];
matrix_cells_containing_fracture_cells = [];
volume_ratio = [];
fractureMatrixFlag = zeros(size(fractureCellFlag,1),2);
%% -------------------------------------------------------------------------此处是修改之重---------------------------------------------------------------
numberInGroup = 4;
%% -------------------------------------------------------------------------上方修改结束---------------------------------------------------------------
for i=1:nx*ny*nz %基质网格编号
for j=1:10
if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
fractureMatrixFlag(matrixvsfra(i,j),:) = [matrixvsfra(i,j),i];
matrix_cells_containing_fracture_cells = [matrix_cells_containing_fracture_cells; i];
%% -------------------------------------------------------------------------此处是修改之重---------------------------------------------------------------
if mod(matrixvsfra(i,j),numberInGroup) == 1 volume_ratio = [volume_ratio; 7/8];end % 右侧重新编号网格所占体积比例
if mod(matrixvsfra(i,j),numberInGroup) == 2 volume_ratio = [volume_ratio; 5/8];end
if mod(matrixvsfra(i,j),numberInGroup) == 3 volume_ratio = [volume_ratio; 3/8];end
if mod(matrixvsfra(i,j),numberInGroup) == 0 volume_ratio = [volume_ratio; 1/8];end
%% -------------------------------------------------------------------------上方修改结束---------------------------------------------------------------
Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
kcell=(kx(i)*ky(i)*kz(i))^(1/3);
Knnc=kcell*Kf(matrixvsfra(i,j))/(kcell+Kf(matrixvsfra(i,j)));
Annc=2*areavsfra(matrixvsfra(i,j));
fracore=corevsfra(matrixvsfra(i,j),:);
matnodes=nodes(i,:);
verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
matcore=mean(verco);d0=matcore-fracore;
dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% dn=abs(dn);%影响数值积分效率
dn=sqrt(dn^2);
dn=matlabFunction(dn);
if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(2)~=0
Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0 && norvec(3)~=0
Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0 && norvec(3)~=0
Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(1)~=0
Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(2)~=0
Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
else if norvec(3)~=0
Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
end
end
end
end
end
end
end
raoT=Knnc*Annc/Dn;
raoT_convection=2*Knnc/Dn^2;
Tinterflow=[Tinterflow;raoT];
Tinterflow_convection=[Tinterflow_convection;raoT_convection];
end
end
end
%% 额外处理，此处并未通用化，有待进一步开展
nfc=size(fracnumber,1);
the_added_matrix_cells = [];
nmc=nx * ny*nz;
the_added_mf_connec = [];
the_added_mf_T = [];
number_of_adding = 0;
cell_divided_by_fracture_flag = matrix_cells_containing_fracture_cells;
% 记录基质网格被分成了哪两个网格,并删除原有的与这些基质网格相关的连接
matrixCellsDivided = zeros(size(matrix_cells_containing_fracture_cells,1),2);
deletedFlag = [];
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
number_of_adding = number_of_adding+1;
the_new_cell = number_of_adding+nmc;
the_added_matrix_cells = [the_added_matrix_cells; the_new_cell];
matrixCellsDivided(i,:) = [the_matrix_cell, the_new_cell];
% m-m连接
for j = 1:size(N,1)
if N(j,1) == the_matrix_cell || N(j,2) == the_matrix_cell
deletedFlag = [deletedFlag; j];
end
% % % if N(j,2) == the_matrix_cell+1
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,2) == the_matrix_cell-nx
% % % N(j,1) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell+1
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Kx(the_matrix_cell)*dzv(the_matrix_cell)*dyv(the_matrix_cell)/(dxv(the_matrix_cell)/3))^(-1)+(Kx(the_matrix_cell+1)*dzv(the_matrix_cell+1)*dyv(the_matrix_cell+1)/(dxv(the_matrix_cell+1)/2))^(-1))^(-1);
% % % end
% % % if N(j,1) == the_matrix_cell-nx
% % % N(j,2) = the_new_cell; T(j) = ...
% % % ((Ky(the_matrix_cell)*dzv(the_matrix_cell)*dxv(the_matrix_cell)/(dyv(the_matrix_cell)/3))^(-1)+(Ky(the_matrix_cell-n)*dzv(the_matrix_cell-n)*dxv(the_matrix_cell-n)/(dxv(the_matrix_cell-n)/2))^(-1))^(-1);
% % % end
end
end
deletedFlag = unique(deletedFlag);
N(deletedFlag,:) = [];
T(deletedFlag,:) = [];
% 构建裂缝网格-基质网格-添加基质网格的对应矩阵，按照裂缝网格顺序排列，方便后续处理
fractureCell_matrixCell_addedMatrixCell = zeros(size(fractureCellFlag,1),3);
for xiang = 1:size(fractureCellFlag,1)
theFractureCell = fractureCellFlag(xiang,1);
aaa = find(fractureMatrixFlag(:,1) == theFractureCell);
theMatrixCell = fractureMatrixFlag(aaa,2);
bbb = find(matrixCellsDivided(:,1) == theMatrixCell);
theAddedMatrixCells = matrixCellsDivided(bbb,2);
fractureCell_matrixCell_addedMatrixCell(theFractureCell,:) = [theFractureCell, theMatrixCell, theAddedMatrixCells];
end
% 添加这些基质网格的真实连接
relatedN = [];
relatedT = [];
for xiang = 1:size(fractureCellFlag,1)/numberInGroup
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
addedNSs =[
% 左侧原有基质网格 x方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)-1, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2);
% 右侧添加基质网格 x方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,2)+1;
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2)+1;
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2)+1;
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)+1;
% 左侧原有基质网格 y方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,2)+nx;
% 右侧添加基质网格 y方向上的连接
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,2)-nx, fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,3);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-3,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-2,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3);
fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-1,3), fractureCell_matrixCell_addedMatrixCell(numberInGroup*xiang-0,3);
];
%% --------------------------------------------------------------此处修改结束-----------------------------------------------------------------
relatedN = [relatedN;
addedNSs
];
% 计算传导率
addedTs = [];
for dai = 1:size(addedNSs,1)
the_matrix_cell1 = addedNSs(dai,1); the_matrix_cell2 = addedNSs(dai,2);
if the_matrix_cell1> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell1);
the_matrix_cell1 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
if the_matrix_cell2> nmc
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,3) == the_matrix_cell2);
the_matrix_cell2 = fractureCell_matrixCell_addedMatrixCell(aaa,2);
end
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
%
if dai == 1
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*1/16))^(-1))^(-1);
end
if dai == 2
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*3/16))^(-1))^(-1);
end
if dai == 3
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*5/16))^(-1))^(-1);
end
if dai == 4
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)*7/16))^(-1))^(-1);
end
%
if dai == 5
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*7/16))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 6
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/16))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 7
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*3/16))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 8
theT = ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/16))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
end
%
if dai == 9
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 10
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 11
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 12
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*4/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*4/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
%
if dai == 13
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*4/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*4/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 14
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 15
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
if dai == 16
theT = ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/4/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/4/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
end
%% -------------------------------------------------------------------------此处修改结束-----------------------------------------------------------------------
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*5/12))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/4))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Kx(the_matrix_cell1)*dzv(the_matrix_cell1)*dyv(the_matrix_cell1)/(dxv(the_matrix_cell1)*1/6))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dyv(the_matrix_cell2)/(dxv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % %
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*3/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*3/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*2/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*2/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
% % % ((Ky(the_matrix_cell1)*dzv(the_matrix_cell1)*dxv(the_matrix_cell1)*1/3/(dyv(the_matrix_cell1)/2))^(-1)+(Kx(the_matrix_cell2)*dzv(the_matrix_cell2)*dxv(the_matrix_cell2)*1/3/(dyv(the_matrix_cell2)/2))^(-1))^(-1);
addedTs = [addedTs; theT];
end
relatedT = [relatedT;addedTs];
end
N = [N; relatedN];
T = [T; relatedT];
%
Ninterflow(:,2) = Ninterflow(:,2)+ number_of_adding;
ori_nmc = nmc;
nmc = ori_nmc +number_of_adding;
% m-f连接
% number_of_adding = 0;
for i = 1:size(matrix_cells_containing_fracture_cells,1)
the_matrix_cell = matrix_cells_containing_fracture_cells(i,1);
aaa = find(fractureCell_matrixCell_addedMatrixCell(:,2) == the_matrix_cell);
the_new_cell = fractureCell_matrixCell_addedMatrixCell(aaa,3);
the_fracture_cell_flag = fractureCell_matrixCell_addedMatrixCell(aaa,1);
% number_of_adding = number_of_adding+1;
% the_new_cell = number_of_adding+ori_nmc;
for j = 1:size(Ninterflow,1)
if Ninterflow(j,1) == the_matrix_cell
the_added_mf_connec = [the_added_mf_connec;the_new_cell,Ninterflow(j,2)];
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
if mod(the_fracture_cell_flag, numberInGroup) == 1
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((1+3/4)/4))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((2-1-3/4)/4));
end
if mod(the_fracture_cell_flag, numberInGroup) == 2
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((3/4+2/4)/4))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((2-3/4-2/4)/4));
end
if mod(the_fracture_cell_flag, numberInGroup) == 3
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((2/4+1/4)/4))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((2-2/4-1/4)/4));
end
if mod(the_fracture_cell_flag, numberInGroup) == 0
the_added_mf_T = [the_added_mf_T; Tinterflow(j)/2*((1/4)/((0+1/4)/4))];
Tinterflow(j) = Tinterflow(j)/2*((1/4)/((2-0-1/4)/4));
end
%% -------------------------------------------------------------------------此处亦是修改之重-----------------------------------------------------------------------
end
end
end
Ninterflow = [Ninterflow; the_added_mf_connec];
Tinterflow = [Tinterflow; the_added_mf_T];
%% 按照2014年的方法，将窜流处理为与上述相似的形式
% syms x y z;
% Ninterflow=[];
% Tinterflow=[];
% for i=1:nx*ny*nz %基质网格编号
% for j=1:10
% if matrixvsfra(i,j)~=0 %this matrix cell contains a fracture cell
% Ninterflow=[Ninterflow;i,matrixvsfra(i,j)+nmc];
% kcell=(kx(i)*ky(i)*kz(i))^(1/3);
% K1=Kf(matrixvsfra(i,j));d1=Wf(matrixvsfra(i,j));
% K2=kffl(matrixvsfra(i,j));d2=dffl(matrixvsfra(i,j));
% Annc=2*areavsfra(matrixvsfra(i,j));
% fracore=corevsfra(matrixvsfra(i,j),:);
% matnodes=nodes(i,:);
% verco=coord(matnodes,:);norvec=normalvec(matrixvsfra(i,j),:);
% matcore=mean(verco);d0=matcore-fracore;
% dn=(x+d0(1))*norvec(1)+(y+d0(2))*norvec(2)+(z+d0(3))*norvec(3);
% % dn=abs(dn);%影响数值积分效率
% dn=sqrt(dn^2);
% dn=matlabFunction(dn);
% if norvec(1)~=0 && norvec(2)~=0 && norvec(3)~=0
% Dn=integral3(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(2)~=0
% Dn=dzv(i)*NTG(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0 && norvec(3)~=0
% Dn=dyv(i)*integral2(dn,-dxv(i)/2,dxv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0 && norvec(3)~=0
% Dn=dxv(i)*integral2(dn,-dyv(i)/2,dyv(i)/2,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(1)~=0
% Dn=dyv(i)*dzv(i)*NTG(i)*integral(dn,-dxv(i)/2,dxv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(2)~=0
% Dn=dxv(i)*dzv(i)*NTG(i)*integral(dn,-dyv(i)/2,dyv(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% else if norvec(3)~=0
% Dn=dxv(i)*dyv(i)*integral(dn,-dzv(i)*NTG(i)/2,dzv(i)*NTG(i)/2)/(dxv(i)*dyv(i)*dzv(i)*NTG(i));
% end
% end
% end
% end
% end
% end
% end
% raoT=((Kcell*Annc/(Dn-d2))^(-1)+(K2*Annc/d2)^(-1)+(K1*Annc/d1)^(-1))^(-1);
% Tinterflow=[Tinterflow;raoT];
% end
% end
% end
%% 把上述三种情况的矩阵分别叠加起来
N = [N; Nmff+nmc; Nff+nmc;Ninterflow;];
T = [T; Tmff; Tff;Tinterflow;];
T_convection = [T_convection;Tmff_convection; Tff_convection;Tinterflow_convection;];
nex=size(N,1);
end
generic extended/plotDis_3D_to_2D_1to3.m
+241
View File
@@ -0,0 +1,241 @@
function plotDis_3D_to_2D_1to3(i, r, OutputRs, type)
coordinate=r.coordinates;
nodes=r.nodes;
cell_divided_by_fracture_flag = r.cell_divided_by_fracture_flag;
nmc = size(nodes,1);
% nel = size(nodes,2);
nel = 4;
if type == 1
v = OutputRs{i}.p;
else
v = 1-OutputRs{i}.sw;%含油饱和度
end
number_divided_cells = size(cell_divided_by_fracture_flag,1);
dis = zeros(nel, nmc-number_divided_cells);
x = zeros(nel, nmc-number_divided_cells);
y = zeros(nel, nmc-number_divided_cells);
the_numbering = 0;
for i = 1 :nmc
if ~ismember(i,cell_divided_by_fracture_flag)
the_numbering = the_numbering +1;
for j = 1 :nel
x(j, the_numbering) = coordinate(nodes(i,j), 1);
y(j, the_numbering) = coordinate(nodes(i,j), 2);
if j == 3
x(j, the_numbering) = coordinate(nodes(i,4), 1);
y(j, the_numbering) = coordinate(nodes(i,4), 2);
end
if j == 4
x(j, the_numbering) = coordinate(nodes(i,3), 1);
y(j, the_numbering) = coordinate(nodes(i,3), 2);
end
dis(j, the_numbering) = v(i);
end
end
end
% 被裂缝剖分的网格绘图
nel = 3;
% if type == 1
% v = OutputRs{i}.p;
% else
% v = 1-OutputRs{i}.sw;%含油饱和度
% end
fractureCell_matrixCell_addedMatrixCell = r.fractureCell_matrixCell_addedMatrixCell;
volume_ratio = r.volume_ratio;
number_divided_cells = size(cell_divided_by_fracture_flag,1);
% dis_division = zeros(nel, 2*number_divided_cells);
% x_division = zeros(nel, 2*number_divided_cells);
% y_division = zeros(nel, 2*number_divided_cells);
dis_division_type1 = [];
x_division_type1 = [];
y_division_type1 = [];
nel_type1 = 4;
dis_division_type2 = [];
x_division_type2 = [];
y_division_type2 = [];
nel_type2 = 3;
the_numbering_division = 0;
for i = 1:nmc
if ismember(i,cell_divided_by_fracture_flag)
aaa = find(cell_divided_by_fracture_flag==i);
theVolumeRatio = volume_ratio(aaa);
theMatrixCell = cell_divided_by_fracture_flag(aaa);
bbb = find(fractureCell_matrixCell_addedMatrixCell(:,2) == theMatrixCell);
theAddedMatrixCell = fractureCell_matrixCell_addedMatrixCell(bbb,3);
if theVolumeRatio == 5/6
% % % % 右侧四边形, 添加的基质网格
% % % the_x_division_type1 = [coordinate(nodes(i,1), 1);coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);2/3*coordinate(nodes(i,3), 1)+1/3*coordinate(nodes(i,4), 1)];
% % % x_division_type1 = [x_division_type1, the_x_division_type1];
% % %
% % % the_y_division_type1 = [coordinate(nodes(i,1), 2);coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);2/3*coordinate(nodes(i,3), 2)+1/3*coordinate(nodes(i,4), 2)];
% % % y_division_type1 = [y_division_type1, the_y_division_type1];
% % %
% % % the_dis_division_type1 = v(theAddedMatrixCell)*ones(4,1);
% % % dis_division_type1 = [dis_division_type1, the_dis_division_type1];
% 左侧三角形, 原始基质网格
the_x_division_type2 = [2/3*coordinate(nodes(i,3), 1)+1/3*coordinate(nodes(i,4), 1);coordinate(nodes(i,1), 1);coordinate(nodes(i,3), 1);];
x_division_type2 = [x_division_type2, the_x_division_type2];
the_y_division_type2 = [2/3*coordinate(nodes(i,3), 2)+1/3*coordinate(nodes(i,4), 2);coordinate(nodes(i,1), 2);coordinate(nodes(i,3), 2);];
y_division_type2 = [y_division_type2, the_y_division_type2];
the_dis_division_type2 = v(theMatrixCell)*ones(3,1);
dis_division_type2 = [dis_division_type2, the_dis_division_type2];
end
if theVolumeRatio == 1/2
% % % % 右侧添加的四边形基质网格
% % % the_x_division_type1 = [2/3*coordinate(nodes(i,1), 1)+1/3*coordinate(nodes(i,2), 1);coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);1/3*coordinate(nodes(i,3), 1)+2/3*coordinate(nodes(i,4), 1)];
% % % x_division_type1 = [x_division_type1, the_x_division_type1];
% % %
% % % the_y_division_type1 = [2/3*coordinate(nodes(i,1), 2)+1/3*coordinate(nodes(i,2), 2);coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);1/3*coordinate(nodes(i,3), 2)+2/3*coordinate(nodes(i,4), 2)];
% % % y_division_type1 = [y_division_type1, the_y_division_type1];
% % %
% % % the_dis_division_type1 = v(theAddedMatrixCell)*ones(4,1);
% % % dis_division_type1 = [dis_division_type1, the_dis_division_type1];
% 左侧原始的四边形基质网格
the_x_division_type1 = [2/3*coordinate(nodes(i,1), 1)+1/3*coordinate(nodes(i,2), 1);1/3*coordinate(nodes(i,3), 1)+2/3*coordinate(nodes(i,4), 1); coordinate(nodes(i,3), 1);coordinate(nodes(i,1), 1);];
x_division_type1 = [x_division_type1, the_x_division_type1];
the_y_division_type1 = [2/3*coordinate(nodes(i,1), 2)+1/3*coordinate(nodes(i,2), 2);1/3*coordinate(nodes(i,3), 2)+2/3*coordinate(nodes(i,4), 2); coordinate(nodes(i,3), 2);coordinate(nodes(i,1), 2);];
y_division_type1 = [y_division_type1, the_y_division_type1];
the_dis_division_type1 = v(theMatrixCell)*ones(4,1);
dis_division_type1 = [dis_division_type1, the_dis_division_type1];
end
if theVolumeRatio == 1/6
% 四边形, 左侧原始基质网格
the_x_division_type1 = [coordinate(nodes(i,1), 1);1/3*coordinate(nodes(i,1), 1)+2/3*coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);coordinate(nodes(i,3), 1);];
x_division_type1 = [x_division_type1, the_x_division_type1];
the_y_division_type1 = [coordinate(nodes(i,1), 2);1/3*coordinate(nodes(i,1), 2)+2/3*coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);coordinate(nodes(i,3), 2);];
y_division_type1 = [y_division_type1, the_y_division_type1];
the_dis_division_type1 = v(theMatrixCell)*ones(4,1);
dis_division_type1 = [dis_division_type1, the_dis_division_type1];
% % % % 三角形, 右侧添加的基质网格
% % % the_x_division_type2 = [1/3*coordinate(nodes(i,1), 1)+2/3*coordinate(nodes(i,2), 1); coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);];
% % % x_division_type2 = [x_division_type2, the_x_division_type2];
% % %
% % % the_y_division_type2 = [1/3*coordinate(nodes(i,1), 2)+2/3*coordinate(nodes(i,2), 2); coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);];
% % % y_division_type2 = [y_division_type2, the_y_division_type2];
% % %
% % % the_dis_division_type2 = v(theAddedMatrixCell)*ones(3,1);
% % % dis_division_type2 = [dis_division_type2, the_dis_division_type2];
end
end
end
% fill(x,y,dis,'EdgeAlpha',1);
figure('color','w');
fill(x,y,dis,'EdgeColor','interp');
hold on;
fill(x_division_type2,y_division_type2,dis_division_type2,'EdgeColor','interp');
hold on;
fill(x_division_type1,y_division_type1,dis_division_type1,'EdgeColor','interp');
%
dis_division_type1 = [];
x_division_type1 = [];
y_division_type1 = [];
nel_type1 = 4;
dis_division_type2 = [];
x_division_type2 = [];
y_division_type2 = [];
nel_type2 = 3;
for i = 1:nmc
if ismember(i,cell_divided_by_fracture_flag)
aaa = find(cell_divided_by_fracture_flag==i);
theVolumeRatio = volume_ratio(aaa);
theMatrixCell = cell_divided_by_fracture_flag(aaa);
bbb = find(fractureCell_matrixCell_addedMatrixCell(:,2) == theMatrixCell);
theAddedMatrixCell = fractureCell_matrixCell_addedMatrixCell(bbb,3);
if theVolumeRatio == 5/6
% 右侧四边形, 添加的基质网格
the_x_division_type1 = [coordinate(nodes(i,1), 1);coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);2/3*coordinate(nodes(i,3), 1)+1/3*coordinate(nodes(i,4), 1)];
x_division_type1 = [x_division_type1, the_x_division_type1];
the_y_division_type1 = [coordinate(nodes(i,1), 2);coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);2/3*coordinate(nodes(i,3), 2)+1/3*coordinate(nodes(i,4), 2)];
y_division_type1 = [y_division_type1, the_y_division_type1];
the_dis_division_type1 = v(theAddedMatrixCell)*ones(4,1);
dis_division_type1 = [dis_division_type1, the_dis_division_type1];
% % % % 左侧三角形, 原始基质网格
% % % the_x_division_type2 = [2/3*coordinate(nodes(i,3), 1)+1/3*coordinate(nodes(i,4), 1);coordinate(nodes(i,1), 1);coordinate(nodes(i,3), 1);];
% % % x_division_type2 = [x_division_type2, the_x_division_type2];
% % %
% % % the_y_division_type2 = [2/3*coordinate(nodes(i,3), 2)+1/3*coordinate(nodes(i,4), 2);coordinate(nodes(i,1), 2);coordinate(nodes(i,3), 2);];
% % % y_division_type2 = [y_division_type2, the_y_division_type2];
% % %
% % % the_dis_division_type2 = v(theMatrixCell)*ones(3,1);
% % % dis_division_type2 = [dis_division_type2, the_dis_division_type2];
end
if theVolumeRatio == 1/2
% 右侧添加的四边形基质网格
the_x_division_type1 = [2/3*coordinate(nodes(i,1), 1)+1/3*coordinate(nodes(i,2), 1);coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);1/3*coordinate(nodes(i,3), 1)+2/3*coordinate(nodes(i,4), 1)];
x_division_type1 = [x_division_type1, the_x_division_type1];
the_y_division_type1 = [2/3*coordinate(nodes(i,1), 2)+1/3*coordinate(nodes(i,2), 2);coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);1/3*coordinate(nodes(i,3), 2)+2/3*coordinate(nodes(i,4), 2)];
y_division_type1 = [y_division_type1, the_y_division_type1];
the_dis_division_type1 = v(theAddedMatrixCell)*ones(4,1);
dis_division_type1 = [dis_division_type1, the_dis_division_type1];
% 左侧原始的四边形基质网格
% % % the_x_division_type1 = [2/3*coordinate(nodes(i,1), 1)+1/3*coordinate(nodes(i,2), 1);1/3*coordinate(nodes(i,3), 1)+2/3*coordinate(nodes(i,4), 1); coordinate(nodes(i,3), 1);coordinate(nodes(i,1), 1);];
% % % x_division_type1 = [x_division_type1, the_x_division_type1];
% % %
% % % the_y_division_type1 = [2/3*coordinate(nodes(i,1), 2)+1/3*coordinate(nodes(i,2), 2);1/3*coordinate(nodes(i,3), 2)+2/3*coordinate(nodes(i,4), 2); coordinate(nodes(i,3), 2);coordinate(nodes(i,1), 2);];
% % % y_division_type1 = [y_division_type1, the_y_division_type1];
% % %
% % % the_dis_division_type1 = v(theMatrixCell)*ones(4,1);
% % % dis_division_type1 = [dis_division_type1, the_dis_division_type1];
end
if theVolumeRatio == 1/6
% % % % 四边形, 左侧原始基质网格
% % % the_x_division_type1 = [coordinate(nodes(i,1), 1);1/3*coordinate(nodes(i,1), 1)+2/3*coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);coordinate(nodes(i,3), 1);];
% % % x_division_type1 = [x_division_type1, the_x_division_type1];
% % %
% % % the_y_division_type1 = [coordinate(nodes(i,1), 2);1/3*coordinate(nodes(i,1), 2)+2/3*coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);coordinate(nodes(i,3), 2);];
% % % y_division_type1 = [y_division_type1, the_y_division_type1];
% % %
% % % the_dis_division_type1 = v(theMatrixCell)*ones(4,1);
% % % dis_division_type1 = [dis_division_type1, the_dis_division_type1];
% 三角形, 右侧添加的基质网格
the_x_division_type2 = [1/3*coordinate(nodes(i,1), 1)+2/3*coordinate(nodes(i,2), 1); coordinate(nodes(i,2), 1);coordinate(nodes(i,4), 1);];
x_division_type2 = [x_division_type2, the_x_division_type2];
the_y_division_type2 = [1/3*coordinate(nodes(i,1), 2)+2/3*coordinate(nodes(i,2), 2); coordinate(nodes(i,2), 2);coordinate(nodes(i,4), 2);];
y_division_type2 = [y_division_type2, the_y_division_type2];
the_dis_division_type2 = v(theAddedMatrixCell)*ones(3,1);
dis_division_type2 = [dis_division_type2, the_dis_division_type2];
end
end
end
hold on;
fill(x_division_type2,y_division_type2,dis_division_type2,'EdgeColor','interp');
hold on;
fill(x_division_type1,y_division_type1,dis_division_type1,'EdgeColor','interp');
%
xlabel( 'x, m' );
ylabel( 'y, m' );
axis equal;
axis tight
xlim([0,60]);
ylim([0,60]);
colorbar
colormap jet
if type == 1
caxis([14,43]);
end
% fill(x,y,dis);
% axis off
generic extended/plotDis_3D_to_2D_new.m
+85
View File
@@ -0,0 +1,85 @@
function plotDis_3D_to_2D_new(i, r, OutputRs, type)
coordinate=r.coordinates;
nodes=r.nodes;
cell_divided_by_fracture_flag = r.cell_divided_by_fracture_flag;
nmc = size(nodes,1);
% nel = size(nodes,2);
nel = 4;
if type == 1
v = OutputRs{i}.p;
else
v = 1-OutputRs{i}.sw;%含油饱和度
end
number_divided_cells = size(cell_divided_by_fracture_flag,1);
dis = zeros(nel, nmc-number_divided_cells);
x = zeros(nel, nmc-number_divided_cells);
y = zeros(nel, nmc-number_divided_cells);
the_numbering = 0;
for i = 1 :nmc
if ~ismember(i,cell_divided_by_fracture_flag)
the_numbering = the_numbering +1;
for j = 1 :nel
x(j, the_numbering) = coordinate(nodes(i,j), 1);
y(j, the_numbering) = coordinate(nodes(i,j), 2);
if j == 3
x(j, the_numbering) = coordinate(nodes(i,4), 1);
y(j, the_numbering) = coordinate(nodes(i,4), 2);
end
if j == 4
x(j, the_numbering) = coordinate(nodes(i,3), 1);
y(j, the_numbering) = coordinate(nodes(i,3), 2);
end
dis(j, the_numbering) = v(i);
end
end
end
% 被裂缝剖分的网格绘图
nel = 3;
% if type == 1
% v = OutputRs{i}.p;
% else
% v = 1-OutputRs{i}.sw;%含油饱和度
% end
number_divided_cells = size(cell_divided_by_fracture_flag,1);
dis_division = zeros(nel, 2*number_divided_cells);
x_division = zeros(nel, 2*number_divided_cells);
y_division = zeros(nel, 2*number_divided_cells);
the_numbering_division = 0;
for i = 1 :nmc
if ismember(i,cell_divided_by_fracture_flag)
the_numbering_division = the_numbering_division +2;
% for j = 1 :nel
x_division(1, the_numbering_division-1) = coordinate(nodes(i,1), 1);
y_division(1, the_numbering_division-1) = coordinate(nodes(i,1), 2);
x_division(2, the_numbering_division-1) = coordinate(nodes(i,4), 1);
y_division(2, the_numbering_division-1) = coordinate(nodes(i,4), 2);
x_division(3, the_numbering_division-1) = coordinate(nodes(i,3), 1);
y_division(3, the_numbering_division-1) = coordinate(nodes(i,3), 2);
dis_division(1:3, the_numbering_division-1) = v(i)*ones(3,1);
x_division(1, the_numbering_division) = coordinate(nodes(i,1), 1);
y_division(1, the_numbering_division) = coordinate(nodes(i,1), 2);
x_division(2, the_numbering_division) = coordinate(nodes(i,2), 1);
y_division(2, the_numbering_division) = coordinate(nodes(i,2), 2);
x_division(3, the_numbering_division) = coordinate(nodes(i,4), 1);
y_division(3, the_numbering_division) = coordinate(nodes(i,4), 2);
dis_division(1:3, the_numbering_division) = v(nmc+the_numbering_division/2)*ones(3,1);
% end
end
end
% fill(x,y,dis,'EdgeAlpha',1);
figure('color','w');
fill(x,y,dis,'EdgeColor','interp');
hold on;
fill(x_division,y_division,dis_division,'EdgeColor','interp');
xlabel( 'x, m' );
ylabel( 'y, m' );
axis equal;
axis tight
xlim([0,60]);
ylim([0,60]);
colorbar
colormap jet
% fill(x,y,dis);
% axis off
generic extended/plotDislayer.m
+145
View File
@@ -0,0 +1,145 @@
function plotDislayer(i, k ,r,OutputRs, type)
%i:时间点，k是从上至下数的层位，type: 1是压力场
figure('color','w')
[ downgrid, frontgrid ,leftgrid, rightgrid, backgrid, upgrid ] = preplot_dislayer( r,k );
coordinate=r.coordinates;
nodes=r.nodes;
nx=r.nx;
ny=r.ny;
nz=r.nz;
% order=[1,2,4,3,1,5,6,8,7,3,4,8,6,2,1];%用以fill函数作图
% % nmc = size(nodes,1);%基质网格数量
% nmc = nx*ny;
% % nel = size(nodes,2);%每个基质网格所包含的点数量
% nel=size(order,2);
if type == 1
v = OutputRs{i}.p;
% v = log(r.kx);
elseif type == 2
% v = 1-OutputRs{i}.sw -OutputRs{i}.sg;%含油饱和度
v = 1-OutputRs{i}.sw;%含油饱和度
elseif type == 3
v = OutputRs{i}.sg;%含油饱和度
else
v = OutputRs{i}.sw;%含油饱和度
end
% 底面
order=[1,2,4,3,1];
nel=size(order,2);
nmc=size(downgrid,2);
dis = zeros(nel, nmc);
x = zeros(nel, nmc);
y = zeros(nel, nmc);
z = zeros(nel, nmc);
for i = 1 : nmc
for j = 1 : nel
x(j, i) = coordinate(nodes(downgrid(i),order(j)), 1);
y(j, i) = coordinate(nodes(downgrid(i),order(j)), 2);
z(j, i) = coordinate(nodes(downgrid(i),order(j)), 3);
dis(j, i) = v(downgrid(i));
end
end
fill3(x,y,z,dis,'edgeColor','interp');
hold on
%左面
order=[1,5,7,3,1];
nel=size(order,2);
nmc=size(leftgrid,2);
dis = zeros(nel, nmc);
x = zeros(nel, nmc);
y = zeros(nel, nmc);
z = zeros(nel, nmc);
for i = 1 : nmc
for j = 1 : nel
x(j, i) = coordinate(nodes(leftgrid(i),order(j)), 1);
y(j, i) = coordinate(nodes(leftgrid(i),order(j)), 2);
z(j, i) = coordinate(nodes(leftgrid(i),order(j)), 3);
dis(j, i) = v(leftgrid(i));
end
end
fill3(x,y,z,dis,'edgeColor','interp');
%右面
order=[2,4,8,6,2];
nel=size(order,2);
nmc=size(rightgrid,2);
dis = zeros(nel, nmc);
x = zeros(nel, nmc);
y = zeros(nel, nmc);
z = zeros(nel, nmc);
for i = 1 : nmc
for j = 1 : nel
x(j, i) = coordinate(nodes(rightgrid(i),order(j)), 1);
y(j, i) = coordinate(nodes(rightgrid(i),order(j)), 2);
z(j, i) = coordinate(nodes(rightgrid(i),order(j)), 3);
dis(j, i) = v(rightgrid(i));
end
end
fill3(x,y,z,dis,'edgeColor','interp');
%前面
order=[1,2,6,5,1];
nel=size(order,2);
nmc=size(frontgrid,2);
dis = zeros(nel, nmc);
x = zeros(nel, nmc);
y = zeros(nel, nmc);
z = zeros(nel, nmc);
for i = 1 : nmc
for j = 1 : nel
x(j, i) = coordinate(nodes(frontgrid(i),order(j)), 1);
y(j, i) = coordinate(nodes(frontgrid(i),order(j)), 2);
z(j, i) = coordinate(nodes(frontgrid(i),order(j)), 3);
dis(j, i) = v(frontgrid(i));
end
end
fill3(x,y,z,dis,'edgeColor','interp');
%后面
order=[3,4,8,7,3];
nel=size(order,2);
nmc=size(backgrid,2);
dis = zeros(nel, nmc);
x = zeros(nel, nmc);
y = zeros(nel, nmc);
z = zeros(nel, nmc);
for i = 1 : nmc
for j = 1 : nel
x(j, i) = coordinate(nodes(backgrid(i),order(j)), 1);
y(j, i) = coordinate(nodes(backgrid(i),order(j)), 2);
z(j, i) = coordinate(nodes(backgrid(i),order(j)), 3);
dis(j, i) = v(backgrid(i));
end
end
fill3(x,y,z,dis,'edgeColor','interp');
%上面
order=[5,6,8,7,5];
nel=size(order,2);
nmc=size(upgrid,2);
dis = zeros(nel, nmc);
x = zeros(nel, nmc);
y = zeros(nel, nmc);
z = zeros(nel, nmc);
for i = 1 : nmc
for j = 1 : nel
x(j, i) = coordinate(nodes(upgrid(i),order(j)), 1);
y(j, i) = coordinate(nodes(upgrid(i),order(j)), 2);
z(j, i) = coordinate(nodes(upgrid(i),order(j)), 3);
dis(j, i) = v(upgrid(i));
end
end
fill3(x,y,z,dis,'edgeColor','interp');
set(gca,'FontName','Times New Roman','FontSize',10,'FontWeight','bold');
xlabel('x, m');
ylabel('y, m');
zlabel('z, m');
view(2);
% fill(x,y,dis);
axis equal
% axis off
axis tight
colormap jet
colorbar
% caxis([0.2,0.8]);
generic extended/plotWellResponse.m
+15
View File
@@ -0,0 +1,15 @@
figure('color','w');
plot(wellResponseData(1:105,1),wellResponseData(1:105,2),'rs-','markersize',6);
hold on;
plot(wellResponseData(1:105,3),wellResponseData(1:105,4),'bo-','markersize',6);
hold on;
plot(wellResponseData(1:104,5),wellResponseData(1:104,6),'k^-','markersize',6);
hold on;
plot(wellResponseData(1:104,7),wellResponseData(1:104,8),'gv-','markersize',6);
hold on;
plot(wellResponseData(1:104,9),wellResponseData(1:104,10),'k-','markersize',6);
hold off;
xlabel('time, days');
ylabel('water cut of the porduction well, fraction');
ylabel('BHP of the injection well, MPa');
legend('EDFM', 'pEDFM-discontinuous', 'pEDFM-continuous','proposed pEDFM workflow','reference solution');% ,'pEDFM, case 3'
generic extended/plot_Newtons.m
+13
View File
@@ -0,0 +1,13 @@
figure('color','w');
plot(Newtons(1:120,1),Newtons(1:120,2),'k^-');
hold on;
plot(Newtons(1:123,3),Newtons(1:123,4),'rs-');
hold on;
plot(Newtons(1:121,5),Newtons(1:121,6),'bo-');
hold on;
plot(Newtons(1:121,7),Newtons(1:121,8),'gv-');
hold off;
xlabel('time, days');
ylabel('cumulative Newton iteration steps');
legend('EDFM', 'pEDFM, method 1', 'pEDFM, method 2','pEDFM, method 3');% ,'pEDFM, case 3'
generic extended/plot_continuous.m
+116
View File
@@ -0,0 +1,116 @@
dx=[0.5*ones(1,120) ];
dy=[0.5*ones(1,120) ];
dz=[2*ones(1,1)];
nx=size(dx,2);
ny=size(dy,2);
nz=size(dz,2);
x_size = 60;
y_size = 60;
coordinates_pre = zeros(nx*ny*nz,2);
select_t = 120;
for k = 1:nz
for j = 1:ny
for i = 1:nx
if i == 1
coordinates_pre(i+(j-1)*nx+(k-1)*nx*ny,1) = sum(dx(1:1),2)/2;
else
coordinates_pre(i+(j-1)*nx+(k-1)*nx*ny,1) = (sum(dx(1:i-1),2)+sum(dx(1:i),2))/2;
end
if j == 1
coordinates_pre(i+(j-1)*nx+(k-1)*nx*ny,2) = sum(dy(1:1),2)/2;
else
coordinates_pre(i+(j-1)*nx+(k-1)*nx*ny,2) = (sum(dy(1:j-1),2)+sum(dy(1:j),2))/2;
end
% if k == 1
% coordinates_pre(i+(j-1)*nx+(k-1)*nx*ny,3) = sum(dz(1:1),2)/2;
% else
% coordinates_pre(i+(j-1)*nx+(k-1)*nx*ny,3) = (sum(dz(1:k-1),2)+sum(dz(1:k),2))/2;
% end
end
end
end
% select_t = 508;
zData = OutputRs{select_t, 1}.p(1:nx*ny*nz,1);
zData1 = 1-OutputRs{select_t, 1}.sw(1:nx*ny*nz,1);
xData = coordinates_pre(:,1);
yData = coordinates_pre(:,2);
% zData = DATA_plot(:,21);
% zData1 = DATA_plot(:,22);
% minx = min(xData);
% maxx = max(xData);
% miny = min(yData);
% maxy = max(yData);
minx = 0;
maxx = x_size;
miny = 0;
maxy = y_size;
tx = (minx:0.05:maxx)';
ty = (miny:0.05:maxy)';
[XI,YI] = meshgrid(tx,ty);
% 非画图区域标记
% 计算域多边形刻画
% Comput_domain_x = [0 40 200 160 200 40 0];
% Comput_domain_y = [40 80 80 40 0 0 40];
Comput_domain_x = [0 x_size x_size 0 0];
Comput_domain_y = [0 0 y_size y_size 0];
% load('coordinates_boundary_node_order.mat');
% coordinates_boundary_node_order(:,1) = coordinates_boundary_node_order(:,1) + 200;
% coordinates_boundary_node_order(:,2) = coordinates_boundary_node_order(:,2) + 130;
% Comput_domain_x = coordinates_boundary_node_order(:,1);
% Comput_domain_y = coordinates_boundary_node_order(:,2);
%
NX = size(XI,1);
NY = size(YI,1);
% for i = 1:NX
% for j = 1:NY
% in=inpolygon(XI,YI,Comput_domain_x,Comput_domain_x);
% end
% end
in=inpolygon(XI,YI,Comput_domain_x',Comput_domain_y');
XI(~in) = nan; YI(~in) = nan;
% for i = 1:NX
% for j = 1:NY
% in=inpolygon(XI(i,j),YI(i,j),Comput_domain_x',Comput_domain_y');
% if ~in XI(i,j) = nan; YI(i,j) = nan; end
% end
% end
ZI = griddata(xData,yData,zData,XI,YI);
ZII = griddata(xData,yData,zData1,XI,YI);
figure('color','w');surf(XI,YI,ZI), hold
% plot3(xData,yData,zData,'o'), hold off
grid off
set(gca,'FontName','Times New Roman','FontSize',10,'FontWeight','bold');
xlabel( 'x, m' );
ylabel( 'y, m' );
zlabel( 'z, m' );
% grid on
view( 0, 90 );
axis equal;
xlim([0,60]);
ylim([0,60]);
colorbar
colormap jet
% caxis([10,15]);
hold off
shading interp
% set('edgecolor','none')
figure('color','w');surf(XI,YI,ZII), hold
% plot3(xData,yData,zData1,'o'), hold off
set(gca,'FontName','Times New Roman','FontSize',10,'FontWeight','bold');
xlabel( 'x, m' );
ylabel( 'y, m' );
zlabel( 'z, m' );
view( 0, 90 );
axis equal;
xlim([0,60]);
ylim([0,60]);
grid off
colorbar
colormap jet
caxis([0.2,0.8]);
hold off
shading interp
generic extended/plotfigures.m
+42
View File
@@ -0,0 +1,42 @@
numberMatrixCells = 120*120;
% % % resultsSaturation1to2 = zeros(numberMatrixCells,5);
% % % resultsPressure1to2 = zeros(numberMatrixCells,5);
% % %
% % % load('resultsEDFM.mat')
% % % theMaxNumber = size(OutputRs,1);
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 2);saveas(gcf, 'EDFM_saturation.fig');
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 1);saveas(gcf, 'EDFM_pressure.fig');
% % % resultsSaturation1to2(:,1) = OutputRs{theMaxNumber,1}.sw(1:numberMatrixCells,1);
% % % resultsPressure1to2(:,1) = OutputRs{theMaxNumber,1}.p(1:numberMatrixCells,1);
% % %
% % % load('resultsPEDFM_method1.mat')
% % % theMaxNumber = size(OutputRs,1);
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 2);saveas(gcf, 'pEDFM_method1_saturation.fig');
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 1);saveas(gcf, 'pEDFM_method1_pressure.fig');
% % % resultsSaturation1to2(:,2) = OutputRs{theMaxNumber,1}.sw(1:numberMatrixCells,1);
% % % resultsPressure1to2(:,2) = OutputRs{theMaxNumber,1}.p(1:numberMatrixCells,1);
% % %
% % % load('resultsPEDFM_method2.mat')
% % % theMaxNumber = size(OutputRs,1);
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 2);saveas(gcf, 'pEDFM_method2_saturation.fig');
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 1);saveas(gcf, 'pEDFM_method2_pressure.fig');
% % % resultsSaturation1to2(:,3) = OutputRs{theMaxNumber,1}.sw(1:numberMatrixCells,1);
% % % resultsPressure1to2(:,3) = OutputRs{theMaxNumber,1}.p(1:numberMatrixCells,1);
% % %
% % % load('resultsNewPEDFM.mat')
% % % theMaxNumber = size(OutputRs,1);
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 2);saveas(gcf, 'NewPEDFM_saturation.fig');
% % % plotDis_3D_to_2D(theMaxNumber, r, OutputRs, 1);saveas(gcf, 'NewPEDFM_pressure.fig');
% % % resultsSaturation1to2(:,4) = OutputRs{theMaxNumber,1}.sw(1:numberMatrixCells,1);
% % % resultsPressure1to2(:,4) = OutputRs{theMaxNumber,1}.p(1:numberMatrixCells,1);
load('resultsReference.mat')
theMaxNumber = size(OutputRs,1);
plotDis_3D_to_2D_1to2(theMaxNumber, r, OutputRs, 2);saveas(gcf, 'reference_saturation.fig');
plotDis_3D_to_2D_1to2(theMaxNumber, r, OutputRs, 1);saveas(gcf, 'reference_pressure.fig');
% % % resultsSaturation1to2(:,5) = OutputRs{theMaxNumber,1}.sw(1:numberMatrixCells,1);
% % % resultsPressure1to2(:,5) = OutputRs{theMaxNumber,1}.p(1:numberMatrixCells,1);
% save resultsSaturation1to2 resultsSaturation1to2;
% save resultsPressure1to2 resultsPressure1to2
generic extended/plotwell.m
+14
View File
@@ -0,0 +1,14 @@
t = Times;
n=size(Times,1);
% para = cell2mat(Wellpara);
nw=1;%Ñ¡¾®ºÅ
% n = length(para);
bhp = zeros(n,1);
for i = 1 : n
% bhp(i) = para(i).bhp(2);
% bhp(i) = Wellpara{i,1}{1,nw}.pwf;
bhp(i) = Wellpara{i}{1,nw}.qo;
% bhp(i) = Wellpara{i}{1,nw}.pwf;
end
plot(t,bhp,'b*-')
hold on