Anexo III – Rutinas para obtener los modelos de elementos finitos
98
Anexo III
RUTINAS PARA OBTENER
LOS MODELOS DE
ELEMENTOS FINITOS Este anexo recoge todo el código escrito en el lenguaje de programación:
FORTRAN. Son varios los programas que se debieron crear, para diversas aplicaciones.
Su enumeración en este anexo sigue el orden en el que aparecen sobre la memoria del
proyecto.
Para utilizar cualquiera de ellos es necesario ubicar el archivo .for y los
diferentes archivos que el código necesite, en la carpeta C:/FORTRAN/. O cambiar a la
ruta deseada en la programación del archivo Fortran.
Anexo III – Rutinas para obtener los modelos de elementos finitos
99
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 1 %
C % "selnodosyeltos.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Imaginese que se tiene la definición de nodos y elementos de un
C modelo. También se tiene un grupo de elementos y sus nodos (pero
C no la definición de los mismos) correspondientes a un submodelo
C del modelo inicial. Este programa permite obtener la definición
C de los nodos y elementos del submodelo, a partir de la
C definición de los nodos y elementos del modelo inicial.
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,N_NODOS,FILAS,AUX,EXITO
REAL*4 NODOS_MAX(MAX,4),NODOS[ALLOCATABLE](:,:),NRB_MAX(MAX,16),
1NRB[ALLOCATABLE](:,:),RN[ALLOCATABLE](:,:)
INTEGER*4 E_PIEL,E_MAX(MAX,5),PIEL[ALLOCATABLE](:,:),FILASE,
1RB_MAX(MAX,16),RB[ALLOCATABLE](:,:),RE[ALLOCATABLE](:,:)
C LEE LOS NODOS DEL ARCHIVO NODOS.txt Y LOS GUARDA EN LA
C VARIABLE "NODOS". CONTIENE LA DEFINICIÓN DE TODOS LOS NODOS
C DEL MODELO COMPLETO
OPEN (unit=101,file='C:\FORTRAN\NODOS.txt',status='unknown')
N_NODOS=0
DO I=1,MAX
READ(101,*,END=16) (NODOS_MAX(I,J),J=1,4)
N_NODOS=N_NODOS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',N_NODOS,'NODOS'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS(N_NODOS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,N_NODOS
NODOS(I,1:4)=NODOS_MAX(I,1:4)
ENDDO
C LEE EL GRUPO DE NODOS DEL ARCHIVO nregboca.txt Y LOS GUARDA EN
C LA VARIABLE "NRB". SON LOS NODOS DE LA SELECCIÓN DEL MODELO
C DE BOCA
OPEN (unit=101,file='C:\FORTRAN\nregboca.txt',status='unknown')
FILAS=0
DO I=1,MAX
READ(101,*,END=17) (NRB_MAX(I,J),J=1,16)
FILAS=FILAS+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',FILAS,'FILAS'
CLOSE(unit=101,status='keep')
ALLOCATE (NRB(FILAS,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
Anexo III – Rutinas para obtener los modelos de elementos finitos
100
ENDIF
DO I=1,FILAS
NRB(I,1:16)=NRB_MAX(I,1:16)
ENDDO
ALLOCATE (RN(FILAS*16,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C LEE LOS ELEMENTOS DEL ARCHIVO PIEL.txt Y LOS GUARDA EN LA
C VARIABLE "PIEL". CONTIENE LA DEFINICIÓN DE TODOS LOS ELEMENTOS
C DE LA PIEL DEL MODELO COMPLETO
OPEN (unit=101,file='C:\FORTRAN\PIEL.txt',status='unknown')
E_PIEL=0
DO I=1,MAX
READ(101,*,END=18) (E_MAX(I,J),J=1,5)
E_PIEL=E_PIEL+1
ENDDO
18 WRITE(*,*) 'Terminada lectura de eltos',E_PIEL,'E_PIEL'
CLOSE(unit=101,status='keep')
ALLOCATE (PIEL(E_PIEL,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,E_PIEL
PIEL(I,1:5)=E_MAX(I,1:5)
ENDDO
C LEE EL GRUPO DE ELEMENTOS DEL ARCHIVO regboca.txt Y LOS GUARDA
C EN LA VARIABLE "RB". SON LOS ELEMENTOS DE LA SELECCIÓN PARA EL
C MODELO DE BOCA
OPEN (unit=101,file='C:\FORTRAN\regboca.txt',status='unknown')
FILASE=0
DO I=1,MAX
READ(101,*,END=19) (RB_MAX(I,J),J=1,16)
FILASE=FILASE+1
ENDDO
19 WRITE(*,*) 'Terminada lectura de eltos',FILASE,'FILASE'
CLOSE(unit=101,status='keep')
ALLOCATE (RB(FILASE,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,FILASE
RB(I,1:16)=RB_MAX(I,1:16)
ENDDO
ALLOCATE (RE(FILASE*16,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C SELECCIONA LOS NODOS DEL GRUPO "NRB", DE ENTRE TODOS LA
C DEFINICIÓN DE TODOS LOS NODOS. PARA CONSEGUIR LA
Anexo III – Rutinas para obtener los modelos de elementos finitos
101
C DEFINICIÓN EXCLUSIVA DEL GRUPO DE NODOS "NRB",
C GUARDANDO DICHA DEFINICIÓN EN LA VARIABLE "RN".
AUX=0
DO I=1,FILAS
DO J=1,16
IF(NRB(I,J).NE.0.0)THEN
AUX=AUX+1
DO K=1,4
RN(AUX,K)=NODOS(NRB(I,J),K)
ENDDO
ENDIF
ENDDO
ENDDO
C SELECCIONA LOS ELTOS DEL GRUPO "RB", DE ENTRE TODOS
C LOS ELEMENTOS DE "PIEL". CONSIGUIENDO LA DEFINICIÓN
C DE LOS ELEMENTOS DEL GRUPO "RB", QUE SE GUARDA EN "RE"
AUX=0
DO I=1,FILASE
DO J=1,16
IF(RB(I,J).NE.0.0)THEN
DO N=1,E_PIEL
IF(RB(I,J).EQ.PIEL(N,1))THEN
AUX=AUX+1
DO K=1,5
RE(AUX,K)=PIEL(N,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDIF
ENDDO
ENDDO
C ESCRIBE EL ARCHIVO regBOCA.inp QUE TIENE EL MODELO DE BOCA
C SELECCIONADO.
OPEN (unit=101,file='regBOCA.inp',status='unknown')
WRITE(101,*) '*NODE,NSET=NTODO'
DO I=1,FILAS*16
WRITE(101,11)
INT(RN(I,1)),',',RN(I,2),',',RN(I,3),',',RN(I,4)
ENDDO
WRITE(101,*) '*ELEMENT, TYPE=C3D4, ELSET=ETODO'
DO I=1,FILASE*16
WRITE(101,12)
RE(I,1),',',RE(I,2),',',RE(I,3),',',RE(I,4),',',RE(I,5)
ENDDO
CLOSE(unit=101,status='keep')
11 FORMAT(I8,A1,F10.8,A1,F10.8,A1,F10.8)
12 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
102
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 2 %
C % "n_comun_2grupos.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este programa proporciona la definición de los nodos comunes a
C dos grupos de nodos. Para ello también es necesaria una variable
C que contenga la definición de los nodos. En nuestro caso la
C definición de los nodos de la región de la boca.
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,AUX,EXITO,N_NODOS
REAL*4 NODOS_MAX(MAX,4),NODOS[ALLOCATABLE](:,:),NS(10000,4)
INTEGER*4 CONT_G1,G1_MAX(MAX,16),G1[ALLOCATABLE](:,:),
1CONT_G2,G2_MAX(MAX,16),G2[ALLOCATABLE](:,:),COMUNES(10000,1)
C LEE LOS NODOS DEL ARCHIVO G1.txt Y LOS GUARDA EN LA
C VARIABLE "G1".
OPEN (unit=101,file='C:\FORTRAN\G1.txt',status='unknown')
CONT_G1=0
DO I=1,MAX
READ(101,*,END=16) (G1_MAX(I,J),J=1,16)
CONT_G1=CONT_G1+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_G1,'FILAS G1'
CLOSE(unit=101,status='keep')
ALLOCATE (G1(CONT_G1,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_G1
G1(I,1:16)=G1_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO G2.txt Y LOS GUARDA EN LA
C VARIABLE "G2".
OPEN (unit=101,file='C:\FORTRAN\G2.txt',status='unknown')
CONT_G2=0
DO I=1,MAX
READ(101,*,END=17) (G2_MAX(I,J),J=1,16)
CONT_G2=CONT_G2+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_G2,'FILAS G2'
CLOSE(unit=101,status='keep')
ALLOCATE (G2(CONT_G2,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_G2
G2(I,1:16)=G2_MAX(I,1:16)
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
103
C LEE LOS NODOS DEL ARCHIVO NODOS.txt Y LOS GUARDA EN LA
C VARIABLE "NODOS".
OPEN (unit=101,file='C:\FORTRAN\NODOS.txt',status='unknown')
N_NODOS=0
DO I=1,MAX
READ(101,*,END=18) (NODOS_MAX(I,J),J=1,4)
N_NODOS=N_NODOS+1
ENDDO
18 WRITE(*,*) 'Terminada lectura de nodos',N_NODOS,'NODOS'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS(N_NODOS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,N_NODOS
NODOS(I,1:4)=NODOS_MAX(I,1:4)
ENDDO
C ALMACENA EN UN VECTOR COLUMNA TODOS LOS NODOS COMUNES A G1 Y G2
C DICHO VECTOR SE LLAMA "COMUNES"
AUX=0
DO I=1,CONT_G1
DO J=1,16
IF(G1(I,J).NE.0.0)THEN
DO K=1,CONT_G2
DO L=1,16
IF(G1(I,J).EQ.G2(K,L))THEN
AUX=AUX+1
COMUNES(AUX,1)=G1(I,J)
EXIT
ENDIF
ENDDO
ENDDO
ENDIF
ENDDO
ENDDO
C SELECCIONA LOS NODOS DEL VECTOR "COMUNES", DE ENTRE TODOS
C LOS NODOS PARA OBTENER LA DEFINICION DE LOS NODOS
C COMUNES
DO I=1,AUX
DO J=1,N_NODOS
IF(COMUNES(I,1).EQ.INT(NODOS(J,1)))THEN
DO K=1,4
NS(I,K)=NODOS(J,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C ESCRIBE EL VECTOR COMUNES, CON LOS NODOS QUE PERTENECEN
C A LOS DOS GRUPOS
OPEN (unit=101,file='COMUNES.txt',status='unknown')
DO I=1,AUX
WRITE(101,12) COMUNES(I,1)
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
104
CLOSE(unit=101,status='keep')
12 FORMAT(I8)
C ESCRIBE LA DEFINICIÓN DE LOS NODOS COMUNES
OPEN (unit=101,file='NODOS_SUPERFICIE.txt',status='unknown')
DO I=1,AUX
WRITE(101,11)
INT(NS(I,1)),',',NS(I,2),',',NS(I,3),',',NS(I,4)
ENDDO
CLOSE(unit=101,status='keep')
11 FORMAT(I8,A1,F10.8,A1,F10.8,A1,F10.8)
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
105
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 3 %
C % "proyecta.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este programa lee una superficie de nodos, los cuales son
C proyectados sobre un plano que se define a partir de tres nodos
C que pertenezcan al grupo de nodos de la superficie. Luego nos
C calcula los desplazamientos necesarios a dar a cada nodo de la
C superfice para que sea proyectado sobre el plano definido.
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,M,N_NODOS,EXITO
REAL*4 NPLANO(1,3),CNP(3,3),A(1),B(1),C(1),D(1),
1t(1),NS_MAX(MAX,4),NS[ALLOCATABLE](:,:),
2PN[ALLOCATABLE](:,:),DN[ALLOCATABLE](:,:)
C LEE LOS NODOS DE LA SUPERFICIE
OPEN (unit=101,file='C:\FORTRAN\NODOS_SUPERFICIE.txt',
1status='unknown')
N_NODOS=0
DO I=1,MAX
READ(101,*,END=16) (NS_MAX(I,J),J=1,4)
N_NODOS=N_NODOS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',N_NODOS,'N_NODOS'
CLOSE(unit=101,status='keep')
ALLOCATE (NS(N_NODOS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (PN(N_NODOS,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (DN(N_NODOS,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,N_NODOS
NS(I,1:4)=NS_MAX(I,1:4)
ENDDO
C DEFINIR LOS NODOS QUE DEFINEN EL PLANO (ESCOGIDOS ENTRE LOS
C NODOS DE LA SUPERFICIE)
NPLANO(1,1)=202471
NPLANO(1,2)=202538
NPLANO(1,3)=203991
C [CNP] CONTIENE LAS COORDENADAS DE LOS TRES NODOS QUE DEFINEN
C EL PLANO
K=1
J=1
Anexo III – Rutinas para obtener los modelos de elementos finitos
106
DO L=1,3
DO I=1,N_NODOS
IF(NPLANO(K,L).EQ.NS(I,J))THEN
DO M=2,4
CNP(L,M-1)=NS(I,M)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C DEFINICIÓN DEL PLANO: SE DEFINIRAN 3 VBLES: (A,B,C) QUE SE
C CORRESPONDEN CON LAS TRES COMPONENTES (X,Y,Z) DEL VECTOR NORMAL
C AL PLANO. DICHO VECTOR SE DEFINE COMO EL PRODUCTO VECTORIAL
C DE LOS VECTORES QUE DEFINEN EL SEGUNDO Y EL TERCER NODO
C RESPECTO AL PRIMERO.
A=((CNP(3,2)-CNP(1,2))*(CNP(2,3)-CNP(1,3)))-((CNP(3,3)-
1CNP(1,3))*(CNP(2,2)-CNP(1,2)))
B=-(((CNP(3,1)-CNP(1,1))*(CNP(2,3)-CNP(1,3)))-((CNP(3,3)-
1CNP(1,3))*(CNP(2,1)-CNP(1,1))))
C=((CNP(3,1)-CNP(1,1))*(CNP(2,2)-CNP(1,2)))-((CNP(2,1)-
1CNP(1,1))*(CNP(3,2)-CNP(1,2)))
C COMPONENTE D: TERMINO INDEPENDIENTE
D=A*CNP(1,1)+B*CNP(1,2)+C*CNP(1,3)
C PROYECCIÓN DE TODOS LOS NODOS DE LA SUPERFICIE SOBRE EL PLANO
C DEFINIDO
DO I=1,N_NODOS
t(1)=(D(1)-A(1)*NS(I,2)-B(1)*NS(I,3)-C(1)*NS(I,4))/
1(A(1)**2+B(1)**2+C(1)**2)
PN(I,1)=NS(I,2)+A(1)*t(1)
PN(I,2)=NS(I,3)+B(1)*t(1)
PN(I,3)=NS(I,4)+C(1)*t(1)
ENDDO
C OBTENCIÓN DE LOS DESPLAZAMIENTOS A DAR PARA CADA NODO. RESTA
C LAS COORDENADAS DE LOS NODOS PROYECTADOS MENOS LAS COORDENADAS
C DE LOS MISMOS ANTES DE PROYECTARSE. ESTO NOS PROPORCIONA LAS
C CONDICIONES DE CONTORNO EN DESPLAZAMIENTOS A SIMULAR.
DO I=1,N_NODOS
DO J=1,3
DN(I,J)=PN(I,J)-NS(I,J+1)
ENDDO
ENDDO
C ESCRIBE LOS PARAMETROS A,B,C,D DEL PLANO DEFINIDO
OPEN (unit=101,file='PLANO.txt',status='unknown')
WRITE(101,11) A(1),',',B(1),',',C(1),',',D(1)
CLOSE(unit=101,status='keep')
11 FORMAT(F12.8,A1,F12.8,A1,F12.8,A1,F12.8)
C ESCRIBE LOS DESPLAZAMIENTOS A DAR A CADA NODO, DIRECTAMENTE
C COMO CONDICIONES DE CONTORNO EN DESPLAZAMIENTOS PARA ABAQUS
OPEN (unit=101,file='CC.txt',status='unknown')
DO I=1,N_NODOS
J=1
K=2
L=3
WRITE(101,12) INT(NS(I,1)),',',J,',',J,',',DN(I,1)
Anexo III – Rutinas para obtener los modelos de elementos finitos
107
WRITE(101,12) INT(NS(I,1)),',',K,',',K,',',DN(I,2)
WRITE(101,12) INT(NS(I,1)),',',L,',',L,',',DN(I,3)
ENDDO
CLOSE(unit=101,status='keep')
12 FORMAT(I8,A1,I8,A1,I8,A1,F12.8)
END
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 4 %
Anexo III – Rutinas para obtener los modelos de elementos finitos
108
C % "restringe.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este programa lee un grupo de nodos y los escribe con el
C formato de condición de contorno de ABAQUS, con desplazamientos
C nulos.
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,N_NODOS,EXITO,L,M
INTEGER*4 M_MAX(MAX,16),Mcc0[ALLOCATABLE](:,:)
REAL*4 CC(1)
C LEE EL GRUPO DE NODOS QUE SE TIENEN QUE ESCRIBIR COMO UN VECTOR
C CON DESPLAZAMIENTOS RESTRINGIDOS.
OPEN (unit=101,file='C:\FORTRAN\Mcc0.txt',status='unknown')
N_NODOS=0
DO I=1,MAX
READ(101,*,END=16) (M_MAX(I,J),J=1,16)
N_NODOS=N_NODOS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',N_NODOS,'N_NODOS'
CLOSE(unit=101,status='keep')
ALLOCATE (Mcc0(N_NODOS,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,N_NODOS
Mcc0(I,1:16)=M_MAX(I,1:16)
ENDDO
C ESCRIBE LOS NODOS CON LA CONDICIÓN DE CONTORNO DE
C DESPLAZAMIENTOS NULOS
OPEN (unit=101,file='CC0.txt',status='unknown')
L=1
M=3
CC=0.0
DO I=1,N_NODOS
DO J=1,16
IF(Mcc0(I,J).NE.0)THEN
WRITE(101,11) Mcc0(I,J),',',L,',',M,',',CC
ENDIF
ENDDO
ENDDO
CLOSE(unit=101,status='keep')
11 FORMAT(I8,A1,I4,A1,I4,A1,F10.6)
END
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Anexo III – Rutinas para obtener los modelos de elementos finitos
109
C % Código 5 %
C % "geomdef.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,N_NODOS,FILAS,EXITO,AUX
REAL*4 NODOS_MAX(MAX,4),NODOS[ALLOCATABLE](:,:),U_MAX(MAX,4),
1U[ALLOCATABLE](:,:),GEOMDEF[ALLOCATABLE](:,:),
2NODOSGD[ALLOCATABLE](:,:)
C LEE LOS NODOS DEL ARCHIVO NODOS.txt Y LOS GUARDA EN LA
C VARIABLE "NODOS".
OPEN (unit=101,file='C:\FORTRAN\NODOS.txt',status='unknown')
N_NODOS=0
DO I=1,MAX
READ(101,*,END=16) (NODOS_MAX(I,J),J=1,4)
N_NODOS=N_NODOS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',N_NODOS,'NODOS'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS(N_NODOS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,N_NODOS
NODOS(I,1:4)=NODOS_MAX(I,1:4)
ENDDO
C LEE LOS DESPLAZAMIENTOS NODALES DE U.txt Y LOS GUARDA EN LA
C VARIABLE "U".
OPEN (unit=101,file='C:\FORTRAN\U.txt',status='unknown')
FILAS=0
DO I=1,MAX
READ(101,*,END=17) (U_MAX(I,J),J=1,4)
FILAS=FILAS+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',FILAS,'FILAS'
CLOSE(unit=101,status='keep')
ALLOCATE (U(FILAS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,FILAS
U(I,1:4)=U_MAX(I,1:4)
ENDDO
ALLOCATE (GEOMDEF(FILAS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
Anexo III – Rutinas para obtener los modelos de elementos finitos
110
ALLOCATE (NODOSGD(N_NODOS,4),STAT=EXITO)
IF (EXITO.NE.0)THEN
PRINT*,"ERROR"
ENDIF
C SUMA LOS DESPLAZAMIENTOS 'U', A LA DEFINICIÓN DE NODOS DE LA
GEOMETRÍA
C INDEFORMADA 'NODOS', PARA OBTENER LA DEFINICIÓN DE LOS NODOS DE
LA GEOMETRÍA
C DEFORMADA: ALMACENÁNDOSE ÉSTA EN LA VBLE 'GEOMDEF'
C GEOMDEF CONTIENE SOLO LOS NODOS DE LA REGIÓN QUE SE SELECCIONÓ
DE LA BOCA
DO I=1,FILAS
DO J=1,4
IF(J.NE.1)THEN
IF(((U(I,J).LT.10E-30).AND.(U(I,J).GT.0)).OR.
2 ((U(I,J).GT.-10E-30).AND.(U(I,J).LT.0)))THEN
U(I,J)=0.0
ENDIF
GEOMDEF(I,J)=U(I,J)+NODOS(INT(U(I,1)),J)
ELSE
GEOMDEF(I,J)=U(I,J)
ENDIF
ENDDO
ENDDO
DO I=1,N_NODOS
DO J=1,4
NODOSGD(I,J)=0
ENDDO
ENDDO
DO I=1,N_NODOS
DO J=1,FILAS
IF(INT(GEOMDEF(J,1)).EQ.NODOS(I,1))THEN
NODOSGD(I,1)=1
AUX=J
EXIT
ENDIF
ENDDO
IF(NODOSGD(I,1).EQ.0)THEN
DO K=1,4
NODOSGD(I,K)=NODOS(I,K)
ENDDO
ELSE
DO K=1,4
NODOSGD(I,K)=GEOMDEF(AUX,K)
ENDDO
ENDIF
ENDDO
C ESCRIBE
OPEN (unit=101,file='GEOMDEF.txt',status='unknown')
DO I=1,FILAS
WRITE(101,11) INT(GEOMDEF(I,1)),',',GEOMDEF(I,2)
2,',',GEOMDEF(I,3),',',GEOMDEF(I,4)
ENDDO
CLOSE(unit=101,status='keep')
11 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
Anexo III – Rutinas para obtener los modelos de elementos finitos
111
OPEN (unit=101,file='NODOSGD.txt',status='unknown')
DO I=1,N_NODOS
WRITE(101,11) INT(NODOSGD(I,1)),',',NODOSGD(I,2)
2,',',NODOSGD(I,3),',',NODOSGD(I,4)
ENDDO
CLOSE(unit=101,status='keep')
END
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Anexo III – Rutinas para obtener los modelos de elementos finitos
112
C % Código 6 %
C % "separación_comisura.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este programa obtiene primero la superficie de nodos comunes a
C dos grupos de nodos y su definición. Posteriormente los duplica,
C comenzando la duplicación en el índice que deseemos. Y asigna,
C los nodos duplicados a formar parte de un grupo de elementos
C que indicamos.
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,M,AUX,EXITO,CONT_NTODO,INICIODEFINICION,AUX2
REAL*4 NTODO_MAX(MAX,4),NTODO[ALLOCATABLE](:,:),
1DEFCOMUNES(10000,4),NDUPL(10000,4)
INTEGER*4 CONT_NLABSUP,NLABSUP_MAX(MAX,16),NLABSUP[ALLOCATABLE]
1(:,:),CONT_NLABINF,NLABINF_MAX(MAX,16),NLABINF[ALLOCATABLE]
2(:,:),2CONT_LABINF,LABINF_MAX(MAX,16),LABINF[ALLOCATABLE](:,:),
3CONT_ETODO,ETODO_MAX(MAX,5),ETODO[ALLOCATABLE](:,:),
4ETODOMOD[ALLOCATABLE](:,:),
5NCOMUN(10000,1)
C LEE LOS NODOS DEL ARCHIVO NLABSUP.txt Y LOS GUARDA EN LA
C VARIABLE "NLABSUP". SON NODOS PERTENECIENTES AL LABIO SUPERIOR
OPEN (unit=101,file='C:\FORTRAN\NLABSUP.txt',status='unknown')
CONT_NLABSUP=0
DO I=1,MAX
READ(101,*,END=16) (NLABSUP_MAX(I,J),J=1,16)
CONT_NLABSUP=CONT_NLABSUP+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NLABSUP,
1'FILAS NLABSUP'
CLOSE(unit=101,status='keep')
ALLOCATE (NLABSUP(CONT_NLABSUP,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NLABSUP
NLABSUP(I,1:16)=NLABSUP_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NLABINF.txt Y LOS GUARDA EN LA
C VARIABLE "NLABINF". SON NODOS PERTENECIENTES AL LABIO INFERIOR
OPEN (unit=101,file='C:\FORTRAN\NLABINF.txt',status='unknown')
CONT_NLABINF=0
DO I=1,MAX
READ(101,*,END=17) (NLABINF_MAX(I,J),J=1,16)
CONT_NLABINF=CONT_NLABINF+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_NLABINF,
1'FILAS NLABINF'
CLOSE(unit=101,status='keep')
ALLOCATE (NLABINF(CONT_NLABINF,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
Anexo III – Rutinas para obtener los modelos de elementos finitos
113
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NLABINF
NLABINF(I,1:16)=NLABINF_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NTODO.txt Y LOS GUARDA EN LA
C VARIABLE "NTODO". ES LA DEFINICIÓN DE TODOS LOS NODOS DEL
C MODELO DE LA BOCA
OPEN (unit=101,file='C:\FORTRAN\NTODO.txt',status='unknown')
CONT_NTODO=0
DO I=1,MAX
READ(101,*,END=18) (NTODO_MAX(I,J),J=1,4)
CONT_NTODO=CONT_NTODO+1
ENDDO
18 WRITE(*,*) 'Terminada lectura de nodos',CONT_NTODO,'FILAS NTODO'
CLOSE(unit=101,status='keep')
ALLOCATE (NTODO(CONT_NTODO,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NTODO
NTODO(I,1:4)=NTODO_MAX(I,1:4)
ENDDO
C LEE EL GRUPO DE ELEMENTOS DEL LABIO INFERIOR DEL ARCHIVO
C LABINF.txt Y LOS GUARDA EN LA VARIABLE "LABINF"
OPEN (unit=101,file='C:\FORTRAN\LABINF.txt',status='unknown')
CONT_LABINF=0
DO I=1,MAX
READ(101,*,END=19) (LABINF_MAX(I,J),J=1,16)
CONT_LABINF=CONT_LABINF+1
ENDDO
19 WRITE(*,*) 'Terminada lectura de nodos',CONT_LABINF,'FILAS
LABINF'
CLOSE(unit=101,status='keep')
ALLOCATE (LABINF(CONT_LABINF,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_LABINF
LABINF(I,1:16)=LABINF_MAX(I,1:16)
ENDDO
C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO ETODO.txt
C Y LOS ALMACENA EN LA VARIABLE "ETODO". CONTIENE LA DEFINICIÓN
C DE TODOS LOS ELEMENTOS DEL MODELO DE LA BOCA
C SE ASIGNAN LAS MISMAS DIMENSIONES DE "ETODO" A LA VBLE
C "ETODOMOD".
OPEN (unit=101,file='C:\FORTRAN\ETODO.txt',status='unknown')
CONT_ETODO=0
DO I=1,MAX
READ(101,*,END=20) (ETODO_MAX(I,J),J=1,5)
CONT_ETODO=CONT_ETODO+1
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
114
20 WRITE(*,*) 'Terminada lectura de nodos',CONT_ETODO,'FILAS ETODO'
CLOSE(unit=101,status='keep')
ALLOCATE (ETODO(CONT_ETODO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ETODO
ETODO(I,1:5)=ETODO_MAX(I,1:5)
ENDDO
ALLOCATE (ETODOMOD(CONT_ETODO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C ALMACENA EN UN VECTOR COLUMNA (VBLE "NCOMUN") TODOS LOS
C NODOS COMUNES A NLABSUP Y NLABINF
AUX=0
DO I=1,CONT_NLABSUP
DO J=1,16
IF(NLABSUP(I,J).NE.0.0)THEN
DO K=1,CONT_NLABINF
DO L=1,16
IF(NLABSUP(I,J).EQ.NLABINF(K,L))THEN
AUX=AUX+1
NCOMUN(AUX,1)=NLABSUP(I,J)
EXIT
ENDIF
ENDDO
ENDDO
ENDIF
ENDDO
ENDDO
C SELECCIONA LOS NODOS DEL VECTOR NCOMUN, DE ENTRE LA DEFINICION
C DE TODOS LOS NODOS DE LA VARIABLE "NTODO"
C PARA OBTENER LA DEFINICION DE NODOS COMUNES, ALMACENANDOLA EN
C "DEFCOMUNES"
DO I=1,AUX
DO J=1,CONT_NTODO
IF(NCOMUN(I,1).EQ.INT(NTODO(J,1)))THEN
DO K=1,4
DEFCOMUNES(I,K)=NTODO(J,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C DEFINE EL NUMERO DE NODO A PARTIR DEL CUAL SE COMIENZA LA
C DUPLICACIÓN
INICIODEFINICION=500000
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEFCOMUNES",
C ALMACENANDOSE LOS DUPLICADOS EN LA VARIABLE "NDUPL"
AUX2=INICIODEFINICION+1
Anexo III – Rutinas para obtener los modelos de elementos finitos
115
DO I=1,AUX
NDUPL(I,1)=AUX2
AUX2=AUX2+1
ENDDO
DO I=1,AUX
DO K=2,4
NDUPL(I,K)=DEFCOMUNES(I,K)
ENDDO
ENDDO
C COPIA DE "ETODO" EN LA VBLE "ETODOMOD"
DO I=1,CONT_ETODO
DO J=1,5
ETODOMOD(I,J)=ETODO(I,J)
ENDDO
ENDDO
C LECTURA ELTO A ELTO DEL GRUPO "LABINF", LEYENDO DEFINICIÓN
C EN "ETODO", SE BUSCAN DE ENTRE LOS NODOS QUE DEFINEN ESTOS
C ELEMENTOS IGUALES A LOS DE NCOMUN.
C CUANDO SE ENCUENTRA SE VA ACTUALIZANDO LA VBLE "ETODOMOD"
C CON LOS NODOS DUPLICADOS.
C SE ESTÁN ASIGNANDO LOS NODOS DUPLICADOS A LA DEFINICIÓN
C DE LOS ELEMENTOS DEL LABIO INFERIOR.
DO I=1,CONT_LABINF
DO J=1,16
IF(LABINF(I,J).NE.0.0)THEN
DO K=1,CONT_ETODO
IF(LABINF(I,J).EQ.ETODOMOD(K,1))THEN
DO L=1,AUX
IF(NCOMUN(L,1).EQ.ETODOMOD(K,2))THEN
ETODOMOD(K,2)=INT(NDUPL(L,1))
ENDIF
IF(NCOMUN(L,1).EQ.ETODOMOD(K,3))THEN
ETODOMOD(K,3)=INT(NDUPL(L,1))
ENDIF
IF(NCOMUN(L,1).EQ.ETODOMOD(K,4))THEN
ETODOMOD(K,4)=INT(NDUPL(L,1))
ENDIF
IF(NCOMUN(L,1).EQ.ETODOMOD(K,5))THEN
ETODOMOD(K,5)=INT(NDUPL(L,1))
ENDIF
ENDDO
ENDIF
ENDDO
ENDIF
ENDDO
ENDDO
C ESCRIBE EL VECTOR "NCOMUN", CON LOS NODOS QUE PERTENECEN A
C LA VEZ A LOS GRUPOS SUP E INF. ESTE SIRVE PARA COMPROBAR
Anexo III – Rutinas para obtener los modelos de elementos finitos
116
OPEN (unit=101,file='NCOMUN.txt',status='unknown')
DO I=1,AUX
WRITE(101,21) NCOMUN(I,1)
ENDDO
CLOSE(unit=101,status='keep')
21 FORMAT(I8)
C ESCRIBE LA DEFINICIÓN DE LOS NODOS DUPLICADOS: "NDUPL"
OPEN (unit=101,file='NDUPL.txt',status='unknown')
DO I=1,AUX
WRITE(101,22)
INT(NDUPL(I,1)),',',NDUPL(I,2),',',NDUPL(I,3),
1 ',',NDUPL(I,4)
ENDDO
CLOSE(unit=101,status='keep')
22 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
C ESCRIBE LA DEFINICIÓN DE LOS NODOS COMUNES
OPEN (unit=101,file='ETODOMOD.txt',status='unknown')
DO I=1,CONT_ETODO
WRITE(101,23)
ETODOMOD(I,1),',',ETODOMOD(I,2),',',ETODOMOD(I,3),
1 ',',ETODOMOD(I,4),',',ETODOMOD(I,5)
ENDDO
CLOSE(unit=101,status='keep')
23 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
C ESCRIBE EL GRUPO DE NODOS DUPLICADOS: "GNDUPL"
OPEN (unit=101,file='GNDUPL.txt',status='unknown')
DO I=1,AUX
WRITE(101,21) INT(NDUPL(I,1))
ENDDO
CLOSE(unit=101,status='keep')
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
117
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 7 %
C % "crear_shell.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,AUX,AUX1,AUX2,AUX3,AUX5,EXITO
INTEGER*4 CONT_NSLS,NSLS_MAX(MAX,1),NSLS[ALLOCATABLE](:,:),
1CONT_NSLI,NSLI_MAX(MAX,1),NSLI[ALLOCATABLE](:,:),
2CONT_ETODOMOD,ETODOMOD_MAX(MAX,5),ETODOMOD[ALLOCATABLE](:,:),
3ETODOAUX[ALLOCATABLE](:,:),
4CONT_ESLS,ESLS[ALLOCATABLE](:,:),SH_LS[ALLOCATABLE](:,:),
5CONT_ESLI,ESLI[ALLOCATABLE](:,:),SH_LI[ALLOCATABLE](:,:)
C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO "ETODOMOD.txt"
C Y LOS ALMACENA EN LA VARIABLE "ETODOMOD"
C ALMACENA MEMORIA PARA LA VBLE "ETODOAUX", DONDE COPIA EL
C CONTENIDO DE "ETODOMOD" AÑADIÉNDOLE DOS COLUMNAS DE CEROS AL
C FINAL
OPEN (unit=101,file='C:\FORTRAN\ETODOMOD.txt',
1status='unknown')
CONT_ETODOMOD=0
DO I=1,MAX
READ(101,*,END=15) (ETODOMOD_MAX(I,J),J=1,5)
CONT_ETODOMOD=CONT_ETODOMOD+1
ENDDO
15 WRITE(*,*) 'Terminada lectura de nodos',CONT_ETODOMOD,
1'FILAS ETODOMOD'
CLOSE(unit=101,status='keep')
ALLOCATE (ETODOMOD(CONT_ETODOMOD,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (ETODOAUX(CONT_ETODOMOD,7),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ETODOMOD
ETODOMOD(I,1:5)=ETODOMOD_MAX(I,1:5)
ENDDO
DO I=1,CONT_ETODOMOD
ETODOAUX(I,1:5)=ETODOMOD_MAX(I,1:5)
ENDDO
DO I=1,CONT_ETODOMOD
ETODOAUX(I,6:7)=0
ENDDO
C LEE LA DEFINICIÓN DEL ARCHIVO "NSUP_LABSUP.txt" Y
C LO ALMACENA EN NSLS
OPEN (unit=101,file='C:\FORTRAN\NSUP_LABSUP.txt',
1status='unknown')
CONT_NSLS=0
DO I=1,MAX
READ(101,*,END=16) (NSLS_MAX(I,1))
Anexo III – Rutinas para obtener los modelos de elementos finitos
118
CONT_NSLS=CONT_NSLS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NSLS,
1'FILAS NSLS'
CLOSE(unit=101,status='keep')
ALLOCATE (NSLS(CONT_NSLS,1),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NSLS
NSLS(I,1)=NSLS_MAX(I,1)
ENDDO
C LEE LA DEFINICIÓN DEL ARCHIVO "NSUP_LABINF.txt" Y
C LO ALMACENA EN NSLI
OPEN (unit=101,file='C:\FORTRAN\NSUP_LABINF.txt',
1status='unknown')
CONT_NSLI=0
DO I=1,MAX
READ(101,*,END=17) (NSLI_MAX(I,1))
CONT_NSLI=CONT_NSLI+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_NSLI,
1'FILAS NSLI'
CLOSE(unit=101,status='keep')
ALLOCATE (NSLI(CONT_NSLI,1),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NSLI
NSLI(I,1)=NSLI_MAX(I,1)
ENDDO
C EN LA 6º COLUMNA DE "ETODOAUX" SE PONE UN 1 SI EN
C DICHA FILA HAY TRES NODOS QUE PERTENEZCAN AL GRUPO
C DE NODOS "NSLS"
CONT_ESLS=0
DO I=1,CONT_ETODOMOD
AUX=0
DO J=2,5
DO K=1,CONT_NSLS
IF(NSLS(K,1).EQ.ETODOMOD(I,J))THEN
AUX=AUX+1
IF(AUX.EQ.3)THEN
ETODOAUX(I,6)=1
CONT_ESLS=CONT_ESLS+1
ENDIF
ENDIF
ENDDO
ENDDO
ENDDO
C ALMACENO MEMORIA PARA LA VBLE "ESLS" Y "SH_LS"
ALLOCATE (ESLS(CONT_ESLS,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
Anexo III – Rutinas para obtener los modelos de elementos finitos
119
ENDIF
ALLOCATE (SH_LS(CONT_ESLS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C EN LA 7º COLUMNA DE "ETODOAUX" SE PONE UN 1 SI EN
C DICHA FILA HAY TRES NODOS QUE PERTENEZCAN AL GRUPO
C DE NODOS "NSLI"
CONT_ESLI=0
DO I=1,CONT_ETODOMOD
AUX=0
DO J=2,5
DO K=1,CONT_NSLI
IF(NSLI(K,1).EQ.ETODOMOD(I,J))THEN
AUX=AUX+1
IF(AUX.EQ.3)THEN
ETODOAUX(I,7)=1
CONT_ESLI=CONT_ESLI+1
ENDIF
ENDIF
ENDDO
ENDDO
ENDDO
C ALMACENO MEMORIA PARA LA VBLE "ESLI" Y "SH_LI"
ALLOCATE (ESLI(CONT_ESLI,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (SH_LI(CONT_ESLI,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C ALMACENO LA DEFINICIÓN DE LOS ELEMENTOS QUE TIENEN UN 1 EN
C LA 6º COLUMNA DE "ETODOAUX", EN LA VBLE "ESLS". ES DECIR,
C NOS QUEDAMOS CON LOS ELEMENTOS DEL LABIO SUPERIOR QUE TIENEN
C UNA CARA QUE PERTENECERÍA AL CONTACTO
AUX5=1
DO I=1,CONT_ETODOMOD
IF(ETODOAUX(I,6).EQ.1)THEN
ESLS(AUX5,1:5)=ETODOAUX(I,1:5)
AUX5=AUX5+1
ENDIF
ENDDO
C ALMACENO LA DEFINICIÓN DE LOS ELEMENTOS QUE TIENEN UN 1 EN
C LA 7º COLUMNA DE "ETODOAUX", EN LA VBLE "ESLI". ES DECIR,
C NOS QUEDAMOS CON LOS ELEMENTOS DEL LABIO INFERIOR QUE TIENEN
C UNA CARA QUE PERTENECERÍA AL CONTACTO
AUX5=1
DO I=1,CONT_ETODOMOD
IF(ETODOAUX(I,7).EQ.1)THEN
ESLI(AUX5,1:5)=ETODOAUX(I,1:5)
AUX5=AUX5+1
ENDIF
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
120
C SE CREAN LOS SHELL DEL LABIO SUPERIOR. DE LOS ELEMENTOS DE
C "ESLS" SE BORRA EL NODO QUE NO PERTENECE AL GRUPO "NSLS",
C QUEDANDO LA DEFINICIÓN DEL ELEMENTO SHELL (POR TRES NODOS)
C DE LA SUPERFICIEDEL LABIO SUPERIOR, QUE SE ALMACENA
C EN "SH_LS"
AUX1=5000001
DO I=1,CONT_ESLS
SH_LS(I,1)=AUX1
AUX1=AUX1+1
ENDDO
DO I=1,CONT_ESLS
AUX3=2
DO J=2,5
DO K=1,CONT_NSLS
IF(NSLS(K,1).EQ.ESLS(I,J))THEN
SH_LS(I,AUX3)=ESLS(I,J)
AUX3=AUX3+1
ENDIF
ENDDO
ENDDO
ENDDO
C SE CREAN LOS SHELL DEL LABIO INFERIOR. DE LOS ELEMENTOS DE
C "ESLI" SE BORRA EL NODO QUE NO PERTENECE AL GRUPO "NSLI",
C QUEDANDO LA DEFINICIÓN DEL ELEMENTO SHELL (POR TRES NODOS)
C DE LA SUPERFICIE DEL LABIO INFERIOR, QUE SE ALMACENA
C EN "SH_LI"
AUX2=6000001
DO I=1,CONT_ESLI
SH_LI(I,1)=AUX2
AUX2=AUX2+1
ENDDO
DO I=1,CONT_ESLI
AUX3=2
DO J=2,5
DO K=1,CONT_NSLI
IF(NSLI(K,1).EQ.ESLI(I,J))THEN
SH_LI(I,AUX3)=ESLI(I,J)
AUX3=AUX3+1
ENDIF
ENDDO
ENDDO
ENDDO
C ESCRIBE LA VARIABLE "SH_LS"
OPEN (unit=101,file='SH_LS.txt',status='unknown')
DO I=1,CONT_ESLS
WRITE(101,21) SH_LS(I,1),',',SH_LS(I,2),','
1 ,SH_LS(I,3),',',SH_LS(I,4)
ENDDO
CLOSE(unit=101,status='keep')
C ESCRIBE LA VARIABLE "SH_LI"
OPEN (unit=101,file='SH_LI.txt',status='unknown')
DO I=1,CONT_ESLI
WRITE(101,21) SH_LI(I,1),',',SH_LI(I,2),','
1 ,SH_LI(I,3),',',SH_LI(I,4)
ENDDO
CLOSE(unit=101,status='keep')
21 FORMAT(I8,A1,I8,A1,I8,A1,I8)
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
121
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 8 %
C % "actmod_completo.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,EXITO,CONT_NODOS,CONT_NTODO
REAL*4 NODOS_MAX(MAX,4),NODOS[ALLOCATABLE](:,:),
1NTODO_MAX(MAX,4),NTODO[ALLOCATABLE](:,:),
2NODOS2[ALLOCATABLE](:,:)
INTEGER*4 CONT_PIEL,PIEL_MAX(MAX,5),PIEL[ALLOCATABLE](:,:),
1CONT_ETODOMOD,ETODOMOD_MAX(MAX,5),ETODOMOD[ALLOCATABLE](:,:),
2PIEL2[ALLOCATABLE](:,:)
C LEE LA CREACIÓN DE NODOS DEL ARCHIVO "NODOS.txt" Y LO GUARDA
C EN LA VBLE "NODOS"
C ALMACENA MEMORIA PARA LA VBLE "NODOS2" Y COPIA
C LA VBLE "NODOS" EN "NODOS2"
OPEN (unit=101,file='C:\FORTRAN\NODOS.txt',status='unknown')
CONT_NODOS=0
DO I=1,MAX
READ(101,*,END=16) (NODOS_MAX(I,J),J=1,4)
CONT_NODOS=CONT_NODOS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS,
1'FILAS NODOS'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS(CONT_NODOS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (NODOS2(CONT_NODOS,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOS
NODOS(I,1:4)=NODOS_MAX(I,1:4)
NODOS2(I,1:4)=NODOS_MAX(I,1:4)
ENDDO
C LEE LA CREACIÓN DE NODOS DEL ARCHIVO "NTODO.txt" Y LO GUARDA
C EN LA VBLE "NTODO"
OPEN (unit=101,file='C:\FORTRAN\NTODO.txt',status='unknown')
CONT_NTODO=0
DO I=1,MAX
READ(101,*,END=17) (NTODO_MAX(I,J),J=1,4)
CONT_NTODO=CONT_NTODO+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_NTODO,
1'FILAS NTODO'
CLOSE(unit=101,status='keep')
ALLOCATE (NTODO(CONT_NTODO,4),STAT=EXITO)
Anexo III – Rutinas para obtener los modelos de elementos finitos
122
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NTODO
NTODO(I,1:4)=NTODO_MAX(I,1:4)
ENDDO
C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO ETODOMOD.txt
C Y LOS ALMACENA EN LA VARIABLE "ETODOMOD"
OPEN (unit=101,file='C:\FORTRAN\ETODOMOD.txt',status='unknown')
CONT_ETODOMOD=0
DO I=1,MAX
READ(101,*,END=18) (ETODOMOD_MAX(I,J),J=1,5)
CONT_ETODOMOD=CONT_ETODOMOD+1
ENDDO
18 WRITE(*,*) 'Terminada lectura de nodos',CONT_ETODOMOD,
1'FILAS ETODOMOD'
CLOSE(unit=101,status='keep')
ALLOCATE (ETODOMOD(CONT_ETODOMOD,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ETODOMOD
ETODOMOD(I,1:5)=ETODOMOD_MAX(I,1:5)
ENDDO
C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO PIEL.txt
C Y LOS ALMACENA EN LA VARIABLE "PIEL"
C ALMACENA MEMORIA PARA LA VBLE "PIEL2" Y COPIA
C LA VBLE "PIEL" EN "PIEL2"
OPEN (unit=101,file='C:\FORTRAN\PIEL.txt',status='unknown')
CONT_PIEL=0
DO I=1,MAX
READ(101,*,END=19) (PIEL_MAX(I,J),J=1,5)
CONT_PIEL=CONT_PIEL+1
ENDDO
19 WRITE(*,*) 'Terminada lectura de nodos',CONT_PIEL,
1'FILAS PIEL'
CLOSE(unit=101,status='keep')
ALLOCATE (PIEL(CONT_PIEL,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (PIEL2(CONT_PIEL,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_PIEL
PIEL(I,1:5)=PIEL_MAX(I,1:5)
PIEL2(I,1:5)=PIEL_MAX(I,1:5)
ENDDO
C ACTUALIZA LA VARIABLE "PIEL" CON "ETODOMOD", SE GUARDA EN
C "PIEL2"
Anexo III – Rutinas para obtener los modelos de elementos finitos
123
DO I=1,CONT_ETODOMOD
DO J=1,CONT_PIEL
IF(ETODOMOD(I,1).EQ.PIEL(J,1))THEN
PIEL2(J,2:5)=ETODOMOD(I,2:5)
ENDIF
ENDDO
ENDDO
C ACTUALIZA LA VARIABLE "NODOS" CON "NTODO", SE GUARDA EN
C "NODOS2"
DO I=1,CONT_NTODO
DO J=1,CONT_NODOS
IF(NTODO(I,1).EQ.NODOS(J,1))THEN
NODOS2(J,2:4)=NTODO(I,2:4)
ENDIF
ENDDO
ENDDO
C ESCRIBE LA VARIABLE "NODOS2"
OPEN (unit=101,file='NODOS2.txt',status='unknown')
DO I=1,CONT_NODOS
WRITE(101,21) INT(NODOS2(I,1)),',',NODOS2(I,2),','
1 ,NODOS2(I,3),',',NODOS2(I,4)
ENDDO
CLOSE(unit=101,status='keep')
21 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
C ESCRIBE LA VARIABLE "PIEL2"
OPEN (unit=101,file='PIEL2.txt',status='unknown')
DO I=1,CONT_PIEL
WRITE(101,22) PIEL2(I,1),',',PIEL2(I,2),',',PIEL2(I,3),
1 ',',PIEL2(I,4),',',PIEL2(I,5)
ENDDO
CLOSE(unit=101,status='keep')
22 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
124
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 9 %
C % "comunes_y_duplica.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este programa selecciona los nodos comunes a los grupos: "NPIEL"
C y "NHUESO". Luego busca los nodos comunes que pertenezcan al
C grupo de nodos "NAUX_VEST", guardándose en "NVEST". Se definen
C los nodos de "NVEST" con ayuda de la variable "NODOS2" que tiene
C la definición de todos los nodos del modelo. Se duplica "NVEST"
C en la variable "NDUPL". Finalmente se sustituyen los nodos
C duplicados por los correspondientes nodos de la definición de
C elementos del grupo Hueso.
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,AUX,AUX2,AUX3,EXITO,CONT_NODOS2,
1INICIODEFINICION
REAL*4 NODOS2_MAX(MAX,4),NODOS2[ALLOCATABLE](:,:),
1DEF_NVEST[ALLOCATABLE](:,:),NDUPL[ALLOCATABLE](:,:)
INTEGER*4 CONT_NPIEL,NPIEL_MAX(MAX,16),NPIEL[ALLOCATABLE](:,:),
1CONT_NHUESO,NHUESO_MAX(MAX,16),NHUESO[ALLOCATABLE](:,:),
2CONT_HUESO,HUESO_MAX(MAX,5),HUESO[ALLOCATABLE](:,:),
3CONT_NAUX_VEST,NAUX_VEST_MAX(MAX,16),NAUX_VEST[ALLOCATABLE]
4(:,:),COMUNES(100000,1),NVEST(100000,1),
5HUESO2[ALLOCATABLE](:,:)
C LEE LOS NODOS DEL ARCHIVO NAUX_VEST.txt Y LOS GUARDA EN LA
C VARIABLE "NAUX_VEST".
OPEN (unit=101,file='C:\FORTRAN\NAUX_VEST.txt',
1status='unknown')
CONT_NAUX_VEST=0
DO I=1,MAX
READ(101,*,END=14) (NAUX_VEST_MAX(I,J),J=1,16)
CONT_NAUX_VEST=CONT_NAUX_VEST+1
ENDDO
14 WRITE(*,*) 'Terminada lectura de nodos',CONT_NAUX_VEST,
2'FILAS NAUX_VEST'
CLOSE(unit=101,status='keep')
ALLOCATE (NAUX_VEST(CONT_NAUX_VEST,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NAUX_VEST
NAUX_VEST(I,1:16)=NAUX_VEST_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NPIEL.txt Y LOS GUARDA EN LA
C VARIABLE "NPIEL".
OPEN (unit=101,file='C:\FORTRAN\NPIEL.txt',status='unknown')
CONT_NPIEL=0
DO I=1,MAX
READ(101,*,END=15) (NPIEL_MAX(I,J),J=1,16)
CONT_NPIEL=CONT_NPIEL+1
ENDDO
15 WRITE(*,*) 'Terminada lectura de nodos',CONT_NPIEL,
Anexo III – Rutinas para obtener los modelos de elementos finitos
125
1'FILAS NPIEL'
CLOSE(unit=101,status='keep')
ALLOCATE (NPIEL(CONT_NPIEL,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NPIEL
NPIEL(I,1:16)=NPIEL_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NHUESO.txt Y LOS GUARDA EN LA
C VARIABLE "NHUESO".
OPEN (unit=101,file='C:\FORTRAN\NHUESO.txt',status='unknown')
CONT_NHUESO=0
DO I=1,MAX
READ(101,*,END=16) (NHUESO_MAX(I,J),J=1,16)
CONT_NHUESO=CONT_NHUESO+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NHUESO,
1'FILAS NHUESO'
CLOSE(unit=101,status='keep')
ALLOCATE (NHUESO(CONT_NHUESO,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NHUESO
NHUESO(I,1:16)=NHUESO_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NODOS2.txt Y LOS GUARDA EN LA
C VARIABLE "NODOS2". CONTIENE LA DEFINICIÓN DE TODOS LOS NODOS
C DEL MODELO.
OPEN (unit=101,file='C:\FORTRAN\NODOS2.txt',status='unknown')
CONT_NODOS2=0
DO I=1,MAX
READ(101,*,END=17) (NODOS2_MAX(I,J),J=1,4)
CONT_NODOS2=CONT_NODOS2+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS2,
1'FILAS NODOS2'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS2(CONT_NODOS2,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOS2
NODOS2(I,1:4)=NODOS2_MAX(I,1:4)
ENDDO
C LEE LA DEFINICIÓN DE ELEMENTOS DEL HUESO DEL ARCHIVO
C HUESO.txt Y LOS GUARDA EN LA VARIABLE "HUESO". TAMBIEN
C SE COPIA HUESO EN HUESO2.
OPEN (unit=101,file='C:\FORTRAN\HUESO.txt',status='unknown')
CONT_HUESO=0
Anexo III – Rutinas para obtener los modelos de elementos finitos
126
DO I=1,MAX
READ(101,*,END=18) (HUESO_MAX(I,J),J=1,5)
CONT_HUESO=CONT_HUESO+1
ENDDO
18 WRITE(*,*) 'Terminada lectura de nodos',CONT_HUESO,'FILAS HUESO'
CLOSE(unit=101,status='keep')
ALLOCATE (HUESO(CONT_HUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
HUESO(I,1:5)=HUESO_MAX(I,1:5)
ENDDO
ALLOCATE (HUESO2(CONT_HUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
HUESO2(I,1:5)=HUESO_MAX(I,1:5)
ENDDO
C ALMACENA EN UN VECTOR COLUMNA TODOS LOS NODOS COMUNES A NPIEL
C Y NHUESO
AUX=0
DO I=1,CONT_NPIEL
DO J=1,16
IF(NPIEL(I,J).NE.0.0)THEN
DO K=1,CONT_NHUESO
DO L=1,16
IF(NPIEL(I,J).EQ.NHUESO(K,L))THEN
AUX=AUX+1
COMUNES(AUX,1)=NPIEL(I,J)
EXIT
ENDIF
ENDDO
ENDDO
ENDIF
ENDDO
ENDDO
C SELECCIONA LOS NODOS DEL VECTOR COMUNES, DENTRO DEL GRUPO
C "NAUX_VEST". PARA OBTENER LOS NODOS COMUNES ENTRE PIEL Y HUESO
C DEL VESTIBULO: "NVEST". Y SE GUARDA MEMORIA PARA DEF_NVEST
C Y NDUPL.
AUX2=0
DO I=1,AUX
DO J=1,CONT_NAUX_VEST
DO K=1,16
IF(COMUNES(I,1).EQ.NAUX_VEST(J,K))THEN
AUX2=AUX2+1
NVEST(AUX2,1)=NAUX_VEST(J,K)
EXIT
ENDIF
ENDDO
ENDDO
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
127
ALLOCATE (DEF_NVEST(AUX2,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (NDUPL(AUX2,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C SELECCIONA LOS NODOS DEL VECTOR "NVEST", DE ENTRE LA DEFINICIÓN
C DE TODOS LOS NODOS EN "NODOS2". PARA OBTENER LA DEFINICIÓN DE
C LOS NODOS COMUNES ENTRE PIEL Y HUESO DEL VESTIBULO
DO I=1,AUX2
DO J=1,CONT_NODOS2
IF(NVEST(I,1).EQ.INT(NODOS2(J,1)))THEN
DO K=1,4
DEF_NVEST(I,K)=NODOS2(J,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C DEFINE EL NUMERO DE NODO A PARTIR DEL CUAL SE COMIENZA
C LA DUPLICACIÓN
INICIODEFINICION=600000
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEF_NVEST",
C ALMACENANDOSE LOS DUPLICADOS EN LA VARIABLE "NDUPL"
AUX3=INICIODEFINICION+1
DO I=1,AUX2
NDUPL(I,1)=AUX3
AUX3=AUX3+1
ENDDO
DO I=1,AUX2
DO K=2,4
NDUPL(I,K)=DEF_NVEST(I,K)
ENDDO
ENDDO
C LECTURA ELTO A ELTO DE "HUESO"
C SE BUSCAN DE ENTRE LOS NODOS QUE DEFINEN ESTOS ELEMENTOS
C IGUALES A LOS DE "NVEST"
C CDO SE ENCUENTRA SE VA ACTUALIZANDO LA VBLE "HUESO2" CON
C LOS NODOS DUPLICADOS "NDUPL"
DO I=1,CONT_HUESO
DO K=1,AUX2
IF(NVEST(K,1).EQ.HUESO(I,2))THEN
HUESO2(I,2)=INT(NDUPL(K,1))
ENDIF
IF(NVEST(K,1).EQ.HUESO(I,3))THEN
HUESO2(I,3)=INT(NDUPL(K,1))
ENDIF
IF(NVEST(K,1).EQ.HUESO(I,4))THEN
HUESO2(I,4)=INT(NDUPL(K,1))
ENDIF
IF(NVEST(K,1).EQ.HUESO(I,5))THEN
HUESO2(I,5)=INT(NDUPL(K,1))
Anexo III – Rutinas para obtener los modelos de elementos finitos
128
ENDIF
ENDDO
ENDDO
C ESCRIBE EL VECTOR "COMUNES", CON LOS NODOS QUE PERTENECEN
C A PIEL Y HUESO
OPEN (unit=101,file='COMUNES.txt',status='unknown')
DO I=1,AUX
WRITE(101,12) COMUNES(I,1)
ENDDO
CLOSE(unit=101,status='keep')
12 FORMAT(I8)
C ESCRIBE EL VECTOR "NVEST", CON LOS NODOS QUE PERTENECEN
C A PIEL Y HUESO EN EL VESTIBULO
OPEN (unit=101,file='NVEST.txt',status='unknown')
DO I=1,AUX2
WRITE(101,12) NVEST(I,1)
ENDDO
CLOSE(unit=101,status='keep')
C ESCRIBE LA DEFINICIÓN DE LOS NODOS COMUNES A PIEL Y HUESO
C DEL VESTIBULO, QUE SE ENCUENTRAN EN LA VBLE "DEF_NVEST"
OPEN (unit=101,file='DEF_NVEST.txt',status='unknown')
DO I=1,AUX2
WRITE(101,11) INT(DEF_NVEST(I,1)),',',DEF_NVEST(I,2),
1',',DEF_NVEST(I,3),',',DEF_NVEST(I,4)
ENDDO
CLOSE(unit=101,status='keep')
11 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
C ESCRIBE LA DEFINICIÓN DE LOS NODOS DUPLICADOS: "NDUPL"
OPEN (unit=101,file='NDUPL.txt',status='unknown')
DO I=1,AUX2
WRITE(101,11) INT(NDUPL(I,1)),',',NDUPL(I,2),',',
1NDUPL(I,3),',',NDUPL(I,4)
ENDDO
CLOSE(unit=101,status='keep')
C ESCRIBE LA NUEVA DEFINICIÓN DE "HUESO" ("HUESO2")
OPEN (unit=101,file='HUESO2.txt',status='unknown')
DO I=1,CONT_HUESO
WRITE(101,13) HUESO2(I,1),',',HUESO2(I,2),',',HUESO2(I,3),
1 ',',HUESO2(I,4),',',HUESO2(I,5)
ENDDO
CLOSE(unit=101,status='keep')
13 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
C ESCRIBE EL GRUPO DE NODOS DUPLICADOS: "GNDUPL"
OPEN (unit=101,file='GNDUPL.txt',status='unknown')
DO I=1,AUX2
WRITE(101,12) INT(NDUPL(I,1))
ENDDO
CLOSE(unit=101,status='keep')
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
129
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 10 %
C % "separar_mandibula.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este programa permite separar el grupo seleccionado como
C mandíbula del resto de estructura ósea. Se parte de los archivos
C NPyH, HUESO, PIEL, NODOS_MAND, NODOS_MSYC, MAXSUP_Y_CRANEO y
C MANDIBULA. Se comienza con la creación de la definición de los
C elementos de la mandíbula y del maxilar superior y craneo.
C Luego se buscan los nodos comunes a estos dos grupos y se
C duplican. Por último se asignan los nodos duplicados a la
C definición del maxilar superior y cráneo, y se actualiza la
C variable NPyH con los nuevos nodos duplicados.
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,AUX,AUX2,COMUNES,INICIODEFINICION
INTEGER*4 CONT_NPyH
REAL*4 NPyH_MAX(MAX,4),NPyH[ALLOCATABLE](:,:),
1DEF_COMUNES[ALLOCATABLE](:,:),DEF_DUPLICADOS[ALLOCATABLE](:,:)
INTEGER*4 CONT_HUESO,HUESO_MAX(MAX,5),HUESO[ALLOCATABLE](:,:)
INTEGER*4 CONT_PIEL,PIEL_MAX(MAX,5),PIEL[ALLOCATABLE](:,:)
INTEGER*4 CONT_NODOS_MAND,NODOS_MAND_MAX(MAX,16),
1NODOS_MAND[ALLOCATABLE](:,:)
INTEGER*4 CONT_NODOS_MSYC,NODOS_MSYC_MAX(MAX,16),
1NODOS_MSYC[ALLOCATABLE](:,:)
INTEGER*4 CONT_MAXSUP_Y_CRANEO,MAXSUP_Y_CRANEO_MAX(MAX,16),
1MAXSUP_Y_CRANEO[ALLOCATABLE](:,:)
INTEGER*4 CONT_MANDIBULA,MANDIBULA_MAX(MAX,16),
1MANDIBULA[ALLOCATABLE](:,:)
INTEGER*4 DEF_MAND(200000,5),DEF_MSYC(250000,5),CONT_DEFMAND,
1CONT_DEFMSYC,DEF_MSYCMOD[ALLOCATABLE](:,:)
C LEE LOS NODOS DEL ARCHIVO NPyH.txt Y LOS GUARDA EN LA
C VARIABLE "NPyH".
OPEN (unit=101,file='C:\FORTRAN\NPyH.inp',status='unknown')
CONT_NPyH=0
DO I=1,MAX
READ(101,*,END=14) (NPyH_MAX(I,J),J=1,4)
CONT_NPyH=CONT_NPyH+1
ENDDO
14 WRITE(*,*) 'Terminada lectura de nodos',CONT_NPyH,
2'FILAS NPyH'
CLOSE(unit=101,status='keep')
ALLOCATE (NPyH(CONT_NPyH,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
Anexo III – Rutinas para obtener los modelos de elementos finitos
130
DO I=1,CONT_NPyH
NPyH(I,1:4)=NPyH_MAX(I,1:4)
ENDDO
C LEE EL ARCHIVO DE CREACIÓN DE ELEMENTOS DE HUESO, A PARTIR DE
C HUESO.inp Y LO ALMACENA EN VARIABLE: "HUESO"
OPEN (unit=101,file='C:\FORTRAN\HUESO.inp',status='unknown')
CONT_HUESO=0
DO I=1,MAX
READ(101,*,END=15) (HUESO_MAX(I,J),J=1,5)
CONT_HUESO=CONT_HUESO+1
ENDDO
15 WRITE(*,*) 'Terminada lectura de nodos',CONT_HUESO,'FILAS HUESO'
CLOSE(unit=101,status='keep')
ALLOCATE (HUESO(CONT_HUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
HUESO(I,1:5)=HUESO_MAX(I,1:5)
ENDDO
C LEE EL ARCHIVO DE CREACIÓN DE ELEMENTOS DE PIEL, A PARTIR DE
C PIEL.inp Y LO ALMACENA EN VARIABLE: "PIEL"
OPEN (unit=101,file='C:\FORTRAN\PIEL.inp',status='unknown')
CONT_PIEL=0
DO I=1,MAX
READ(101,*,END=16) (PIEL_MAX(I,J),J=1,5)
CONT_PIEL=CONT_PIEL+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_PIEL,'FILAS PIEL'
CLOSE(unit=101,status='keep')
ALLOCATE (PIEL(CONT_PIEL,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_PIEL
PIEL(I,1:5)=PIEL_MAX(I,1:5)
ENDDO
ALLOCATE (HUESO2(CONT_HUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
HUESO2(I,1:5)=HUESO_MAX(I,1:5)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NODOS_MAND.inp Y LOS GUARDA EN LA
C VARIABLE "NODOS_MAND".
OPEN
(unit=101,file='C:\FORTRAN\NODOS_MAND.inp',status='unknown')
CONT_NODOS_MAND=0
DO I=1,MAX
READ(101,*,END=19) (NODOS_MAND_MAX(I,J),J=1,16)
Anexo III – Rutinas para obtener los modelos de elementos finitos
131
CONT_NODOS_MAND=CONT_NODOS_MAND+1
ENDDO
19 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS_MAND,
1'FILAS NODOS_MAND'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS_MAND(CONT_NODOS_MAND,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOS_MAND
NODOS_MAND(I,1:16)=NODOS_MAND_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NODOS_MSYC.inp Y LOS GUARDA EN LA
C VARIABLE "NODOS_MSYC".
OPEN
(unit=101,file='C:\FORTRAN\NODOS_MSYC.inp',status='unknown')
CONT_NODOS_MSYC=0
DO I=1,MAX
READ(101,*,END=20) (NODOS_MSYC_MAX(I,J),J=1,16)
CONT_NODOS_MSYC=CONT_NODOS_MSYC+1
ENDDO
20 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS_MSYC,
1'FILAS NODOS_MSYC'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS_MSYC(CONT_NODOS_MSYC,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOS_MSYC
NODOS_MSYC(I,1:16)=NODOS_MSYC_MAX(I,1:16)
ENDDO
C LEE LOS ELTOS MAXSUP_Y_CRANEO.inp Y LOS GUARDA EN LA
C VARIABLE "MAXSUP_Y_CRANEO".
OPEN
(unit=101,file='C:\FORTRAN\MAXSUP_Y_CRANEO.inp',status='unknown')
CONT_MAXSUP_Y_CRANEO=0
DO I=1,MAX
READ(101,*,END=21) (MAXSUP_Y_CRANEO_MAX(I,J),J=1,16)
CONT_MAXSUP_Y_CRANEO=CONT_MAXSUP_Y_CRANEO+1
ENDDO
21 WRITE(*,*) 'Terminada lectura de nodos',CONT_MAXSUP_Y_CRANEO,
1'FILAS MAXSUP_Y_CRANEO'
CLOSE(unit=101,status='keep')
ALLOCATE (MAXSUP_Y_CRANEO(CONT_MAXSUP_Y_CRANEO,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_MAXSUP_Y_CRANEO
MAXSUP_Y_CRANEO(I,1:16)=MAXSUP_Y_CRANEO_MAX(I,1:16)
ENDDO
C LEE LOS ELTOS MANDIBULA.inp Y LOS GUARDA EN LA
Anexo III – Rutinas para obtener los modelos de elementos finitos
132
C VARIABLE "MANDIBULA".
OPEN (unit=101,file='C:\FORTRAN\MANDIBULA.inp',status='unknown')
CONT_MANDIBULA=0
DO I=1,MAX
READ(101,*,END=22) (MANDIBULA_MAX(I,J),J=1,16)
CONT_MANDIBULA=CONT_MANDIBULA+1
ENDDO
22 WRITE(*,*) 'Terminada lectura de nodos',CONT_MANDIBULA,'FILAS
MANDIBULA'
CLOSE(unit=101,status='keep')
ALLOCATE (MANDIBULA(CONT_MANDIBULA,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_MANDIBULA
MANDIBULA(I,1:16)=MANDIBULA_MAX(I,1:16)
ENDDO
C
WRITE(*,*) 'Terminada lectura vbles e inicio definición'
C
C CREA LA DEFINICIÓN DE ELEMENTOS DE LA MANDIBULA. PARA ELLO, SE
VA LEYENDO
C LA VARIABLE QUE CONTIENE EL GRUPO DE ELEMENTOS DE LA MISMA:
"MANDIBULA", Y
C SE BUSCA LA DEFINICIÓN DE ESTOS EN "HUESO", DEFINIENDO
"DEF_MAND"
CONT_DEFMAND=0
DO I=1,CONT_MANDIBULA
DO J=1,16
IF(MANDIBULA(I,J).NE.0.0)THEN
DO K=1,CONT_HUESO
IF(MANDIBULA(I,J).EQ.HUESO(K,1))THEN
CONT_DEFMAND=CONT_DEFMAND+1
DEF_MAND(CONT_DEFMAND,1)=HUESO(K,1)
DEF_MAND(CONT_DEFMAND,2)=HUESO(K,2)
DEF_MAND(CONT_DEFMAND,3)=HUESO(K,3)
DEF_MAND(CONT_DEFMAND,4)=HUESO(K,4)
DEF_MAND(CONT_DEFMAND,5)=HUESO(K,5)
ENDIF
ENDDO
ENDIF
ENDDO
ENDDO
C CREA LA DEFINICIÓN DE ELEMENTOS DEL MAXSUP_Y_CRANEO. PARA ELLO,
C SE VA LEYENDO LA VARIABLE QUE CONTIENE EL GRUPO DE ELEMENTOS:
C "MAXSUP_Y_CRANEO", Y SE BUSCA LA DEFINICIÓN DE ESTOS EN
C "HUESO", DEFINIENDO "DEF_MSYC"
CONT_DEFMSYC=0
DO I=1,CONT_MAXSUP_Y_CRANEO
DO J=1,16
IF(MAXSUP_Y_CRANEO(I,J).NE.0.0)THEN
DO K=1,CONT_HUESO
IF(MAXSUP_Y_CRANEO(I,J).EQ.HUESO(K,1))THEN
Anexo III – Rutinas para obtener los modelos de elementos finitos
133
CONT_DEFMSYC=CONT_DEFMSYC+1
DEF_MSYC(CONT_DEFMSYC,1)=HUESO(K,1)
DEF_MSYC(CONT_DEFMSYC,2)=HUESO(K,2)
DEF_MSYC(CONT_DEFMSYC,3)=HUESO(K,3)
DEF_MSYC(CONT_DEFMSYC,4)=HUESO(K,4)
DEF_MSYC(CONT_DEFMSYC,5)=HUESO(K,5)
ENDIF
ENDDO
ENDIF
ENDDO
ENDDO
C LOS ELEMENTOS DEL MAXILAR SUPERIOR Y EL CRANEO, SE REDEFINIRAN
C CON LOS NODOS QUE SE HAYAN DUPLICADO. PARA ELLO SE GUARDA
MEMORIA
C DE LA VARIABLE: "DEF_MSYCMOD"
ALLOCATE (DEF_MSYCMOD(CONT_DEFMSYC,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C COPIA DEF_MSYC EN DEF_MSYCMOD
DO I=1,CONT_DEFMSYC
DO J=1,5
DEF_MSYCMOD(I,J)=DEF_MSYC(I,J)
ENDDO
ENDDO
C
WRITE(*,*) 'Terminada definición e inicio duplicación'
C
C ALMACENA EN UN VECTOR COLUMNA "COMUNES" TODOS LOS NODOS COMUNES
A LOS
C GRUPOS DE NODOS: "NODOS_MAND" Y "NODOS_MSYC"
AUX=0
DO I=1,CONT_NODOS_MAND
DO J=1,16
IF(NODOS_MAND(I,J).NE.0.0)THEN
DO K=1,CONT_NODOS_MSYC
DO L=1,16
IF(NODOS_MAND(I,J).EQ.NODOS_MSYC(K,L))THEN
AUX=AUX+1
COMUNES(AUX,1)=NODOS_MAND(I,J)
EXIT
ENDIF
ENDDO
ENDDO
ENDIF
ENDDO
ENDDO
C ALMACENA MEMORIA PARA LA VARIABLE QUE CONTIENE LA DEFINICIÓN DE
LOS
C NODOS COMUNES: "DEF_COMUNES"
ALLOCATE (DEF_COMUNES(AUX,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
Anexo III – Rutinas para obtener los modelos de elementos finitos
134
C ALMACENA MEMORIA PARA LA VARIABLE QUE CONTIENE LA DEFINICIÓN DE
LOS
C NODOS DUPLICADOS: "DEF_DUPLICADOS"
ALLOCATE (DEF_DUPLICADOS(AUX,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C SELECCIONA LOS NODOS DEL VECTOR "COMUNES", DE ENTRE LA
DEFINICIÓN
C DE TODOS LOS NODOS EN "HPyH". PARA OBTENER LA DEFINICIÓN DE
C LOS NODOS COMUNES "DEF_COMUNES"
DO I=1,AUX
DO J=1,CONT_NPyH
IF(COMUNES(I,1).EQ.INT(NPyH(J,1)))THEN
DO K=1,4
DEF_COMUNES(I,K)=NPyH(J,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C DEFINE EL NUMERO DE NODO A PARTIR DEL CUAL SE COMIENZA LA
DUPLICACIÓN
INICIODEFINICION=700000
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEF_COMUNES",
ALMACENANDOSE LOS
C DUPLICADOS EN LA VARIABLE "DEF_DUPLICADOS"
AUX2=INICIODEFINICION+1
DO I=1,AUX
DEF_DUPLICADOS(I,1)=AUX2
AUX2=AUX2+1
ENDDO
DO I=1,AUX
DO K=2,4
DEF_DUPLICADOS(I,K)=DEF_COMUNES(I,K)
ENDDO
ENDDO
C
WRITE(*,*) 'Terminada duplicación e inicio asignación
duplicados'
C
C LECTURA ELTO A ELTO DE "DEF_MSYC" BUSCANDO ENTRE LOS NODOS QUE
C DEFINEN ESTOS ELEMENTOS, NODOS QUE PERTENEZCAN A "DEF_COMUNES"
C CDO SE ENCUENTRAN SE VA ACTUALIZANDO LA VBLE "DEF_MSYCMOD" CON
C LOS NODOS DUPLICADOS "DEF_DUPLICADOS"
DO I=1,CONT_DEFMSYC
DO K=1,AUX
IF(INT(DEF_COMUNES(K,1)).EQ.DEF_MSYC(I,2))THEN
DEF_MSYCMOD(I,2)=INT(DEF_DUPLICADOS(K,1))
ENDIF
IF(INT(DEF_COMUNES(K,1)).EQ.DEF_MSYC(I,3))THEN
DEF_MSYCMOD(I,3)=INT(DEF_DUPLICADOS(K,1))
ENDIF
IF(INT(DEF_COMUNES(K,1)).EQ.DEF_MSYC(I,4))THEN
Anexo III – Rutinas para obtener los modelos de elementos finitos
135
DEF_MSYCMOD(I,4)=INT(DEF_DUPLICADOS(K,1))
ENDIF
IF(INT(DEF_COMUNES(K,1)).EQ.DEF_MSYC(I,5))THEN
DEF_MSYCMOD(I,5)=INT(DEF_DUPLICADOS(K,1))
ENDIF
ENDDO
ENDDO
C ESCRIBE LA DEFINICIÓN DE TODOS LOS NODOS DEL MODELO:
C "NPyH" + LA NUEVA DEFINICIÓN DE NODOS DUPLICADOS:
C "DEF_DUPLICADOS"
OPEN (unit=101,file='NPyH2.inp',status='unknown')
WRITE(101,*) '*NODE,NSET=NODOS_PIELYHUESO'
DO I=1,CONT_NPyH
WRITE(101,11) INT(NPyH(I,1)),',',NPyH(I,2),',',
1NPyH(I,3),',',NPyH(I,4)
ENDDO
DO I=1,AUX
WRITE(101,11) INT(DEF_DUPLICADOS(I,1)),',',
1DEF_DUPLICADOS(I,2),',',DEF_DUPLICADOS(I,3),',',
2DEF_DUPLICADOS(I,4)
ENDDO
CLOSE(unit=101,status='keep')
11 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
C ESCRIBE LA DEFINICIÓN DE ELTOS DE MANDIBULA
OPEN (unit=101,file='DEFMAND.inp',status='unknown')
WRITE(101,*) '*ELEMENT,TYPE=C3D4,ELSET=MANDIBULA'
DO I=1,CONT_DEFMAND
WRITE(101,12) DEF_MAND(I,1),',',DEF_MAND(I,2),',',
1DEF_MAND(I,3),',',DEF_MAND(I,4),',',DEF_MAND(I,5)
ENDDO
CLOSE(unit=101,status='keep')
12 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
C ESCRIBE LA DEFINICIÓN DE ELTOS DE MAXSUP Y CRANEO
OPEN (unit=101,file='DEFMSYC.inp',status='unknown')
WRITE(101,*) '*ELEMENT,TYPE=C3D4,ELSET=MAXSUP_Y_CRANEO'
DO I=1,CONT_DEFMSYC
WRITE(101,12) DEF_MSYCMOD(I,1),',',DEF_MSYCMOD(I,2),',',
1DEF_MSYCMOD(I,3),',',DEF_MSYCMOD(I,4),',',DEF_MSYCMOD(I,5)
ENDDO
CLOSE(unit=101,status='keep')
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
136
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 11 %
C % "Movimiento_mandibula.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,EXITO,AUX
INTEGER*4 CONT_NPyH
REAL*4 NPyH_MAX(MAX,4),NPyH[ALLOCATABLE](:,:),
1NCOMP[ALLOCATABLE](:,:)
INTEGER*4 CONT_NODOS_MAND,NODOS_MAND_MAX(MAX,16),
1NODOS_MAND[ALLOCATABLE](:,:)
REAL*4 V(1,3),A(1,3),B(1,3),BETA,BETAR,AB(1,3),ABMODULO,
1ZP(1,3),TS,PI
REAL*4 DNM(MAX,4),TI[ALLOCATABLE](:,:),T[ALLOCATABLE](:,:),
1S[ALLOCATABLE](:,:),SP[ALLOCATABLE](:,:),
2SPMODULO[ALLOCATABLE](:,:),XP[ALLOCATABLE](:,:),
3YP[ALLOCATABLE](:,:),DPL[ALLOCATABLE](:,:),DP[ALLOCATABLE](:,:),
4N[ALLOCATABLE](:,:),R[ALLOCATABLE](:,:),G[ALLOCATABLE](:,:),
5PL[ALLOCATABLE](:,:)
C LEE LOS NODOS DEL ARCHIVO NPyH2.txt Y LOS GUARDA EN LA
C VARIABLE "NPyH". EL ARCHIVO DESDE EL QUE SE LEE "NPyH2" TIENE
C LA DEFINICIÓN DE NODOS TRAS SEPARAR LA MANDÍBULA.
OPEN (unit=101,file='C:\FORTRAN\NPyH2.inp',status='unknown')
CONT_NPyH=0
DO I=1,MAX
READ(101,*,END=14) (NPyH_MAX(I,J),J=1,4)
CONT_NPyH=CONT_NPyH+1
ENDDO
14 WRITE(*,*) 'Terminada lectura de nodos',CONT_NPyH,
2'FILAS NPyH'
CLOSE(unit=101,status='keep')
ALLOCATE (NPyH(CONT_NPyH,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NPyH
NPyH(I,1:4)=NPyH_MAX(I,1:4)
ENDDO
ALLOCATE (NCOMP(CONT_NPyH,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NPyH
NCOMP(I,1:4)=NPyH_MAX(I,1:4)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NODOS_MAND.inp Y LOS GUARDA EN LA
Anexo III – Rutinas para obtener los modelos de elementos finitos
137
C VARIABLE "NODOS_MAND".
OPEN
(unit=101,file='C:\FORTRAN\NODOS_MAND.inp',status='unknown')
CONT_NODOS_MAND=0
DO I=1,MAX
READ(101,*,END=15) (NODOS_MAND_MAX(I,J),J=1,16)
CONT_NODOS_MAND=CONT_NODOS_MAND+1
ENDDO
15 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS_MAND,
1'FILAS NODOS_MAND'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS_MAND(CONT_NODOS_MAND,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOS_MAND
NODOS_MAND(I,1:16)=NODOS_MAND_MAX(I,1:16)
ENDDO
C
WRITE(*,*) 'Terminada lectura vbles e inicio definición nodos
1mandíbula'
C
C SELECCIONA LOS NODOS DEL VECTOR "NODOS_MAND", DE ENTRE LA
DEFINICIÓN
C DE TODOS LOS NODOS EN "HPyH". PARA OBTENER LA DEFINICIÓN DE
C LOS NODOS DE LA MANDÍBULA "DNM"
AUX=0
DO I=1,CONT_NODOS_MAND
DO J=1,16
IF(NODOS_MAND(I,J).NE.0.0)THEN
DO K=1,CONT_NPyH
IF(NODOS_MAND(I,J).EQ.INT(NPyH(K,1)))THEN
AUX=AUX+1
DO L=1,4
DNM(AUX,L)=NPyH(K,L)
ENDDO
EXIT
ENDIF
ENDDO
ENDIF
ENDDO
ENDDO
WRITE(*,*) 'AUX',AUX
ALLOCATE (TI(AUX,1),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (T(AUX,1),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
Anexo III – Rutinas para obtener los modelos de elementos finitos
138
ALLOCATE (S(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (SP(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (SPMODULO(AUX,1),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (XP(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (YP(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (G(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (PL(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (DPL(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (DP(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (N(AUX,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (R(AUX,3),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C
WRITE(*,*) 'Terminada definición nodos mandíbula e inicio def
1movimiento'
C
Anexo III – Rutinas para obtener los modelos de elementos finitos
139
C VECTOR TRASLACIÓN
V(1,1)=0
V(1,2)=0
V(1,3)=0
C DOS PUNTOS QUE DEFINEN EL EJE DE ROTACIÓN
A(1,1)=0.0457219779491425
A(1,2)=0.133177503943443
A(1,3)=0.136721208691597
B(1,1)=0.127031192183495
B(1,2)=0.130933851003647
B(1,3)=0.136469513177872
C ÁNGULO EN DECIMALES
BETA=15
TS=360
PI=3.14159265
C
BETAR=BETA*2*PI/TS
C
WRITE(*,*) 'Terminada definición movimiento e inicio movimiento'
C
C VECTOR AB (ES EL QUE DEFINE EL EJE)
AB(1,1)=B(1,1)-A(1,1)
AB(1,2)=B(1,2)-A(1,2)
AB(1,3)=B(1,3)-A(1,3)
C VECTOR AB UNITARIO: "ZP" Z PRIMA
ABMODULO=SQRT(AB(1,1)**2+AB(1,2)**2+AB(1,3)**2)
ZP(1,1)=AB(1,1)/ABMODULO
ZP(1,2)=AB(1,2)/ABMODULO
ZP(1,3)=AB(1,3)/ABMODULO
C
DO I=1,AUX
C TERMINO INDEPENDIENTE DE UN PLANO PERPENDICULAR AL VECTOR "AB"
C QUE PASA POR NODO "DNM(I,1)"
TI(I,1)=ZP(1,1)*DNM(I,2)+ZP(1,2)*DNM(I,3)+ZP(1,3)*DNM(I,4)
C RECTA AB EN IMPLÍCITAS, SE INTRODUCE EN LA ECUACIÓN DEL PLANO
PARA
C DESPEJAR EL PARÁMETRO "T"
C X=A(1,1)+AB(1,1)*T
C Y=A(1,2)+AB(1,2)*T
C Z=A(1,3)+AB(1,3)*T
T(I,1)=(TI(I,1)-ZP(1,1)*A(1,1)-ZP(1,2)*A(1,2)-ZP(1,3)*A(1,3))/
1(ZP(1,1)**2+ZP(1,2)**2+ZP(1,3)**2)
C RESOLVIENDO EL SISTEMA DE 3ECS CON 3INC QUE FORMAN LAS DOS
C ECUACIONES DE LA RECTA Y EL PLANO. SE OBTIENE LA INTERSECCIÓN DE
AMBOS.
C SE LLAMA AL PUNTO INTERSECCIÓN "S"
S(I,1)=A(1,1)+ZP(1,1)*T(I,1)
S(I,2)=A(1,2)+ZP(1,2)*T(I,1)
S(I,3)=A(1,3)+ZP(1,3)*T(I,1)
C VECTOR SP DEFINE OTRO EJE LOCAL. ÉSTE CONTENIDO EN EL PLANO
CALCULADO
C ANTERIORMENTE. P SE REFIERE AL PUNTO QUE SE TRABAJE (NODO DEL
BUCLE)
SP(I,1)=DNM(I,2)-S(I,1)
SP(I,2)=DNM(I,3)-S(I,2)
Anexo III – Rutinas para obtener los modelos de elementos finitos
140
SP(I,3)=DNM(I,4)-S(I,3)
C VECTOR SP UNITARIO: "XP" X PRIMA
SPMODULO(I,1)=SQRT(SP(I,1)**2+SP(I,2)**2+SP(I,3)**2)
XP(I,1)=SP(I,1)/SPMODULO(I,1)
XP(I,2)=SP(I,2)/SPMODULO(I,1)
XP(I,3)=SP(I,3)/SPMODULO(I,1)
C PRODUCTO VECTORIAL DE ZP SOBRE XP DEFINE EL TERCER EJE LOCAL:
"YP"
C ESTE VECTOR ES UNITARIO, YA QUE ZP Y XP LO SON Y FORMAN 90º
YP(I,1)=(ZP(1,2)*XP(I,3))-(ZP(1,3)*XP(I,2))
YP(I,2)=-(ZP(1,1)*XP(I,3))+(ZP(1,3)*XP(I,1))
YP(I,3)=(ZP(1,1)*XP(I,2))-(ZP(1,2)*XP(I,1))
C EL MODULO DEL VECTOR "SP" ES EL RADIO DE GIRO ENTORNO AL EJE.
C ESTE GIRO SE DEFINE COMO:
G(I,1)=SPMODULO(I,1)*COS(BETAR)
G(I,2)=SPMODULO(I,1)*SIN(BETAR)
G(I,3)=0
C P (COORDENADAS NODO) EN LOCALES:
PL(I,1)=SPMODULO(I,1)
PL(I,2)=0
PL(I,3)=0
C INCREMENTO P EN LOCALES:
DPL(I,1)=G(I,1)-PL(I,1)
DPL(I,2)=G(I,2)-PL(I,2)
DPL(I,3)=G(I,3)-PL(I,3)
C INCREMENTO DE P EN GLOBALES: "DP"
DP(I,1)=(XP(I,1)*DPL(I,1))+(YP(I,1)*DPL(I,2))
DP(I,2)=(XP(I,2)*DPL(I,1))+(YP(I,2)*DPL(I,2))
DP(I,3)=(XP(I,3)*DPL(I,1))+(YP(I,3)*DPL(I,2))
C LAS NUEVAS COORDENADAS "N" DEL PUNTO GIRADO SON:
C "DP" ES EL INCREMENTO DEBIDO AL GIRO
C "V" ES EL INCREMENTO DEBIDO A LA TRASLACIÓN
N(I,1)=DNM(I,1)
N(I,2)=DNM(I,2)+DP(I,1)+V(1,1)
N(I,3)=DNM(I,3)+DP(I,2)+V(1,2)
N(I,4)=DNM(I,4)+DP(I,3)+V(1,3)
C LOS INCREMENTOS "R" PARA ESCRIBIR LAS CC:
R(I,1)=DP(I,1)+V(1,1)
R(I,2)=DP(I,2)+V(1,2)
R(I,3)=DP(I,3)+V(1,3)
ENDDO
C
WRITE(*,*) 'Comprobación'
C
C LA COMPROBACIÓN DEVUELVE LA DEFINICIÓN DE NODOS: NPyH CON
C EL MOVIMIENTO IMPUESTO A LA MANDÍBULA. DE MANERA QUE AL CARGARLO
C EN ABAQUS CAE SE COMPRUEBE QUE EL GIRO SE REALIZA CON EXITO.
C LA NUEVA DEFINICIÓN DE "NPyH" SE OBTENDRÁ EN "NCOMP"
Anexo III – Rutinas para obtener los modelos de elementos finitos
141
DO I=1,AUX
DO J=1,CONT_NPyH
IF(INT(N(I,1)).EQ.INT(NPyH(J,1)))THEN
DO K=2,4
NCOMP(J,K)=N(I,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C
WRITE(*,*) 'Fin movimiento. Inicio escritura resultados'
C
C ESCRIBE LAS CONDICIONES DE CONTORNO, PARA IMPONER EL MOVIMIENTO
C REALIZADO A LA MANDÍBULA.
OPEN (unit=101,file='CCMAND.inp',status='unknown')
DO I=1,AUX
WRITE(101,11) INT(N(I,1)),',',1,',',1,',',R(I,1)
WRITE(101,11) INT(N(I,1)),',',2,',',2,',',R(I,2)
WRITE(101,11) INT(N(I,1)),',',3,',',3,',',R(I,3)
ENDDO
CLOSE(unit=101,status='keep')
11 FORMAT(I8,A1,I8,A1,I8,A1,E16.8)
C ESCRIBE LA DEFINICIÓN DE NODOS PARA COMPROBACIÓN
OPEN (unit=101,file='NCOMP.inp',status='unknown')
WRITE(101,*) '*NODE,NSET=NODOS_PIELYHUESO'
DO I=1,CONT_NPyH
WRITE(101,12) INT(NCOMP(I,1)),',',NCOMP(I,2),',',
1NCOMP(I,3),',',NCOMP(I,4)
ENDDO
CLOSE(unit=101,status='keep')
12 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
142
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 12 %
C % "Obtener_modelo_plano.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este código permite seleccionar una de las caras de los
C elementos hexaédricos que forman el modelo 2D recién exportado.
C Formando, por tanto, un modelo 2D real con elementos planos de
C forma cuadrada.
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,EXITO,CONT
INTEGER*4 CONT_NODOSP,CONT_ELHUESO,CONT_ELPIEL,CONT_NODOSDEF,
1CONT_EHDEF,CONT_EPDEF
REAL*4 NODOSP_MAX(MAX,4),NODOSP[ALLOCATABLE](:,:),
1NODOSDEF_MAX[ALLOCATABLE](:,:),NODOSDEF[ALLOCATABLE](:,:)
INTEGER*4 ELHUESO_MAX(MAX,5),ELHUESO[ALLOCATABLE](:,:),
1ELPIEL_MAX(MAX,5),ELPIEL[ALLOCATABLE](:,:),
2AUX_ELHUESO[ALLOCATABLE](:,:),AUX_ELPIEL[ALLOCATABLE](:,:),
3ELHUESODEF[ALLOCATABLE](:,:),ELPIELDEF[ALLOCATABLE](:,:),
4INI_HUESO,INI_PIEL
C LEE LOS NODOS DEL ARCHIVO NODOSP.txt Y LOS GUARDA EN LA VARIABLE
C CON EL MISMO NOMBRE
OPEN (unit=101,file='C:\FORTRAN\NODOSP.txt',status='unknown')
CONT_NODOSP=0
DO I=1,MAX
READ(101,*,END=16) (NODOSP_MAX(I,J),J=1,4)
CONT_NODOSP=CONT_NODOSP+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOSP,
1'FILAS NODOSP'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOSP(CONT_NODOSP,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOSP
NODOSP(I,1:4)=NODOSP_MAX(I,1:4)
ENDDO
C LEE LOS ELEMENTOS TIPO PLANOS DEL ARCHIVO ELHUESO.txt Y LOS
GUARDA EN LA VARIABLE
C CON EL MISMO NOMBRE
OPEN (unit=101,file='C:\FORTRAN\ELHUESO.txt',status='unknown')
CONT_ELHUESO=0
DO I=1,MAX
READ(101,*,END=17) (ELHUESO_MAX(I,J),J=1,5)
CONT_ELHUESO=CONT_ELHUESO+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_ELHUESO,
1'FILAS ELHUESO'
Anexo III – Rutinas para obtener los modelos de elementos finitos
143
CLOSE(unit=101,status='keep')
ALLOCATE (ELHUESO(CONT_ELHUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ELHUESO
ELHUESO(I,1:5)=ELHUESO_MAX(I,1:5)
ENDDO
C LEE LOS ELEMENTOS TIPO PLANOS DEL ARCHIVO ELPIEL.txt Y LOS
GUARDA EN LA VARIABLE
C CON EL MISMO NOMBRE
OPEN (unit=101,file='C:\FORTRAN\ELPIEL.txt',status='unknown')
CONT_ELPIEL=0
DO I=1,MAX
READ(101,*,END=18) (ELPIEL_MAX(I,J),J=1,5)
CONT_ELPIEL=CONT_ELPIEL+1
ENDDO
18 WRITE(*,*) 'Terminada lectura de nodos',CONT_ELPIEL,
1'FILAS ELPIEL'
CLOSE(unit=101,status='keep')
ALLOCATE (ELPIEL(CONT_ELPIEL,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ELPIEL
ELPIEL(I,1:5)=ELPIEL_MAX(I,1:5)
ENDDO
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
C ALMACENA MEMORIA PARA UNA VARIABLE DEL MISMO TAMAÑO QUE NODOSP,
C A LA QUE LLAMAREMOS NODOSDEF_MAX, AUNQUE LA CAPACIDAD DE ESTA NO
SERÁ
C COMPLETADA
ALLOCATE (NODOSDEF_MAX(CONT_NODOSP,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C COPIA LA DEFINICIÓN DE LOS NODOS QUE TENGAN EN SU PRIMERA
COMPONENTE EL
C VALOR DE 0.001 EN LA VARIABLE NODOSDEF_MAX.
CONT_NODOSDEF=0
DO I=1,CONT_NODOSP
IF(NODOSP(I,2).EQ.0.001)THEN
CONT_NODOSDEF=CONT_NODOSDEF+1
DO J=1,4
NODOSDEF_MAX(CONT_NODOSDEF,J)=NODOSP(I,J)
ENDDO
ENDIF
ENDDO
C ALMACENA MEMORIA PARA NODOSDEF Y SE ESCRIBE LA MISMA CON EL
CONTENIDO DE
Anexo III – Rutinas para obtener los modelos de elementos finitos
144
C NODOSDEF_MAX
ALLOCATE (NODOSDEF(CONT_NODOSDEF,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOSDEF
NODOSDEF(I,1:4)=NODOSDEF_MAX(I,1:4)
ENDDO
WRITE(*,*) 'PRUEBA1'
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
C SE DEFINE UNA VARIABLE AUXILIAR IDENTICA A "ELHUESO" PERO CON
UNA COLUMNA
C MÁS AL FINAL, PUESTA EN CERO. LA LLAMAREMOS "AUX_ELHUESO".
ALLOCATE (AUX_ELHUESO(CONT_ELHUESO,6),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ELHUESO
AUX_ELHUESO(I,1:5)=ELHUESO(I,1:5)
AUX_ELHUESO(I,6)=0
ENDDO
C ENTRE LOS ELEMENTOS PLANOS DEL HUESO SE SELECCIONAN AQUELLOS QUE
ESTAN
C FORMADOS POR CUATRO NODOS DE LOS DEFINIDOS EN NODOSDEF. LA
SELECCIÓN SE
C HARÁ HACIENDO "1" LA SEXTA COLUMNA DE "AUX_ELHUESO"
DO I=1,CONT_ELHUESO
CONT=0
DO J=2,5
DO K=1,CONT_NODOSDEF
IF(ELHUESO(I,J).EQ.INT(NODOSDEF(K,1)))THEN
CONT=CONT+1
ENDIF
ENDDO
IF(CONT.EQ.4)THEN
AUX_ELHUESO(I,6)=1
ENDIF
ENDDO
ENDDO
C ALMACENA MEMORIA PARA LA VARIABLE DEFINITIVA QUE TIENE LOS
ELEMENTOS
C PLANOS DEL GRUPO HUESO. "ELHUESODEF".
ALLOCATE (ELHUESODEF(40000,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C BUSCA LOS ELEMENTOS DE "AUX_ELHUESO" QUE TIENEN UN "1" EN SU
SEXTA
C COLUMNA. ESTOS SON ESCRITOS A PARTIR DEL ELEMENTO 50001, EN LA
VARIABLE
C QUE CONTENDRÁ LOS ELEMENTOS PLANOS DEFINITIVOS DEL GRUPO HUESO.
INI_HUESO=50000
CONT_EHDEF=0
DO I=1,CONT_ELHUESO
IF(AUX_ELHUESO(I,6).EQ.1)THEN
Anexo III – Rutinas para obtener los modelos de elementos finitos
145
INI_HUESO=INI_HUESO+1
CONT_EHDEF=CONT_EHDEF+1
ELHUESODEF(CONT_EHDEF,1)=INI_HUESO
ELHUESODEF(CONT_EHDEF,2:5)=AUX_ELHUESO(I,2:5)
ENDIF
ENDDO
WRITE(*,*) 'PRUEBA2'
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
C SE DEFINE UNA VARIABLE AUXILIAR IDENTICA A "ELPIEL" PERO CON UNA
COLUMNA
C MÁS AL FINAL, PUESTA EN CERO. LA LLAMAREMOS "AUX_ELPIEL".
ALLOCATE (AUX_ELPIEL(CONT_ELPIEL,6),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ELPIEL
AUX_ELPIEL(I,1:5)=ELPIEL(I,1:5)
AUX_ELPIEL(I,6)=0
ENDDO
C ENTRE LOS ELEMENTOS PLANOS DE LA VBLE PIEL SE SELECCIONAN
AQUELLOS QUE ESTAN
C FORMADOS POR CUATRO NODOS DE LOS DEFINIDOS EN NODOSDEF. LA
SELECCIÓN SE
C HARÁ HACIENDO "1" LA SEXTA COLUMNA DE "AUX_ELPIEL"
DO I=1,CONT_ELPIEL
CONT=0
DO J=2,5
DO K=1,CONT_NODOSDEF
IF(ELPIEL(I,J).EQ.INT(NODOSDEF(K,1)))THEN
CONT=CONT+1
ENDIF
ENDDO
IF(CONT.EQ.4)THEN
AUX_ELPIEL(I,6)=1
ENDIF
ENDDO
ENDDO
C ALMACENA MEMORIA PARA LA VARIABLE DEFINITIVA QUE TIENE LOS
ELEMENTOS
C PLANOS DEL GRUPO PIEL. "ELPIELDEF".
ALLOCATE (ELPIELDEF(40000,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C BUSCA LOS ELEMENTOS DE "AUX_ELPIEL" QUE TIENEN UN "1" EN SU
SEXTA
C COLUMNA. ESTOS SON ESCRITOS A PARTIR DEL ELEMENTO 1, EN LA
VARIABLE
C QUE CONTENDRÁ LOS ELEMENTOS PLANOS DEFINITIVOS DEL GRUPO PIEL.
INI_PIEL=0
CONT_EPDEF=0
DO I=1,CONT_ELPIEL
IF(AUX_ELPIEL(I,6).EQ.1)THEN
INI_PIEL=INI_PIEL+1
CONT_EPDEF=CONT_EPDEF+1
Anexo III – Rutinas para obtener los modelos de elementos finitos
146
ELPIELDEF(CONT_EPDEF,1)=INI_PIEL
ELPIELDEF(CONT_EPDEF,2:5)=AUX_ELPIEL(I,2:5)
ENDIF
ENDDO
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
C ESCRIBE EL MODELO SAGITAL FORMADO POR ELEMENTOS PLANOS DE 4
NODOS
OPEN (unit=101,file='MODELO_SAGITAL.inp',status='unknown')
WRITE(101,*) '*NODE,NSET=NODOS'
DO I=1,CONT_NODOSDEF
WRITE(101,20)
INT(NODOSDEF(I,1)),',',NODOSDEF(I,2),',',NODOSDEF(I,3),
1 ',',NODOSDEF(I,4)
ENDDO
WRITE(101,*) '*ELEMENT,TYPE=S4,ELSET=PIEL'
DO I=1,CONT_EPDEF
WRITE(101,21)
ELPIELDEF(I,1),',',ELPIELDEF(I,2),',',ELPIELDEF(I,3),
1 ',',ELPIELDEF(I,4),',',ELPIELDEF(I,5)
ENDDO
WRITE(101,*) '*ELEMENT,TYPE=S4,ELSET=HUESO'
DO I=1,CONT_EHDEF
WRITE(101,21)
ELHUESODEF(I,1),',',ELHUESODEF(I,2),',',ELHUESODEF(I,3),
1 ',',ELHUESODEF(I,4),',',ELHUESODEF(I,5)
ENDDO
CLOSE(unit=101,status='keep')
20 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
21 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
147
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 12 %
C % "Separar_comisura2D.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Esta rutina crea la comisura del modelo bidimensional de eltos
C planos.
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,M,AUX,EXITO,CONT_NTODO,INICIODEFINICION,AUX2
REAL*4 NTODO_MAX(MAX,4),NTODO[ALLOCATABLE](:,:),
1DEFCOMUNES(10000,4),NDUPL(10000,4)
INTEGER*4 CONT_NODOSINF,NODOSINF_MAX(MAX,16),
1NODOSINF[ALLOCATABLE](:,:),
2CONT_NODOSUP,NODOSUP_MAX(MAX,16),NODOSUP[ALLOCATABLE](:,:),
3CONT_LABINF,LABINF_MAX(MAX,16),LABINF[ALLOCATABLE](:,:),
4CONT_LABSUP,LABSUP_MAX(MAX,16),LABSUP[ALLOCATABLE](:,:),
5CONT_ETODO,ETODO_MAX(MAX,5),ETODO[ALLOCATABLE](:,:),
6CONT_HUESO,HUESO_MAX(MAX,5),HUESO[ALLOCATABLE](:,:),
7ETODOMOD[ALLOCATABLE](:,:),
8NCOMUN(10000,1)
C LEE LOS NODOS DEL ARCHIVO NODOSINF.txt Y LOS GUARDA EN LA
C VARIABLE "NODOSINF".
OPEN (unit=101,file='C:\FORTRAN\NODOSINF.txt',status='unknown')
CONT_NODOSINF=0
DO I=1,MAX
READ(101,*,END=16) (NODOSINF_MAX(I,J),J=1,16)
CONT_NODOSINF=CONT_NODOSINF+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOSINF,
1'FILAS NODOSINF'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOSINF(CONT_NODOSINF,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOSINF
NODOSINF(I,1:16)=NODOSINF_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NODOSUP.txt Y LOS GUARDA EN LA
C VARIABLE "NODOSUP".
OPEN (unit=101,file='C:\FORTRAN\NODOSUP.txt',status='unknown')
CONT_NODOSUP=0
DO I=1,MAX
READ(101,*,END=17) (NODOSUP_MAX(I,J),J=1,16)
CONT_NODOSUP=CONT_NODOSUP+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOSUP,
1'FILAS NODOSUP'
CLOSE(unit=101,status='keep')
Anexo III – Rutinas para obtener los modelos de elementos finitos
148
ALLOCATE (NODOSUP(CONT_NODOSUP,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOSUP
NODOSUP(I,1:16)=NODOSUP_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NTODO.txt Y LOS GUARDA EN LA
C VARIABLE "NTODO".
OPEN (unit=101,file='C:\FORTRAN\NTODO.txt',status='unknown')
CONT_NTODO=0
DO I=1,MAX
READ(101,*,END=18) (NTODO_MAX(I,J),J=1,4)
CONT_NTODO=CONT_NTODO+1
ENDDO
18 WRITE(*,*) 'Terminada lectura de nodos',CONT_NTODO,'FILAS NTODO'
CLOSE(unit=101,status='keep')
ALLOCATE (NTODO(CONT_NTODO,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NTODO
NTODO(I,1:4)=NTODO_MAX(I,1:4)
ENDDO
C LEE EL GRUPO DE ELEMENTOS DEL LABIO SUPERIOR DEL ARCHIVO
C LABSUP.txt Y LOS GUARDA EN LA VARIABLE "LABSUP" ESTE GRUPO TIENE
C LOS ELEMENTOS DEL LABIO SUPERIOR HACIA ARRIBA
OPEN (unit=101,file='C:\FORTRAN\LABSUP.txt',status='unknown')
CONT_LABSUP=0
DO I=1,MAX
READ(101,*,END=19) (LABSUP_MAX(I,J),J=1,16)
CONT_LABSUP=CONT_LABSUP+1
ENDDO
19 WRITE(*,*) 'Terminada lectura de nodos',CONT_LABSUP,'FILAS
LABSUP'
CLOSE(unit=101,status='keep')
ALLOCATE (LABSUP(CONT_LABSUP,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_LABSUP
LABSUP(I,1:16)=LABSUP_MAX(I,1:16)
ENDDO
C LEE EL GRUPO DE ELEMENTOS DEL LABIO INFERIOR DEL ARCHIVO
C LABINF.txt Y LOS GUARDA EN LA VARIABLE "LABINF" ESTE GRUPO TIENE
C LOS ELEMENTOS DEL LABIO INFERIOR HACIA ABAJO
OPEN (unit=101,file='C:\FORTRAN\LABINF.txt',status='unknown')
CONT_LABINF=0
DO I=1,MAX
READ(101,*,END=20) (LABINF_MAX(I,J),J=1,16)
Anexo III – Rutinas para obtener los modelos de elementos finitos
149
CONT_LABINF=CONT_LABINF+1
ENDDO
20 WRITE(*,*) 'Terminada lectura de nodos',CONT_LABINF,'FILAS
LABINF'
CLOSE(unit=101,status='keep')
ALLOCATE (LABINF(CONT_LABINF,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_LABINF
LABINF(I,1:16)=LABINF_MAX(I,1:16)
ENDDO
C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO ETODO.txt
C Y LOS ALMACENA EN LA VARIABLE "ETODO"
C SE ASIGNA DIMENSIONES A LA VARIABLE "ETODOMOD"
OPEN (unit=101,file='C:\FORTRAN\ETODO.txt',status='unknown')
CONT_ETODO=0
DO I=1,MAX
READ(101,*,END=21) (ETODO_MAX(I,J),J=1,5)
CONT_ETODO=CONT_ETODO+1
ENDDO
21 WRITE(*,*) 'Terminada lectura de nodos',CONT_ETODO,'FILAS ETODO'
CLOSE(unit=101,status='keep')
ALLOCATE (ETODO(CONT_ETODO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ETODO
ETODO(I,1:5)=ETODO_MAX(I,1:5)
ENDDO
ALLOCATE (ETODOMOD(CONT_ETODO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO HUESO.txt
C Y LOS ALMACENA EN LA VARIABLE "HUESO"
OPEN (unit=101,file='C:\FORTRAN\HUESO.txt',status='unknown')
CONT_HUESO=0
DO I=1,MAX
READ(101,*,END=22) (HUESO_MAX(I,J),J=1,5)
CONT_HUESO=CONT_HUESO+1
ENDDO
22 WRITE(*,*) 'Terminada lectura de nodos',CONT_HUESO,'FILAS HUESO'
CLOSE(unit=101,status='keep')
ALLOCATE (HUESO(CONT_HUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
HUESO(I,1:5)=HUESO_MAX(I,1:5)
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
150
C ALMACENA EN UN VECTOR COLUMNA (VBLE "NCOMUN") TODOS LOS
C NODOS COMUNES A NODOSINF Y NODOSUP
AUX=0
DO I=1,CONT_NODOSUP
DO J=1,16
IF(NODOSUP(I,J).NE.0.0)THEN
DO K=1,CONT_NODOSINF
DO L=1,16
IF(NODOSUP(I,J).EQ.NODOSINF(K,L))THEN
AUX=AUX+1
NCOMUN(AUX,1)=NODOSUP(I,J)
EXIT
ENDIF
ENDDO
ENDDO
ENDIF
ENDDO
ENDDO
C SELECCIONA LOS NODOS DEL VECTOR NCOMUN, DE ENTRE LA DEFINICION
C DE TODOS LOS NODOS DE LA VARIABLE (NTODO)
C PARA OBTENER LA DEFINICION DE NODOS COMUNES ALMACENANDOLA EN
C "DEFCOMUNES"
DO I=1,AUX
DO J=1,CONT_NTODO
IF(NCOMUN(I,1).EQ.INT(NTODO(J,1)))THEN
DO K=1,4
DEFCOMUNES(I,K)=NTODO(J,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C DEFINE EL NUMERO DE NODO A PARTIR DEL CUAL SE COMIENZA LA
DUPLICACIÓN
INICIODEFINICION=100000
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEFCOMUNES", ALMACENANDOSE
LOS
C DUPLICADOS EN LA VARIABLE "NDUPL"
AUX2=INICIODEFINICION+1
DO I=1,AUX
NDUPL(I,1)=AUX2
AUX2=AUX2+1
ENDDO
DO I=1,AUX
DO K=2,4
NDUPL(I,K)=DEFCOMUNES(I,K)
ENDDO
ENDDO
C COPIA DE "ETODO" EN LA VBLE "ETODOMOD"
DO I=1,CONT_ETODO
DO J=1,5
ETODOMOD(I,J)=ETODO(I,J)
Anexo III – Rutinas para obtener los modelos de elementos finitos
151
ENDDO
ENDDO
C LECTURA ELTO A ELTO DEL GRUPO "LABINF", LEYENDO DEFINICIÓN EN
"ETODO",
C SE BUSCAN DE ENTRE LOS NODOS QUE DEFINEN ESTOS ELEMENTOS
C IGUALES A LOS DE NCOMUN.
C CDO SE ENCUENTRA SE VA ACTUALIZANDO LA VBLE "ETODOMOD" CON LOS
NODOS
C DUPLICADOS
DO I=1,CONT_LABINF
DO J=1,16
IF(LABINF(I,J).NE.0.0)THEN
DO K=1,CONT_ETODO
IF(LABINF(I,J).EQ.ETODOMOD(K,1))THEN
DO L=1,AUX
IF(NCOMUN(L,1).EQ.ETODOMOD(K,2))THEN
ETODOMOD(K,2)=INT(NDUPL(L,1))
ENDIF
IF(NCOMUN(L,1).EQ.ETODOMOD(K,3))THEN
ETODOMOD(K,3)=INT(NDUPL(L,1))
ENDIF
IF(NCOMUN(L,1).EQ.ETODOMOD(K,4))THEN
ETODOMOD(K,4)=INT(NDUPL(L,1))
ENDIF
IF(NCOMUN(L,1).EQ.ETODOMOD(K,5))THEN
ETODOMOD(K,5)=INT(NDUPL(L,1))
ENDIF
ENDDO
ENDIF
ENDDO
ENDIF
ENDDO
ENDDO
C ESCRIBE EL ARCHIVO .inp RESULTANTE CON LOS LABIOS SEPARADOS.
OPEN (unit=101,file='2D_LABIOS_SEPARADOS.inp',status='unknown')
WRITE(101,*) '*NODE,NSET=NODOS'
DO I=1,CONT_NTODO
WRITE(101,27)
INT(NTODO(I,1)),',',NTODO(I,2),',',NTODO(I,3),
1 ',',NTODO(I,4)
ENDDO
DO I=1,AUX
WRITE(101,27)
INT(NDUPL(I,1)),',',NDUPL(I,2),',',NDUPL(I,3),
1 ',',NDUPL(I,4)
ENDDO
WRITE(101,*) '*ELEMENT,TYPE=CPE4H,ELSET=PIEL'
Anexo III – Rutinas para obtener los modelos de elementos finitos
152
DO I=1,CONT_ETODO
WRITE(101,28)
ETODOMOD(I,1),',',ETODOMOD(I,2),',',ETODOMOD(I,3),
1 ',',ETODOMOD(I,4),',',ETODOMOD(I,5)
ENDDO
WRITE(101,*) '*ELEMENT,TYPE=S4,ELSET=HUESO'
DO I=1,CONT_HUESO
WRITE(101,28) HUESO(I,1),',',HUESO(I,2),',',HUESO(I,3),
1 ',',HUESO(I,4),',',HUESO(I,5)
ENDDO
CLOSE(unit=101,status='keep')
27 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
28 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
C ESCRIBE EL VECTOR "NCOMUN", CON LOS NODOS QUE FINALMENTE SE HAN
C ASOCIADO A ELEMENTOS DEL LABIO SUPERIOR
OPEN (unit=101,file='NCOMISURASUP.txt',status='unknown')
DO I=1,AUX
WRITE(101,29) NCOMUN(I,1)
ENDDO
CLOSE(unit=101,status='keep')
29 FORMAT(I8)
C ESCRIBE EL GRUPO DE NODOS DUPLICADOS, DE NODOS ASOCIADO A
C ELEMENTOS DEL LABIO INFERIOR
OPEN (unit=101,file='NCOMISURAINF.txt',status='unknown')
DO I=1,AUX
WRITE(101,29) INT(NDUPL(I,1))
ENDDO
CLOSE(unit=101,status='keep')
END
Anexo III – Rutinas para obtener los modelos de elementos finitos
153
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 13 %
C % "Comunes_y_duplica2D.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C Este programa crea el vestíbulo del modelo 2D de elementos
C planos, una vez se ha realizado sobre este la separación de los
C labios.
PROGRAM LECTURA
INTEGER*4,PARAMETER:: MAX=1000000
INTEGER*4 I,J,K,L,AUX,AUX2,AUX3,EXITO,CONT_NODOS2,
1INICIODEFINICION
REAL*4 NODOS2_MAX(MAX,4),NODOS2[ALLOCATABLE](:,:),
1DEF_NVEST[ALLOCATABLE](:,:),NDUPL[ALLOCATABLE](:,:)
INTEGER*4 CONT_NPIEL,NPIEL_MAX(MAX,16),NPIEL[ALLOCATABLE](:,:),
1CONT_NHUESO,NHUESO_MAX(MAX,16),NHUESO[ALLOCATABLE](:,:),
2CONT_HUESO,HUESO_MAX(MAX,5),HUESO[ALLOCATABLE](:,:),
3CONT_NAUX_VEST,NAUX_VEST_MAX(MAX,16),NAUX_VEST[ALLOCATABLE](:,:
),
4CONT_PIEL,PIEL_MAX(MAX,5),PIEL[ALLOCATABLE](:,:),
5COMUNES(100000,1),
6NVEST(100000,1),
7HUESO2[ALLOCATABLE](:,:)
C LEE LOS NODOS DEL ARCHIVO NAUX_VEST.txt Y LOS GUARDA EN LA
C VARIABLE "NAUX_VEST".
OPEN (unit=101,file='C:\FORTRAN\NAUX_VEST.txt',status='unknown')
CONT_NAUX_VEST=0
DO I=1,MAX
READ(101,*,END=14) (NAUX_VEST_MAX(I,J),J=1,16)
CONT_NAUX_VEST=CONT_NAUX_VEST+1
ENDDO
14 WRITE(*,*) 'Terminada lectura de nodos',CONT_NAUX_VEST,
2'FILAS NAUX_VEST'
CLOSE(unit=101,status='keep')
ALLOCATE (NAUX_VEST(CONT_NAUX_VEST,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NAUX_VEST
NAUX_VEST(I,1:16)=NAUX_VEST_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NPIEL.txt Y LOS GUARDA EN LA
C VARIABLE "NPIEL".
OPEN (unit=101,file='C:\FORTRAN\NPIEL.txt',status='unknown')
CONT_NPIEL=0
DO I=1,MAX
READ(101,*,END=15) (NPIEL_MAX(I,J),J=1,16)
CONT_NPIEL=CONT_NPIEL+1
ENDDO
15 WRITE(*,*) 'Terminada lectura de nodos',CONT_NPIEL,'FILAS NPIEL'
CLOSE(unit=101,status='keep')
ALLOCATE (NPIEL(CONT_NPIEL,16),STAT=EXITO)
Anexo III – Rutinas para obtener los modelos de elementos finitos
154
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NPIEL
NPIEL(I,1:16)=NPIEL_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NHUESO.txt Y LOS GUARDA EN LA
C VARIABLE "NHUESO".
OPEN (unit=101,file='C:\FORTRAN\NHUESO.txt',status='unknown')
CONT_NHUESO=0
DO I=1,MAX
READ(101,*,END=16) (NHUESO_MAX(I,J),J=1,16)
CONT_NHUESO=CONT_NHUESO+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NHUESO,'FILAS
NHUESO'
CLOSE(unit=101,status='keep')
ALLOCATE (NHUESO(CONT_NHUESO,16),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NHUESO
NHUESO(I,1:16)=NHUESO_MAX(I,1:16)
ENDDO
C LEE LOS NODOS DEL ARCHIVO NODOS2.txt Y LOS GUARDA EN LA
C VARIABLE "NODOS2".
OPEN (unit=101,file='C:\FORTRAN\NODOS2.txt',status='unknown')
CONT_NODOS2=0
DO I=1,MAX
READ(101,*,END=17) (NODOS2_MAX(I,J),J=1,4)
CONT_NODOS2=CONT_NODOS2+1
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS2,'FILAS
NODOS2'
CLOSE(unit=101,status='keep')
ALLOCATE (NODOS2(CONT_NODOS2,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOS2
NODOS2(I,1:4)=NODOS2_MAX(I,1:4)
ENDDO
C LEE EL GRUPO DE ELEMENTOS DEL HUESO DEL ARCHIVO
C HUESO.txt Y LOS GUARDA EN LA VARIABLE "HUESO" Y
C SE COPIA HUESO EN HUESO2.
OPEN (unit=101,file='C:\FORTRAN\HUESO.txt',status='unknown')
CONT_HUESO=0
DO I=1,MAX
READ(101,*,END=18) (HUESO_MAX(I,J),J=1,5)
CONT_HUESO=CONT_HUESO+1
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
155
18 WRITE(*,*) 'Terminada lectura de nodos',CONT_HUESO,'FILAS HUESO'
CLOSE(unit=101,status='keep')
ALLOCATE (HUESO(CONT_HUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
HUESO(I,1:5)=HUESO_MAX(I,1:5)
ENDDO
ALLOCATE (HUESO2(CONT_HUESO,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
HUESO2(I,1:5)=HUESO_MAX(I,1:5)
ENDDO
C LEE EL GRUPO DE ELEMENTOS DE LA PIEL DEL ARCHIVO
C PIEL.txt Y LOS GUARDA EN LA VARIABLE "PIEL"
OPEN (unit=101,file='C:\FORTRAN\PIEL.txt',status='unknown')
CONT_PIEL=0
DO I=1,MAX
READ(101,*,END=19) (PIEL_MAX(I,J),J=1,5)
CONT_PIEL=CONT_PIEL+1
ENDDO
19 WRITE(*,*) 'Terminada lectura de nodos',CONT_PIEL,'FILAS PIEL'
CLOSE(unit=101,status='keep')
ALLOCATE (PIEL(CONT_PIEL,5),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_PIEL
PIEL(I,1:5)=PIEL_MAX(I,1:5)
ENDDO
C ALMACENA EN UN VECTOR COLUMNA TODOS LOS NODOS COMUNES A NPIEL
C Y NHUESO
AUX=0
DO I=1,CONT_NPIEL
DO J=1,16
IF(NPIEL(I,J).NE.0.0)THEN
DO K=1,CONT_NHUESO
DO L=1,16
IF(NPIEL(I,J).EQ.NHUESO(K,L))THEN
AUX=AUX+1
COMUNES(AUX,1)=NPIEL(I,J)
EXIT
ENDIF
ENDDO
ENDDO
ENDIF
ENDDO
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
156
C SELECCIONA LOS NODOS DEL VECTOR COMUNES, DENTRO DEL GRUPO
C "NAUX_VEST". PARA OBTENER LOS NODOS COMUNES ENTRE PIEL Y HUESO
C DEL VESTIBULO: "NVEST". Y SE GUARDA MEMORIA PARA DEF_NVEST Y
NDUPL.
AUX2=0
DO I=1,AUX
DO J=1,CONT_NAUX_VEST
DO K=1,16
IF(COMUNES(I,1).EQ.NAUX_VEST(J,K))THEN
AUX2=AUX2+1
NVEST(AUX2,1)=NAUX_VEST(J,K)
EXIT
ENDIF
ENDDO
ENDDO
ENDDO
ALLOCATE (DEF_NVEST(AUX2,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
ALLOCATE (NDUPL(AUX2,4),STAT=EXITO)
IF (EXITO.NE.0) THEN
PRINT*,"ERROR"
ENDIF
C SELECCIONA LOS NODOS DEL VECTOR "NVEST", DE ENTRE LA DEFINICIÓN
C DE TODOS LOS NODOS EN "NODOS2". PARA OBTENER LA DEFINICIÓN DE
C LOS NODOS COMUNES ENTRE PIEL Y HUESO DEL VESTIBULO
DO I=1,AUX2
DO J=1,CONT_NODOS2
IF(NVEST(I,1).EQ.INT(NODOS2(J,1)))THEN
DO K=1,4
DEF_NVEST(I,K)=NODOS2(J,K)
ENDDO
EXIT
ENDIF
ENDDO
ENDDO
C DEFINE EL NUMERO DE NODO A PARTIR DEL CUAL SE COMIENZA LA
DUPLICACIÓN
INICIODEFINICION=200000
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEF_NVEST", ALMACENANDOSE
LOS
C DUPLICADOS EN LA VARIABLE "NDUPL"
AUX3=INICIODEFINICION+1
DO I=1,AUX2
NDUPL(I,1)=AUX3
AUX3=AUX3+1
ENDDO
DO I=1,AUX2
DO K=2,4
NDUPL(I,K)=DEF_NVEST(I,K)
ENDDO
ENDDO
Anexo III – Rutinas para obtener los modelos de elementos finitos
157
C LECTURA ELTO A ELTO DE "HUESO"
C SE BUSCAN DE ENTRE LOS NODOS QUE DEFINEN ESTOS ELEMENTOS
C IGUALES A LOS DE "NVEST"
C CDO SE ENCUENTRA SE VA ACTUALIZANDO LA VBLE "HUESO2" CON LOS
NODOS
C DUPLICADOS "NDUPL"
C
DO I=1,CONT_HUESO
DO K=1,AUX2
IF(NVEST(K,1).EQ.HUESO(I,2))THEN
HUESO2(I,2)=INT(NDUPL(K,1))
ENDIF
IF(NVEST(K,1).EQ.HUESO(I,3))THEN
HUESO2(I,3)=INT(NDUPL(K,1))
ENDIF
IF(NVEST(K,1).EQ.HUESO(I,4))THEN
HUESO2(I,4)=INT(NDUPL(K,1))
ENDIF
IF(NVEST(K,1).EQ.HUESO(I,5))THEN
HUESO2(I,5)=INT(NDUPL(K,1))
ENDIF
ENDDO
ENDDO
C ESCRIBE EL .INP RESULTANTE DE CREAR EL VESTIBULO
OPEN (unit=101,file='2D_CREA_VESTIBULO.inp',status='unknown')
WRITE(101,*) '*NODE,NSET=NODOS'
DO I=1,CONT_NODOS2
WRITE(101,27)
INT(NODOS2(I,1)),',',NODOS2(I,2),',',NODOS2(I,3),
1 ',',NODOS2(I,4)
ENDDO
DO I=1,AUX2
WRITE(101,27)
INT(NDUPL(I,1)),',',NDUPL(I,2),',',NDUPL(I,3),
1 ',',NDUPL(I,4)
ENDDO
WRITE(101,*) '*ELEMENT,TYPE=CPE4H,ELSET=PIEL'
DO I=1,CONT_PIEL
WRITE(101,28) PIEL(I,1),',',PIEL(I,2),',',PIEL(I,3),
1 ',',PIEL(I,4),',',PIEL(I,5)
ENDDO
WRITE(101,*) '*ELEMENT,TYPE=S4,ELSET=HUESO'
DO I=1,CONT_HUESO
WRITE(101,28) HUESO2(I,1),',',HUESO2(I,2),',',HUESO2(I,3),
1 ',',HUESO2(I,4),',',HUESO2(I,5)
ENDDO
CLOSE(unit=101,status='keep')
27 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
28 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
END
Recommended