Subrutinas para El Calculo de Los Elementos Finitos PDF

Anexo III – Rutinas para obtener los modelos de elementos finitos
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.
98
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'
ALLOCATE (NRB(FILAS,16),STAT=EXITO)
PRINT*,"ERROR"
99
ENDIF
DO I=1,FILAS
NRB(I,1:16)=NRB_MAX(I,1:16)
ENDDO
ALLOCATE (RN(FILAS*16,4),STAT=EXITO)
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'
ALLOCATE (PIEL(E_PIEL,5),STAT=EXITO)
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'
ALLOCATE (RB(FILASE,16),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
DO I=1,FILASE
RB(I,1:16)=RB_MAX(I,1:16)
ENDDO
ALLOCATE (RE(FILASE*16,5),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
C SELECCIONA LOS NODOS DEL GRUPO "NRB", DE ENTRE TODOS LA

C DEFINICIÓN DE TODOS LOS NODOS. PARA CONSEGUIR LA
100
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
11 FORMAT(I8,A1,F10.8,A1,F10.8,A1,F10.8)
12 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)
END
101
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 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'
ALLOCATE (G1(CONT_G1,16),STAT=EXITO)
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'
ALLOCATE (G2(CONT_G2,16),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_G2
G2(I,1:16)=G2_MAX(I,1:16)
ENDDO
102

C VARIABLE "NODOS".
N_NODOS=0
DO I=1,MAX
N_NODOS=N_NODOS+1
ENDDO
PRINT*,"ERROR"
ENDIF
DO I=1,N_NODOS
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
103
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
11 FORMAT(I8,A1,F10.8,A1,F10.8,A1,F10.8)
END
104
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 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'
ALLOCATE (NS(N_NODOS,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (PN(N_NODOS,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (DN(N_NODOS,3),STAT=EXITO)
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
105
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)
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)
106
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
12 FORMAT(I8,A1,I8,A1,I8,A1,F12.8)
END
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 4 %
107
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 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'
ALLOCATE (Mcc0(N_NODOS,16),STAT=EXITO)
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
11 FORMAT(I8,A1,I4,A1,I4,A1,F10.6)
END
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
108
C % Código 5 %
C % "geomdef.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C
C
PROGRAM LECTURA
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 VARIABLE "NODOS".
N_NODOS=0
DO I=1,MAX
N_NODOS=N_NODOS+1
ENDDO
PRINT*,"ERROR"
ENDIF
DO I=1,N_NODOS
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'
ALLOCATE (U(FILAS,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
DO I=1,FILAS
U(I,1:4)=U_MAX(I,1:4)
ENDDO
ALLOCATE (GEOMDEF(FILAS,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
109
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
11 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
110
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
END
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
111
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 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'
ALLOCATE (NLABSUP(CONT_NLABSUP,16),STAT=EXITO)
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'
ALLOCATE (NLABINF(CONT_NLABINF,16),STAT=EXITO)
112
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'
ALLOCATE (NTODO(CONT_NTODO,4),STAT=EXITO)
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'
ALLOCATE (LABINF(CONT_LABINF,16),STAT=EXITO)
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
113
20 WRITE(*,*) 'Terminada lectura de nodos',CONT_ETODO,'FILAS ETODO'

ALLOCATE (ETODO(CONT_ETODO,5),STAT=EXITO)
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)
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
114
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
ENDIF
ENDIF
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
115
OPEN (unit=101,file='NCOMUN.txt',status='unknown')
DO I=1,AUX
WRITE(101,21) NCOMUN(I,1)
ENDDO
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
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
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
END
116
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 7 %
C % "crear_shell.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
PROGRAM LECTURA
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'
ALLOCATE (ETODOMOD(CONT_ETODOMOD,5),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (ETODOAUX(CONT_ETODOMOD,7),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ETODOMOD
ETODOMOD(I,1:5)=ETODOMOD_MAX(I,1:5)
ENDDO
ETODOAUX(I,1:5)=ETODOMOD_MAX(I,1:5)
ENDDO
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))
117
CONT_NSLS=CONT_NSLS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NSLS,
1'FILAS NSLS'
ALLOCATE (NSLS(CONT_NSLS,1),STAT=EXITO)
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'
ALLOCATE (NSLI(CONT_NSLI,1),STAT=EXITO)
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
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)
PRINT*,"ERROR"
118
ENDIF
ALLOCATE (SH_LS(CONT_ESLS,4),STAT=EXITO)
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
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)
PRINT*,"ERROR"
ENDIF
ALLOCATE (SH_LI(CONT_ESLI,4),STAT=EXITO)
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
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
IF(ETODOAUX(I,7).EQ.1)THEN
ESLI(AUX5,1:5)=ETODOAUX(I,1:5)
AUX5=AUX5+1
ENDIF
ENDDO
119
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
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
21 FORMAT(I8,A1,I8,A1,I8,A1,I8)
END
120
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 8 %
C % "actmod_completo.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
PROGRAM LECTURA
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"
CONT_NODOS=0
DO I=1,MAX
CONT_NODOS=CONT_NODOS+1
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS,
1'FILAS NODOS'
ALLOCATE (NODOS(CONT_NODOS,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (NODOS2(CONT_NODOS,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOS
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"
CONT_NTODO=0
DO I=1,MAX
ENDDO
17 WRITE(*,*) 'Terminada lectura de nodos',CONT_NTODO,
1'FILAS NTODO'
121
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NTODO
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'
ALLOCATE (ETODOMOD(CONT_ETODOMOD,5),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
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"
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'
ALLOCATE (PIEL(CONT_PIEL,5),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (PIEL2(CONT_PIEL,5),STAT=EXITO)
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"
122
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
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
END
123
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 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'
ALLOCATE (NAUX_VEST(CONT_NAUX_VEST,16),STAT=EXITO)
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,
124
1'FILAS NPIEL'
ALLOCATE (NPIEL(CONT_NPIEL,16),STAT=EXITO)
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'
ALLOCATE (NHUESO(CONT_NHUESO,16),STAT=EXITO)
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'
ALLOCATE (NODOS2(CONT_NODOS2,4),STAT=EXITO)
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
125
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'
ALLOCATE (HUESO(CONT_HUESO,5),STAT=EXITO)
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)
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
126
ALLOCATE (DEF_NVEST(AUX2,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (NDUPL(AUX2,4),STAT=EXITO)
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
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEF_NVEST",

C ALMACENANDOSE LOS DUPLICADOS EN LA VARIABLE "NDUPL"
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
ENDIF
ENDIF
127
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
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
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
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
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
C ESCRIBE EL GRUPO DE NODOS DUPLICADOS: "GNDUPL"

OPEN (unit=101,file='GNDUPL.txt',status='unknown')
DO I=1,AUX2
ENDDO
END
128
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 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'
ALLOCATE (NPyH(CONT_NPyH,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
129
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
ENDDO
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
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
ENDDO
16 WRITE(*,*) 'Terminada lectura de nodos',CONT_PIEL,'FILAS PIEL'
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_PIEL
ENDDO
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
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)
130
CONT_NODOS_MAND=CONT_NODOS_MAND+1
ENDDO
19 WRITE(*,*) 'Terminada lectura de nodos',CONT_NODOS_MAND,
1'FILAS NODOS_MAND'
ALLOCATE (NODOS_MAND(CONT_NODOS_MAND,16),STAT=EXITO)
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'
ALLOCATE (NODOS_MSYC(CONT_NODOS_MSYC,16),STAT=EXITO)
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'
ALLOCATE (MAXSUP_Y_CRANEO(CONT_MAXSUP_Y_CRANEO,16),STAT=EXITO)
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
131
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'
ALLOCATE (MANDIBULA(CONT_MANDIBULA,16),STAT=EXITO)
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)
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
132
CONT_DEFMSYC=CONT_DEFMSYC+1
DEF_MSYC(CONT_DEFMSYC,1)=HUESO(K,1)
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)
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 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)
PRINT*,"ERROR"
ENDIF
133
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)
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

DUPLICACIÓN
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEF_COMUNES",

ALMACENANDOSE LOS
C DUPLICADOS EN LA VARIABLE "DEF_DUPLICADOS"
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
ENDIF
134
ENDIF
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
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
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
END
135
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C % Código 11 %
C % "Movimiento_mandibula.for" %
C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C
C
PROGRAM LECTURA
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'
ALLOCATE (NPyH(CONT_NPyH,4),STAT=EXITO)
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)
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
136
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'
ALLOCATE (NODOS_MAND(CONT_NODOS_MAND,16),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
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 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)
PRINT*,"ERROR"
ENDIF
ALLOCATE (T(AUX,1),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
137
ALLOCATE (S(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (SP(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (SPMODULO(AUX,1),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (XP(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (YP(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (G(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (PL(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (DPL(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (DP(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (N(AUX,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
ALLOCATE (R(AUX,3),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
C
WRITE(*,*) 'Terminada definición nodos mandíbula e inicio def
1movimiento'
C
138
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
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)
139
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)
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))
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"
140
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
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
12 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
END
141
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 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'
ALLOCATE (NODOSP(CONT_NODOSP,4),STAT=EXITO)
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
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'
142
ALLOCATE (ELHUESO(CONT_ELHUESO,5),STAT=EXITO)
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
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'
ALLOCATE (ELPIEL(CONT_ELPIEL,5),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_ELPIEL
ELPIEL(I,1:5)=ELPIEL_MAX(I,1:5)
ENDDO
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)
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
143
C NODOSDEF_MAX
ALLOCATE (NODOSDEF(CONT_NODOSDEF,4),STAT=EXITO)
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NODOSDEF
NODOSDEF(I,1:4)=NODOSDEF_MAX(I,1:4)
ENDDO
WRITE(*,*) 'PRUEBA1'
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)
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)
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
144
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'
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)
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)
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
145
ELPIELDEF(CONT_EPDEF,1)=INI_PIEL
ELPIELDEF(CONT_EPDEF,2:5)=AUX_ELPIEL(I,2:5)
ENDIF
ENDDO
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
20 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
END
146
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 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](:,:),
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'
ALLOCATE (NODOSINF(CONT_NODOSINF,16),STAT=EXITO)
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'
147
ALLOCATE (NODOSUP(CONT_NODOSUP,16),STAT=EXITO)
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".
CONT_NTODO=0
DO I=1,MAX
ENDDO
18 WRITE(*,*) 'Terminada lectura de nodos',CONT_NTODO,'FILAS NTODO'
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_NTODO
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'
ALLOCATE (LABSUP(CONT_LABSUP,16),STAT=EXITO)
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)
148
CONT_LABINF=CONT_LABINF+1
ENDDO
20 WRITE(*,*) 'Terminada lectura de nodos',CONT_LABINF,'FILAS
LABINF'
ALLOCATE (LABINF(CONT_LABINF,16),STAT=EXITO)
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'
ALLOCATE (ETODO(CONT_ETODO,5),STAT=EXITO)
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)
PRINT*,"ERROR"
ENDIF
C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO HUESO.txt

C Y LOS ALMACENA EN LA VARIABLE "HUESO"
CONT_HUESO=0
DO I=1,MAX
ENDDO
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
ENDDO
149
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

DUPLICACIÓN
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEFCOMUNES", ALMACENANDOSE

LOS
C DUPLICADOS EN LA VARIABLE "NDUPL"
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)
150
ENDDO
ENDDO
C LECTURA ELTO A ELTO DEL GRUPO "LABINF", LEYENDO DEFINICIÓN EN

"ETODO",
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
ENDIF
ENDIF
ENDIF
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')
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)
1 ',',NDUPL(I,4)
ENDDO
WRITE(101,*) '*ELEMENT,TYPE=CPE4H,ELSET=PIEL'
151
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
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
27 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
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
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
ENDDO
END
152
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 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](:,:),
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'
ALLOCATE (NAUX_VEST(CONT_NAUX_VEST,16),STAT=EXITO)
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'
ALLOCATE (NPIEL(CONT_NPIEL,16),STAT=EXITO)
153
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'
ALLOCATE (NHUESO(CONT_NHUESO,16),STAT=EXITO)
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'
ALLOCATE (NODOS2(CONT_NODOS2,4),STAT=EXITO)
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.
CONT_HUESO=0
DO I=1,MAX
ENDDO
154

PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
ENDDO
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_HUESO
ENDDO
C LEE EL GRUPO DE ELEMENTOS DE LA PIEL DEL ARCHIVO

C PIEL.txt Y LOS GUARDA EN LA VARIABLE "PIEL"
CONT_PIEL=0
DO I=1,MAX
ENDDO
19 WRITE(*,*) 'Terminada lectura de nodos',CONT_PIEL,'FILAS PIEL'
PRINT*,"ERROR"
ENDIF
DO I=1,CONT_PIEL
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
155
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)
PRINT*,"ERROR"
ENDIF
ALLOCATE (NDUPL(AUX2,4),STAT=EXITO)
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

DUPLICACIÓN
C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEF_NVEST", ALMACENANDOSE

LOS
C DUPLICADOS EN LA VARIABLE "NDUPL"
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
156
C LECTURA ELTO A ELTO DE "HUESO"

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
ENDIF
ENDIF
ENDIF
ENDIF
ENDDO
ENDDO
C ESCRIBE EL .INP RESULTANTE DE CREAR EL VESTIBULO

OPEN (unit=101,file='2D_CREA_VESTIBULO.inp',status='unknown')
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)
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
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
27 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)
END
157

Subrutinas para El Calculo de Los Elementos Finitos PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Subrutinas para El Calculo de Los Elementos Finitos PDF

Cargado por

Copyright:

Formatos disponibles

Anexo III – Rutinas para obtener los modelos de elementos finitos

RUTINAS PARA OBTENER

Para utilizar cualquiera de ellos es necesario ubicar el archivo .for y los

C LEE LOS NODOS DEL ARCHIVO NODOS.txt Y LOS GUARDA EN LA

C LEE EL GRUPO DE NODOS DEL ARCHIVO nregboca.txt Y LOS GUARDA EN

C LEE LOS ELEMENTOS DEL ARCHIVO PIEL.txt Y LOS GUARDA EN LA

C LEE EL GRUPO DE ELEMENTOS DEL ARCHIVO regboca.txt Y LOS GUARDA

C SELECCIONA LOS NODOS DEL GRUPO "NRB", DE ENTRE TODOS LA

C DEFINICIÓN EXCLUSIVA DEL GRUPO DE NODOS "NRB",

C SELECCIONA LOS ELTOS DEL GRUPO "RB", DE ENTRE TODOS

C ESCRIBE EL ARCHIVO regBOCA.inp QUE TIENE EL MODELO DE BOCA

C LEE LOS NODOS DEL ARCHIVO G1.txt Y LOS GUARDA EN LA

C LEE LOS NODOS DEL ARCHIVO G2.txt Y LOS GUARDA EN LA

C LEE LOS NODOS DEL ARCHIVO NODOS.txt Y LOS GUARDA EN LA

C ALMACENA EN UN VECTOR COLUMNA TODOS LOS NODOS COMUNES A G1 Y G2

C SELECCIONA LOS NODOS DEL VECTOR "COMUNES", DE ENTRE TODOS

C ESCRIBE EL VECTOR COMUNES, CON LOS NODOS QUE PERTENECEN

C LEE LOS NODOS DE LA SUPERFICIE

C DEFINIR LOS NODOS QUE DEFINEN EL PLANO (ESCOGIDOS ENTRE LOS

C [CNP] CONTIENE LAS COORDENADAS DE LOS TRES NODOS QUE DEFINEN

C DEFINICIÓN DEL PLANO: SE DEFINIRAN 3 VBLES: (A,B,C) QUE SE

C COMPONENTE D: TERMINO INDEPENDIENTE

C PROYECCIÓN DE TODOS LOS NODOS DE LA SUPERFICIE SOBRE EL PLANO

C OBTENCIÓN DE LOS DESPLAZAMIENTOS A DAR PARA CADA NODO. RESTA

C ESCRIBE LOS PARAMETROS A,B,C,D DEL PLANO DEFINIDO

C ESCRIBE LOS DESPLAZAMIENTOS A DAR A CADA NODO, DIRECTAMENTE

C LEE EL GRUPO DE NODOS QUE SE TIENEN QUE ESCRIBIR COMO UN VECTOR

C ESCRIBE LOS NODOS CON LA CONDICIÓN DE CONTORNO DE

C LEE LOS NODOS DEL ARCHIVO NODOS.txt Y LOS GUARDA EN LA

C LEE LOS DESPLAZAMIENTOS NODALES DE U.txt Y LOS GUARDA EN LA

C SUMA LOS DESPLAZAMIENTOS 'U', A LA DEFINICIÓN DE NODOS DE LA

C LEE LOS NODOS DEL ARCHIVO NLABSUP.txt Y LOS GUARDA EN LA

C LEE LOS NODOS DEL ARCHIVO NLABINF.txt Y LOS GUARDA EN LA

C LEE LOS NODOS DEL ARCHIVO NTODO.txt Y LOS GUARDA EN LA

C LEE EL GRUPO DE ELEMENTOS DEL LABIO INFERIOR DEL ARCHIVO

C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO ETODO.txt

20 WRITE(*,*) 'Terminada lectura de nodos',CONT_ETODO,'FILAS ETODO'

C ALMACENA EN UN VECTOR COLUMNA (VBLE "NCOMUN") TODOS LOS

C SELECCIONA LOS NODOS DEL VECTOR NCOMUN, DE ENTRE LA DEFINICION

C DEFINE EL NUMERO DE NODO A PARTIR DEL CUAL SE COMIENZA LA

C SE DUPLICAN LOS NODOS DE LA VARIABLE "DEFCOMUNES",

C COPIA DE "ETODO" EN LA VBLE "ETODOMOD"

C LECTURA ELTO A ELTO DEL GRUPO "LABINF", LEYENDO DEFINICIÓN

C ESCRIBE EL VECTOR "NCOMUN", CON LOS NODOS QUE PERTENECEN A

C ESCRIBE LA DEFINICIÓN DE LOS NODOS DUPLICADOS: "NDUPL"

C ESCRIBE LA DEFINICIÓN DE LOS NODOS COMUNES

C ESCRIBE EL GRUPO DE NODOS DUPLICADOS: "GNDUPL"

C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO "ETODOMOD.txt"

C LEE LA DEFINICIÓN DEL ARCHIVO "NSUP_LABSUP.txt" Y

C LEE LA DEFINICIÓN DEL ARCHIVO "NSUP_LABINF.txt" Y

C EN LA 6º COLUMNA DE "ETODOAUX" SE PONE UN 1 SI EN

C ALMACENO MEMORIA PARA LA VBLE "ESLS" Y "SH_LS"

C EN LA 7º COLUMNA DE "ETODOAUX" SE PONE UN 1 SI EN

C ALMACENO MEMORIA PARA LA VBLE "ESLI" Y "SH_LI"

C ALMACENO LA DEFINICIÓN DE LOS ELEMENTOS QUE TIENEN UN 1 EN

C ALMACENO LA DEFINICIÓN DE LOS ELEMENTOS QUE TIENEN UN 1 EN

C SE CREAN LOS SHELL DEL LABIO SUPERIOR. DE LOS ELEMENTOS DE

C SE CREAN LOS SHELL DEL LABIO INFERIOR. DE LOS ELEMENTOS DE

C LEE LA CREACIÓN DE NODOS DEL ARCHIVO "NODOS.txt" Y LO GUARDA

C LEE LA CREACIÓN DE NODOS DEL ARCHIVO "NTODO.txt" Y LO GUARDA

C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO ETODOMOD.txt

C LEE LA DEFINICIÓN DE ELEMENTOS DEL ARCHIVO PIEL.txt

C ACTUALIZA LA VARIABLE "PIEL" CON "ETODOMOD", SE GUARDA EN

20 WRITE(,) 'Terminada lectura de nodos',CONT_ETODO,'FILAS ETODO'

15 WRITE(,) 'Terminada lectura de nodos',CONT_NODOS_MAND,