OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
fvmesh.F File Reference
#include "implicit_f.inc"
#include "units_c.inc"
#include "sysunit.inc"

Go to the source code of this file.

Functions/Subroutines

subroutine fvmesh1 (ibuf, elem, x, ivolu, bric, xb, rvolu, nel, neli, nbric, tbric, sfac, dxm, nba, nela, tba, tfaca, tagels, ibufa, elema, tagela, ixs, id, titr, nb_node, ityp)
subroutine coorloc (vpx, vpy, vpz, v1x, v1y, v1z, v2x, v2y, v2z, ksi, eta)
subroutine fvdim (t_monvol)
subroutine fvdeal ()

Function/Subroutine Documentation

◆ coorloc()

subroutine coorloc ( vpx,
vpy,
vpz,
v1x,
v1y,
v1z,
v2x,
v2y,
v2z,
ksi,
eta )

Definition at line 3415 of file fvmesh.F.

3418C-----------------------------------------------
3419C I m p l i c i t T y p e s
3420C-----------------------------------------------
3421#include "implicit_f.inc"
3422C-----------------------------------------------
3423C D u m m y A r g u m e n t s
3424C-----------------------------------------------
3425 my_real
3426 . vpx, vpy, vpz, v1x, v1y,
3427 . v1z, v2x, v2y, v2z, ksi,
3428 . eta
3429C-----------------------------------------------
3430C L o c a l V a r i a b l e s
3431C-----------------------------------------------
3432 my_real
3433 . sp1, sp2, s11, s22, s12, d
3434C
3435 sp1=vpx*v1x+vpy*v1y+vpz*v1z
3436 sp2=vpx*v2x+vpy*v2y+vpz*v2z
3437 s11=v1x*v1x+v1y*v1y+v1z*v1z
3438 s22=v2x*v2x+v2y*v2y+v2z*v2z
3439 s12=v1x*v2x+v1y*v2y+v1z*v2z
3440C
3441 d=s11*s22-s12*s12
3442C
3443 ksi=(sp1*s22-sp2*s12)/d
3444 eta=(sp2*s11-sp1*s12)/d
3445C
3446 RETURN
my_real
#define my_real
Definition cppsort.cpp:32

◆ fvdeal()

subroutine fvdeal

Definition at line 3499 of file fvmesh.F.

3500C-----------------------------------------------
3501C M o d u l e s
3502C-----------------------------------------------
3503 USE fvbag_mod
3504C-----------------------------------------------
3505C I m p l i c i t T y p e s
3506C-----------------------------------------------
3507#include "implicit_f.inc"
3508C-----------------------------------------------
3509C C o m m o n B l o c k s
3510C-----------------------------------------------
3511C-----------------------------------------------
3512C L o c a l V a r i a b l e s
3513C-----------------------------------------------
3514 INTEGER I
3515C
3516 IF (ALLOCATED(fvdata)) THEN
3517 DO i=1,nfvbag
3518 IF (ASSOCIATED(fvdata(i)%IFVNOD)) DEALLOCATE(fvdata(i)%IFVNOD)
3519 IF (ASSOCIATED(fvdata(i)%RFVNOD)) DEALLOCATE(fvdata(i)%RFVNOD)
3520 IF (ASSOCIATED(fvdata(i)%IFVTRI)) DEALLOCATE(fvdata(i)%IFVTRI)
3521 IF (ASSOCIATED(fvdata(i)%IFVPOLY)) DEALLOCATE(fvdata(i)%IFVPOLY)
3522 IF (ASSOCIATED(fvdata(i)%IFVTADR)) DEALLOCATE(fvdata(i)%IFVTADR)
3523 IF (ASSOCIATED(fvdata(i)%IFVPOLH)) DEALLOCATE(fvdata(i)%IFVPOLH)
3524 IF (ASSOCIATED(fvdata(i)%IFVPADR)) DEALLOCATE(fvdata(i)%IFVPADR)
3525 IF (ASSOCIATED(fvdata(i)%IDPOLH)) DEALLOCATE(fvdata(i)%IDPOLH)
3526 IF (ASSOCIATED(fvdata(i)%IBPOLH)) DEALLOCATE(fvdata(i)%IBPOLH)
3527 IF (ASSOCIATED(fvdata(i)%IFVPOLY_ANIM)) DEALLOCATE(fvdata(i)%IFVPOLY_ANIM)
3528 IF (ASSOCIATED(fvdata(i)%IFVTADR_ANIM)) DEALLOCATE(fvdata(i)%IFVTADR_ANIM)
3529 IF (ASSOCIATED(fvdata(i)%IFVPOLH_ANIM)) DEALLOCATE(fvdata(i)%IFVPOLH_ANIM)
3530 IF (ASSOCIATED(fvdata(i)%IFVPADR_ANIM)) DEALLOCATE(fvdata(i)%IFVPADR_ANIM)
3531 IF (ASSOCIATED(fvdata(i)%REDIR_ANIM)) DEALLOCATE(fvdata(i)%REDIR_ANIM)
3532 IF (ASSOCIATED(fvdata(i)%NOD_ANIM)) DEALLOCATE(fvdata(i)%NOD_ANIM)
3533 IF (ASSOCIATED(fvdata(i)%MPOLH)) DEALLOCATE(fvdata(i)%MPOLH)
3534 IF (ASSOCIATED(fvdata(i)%QPOLH)) DEALLOCATE(fvdata(i)%QPOLH)
3535 IF (ASSOCIATED(fvdata(i)%EPOLH)) DEALLOCATE(fvdata(i)%EPOLH)
3536 IF (ASSOCIATED(fvdata(i)%PPOLH)) DEALLOCATE(fvdata(i)%PPOLH)
3537 IF (ASSOCIATED(fvdata(i)%RPOLH)) DEALLOCATE(fvdata(i)%RPOLH)
3538 IF (ASSOCIATED(fvdata(i)%GPOLH)) DEALLOCATE(fvdata(i)%GPOLH)
3539 IF (ASSOCIATED(fvdata(i)%CPAPOLH)) DEALLOCATE(fvdata(i)%CPAPOLH)
3540 IF (ASSOCIATED(fvdata(i)%CPBPOLH)) DEALLOCATE(fvdata(i)%CPBPOLH)
3541 IF (ASSOCIATED(fvdata(i)%CPCPOLH)) DEALLOCATE(fvdata(i)%CPCPOLH)
3542 IF (ASSOCIATED(fvdata(i)%RMWPOLH)) DEALLOCATE(fvdata(i)%RMWPOLH)
3543 IF (ASSOCIATED(fvdata(i)%VPOLH_INI)) DEALLOCATE(fvdata(i)%VPOLH_INI)
3544 IF (ASSOCIATED(fvdata(i)%DTPOLH)) DEALLOCATE(fvdata(i)%DTPOLH)
3545C
3546 IF (ASSOCIATED(fvdata(i)%BRIC)) DEALLOCATE(fvdata(i)%BRIC)
3547 IF (ASSOCIATED(fvdata(i)%TBRIC)) DEALLOCATE(fvdata(i)%TBRIC)
3548 IF (ASSOCIATED(fvdata(i)%XB)) DEALLOCATE(fvdata(i)%XB)
3549 IF (ASSOCIATED(fvdata(i)%SFAC)) DEALLOCATE(fvdata(i)%SFAC)
3550C
3551 IF (ASSOCIATED(fvdata(i)%TPOLH)) DEALLOCATE(fvdata(i)%TPOLH)
3552 IF (ASSOCIATED(fvdata(i)%CPDPOLH)) DEALLOCATE(fvdata(i)%CPDPOLH)
3553 IF (ASSOCIATED(fvdata(i)%CPEPOLH)) DEALLOCATE(fvdata(i)%CPEPOLH)
3554 IF (ASSOCIATED(fvdata(i)%CPFPOLH)) DEALLOCATE(fvdata(i)%CPFPOLH)
3555 ENDDO
3556 DEALLOCATE(fvdata)
3557 ENDIF
3558C
3559 IF (ALLOCATED(fvspmd)) THEN
3560 DO i=1,nfvbag
3561 IF (ASSOCIATED(fvspmd(i)%IBUF_L)) DEALLOCATE(fvspmd(i)%IBUF_L)
3562 IF (ASSOCIATED(fvspmd(i)%IBUFA_L)) DEALLOCATE(fvspmd(i)%IBUFA_L)
3563 IF (ASSOCIATED(fvspmd(i)%IBUFSA_L)) DEALLOCATE(fvspmd(i)%IBUFSA_L)
3564 IF (ASSOCIATED(fvspmd(i)%IXSA)) DEALLOCATE(fvspmd(i)%IXSA)
3565 IF (ASSOCIATED(fvspmd(i)%ELEMSA)) DEALLOCATE(fvspmd(i)%ELEMSA)
3566 ENDDO
3567 DEALLOCATE(fvspmd)
3568 ENDIF
3569C
3570 RETURN
fvbag_mod
Definition fvbag_mod.F:44
fvbag_mod::fvspmd
type(fvbag_spmd), dimension(:), allocatable fvspmd
Definition fvbag_mod.F:129
fvbag_mod::fvdata
type(fvbag_data), dimension(:), allocatable fvdata
Definition fvbag_mod.F:128
fvbag_mod::nfvbag
integer nfvbag
Definition fvbag_mod.F:127

◆ fvdim()

subroutine fvdim ( type(monvol_struct_), dimension(nvolu), intent(inout) t_monvol)

Definition at line 3456 of file fvmesh.F.

3457C-----------------------------------------------
3458C M o d u l e s
3459C-----------------------------------------------
3460 USE fvbag_mod
3461 USE monvol_struct_mod
3462C-----------------------------------------------
3463C I m p l i c i t T y p e s
3464C-----------------------------------------------
3465#include "implicit_f.inc"
3466C-----------------------------------------------
3467C C o m m o n B l o c k s
3468C-----------------------------------------------
3469#include "com04_c.inc"
3470C-----------------------------------------------
3471C D u m m y A r g u m e n t s
3472C-----------------------------------------------
3473 TYPE(MONVOL_STRUCT_), DIMENSION(NVOLU), INTENT(INOUT) :: T_MONVOL
3474C-----------------------------------------------
3475C L o c a l V a r i a b l e s
3476C-----------------------------------------------
3477 INTEGER N, ITYP
3478C
3479 ALLOCATE(fvid(nvolu))
3480 fvid(:) = -1
3481 nfvbag=0
3482 DO n = 1, nvolu
3483 ityp = t_monvol(n)%TYPE
3484 IF (ityp == 6 .OR. ityp == 8) THEN
3485 nfvbag = nfvbag+1
3486 t_monvol(n)%IVOLU(45) = nfvbag
3487 t_monvol(n)%IVOLU(57) = 0
3488 fvid(nfvbag) = n
3489 ENDIF
3490 ENDDO
3491C
3492 RETURN
fvbag_mod::fvid
integer, dimension(:), allocatable fvid
Definition fvbag_mod.F:130
monvol_struct_mod
Definition monvol_struct_mod.F:66

◆ fvmesh1()

subroutine fvmesh1 ( integer, dimension(*) ibuf,
integer, dimension(3,*) elem,
x,
integer, dimension(*) ivolu,
integer, dimension(8,*) bric,
xb,
rvolu,
integer nel,
integer neli,
integer nbric,
integer, dimension(13,*) tbric,
sfac,
dxm,
integer nba,
integer nela,
integer, dimension(2,*) tba,
integer, dimension(12,*) tfaca,
integer, dimension(*) tagels,
integer, dimension(*) ibufa,
integer, dimension(3,*) elema,
integer, dimension(*) tagela,
integer, dimension(nixs,*) ixs,
integer id,
character(len=nchartitle) titr,
integer nb_node,
integer ityp )

Definition at line 48 of file fvmesh.F.

