anexo iii – rutinas para obtener los modelos de elementos...

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.


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'


ALLOCATE (NRB(FILAS,16),STAT=EXITO)


PRINT*,"ERROR"


100

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


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


11 FORMAT(I8,A1,F10.8,A1,F10.8,A1,F10.8)

12 FORMAT(I8,A1,I8,A1,I8,A1,I8,A1,I8)

END


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 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


103


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


104


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


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 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


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)


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)


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


12 FORMAT(I8,A1,I8,A1,I8,A1,F12.8)

END

C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

C % Código 4 %


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 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 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


109

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


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


11 FORMAT(I8,A1,E16.8,A1,E16.8,A1,E16.8)


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


END

C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


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 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)



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'


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


114

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


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



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


116

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


117

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))


118

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"


119

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


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


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


121

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'




122


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"


123


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


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 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,


125

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


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'


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


127

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




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


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


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 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


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



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)


131

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


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'


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


133

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


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)


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



135


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


136

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


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'


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


138

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


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



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)


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)



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"


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


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


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 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'


143


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


144

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


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'



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


146

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


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 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'



148

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)


149

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


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


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)


151

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'


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


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


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 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)


154


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


155





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


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)


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


157

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

anexo iii – rutinas para obtener los modelos de elementos...

Documents