268 lines
6.5 KiB
Fortran
268 lines
6.5 KiB
Fortran
MODULE moduleMesh1DRead
|
|
USE moduleMesh
|
|
USE moduleMesh1D
|
|
USE moduleMesh1DBoundary
|
|
|
|
!TODO: make this abstract to allow different mesh formats
|
|
TYPE, EXTENDS(meshGeneric):: mesh1DGeneric
|
|
CONTAINS
|
|
PROCEDURE, PASS:: init => init1DMesh
|
|
PROCEDURE, PASS:: readMesh => readMesh1D
|
|
|
|
END TYPE
|
|
|
|
INTERFACE connected
|
|
MODULE PROCEDURE connectedVolVol, connectedVolEdge
|
|
|
|
END INTERFACE connected
|
|
|
|
CONTAINS
|
|
!Init 1D mesh
|
|
SUBROUTINE init1DMesh(self, meshFormat)
|
|
USE moduleMesh
|
|
USE moduleErrors
|
|
IMPLICIT NONE
|
|
|
|
CLASS(mesh1DGeneric), INTENT(out):: self
|
|
CHARACTER(:), ALLOCATABLE, INTENT(in):: meshFormat
|
|
|
|
SELECT CASE(meshFormat)
|
|
CASE ("gmsh")
|
|
self%printOutput => printOutputGmsh
|
|
self%printColl => printCollGmsh
|
|
self%printEM => printEMGmsh
|
|
|
|
CASE DEFAULT
|
|
CALL criticalError("Mesh type " // meshFormat // " not supported.", "init1D")
|
|
|
|
END SELECT
|
|
|
|
END SUBROUTINE init1DMesh
|
|
|
|
!Reads 1D mesh
|
|
SUBROUTINE readMesh1D(self, filename)
|
|
USE moduleBoundary
|
|
IMPLICIT NONE
|
|
|
|
CLASS(mesh1DGeneric), INTENT(inout):: self
|
|
CHARACTER(:), ALLOCATABLE, INTENT(in):: filename
|
|
REAL(8):: x
|
|
INTEGER:: p(1:2)
|
|
INTEGER:: e, et, n, eTemp, elemType, bt
|
|
INTEGER:: totalNumElem
|
|
INTEGER:: boundaryType
|
|
|
|
!Open file mesh
|
|
OPEN(10, FILE=TRIM(filename))
|
|
!Skip header
|
|
READ(10, *)
|
|
READ(10, *)
|
|
READ(10, *)
|
|
READ(10, *)
|
|
!Read number of nodes
|
|
READ(10, *) self%numNodes
|
|
!Allocate required matrices and vectors
|
|
ALLOCATE(self%nodes(1:self%numNodes))
|
|
ALLOCATE(self%K(1:self%numNodes, 1:self%numNodes))
|
|
ALLOCATE(self%IPIV(1:self%numNodes, 1:self%numNodes))
|
|
self%K = 0.D0
|
|
self%IPIV = 0
|
|
!Read nodes coordinates. Only relevant for x
|
|
DO e = 1, self%numNodes
|
|
READ(10, *) n, x
|
|
ALLOCATE(meshNode1D:: self%nodes(n)%obj)
|
|
CALL self%nodes(n)%obj%init(n, (/ x, 0.D0, 0.D0 /))
|
|
|
|
END DO
|
|
!Skips comments
|
|
READ(10, *)
|
|
READ(10, *)
|
|
!Reads the total number of elements (edges+vol)
|
|
READ(10, *) totalNumElem
|
|
self%numEdges = 0
|
|
DO e = 1, totalNumElem
|
|
READ(10, *) eTemp, elemType
|
|
IF (elemType == 15) THEN !15 is physical node in GMSH
|
|
self%numEdges = e
|
|
|
|
END IF
|
|
|
|
END DO
|
|
|
|
!Substract the number of edges to the total number of elements
|
|
!to obtain the number of volume elements
|
|
self%numVols = totalNumelem - self%numEdges
|
|
!Allocates arrays
|
|
ALLOCATE(self%edges(1:self%numEdges))
|
|
ALLOCATE(self%vols(1:self%numVols))
|
|
|
|
!Go back to the beginning of reading elements
|
|
DO e = 1, totalNumelem
|
|
BACKSPACE(10)
|
|
|
|
END DO
|
|
|
|
!Reads edges
|
|
DO e = 1, self%numEdges
|
|
READ(10, *) n, elemType, eTemp, boundaryType, eTemp, p(1)
|
|
!Associate boundary condition
|
|
bt = getBoundaryId(boundaryType)
|
|
SELECT CASE(boundary(bt)%obj%boundaryType)
|
|
CASE ('reflection')
|
|
ALLOCATE(meshEdge1DRef:: self%edges(e)%obj)
|
|
|
|
CASE ('absorption')
|
|
ALLOCATE(meshEdge1DAbs:: self%edges(e)%obj)
|
|
|
|
END SELECT
|
|
|
|
CALL self%edges(e)%obj%init(n, p(1:1), bt, boundaryType)
|
|
|
|
END DO
|
|
|
|
!Read and initialize volumes
|
|
DO e = 1, self%numVols
|
|
READ(10, *) n, elemType, eTemp, eTemp, eTemp, p(1:2)
|
|
ALLOCATE(meshVol1DSegm:: self%vols(e)%obj)
|
|
CALL self%vols(e)%obj%init(n - self%numEdges, p(1:2))
|
|
|
|
END DO
|
|
|
|
CLOSE(10)
|
|
|
|
!Build connectivity between elements
|
|
DO e = 1, self%numVols
|
|
!Connectivity between volumes
|
|
DO et = 1, self%numVols
|
|
IF (e /= et) THEN
|
|
CALL connected(self%vols(e)%obj, self%vols(et)%obj)
|
|
|
|
END IF
|
|
|
|
END DO
|
|
|
|
!Connectivity betwen vols and edges
|
|
DO et = 1, self%numEdges
|
|
CALL connected(self%vols(e)%obj, self%edges(et)%obj)
|
|
|
|
END DO
|
|
|
|
!Constructs the global K matrix
|
|
CALL constructGlobalK(self%K, self%vols(e)%obj)
|
|
|
|
END DO
|
|
|
|
END SUBROUTINE readMesh1D
|
|
|
|
SUBROUTINE connectedVolVol(elemA, elemB)
|
|
IMPLICIT NONE
|
|
|
|
CLASS(meshVol), INTENT(inout):: elemA
|
|
CLASS(meshVol), INTENT(inout):: elemB
|
|
|
|
SELECT TYPE(elemA)
|
|
TYPE IS(meshVol1DSegm)
|
|
SELECT TYPE(elemB)
|
|
TYPE IS(meshVol1DSegm)
|
|
CALL connectedSegmSegm(elemA, elemB)
|
|
|
|
END SELECT
|
|
|
|
END SELECT
|
|
|
|
END SUBROUTINE connectedVolVol
|
|
|
|
SUBROUTINE connectedSegmSegm(elemA, elemB)
|
|
IMPLICIT NONE
|
|
|
|
CLASS(meshVol1DSegm), INTENT(inout), TARGET:: elemA
|
|
CLASS(meshVol1DSegm), INTENT(inout), TARGET:: elemB
|
|
|
|
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
|
|
elemA%n2%n == elemB%n1%n) THEN
|
|
elemA%e1 => elemB
|
|
elemB%e2 => elemA
|
|
|
|
END IF
|
|
|
|
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
|
|
elemA%n1%n == elemB%n2%n) THEN
|
|
|
|
elemA%e2 => elemB
|
|
elemB%e1 => elemA
|
|
|
|
END IF
|
|
|
|
END SUBROUTINE connectedSegmSegm
|
|
|
|
SUBROUTINE connectedVolEdge(elemA, elemB)
|
|
IMPLICIT NONE
|
|
|
|
CLASS(meshVol), INTENT(inout):: elemA
|
|
CLASS(meshEdge), INTENT(inout):: elemB
|
|
|
|
SELECT TYPE(elemA)
|
|
TYPE IS (meshVol1DSegm)
|
|
SELECT TYPE(elemB)
|
|
CLASS IS(meshEdge1D)
|
|
CALL connectedSegmEdge(elemA, elemB)
|
|
|
|
END SELECT
|
|
|
|
END SELECT
|
|
|
|
END SUBROUTINE connectedVolEdge
|
|
|
|
SUBROUTINE connectedSegmEdge(elemA, elemB)
|
|
IMPLICIT NONE
|
|
|
|
CLASS(meshVol1DSegm), INTENT(inout), TARGET:: elemA
|
|
CLASS(meshEdge1D), INTENT(inout), TARGET:: elemB
|
|
|
|
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
|
|
elemA%n2%n == elemB%n1%n) THEN
|
|
|
|
elemA%e1 => elemB
|
|
elemB%e2 => elemA
|
|
|
|
END IF
|
|
|
|
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
|
|
elemA%n1%n == elemB%n1%n) THEN
|
|
|
|
elemA%e2 => elemB
|
|
elemB%e1 => elemA
|
|
|
|
END IF
|
|
|
|
END SUBROUTINE connectedSegmEdge
|
|
|
|
SUBROUTINE constructGlobalK(K, elem)
|
|
IMPLICIT NONE
|
|
|
|
REAL(8), INTENT(inout):: K(1:,1:)
|
|
CLASS(meshVol), INTENT(in):: elem
|
|
REAL(8):: localK(1:2,1:2)
|
|
INTEGER:: i, j
|
|
INTEGER:: n(1:2)
|
|
|
|
SELECT TYPE(elem)
|
|
TYPE IS(meshVol1DSegm)
|
|
localK = elem%elemK()
|
|
n = (/ elem%n1%n, elem%n2%n /)
|
|
|
|
CLASS DEFAULT
|
|
n = 0
|
|
localK = 0.D0
|
|
|
|
END SELECT
|
|
|
|
DO i = 1, 2
|
|
DO j = 1, 2
|
|
K(n(i), n(j)) = K(n(i), n(j)) + localK(i, j)
|
|
END DO
|
|
END DO
|
|
|
|
END SUBROUTINE constructGlobalK
|
|
|
|
END MODULE moduleMesh1DRead
|