53C-----------------------------------------------
54C M o d u l e s
55C-----------------------------------------------
56 USE message_mod
57 USE fvbag_mod
58 USE reorder_mod
59 USE names_and_titles_mod , ONLY : nchartitle
60 USE fvbag_gpolcut_mod, ONLY : fvbag_gpolcut
61C-----------------------------------------------
62C I m p l i c i t T y p e s
63C-----------------------------------------------
64#include "implicit_f.inc"
65C-----------------------------------------------
66C C o m m o n B l o c k s
67C-----------------------------------------------
68#include "units_c.inc"
69#include "sysunit.inc"
70C-----------------------------------------------
71C D u m m y A r g u m e n t s
72C-----------------------------------------------
73 INTEGER IBUF(*), ELEM(3,*), IVOLU(*), BRIC(8,*),
74 . NEL, NELI, NBRIC, TBRIC(13,*), NBA, NELA, TBA(2,*),
75 . TFACA(12,*), TAGELS(*), IBUFA(*), ELEMA(3,*), TAGELA(*),
76 . IXS(NIXS,*), NB_NODE, ITYP
77 my_real x(3,*), xb(3,*), rvolu(*), sfac(6,4,*), dxm
78 INTEGER ID
79 CHARACTER(len=nchartitle) :: TITR
80C-----------------------------------------------
81C L o c a l V a r i a b l e s
82C-----------------------------------------------
83 INTEGER ILVOUT, NLAYER, NFACMAX, NPPMAX, I, J, IEL, N1, N2, N3,
84 . NN1, NN2, NN3, IAD, NPOLY, NNS, ITAGB(NBRIC),
85 . NVMAX, INFO, ICUT, NVERTS, NF1, NF2, NF3, NF4, NS,
86 . NSMAX, NV, K, KK, NNP, NPOLMAX, NRPMAX, N, M, MM, NPOLH,
87 . NPOLB, ITY, NN, NPHMAX, NPOLHMAX, JJ, JJJ, II,
88 . NNS_OLD, NNP_OLD, NPA, JMAX, IMAX, JJMAX, NP, NNTR,
89 . NPOLY_OLD, IPSURF, IC1, IC2, NHOL, NELP, NPOLH_OLD,
90 . L, LL, IFV, NNS2, NPOLY2, NPL, POLC, NSPOLY, NCPOLY,
91 . NPOLHF, LENP, LENH, IP, LENIMAX,
92 . LENRMAX, KKK, NSEG, IMIN, NFAC, N4, NN4,
93 . ITAGBA(NBA), IBSA(NBA), ITAGN(NB_NODE), NALL,
94 . NNS_ANIM, NBZ, NBNEDGE, NNS3, NPOLY_NEW, NNSP, NEDGE,
95 . ITYZ, INZ, J0, NNS1, K0, I1, I2, IDEP, NSTR, NCTR, IIZ,
96 . NNS_OLD_SAVE,ITYZINT,IAD1, IAD2, ITMP1
97 INTEGER, DIMENSION(:), ALLOCATABLE :: IFLAG
98 parameter(nvmax=12)
99 my_real x1, y1, z1, x2, y2, z2, x3, y3, z3, x12, y12, z12,
100 . x13, y13, z13, nrx, nry, nrz, area2, elarea(nel+neli),
101 . norm(3,nel+neli), xbmax, ybmax, zbmax, xbmin, ybmin, zbmin,
102 . xc, yc, zc, xx, yy, zz, pp(3,3), xl7(3), bcenter(3),
103 . bhalfsize(3), xtmax, ytmax, ztmax, xtmin, ytmin, ztmin,
104 . tverts(9), tmptri(3,3), tmpbox(3,8), tmpnorm(3,6), tole,
105 . xg, yg, zg, fv0(3), fv1(3), fv2(3), fu0(3), fu1(3),
106 . fu2(3), quad(3,4), nr(3), area, nx, ny, nz, nnx,
107 . nny, nnz, x0, y0, z0, lmax2, tole2, dd, vm, volumin,
108 . areamax, volph, areap, areael, vpx, vpy, vpz,
109 . v1x, v1y, v1z, v2x, v2y, v2z, nrm1, vx, vy, vz, ss,
110 . normf(3,4), ksi, eta, vx1, vy1, vz1, vx2, vy2, vz2,
111 . vmin, x4, y4, z4, norma(3,nela),
112 . dd2, xn(3), zlmin, zlmax, zl, vnorm, vx3, vy3, vz3, lz,
113 . dz, alpha, gamai, cpai, cpbi, cpci, rmwi, pini, ti, cpi,
114 . cvi, rhoi, zl1, zl2, zl3, zlc, val, tmass,
115 . ti2, cpdi, cpei, cpfi, r1
116 INTEGER :: COUNT_ELEM_INT, COUNT_ELEM_EXT, COUNT_TRIA_INTERNE
117 INTEGER :: COUNT_ELEM_INT_OLD, COUNT_ELEM_EXT_OLD, COUNT_TRIA_INTERNE_OLD
118 INTEGER, ALLOCATABLE :: FACET(:,:), IPOLY(:,:),
119 . IELNOD(:,:), POLH(:,:), IPOLY_F(:,:),
120 . POLH_F(:,:), IFVNOD(:), IFVNOD_OLD(:),
121 . REDIR_POLY(:), PSEG(:,:), REDIR(:),
122 . PTRI(:,:), REDIR_POLH(:), POLB(:),
123 . IPOLY_OLD(:), POLH_NEW(:,:), ITAGT(:),
124 . TRI(:,:), ADR(:), ADR_OLD(:), IMERGED(:),
125 . IPOLY_F_OLD(:,:), INEDGE(:,:), NREF(:,:),
126 . IZ(:,:), LEDGE(:), IFVNOD2(:,:)
127 my_real, ALLOCATABLE :: normt(:,:), poly(:,:), rpoly(:,:),
128 . rpoly_f(:,:), volu(:), pnodes(:,:),
129 . pholes(:,:), rpoly_old(:),
130 . volu_old(:), rpoly_f_old(:,:),
131 . rnedge(:,:),
132 . aref(:,:), rfvnod2(:,:), xns(:,:),
133 . xns2(:,:), areatr(:)
134
135 INTEGER FAC(4,6), FACNOR(4,6), FAC4(3,4), FAC6(4,5)
136 INTEGER FAC5(4,5), NFACE(4), NTYPE, IQUAD
137 DATA fac /1,4,3,2,
138 . 5,6,7,8,
139 . 1,2,6,5,
140 . 2,3,7,6,
141 . 3,4,8,7,
142 . 4,1,5,8/
143 DATA facnor /3,4,5,6,
144 . 3,4,5,6,
145 . 1,4,2,6,
146 . 1,5,2,3,
147 . 1,6,2,4,
148 . 1,3,2,5/
149 DATA fac4 /1,5,3,
150 . 3,5,6,
151 . 6,5,1,
152 . 1,3,6/
153 DATA fac6 /1,3,2,0,
154 . 5,6,7,0,
155 . 1,2,6,5,
156 . 2,3,7,6,
157 . 3,4,8,7/
158 DATA fac5 /1,2,5,0,
159 . 2,3,5,0,
160 . 3,4,5,0,
161 . 4,1,5,0,
162 . 1,4,3,2/
163 DATA nface/6,4,5,5/
164C-------------------------
165C liste chainee polygones
166 TYPE polygone
167 INTEGER IZ(3), NNSP
168 INTEGER, DIMENSION(:), POINTER :: IPOLY, IELNOD
169 INTEGER, DIMENSION(:,:), POINTER :: NREF
170 my_real, DIMENSION(:), POINTER :: rpoly
171 my_real, DIMENSION(:,:), POINTER :: aref
172 TYPE(POLYGONE), POINTER :: PTR
173 END TYPE polygone
174 TYPE(POLYGONE), POINTER :: FIRST, PTR_PREC, PTR_CUR, PTR_TMP,
175 . PTR_OLD, FIRST2, PTR_CUR2, PTR_PREC2,
176 . PTR_TMP2
177 TYPE(POLYGONE), TARGET :: NOTHING
178C liste chainee polyedres
179 TYPE polyhedre
180 INTEGER RANK
181 INTEGER, DIMENSION(:), POINTER :: POLH
182 TYPE(POLYHEDRE), POINTER :: PTR
183 END TYPE polyhedre
184 TYPE(POLYHEDRE), POINTER :: PHFIRST, PH_PREC, PH_CUR, PH_TMP
185
186 my_real, DIMENSION(:), ALLOCATABLE :: radius
187 INTEGER, DIMENSION(:), ALLOCATABLE :: IDX
188C
189C Structure de donnees maillage volumes finis
190C - NNS : Nombre de nouveaux noeuds ( = IVOLU(46) )
191C - NNTR : Nombre de nouveaux triangles ( = IVOLU(47) )
192C - NPOLY : Nombre de polygones ( = IVOLU(48) )
193C - NPOLH : Nombre de polyedres ( volumes finis) ( = IVOLU(49) )
194C
195C - IFVNOD(NNS) : Triangle airbag de reference pour le nouveau noeud
196C - RFVNOD(2,NNS) : Coordonnees locales du noeud dans le triangle
197C
198C - IFVTRI(6,NNTR) : Connectivite nouveaux triangles (1->3)
199C Element de reference si appuye sur surface (4)
200C Polyedres connectes si interne (5->6)
201C
202C - IFVPOLY(NNTR) : Attribution triangles-polygones
203C - IFVTADR(NPOLY+1) : Adresses dans le tableau precedent
204C
205C - IFVPOLH(NPOLY) : Attribution polygones-polyedres
206C - IFVPADR(NPOLH+1) : Adresses dans le tableau precedent
207C
208C
209 nothing%PTR => nothing
210 ptr_prec => nothing
211 iquad = 0
212 n4 = 0
213 nx = 0
214 ny = 0
215 nz = 0
216 ipsurf = 0
217 NULLIFY(first)
218 NULLIFY(phfirst)
219 NULLIFY(ptr_cur)
220C
221 ilvout=ivolu(44)
222 IF (ilvout >=1.AND.nba == 0) WRITE(istdo,'(A19,I10)')
223 . ' --> FVMBAG ID: ',ivolu(1)
224C
225 nlayer=ivolu(40)
226 nfacmax=ivolu(41)
227 nppmax=ivolu(42)
228C
229 DO i=1,nbric
230 tbric(7,i)=0
231 DO j=1,6
232 tbric(7+j,i)=0
233 ENDDO
234 ENDDO
235C---------------------------------------------------
236C Normales elementaires
237C---------------------------------------------------
238 DO iel=1,nel+neli
239 n1=elem(1,iel)
240 n2=elem(2,iel)
241 n3=elem(3,iel)
242 nn1=ibuf(n1)
243 nn2=ibuf(n2)
244 nn3=ibuf(n3)
245 CALL fvnormal(x,nn1,nn2,nn3,0,nrx,nry,nrz)
246 area2=sqrt(nrx**2+nry**2+nrz**2)
247 elarea(iel)=half*area2
248 norm(1,iel)=nrx/area2
249 norm(2,iel)=nry/area2
250 norm(3,iel)=nrz/area2
251 ENDDO
252C
253 DO iel=1,nela
254 n1=elema(1,iel)
255 n2=elema(2,iel)
256 n3=elema(3,iel)
257 IF (tagela(iel) > 0) THEN
258 nn1=ibuf(n1)
259 nn2=ibuf(n2)
260 nn3=ibuf(n3)
261 ELSEIF (tagela(iel) < 0) THEN
262 nn1=ibufa(n1)
263 nn2=ibufa(n2)
264 nn3=ibufa(n3)
265 ENDIF
266 CALL fvnormal(x,nn1,nn2,nn3,0,nrx,nry,nrz)
267 area2=sqrt(nrx**2+nry**2+nrz**2)
268 norma(1,iel)=nrx/area2
269 norma(2,iel)=nry/area2
270 norma(3,iel)=nrz/area2
271 ENDDO
272C---------------------------------------------------
273C Creation de tous les polygones
274C---------------------------------------------------
275 npoly=0
276 nns=0
277 npoly2=0
278 nns2=0
279 IF (nela == 0) THEN
280 npoly=0
281 npolh=0
282 GOTO 370
283 ENDIF
284C
285 DO i=1,nbric
286 itagb(i)=0
287 ENDDO
288C 1. Facettes airbag coupees
289C nullify sinon test sur associated vrai second appel fvmesh1
290 NULLIFY(first2)
291 IF (ilvout >=1) WRITE(istdo,'(8X,A)') 'BUILDING POLYGONS'
292C
293 DO i=1,nbric
294 !IF (ILVOUT >=1) CALL PROGALE_C(I, NBRIC, 1) !dynamic screen output
295C
296 ptr_old => ptr_cur
297 npoly_old=npoly
298 nns_old=nns
299 100 CONTINUE
300C
301 ALLOCATE(facet(6,1+nfacmax), tri(nfacmax,5),
302 . normt(3,nfacmax), poly(3,nvmax))
303 DO j=1,6
304 facet(j,1)=0
305 ENDDO
306C
307 xbmax=-ep30
308 ybmax=-ep30
309 zbmax=-ep30
310 xbmin=ep30
311 ybmin=ep30
312 zbmin=ep30
313 xc=zero
314 yc=zero
315 zc=zero
316 DO j=1,8
317 xx=xb(1,bric(j,i))
318 yy=xb(2,bric(j,i))
319 zz=xb(3,bric(j,i))
320 xbmax=max(xbmax,xx)
321 ybmax=max(ybmax,yy)
322 zbmax=max(zbmax,zz)
323 xbmin=min(xbmin,xx)
324 ybmin=min(ybmin,yy)
325 zbmin=min(zbmin,zz)
326 xc=xc+one_over_8*xx
327 yc=yc+one_over_8*yy
328 zc=zc+one_over_8*zz
329 ENDDO
330C Passage repere local brique
331 pp(1,1)=sfac(4,2,i)
332 pp(2,1)=sfac(4,3,i)
333 pp(3,1)=sfac(4,4,i)
334 pp(1,2)=sfac(5,2,i)
335 pp(2,2)=sfac(5,3,i)
336 pp(3,2)=sfac(5,4,i)
337 pp(1,3)=sfac(2,2,i)
338 pp(2,3)=sfac(2,3,i)
339 pp(3,3)=sfac(2,4,i)
340C
341 xx=xb(1,bric(7,i))
342 yy=xb(2,bric(7,i))
343 zz=xb(3,bric(7,i))
344 xl7(1)=pp(1,1)*(xx-xc)+pp(2,1)*(yy-yc)+pp(3,1)*(zz-zc)
345 xl7(2)=pp(1,2)*(xx-xc)+pp(2,2)*(yy-yc)+pp(3,2)*(zz-zc)
346 xl7(3)=pp(1,3)*(xx-xc)+pp(2,3)*(yy-yc)+pp(3,3)*(zz-zc)
347 bcenter(1)=zero
348 bcenter(2)=zero
349 bcenter(3)=zero
350 bhalfsize(1)=xl7(1)
351 bhalfsize(2)=xl7(2)
352 bhalfsize(3)=xl7(3)
353 info=0
354 DO iel=1,nela
355 n1=elema(1,iel)
356 n2=elema(2,iel)
357 n3=elema(3,iel)
358 IF (tagela(iel) > 0) THEN
359 nn1=ibuf(n1)
360 nn2=ibuf(n2)
361 nn3=ibuf(n3)
362 ELSEIF (tagela(iel) < 0) THEN
363 nn1=ibufa(n1)
364 nn2=ibufa(n2)
365 nn3=ibufa(n3)
366 ENDIF
367 x1=x(1,nn1)
368 y1=x(2,nn1)
369 z1=x(3,nn1)
370 x2=x(1,nn2)
371 y2=x(2,nn2)
372 z2=x(3,nn2)
373 x3=x(1,nn3)
374 y3=x(2,nn3)
375 z3=x(3,nn3)
376 xtmax=max(x1,x2,x3)
377 ytmax=max(y1,y2,y3)
378 ztmax=max(z1,z2,z3)
379 xtmin=min(x1,x2,x3)
380 ytmin=min(y1,y2,y3)
381 ztmin=min(z1,z2,z3)
382 IF (xbmax < xtmin.OR.ybmax < ytmin.OR.zbmax < ztmin.OR.
383 . xbmin > xtmax.OR.ybmin > ytmax.OR.zbmin > ztmax)
384 . cycle
385C
386 tverts(1)=pp(1,1)*(x1-xc)+pp(2,1)*(y1-yc)+pp(3,1)*(z1-zc)
387 tverts(2)=pp(1,2)*(x1-xc)+pp(2,2)*(y1-yc)+pp(3,2)*(z1-zc)
388 tverts(3)=pp(1,3)*(x1-xc)+pp(2,3)*(y1-yc)+pp(3,3)*(z1-zc)
389 tverts(4)=pp(1,1)*(x2-xc)+pp(2,1)*(y2-yc)+pp(3,1)*(z2-zc)
390 tverts(5)=pp(1,2)*(x2-xc)+pp(2,2)*(y2-yc)+pp(3,2)*(z2-zc)
391 tverts(6)=pp(1,3)*(x2-xc)+pp(2,3)*(y2-yc)+pp(3,3)*(z2-zc)
392 tverts(7)=pp(1,1)*(x3-xc)+pp(2,1)*(y3-yc)+pp(3,1)*(z3-zc)
393 tverts(8)=pp(1,2)*(x3-xc)+pp(2,2)*(y3-yc)+pp(3,2)*(z3-zc)
394 tverts(9)=pp(1,3)*(x3-xc)+pp(2,3)*(y3-yc)+pp(3,3)*(z3-zc)
395C
396 CALL tribox3(icut, bcenter, bhalfsize, tverts)
397C Liste elargie pour faces laterales
398 IF (icut == 0) THEN
399 tole=em5
400* TOLE=ZERO
401 xg=third*(x1+x2+x3)
402 yg=third*(y1+y2+y3)
403 zg=third*(z1+z2+z3)
404 x1=xg+(one+tole)*(x1-xg)
405 y1=yg+(one+tole)*(y1-yg)
406 z1=zg+(one+tole)*(z1-zg)
407 x2=xg+(one+tole)*(x2-xg)
408 y2=yg+(one+tole)*(y2-yg)
409 z2=zg+(one+tole)*(z2-zg)
410 x3=xg+(one+tole)*(x3-xg)
411 y3=yg+(one+tole)*(y3-yg)
412 z3=zg+(one+tole)*(z3-zg)
413C
414 tverts(1)=pp(1,1)*(x1-xc)+pp(2,1)*(y1-yc)+pp(3,1)*(z1-zc)
415 tverts(2)=pp(1,2)*(x1-xc)+pp(2,2)*(y1-yc)+pp(3,2)*(z1-zc)
416 tverts(3)=pp(1,3)*(x1-xc)+pp(2,3)*(y1-yc)+pp(3,3)*(z1-zc)
417 tverts(4)=pp(1,1)*(x2-xc)+pp(2,1)*(y2-yc)+pp(3,1)*(z2-zc)
418 tverts(5)=pp(1,2)*(x2-xc)+pp(2,2)*(y2-yc)+pp(3,2)*(z2-zc)
419 tverts(6)=pp(1,3)*(x2-xc)+pp(2,3)*(y2-yc)+pp(3,3)*(z2-zc)
420 tverts(7)=pp(1,1)*(x3-xc)+pp(2,1)*(y3-yc)+pp(3,1)*(z3-zc)
421 tverts(8)=pp(1,2)*(x3-xc)+pp(2,2)*(y3-yc)+pp(3,2)*(z3-zc)
422 tverts(9)=pp(1,3)*(x3-xc)+pp(2,3)*(y3-yc)+pp(3,3)*(z3-zc)
423C
424 CALL tribox3(icut, bcenter, bhalfsize, tverts)
425 IF (icut == 1) icut=2
426 ENDIF
427C
428 IF (icut >= 1) THEN
429 IF (icut == 1) THEN
430 tbric(7,i)=2
431 tmptri(1,1)=x1
432 tmptri(2,1)=y1
433 tmptri(3,1)=z1
434 tmptri(1,2)=x2
435 tmptri(2,2)=y2
436 tmptri(3,2)=z2
437 tmptri(1,3)=x3
438 tmptri(2,3)=y3
439 tmptri(3,3)=z3
440 DO j=1,8
441 tmpbox(1,j)=xb(1,bric(j,i))
442 tmpbox(2,j)=xb(2,bric(j,i))
443 tmpbox(3,j)=xb(3,bric(j,i))
444 ENDDO
445 DO j=1,6
446 tmpnorm(1,j)=-sfac(j,2,i)
447 tmpnorm(2,j)=-sfac(j,3,i)
448 tmpnorm(3,j)=-sfac(j,4,i)
449 ENDDO
450 CALL itribox(tmptri, tmpbox, tmpnorm, nverts, poly,
451 . nvmax )
452 IF (nverts > 2) THEN
453 npoly=npoly+1
454 IF (.NOT.ASSOCIATED(first)) THEN
455 ALLOCATE(first)
456 ptr_cur => first
457 ELSE
458 ALLOCATE(ptr_cur)
459 ptr_prec%PTR => ptr_cur
460 ENDIF
461 ALLOCATE(ptr_cur%IPOLY(6+nverts),
462 . ptr_cur%IELNOD(nverts),
463 . ptr_cur%RPOLY(4+3*nverts))
464 ptr_cur%IPOLY(1)=1
465 ptr_cur%IPOLY(2)=nverts
466 ptr_cur%IPOLY(3)=iel
467 ptr_cur%IPOLY(4)=i
468 ptr_cur%IPOLY(5)=0
469 ptr_cur%IPOLY(6)=0
470 ptr_cur%RPOLY(1)=zero
471 ptr_cur%RPOLY(2)=norma(1,iel)
472 ptr_cur%RPOLY(3)=norma(2,iel)
473 ptr_cur%RPOLY(4)=norma(3,iel)
474 DO j=1,nverts
475 nns=nns+1
476 ptr_cur%IPOLY(6+j)=nns
477 ptr_cur%IELNOD(j)=iel
478 ptr_cur%RPOLY(4+3*(j-1)+1)=poly(1,j)
479 ptr_cur%RPOLY(4+3*(j-1)+2)=poly(2,j)
480 ptr_cur%RPOLY(4+3*(j-1)+3)=poly(3,j)
481 ENDDO
482 ptr_prec => ptr_cur
483 ENDIF
484 ENDIF
485C Facettes coupees (1 quadrangle=2 triangles)
486 tole=em5
487* TOLE=ZERO
488 xg=third*(x1+x2+x3)
489 yg=third*(y1+y2+y3)
490 zg=third*(z1+z2+z3)
491 x1=xg+(one+tole)*(x1-xg)
492 y1=yg+(one+tole)*(y1-yg)
493 z1=zg+(one+tole)*(z1-zg)
494 x2=xg+(one+tole)*(x2-xg)
495 y2=yg+(one+tole)*(y2-yg)
496 z2=zg+(one+tole)*(z2-zg)
497 x3=xg+(one+tole)*(x3-xg)
498 y3=yg+(one+tole)*(y3-yg)
499 z3=zg+(one+tole)*(z3-zg)
500C
501 fv0(1)=x1
502 fv0(2)=y1
503 fv0(3)=z1
504 fv1(1)=x2
505 fv1(2)=y2
506 fv1(3)=z2
507 fv2(1)=x3
508 fv2(2)=y3
509 fv2(3)=z3
510 DO j=1,6
511 nf1=bric(fac(1,j),i)
512 nf2=bric(fac(2,j),i)
513 nf3=bric(fac(3,j),i)
514 nf4=bric(fac(4,j),i)
515 fu0(1)=xb(1,nf1)
516 fu0(2)=xb(2,nf1)
517 fu0(3)=xb(3,nf1)
518 fu1(1)=xb(1,nf2)
519 fu1(2)=xb(2,nf2)
520 fu1(3)=xb(3,nf2)
521 fu2(1)=xb(1,nf3)
522 fu2(2)=xb(2,nf3)
523 fu2(3)=xb(3,nf3)
524C
525 CALL tritri3(icut, fv0, fv1, fv2, fu0, fu1, fu2)
526 IF (icut == 1) THEN
527 tbric(7+j,i)=2
528 ns=facet(j,1)
529 ns=ns+1
530 facet(j,1)=ns
531 IF (ns > nfacmax) THEN
532 info=1
533 ELSE
534 facet(j,1+ns)=iel
535 ENDIF
536 cycle
537 ENDIF
538C
539 fu1(1)=xb(1,nf3)
540 fu1(2)=xb(2,nf3)
541 fu1(3)=xb(3,nf3)
542 fu2(1)=xb(1,nf4)
543 fu2(2)=xb(2,nf4)
544 fu2(3)=xb(3,nf4)
545C
546 CALL tritri3(icut, fv0, fv1, fv2, fu0, fu1, fu2)
547 IF (icut == 1) THEN
548 tbric(7+j,i)=2
549 ns=facet(j,1)
550 ns=ns+1
551 facet(j,1)=ns
552 IF (ns > nfacmax) THEN
553 info=1
554 ELSE
555 facet(j,1+ns)=iel
556 ENDIF
557 ENDIF
558 ENDDO
559 ENDIF
560 ENDDO
561C
562 IF (info == 1) THEN
563 nsmax=0
564 DO j=1,6
565 nsmax=max(nsmax,facet(j,1))
566 ENDDO
567 nfacmax=nsmax
568 IF(ilvout >=1) WRITE(iout,'(A,I10,A,I10)')
569 . ' monitored volume id: ',IVOLU(1),
570 . ' nfacmax is reset to ',NSMAX
571C Destruction des polygones crees pour rien
572 IF (NPOLY_OLD > 0) THEN
573 PTR_CUR => PTR_OLD%PTR
574 ELSE
575 PTR_CUR => FIRST
576 ENDIF
577 DO J=1,NPOLY-NPOLY_OLD
578 PTR_TMP => PTR_CUR%PTR
579 DEALLOCATE(PTR_CUR%IPOLY, PTR_CUR%RPOLY,
580 . PTR_CUR%IELNOD)
581 DEALLOCATE(PTR_CUR)
582 PTR_CUR => PTR_TMP
583 ENDDO
584 IF (NPOLY_OLD > 0) THEN
585 PTR_PREC => PTR_OLD
586 ELSE
587 NULLIFY(FIRST)
588 ENDIF
589 NPOLY=NPOLY_OLD
590 NNS=NNS_OLD
591C
592C
593 DEALLOCATE(FACET, TRI, NORMT, POLY)
594 GOTO 100
595 ENDIF
596C 2. Faces laterales
597 IF (TBRIC(7,I) <= 1) THEN
598 DEALLOCATE(FACET, TRI, NORMT, POLY)
599 CYCLE
600 END IF
601C Debut boucle sur les 6 faces de la brique i
602 DO J=1,6
603 NV=TBRIC(J,I)
604 IF (NV == 0) CYCLE
605 IF (ITAGB(NV) == 1) CYCLE
606 IF (TBRIC(7+J,I) == 2) THEN
607 DO K=1,4
608 KK=FAC(K,J)
609 QUAD(1,K)=XB(1,BRIC(KK,I))
610 QUAD(2,K)=XB(2,BRIC(KK,I))
611 QUAD(3,K)=XB(3,BRIC(KK,I))
612 ENDDO
613 NS=FACET(J,1)
614 DO K=1,NS
615 IEL=FACET(J,1+K) ! 1<IEL< NELA
616 IF (TAGELA(IEL) > 0) THEN
617 DO L=1,3
618 LL=IBUF(ELEMA(L,IEL))
619 TRI(K,L)=LL
620 ENDDO
621 IF(TAGELA(IEL) <= NEL) THEN
622C Triangle sur airbag
623 TRI(K,5)=1
624 ELSE
625C Triangle sur structure interne
626 TRI(K,5)=3
627 ENDIF
628 ELSEIF (TAGELA(IEL) < 0) THEN
629C Triangle sur brique additionelle
630 DO L=1,3
631 LL=IBUFA(ELEMA(L,IEL))
632 TRI(K,L)=LL
633 ENDDO
634 TRI(K,5)=2
635 ENDIF
636 TRI(K,4)=IEL
637 NORMT(1,K)=NORMA(1,IEL)
638 NORMT(2,K)=NORMA(2,IEL)
639 NORMT(3,K)=NORMA(3,IEL)
640 ENDDO
641 DO K=1,4
642 NORMF(1,K)=SFAC(FACNOR(K,J),2,I)
643 NORMF(2,K)=SFAC(FACNOR(K,J),3,I)
644 NORMF(3,K)=SFAC(FACNOR(K,J),4,I)
645 ENDDO
646 NR(1)=SFAC(J,2,I)
647 NR(2)=SFAC(J,3,I)
648 NR(3)=SFAC(J,4,I)
649C
650 NNP=0
651 NPOLMAX=NLAYER
652C
653 200 CONTINUE
654 NRPMAX=NPPMAX*3+4
655 ALLOCATE(IPOLY(6+NPPMAX+1+NPOLMAX,NPOLMAX),
656 . RPOLY(NRPMAX+3*NPOLMAX,NPOLMAX),
657 . IELNOD(NPPMAX,NPOLMAX))
658C
659 CALL FACEPOLY(QUAD, TRI, NS, IPOLY, RPOLY,
660 . NR, NORMF, NORMT, NFACMAX, NNP,
661 . NRPMAX, I, NV, DXM, NPOLMAX,
662 . NPPMAX, INFO, IELNOD, X, J,
663 . ILVOUT, IVOLU(1) )
664 IF (INFO == 1) THEN
665 DEALLOCATE(IPOLY, RPOLY, IELNOD)
666 GOTO 200
667 ENDIF
668C
669 DO N=1,NNP
670 IF (IPOLY(1,N) == -1) CYCLE
671 NPOLY2=NPOLY2+1
672.NOT. IF (ASSOCIATED(FIRST2)) THEN
673 ALLOCATE(FIRST2)
674 PTR_CUR2 => FIRST2
675 ELSE
676 ALLOCATE(PTR_CUR2)
677 PTR_PREC2%PTR => PTR_CUR2
678 ENDIF
679 NN=IPOLY(2,N)
680 NHOL=IPOLY(6+NN+1,N)
681 ALLOCATE(PTR_CUR2%IPOLY(6+NN+1+NHOL),
682 . PTR_CUR2%IELNOD(NN),
683 . PTR_CUR2%RPOLY(4+3*NN+3*NHOL))
684 DO M=1,6
685 PTR_CUR2%IPOLY(M)=IPOLY(M,N)
686 ENDDO
687 DO M=1,4
688 PTR_CUR2%RPOLY(M)=RPOLY(M,N)
689 ENDDO
690 DO M=1,IPOLY(2,N)
691 NNS2=NNS2+1
692 PTR_CUR2%IPOLY(6+M)=NNS2
693 MM=IELNOD(M,N)
694 PTR_CUR2%IELNOD(M)=FACET(J,1+MM)
695 PTR_CUR2%RPOLY(4+3*(M-1)+1)=RPOLY(4+3*(M-1)+1,N)
696 PTR_CUR2%RPOLY(4+3*(M-1)+2)=RPOLY(4+3*(M-1)+2,N)
697 PTR_CUR2%RPOLY(4+3*(M-1)+3)=RPOLY(4+3*(M-1)+3,N)
698 ENDDO
699 PTR_CUR2%IPOLY(6+NN+1)=NHOL
700 DO M=1,NHOL
701 PTR_CUR2%IPOLY(6+NN+1+M)=IPOLY(6+NN+1+M,N)
702 PTR_CUR2%RPOLY(4+3*NN+3*(M-1)+1)=
703 . RPOLY(4+3*NN+3*(M-1)+1,N)
704 PTR_CUR2%RPOLY(4+3*NN+3*(M-1)+2)=
705 . RPOLY(4+3*NN+3*(M-1)+2,N)
706 PTR_CUR2%RPOLY(4+3*NN+3*(M-1)+3)=
707 . RPOLY(4+3*NN+3*(M-1)+3,N)
708 ENDDO
709 PTR_PREC2 => PTR_CUR2
710 ENDDO
711C
712 DEALLOCATE(IPOLY, RPOLY, IELNOD)
713 ENDIF
714 ENDDO
715C Fin de boucle sur les faces des briques
716 ITAGB(I)=1
717C
718 DEALLOCATE(FACET, TRI, NORMT, POLY)
719 ENDDO
720C Fin de boucle sur les briques
721C Fin de creation des polygones
722C-----------------------------------------------------------------------------------
723C Concatenation des deux listes
724 PTR_CUR2 => FIRST2
725 PTR_PREC => PTR_CUR
726 DO I=1,NPOLY2
727 NPOLY=NPOLY+1
728 ALLOCATE(PTR_CUR)
729 PTR_PREC%PTR => PTR_CUR
730 NN=PTR_CUR2%IPOLY(2)
731 NHOL=PTR_CUR2%IPOLY(6+NN+1)
732 ALLOCATE(PTR_CUR%IPOLY(6+NN+1+NHOL),
733 . PTR_CUR%IELNOD(NN),
734 . PTR_CUR%RPOLY(4+3*NN+3*NHOL))
735 DO J=1,6
736 PTR_CUR%IPOLY(J)=PTR_CUR2%IPOLY(J)
737 ENDDO
738 DO J=1,4
739 PTR_CUR%RPOLY(J)=PTR_CUR2%RPOLY(J)
740 ENDDO
741 DO J=1,NN
742 PTR_CUR%IPOLY(6+J)=NNS+PTR_CUR2%IPOLY(6+J)
743 PTR_CUR%IELNOD(J)=PTR_CUR2%IELNOD(J)
744 PTR_CUR%RPOLY(4+3*(J-1)+1)=PTR_CUR2%RPOLY(4+3*(J-1)+1)
745 PTR_CUR%RPOLY(4+3*(J-1)+2)=PTR_CUR2%RPOLY(4+3*(J-1)+2)
746 PTR_CUR%RPOLY(4+3*(J-1)+3)=PTR_CUR2%RPOLY(4+3*(J-1)+3)
747 ENDDO
748 PTR_CUR%IPOLY(6+NN+1)=NHOL
749 DO J=1,NHOL
750 PTR_CUR%IPOLY(6+NN+1+J)=PTR_CUR2%IPOLY(6+NN+1+J)
751 PTR_CUR%RPOLY(4+3*NN+3*(J-1)+1)=
752 . PTR_CUR2%RPOLY(4+3*NN+3*(J-1)+1)
753 PTR_CUR%RPOLY(4+3*NN+3*(J-1)+2)=
754 . PTR_CUR2%RPOLY(4+3*NN+3*(J-1)+2)
755 PTR_CUR%RPOLY(4+3*NN+3*(J-1)+3)=
756 . PTR_CUR2%RPOLY(4+3*NN+3*(J-1)+3)
757 ENDDO
758 PTR_TMP2 => PTR_CUR2%PTR
759 DEALLOCATE(PTR_CUR2%IPOLY, PTR_CUR2%RPOLY, PTR_CUR2%IELNOD)
760 DEALLOCATE(PTR_CUR2)
761 PTR_CUR2 => PTR_TMP2
762 PTR_PREC => PTR_CUR
763 ENDDO
764C
765 NNS=NNS+NNS2
766C---------------------------------------------------
767C Decoupage des polygones selon la verticale locale
768C---------------------------------------------------
769 NBZ=IVOLU(65)
770 IF (NBZ > 1) THEN
771 PTR_CUR => FIRST
772 DO I=1,NPOLY
773 PTR_CUR%NNSP=0
774 PTR_CUR => PTR_CUR%PTR
775 ENDDO
776C
777 VX3=RVOLU(35)
778 VY3=RVOLU(36)
779 VZ3=RVOLU(37)
780 VX1=RVOLU(38)
781 VY1=RVOLU(39)
782 VZ1=RVOLU(40)
783C Repere local
784 VNORM=SQRT(VX3**2+VY3**2+VZ3**2)
785 VX3=VX3/VNORM
786 VY3=VY3/VNORM
787 VZ3=VZ3/VNORM
788 SS=VX3*VX1+VY3*VY1+VZ3*VZ1
789 VX1=VX1-SS*VX3
790 VY1=VY1-SS*VY3
791 VZ1=VZ1-SS*VZ3
792 VNORM=SQRT(VX1**2+VY1**2+VZ1**2)
793 VX1=VX1/VNORM
794 VY1=VY1/VNORM
795 VZ1=VZ1/VNORM
796 VX2=VY3*VZ1-VZ3*VY1
797 VY2=VZ3*VX1-VX3*VZ1
798 VZ2=VX3*VY1-VY3*VX1
799C
800 X0=RVOLU(41)
801 Y0=RVOLU(42)
802 Z0=RVOLU(43)
803 LZ=RVOLU(53)
804 DZ=TWO*LZ/NBZ
805 DXM=MIN(DXM,DZ)
806C
807 ZBMIN=EP30
808 ZBMAX=-EP30
809 DO IEL=1,NEL
810 N1=ELEM(1,IEL)
811 N2=ELEM(2,IEL)
812 N3=ELEM(3,IEL)
813 NN1=IBUF(N1)
814 NN2=IBUF(N2)
815 NN3=IBUF(N3)
816 X1=X(1,NN1)
817 X2=X(1,NN2)
818 X3=X(1,NN3)
819 Y1=X(2,NN1)
820 Y2=X(2,NN2)
821 Y3=X(2,NN3)
822 Z1=X(3,NN1)
823 Z2=X(3,NN2)
824 Z3=X(3,NN3)
825 X12=X2-X1
826 Y12=Y2-Y1
827 Z12=Z2-Z1
828 X13=X3-X1
829 Y13=Y3-Y1
830 Z13=Z3-Z1
831 ZL1=(X1-X0)*VX3+(Y1-Y0)*VY3+(Z1-Z0)*VZ3
832 ZL2=(X2-X0)*VX3+(Y2-Y0)*VY3+(Z2-Z0)*VZ3
833 ZL3=(X3-X0)*VX3+(Y3-Y0)*VY3+(Z3-Z0)*VZ3
834 ZBMIN=MIN(ZBMIN,ZL1)
835 ZBMIN=MIN(ZBMIN,ZL2)
836 ZBMIN=MIN(ZBMIN,ZL3)
837 ZBMAX=MAX(ZBMAX,ZL1)
838 ZBMAX=MAX(ZBMAX,ZL2)
839 ZBMAX=MAX(ZBMAX,ZL3)
840 ENDDO
841C Clipping des polygones
842 X0=X0-LZ*VX3
843 Y0=Y0-LZ*VY3
844 Z0=Z0-LZ*VZ3
845 ZLC=-LZ
846 ALLOCATE(INEDGE(6,NPOLY*NPPMAX), RNEDGE(6,NPOLY*NPPMAX))
847 NBNEDGE=0
848 NNS3=0
849 NPOLY_NEW=NPOLY
850 IIZ=0
851 DO I=1,NBZ+1
852.OR. IF (ZLC < ZBMINZLC > ZBMAX) THEN
853 X0=X0+DZ*VX3
854 Y0=Y0+DZ*VY3
855 Z0=Z0+DZ*VZ3
856 ZLC=ZLC+DZ
857 CYCLE
858 ENDIF
859 IIZ=IIZ+1
860 PTR_CUR => FIRST
861 DO J=1,NPOLY
862 ZLMIN=EP30
863 ZLMAX=-EP30
864 DO K=1,PTR_CUR%IPOLY(2)
865 XX=PTR_CUR%RPOLY(4+3*(K-1)+1)
866 YY=PTR_CUR%RPOLY(4+3*(K-1)+2)
867 ZZ=PTR_CUR%RPOLY(4+3*(K-1)+3)
868 ZL=(XX-X0)*VX3+(YY-Y0)*VY3+(ZZ-Z0)*VZ3
869 ZLMIN=MIN(ZLMIN,ZL)
870 ZLMAX=MAX(ZLMAX,ZL)
871 ENDDO
872C
873 IF (ZLMIN*ZLMAX < ZERO) THEN
874 ITY=PTR_CUR%IPOLY(1)
875 NN=PTR_CUR%IPOLY(2)
876 NHOL=0
877 IF (ITY == 2) NHOL=PTR_CUR%IPOLY(6+NN+1)
878 ALLOCATE(IPOLY(6+2*NN+1+NHOL,NN),
879 . RPOLY(4+3*2*NN+3*NHOL,NN),
880 . IELNOD(2*NN,NN),
881 . NREF(2,NN), AREF(4,NN),
882 . IZ(3,NN))
883 CALL FVBAG_GPOLCUT(
884 . IPOLY, RPOLY, PTR_CUR%IPOLY, PTR_CUR%RPOLY, INEDGE,
885 . RNEDGE, NBNEDGE, VX3, VY3, VZ3,
886 . X0, Y0, Z0, NREF, AREF,
887 . NN, NHOL, IIZ, IZ, NNS3,
888 . NNP , NNSP, IELNOD, PTR_CUR%IELNOD)
889C
890 IF(NNP >= 1) THEN
891 PTR_TMP => PTR_CUR%PTR
892 NPOLY_NEW=NPOLY_NEW-1
893 DO N=1,NNP
894 NPOLY_NEW=NPOLY_NEW+1
895 IF (N == 1) THEN
896 DEALLOCATE(PTR_CUR%IPOLY, PTR_CUR%RPOLY,
897 . PTR_CUR%IELNOD)
898 ELSE
899 ALLOCATE(PTR_CUR)
900 PTR_PREC%PTR => PTR_CUR
901 PTR_CUR%NNSP=0
902 ENDIF
903 NN=IPOLY(2,N)
904 NHOL=IPOLY(6+NN+1,N)
905 ALLOCATE(PTR_CUR%IPOLY(6+NN+1+NHOL),
906 . PTR_CUR%IELNOD(NN),
907 . PTR_CUR%RPOLY(4+3*NN+3*NHOL))
908 DO M=1,6
909 PTR_CUR%IPOLY(M)=IPOLY(M,N)
910 ENDDO
911 DO M=1,4
912 PTR_CUR%RPOLY(M)=RPOLY(M,N)
913 ENDDO
914 DO M=1,NN
915 MM=IPOLY(6+M,N)
916 PTR_CUR%IPOLY(6+M)=MM
917 PTR_CUR%IELNOD(M)=IELNOD(M,N)
918 PTR_CUR%RPOLY(4+3*(M-1)+1)=RPOLY(4+3*(M-1)+1,N)
919 PTR_CUR%RPOLY(4+3*(M-1)+2)=RPOLY(4+3*(M-1)+2,N)
920 PTR_CUR%RPOLY(4+3*(M-1)+3)=RPOLY(4+3*(M-1)+3,N)
921 ENDDO
922 NHOL=IPOLY(6+NN+1,N)
923 PTR_CUR%IPOLY(6+NN+1)=NHOL
924 DO M=1,NHOL
925 PTR_CUR%IPOLY(6+NN+1+M)=IPOLY(6+NN+1+M,N)
926 PTR_CUR%RPOLY(4+3*NN+3*(M-1)+1)=
927 . RPOLY(4+3*NN+3*(M-1)+1,N)
928 PTR_CUR%RPOLY(4+3*NN+3*(M-1)+2)=
929 . RPOLY(4+3*NN+3*(M-1)+2,N)
930 PTR_CUR%RPOLY(4+3*NN+3*(M-1)+3)=
931 . RPOLY(4+3*NN+3*(M-1)+3,N)
932 ENDDO
933 PTR_CUR%IZ(1)=1
934 PTR_CUR%IZ(2)=IZ(2,N)
935 IF (N == NNP) THEN
936 PTR_CUR%NNSP=NNSP
937 ALLOCATE(PTR_CUR%NREF(3,NNSP),
938 . PTR_CUR%AREF(4,NNSP))
939 DO M=1,NNSP
940 NNS3=NNS3+1
941 PTR_CUR%NREF(1,M)=NNS3
942 PTR_CUR%NREF(2,M)=NREF(1,M)
943 PTR_CUR%NREF(3,M)=NREF(2,M)
944 PTR_CUR%AREF(1,M)=AREF(1,M)
945 PTR_CUR%AREF(2,M)=AREF(2,M)
946 PTR_CUR%AREF(3,M)=AREF(3,M)
947 PTR_CUR%AREF(4,M)=AREF(4,M)
948 ENDDO
949 ENDIF
950 PTR_PREC => PTR_CUR
951 IF (N == NNP) PTR_CUR%PTR => PTR_TMP
952 ENDDO
953 ENDIF
954C
955 DEALLOCATE(IPOLY, RPOLY, IELNOD, NREF, AREF, IZ)
956 ELSE
957C
958.AND. IF (ZLMIN == ZEROZLMAX > ZERO) THEN
959 NN=PTR_CUR%IPOLY(2)
960 ALLOCATE(NREF(2,2*NN), AREF(4,2*NN))
961 CALL HORIEDGE(
962 . PTR_CUR%IPOLY, PTR_CUR%RPOLY, VX3, VY3, VZ3,
963 . NBNEDGE, INEDGE, RNEDGE, X0, Y0,
964 . Z0, IIZ , NNS3, NREF, AREF,
965 . NNSP )
966C
967 IF (NNSP > 0) THEN
968 ALLOCATE(PTR_CUR%NREF(3,NNSP),
969 . PTR_CUR%AREF(4,NNSP))
970 PTR_CUR%NNSP=NNSP
971 DO N=1,NNSP
972 NNS3=NNS3+1
973 PTR_CUR%NREF(1,N)=NNS3
974 PTR_CUR%NREF(2,N)=NREF(1,N)
975 PTR_CUR%NREF(3,N)=NREF(2,N)
976 PTR_CUR%AREF(1,N)=AREF(1,N)
977 PTR_CUR%AREF(2,N)=AREF(2,N)
978 PTR_CUR%AREF(3,N)=AREF(3,N)
979 PTR_CUR%AREF(4,N)=AREF(4,N)
980 ENDDO
981 ENDIF
982 DEALLOCATE(NREF, AREF)
983 ENDIF
984C
985 IF (ZLMIN >= ZERO) THEN
986 PTR_CUR%IZ(1)=1
987 PTR_CUR%IZ(2)=IIZ+1
988.AND. ELSEIF (IIZ == 1ZLMAX <= ZERO) THEN
989 PTR_CUR%IZ(1)=1
990 PTR_CUR%IZ(2)=1
991 ENDIF
992 PTR_PREC => PTR_CUR
993 ENDIF
994 PTR_CUR => PTR_CUR%PTR
995 ENDDO
996 NPOLY=NPOLY_NEW
997 X0=X0+DZ*VX3
998 Y0=Y0+DZ*VY3
999 Z0=Z0+DZ*VZ3
1000 ZLC=ZLC+DZ
1001 ENDDO
1002C
1003 ALLOCATE(REDIR(NNS))
1004 PTR_CUR => FIRST
1005 NNS=0
1006 DO I=1,NPOLY
1007 NN=PTR_CUR%IPOLY(2)
1008 DO J=1,NN
1009 JJ=PTR_CUR%IPOLY(6+J)
1010 IF (JJ > 0) THEN
1011 NNS=NNS+1
1012 REDIR(JJ)=NNS
1013 ENDIF
1014 ENDDO
1015 PTR_CUR => PTR_CUR%PTR
1016 ENDDO
1017C
1018 PTR_CUR => FIRST
1019 DO I=1,NPOLY
1020 NNSP=PTR_CUR%NNSP
1021 IF (NNSP > 0) THEN
1022 DO J=1,NNSP
1023 N1=PTR_CUR%NREF(2,J)
1024 N2=PTR_CUR%NREF(3,J)
1025 IF (N1 > 0) PTR_CUR%NREF(2,J)=REDIR(N1)
1026 IF (N2 > 0) PTR_CUR%NREF(3,J)=REDIR(N2)
1027 ENDDO
1028 ENDIF
1029 PTR_CUR => PTR_CUR%PTR
1030 ENDDO
1031 DEALLOCATE(REDIR)
1032C Creation des nouveaux polygones horizontaux
1033 PTR_CUR => FIRST
1034 DO I=1,NPOLY
1035 PTR_PREC => PTR_CUR
1036 PTR_CUR => PTR_CUR%PTR
1037 ENDDO
1038C
1039 ALLOCATE(LEDGE(NBNEDGE))
1040 DO I=1,IIZ
1041 DO J=1,NBRIC
1042 NEDGE=0
1043 DO K=1,NBNEDGE
1044 IF (INEDGE(6,K) /= I) CYCLE
1045.AND. IF (INEDGE(1,K) == 1INEDGE(5,K) /= J) CYCLE
1046.AND..AND. IF (INEDGE(1,K) == 2INEDGE(4,K) /= J
1047 . INEDGE(5,K) /= J) CYCLE
1048 NEDGE=NEDGE+1
1049 LEDGE(NEDGE)=K
1050 ENDDO
1051 IF (NEDGE == 0) CYCLE
1052 ALLOCATE(IPOLY(6+2*NEDGE+1+NEDGE,NEDGE),
1053 . RPOLY(4+6*NEDGE+3*NEDGE,NEDGE),
1054 . IZ(3,NEDGE), IELNOD(NEDGE,NEDGE))
1055C
1056 CALL HORIPOLY(INEDGE, RNEDGE, LEDGE, NEDGE, IPOLY,
1057 . RPOLY, IZ, IELNOD, NNP, VX3,
1058 . VY3, VZ3, I , J , NEL,
1059 . TAGELA )
1060C
1061 DO N=1,NNP
1062 IF (IPOLY(1,N) == -1) CYCLE
1063 NPOLY=NPOLY+1
1064 ALLOCATE(PTR_CUR)
1065 PTR_PREC%PTR => PTR_CUR
1066 NN=IPOLY(2,N)
1067 NHOL=IPOLY(6+NN+1,N)
1068 ALLOCATE(PTR_CUR%IPOLY(6+NN+1+NHOL),
1069 . PTR_CUR%RPOLY(4+3*NN+3*NHOL),
1070 . PTR_CUR%IELNOD(NN))
1071 PTR_CUR%NNSP=0
1072 DO M=1,6
1073 PTR_CUR%IPOLY(M)=IPOLY(M,N)
1074 ENDDO
1075 DO M=1,4
1076 PTR_CUR%RPOLY(M)=RPOLY(M,N)
1077 ENDDO
1078 DO M=1,NN
1079 PTR_CUR%IPOLY(6+M)=IPOLY(6+M,N)
1080 PTR_CUR%IELNOD(M)=IELNOD(M,N)
1081 PTR_CUR%RPOLY(4+3*(M-1)+1)=RPOLY(4+3*(M-1)+1,N)
1082 PTR_CUR%RPOLY(4+3*(M-1)+2)=RPOLY(4+3*(M-1)+2,N)
1083 PTR_CUR%RPOLY(4+3*(M-1)+3)=RPOLY(4+3*(M-1)+3,N)
1084 ENDDO
1085 NHOL=IPOLY(6+NN+1,N)
1086 PTR_CUR%IPOLY(6+NN+1)=NHOL
1087 DO M=1,NHOL
1088 PTR_CUR%IPOLY(6+NN+1+M)=IPOLY(6+NN+1+M,N)
1089 PTR_CUR%RPOLY(4+3*NN+3*(M-1)+1)=
1090 . RPOLY(4+3*NN+3*(M-1)+1,N)
1091 PTR_CUR%RPOLY(4+3*NN+3*(M-1)+2)=
1092 . RPOLY(4+3*NN+3*(M-1)+2,N)
1093 PTR_CUR%RPOLY(4+3*NN+3*(M-1)+3)=
1094 . RPOLY(4+3*NN+3*(M-1)+3,N)
1095 ENDDO
1096 DO M=1,3
1097 PTR_CUR%IZ(M)=IZ(M,N)
1098 ENDDO
1099 PTR_PREC => PTR_CUR
1100 ENDDO
1101C
1102 DEALLOCATE(IPOLY, RPOLY, IZ, IELNOD)
1103 ENDDO
1104 ENDDO
1105 DEALLOCATE(LEDGE)
1106 ELSE
1107 PTR_CUR => FIRST
1108 DO I=1,NPOLY
1109 PTR_CUR%NNSP=0
1110 PTR_CUR%IZ(1)=1
1111 PTR_CUR%IZ(2)=1
1112 PTR_CUR => PTR_CUR%PTR
1113C
1114 IIZ=0
1115 ENDDO
1116 ENDIF
1117C---------------------------------------------------
1118C Construction des polyedres
1119C---------------------------------------------------
1120 NPOLH=0
1121C
1122 IF (ILVOUT >=1) WRITE(ISTDO,'(8x,a)') 'building finite volumes'
1123 DO I=1,NBRIC
1124 !IF (ILVOUT >=1) CALL PROGALE_C(I, NBRIC, 2) !dynamic screen output
1125C
1126 IF (TBRIC(7,I) /= 2) CYCLE
1127C Polygones de la brique
1128 NPOLB=0
1129 NPPMAX=0
1130 PTR_CUR => FIRST
1131 DO J=1,NPOLY
1132 ITY=PTR_CUR%IPOLY(1)
1133.AND..OR. IF ((ITY == 1PTR_CUR%IPOLY(4) == I)
1134.AND. . (ITY == 2
1135.OR. . (PTR_CUR%IPOLY(3) == IPTR_CUR%IPOLY(4) == I))) THEN
1136 NPOLB=NPOLB+1
1137 NPPMAX=MAX(NPPMAX,PTR_CUR%IPOLY(2))
1138 ENDIF
1139 PTR_CUR => PTR_CUR%PTR
1140 ENDDO
1141 IF (NPOLB == 0) CYCLE
1142C
1143 NRPMAX=4+3*NPPMAX
1144 ALLOCATE(POLB(NPOLB), IPOLY(6+NPPMAX,NPOLB),
1145 . RPOLY(NRPMAX,NPOLB), REDIR(NPOLB))
1146 DO INZ=1,IIZ+1
1147 NPOLB=0
1148 ITYZINT=0
1149 PTR_CUR => FIRST
1150 DO J=1,NPOLY
1151 ITY=PTR_CUR%IPOLY(1)
1152 ITYZ=PTR_CUR%IZ(1)
1153.AND..OR. IF (((ITY == 1PTR_CUR%IPOLY(4) == I)
1154.AND..OR. . (ITY == 2(PTR_CUR%IPOLY(3) == I
1155 . PTR_CUR%IPOLY(4) == I)))
1156.AND. .
1157.AND..OR. . ((ITYZ == 1PTR_CUR%IZ(2) == INZ)
1158.AND..OR. . (ITYZ == 2(PTR_CUR%IZ(2) == INZ
1159 . PTR_CUR%IZ(3) == INZ)))) THEN
1160 NPOLB=NPOLB+1
1161 REDIR(NPOLB)=J
1162 NN=PTR_CUR%IPOLY(2)
1163.AND. IF(ITY==1ITYZINT==0) THEN
1164 IEL=PTR_CUR%IPOLY(3) ! 1<IEL<NELA
1165 IF(TAGELA(IEL) > NEL) ITYZINT=1
1166 ENDIF
1167 DO K=1,6+NN
1168 IPOLY(K,NPOLB)=PTR_CUR%IPOLY(K)
1169 ENDDO
1170 DO K=1,4+3*NN
1171 RPOLY(K,NPOLB)=PTR_CUR%RPOLY(K)
1172 ENDDO
1173 POLB(NPOLB)=NPOLB
1174 ENDIF
1175 PTR_CUR => PTR_CUR%PTR
1176 ENDDO
1177 IF (NPOLB == 0) CYCLE
1178C
1179 NPHMAX=NPOLB
1180 NPOLHMAX=NLAYER
1181C
1182 300 CONTINUE
1183 IF (ALLOCATED(POLH)) DEALLOCATE(POLH)
1184 ALLOCATE(POLH(NPHMAX+2,NPOLHMAX))
1185C
1186 IF(ITYZINT==0) THEN
1187 CALL POLYHEDR(IPOLY, RPOLY , POLB, NPOLB, POLH,
1188 . NNP, NRPMAX , NPHMAX, I, DXM ,
1189 . INFO , NPOLHMAX, NPPMAX )
1190 ELSE
1191 CALL POLYHEDR1(IPOLY, RPOLY , POLB, NPOLB, POLH,
1192 . NNP, NRPMAX , NPHMAX, I, DXM ,
1193 . INFO , NPOLHMAX, NPPMAX, NEL , INZ ,
1194 . TAGELA )
1195 ENDIF
1196 IF (INFO == 1) GOTO 300
1197C Modifications des polygones
1198 PTR_CUR => FIRST
1199 NPL=1
1200 POLC=REDIR(POLB(NPL))
1201 DO J=1,NPOLY
1202 IF (J == POLC) THEN
1203 ITY=PTR_CUR%IPOLY(1)
1204 IF (ITY == 1) THEN
1205 PTR_CUR%IPOLY(5)=NPOLH+IPOLY(5,NPL)
1206 IEL=PTR_CUR%IPOLY(3)
1207 IF(TAGELA(IEL) > NEL) THEN
1208 PTR_CUR%IPOLY(6)=NPOLH+IPOLY(6,NPL)
1209 ENDIF
1210 ELSEIF (ITY == 2) THEN
1211 IF (PTR_CUR%IPOLY(5) == 0) THEN
1212 PTR_CUR%IPOLY(5)=NPOLH+IPOLY(5,NPL)
1213 ELSE
1214 PTR_CUR%IPOLY(6)=NPOLH+IPOLY(6,NPL)
1215 ENDIF
1216 ENDIF
1217 IF (NPL == NPOLB) GOTO 350
1218 NPL=NPL+1
1219 POLC=REDIR(POLB(NPL))
1220 ENDIF
1221 PTR_CUR => PTR_CUR%PTR
1222 ENDDO
1223 350 CONTINUE
1224C
1225 DO N=1,NNP
1226 NPOLH=NPOLH+1
1227
1228.NOT. IF (ASSOCIATED(PHFIRST)) THEN
1229 ALLOCATE(PHFIRST)
1230 PH_CUR => PHFIRST
1231 ELSE
1232 ALLOCATE(PH_CUR)
1233 PH_PREC%PTR => PH_CUR
1234 ENDIF
1235 NN=POLH(1,N)
1236 ALLOCATE(PH_CUR%POLH(2+NN))
1237 PH_CUR%RANK=NPOLH
1238 PH_CUR%POLH(1)=POLH(1,N)
1239 PH_CUR%POLH(2)=POLH(2,N)
1240 DO M=1,NN
1241 PH_CUR%POLH(2+M)=REDIR(POLH(2+M,N))
1242 ENDDO
1243 PH_PREC => PH_CUR
1244 ENDDO
1245C
1246 ENDDO !INZ=1,IIZ+1
1247 DEALLOCATE(IPOLY, RPOLY, POLB, POLH, REDIR)
1248 ENDDO !I=1,NBRIC
1249C---------------------------------------------------
1250C Passage listes chainees -> tableaux classiques pour la suite des traitements
1251C---------------------------------------------------
1252 370 CONTINUE
1253C
1254 PTR_CUR => FIRST
1255 LENIMAX=0
1256 LENRMAX=0
1257 NNS=0
1258 NNS2=0
1259 DO I=1,NPOLY
1260 NN=PTR_CUR%IPOLY(2)
1261 NNS=NNS+NN
1262 NNS2=NNS2+PTR_CUR%NNSP
1263 IF (PTR_CUR%IPOLY(1) == 1) THEN
1264 LENIMAX=MAX(LENIMAX,6+NN+1)
1265 LENRMAX=MAX(LENRMAX,4+3*NN)
1266 ELSEIF (PTR_CUR%IPOLY(1) == 2) THEN
1267 NHOL=PTR_CUR%IPOLY(6+NN+1)
1268 LENIMAX=MAX(LENIMAX,6+NN+1+NHOL)
1269 LENRMAX=MAX(LENRMAX,4+3*NN+3*NHOL)
1270 ENDIF
1271 PTR_CUR => PTR_CUR%PTR
1272 ENDDO
1273 PH_CUR => PHFIRST
1274 NPHMAX=0
1275C
1276 DO I=1,NPOLH
1277 NN=PH_CUR%POLH(1)
1278 NPHMAX=MAX(NPHMAX,NN)
1279 PH_CUR => PH_CUR%PTR
1280 ENDDO
1281C
1282 NPOLY_OLD=NPOLY
1283 NPOLH_OLD=NPOLH
1284C--------------------------------------------
1285C Briques additionelles
1286C--------------------------------------------
1287 IF (NBA > 0) THEN
1288 NPOLH=NPOLH+NBA
1289 DO I=1,NBA
1290 ITAGBA(I)=0
1291 ENDDO
1292C
1293 DO I=1,NB_NODE
1294 ITAGN(I)=0
1295 ENDDO
1296 DO IEL=1,NEL
1297 N1=IBUF(ELEM(1,IEL))
1298 N2=IBUF(ELEM(2,IEL))
1299 N3=IBUF(ELEM(3,IEL))
1300 ITAGN(N1)=1
1301 ITAGN(N2)=1
1302 ITAGN(N3)=1
1303 ENDDO
1304C
1305 COUNT_ELEM_INT_OLD = 0
1306 COUNT_ELEM_EXT_OLD = 0
1307 COUNT_TRIA_INTERNE_OLD = 0
1308 DO I=1,NBA
1309 NTYPE=TBA(2,I)
1310 NFAC=NFACE(NTYPE)
1311 NNP=0
1312 DO J=1,NFAC
1313 ITY=TFACA(2*(J-1)+1,I)
1314.OR. IF (ITY == 1 ITY == -2) THEN
1315C Face interne brique/brique
1316 NV=TFACA(2*(J-1)+2,I)
1317 IF (ITAGBA(NV) == 0) THEN
1318 IF (ITY == 1) COUNT_TRIA_INTERNE_OLD = COUNT_TRIA_INTERNE_OLD + 1
1319 IF (ITY == -2) COUNT_ELEM_INT_OLD = COUNT_ELEM_INT_OLD + 1
1320 LENIMAX=MAX(LENIMAX,6+3+1)
1321 LENRMAX=MAX(LENRMAX,6+3*3)
1322 IF (NTYPE==2) THEN
1323 NPOLY=NPOLY+1
1324 NNS=NNS+3
1325 ELSEIF (NTYPE==3) THEN
1326 IF(J <= 2) THEN
1327 NPOLY=NPOLY+1
1328 NNS=NNS+3
1329 ELSE
1330 NPOLY=NPOLY+2
1331 NNS=NNS+6
1332 ENDIF
1333 ELSEIF (NTYPE==4) THEN
1334 IF(J <= 4) THEN
1335 NPOLY=NPOLY+1
1336 NNS=NNS+3
1337 ELSE
1338 NPOLY=NPOLY+2
1339 NNS=NNS+6
1340 ENDIF
1341 ELSEIF (NTYPE==1) THEN
1342 NPOLY=NPOLY+2
1343 NNS=NNS+6
1344 ENDIF
1345 ENDIF
1346C
1347 IF (NTYPE==2) THEN
1348 NNP=NNP+1
1349 ELSEIF (NTYPE==3) THEN
1350 IF(J <= 2) THEN
1351 NNP=NNP+1
1352 ELSE
1353 NNP=NNP+2
1354 ENDIF
1355 ELSEIF (NTYPE==4) THEN
1356 IF(J <= 4) THEN
1357 NNP=NNP+1
1358 ELSE
1359 NNP=NNP+2
1360 ENDIF
1361 ELSEIF (NTYPE==1) THEN
1362 NNP=NNP+2
1363 ENDIF
1364C
1365 ELSEIF (ITY == 2) THEN
1366C Face brique appuyee sur surface externe (ity == 2)
1367 COUNT_ELEM_EXT_OLD = COUNT_ELEM_EXT_OLD + 1
1368 IF (NTYPE==2) THEN
1369 NPOLY=NPOLY+1
1370 NNS=NNS+3
1371 NNP=NNP+1
1372 ELSEIF (NTYPE==3) THEN
1373 IF(J <= 2) THEN
1374 NPOLY=NPOLY+1
1375 NNS=NNS+3
1376 NNP=NNP+1
1377 ELSE
1378 NPOLY=NPOLY+2
1379 NNS=NNS+6
1380 NNP=NNP+2
1381 ENDIF
1382 ELSEIF (NTYPE==4) THEN
1383 IF(J <= 4) THEN
1384 NPOLY=NPOLY+1
1385 NNS=NNS+3
1386 NNP=NNP+1
1387 ELSE
1388 NPOLY=NPOLY+2
1389 NNS=NNS+6
1390 NNP=NNP+2
1391 ENDIF
1392 ELSEIF (NTYPE==1) THEN
1393 NPOLY=NPOLY+2
1394 NNS=NNS+6
1395 NNP=NNP+2
1396 ENDIF
1397C
1398 ELSEIF (ITY == 3) THEN
1399C Face interne brique/polyedres
1400 PTR_CUR => FIRST
1401 DO K=1,NPOLY_OLD
1402 IF (PTR_CUR%IPOLY(1) == 1) THEN
1403 IEL=PTR_CUR%IPOLY(3)
1404 IF (-TAGELA(IEL) == I) NNP=NNP+1
1405 ENDIF
1406 PTR_CUR => PTR_CUR%PTR
1407 ENDDO
1408 ENDIF
1409 ENDDO !J=1,NFAC
1410 ITAGBA(I)=1
1411 NPHMAX=MAX(NPHMAX,NNP)
1412C Calcul de IBSA =1 si tous les noeuds de la brique sont sur l'airbag =0 autrement
1413 II=TBA(1,I)
1414 NALL=1
1415 IF (NTYPE==2) THEN
1416 DO J=1,4
1417 JJ=IXS(1+2*(J-1)+1,II)
1418 NALL=NALL*ITAGN(JJ)
1419 ENDDO
1420 ELSEIF (NTYPE==3) THEN
1421 DO J=1,3
1422 JJ=IXS(1+J,II)
1423 NALL=NALL*ITAGN(JJ)
1424 ENDDO
1425 DO J=4,6
1426 JJ=IXS(1+J+1,II)
1427 NALL=NALL*ITAGN(JJ)
1428 ENDDO
1429 ELSEIF (NTYPE==4) THEN
1430 DO J=1,5
1431 JJ=IXS(1+J,II)
1432 NALL=NALL*ITAGN(JJ)
1433 ENDDO
1434 ELSEIF (NTYPE==1) THEN
1435 DO J=1,8
1436 JJ=IXS(1+J,II)
1437 NALL=NALL*ITAGN(JJ)
1438 ENDDO
1439 ENDIF
1440 IBSA(I)=NALL
1441 ENDDO !I=1,NBA
1442 ENDIF
1443C
1444 ALLOCATE(IPOLY_F(LENIMAX,NPOLY), RPOLY_F(LENRMAX,NPOLY),
1445 . POLH_F(2+NPHMAX,NPOLH), IFVNOD(NNS), VOLU(NPOLH),
1446 . IFVNOD2(2,NNS2), RFVNOD2(4,NNS2), XNS(3,NNS),
1447 . XNS2(3,NNS2))
1448C
1449 NPOLY=NPOLY_OLD
1450 NPOLH=NPOLH_OLD
1451
1452 VOLU(1:NPOLH) = 0
1453 IMAX = 0
1454 PTR_CUR => FIRST
1455 NNS=0
1456 DO I=1,NPOLY
1457 NN=PTR_CUR%IPOLY(2)
1458 DO J=1,NN
1459 JJ=PTR_CUR%IPOLY(6+J)
1460 IF (JJ > 0) THEN
1461 NNS=NNS+1
1462 XNS(1,NNS)=PTR_CUR%RPOLY(4+3*(J-1)+1)
1463 XNS(2,NNS)=PTR_CUR%RPOLY(4+3*(J-1)+2)
1464 XNS(3,NNS)=PTR_CUR%RPOLY(4+3*(J-1)+3)
1465 ENDIF
1466 ENDDO
1467 PTR_CUR => PTR_CUR%PTR
1468 ENDDO
1469C
1470 NNS=0
1471 PTR_CUR => FIRST
1472 DO I=1,NPOLY
1473 NN=PTR_CUR%IPOLY(2)
1474 DO J=1,6
1475 IPOLY_F(J,I)=PTR_CUR%IPOLY(J)
1476 ENDDO
1477 DO J=1,4+3*NN
1478 RPOLY_F(J,I)=PTR_CUR%RPOLY(J)
1479 ENDDO
1480 DO J=1,NN
1481 JJ=PTR_CUR%IPOLY(6+J)
1482 IF (JJ > 0) THEN
1483 NNS=NNS+1
1484 IPOLY_F(6+J,I)=NNS
1485 IFVNOD(NNS)=PTR_CUR%IELNOD(J)
1486 ELSE
1487 IPOLY_F(6+J,I)=JJ
1488 ENDIF
1489 ENDDO
1490 IF (PTR_CUR%IPOLY(1) == 1) THEN
1491 IEL=IPOLY_F(3,I)
1492 IF(TAGELA(IEL) < 0 ) THEN
1493 IPOLY_F(4,I)=IPOLY_F(5,I)
1494 IPOLY_F(5,I)=0
1495 ELSEIF(TAGELA(IEL) > 0) THEN
1496 IF(TAGELA(IEL) <= NEL) THEN
1497 IPOLY_F(4,I)=IPOLY_F(5,I)
1498 IPOLY_F(5,I)=0
1499 ENDIF
1500 ENDIF
1501 ELSEIF (PTR_CUR%IPOLY(1) == 2) THEN
1502 NHOL=PTR_CUR%IPOLY(6+NN+1)
1503 IPOLY_F(6+NN+1,I)=NHOL
1504 DO J=1,NHOL
1505 IPOLY_F(6+NN+1+J,I)=PTR_CUR%IPOLY(6+NN+1+J)
1506 RPOLY_F(4+3*NN+3*(J-1)+1,I)=
1507 . PTR_CUR%RPOLY(4+3*NN+3*(J-1)+1)
1508 RPOLY_F(4+3*NN+3*(J-1)+2,I)=
1509 . PTR_CUR%RPOLY(4+3*NN+3*(J-1)+2)
1510 RPOLY_F(4+3*NN+3*(J-1)+3,I)=
1511 . PTR_CUR%RPOLY(4+3*NN+3*(J-1)+3)
1512 ENDDO
1513 ENDIF
1514 NNSP=PTR_CUR%NNSP
1515 IF (NNSP > 0) THEN
1516 DO J=1,NNSP
1517 JJ=PTR_CUR%NREF(1,J)
1518 IFVNOD2(1,JJ)=PTR_CUR%NREF(2,J)
1519 IFVNOD2(2,JJ)=PTR_CUR%NREF(3,J)
1520 RFVNOD2(1,JJ)=PTR_CUR%AREF(1,J)
1521 RFVNOD2(2,JJ)=PTR_CUR%AREF(2,J)
1522 RFVNOD2(3,JJ)=PTR_CUR%AREF(3,J)
1523 RFVNOD2(4,JJ)=PTR_CUR%AREF(4,J)
1524 ENDDO
1525 ENDIF
1526 PTR_TMP => PTR_CUR%PTR
1527 DEALLOCATE(PTR_CUR%IPOLY, PTR_CUR%RPOLY, PTR_CUR%IELNOD)
1528 IF (NNSP > 0) DEALLOCATE(PTR_CUR%NREF, PTR_CUR%AREF)
1529 DEALLOCATE(PTR_CUR)
1530 PTR_CUR => PTR_TMP
1531 ENDDO
1532C
1533 DO I=1,NNS2
1534 N1=IFVNOD2(1,I)
1535 N2=IFVNOD2(2,I)
1536 IDEP=0
1537 IF (N1 < 0) THEN
1538 II=-N1
1539.AND. IF (IFVNOD2(1,II) /= N2IFVNOD2(2,II) /= N2) THEN
1540 WRITE(ISTDO,*) 'problem dependant node ',I
1541 CALL MY_EXIT(2)
1542 ENDIF
1543 N1=IFVNOD2(1,II)
1544 N2=IFVNOD2(2,II)
1545 IDEP=1
1546 ELSEIF (N2 < 0) THEN
1547 II=-N2
1548.AND. IF (IFVNOD2(1,II) /= N1IFVNOD2(2,II) /= N1) THEN
1549 WRITE(ISTDO,*) 'problem dependant node ',I
1550 CALL MY_EXIT(2)
1551 ENDIF
1552 N1=IFVNOD2(1,II)
1553 N2=IFVNOD2(2,II)
1554 IDEP=1
1555 ENDIF
1556 IFVNOD2(1,I)=N1
1557 IFVNOD2(2,I)=N2
1558 IF (IDEP == 1) THEN
1559C Recalcul des coordonnees barycentriques du point dependant
1560 II=1
1561 VAL=ABS(XNS(1,N1)-XNS(1,N2))
1562 DO J=2,3
1563 IF (ABS(XNS(J,N1)-XNS(J,N2)) > VAL) THEN
1564 II=J
1565 VAL=ABS(XNS(J,N1)-XNS(J,N2))
1566 ENDIF
1567 ENDDO
1568 RFVNOD2(1,I)=(RFVNOD2(II+1,I)-XNS(II,N2))/
1569 . (XNS(II,N1)-XNS(II,N2))
1570 ENDIF
1571 ENDDO
1572C
1573 PH_CUR => PHFIRST
1574 DO I=1,NPOLH
1575 NN=PH_CUR%POLH(1)
1576 DO J=1,2+NN
1577 POLH_F(J,I)=PH_CUR%POLH(J)
1578 ENDDO
1579 PH_TMP => PH_CUR%PTR
1580 DEALLOCATE(PH_CUR%POLH)
1581 DEALLOCATE(PH_CUR)
1582 PH_CUR => PH_TMP
1583 ENDDO
1584C
1585 ALLOCATE(IFLAG(NB_NODE))
1586 IFLAG(1:NB_NODE) = 0
1587
1588 IF (NBA > 0) THEN
1589 DO I=1,NBA
1590 ITAGBA(I)=0
1591 ENDDO
1592C
1593 COUNT_ELEM_INT = 0
1594 COUNT_ELEM_EXT = 0
1595 COUNT_TRIA_INTERNE = 0
1596 NPOLY_OLD=NPOLY
1597 DO I=1,NBA
1598 II=TBA(1,I)
1599 NTYPE=TBA(2,I)
1600 NFAC=NFACE(NTYPE)
1601 NNP=0
1602 DO J=1,NFAC
1603 ITY=TFACA(2*(J-1)+1,I)
1604 IF (ITY == 1) THEN
1605C Face interne brique/brique
1606 NV=TFACA(2*(J-1)+2,I)
1607 IF (ITAGBA(NV) == 0) THEN
1608 COUNT_TRIA_INTERNE = COUNT_TRIA_INTERNE + 1
1609 IF (NTYPE==2) THEN
1610 IQUAD=0
1611 N1=FAC4(1,J)
1612 N2=FAC4(2,J)
1613 N3=FAC4(3,J)
1614 ELSEIF (NTYPE==3) THEN
1615 IF(J <= 2) THEN
1616 IQUAD=0
1617 N1=FAC6(1,J)
1618 N2=FAC6(2,J)
1619 N3=FAC6(3,J)
1620 ELSE
1621 IQUAD=1
1622 N1=FAC6(1,J)
1623 N2=FAC6(2,J)
1624 N3=FAC6(3,J)
1625 N4=FAC6(4,J)
1626 ENDIF
1627 ELSEIF (NTYPE==4) THEN
1628 IF(J <= 4) THEN
1629 IQUAD=0
1630 N1=FAC5(1,J)
1631 N2=FAC5(2,J)
1632 N3=FAC5(3,J)
1633 ELSE
1634 IQUAD=1
1635 N1=FAC5(1,J)
1636 N2=FAC5(2,J)
1637 N3=FAC5(3,J)
1638 N4=FAC5(4,J)
1639 ENDIF
1640 ELSEIF (NTYPE==1) THEN
1641 IQUAD=1
1642 N1=FAC(1,J)
1643 N2=FAC(2,J)
1644 N3=FAC(3,J)
1645 N4=FAC(4,J)
1646 ENDIF
1647C
1648 IF(IQUAD==0) THEN
1649C Face=triangle
1650 NPOLY=NPOLY+1
1651 IPOLY_F(1,NPOLY)=2
1652 IPOLY_F(2,NPOLY)=3
1653 IPOLY_F(3,NPOLY)=0
1654 IPOLY_F(4,NPOLY)=0
1655 IPOLY_F(5,NPOLY)=NPOLH+I
1656 IPOLY_F(6,NPOLY)=NPOLH+NV
1657 IPOLY_F(6+1,NPOLY)=NNS+1
1658 IPOLY_F(6+2,NPOLY)=NNS+2
1659 IPOLY_F(6+3,NPOLY)=NNS+3
1660 IPOLY_F(6+3+1,NPOLY)=0
1661C
1662 NN1=IXS(1+N1,II)
1663 NN2=IXS(1+N2,II)
1664 NN3=IXS(1+N3,II)
1665 IFVNOD(NNS+1)=-NN1
1666 IFVNOD(NNS+2)=-NN2
1667 IFVNOD(NNS+3)=-NN3
1668 NNS=NNS+3
1669 X1=X(1,NN1)
1670 Y1=X(2,NN1)
1671 Z1=X(3,NN1)
1672 X2=X(1,NN2)
1673 Y2=X(2,NN2)
1674 Z2=X(3,NN2)
1675 X3=X(1,NN3)
1676 Y3=X(2,NN3)
1677 Z3=X(3,NN3)
1678 CALL FVNORMAL(X,NN1,NN2,NN3,0,NRX,NRY,NRZ)
1679 AREA2=SQRT(NRX**2+NRY**2+NRZ**2)
1680 RPOLY_F(2,NPOLY)=NRX/AREA2
1681 RPOLY_F(3,NPOLY)=NRY/AREA2
1682 RPOLY_F(4,NPOLY)=NRZ/AREA2
1683 RPOLY_F(4+1,NPOLY)=X1
1684 RPOLY_F(4+2,NPOLY)=Y1
1685 RPOLY_F(4+3,NPOLY)=Z1
1686 RPOLY_F(4+4,NPOLY)=X2
1687 RPOLY_F(4+5,NPOLY)=Y2
1688 RPOLY_F(4+6,NPOLY)=Z2
1689 RPOLY_F(4+7,NPOLY)=X3
1690 RPOLY_F(4+8,NPOLY)=Y3
1691 RPOLY_F(4+9,NPOLY)=Z3
1692C
1693 NNP=NNP+1
1694 POLH_F(2+NNP,NPOLH+I)=NPOLY
1695 ELSEIF(IQUAD==1) THEN
1696C Face=quadrangle
1697 NN1=IXS(1+N1,II)
1698 NN2=IXS(1+N2,II)
1699 NN3=IXS(1+N3,II)
1700 NN4=IXS(1+N4,II)
1701 X1=X(1,NN1)
1702 Y1=X(2,NN1)
1703 Z1=X(3,NN1)
1704 X2=X(1,NN2)
1705 Y2=X(2,NN2)
1706 Z2=X(3,NN2)
1707 X3=X(1,NN3)
1708 Y3=X(2,NN3)
1709 Z3=X(3,NN3)
1710 X4=X(1,NN4)
1711 Y4=X(2,NN4)
1712 Z4=X(3,NN4)
1713C
1714 NPOLY=NPOLY+1
1715 IPOLY_F(1,NPOLY)=2
1716 IPOLY_F(2,NPOLY)=3
1717 IPOLY_F(3,NPOLY)=0
1718 IPOLY_F(4,NPOLY)=0
1719 IPOLY_F(5,NPOLY)=NPOLH+I
1720 IPOLY_F(6,NPOLY)=NPOLH+NV
1721 IPOLY_F(6+1,NPOLY)=NNS+1
1722 IPOLY_F(6+2,NPOLY)=NNS+2
1723 IPOLY_F(6+3,NPOLY)=NNS+3
1724 IPOLY_F(6+3+1,NPOLY)=0
1725 IFVNOD(NNS+1)=-NN1
1726 IFVNOD(NNS+2)=-NN2
1727 IFVNOD(NNS+3)=-NN3
1728 NNS=NNS+3
1729 CALL FVNORMAL(X,NN1,NN2,NN3,0,NRX,NRY,NRZ)
1730 AREA2=SQRT(NRX**2+NRY**2+NRZ**2)
1731 RPOLY_F(2,NPOLY)=NRX/AREA2
1732 RPOLY_F(3,NPOLY)=NRY/AREA2
1733 RPOLY_F(4,NPOLY)=NRZ/AREA2
1734 RPOLY_F(4+1,NPOLY)=X1
1735 RPOLY_F(4+2,NPOLY)=Y1
1736 RPOLY_F(4+3,NPOLY)=Z1
1737 RPOLY_F(4+4,NPOLY)=X2
1738 RPOLY_F(4+5,NPOLY)=Y2
1739 RPOLY_F(4+6,NPOLY)=Z2
1740 RPOLY_F(4+7,NPOLY)=X3
1741 RPOLY_F(4+8,NPOLY)=Y3
1742 RPOLY_F(4+9,NPOLY)=Z3
1743C
1744 NNP=NNP+1
1745 POLH_F(2+NNP,NPOLH+I)=NPOLY
1746C
1747 NPOLY=NPOLY+1
1748 IPOLY_F(1,NPOLY)=2
1749 IPOLY_F(2,NPOLY)=3
1750 IPOLY_F(3,NPOLY)=0
1751 IPOLY_F(4,NPOLY)=0
1752 IPOLY_F(5,NPOLY)=NPOLH+I
1753 IPOLY_F(6,NPOLY)=NPOLH+NV
1754 IPOLY_F(6+1,NPOLY)=NNS+1
1755 IPOLY_F(6+2,NPOLY)=NNS+2
1756 IPOLY_F(6+3,NPOLY)=NNS+3
1757 IPOLY_F(6+3+1,NPOLY)=0
1758 IFVNOD(NNS+1)=-NN1
1759 IFVNOD(NNS+2)=-NN3
1760 IFVNOD(NNS+3)=-NN4
1761 NNS=NNS+3
1762 CALL FVNORMAL(X,NN1,NN3,NN4,0,NRX,NRY,NRZ)
1763 AREA2=SQRT(NRX**2+NRY**2+NRZ**2)
1764 RPOLY_F(2,NPOLY)=NRX/AREA2
1765 RPOLY_F(3,NPOLY)=NRY/AREA2
1766 RPOLY_F(4,NPOLY)=NRZ/AREA2
1767 RPOLY_F(4+1,NPOLY)=X1
1768 RPOLY_F(4+2,NPOLY)=Y1
1769 RPOLY_F(4+3,NPOLY)=Z1
1770 RPOLY_F(4+4,NPOLY)=X3
1771 RPOLY_F(4+5,NPOLY)=Y3
1772 RPOLY_F(4+6,NPOLY)=Z3
1773 RPOLY_F(4+7,NPOLY)=X4
1774 RPOLY_F(4+8,NPOLY)=Y4
1775 RPOLY_F(4+9,NPOLY)=Z4
1776C
1777 NNP=NNP+1
1778 POLH_F(2+NNP,NPOLH+I)=NPOLY
1779 ENDIF
1780 ELSE
1781 DO K=1,POLH_F(1,NPOLH+NV)
1782 KK=POLH_F(2+K,NPOLH+NV)
1783.AND. IF (IPOLY_F(1,KK) == 2
1784 . IPOLY_F(6,KK) == NPOLH+I) THEN
1785 NNP=NNP+1
1786 POLH_F(2+NNP,NPOLH+I)=KK
1787 ENDIF
1788 ENDDO
1789 ENDIF
1790 ELSEIF (ITY == 2) THEN
1791C Face brique appuyee sur surface externe (traitee plus loin)
1792 COUNT_ELEM_EXT = COUNT_ELEM_EXT + 1
1793 ELSEIF (ITY == -2) THEN
1794C Brick face lying on an internal surface element.
1795C Need to compute the normal in order to ensure proper orientation
1796 COUNT_ELEM_INT = COUNT_ELEM_INT + 1
1797 IF (NTYPE==2) THEN
1798 IQUAD=0
1799 N1=FAC4(1,J)
1800 N2=FAC4(2,J)
1801 N3=FAC4(3,J)
1802 ELSEIF (NTYPE==3) THEN
1803 IF(J <= 2) THEN
1804 IQUAD=0
1805 N1=FAC6(1,J)
1806 N2=FAC6(2,J)
1807 N3=FAC6(3,J)
1808 ELSE
1809 IQUAD=1
1810 N1=FAC6(1,J)
1811 N2=FAC6(2,J)
1812 N3=FAC6(3,J)
1813 N4=FAC6(4,J)
1814 ENDIF
1815 ELSEIF (NTYPE==4) THEN
1816 IF(J <= 4) THEN
1817 IQUAD=0
1818 N1=FAC5(1,J)
1819 N2=FAC5(2,J)
1820 N3=FAC5(3,J)
1821 ELSE
1822 IQUAD=1
1823 N1=FAC5(1,J)
1824 N2=FAC5(2,J)
1825 N3=FAC5(3,J)
1826 N4=FAC5(4,J)
1827 ENDIF
1828 ELSEIF (NTYPE==1) THEN
1829 IQUAD=1
1830 N1=FAC(1,J)
1831 N2=FAC(2,J)
1832 N3=FAC(3,J)
1833 N4=FAC(4,J)
1834 ENDIF
1835 IF (IQUAD == 0) THEN
1836 NN1=IXS(1+N1,II)
1837 NN2=IXS(1+N2,II)
1838 NN3=IXS(1+N3,II)
1839 CALL FVNORMAL(X,NN1,NN2,NN3,0,NRX,NRY,NRZ)
1840 IFLAG(NN1) = 1
1841 IFLAG(NN2) = 1
1842 IFLAG(NN3) = 1
1843 DO IEL = NEL + 1, NEL + NELI
1844 IF (IFLAG(IBUF(ELEM(1, IEL))) * IFLAG(IBUF(ELEM(2, IEL))) *
1845 . IFLAG(IBUF(ELEM(3, IEL))) == 1) THEN
1846 IF (NORM(1, IEL) * NRX + NORM(2, IEL) * NRY + NORM(3, IEL) * NRZ < 0) THEN
1847 IF (TAGELS(2*IEL - NEL - 1) == I) THEN
1848 NORM(1, IEL) = -NORM(1, IEL)
1849 NORM(2, IEL) = -NORM(2, IEL)
1850 NORM(3, IEL) = -NORM(3, IEL)
1851 ENDIF
1852 ENDIF
1853 ENDIF
1854 ENDDO
1855 IFLAG(NN1) = 0
1856 IFLAG(NN2) = 0
1857 IFLAG(NN3) = 0
1858 ELSE IF (IQUAD == 1) THEN
1859 NN1=IXS(1+N1,II)
1860 NN2=IXS(1+N2,II)
1861 NN3=IXS(1+N3,II)
1862 NN4=IXS(1+N4,II)
1863 CALL FVNORMAL(X,NN1,NN2,NN3,0,NRX,NRY,NRZ)
1864 IFLAG(NN1) = 1
1865 IFLAG(NN2) = 1
1866 IFLAG(NN3) = 1
1867 IFLAG(NN4) = 1
1868 DO IEL = NEL + 1, NEL + NELI
1869 IF (IFLAG(IBUF(ELEM(1, IEL))) * IFLAG(IBUF(ELEM(2, IEL))) *
1870 . IFLAG(IBUF(ELEM(3, IEL))) == 1) THEN
1871 IF (NORM(1, IEL) * NRX + NORM(2, IEL) * NRY + NORM(3, IEL) * NRZ < 0) THEN
1872 IF (TAGELS(2*IEL - NEL - 1) == I) THEN
1873 NORM(1, IEL) = -NORM(1, IEL)
1874 NORM(2, IEL) = -NORM(2, IEL)
1875 NORM(3, IEL) = -NORM(3, IEL)
1876 ENDIF
1877 ENDIF
1878 ENDIF
1879 ENDDO
1880 IFLAG(NN1) = 0
1881 IFLAG(NN2) = 0
1882 IFLAG(NN3) = 0
1883 IFLAG(NN4) = 0
1884 ENDIF
1885 ELSEIF (ITY == 3) THEN
1886C Face interne brique/polyedres
1887 DO K=1,NPOLY_OLD
1888 IF (IPOLY_F(1,K) == 1) THEN
1889 IEL=IPOLY_F(3,K)
1890 IF (-TAGELA(IEL) == I) THEN
1891 NNP=NNP+1
1892 POLH_F(2+NNP,NPOLH+I)=K
1893 IPOLY_F(1,K)=2
1894 IPOLY_F(3,K)=0
1895 IP=IPOLY_F(4,K)
1896 IPOLY_F(4,K)=0
1897 IPOLY_F(5,K)=IP
1898 IPOLY_F(6,K)=NPOLH+I
1899 NN=IPOLY_F(2,K)
1900 IPOLY_F(6+NN+1,K)=0
1901 ENDIF
1902 ENDIF
1903 ENDDO
1904 ENDIF
1905 ENDDO
1906 POLH_F(1,NPOLH+I)=NNP
1907 POLH_F(2,NPOLH+I)=-I
1908 ITAGBA(I)=1
1909 ENDDO ! I=1,NBA
1910C
1911 NPOLH=NPOLH+NBA
1912C
1913 DO I=1,NPOLY_OLD
1914 IF (IPOLY_F(1,I) == 1) THEN
1915 IEL=IPOLY_F(3,I)
1916 IF (TAGELA(IEL) > 0) IPOLY_F(3,I)=TAGELA(IEL)
1917 ENDIF
1918 ENDDO
1919C External airbag surface
1920 DO IEL=1,NEL
1921 IF (TAGELS(IEL) > 0) THEN
1922 NPOLY=NPOLY+1
1923 IPOLY_F(1,NPOLY)=1
1924 IPOLY_F(2,NPOLY)=3
1925 IPOLY_F(3,NPOLY)=IEL
1926 IPOLY_F(4,NPOLY)=NPOLH_OLD+TAGELS(IEL)
1927 IPOLY_F(5,NPOLY)=0
1928 IPOLY_F(6,NPOLY)=0
1929 IPOLY_F(7,NPOLY)=NNS+1
1930 IPOLY_F(8,NPOLY)=NNS+2
1931 IPOLY_F(9,NPOLY)=NNS+3
1932 N1=ELEM(1,IEL)
1933 N2=ELEM(2,IEL)
1934 N3=ELEM(3,IEL)
1935 NN1=IBUF(N1)
1936 NN2=IBUF(N2)
1937 NN3=IBUF(N3)
1938 IFVNOD(NNS+1)=-NN1
1939 IFVNOD(NNS+2)=-NN2
1940 IFVNOD(NNS+3)=-NN3
1941 NNS=NNS+3
1942 RPOLY_F(1,NPOLY)=ELAREA(IEL)
1943 RPOLY_F(2,NPOLY)=NORM(1,IEL)
1944 RPOLY_F(3,NPOLY)=NORM(2,IEL)
1945 RPOLY_F(4,NPOLY)=NORM(3,IEL)
1946 X1=X(1,NN1)
1947 Y1=X(2,NN1)
1948 Z1=X(3,NN1)
1949 X2=X(1,NN2)
1950 Y2=X(2,NN2)
1951 Z2=X(3,NN2)
1952 X3=X(1,NN3)
1953 Y3=X(2,NN3)
1954 Z3=X(3,NN3)
1955 RPOLY_F(5,NPOLY)=X1
1956 RPOLY_F(6,NPOLY)=Y1
1957 RPOLY_F(7,NPOLY)=Z1
1958 RPOLY_F(8,NPOLY)=X2
1959 RPOLY_F(9,NPOLY)=Y2
1960 RPOLY_F(10,NPOLY)=Z2
1961 RPOLY_F(11,NPOLY)=X3
1962 RPOLY_F(12,NPOLY)=Y3
1963 RPOLY_F(13,NPOLY)=Z3
1964C
1965 NNP=POLH_F(1,NPOLH_OLD+TAGELS(IEL))
1966 NNP=NNP+1
1967 POLH_F(1,NPOLH_OLD+TAGELS(IEL))=NNP
1968 POLH_F(2+NNP,NPOLH_OLD+TAGELS(IEL))=NPOLY
1969 ENDIF
1970 ENDDO
1971C Internal airbag surface
1972 DO IEL=NEL + 1,NEL + NELI
1973 IF (TAGELS(2*IEL-NEL-1) > 0) THEN
1974 NPOLY=NPOLY+1
1975 IPOLY_F(1,NPOLY)=3
1976 IPOLY_F(2,NPOLY)=3
1977 IPOLY_F(3,NPOLY)=IEL
1978 IPOLY_F(4,NPOLY)=NPOLH_OLD + TAGELS(2 * IEL - NEL - 1)
1979 IPOLY_F(5,NPOLY)=NPOLH_OLD + TAGELS(2*IEL-NEL-1)
1980 IPOLY_F(6,NPOLY)=NPOLH_OLD + TAGELS(2*IEL-NEL)
1981 IPOLY_F(7,NPOLY)=NNS+1
1982 IPOLY_F(8,NPOLY)=NNS+2
1983 IPOLY_F(9,NPOLY)=NNS+3
1984 N1=ELEM(1,IEL)
1985 N2=ELEM(2,IEL)
1986 N3=ELEM(3,IEL)
1987 NN1=IBUF(N1)
1988 NN2=IBUF(N2)
1989 NN3=IBUF(N3)
1990 IFVNOD(NNS+1)=-NN1
1991 IFVNOD(NNS+2)=-NN2
1992 IFVNOD(NNS+3)=-NN3
1993 NNS=NNS+3
1994 RPOLY_F(1,NPOLY)=ELAREA(IEL)
1995 RPOLY_F(2,NPOLY)=NORM(1,IEL)
1996 RPOLY_F(3,NPOLY)=NORM(2,IEL)
1997 RPOLY_F(4,NPOLY)=NORM(3,IEL)
1998 X1=X(1,NN1)
1999 Y1=X(2,NN1)
2000 Z1=X(3,NN1)
2001 X2=X(1,NN2)
2002 Y2=X(2,NN2)
2003 Z2=X(3,NN2)
2004 X3=X(1,NN3)
2005 Y3=X(2,NN3)
2006 Z3=X(3,NN3)
2007 RPOLY_F(5,NPOLY)=X1
2008 RPOLY_F(6,NPOLY)=Y1
2009 RPOLY_F(7,NPOLY)=Z1
2010 RPOLY_F(8,NPOLY)=X2
2011 RPOLY_F(9,NPOLY)=Y2
2012 RPOLY_F(10,NPOLY)=Z2
2013 RPOLY_F(11,NPOLY)=X3
2014 RPOLY_F(12,NPOLY)=Y3
2015 RPOLY_F(13,NPOLY)=Z3
2016C Internal surface elements have two neighbours
2017 NNP=POLH_F(1,NPOLH_OLD+TAGELS(2*IEL-NEL-1))
2018 NNP=NNP+1
2019 POLH_F(1,NPOLH_OLD+TAGELS(2*IEL-NEL-1))=NNP
2020 POLH_F(2+NNP,NPOLH_OLD+TAGELS(2*IEL-NEL-1))=NPOLY
2021 NNP=POLH_F(1,NPOLH_OLD+TAGELS(2*IEL-NEL))
2022 NNP=NNP+1
2023 POLH_F(1,NPOLH_OLD+TAGELS(2*IEL-NEL))=NNP
2024 POLH_F(2+NNP,NPOLH_OLD+TAGELS(2*IEL-NEL))=NPOLY
2025 ENDIF
2026 ENDDO
2027 ENDIF
2028C---------------------------------------------------
2029C Surface des polygones
2030C---------------------------------------------------
2031 DO I=1,NPOLY
2032 ITY=IPOLY_F(1,I)
2033 NN=IPOLY_F(2,I)
2034 NHOL=0
2035 IF (ITY == 2) NHOL=IPOLY_F(6+NN+1,I)
2036 AREA=ZERO
2037 NX=RPOLY_F(2,I)
2038 NY=RPOLY_F(3,I)
2039 NZ=RPOLY_F(4,I)
2040 IF (NHOL == 0) THEN
2041 X1=RPOLY_F(5,I)
2042 Y1=RPOLY_F(6,I)
2043 Z1=RPOLY_F(7,I)
2044 DO J=1,NN-2
2045 JJ=J+1
2046 JJJ=JJ+1
2047 X2=RPOLY_F(4+3*(JJ-1)+1,I)
2048 Y2=RPOLY_F(4+3*(JJ-1)+2,I)
2049 Z2=RPOLY_F(4+3*(JJ-1)+3,I)
2050 X3=RPOLY_F(4+3*(JJJ-1)+1,I)
2051 Y3=RPOLY_F(4+3*(JJJ-1)+2,I)
2052 Z3=RPOLY_F(4+3*(JJJ-1)+3,I)
2053 X12=X2-X1
2054 Y12=Y2-Y1
2055 Z12=Z2-Z1
2056 X13=X3-X1
2057 Y13=Y3-Y1
2058 Z13=Z3-Z1
2059 NNX=Y12*Z13-Z12*Y13
2060 NNY=Z12*X13-X12*Z13
2061 NNZ=X12*Y13-Y12*X13
2062 AREA=AREA+(NNX*NX+NNY*NY+NNZ*NZ)
2063 ENDDO
2064 ELSE
2065 ALLOCATE(ADR(NHOL+1))
2066 DO J=1,NHOL
2067 ADR(J)=IPOLY_F(6+NN+1+J,I)
2068 ENDDO
2069 ADR(NHOL+1)=NN
2070 X1=RPOLY_F(5,I)
2071 Y1=RPOLY_F(6,I)
2072 Z1=RPOLY_F(7,I)
2073 DO J=1,ADR(1)-2
2074 JJ=J+1
2075 JJJ=JJ+1
2076 X2=RPOLY_F(4+3*(JJ-1)+1,I)
2077 Y2=RPOLY_F(4+3*(JJ-1)+2,I)
2078 Z2=RPOLY_F(4+3*(JJ-1)+3,I)
2079 X3=RPOLY_F(4+3*(JJJ-1)+1,I)
2080 Y3=RPOLY_F(4+3*(JJJ-1)+2,I)
2081 Z3=RPOLY_F(4+3*(JJJ-1)+3,I)
2082 X12=X2-X1
2083 Y12=Y2-Y1
2084 Z12=Z2-Z1
2085 X13=X3-X1
2086 Y13=Y3-Y1
2087 Z13=Z3-Z1
2088 NNX=Y12*Z13-Z12*Y13
2089 NNY=Z12*X13-X12*Z13
2090 NNZ=X12*Y13-Y12*X13
2091 AREA=AREA+(NNX*NX+NNY*NY+NNZ*NZ)
2092 ENDDO
2093 AREA=ABS(AREA)
2094C On retranche la surface des trous
2095 DO J=1,NHOL
2096 X1=RPOLY_F(4+3*ADR(J)+1,I)
2097 Y1=RPOLY_F(4+3*ADR(J)+2,I)
2098 Z1=RPOLY_F(4+3*ADR(J)+3,I)
2099 AREA2=ZERO
2100 DO K=ADR(J)+1,ADR(J+1)-2
2101 KK=K+1
2102 KKK=KK+1
2103 X2=RPOLY_F(4+3*(KK-1)+1,I)
2104 Y2=RPOLY_F(4+3*(KK-1)+2,I)
2105 Z2=RPOLY_F(4+3*(KK-1)+3,I)
2106 X3=RPOLY_F(4+3*(KKK-1)+1,I)
2107 Y3=RPOLY_F(4+3*(KKK-1)+2,I)
2108 Z3=RPOLY_F(4+3*(KKK-1)+3,I)
2109 X12=X2-X1
2110 Y12=Y2-Y1
2111 Z12=Z2-Z1
2112 X13=X3-X1
2113 Y13=Y3-Y1
2114 Z13=Z3-Z1
2115 NNX=Y12*Z13-Z12*Y13
2116 NNY=Z12*X13-X12*Z13
2117 NNZ=X12*Y13-Y12*X13
2118 AREA2=AREA2+(NNX*NX+NNY*NY+NNZ*NZ)
2119 ENDDO
2120 AREA=AREA-ABS(AREA2)
2121 ENDDO
2122 DEALLOCATE(ADR)
2123 ENDIF
2124 RPOLY_F(1,I)=HALF*ABS(AREA)
2125 ENDDO
2126C---------------------------------------------------
2127C Volume des polyedres
2128C---------------------------------------------------
2129 DO I=1,NPOLH
2130 VOLU(I)=ZERO
2131 DO J=1,POLH_F(1,I)
2132 JJ=POLH_F(2+J,I)
2133 AREA=RPOLY_F(1,JJ)
2134 ITY=IPOLY_F(1,JJ)
2135 IF (ITY == 1) THEN
2136 IEL=IPOLY_F(3,JJ)
2137 IF(TAGELS(IEL) > 0) THEN
2138 NX=RPOLY_F(2,JJ)
2139 NY=RPOLY_F(3,JJ)
2140 NZ=RPOLY_F(4,JJ)
2141 ELSEIF(TAGELS(IEL) == 0) THEN
2142 IF(IEL <= NEL) THEN
2143 NX=RPOLY_F(2,JJ)
2144 NY=RPOLY_F(3,JJ)
2145 NZ=RPOLY_F(4,JJ)
2146 ELSEIF(IEL > NEL) THEN
2147 IF (IPOLY_F(5,JJ) == I) THEN
2148 NX=RPOLY_F(2,JJ)
2149 NY=RPOLY_F(3,JJ)
2150 NZ=RPOLY_F(4,JJ)
2151 ELSEIF (IPOLY_F(6,JJ) == I) THEN
2152 NX=-RPOLY_F(2,JJ)
2153 NY=-RPOLY_F(3,JJ)
2154 NZ=-RPOLY_F(4,JJ)
2155 ENDIF
2156 ENDIF
2157 ENDIF
2158.OR. ELSEIF (ITY == 2ITY == 3) THEN
2159 IF (IPOLY_F(5,JJ) == I) THEN
2160 NX=RPOLY_F(2,JJ)
2161 NY=RPOLY_F(3,JJ)
2162 NZ=RPOLY_F(4,JJ)
2163 ELSEIF (IPOLY_F(6,JJ) == I) THEN
2164 NX=-RPOLY_F(2,JJ)
2165 NY=-RPOLY_F(3,JJ)
2166 NZ=-RPOLY_F(4,JJ)
2167 ENDIF
2168 ENDIF
2169 X1=RPOLY_F(5,JJ)
2170 Y1=RPOLY_F(6,JJ)
2171 Z1=RPOLY_F(7,JJ)
2172 VOLU(I)=VOLU(I)+THIRD*AREA*(X1*NX+Y1*NY+Z1*NZ)
2173 ENDDO
2174 ENDDO
2175C---------------------------------------------------
2176C Check negative volumes
2177C---------------------------------------------------
2178 IF (ITYP == 8) THEN
2179 DO I = 1, NPOLH
2180 IF (VOLU(I) <= ZERO) THEN
2181 CALL ANCMSG(MSGID = 1627, MSGTYPE = MSGERROR,
2182 . ANMODE = ANINFO,
2183 . I1 = ID,
2184 . C1 = TITR,
2185 . I2 = IXS(11, TBA(1, I)))
2186 ENDIF
2187 ENDDO
2188 ENDIF
2189C---------------------------------------------------
2190C Elimination des segments de longueur nulle dans les polygones
2191C---------------------------------------------------
2192 NNS_OLD=NNS
2193 NNS_OLD_SAVE=NNS_OLD
2194 ALLOCATE(IFVNOD_OLD(NNS_OLD), REDIR(NNS_OLD))
2195 DO I=1,NNS_OLD
2196 IFVNOD_OLD(I)=IFVNOD(I)
2197 ENDDO
2198 NNS_OLD=0
2199 NNS=0
2200C
2201C TOLE=RVOLU(50)
2202 TOLE=EPSILON(ZERO)*0.5
2203 DO I=1,NPOLY
2204 NNP_OLD=IPOLY_F(2,I)
2205C
2206 LMAX2=ZERO
2207 X0=RPOLY_F(5,I)
2208 Y0=RPOLY_F(6,I)
2209 Z0=RPOLY_F(7,I)
2210 DO J=2,NNP_OLD
2211 X1=RPOLY_F(4+3*(J-1)+1,I)
2212 Y1=RPOLY_F(4+3*(J-1)+2,I)
2213 Z1=RPOLY_F(4+3*(J-1)+3,I)
2214 LMAX2=MAX(LMAX2,(X1-X0)**2+(Y1-Y0)**2+(Z1-Z0)**2)
2215 X0=X1
2216 Y0=Y1
2217 Z0=Z1
2218 ENDDO
2219 X1=RPOLY_F(5,I)
2220 Y1=RPOLY_F(6,I)
2221 Z1=RPOLY_F(7,I)
2222 LMAX2=MAX(LMAX2,(X1-X0)**2+(Y1-Y0)**2+(Z1-Z0)**2)
2223 TOLE2=TOLE**2*LMAX2
2224C
2225 NHOL=0
2226 IF (IPOLY_F(1,I) == 2) NHOL=IPOLY_F(6+NNP_OLD+1,I)
2227 ALLOCATE(IPOLY_OLD(NNP_OLD), RPOLY_OLD(3*NNP_OLD),
2228 . ADR_OLD(NHOL+2), ADR(NHOL+2))
2229 DO J=1,NNP_OLD
2230 IPOLY_OLD(J)=IPOLY_F(6+J,I)
2231 ENDDO
2232 DO J=1,3*NNP_OLD
2233 RPOLY_OLD(J)=RPOLY_F(4+J,I)
2234 ENDDO
2235 NNP=0
2236 IF (NHOL == 0) THEN
2237 X0=RPOLY_F(5,I)
2238 Y0=RPOLY_F(6,I)
2239 Z0=RPOLY_F(7,I)
2240 IF (IPOLY_OLD(1) > 0) THEN
2241 NNS_OLD=NNS_OLD+1
2242 IF (NNS_OLD > NNS_OLD_SAVE) THEN
2243 CALL ANCMSG(MSGID=744,
2244 . MSGTYPE=MSGERROR,
2245 . ANMODE=ANINFO,
2246 . I1=ID,
2247 . C1=TITR)
2248 END IF
2249 NNS=NNS+1
2250 REDIR(NNS_OLD)=NNS
2251 IPOLY_F(7,I)=NNS
2252 IFVNOD(NNS)=IFVNOD_OLD(NNS_OLD)
2253 ELSE
2254 IPOLY_F(7,I)=IPOLY_OLD(1)
2255 ENDIF
2256 NNP=NNP+1
2257 J0=1
2258 NNS1=NNS
2259 DO J=2,NNP_OLD
2260 IF (IPOLY_OLD(J) > 0) THEN
2261 NNS_OLD=NNS_OLD+1
2262 IF (NNS_OLD > NNS_OLD_SAVE) THEN
2263 CALL ANCMSG(MSGID=744,
2264 . MSGTYPE=MSGERROR,
2265 . ANMODE=ANINFO,
2266 . I1=ID,
2267 . C1=TITR)
2268 END IF
2269 END IF
2270 X1=RPOLY_OLD(3*(J-1)+1)
2271 Y1=RPOLY_OLD(3*(J-1)+2)
2272 Z1=RPOLY_OLD(3*(J-1)+3)
2273 DD=(X1-X0)**2+(Y1-Y0)**2+(Z1-Z0)**2
2274 IF (DD > TOLE2) THEN
2275 NNP=NNP+1
2276 IF (IPOLY_OLD(J) > 0) THEN
2277 NNS=NNS+1
2278 IFVNOD(NNS)=IFVNOD_OLD(NNS_OLD)
2279 RPOLY_F(4+3*(NNP-1)+1,I)=X1
2280 RPOLY_F(4+3*(NNP-1)+2,I)=Y1
2281 RPOLY_F(4+3*(NNP-1)+3,I)=Z1
2282 IPOLY_F(6+NNP,I)=NNS
2283 ELSE
2284 RPOLY_F(4+3*(NNP-1)+1,I)=X1
2285 RPOLY_F(4+3*(NNP-1)+2,I)=Y1
2286 RPOLY_F(4+3*(NNP-1)+3,I)=Z1
2287 IPOLY_F(6+NNP,I)=IPOLY_OLD(J)
2288 ENDIF
2289 X0=X1
2290 Y0=Y1
2291 Z0=Z1
2292.AND. ELSEIF (IPOLY_OLD(J) > 0
2293 . IPOLY_OLD(J0) < 0) THEN
2294 NNS=NNS+1
2295 IFVNOD(NNS)=IFVNOD_OLD(NNS_OLD)
2296 RPOLY_F(4+3*(NNP-1)+1,I)=X1
2297 RPOLY_F(4+3*(NNP-1)+2,I)=Y1
2298 RPOLY_F(4+3*(NNP-1)+3,I)=Z1
2299 IPOLY_F(6+NNP,I)=NNS
2300 ENDIF
2301 IF (IPOLY_OLD(J) > 0) REDIR(NNS_OLD)=NNS
2302 J0=J
2303 ENDDO
2304 X1=RPOLY_F(5,I)
2305 Y1=RPOLY_F(6,I)
2306 Z1=RPOLY_F(7,I)
2307 DD=(X1-X0)**2+(Y1-Y0)**2+(Z1-Z0)**2
2308.AND. IF (DD <= TOLE2IPOLY_OLD(1) > 0) THEN
2309 REDIR(NNS_OLD)=NNS1
2310 NNS=NNS-1
2311 NNP=NNP-1
2312.AND. ELSEIF (DD <= TOLE2IPOLY_OLD(1) < 0) THEN
2313 NNP=NNP-1
2314 RPOLY_F(5,I)=X0
2315 RPOLY_F(6,I)=Y0
2316 RPOLY_F(7,I)=Z0
2317 IPOLY_F(7,I)=NNS
2318 ENDIF
2319 IPOLY_F(6+NNP+1,I)=0
2320 ELSE
2321 ADR_OLD(1)=0
2322 ADR(1)=0
2323 DO J=1,NHOL
2324 ADR_OLD(J+1)=IPOLY_F(6+NNP_OLD+1+J,I)
2325 ENDDO
2326 ADR_OLD(NHOL+2)=NNP_OLD
2327 DO J=1,NHOL+1
2328 X0=RPOLY_F(4+3*ADR(J)+1,I)
2329 Y0=RPOLY_F(4+3*ADR(J)+2,I)
2330 Z0=RPOLY_F(4+3*ADR(J)+3,I)
2331 IF (IPOLY_OLD(ADR_OLD(J)+1) > 0) THEN
2332 NNS_OLD=NNS_OLD+1
2333 IF (NNS_OLD > NNS_OLD_SAVE) THEN
2334 CALL ANCMSG(MSGID=744,
2335 . MSGTYPE=MSGERROR,
2336 . ANMODE=ANINFO,
2337 . I1=ID,
2338 . C1=TITR)
2339 END IF
2340 NNS=NNS+1
2341 REDIR(NNS_OLD)=NNS
2342 IPOLY_F(6+ADR(J)+1,I)=NNS
2343 IFVNOD(NNS)=IFVNOD_OLD(NNS_OLD)
2344 ELSE
2345 IPOLY_F(6+ADR(J)+1,I)=IPOLY_OLD(ADR_OLD(J)+1)
2346 ENDIF
2347 NNP=NNP+1
2348 K0=1
2349 NNS1=NNS
2350 DO K=ADR_OLD(J)+2,ADR_OLD(J+1)
2351 NNS_OLD=NNS_OLD+1
2352 IF (NNS_OLD > NNS_OLD_SAVE) THEN
2353 CALL ANCMSG(MSGID=744,
2354 . MSGTYPE=MSGERROR,
2355 . ANMODE=ANINFO,
2356 . I1=ID,
2357 . C1=TITR)
2358 END IF
2359 X1=RPOLY_OLD(3*(K-1)+1)
2360 Y1=RPOLY_OLD(3*(K-1)+2)
2361 Z1=RPOLY_OLD(3*(K-1)+3)
2362 DD=(X1-X0)**2+(Y1-Y0)**2+(Z1-Z0)**2
2363 IF (DD > TOLE2) THEN
2364 NNP=NNP+1
2365 IF (IPOLY_OLD(K) > 0) THEN
2366 NNS=NNS+1
2367 IFVNOD(NNS)=IFVNOD_OLD(NNS_OLD)
2368 RPOLY_F(4+3*(NNP-1)+1,I)=X1
2369 RPOLY_F(4+3*(NNP-1)+2,I)=Y1
2370 RPOLY_F(4+3*(NNP-1)+3,I)=Z1
2371 IPOLY_F(6+NNP,I)=NNS
2372 ELSE
2373 RPOLY_F(4+3*(NNP-1)+1,I)=X1
2374 RPOLY_F(4+3*(NNP-1)+2,I)=Y1
2375 RPOLY_F(4+3*(NNP-1)+3,I)=Z1
2376 IPOLY_F(6+NNP,I)=IPOLY_OLD(K)
2377 ENDIF
2378 X0=X1
2379 Y0=Y1
2380 Z0=Z1
2381.AND. ELSEIF (IPOLY_OLD(K) > 0
2382 . IPOLY_OLD(K0) < 0) THEN
2383 NNS=NNS+1
2384 IFVNOD(NNS)=IFVNOD_OLD(NNS_OLD)
2385 RPOLY_F(4+3*(NNP-1)+1,I)=X1
2386 RPOLY_F(4+3*(NNP-1)+2,I)=Y1
2387 RPOLY_F(4+3*(NNP-1)+3,I)=Z1
2388 IPOLY_F(6+NNP,I)=NNS
2389 ENDIF
2390 IF (IPOLY_OLD(K) > 0) REDIR(NNS_OLD)=NNS
2391 K0=K
2392 ENDDO
2393 X1=RPOLY_F(4+3*(ADR(J)-1)+1,I)
2394 Y1=RPOLY_F(4+3*(ADR(J)-1)+2,I)
2395 Z1=RPOLY_F(4+3*(ADR(J)-1)+3,I)
2396 DD=(X1-X0)**2+(Y1-Y0)**2+(Z1-Z0)**2
2397.AND. IF (DD <= TOLE2IPOLY_OLD(ADR_OLD(J)+1) > 0) THEN
2398 REDIR(NNS_OLD)=NNS1
2399 NNS=NNS-1
2400 NNP=NNP-1
2401.AND. ELSEIF (DD <= TOLE2
2402 . IPOLY_OLD(ADR_OLD(J)+1) < 0) THEN
2403 NNP=NNP-1
2404 RPOLY_F(4+3*(ADR(J)-1)+1,I)=X0
2405 RPOLY_F(4+3*(ADR(J)-1)+2,I)=Y0
2406 RPOLY_F(4+3*(ADR(J)-1)+3,I)=Z0
2407 IPOLY_F(6+ADR(J)+1,I)=NNS
2408 ENDIF
2409 ADR(J+1)=NNP
2410 ENDDO
2411 IPOLY_F(6+NNP+1,I)=NHOL
2412 DO J=1,NHOL
2413 IPOLY_F(6+NNP+1+J,I)=ADR(J+1)
2414 RPOLY_F(4+3*NNP+3*(J-1)+1,I)=
2415 . RPOLY_F(4+3*NNP_OLD+3*(J-1)+1,I)
2416 RPOLY_F(4+3*NNP+3*(J-1)+2,I)=
2417 . RPOLY_F(4+3*NNP_OLD+3*(J-1)+2,I)
2418 RPOLY_F(4+3*NNP+3*(J-1)+3,I)=
2419 . RPOLY_F(4+3*NNP_OLD+3*(J-1)+3,I)
2420 ENDDO
2421 ENDIF
2422 IPOLY_F(2,I)=NNP
2423C
2424 IF (NNP < NNP_OLD) THEN
2425C Nouvelle aire du polygone
2426 AREA=ZERO
2427 NX=RPOLY_F(2,I)
2428 NY=RPOLY_F(3,I)
2429 NZ=RPOLY_F(4,I)
2430 IF (NHOL == 0) THEN
2431 X1=RPOLY_F(5,I)
2432 Y1=RPOLY_F(6,I)
2433 Z1=RPOLY_F(7,I)
2434 DO J=1,IPOLY_F(2,I)-2
2435 JJ=J+1
2436 JJJ=JJ+1
2437 X2=RPOLY_F(4+3*(JJ-1)+1,I)
2438 Y2=RPOLY_F(4+3*(JJ-1)+2,I)
2439 Z2=RPOLY_F(4+3*(JJ-1)+3,I)
2440 X3=RPOLY_F(4+3*(JJJ-1)+1,I)
2441 Y3=RPOLY_F(4+3*(JJJ-1)+2,I)
2442 Z3=RPOLY_F(4+3*(JJJ-1)+3,I)
2443 X12=X2-X1
2444 Y12=Y2-Y1
2445 Z12=Z2-Z1
2446 X13=X3-X1
2447 Y13=Y3-Y1
2448 Z13=Z3-Z1
2449 NNX=Y12*Z13-Z12*Y13
2450 NNY=Z12*X13-X12*Z13
2451 NNZ=X12*Y13-Y12*X13
2452 AREA=AREA+(NNX*NX+NNY*NY+NNZ*NZ)
2453 ENDDO
2454 ELSE
2455 X1=RPOLY_F(5,I)
2456 Y1=RPOLY_F(6,I)
2457 Z1=RPOLY_F(7,I)
2458 DO J=1,ADR(1)-2
2459 JJ=J+1
2460 JJJ=JJ+1
2461 X2=RPOLY_F(4+3*(JJ-1)+1,I)
2462 Y2=RPOLY_F(4+3*(JJ-1)+2,I)
2463 Z2=RPOLY_F(4+3*(JJ-1)+3,I)
2464 X3=RPOLY_F(4+3*(JJJ-1)+1,I)
2465 Y3=RPOLY_F(4+3*(JJJ-1)+2,I)
2466 Z3=RPOLY_F(4+3*(JJJ-1)+3,I)
2467 X12=X2-X1
2468 Y12=Y2-Y1
2469 Z12=Z2-Z1
2470 X13=X3-X1
2471 Y13=Y3-Y1
2472 Z13=Z3-Z1
2473 NNX=Y12*Z13-Z12*Y13
2474 NNY=Z12*X13-X12*Z13
2475 NNZ=X12*Y13-Y12*X13
2476 AREA=AREA+(NNX*NX+NNY*NY+NNZ*NZ)
2477 ENDDO
2478 ENDIF
2479C
2480 DO J=1,NHOL
2481 X1=RPOLY_F(4+3*ADR(J+1)+1,I)
2482 Y1=RPOLY_F(4+3*ADR(J+1)+2,I)
2483 Z1=RPOLY_F(4+3*ADR(J+1)+3,I)
2484 DO K=ADR(J+1)+1,ADR(J+2)
2485 KK=K+1
2486 KKK=KK+1
2487 X2=RPOLY_F(4+3*(KK-1)+1,I)
2488 Y2=RPOLY_F(4+3*(KK-1)+2,I)
2489 Z2=RPOLY_F(4+3*(KK-1)+3,I)
2490 X3=RPOLY_F(4+3*(KKK-1)+1,I)
2491 Y3=RPOLY_F(4+3*(KKK-1)+2,I)
2492 Z3=RPOLY_F(4+3*(KKK-1)+3,I)
2493 X12=X2-X1
2494 Y12=Y2-Y1
2495 Z12=Z2-Z1
2496 X13=X3-X1
2497 Y13=Y3-Y1
2498 Z13=Z3-Z1
2499 NNX=Y12*Z13-Z12*Y13
2500 NNY=Z12*X13-X12*Z13
2501 NNZ=X12*Y13-Y12*X13
2502 AREA=AREA-(NNX*NX+NNY*NY+NNZ*NZ)
2503 ENDDO
2504 ENDDO
2505 RPOLY_F(1,I)=HALF*ABS(AREA)
2506 ENDIF
2507C
2508 DEALLOCATE(IPOLY_OLD, RPOLY_OLD, ADR_OLD, ADR)
2509 ENDDO ! I=1,NPOLY
2510C
2511C
2512 DO I=1,NNS2
2513 I1=IFVNOD2(1,I)
2514 I2=IFVNOD2(2,I)
2515 IFVNOD2(1,I)=REDIR(I1)
2516 IFVNOD2(2,I)=REDIR(I2)
2517 ENDDO
2518C
2519 DEALLOCATE(IFVNOD_OLD, REDIR)
2520C---------------------------------------------------
2521C Fusion des polyedres a volume infinitesimal a leur voisin
2522C---------------------------------------------------
2523 NPHMAX=2*NPHMAX
2524 INFO=0
2525 ALLOCATE(VOLU_OLD(NPOLH), RPOLY_F_OLD(LENRMAX,NPOLY),
2526 . IPOLY_F_OLD(LENIMAX,NPOLY))
2527 DO I=1,NPOLH
2528 VOLU_OLD(I)=VOLU(I)
2529 ENDDO
2530 DO I=1,NPOLY
2531 DO J=1,LENIMAX
2532 IPOLY_F_OLD(J,I)=IPOLY_F(J,I)
2533 ENDDO
2534 DO J=1,LENRMAX
2535 RPOLY_F_OLD(J,I)=RPOLY_F(J,I)
2536 ENDDO
2537 ENDDO
2538 400 IF (ALLOCATED(POLH_NEW)) DEALLOCATE(POLH_NEW)
2539 IF (ALLOCATED(IMERGED)) DEALLOCATE(IMERGED)
2540 ALLOCATE(POLH_NEW(2+NPHMAX,NPOLH), IMERGED(NPOLH))
2541C
2542 IF (INFO == 1) THEN
2543 DO I=1,NPOLH
2544 VOLU(I)=VOLU_OLD(I)
2545 ENDDO
2546 DO I=1,NPOLY
2547 DO J=1,LENIMAX
2548 IPOLY_F(J,I)=IPOLY_F_OLD(J,I)
2549 ENDDO
2550 DO J=1,LENRMAX
2551 RPOLY_F(J,I)=RPOLY_F_OLD(J,I)
2552 ENDDO
2553 ENDDO
2554 ENDIF
2555C
2556 DO I=1,NPOLH
2557 IMERGED(I)=0
2558 DO J=1,2+POLH_F(1,I)
2559 POLH_NEW(J,I)=POLH_F(J,I)
2560 ENDDO
2561 ENDDO
2562C
2563 DO I=1,NPOLH
2564 IF (POLH_F(2,I) < 0) CYCLE ! tetraedre, ... solide additionel
2565C IF (VOLU(I) < ZERO) THEN
2566 IF (VOLU(I) < -EM10) THEN
2567 DO J=1,POLH_F(1,I)
2568 JJ=POLH_F(2+J,I)
2569 RPOLY_F(1,JJ)=-ONE
2570 ENDDO
2571 VOLU(I)=ZERO
2572 ENDIF
2573 ENDDO
2574C
2575C Volume moyen
2576 VM=ZERO
2577 NPA=0
2578 DO I=1,NPOLH
2579 IF (VOLU(I) > ZERO) THEN
2580 VM = MIN(VM ,VOLU(I))
2581 NPA=NPA+1
2582 ENDIF
2583 ENDDO
2584 VM=VM/NPA
2585C
2586 RVOLU(33)=VM
2587C No merging will be performed during starter.
2588C Starter merging algorithm does not take internal surfaces into account and
2589C therefore may create holes through internal surfaces ...
2590 VOLUMIN = EM30 * VM
2591 INFO=0
2592 DO I=1,NPOLH
2593 IF (VOLU(I) <= VOLUMIN) THEN
2594 AREAMAX=ZERO
2595 JMAX=0
2596 IMAX=0
2597 DO J=1,POLH_NEW(1,I)
2598 JJ=POLH_NEW(2+J,I)
2599 ITY=IPOLY_F(1,JJ)
2600 IF (ITY == 1) CYCLE
2601 AREA=RPOLY_F(1,JJ)
2602 IF (AREA > AREAMAX) THEN
2603 IF (IPOLY_F(5,JJ) == I) THEN
2604 II=IPOLY_F(6,JJ)
2605 JMAX=J
2606 IMAX=II
2607 ELSEIF (IPOLY_F(6,JJ) == I) THEN
2608 II=IPOLY_F(5,JJ)
2609 JMAX=J
2610 IMAX=II
2611 ENDIF
2612 AREAMAX=AREA
2613 ENDIF
2614 ENDDO
2615C
2616 IF (JMAX /= 0) THEN
2617 JJMAX=POLH_NEW(2+JMAX,I)
2618 RPOLY_F(1,JJMAX)=-ONE
2619 ELSE
2620 JMAX=1
2621 JJMAX=POLH_NEW(2+JMAX,I)
2622 ITY=IPOLY_F(1,JJMAX)
2623 IF (ITY == 2) RPOLY_F(1,JJMAX)=-ONE
2624C On merge certain polyedres de volume < volumin avec le polyedre 1
2625C on ne devrait plus passer la
2626 IMAX=1
2627 ENDIF
2628 IF (IMERGED(IMAX) == 1) IMAX=POLH_NEW(2,IMAX)
2629 NP=POLH_NEW(1,IMAX)
2630
2631C---+----1----+----2----+----3----+----4----+----5----+----6----+----7--
2632 IF(ILVOUT >= 2) THEN
2633 WRITE(IOUT,'(a,i8,a6,g11.4,a1,a,i8,a6,g11.4,a1)')
2634 . '** global merge: merging finite volume ',I,' (vol=',
2635 . VOLU(I),')',' with finite volume ',IMAX,
2636 . ' (vol=',VOLU(IMAX),')'
2637 ENDIF
2638 VOLU(IMAX)=VOLU(IMAX)+VOLU(I)
2639 VOLU(I)=-ONE
2640 IMERGED(I)=1
2641 DO J=1,POLH_NEW(1,I)
2642 IF (J /= JMAX) THEN
2643 NP=NP+1
2644 IF (NP > NPHMAX) INFO=1
2645 IF (INFO == 0) THEN
2646 JJ=POLH_NEW(2+J,I)
2647 POLH_NEW(2+NP,IMAX)=JJ
2648 ITY=IPOLY_F(1,JJ)
2649 IEL=IPOLY_F(3,JJ) ! 1<IEL<NEL
2650.AND. IF(ITY == 1 IEL > NEL)ITY=3
2651 IF (ITY >= 2) THEN
2652 IF (IPOLY_F(5,JJ) == I) THEN
2653 IPOLY_F(5,JJ)=IMAX
2654 ELSEIF (IPOLY_F(6,JJ) == I) THEN
2655 IPOLY_F(6,JJ)=IMAX
2656 ENDIF
2657 ENDIF
2658 ELSE
2659 NPHMAX=MAX(NPHMAX,NP)
2660 ENDIF
2661 ENDIF
2662 ENDDO
2663 POLH_NEW(2,I)=IMAX
2664 IF (INFO == 0) POLH_NEW(1,IMAX)=NP
2665 ENDIF
2666 ENDDO !I=1,NPOLH
2667 IF (INFO == 1) GOTO 400
2668C
2669 VMIN=EP30
2670 IMIN=1
2671 DO I=1,NPOLH
2672 IF (VOLU(I) <= ZERO) CYCLE
2673 IF (VOLU(I) < VMIN) THEN
2674 VMIN=VOLU(I)
2675 IMIN=I
2676 ENDIF
2677 DO J=1,POLH_NEW(1,I)
2678 JJ=POLH_NEW(2+J,I)
2679.OR. IF (IPOLY_F(1,JJ) == 1RPOLY_F(1,JJ) < ZERO) CYCLE
2680 IF (IPOLY_F(5,JJ) == IPOLY_F(6,JJ)) RPOLY_F(1,JJ)=-ONE
2681 ENDDO
2682 ENDDO
2683 DEALLOCATE(VOLU_OLD, RPOLY_F_OLD, IPOLY_F_OLD, IMERGED)
2684C---------------------------------------------------
2685C Verifications
2686C---------------------------------------------------
2687 VOLPH=ZERO
2688 AREAP=ZERO
2689 AREAEL=ZERO
2690 NPOLHF=0
2691 DO I=1,NPOLH
2692 IF (VOLU(I) > ZERO) THEN
2693 NPOLHF=NPOLHF+1
2694 VOLPH=VOLPH+VOLU(I)
2695 ENDIF
2696 ENDDO
2697 NSPOLY=0
2698 NCPOLY=0
2699 DO I=1,NPOLY
2700 ITY=IPOLY_F(1,I)
2701.AND. IF (ITY == 1RPOLY_F(1,I) > ZERO) THEN
2702 NSPOLY=NSPOLY+1
2703 AREAP=AREAP+RPOLY_F(1,I)
2704.OR..AND. ELSEIF ((ITY == 2 ITY == 3) RPOLY_F(1,I) > ZERO) THEN
2705 NCPOLY=NCPOLY+1
2706 ENDIF
2707 ENDDO
2708 DO IEL=1,NEL
2709 AREAEL=AREAEL+ELAREA(IEL)
2710 ENDDO
2711C---------------------------------------------------
2712C Coordonnees elementaires des nouveaux noeuds
2713C---------------------------------------------------
2714 IFV=IVOLU(45)
2715 ALLOCATE(FVDATA(IFV)%IFVNOD(3,NNS+NNS2),
2716 . FVDATA(IFV)%RFVNOD(2,NNS+NNS2))
2717C
2718 FVDATA(IFV)%RFVNOD(1:2,1:NNS+NNS2) = 0
2719 DO I=1,NNS+NNS2
2720 FVDATA(IFV)%IFVNOD(1,I)=0
2721 FVDATA(IFV)%IFVNOD(2,I)=0
2722 FVDATA(IFV)%IFVNOD(3,I)=0
2723 ENDDO
2724C
2725 NNS_OLD=NNS
2726 NNS=0
2727 DO I=1,NPOLY
2728 NNP=IPOLY_F(2,I)
2729 DO J=1,NNP
2730 IF (IPOLY_F(6+J,I) > 0) THEN
2731 NNS=NNS+1
2732 IF (NNS > NNS_OLD) THEN
2733 CALL ANCMSG(MSGID=744,
2734 . MSGTYPE=MSGERROR,
2735 . ANMODE=ANSTOP,
2736 . I1=ID,
2737 . C1=TITR)
2738 END IF
2739
2740 IF (IFVNOD(NNS) < 0) THEN
2741C point de solide additionnel
2742 FVDATA(IFV)%IFVNOD(1,NNS)=2
2743 FVDATA(IFV)%IFVNOD(2,NNS)=-IFVNOD(NNS)
2744 CYCLE
2745 ENDIF
2746C point appuye sur airbag
2747 FVDATA(IFV)%IFVNOD(1,NNS)=1
2748 IEL=IFVNOD(NNS)
2749 FVDATA(IFV)%IFVNOD(2,NNS)=IEL
2750 XX=RPOLY_F(4+3*(J-1)+1,I)
2751 YY=RPOLY_F(4+3*(J-1)+2,I)
2752 ZZ=RPOLY_F(4+3*(J-1)+3,I)
2753C
2754 N1=ELEMA(1,IEL)
2755 N2=ELEMA(2,IEL)
2756 N3=ELEMA(3,IEL)
2757 IF (TAGELA(IEL) > 0) THEN
2758 NN1=IBUF(N1)
2759 NN2=IBUF(N2)
2760 NN3=IBUF(N3)
2761 ELSEIF (TAGELA(IEL) < 0) THEN
2762 NN1=IBUFA(N1)
2763 NN2=IBUFA(N2)
2764 NN3=IBUFA(N3)
2765 ENDIF
2766 X1=X(1,NN1)
2767 Y1=X(2,NN1)
2768 Z1=X(3,NN1)
2769 X2=X(1,NN2)
2770 Y2=X(2,NN2)
2771 Z2=X(3,NN2)
2772 X3=X(1,NN3)
2773 Y3=X(2,NN3)
2774 Z3=X(3,NN3)
2775C
2776 VPX=XX-X1
2777 VPY=YY-Y1
2778 VPZ=ZZ-Z1
2779 V1X=X2-X1
2780 V1Y=Y2-Y1
2781 V1Z=Z2-Z1
2782 V2X=X3-X1
2783 V2Y=Y3-Y1
2784 V2Z=Z3-Z1
2785 CALL COORLOC(VPX, VPY, VPZ, V1X, V1Y,
2786 . V1Z, V2X, V2Y, V2Z, KSI,
2787 . ETA)
2788C
2789 FVDATA(IFV)%RFVNOD(1,NNS)=KSI
2790 FVDATA(IFV)%RFVNOD(2,NNS)=ETA
2791 ELSE
2792C point interne
2793 JJ=-IPOLY_F(6+J,I)
2794 FVDATA(IFV)%IFVNOD(1,NNS_OLD+JJ)=3
2795 FVDATA(IFV)%IFVNOD(2,NNS_OLD+JJ)=IFVNOD2(1,JJ)
2796 FVDATA(IFV)%IFVNOD(3,NNS_OLD+JJ)=IFVNOD2(2,JJ)
2797 FVDATA(IFV)%RFVNOD(1,NNS_OLD+JJ)=RFVNOD2(1,JJ)
2798 ENDIF
2799 ENDDO
2800 ENDDO
2801C
2802 DO I=1,NNS2
2803 IF (FVDATA(IFV)%IFVNOD(1,NNS+I) == 0) THEN
2804 FVDATA(IFV)%IFVNOD(1,NNS+I)=3
2805 FVDATA(IFV)%IFVNOD(2,NNS+I)=1
2806 FVDATA(IFV)%IFVNOD(3,NNS+I)=2
2807 FVDATA(IFV)%RFVNOD(1,NNS+I)=ONE
2808 ENDIF
2809 ENDDO
2810C
2811 IF (NNS > NNS_OLD) THEN
2812 CALL ANCMSG(MSGID=744,
2813 . MSGTYPE=MSGERROR,
2814 . ANMODE=ANINFO,
2815 . I1=ID,
2816 . C1=TITR)
2817 END IF
2818C---------------------------------------------------
2819C Triangulation des polygones
2820C---------------------------------------------------
2821 NNTR=0
2822 DO I=1,NPOLY
2823 NN=IPOLY_F(2,I)
2824 NNTR=NNTR+NN
2825 ENDDO
2826C
2827 ALLOCATE(FVDATA(IFV)%IFVTRI(6,NNTR),
2828 . FVDATA(IFV)%IFVPOLY(NNTR),
2829 . FVDATA(IFV)%IFVTADR(NPOLY+1))
2830C
2831 NNTR=0
2832 NPOLY_OLD=NPOLY
2833 NPOLY=0
2834 ALLOCATE(REDIR_POLY(NPOLY_OLD))
2835 DO I=1,NPOLY_OLD
2836 REDIR_POLY(I)=0
2837 ENDDO
2838C
2839 NNS=0
2840 DO I=1,NPOLY_OLD
2841 IF (RPOLY_F(1,I) <= ZERO) THEN
2842 DO J=1,IPOLY_F(2,I)
2843 IF (IPOLY_F(6+J,I) > 0) NNS=NNS+1
2844 ENDDO
2845 CYCLE
2846 ENDIF
2847 NPOLY=NPOLY+1
2848 REDIR_POLY(I)=NPOLY
2849 NNP=IPOLY_F(2,I)
2850 NHOL=0
2851 IF (IPOLY_F(1,I) == 2) NHOL=IPOLY_F(6+NNP+1,I)
2852 ALLOCATE(PNODES(2,NNP), PSEG(2,NNP), PHOLES(2,NHOL),PTRI(3,NNP), REDIR(NNP))
2853 PTRI(1:3,1:NNP) = 0
2854C
2855 DO J=1,NNP
2856 IF (IPOLY_F(6+J,I) > 0) THEN
2857 NNS=NNS+1
2858 REDIR(J)=NNS
2859 ELSE
2860 JJ=-IPOLY_F(6+J,I)
2861 REDIR(J)=NNS_OLD+JJ
2862 ENDIF
2863 ENDDO
2864 IF (IPOLY_F(1,I) == 1) THEN
2865 IPSURF=IPOLY_F(3,I)
2866 IF( IPSURF > NEL) THEN
2867 IPSURF=-IPSURF
2868 IC1=IPOLY_F(5,I)
2869 IC2=IPOLY_F(6,I)
2870 ELSE
2871 IC1=0
2872 IC2=0
2873 ENDIF
2874.OR. ELSEIF (IPOLY_F(1,I) == 2 IPOLY_F(1,I) == 3) THEN
2875 IPSURF=0
2876 IC1=IPOLY_F(5,I)
2877 IC2=IPOLY_F(6,I)
2878 ENDIF
2879C
2880C Coordonnees des sommets dans le plan du polygone
2881 NX=RPOLY_F(2,I)
2882 NY=RPOLY_F(3,I)
2883 NZ=RPOLY_F(4,I)
2884C
2885 X0=RPOLY_F(5,I)
2886 Y0=RPOLY_F(6,I)
2887 Z0=RPOLY_F(7,I)
2888 X1=RPOLY_F(8,I)
2889 Y1=RPOLY_F(9,I)
2890 Z1=RPOLY_F(10,I)
2891 NRM1=SQRT((X1-X0)**2+(Y1-Y0)**2+(Z1-Z0)**2)
2892 VX1=(X1-X0)/NRM1
2893 VY1=(Y1-Y0)/NRM1
2894 VZ1=(Z1-Z0)/NRM1
2895 VX2=NY*VZ1-NZ*VY1
2896 VY2=NZ*VX1-NX*VZ1
2897 VZ2=NX*VY1-NY*VX1
2898C
2899 PNODES(1,1)=ZERO
2900 PNODES(2,1)=ZERO
2901 IF (NHOL == 0) THEN
2902 DO J=2,NNP
2903 XX=RPOLY_F(4+3*(J-1)+1,I)
2904 YY=RPOLY_F(4+3*(J-1)+2,I)
2905 ZZ=RPOLY_F(4+3*(J-1)+3,I)
2906 VX=XX-X0
2907 VY=YY-Y0
2908 VZ=ZZ-Z0
2909 PNODES(1,J)=VX*VX1+VY*VY1+VZ*VZ1
2910 PNODES(2,J)=VX*VX2+VY*VY2+VZ*VZ2
2911 PSEG(1,J-1)=J-1
2912 PSEG(2,J-1)=J
2913 ENDDO
2914 PSEG(1,NNP)=NNP
2915 PSEG(2,NNP)=1
2916 NSEG=NNP
2917 ELSE
2918 ALLOCATE(ADR(NHOL+1))
2919 DO J=1,NHOL
2920 ADR(J)=IPOLY_F(6+NNP+1+J,I)
2921 ENDDO
2922 ADR(NHOL+1)=NNP
2923 NSEG=0
2924 DO J=2,ADR(1)
2925 XX=RPOLY_F(4+3*(J-1)+1,I)
2926 YY=RPOLY_F(4+3*(J-1)+2,I)
2927 ZZ=RPOLY_F(4+3*(J-1)+3,I)
2928 VX=XX-X0
2929 VY=YY-Y0
2930 VZ=ZZ-Z0
2931 PNODES(1,J)=VX*VX1+VY*VY1+VZ*VZ1
2932 PNODES(2,J)=VX*VX2+VY*VY2+VZ*VZ2
2933 NSEG=NSEG+1
2934 PSEG(1,NSEG)=J-1
2935 PSEG(2,NSEG)=J
2936 ENDDO
2937 NSEG=NSEG+1
2938 PSEG(1,NSEG)=ADR(1)
2939 PSEG(2,NSEG)=1
2940 DO J=1,NHOL
2941 XX=RPOLY_F(4+3*ADR(J)+1,I)
2942 YY=RPOLY_F(4+3*ADR(J)+2,I)
2943 ZZ=RPOLY_F(4+3*ADR(J)+3,I)
2944 VX=XX-X0
2945 VY=YY-Y0
2946 VZ=ZZ-Z0
2947 PNODES(1,ADR(J)+1)=VX*VX1+VY*VY1+VZ*VZ1
2948 PNODES(2,ADR(J)+1)=VX*VX2+VY*VY2+VZ*VZ2
2949 DO K=ADR(J)+2,ADR(J+1)
2950 XX=RPOLY_F(4+3*(K-1)+1,I)
2951 YY=RPOLY_F(4+3*(K-1)+2,I)
2952 ZZ=RPOLY_F(4+3*(K-1)+3,I)
2953 VX=XX-X0
2954 VY=YY-Y0
2955 VZ=ZZ-Z0
2956 PNODES(1,K)=VX*VX1+VY*VY1+VZ*VZ1
2957 PNODES(2,K)=VX*VX2+VY*VY2+VZ*VZ2
2958 NSEG=NSEG+1
2959 PSEG(1,NSEG)=K-1
2960 PSEG(2,NSEG)=K
2961 ENDDO
2962 NSEG=NSEG+1
2963 PSEG(1,NSEG)=ADR(J+1)
2964 PSEG(2,NSEG)=ADR(J)+1
2965C
2966 XX=RPOLY_F(4+3*NNP+3*(J-1)+1,I)
2967 YY=RPOLY_F(4+3*NNP+3*(J-1)+2,I)
2968 ZZ=RPOLY_F(4+3*NNP+3*(J-1)+3,I)
2969 VX=XX-X0
2970 VY=YY-Y0
2971 VZ=ZZ-Z0
2972 PHOLES(1,J)=VX*VX1+VY*VY1+VZ*VZ1
2973 PHOLES(2,J)=VX*VX2+VY*VY2+VZ*VZ2
2974 ENDDO
2975 DEALLOCATE(ADR)
2976 ENDIF
2977C
2978 NELP = 0
2979 CALL C_TRICALL(PNODES, PSEG, PHOLES, PTRI, NNP, NSEG, NHOL, NELP)
2980C
2981 FVDATA(IFV)%IFVTADR(NPOLY)=NNTR+1
2982C avoid bug with PGI => comp O1
2983C CALL BIDON1(IFV)
2984 DO J=1,NELP
2985 NNTR=NNTR+1
2986 N1=PTRI(1,J)
2987 N2=PTRI(2,J)
2988 N3=PTRI(3,J)
2989C Verification de la normale
2990 X1=RPOLY_F(4+3*(N1-1)+1,I)
2991 Y1=RPOLY_F(4+3*(N1-1)+2,I)
2992 Z1=RPOLY_F(4+3*(N1-1)+3,I)
2993 X2=RPOLY_F(4+3*(N2-1)+1,I)
2994 Y2=RPOLY_F(4+3*(N2-1)+2,I)
2995 Z2=RPOLY_F(4+3*(N2-1)+3,I)
2996 X3=RPOLY_F(4+3*(N3-1)+1,I)
2997 Y3=RPOLY_F(4+3*(N3-1)+2,I)
2998 Z3=RPOLY_F(4+3*(N3-1)+3,I)
2999 X12=X2-X1
3000 Y12=Y2-Y1
3001 Z12=Z2-Z1
3002 X13=X3-X1
3003 Y13=Y3-Y1
3004 Z13=Z3-Z1
3005 NRX=Y12*Z13-Z12*Y13
3006 NRY=Z12*X13-X12*Z13
3007 NRZ=X12*Y13-Y12*X13
3008 SS=NRX*NX+NRY*NY+NRZ*NZ
3009C
3010 IF (SS > ZERO) THEN
3011 FVDATA(IFV)%IFVTRI(1,NNTR)=REDIR(N1)
3012 FVDATA(IFV)%IFVTRI(2,NNTR)=REDIR(N2)
3013 FVDATA(IFV)%IFVTRI(3,NNTR)=REDIR(N3)
3014 ELSE
3015 FVDATA(IFV)%IFVTRI(1,NNTR)=REDIR(N1)
3016 FVDATA(IFV)%IFVTRI(2,NNTR)=REDIR(N3)
3017 FVDATA(IFV)%IFVTRI(3,NNTR)=REDIR(N2)
3018 ENDIF
3019 FVDATA(IFV)%IFVTRI(4,NNTR)=IPSURF
3020 FVDATA(IFV)%IFVTRI(5,NNTR)=IC1
3021 FVDATA(IFV)%IFVTRI(6,NNTR)=IC2
3022 FVDATA(IFV)%IFVPOLY(NNTR)=NNTR
3023 ENDDO
3024C
3025 DEALLOCATE(PNODES, PSEG, PHOLES, PTRI, REDIR)
3026 ENDDO
3027 FVDATA(IFV)%IFVTADR(NPOLY+1)=NNTR+1
3028C---------------------------------------------------
3029C Structure des polyedres
3030C---------------------------------------------------
3031 ALLOCATE(FVDATA(IFV)%IFVPOLH(2*NPOLY),
3032 . FVDATA(IFV)%IFVPADR(NPOLH+1),
3033 . FVDATA(IFV)%IDPOLH(NPOLH),
3034 . FVDATA(IFV)%IBPOLH(NPOLH))
3035 NNP=0
3036 NPOLH_OLD=NPOLH
3037 NPOLH=0
3038 ALLOCATE(REDIR_POLH(NPOLH_OLD))
3039 DO I=1,NPOLH_OLD
3040 REDIR_POLH(I)=0
3041 ENDDO
3042C
3043 DO I=1,NPOLH_OLD
3044 IF (VOLU(I) <= ZERO) CYCLE
3045 NPOLH=NPOLH+1
3046 REDIR_POLH(I)=NPOLH
3047 FVDATA(IFV)%IFVPADR(NPOLH)=NNP+1
3048 DO J=1,POLH_NEW(1,I)
3049 JJ=REDIR_POLY(POLH_NEW(2+J,I))
3050 IF (JJ == 0) CYCLE
3051 NNP=NNP+1
3052 FVDATA(IFV)%IFVPOLH(NNP)=REDIR_POLY(POLH_NEW(2+J,I))
3053 ENDDO
3054C
3055 FVDATA(IFV)%IDPOLH(NPOLH)=NPOLH
3056C
3057 II=POLH_NEW(2,I)
3058 IF (II >= 0) II=0
3059 IF (II < 0)THEN
3060 IF(IBSA(-II) == 1) II=-II
3061 ENDIF
3062 FVDATA(IFV)%IBPOLH(NPOLH)=II
3063 ENDDO
3064 FVDATA(IFV)%IFVPADR(NPOLH+1)=NNP+1
3065C
3066 DO I=1,NNTR
3067 IF (FVDATA(IFV)%IFVTRI(4,I) <= 0) THEN
3068 IC1=FVDATA(IFV)%IFVTRI(5,I)
3069 IC2=FVDATA(IFV)%IFVTRI(6,I)
3070 FVDATA(IFV)%IFVTRI(5,I)=REDIR_POLH(IC1)
3071 FVDATA(IFV)%IFVTRI(6,I)=REDIR_POLH(IC2)
3072 ENDIF
3073 ENDDO
3074C
3075 IVOLU(46)=NNS+NNS2
3076 IVOLU(47)=NNTR
3077 IVOLU(48)=NPOLY
3078 IVOLU(49)=NPOLH
3079C
3080 FVDATA(IFV)%NNS=NNS+NNS2
3081 FVDATA(IFV)%NNTR=NNTR
3082 FVDATA(IFV)%LENP=FVDATA(IFV)%IFVTADR(NPOLY+1)-1
3083 FVDATA(IFV)%NPOLY=NPOLY
3084 FVDATA(IFV)%LENH=FVDATA(IFV)%IFVPADR(NPOLH+1)-1
3085 FVDATA(IFV)%NPOLH=NPOLH
3086C
3087 ALLOCATE(FVDATA(IFV)%MPOLH(NPOLH), FVDATA(IFV)%QPOLH(3,NPOLH),
3088 . FVDATA(IFV)%EPOLH(NPOLH), FVDATA(IFV)%PPOLH(NPOLH),
3089 . FVDATA(IFV)%RPOLH(NPOLH), FVDATA(IFV)%GPOLH(NPOLH),
3090 . FVDATA(IFV)%TPOLH(NPOLH),
3091 . FVDATA(IFV)%CPAPOLH(NPOLH), FVDATA(IFV)%CPBPOLH(NPOLH),
3092 . FVDATA(IFV)%CPCPOLH(NPOLH), FVDATA(IFV)%RMWPOLH(NPOLH),
3093 . FVDATA(IFV)%VPOLH_INI(NPOLH), FVDATA(IFV)%DTPOLH(NPOLH))
3094 ALLOCATE(FVDATA(IFV)%CPDPOLH(NPOLH), FVDATA(IFV)%CPEPOLH(NPOLH),
3095 . FVDATA(IFV)%CPFPOLH(NPOLH))
3096C---------------------------------------------------
3097C Initialisation des quantites dans les polyedres
3098C---------------------------------------------------
3099 GAMAI=RVOLU(1)
3100 CPAI=RVOLU(7)
3101 CPBI=RVOLU(8)
3102 CPCI=RVOLU(9)
3103 RMWI=RVOLU(10)
3104 PINI=RVOLU(12)
3105 TI=RVOLU(13)
3106 CPDI=RVOLU(56)
3107 CPEI=RVOLU(57)
3108 CPFI=RVOLU(58)
3109 TI2=TI*TI
3110 RHOI=PINI/(TI*RMWI)
3111C
3112 CPI=CPAI+HALF*CPBI*TI+THIRD*CPCI*TI2
3113 IF(IVOLU(2) == 8) THEN
3114 CPI=CPI+FOURTH*CPDI*TI2*TI-CPEI/TI2+ONE_FIFTH*CPFI*TI2*TI2
3115 ENDIF
3116 CVI=CPI-RMWI
3117C
3118 TMASS=0
3119 DO I=1,NPOLH_OLD
3120 II=REDIR_POLH(I)
3121 IF (II == 0) CYCLE
3122 FVDATA(IFV)%MPOLH(II)=RHOI*VOLU(I)
3123 FVDATA(IFV)%QPOLH(1,II)=ZERO
3124 FVDATA(IFV)%QPOLH(2,II)=ZERO
3125 FVDATA(IFV)%QPOLH(3,II)=ZERO
3126 FVDATA(IFV)%EPOLH(II)=FVDATA(IFV)%MPOLH(II)*CVI*TI
3127 FVDATA(IFV)%PPOLH(II)=PINI
3128 FVDATA(IFV)%RPOLH(II)=RHOI
3129 FVDATA(IFV)%GPOLH(II)=GAMAI
3130 FVDATA(IFV)%CPAPOLH(II)=CPAI
3131 FVDATA(IFV)%CPBPOLH(II)=CPBI
3132 FVDATA(IFV)%CPCPOLH(II)=CPCI
3133 FVDATA(IFV)%TPOLH(II)=TI
3134 FVDATA(IFV)%CPDPOLH(II)=CPDI
3135 FVDATA(IFV)%CPEPOLH(II)=CPEI
3136 FVDATA(IFV)%CPFPOLH(II)=CPFI
3137 FVDATA(IFV)%RMWPOLH(II)=RMWI
3138 FVDATA(IFV)%DTPOLH(II)=EP30
3139 FVDATA(IFV)%VPOLH_INI(II)=VOLU(I)
3140 TMASS=TMASS+RHOI*VOLU(I)
3141 ENDDO
3142C
3143 IMIN=REDIR_POLH(IMIN)
3144 DEALLOCATE(IPOLY_F, RPOLY_F, POLH_F, VOLU, REDIR_POLY, REDIR_POLH,
3145 . POLH_NEW, IFVNOD, IFVNOD2, RFVNOD2, XNS, XNS2)
3146C---------------------------------------------------
3147C Impressions
3148C---------------------------------------------------
3149 NSTR=0
3150 NCTR=0
3151 DO I=1,NNTR
3152 IF (FVDATA(IFV)%IFVTRI(4,I) > 0) THEN
3153 NSTR=NSTR+1
3154 ELSE
3155 NCTR=NCTR+1
3156 ENDIF
3157 ENDDO
3158C
3159C NSPOLY NUMBER OF SURFACE POLYGONS
3160C NSTR NUMBER OF SURFACE TRIANGLES
3161C NCPOLY NUMBER OF COMMUNICATION POLYGONS
3162C NCTR NUMBER OF COMMUNICATION TRIANGLES
3163C NPOLHF NUMBER OF POLYHEDRA (FINITE VOLUMES)
3164C
3165 WRITE(IOUT,1000) IVOLU(1),NSPOLY,NSTR,NCPOLY,NCTR,NPOLHF
3166 WRITE(IOUT,1010) VMIN,IMIN,VOLUMIN
3167 WRITE(IOUT,1020) VOLPH,AREAP,TMASS
3168C
3169C---------------------------------------------------
3170C Anim des volumes finis
3171C---------------------------------------------------
3172 IVOLU(43)=0
3173 FVDATA(IFV)%NPOLH_ANIM=NPOLH
3174 LENP=FVDATA(IFV)%IFVTADR(NPOLY+1)
3175 LENH=FVDATA(IFV)%IFVPADR(NPOLH+1)
3176 ALLOCATE(FVDATA(IFV)%IFVPOLY_ANIM(LENP),
3177 . FVDATA(IFV)%IFVTADR_ANIM(NPOLY+1),
3178 . FVDATA(IFV)%IFVPOLH_ANIM(LENH),
3179 . FVDATA(IFV)%IFVPADR_ANIM(NPOLH+1),
3180 . FVDATA(IFV)%IFVTRI_ANIM(6,NNTR),
3181 . FVDATA(IFV)%REDIR_ANIM(NNS+NNS2),
3182 . FVDATA(IFV)%NOD_ANIM(3,NNS+NNS2),
3183 . REDIR(NNS+NNS2), ITAGT(NNTR))
3184 DO I=1,LENP
3185 FVDATA(IFV)%IFVPOLY_ANIM(I)=FVDATA(IFV)%IFVPOLY(I)
3186 ENDDO
3187 DO I=1,NPOLY+1
3188 FVDATA(IFV)%IFVTADR_ANIM(I)=FVDATA(IFV)%IFVTADR(I)
3189 ENDDO
3190 DO I=1,LENH
3191 FVDATA(IFV)%IFVPOLH_ANIM(I)=FVDATA(IFV)%IFVPOLH(I)
3192 ENDDO
3193 DO I=1,NPOLH+1
3194 FVDATA(IFV)%IFVPADR_ANIM(I)=FVDATA(IFV)%IFVPADR(I)
3195 ENDDO
3196C-----------------------------------------
3197C Elimination des noeuds doubles pour anim
3198C-----------------------------------------
3199 TOLE=EM05*FAC_LENGTH
3200 TOLE2=TOLE**2
3201 NNS_ANIM=0
3202 ALLOCATE(PNODES(3,NNS+NNS2))
3203 DO I=1,NNS
3204 IF (FVDATA(IFV)%IFVNOD(1,I) == 1) THEN
3205 IEL=FVDATA(IFV)%IFVNOD(2,I)
3206 KSI=FVDATA(IFV)%RFVNOD(1,I)
3207 ETA=FVDATA(IFV)%RFVNOD(2,I)
3208 N1=ELEMA(1,IEL)
3209 N2=ELEMA(2,IEL)
3210 N3=ELEMA(3,IEL)
3211 IF (TAGELA(IEL) > 0) THEN
3212 N1=IBUF(N1)
3213 N2=IBUF(N2)
3214 N3=IBUF(N3)
3215 ELSEIF (TAGELA(IEL) < 0) THEN
3216 N1=IBUFA(N1)
3217 N2=IBUFA(N2)
3218 N3=IBUFA(N3)
3219 ENDIF
3220 X1=X(1,N1)
3221 Y1=X(2,N1)
3222 Z1=X(3,N1)
3223 X2=X(1,N2)
3224 Y2=X(2,N2)
3225 Z2=X(3,N2)
3226 X3=X(1,N3)
3227 Y3=X(2,N3)
3228 Z3=X(3,N3)
3229 PNODES(1,I)=(ONE-KSI-ETA)*X1+KSI*X2+ETA*X3
3230 PNODES(2,I)=(ONE-KSI-ETA)*Y1+KSI*Y2+ETA*Y3
3231 PNODES(3,I)=(ONE-KSI-ETA)*Z1+KSI*Z2+ETA*Z3
3232 ELSEIF (FVDATA(IFV)%IFVNOD(1,I) == 2) THEN
3233 II=FVDATA(IFV)%IFVNOD(2,I)
3234 PNODES(1,I)=X(1,II)
3235 PNODES(2,I)=X(2,II)
3236 PNODES(3,I)=X(3,II)
3237 ENDIF
3238 ENDDO
3239 DO I=1,NNS2
3240 II=NNS+I
3241 I1=FVDATA(IFV)%IFVNOD(2,II)
3242 I2=FVDATA(IFV)%IFVNOD(3,II)
3243 ALPHA=FVDATA(IFV)%RFVNOD(1,II)
3244 PNODES(1,II)=ALPHA*PNODES(1,I1)+(ONE-ALPHA)*PNODES(1,I2)
3245 PNODES(2,II)=ALPHA*PNODES(2,I1)+(ONE-ALPHA)*PNODES(2,I2)
3246 PNODES(3,II)=ALPHA*PNODES(3,I1)+(ONE-ALPHA)*PNODES(3,I2)
3247 ENDDO
3248C--------------------------
3249C Impression
3250C--------------------------
3251 IF(ILVOUT >=3 ) THEN
3252 ALLOCATE(AREATR(NNTR))
3253 DO I=1,NNTR
3254 N1=FVDATA(IFV)%IFVTRI(1,I)
3255 N2=FVDATA(IFV)%IFVTRI(2,I)
3256 N3=FVDATA(IFV)%IFVTRI(3,I)
3257 X1=PNODES(1,N1)
3258 Y1=PNODES(2,N1)
3259 Z1=PNODES(3,N1)
3260 X2=PNODES(1,N2)
3261 Y2=PNODES(2,N2)
3262 Z2=PNODES(3,N2)
3263 X3=PNODES(1,N3)
3264 Y3=PNODES(2,N3)
3265 Z3=PNODES(3,N3)
3266 CALL FVNORMAL(PNODES,N1,N2,N3,0,NRX,NRY,NRZ)
3267 AREA2=SQRT(NRX**2+NRY**2+NRZ**2)
3268 AREATR(I)=HALF*AREA2
3269 ENDDO
3270C
3271C---+----1----+----2----+----3----+----4----+----5----+----6----+----7--
3272 WRITE(IOUT,'(/a,10x,3a)')' finite volume',' brick volume ',
3273 . ' polygone triangle area'
3274C
3275 DO I=1,NPOLH
3276 N1= FVDATA(IFV)%IDPOLH(I)
3277 N2= FVDATA(IFV)%IBPOLH(I)
3278 N3= 0
3279 IF(N2 /= 0) THEN
3280 N3= TBA(1,IABS(N2))
3281 ENDIF
3282 VOLPH=FVDATA(IFV)%VPOLH_INI(I)
3283 II=0
3284 JJJ=0
3285 KKK=0
3286 DO J=FVDATA(IFV)%IFVPADR(I),FVDATA(IFV)%IFVPADR(I+1)-1
3287 JJJ=JJJ+1
3288 JJ=FVDATA(IFV)%IFVPOLH(J)
3289 DO K=FVDATA(IFV)%IFVTADR(JJ),FVDATA(IFV)%IFVTADR(JJ+1)-1
3290 KKK=KKK+1
3291 KK=FVDATA(IFV)%IFVPOLY(K)
3292 AREA=AREATR(KK)
3293 IEL=FVDATA(IFV)%IFVTRI(4,KK)
3294 IC1=FVDATA(IFV)%IFVTRI(5,KK)
3295 IC2=FVDATA(IFV)%IFVTRI(6,KK)
3296 IF(KKK == 1) THEN
3297 WRITE(IOUT,'(3i10,2x,f10.2,4x,i5,5x,i10,5x,g14.6,3i10)')
3298 . N1,N2,N3,VOLPH,JJJ,KK,AREA,IEL,IC1,IC2
3299 ELSE
3300 WRITE(IOUT,'(46x,i5,5x,i10,5x,g14.6,3i10)')
3301 . JJJ,KK,AREA,IEL,IC1,IC2
3302 ENDIF
3303 ENDDO
3304 ENDDO
3305 ENDDO
3306 DEALLOCATE(AREATR)
3307 ENDIF
3308C-------------------------------------------
3309C Merge des points coincidents
3310C-------------------------------------------
3311 IF (ILVOUT >=1) WRITE(ISTDO,'(8x,a)')
3312 . 'merging coincident nodes for anim'
3313
3314 ALLOCATE(RADIUS(NNS + NNS2), IDX(NNS + NNS2))
3315 DO I = 1, NNS + NNS2
3316 XX=PNODES(1,I)
3317 YY=PNODES(2,I)
3318 ZZ=PNODES(3,I)
3319 RADIUS(I) = XX*XX + YY*YY + ZZ*ZZ
3320 IDX(I) = I
3321 ENDDO
3322
3323 CALL QUICKSORT(RADIUS, IDX, 1, NNS + NNS2)
3324 I = 1
3325 DO WHILE(I < NNS+ NNS2)
3326 !IF (ILVOUT >=1) CALL PROGALE_C(I, NNS+NNS2, 3) !dynamic screen output
3327 IAD1 = IDX(I)
3328 XX = PNODES(1,IAD1)
3329 YY = PNODES(2,IAD1)
3330 ZZ = PNODES(3,IAD1)
3331 R1 = RADIUS(I)
3332 NNS_ANIM = NNS_ANIM + 1
3333 REDIR(IAD1) = NNS_ANIM
3334 FVDATA(IFV)%REDIR_ANIM(NNS_ANIM)=IAD1
3335 FVDATA(IFV)%NOD_ANIM(1,NNS_ANIM)=XX
3336 FVDATA(IFV)%NOD_ANIM(2,NNS_ANIM)=YY
3337 FVDATA(IFV)%NOD_ANIM(3,NNS_ANIM)=ZZ
3338 J = I
3339 DO WHILE(J <= NNS + NNS2)
3340 IF (ABS(R1 - RADIUS(J)) <= TOLE2) THEN
3341 J = J + 1
3342 ELSE
3343 EXIT
3344 ENDIF
3345 ENDDO
3346 J = J - 1
3347
3348 IAD = I + 1
3349 DO WHILE (IAD <= J)
3350 IAD2 = IDX(IAD)
3351 XN(1) = PNODES(1,IAD2)
3352 XN(2) = PNODES(2,IAD2)
3353 XN(3) = PNODES(3,IAD2)
3354 DD2=(XX-XN(1))**2+(YY-XN(2))**2+(ZZ-XN(3))**2
3355 IF (DD2 <= TOLE2) THEN
3356C NODE IAD2 is duplicated with node IAD1
3357 REDIR(IAD2) = REDIR(IAD1)
3358 IAD = IAD + 1
3359 ELSE
3360C put it at the end
3361 ITMP1 = IDX(J)
3362 IDX(J) = IAD2
3363 IDX(IAD) = ITMP1
3364 J = J - 1
3365 ENDIF
3366 ENDDO
3367 I = J + 1
3368 ENDDO
3369
3370 DEALLOCATE(RADIUS, IDX)
3371
3372 FVDATA(IFV)%NNS_ANIM=NNS_ANIM
3373 FVDATA(IFV)%ID=IVOLU(1)
3374C
3375 DO I=1,NNTR
3376 N1=FVDATA(IFV)%IFVTRI(1,I)
3377 N2=FVDATA(IFV)%IFVTRI(2,I)
3378 N3=FVDATA(IFV)%IFVTRI(3,I)
3379 FVDATA(IFV)%IFVTRI_ANIM(1,I)=REDIR(N1)
3380 FVDATA(IFV)%IFVTRI_ANIM(2,I)=REDIR(N2)
3381 FVDATA(IFV)%IFVTRI_ANIM(3,I)=REDIR(N3)
3382 FVDATA(IFV)%IFVTRI_ANIM(4,I)=
3383 . FVDATA(IFV)%IFVTRI(4,I)
3384 FVDATA(IFV)%IFVTRI_ANIM(5,I)=
3385 . FVDATA(IFV)%IFVTRI(5,I)
3386 FVDATA(IFV)%IFVTRI_ANIM(6,I)=
3387 . FVDATA(IFV)%IFVTRI(6,I)
3388 ENDDO
3389 DEALLOCATE(PNODES)
3390C
3391 DEALLOCATE(REDIR, ITAGT)
3392 DEALLOCATE(IFLAG)
3393C
3394 RETURN
3395C
33961000 FORMAT(/5X,'volume number ',I10,
3397 . /5X,'number of surface polygons. . . . . . .=',I10,
3398 . /5X,'number of surface triangles . . . . . .=',I10,
3399 . /5X,'number of communication polygons. . . .=',I10,
3400 . /5X,'number of communication triangles . . .=',I10,
3401 . /5X,'number of finite volumes. . . . . . . .=',I10)
34021010 FORMAT( 5X,'min finite volume volume. . . . . . . .=',1PG20.13,
3403 . 5X,'(finite volume id ',I10,')',
3404 . /5X,'initial merging volume. . . . . . . . .=',1PG20.13)
34051020 FORMAT( 5X,'sum volume of finite volumes. . . . . .=',1PG20.13,
3406 . /5X,'sum area surface triangles. . . . . . .=',1PG20.13,
3407 . /5X,'sum mass of finite volumes. . . . . . .=',1PG20.13)
3408C
norm
norm(diag(diag(diag(inv(mat))) -id.SOL), 2) % destroy mumps instance id.JOB
alpha
#define alpha
Definition eval.h:35
fvnormal
subroutine fvnormal(x, n1, n2, n3, n4, nx, ny, nz)
Definition fvmbag1.F:576
area
subroutine area(d1, x, x2, y, y2, eint, stif0)
Definition hm_read_prop32.F:567
itribox
subroutine itribox(tri, box, norm, nverts, poly, nvmax)
Definition itribox.F:31
min
#define min(a, b)
Definition macros.h:20
max
#define max(a, b)
Definition macros.h:21
merge
subroutine merge(x, itab, itabm1, cmerge, imerge, imerge2, iadmerge2, nmerge_tot)
Definition merge.F:36
id
initmumps id
Definition multiplerhs_example.m:4
for
for(i8=*sizetab-1;i8 >=0;i8--)
Definition mumps_common.c:91
fvbag_gpolcut_mod
Definition gpolcut.F:28
fvbag_gpolcut_mod::fvbag_gpolcut
subroutine fvbag_gpolcut(ipoly, rpoly, ipoly_old, rpoly_old, inedge, rnedge, nbnedge, nx, ny, nz, x0, y0, z0, ins, rns, nn, nhol, inz, iz, nns3, npoly, ns, ielnod, ielnod_old)
Definition gpolcut.F:40
message_mod
Definition message_mod.F:1249
names_and_titles_mod
Definition names_and_titles_mod.F:997
names_and_titles_mod::nchartitle
integer, parameter nchartitle
Definition names_and_titles_mod.F:1003
reorder_mod
Definition reorder_mod.F:45
facnor
subroutine facnor(x, d, ii, xnorm, cdg, invert)
Definition facnor.F:30
tritri3
subroutine tritri3(icut, fv0, fv1, fv2, fu0, fu1, fu2)
Definition fvmbags_stub.F:74
tribox3
subroutine tribox3(icut, bcenter, bhalfsize, tverts)
Definition fvmbags_stub.F:55
tmass
subroutine tmass(x, nc, geo, pm, ms, stifn, partsav, v, ipart, mst, stifint, stt, area, mxt, nc1, nc2, x1, x2, y1, y2, z1, z2)
Definition tmass.F:33