First working version of model builder with several output file types and mode_create working
This commit is contained in:
Alex
parent
8217e8b51c
commit
ff3fc5e20a
6 changed files with 418 additions and 142 deletions
|
|
@ -5,28 +5,27 @@ module mode_create
|
|||
use atoms
|
||||
use io
|
||||
use subroutines
|
||||
use elements
|
||||
|
||||
implicit none
|
||||
|
||||
character(len=100) :: name, element_type
|
||||
real(kind = dp) :: lattice_parameter, orient(3,3), cell_mat(3,8), box_len(3), basis(3,3), origin(3), maxlen(3), &
|
||||
orient_inv(3,3), box_vert(3,8), ox_bd(6), maxbd(3), lattice_space(3)
|
||||
integer :: esize, duplicate(3), ix, iy, iz, box_lat_vert(3,8), lat_num, lat_atom_num, bd_in_lat(6)
|
||||
orient_inv(3,3), box_vert(3,8), maxbd(3), lattice_space(3)
|
||||
integer :: esize, duplicate(3), ix, iy, iz, box_lat_vert(3,8), lat_ele_num, lat_atom_num, bd_in_lat(6)
|
||||
logical :: dup_flag, dim_flag
|
||||
|
||||
real(kind=dp), allocatable :: r_lat(:,:,:), r_atom_lat(:,:)
|
||||
public
|
||||
contains
|
||||
|
||||
subroutine create(arg_num)
|
||||
subroutine create()
|
||||
! Main subroutine which controls execution
|
||||
|
||||
integer, intent(in) :: arg_num
|
||||
character(len=100) :: textholder
|
||||
|
||||
integer :: i, ibasis, inod
|
||||
real(kind=dp) :: r(3), periodvone(3), periodvtwo(3)
|
||||
real(kind=dp), allocatable :: r_node(:,:,:)
|
||||
real(kind=dp), allocatable :: r_node_temp(:,:,:)
|
||||
|
||||
!Initialize default parameters
|
||||
orient = reshape((/ 1.0_dp, 0.0_dp, 0.0_dp, 0.0_dp, 1.0_dp, 0.0_dp, 0.0_dp, 0.0_dp, 1.0_dp /), shape(orient))
|
||||
|
|
@ -40,11 +39,11 @@ module mode_create
|
|||
dup_flag = .false.
|
||||
dim_flag = .false.
|
||||
basisnum = 0
|
||||
lat_num = 0
|
||||
lat_ele_num = 0
|
||||
lat_atom_num = 0
|
||||
|
||||
!First we parse the command
|
||||
call parse_command(arg_num)
|
||||
call parse_command()
|
||||
|
||||
! Before building do a check on the file
|
||||
if (outfilenum == 0) then
|
||||
|
|
@ -55,7 +54,7 @@ module mode_create
|
|||
!Now we setup the unit element and call other init subroutines
|
||||
call def_ng_node(1, element_type)
|
||||
|
||||
allocate(r_node(3,max_basisnum,max_ng_node))
|
||||
allocate(r_node_temp(3,max_basisnum,max_ng_node))
|
||||
|
||||
if(dup_flag) then
|
||||
|
||||
|
|
@ -64,7 +63,7 @@ module mode_create
|
|||
|
||||
|
||||
do i = 1, 8
|
||||
box_vert(:,i) = duplicate(:)*lattice_space(:)*cubic_cell(:,i) + origin(:)
|
||||
box_vert(:,i) = duplicate(:)*esize*lattice_space(:)*cubic_cell(:,i) + origin(:)
|
||||
end do
|
||||
call matrix_inverse(orient,3,orient_inv)
|
||||
!Now get the rotated box vertex positions in lattice space. Should be integer units
|
||||
|
|
@ -72,31 +71,14 @@ module mode_create
|
|||
!Find the new maxlen
|
||||
maxbd = maxval(matmul(orient,matmul(fcc_mat,box_lat_vert)),2)
|
||||
do i = 1, 3
|
||||
box_bd(2*i) = maxval(box_vert(i,:)) - 0.1_dp*lattice_space(i)
|
||||
box_bd(2*i-1) = origin(i)
|
||||
box_bd(2*i) = maxval(box_vert(i,:)) - 0.25_dp*lattice_space(i)
|
||||
box_bd(2*i-1) = origin(i)-0.25_dp*lattice_space(i)
|
||||
end do
|
||||
|
||||
!and then call the build function with the correct transformation matrix
|
||||
select case(trim(adjustl(element_type)))
|
||||
case('fcc')
|
||||
! periodvone(:) = matmul(orient, reshape((/ 1, 1, 0 /),(/ 3 /)))
|
||||
! periodvtwo(:) = matmul(orient, reshape((/ 1, 1, 2 /),(/ 3 /)))
|
||||
|
||||
! do i = 1, 3
|
||||
! if (periodvone(i) < lim_zero) then
|
||||
! ! box_bd(2*i) =floor(box_bd(2*i)/periodvtwo(i))*periodvtwo(i)
|
||||
! box_bd(2*i) = box_bd(2*i) - 0.5*periodvtwo(i)
|
||||
! else if(periodvtwo(i) < lim_zero) then
|
||||
! ! box_bd(2*i) =floor(box_bd(2*i)/periodvone(i))*periodvone(i)
|
||||
! box_bd(2*i) = box_bd(2*i) - 0.5*periodvone(i)
|
||||
! else
|
||||
! ! box_bd(2*i) = floor(box_bd(2*i)/lcm(periodvone(i),periodvtwo(i)))*lcm(periodvone(i),periodvtwo(i))
|
||||
! box_bd(2*i) = box_bd(2*i) - 0.5*lcm(periodvone(i),periodvtwo(i))
|
||||
|
||||
! end if
|
||||
! end do
|
||||
|
||||
call lattice_in_box(box_lat_vert, fcc_mat)
|
||||
call build_with_rhomb(box_lat_vert, fcc_mat)
|
||||
case default
|
||||
print *, "Element type ", trim(adjustl(element_type)), " not accepted in mode create, please specify a supported ", &
|
||||
"element type"
|
||||
|
|
@ -116,33 +98,45 @@ module mode_create
|
|||
!Add the basis atoms to the unit cell
|
||||
do inod = 1, max_ng_node
|
||||
do ibasis = 1, basisnum(1)
|
||||
r_node(:,ibasis,inod) = cell_mat(:,inod) + basis_pos(:,ibasis,1) + origin(:)
|
||||
r_node_temp(:,ibasis,inod) = cell_mat(:,inod) + basis_pos(:,ibasis,1) + origin(:)
|
||||
end do
|
||||
end do
|
||||
|
||||
call add_element(element_type, esize, 1, r_node)
|
||||
do i = 1,3
|
||||
box_bd(2*i) = maxval(r_node_temp(i,:,:))
|
||||
box_bd(2*i-1) = origin(i)
|
||||
end do
|
||||
call add_element(element_type, esize, 1, r_node_temp)
|
||||
end if
|
||||
|
||||
!If we passed the dup_flag or dim_flag then we have to convert the lattice points and add them to the atom/element arrays
|
||||
if(dup_flag.or.dim_flag) then
|
||||
!Allocate variables
|
||||
call alloc_ele_arrays(lat_num, lat_atom_num*basisnum(1))
|
||||
call alloc_ele_arrays(lat_ele_num, lat_atom_num*basisnum(1))
|
||||
if(lat_atom_num > 0) then
|
||||
!Check for periodicity
|
||||
do i = 1, lat_atom_num
|
||||
do ibasis = 1, basisnum(1)
|
||||
do ibasis = 1, basisnum(1)
|
||||
call add_atom(basis_type(ibasis,1), (r_atom_lat(:,i)*lattice_parameter)+basis_pos(:,ibasis,1))
|
||||
end do
|
||||
end do
|
||||
deallocate(r_atom_lat)
|
||||
end if
|
||||
|
||||
if(lat_ele_num > 0) then
|
||||
do i = 1, lat_ele_num
|
||||
do inod= 1, ng_node(1)
|
||||
do ibasis = 1, basisnum(1)
|
||||
r_node_temp(:,ibasis,inod) = (r_lat(:,inod,i)*lattice_parameter)+basis_pos(:,ibasis,1)
|
||||
end do
|
||||
end do
|
||||
call add_element(element_type, esize, 1, r_node_temp)
|
||||
end do
|
||||
end if
|
||||
end if
|
||||
|
||||
end subroutine create
|
||||
!This subroutine parses the command and pulls out information needed for mode_create
|
||||
subroutine parse_command(arg_num)
|
||||
subroutine parse_command()
|
||||
|
||||
integer, intent(in) :: arg_num
|
||||
|
||||
integer :: arg_pos, ori_pos, i, j, arglen, stat
|
||||
character(len=100) :: textholder
|
||||
|
|
@ -217,7 +211,6 @@ module mode_create
|
|||
read(textholder, *) origin(i)
|
||||
arg_pos = arg_pos + 1
|
||||
end do
|
||||
print *, origin
|
||||
!If a filetype is passed then we add name.ext to the outfiles list
|
||||
case('xyz')
|
||||
textholder = trim(adjustl(name)) //'.xyz'
|
||||
|
|
@ -244,13 +237,11 @@ module mode_create
|
|||
select case(trim(adjustl(element_type)))
|
||||
case('fcc')
|
||||
do i = 1,3
|
||||
print *, orient(i,:)
|
||||
!Check if one of the directions is 110
|
||||
if ((is_equal(abs(orient(i,1)), abs(orient(i,2))).and.(is_equal(orient(i,3),0.0_dp))).or.&
|
||||
(is_equal(abs(orient(i,2)), abs(orient(i,3))).and.(is_equal(orient(i,1),0.0_dp))).or.&
|
||||
(is_equal(abs(orient(i,3)), abs(orient(i,1))).and.(is_equal(orient(i,2),0.0_dp)))) then
|
||||
|
||||
print *, '110', i
|
||||
lattice_space(i) = 0.5_dp * lattice_space(i)
|
||||
|
||||
!Check if one direction is 112
|
||||
|
|
@ -259,7 +250,6 @@ module mode_create
|
|||
(is_equal(abs(orient(i,3)), abs(orient(i,1))).and.(is_equal(abs(orient(i,2)),2.0_dp*abs(orient(i,3))))))&
|
||||
then
|
||||
|
||||
print *, '112 ', i
|
||||
lattice_space(i) = 0.5_dp * lattice_space(i)
|
||||
|
||||
end if
|
||||
|
|
@ -272,21 +262,27 @@ module mode_create
|
|||
if (basisnum(1) == 0) then
|
||||
max_basisnum = 1
|
||||
basisnum(1) = 1
|
||||
basis_type(1,1) = name !If basis command not defined then we use name as the atom_name
|
||||
call add_atom_type(name, basis_type(1,1)) !If basis command not defined then we use name as the atom_name
|
||||
basis_pos(:,1,1) = 0.0_dp
|
||||
end if
|
||||
end subroutine
|
||||
|
||||
subroutine lattice_in_box(box_in_lat, transform_matrix)
|
||||
subroutine build_with_rhomb(box_in_lat, transform_matrix)
|
||||
!This subroutine returns all the lattice points in the box in r_lat
|
||||
|
||||
!Inputs
|
||||
integer, dimension(3,8), intent(in) :: box_in_lat !The box vertices transformed to lattice space
|
||||
real(kind=dp), dimension(3,3), intent(in) :: transform_matrix !The transformation matrix from lattice_space to real space
|
||||
!Internal variables
|
||||
integer :: i, j, bd_in_lat(6), ix, iy, iz, numlatpoints
|
||||
real(kind=dp) :: box_face_center(3,6), face_normals(3,6), Cx(2), Cy, Cz, A(2), v(3)
|
||||
integer :: i, inod, bd_in_lat(6), bd_in_array(6), ix, iy, iz, numlatpoints, templatpoints, ele(3,8), rzero(3), ilat, &
|
||||
type_interp(basisnum(1)*esize**3), vlat(3), temp_lat(3,8), m, n, o
|
||||
real(kind=dp) :: v(3), temp_nodes(3,1,8), ele_atoms(3,esize**3), r_interp(3,basisnum(1)*esize**3)
|
||||
real(kind=dp), allocatable :: resize_lat_array(:,:)
|
||||
logical, allocatable :: lat_points(:,:,:)
|
||||
logical :: node_in_bd(8)
|
||||
|
||||
!Do some value initialization
|
||||
max_esize = esize
|
||||
|
||||
!First find the bounding lattice points (min and max points for the box in each dimension)
|
||||
numlatpoints = 1
|
||||
|
|
@ -304,82 +300,10 @@ module mode_create
|
|||
case default
|
||||
continue
|
||||
end select
|
||||
!Calculate the box_face centroids and box face normals. This is used in the centroid code.
|
||||
box_face_center(:,:) = 0.0_dp
|
||||
face_normals = reshape((/ -1.0_dp, 0.0_dp, 0.0_dp, &
|
||||
1.0_dp, 0.0_dp, 0.0_dp, &
|
||||
0.0_dp, -1.0_dp, 0.0_dp, &
|
||||
0.0_dp, 1.0_dp, 0.0_dp, &
|
||||
0.0_dp, 0.0_dp, -1.0_dp, &
|
||||
0.0_dp, 0.0_dp, 1.0_dp /),&
|
||||
shape(face_normals))
|
||||
!Face normals
|
||||
select case(trim(adjustl(element_type)))
|
||||
case('fcc')
|
||||
do i = 1, 6
|
||||
!Box face normal
|
||||
face_normals(:,i) = matmul(fcc_inv, matmul(orient_inv, face_normals(:,i)))
|
||||
end do
|
||||
end select
|
||||
|
||||
!Face centroids
|
||||
do i =1, 6
|
||||
|
||||
!Initialize variables
|
||||
A(:) = 0.0_dp
|
||||
Cx(:) = 0.0_dp
|
||||
Cy = 0.0_dp
|
||||
Cz = 0.0_dp
|
||||
|
||||
!Calculate all terms using a projection onto the xy and xz planes and then using the 2d equation
|
||||
!for centroid of a plane. This is why we calculate the x centroid twice.
|
||||
do j = 1, 4
|
||||
! A(1) = A(1) + 0.5*(box_in_lat(1,cubic_faces(j,i))*box_in_lat(2,cubic_faces(j+1,i)) &
|
||||
! - box_in_lat(1,cubic_faces(j+1,i))*box_in_lat(2,cubic_faces(j,i)))
|
||||
|
||||
! !Centroid in x from xy plane
|
||||
! Cx(1) = Cx(1) + (box_in_lat(1,cubic_faces(j,i))+box_in_lat(1,cubic_faces(j+1,i)))* &
|
||||
! (box_in_lat(1,cubic_faces(j,i))*box_in_lat(2,cubic_faces(j+1,i)) &
|
||||
! - box_in_lat(1,cubic_faces(j+1,i))*box_in_lat(2,cubic_faces(j,i)))
|
||||
|
||||
! !Centroid in y from xy plane
|
||||
! Cy = Cy + (box_in_lat(2,cubic_faces(j,i))+box_in_lat(2,cubic_faces(j+1,i)))* &
|
||||
! (box_in_lat(1,cubic_faces(j,i))*box_in_lat(2,cubic_faces(j+1,i)) &
|
||||
! - box_in_lat(1,cubic_faces(j+1,i))*box_in_lat(2,cubic_faces(j,i)))
|
||||
|
||||
! A(2) = A(2) + 0.5*(box_in_lat(1,cubic_faces(j,i))*box_in_lat(3,cubic_faces(j+1,i)) &
|
||||
! - box_in_lat(1,cubic_faces(j+1,i))*box_in_lat(3,cubic_faces(j,i)))
|
||||
|
||||
! !Centroid in x from xz plane
|
||||
! Cx(2) = Cx(2) + (box_in_lat(1,cubic_faces(j,i))+box_in_lat(1,cubic_faces(j+1,i)))* &
|
||||
! (box_in_lat(1,cubic_faces(j,i))*box_in_lat(3,cubic_faces(j+1,i)) &
|
||||
! - box_in_lat(1,cubic_faces(j+1,i))*box_in_lat(3,cubic_faces(j,i)))
|
||||
|
||||
! !Centroid in z from xz plane
|
||||
! Cz = Cz + (box_in_lat(3,cubic_faces(j,i))+box_in_lat(3,cubic_faces(j+1,i)))* &
|
||||
! (box_in_lat(1,cubic_faces(j,i))*box_in_lat(3,cubic_faces(j+1,i)) &
|
||||
! - box_in_lat(1,cubic_faces(j+1,i))*box_in_lat(3,cubic_faces(j,i)))
|
||||
|
||||
! print *, j, i, Cx, Cy, Cz, A
|
||||
Cx(1) = Cx(1) + box_in_lat(1,cubic_faces(j,i))*0.25
|
||||
Cy = Cy + box_in_lat(2,cubic_faces(j,i))*0.25
|
||||
Cz = Cz + box_in_lat(3,cubic_faces(j,i))*0.25
|
||||
|
||||
end do
|
||||
|
||||
! Cx = Cx * 1/(6*A)
|
||||
! if(Cx(1) /= Cx(2)) then
|
||||
! call error_message(7)
|
||||
! end if
|
||||
! Cy = Cy* 1/(6*A(1))
|
||||
! Cz = Cz*1/(6*A(2))
|
||||
|
||||
box_face_center(:,i) = (/ Cx(1), Cy, Cz /)
|
||||
end do
|
||||
|
||||
!Loop over all of lattice points within the boundary, we choose between two loops. One for the atomistic case
|
||||
!and one for the regular case
|
||||
print *, box_bd
|
||||
if (esize==2) then
|
||||
!atomistics
|
||||
do iz = bd_in_lat(5)-5, bd_in_lat(6)+5
|
||||
|
|
@ -398,10 +322,141 @@ module mode_create
|
|||
end do
|
||||
end do
|
||||
else
|
||||
continue
|
||||
!If we are working with elements we have to use more complex code
|
||||
|
||||
!Initialize finite element
|
||||
ele(:,:) = (esize-1) * cubic_cell(:,:)
|
||||
|
||||
!Make a 3 dimensional array of lattice points. This array is indexed by the integer lattice position.
|
||||
!A value of true means that the coordinate is a lattice point which is within the box_bd
|
||||
allocate(lat_points(bd_in_lat(2)-bd_in_lat(1)+10,bd_in_lat(4)-bd_in_lat(3)+10,bd_in_lat(6)-bd_in_lat(5)+10))
|
||||
lat_points(:,:,:) = .false.
|
||||
do iz = bd_in_lat(5)-5, bd_in_lat(6)+5
|
||||
do iy = bd_in_lat(3)-5, bd_in_lat(4)+5
|
||||
do ix = bd_in_lat(1)-5, bd_in_lat(2)+5
|
||||
v= (/ real(ix,dp), real(iy, dp), real(iz,dp) /)
|
||||
|
||||
!Transform point back to real space for easier checking
|
||||
v = matmul(orient, matmul(transform_matrix,v))
|
||||
!If within the boundaries
|
||||
if(in_block_bd(v, box_bd)) then
|
||||
lat_points(ix-bd_in_lat(1)+5,iy-bd_in_lat(3)+5,iz-bd_in_lat(5) + 5) = .true.
|
||||
end if
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
|
||||
!Now we redefine bd_in_lat The first 3 indices contains limits for the lat_points array
|
||||
bd_in_array(1) = bd_in_lat(2) - bd_in_lat(1) + 10
|
||||
bd_in_array(2) = bd_in_lat(4) - bd_in_lat(3) + 10
|
||||
bd_in_array(3) = bd_in_lat(6) - bd_in_lat(5) + 10
|
||||
!Figure out where the starting point is. This is the first piont which fully contains the finite element
|
||||
outerloop: do iz = 1, bd_in_array(3)
|
||||
do iy = 1, bd_in_array(2)
|
||||
do ix = 1, bd_in_array(1)
|
||||
node_in_bd(8) = .false.
|
||||
do inod = 1, 8
|
||||
vlat = ele(:,inod) + (/ ix, iy, iz /)
|
||||
|
||||
!Check to see if the node resides at a position containing a lattice point within the box
|
||||
if(any(vlat > shape(lat_points))) then
|
||||
continue
|
||||
else if(lat_points(vlat(1),vlat(2),vlat(3))) then
|
||||
node_in_bd(inod) = .true.
|
||||
end if
|
||||
end do
|
||||
|
||||
if(all(node_in_bd)) then
|
||||
rzero = (/ ix, iy, iz /)
|
||||
exit outerloop
|
||||
end if
|
||||
end do
|
||||
end do
|
||||
end do outerloop
|
||||
|
||||
!Now build the finite element region
|
||||
lat_ele_num = 0
|
||||
lat_atom_num = 0
|
||||
allocate(r_lat(3,8,numlatpoints/esize))
|
||||
|
||||
!Redefined the second 3 indices as the number of elements that fit in the bounds
|
||||
do i = 1, 3
|
||||
bd_in_array(3+i) = bd_in_array(i)/esize
|
||||
end do
|
||||
|
||||
!Now start the element at rzero
|
||||
do inod=1, 8
|
||||
ele(:,inod) = ele(:,inod) + rzero
|
||||
end do
|
||||
do iz = -bd_in_array(6), bd_in_array(6)
|
||||
do iy = -bd_in_array(5), bd_in_array(5)
|
||||
do ix = -bd_in_array(4), bd_in_array(4)
|
||||
node_in_bd(:) = .false.
|
||||
temp_nodes(:,:,:) = 0.0_dp
|
||||
temp_lat(:,:) = 0
|
||||
do inod = 1, 8
|
||||
vlat= ele(:,inod) + (/ ix*(esize), iy*(esize), iz*(esize) /)
|
||||
!Transform point back to real space for easier checking
|
||||
! v = matmul(orient, matmul(transform_matrix,v))
|
||||
do i = 1,3
|
||||
v(i) = real(vlat(i) + bd_in_lat(2*i-1) - 5)
|
||||
end do
|
||||
temp_nodes(:,1, inod) = matmul(orient, matmul(transform_matrix, v))
|
||||
temp_lat(:,inod) = vlat
|
||||
|
||||
!Check to see if the lattice point values are greater then the array limits
|
||||
if(any(vlat > shape(lat_points)).or.any(vlat < 1)) then
|
||||
continue
|
||||
!If within array boundaries check to see if it is a lattice point
|
||||
else if(lat_points(vlat(1),vlat(2),vlat(3))) then
|
||||
node_in_bd(inod) = .true.
|
||||
end if
|
||||
end do
|
||||
|
||||
if(all(node_in_bd)) then
|
||||
lat_ele_num = lat_ele_num+1
|
||||
r_lat(:,:,lat_ele_num) = temp_nodes(:,1,:)
|
||||
|
||||
!Now set all the lattice points contained within an element to false
|
||||
do o = minval(temp_lat(3,:)), maxval(temp_lat(3,:))
|
||||
do n = minval(temp_lat(2,:)), maxval(temp_lat(2,:))
|
||||
do m = minval(temp_lat(1,:)), maxval(temp_lat(1,:))
|
||||
lat_points(m,n,o) = .false.
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
|
||||
end if
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
|
||||
!Now figure out how many lattice points could not be contained in elements
|
||||
print *, count(lat_points)
|
||||
allocate(r_atom_lat(3,count(lat_points)))
|
||||
lat_atom_num = 0
|
||||
do ix = 1, bd_in_array(3)
|
||||
do iy = 1, bd_in_array(2)
|
||||
do iz = 1, bd_in_array(1)
|
||||
!If this point is a lattice point then save the lattice point as an atom
|
||||
if (lat_points(ix,iy,iz)) then
|
||||
v= (/ real(ix,dp), real(iy, dp), real(iz,dp) /)
|
||||
do i = 1,3
|
||||
v(i) = v(i) + real(bd_in_lat(2*i-1) - 5)
|
||||
end do
|
||||
!Transform point back to real space
|
||||
v = matmul(orient, matmul(transform_matrix,v))
|
||||
lat_atom_num = lat_atom_num + 1
|
||||
r_atom_lat(:,lat_atom_num) = v
|
||||
end if
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
|
||||
print *, lat_atom_num
|
||||
end if
|
||||
|
||||
end subroutine lattice_in_box
|
||||
end subroutine build_with_rhomb
|
||||
|
||||
|
||||
subroutine error_message(errorid)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue