diff --git a/README.md b/README.md index 34f1f31..d390177 100644 --- a/README.md +++ b/README.md @@ -99,4 +99,16 @@ Default origin is `0 0 0`. This command just sets the origin for where the simul cacmb --convert infile outfile ``` -This mode converts a file of type infile to a file of type outfile \ No newline at end of file +This mode converts a file `infile` to a file of `outfile`. The extensions determine the conversion process. + +### Mode Merge + +``` +cacmb --merge dim N infiles outfile +``` + +This mode merges multiple data files and creates one big simulation cell. The parameters are: + +`N` - The number of files which are being read + +`dim` - the dimension they are to be stacked along, can be either `x`, `y`, or `z`. If the argument `none` is passed then the cells are just overlaid. Future options will include a delete overlap command. \ No newline at end of file diff --git a/src/box.f90 b/src/box.f90 index fd1586a..ad5fe55 100644 --- a/src/box.f90 +++ b/src/box.f90 @@ -10,8 +10,9 @@ module box !command. Currently only mode_merge will require sub_boxes, for mode_create it will always !allocate to only 1 sub_box integer :: sub_box_num = 0 - real(kind=dp), allocatable :: sub_box_ori(:,:,:) - real(kind=dp), allocatable :: sub_box_bd(:,:) + integer, allocatable :: sub_box_array_bd(:,:,:)!Boundaries in the atom and element arrays for each sub_box + real(kind=dp), allocatable :: sub_box_ori(:,:,:)!Orientations for each of the subboxes + real(kind=dp), allocatable :: sub_box_bd(:,:)!Boundaries for each of the sub_boxes public contains @@ -26,10 +27,36 @@ module box integer, intent(in) :: n - sub_box_num = n - allocate(sub_box_ori(3,3,n), sub_box_bd(6,n)) + allocate(sub_box_ori(3,3,n), sub_box_bd(6,n), sub_box_array_bd(2,2,n)) + end subroutine alloc_sub_box + subroutine grow_sub_box(n) + !Grows sub box arrays, this is only called when a new file is read in + integer, intent(in) :: n + + integer, allocatable :: temp_array_bd(:,:,:), temp_file(:) + real(kind=dp), allocatable :: temp_ori(:,:,:), temp_bd(:,:) + !Allocate temporary arrays + allocate(temp_ori(3,3,sub_box_num+n),temp_bd(6,sub_box_num+n), & + temp_array_bd(2,2,sub_box_num+n), temp_file(sub_box_num+n)) + + !Move allocation for all sub_box_arrays + temp_ori(:,:,1:sub_box_num) = sub_box_ori + temp_ori(:,:,sub_box_num+1:) = 0.0_dp + call move_alloc(temp_ori, sub_box_ori) + + temp_bd(:, 1:sub_box_num) = sub_box_bd + temp_bd(:, sub_box_num+1:) = 0.0_dp + call move_alloc(temp_bd, sub_box_bd) + + temp_array_bd(:,:,1:sub_box_num) = sub_box_array_bd + temp_array_bd(:,:,sub_box_num+1:) = 0.0_dp + call move_alloc(temp_array_bd, sub_box_array_bd) + + return + end subroutine grow_sub_box + subroutine grow_box(temp_box_bd) !This function takes in a temporary box boundary and adjusts the overall box boundaries !to include it diff --git a/src/elements.f90 b/src/elements.f90 index 633a50a..28e0e5e 100644 --- a/src/elements.f90 +++ b/src/elements.f90 @@ -152,36 +152,36 @@ module elements atom_size = size(type_atom) !Check if we need to grow the ele_size, if so grow all the variables - if ( n > size(size_ele)) then + if ( n+ele_num > size(size_ele)) then - allocate(temp_int(n+buffer_size)) + allocate(temp_int(n+ele_num+buffer_size)) temp_int(1:ele_size) = lat_ele temp_int(ele_size+1:) = 0 call move_alloc(temp_int(1:ele_size), lat_ele) - allocate(temp_int(n+buffer_size)) + allocate(temp_int(n+ele_num+buffer_size)) temp_int(1:ele_size) = size_ele temp_int(ele_size+1:) = 0 call move_alloc(temp_int(1:ele_size), size_ele) - allocate(char_temp(n+buffer_size)) + allocate(char_temp(n+ele_num+buffer_size)) char_temp(1:ele_size) = type_ele call move_alloc(char_temp, type_ele) - allocate(temp_ele_real(3, max_basisnum, max_ng_node, n+buffer_size)) + allocate(temp_ele_real(3, max_basisnum, max_ng_node, n+ele_num+buffer_size)) temp_ele_real(:,:,:,1:ele_size) = r_node temp_ele_real(:,:,:,ele_size+1:) = 0.0_dp call move_alloc(temp_ele_real, r_node) end if !Now grow atom arrays if needed - if (m > atom_size) then - allocate(temp_int(m+buffer_size)) + if (m+atom_num > atom_size) then + allocate(temp_int(m+atom_num+buffer_size)) temp_int(1:atom_size) = type_atom temp_int(atom_size+1:) = 0 call move_alloc(temp_int, type_atom) - allocate(temp_real(3,m+buffer_size)) + allocate(temp_real(3,m+atom_num+buffer_size)) temp_real(:,1:atom_size) = r_atom temp_real(:, atom_size+1:) = 0.0_dp call move_alloc(temp_real, r_atom) diff --git a/src/mode_convert.f90 b/src/mode_convert.f90 index b46b07f..d6e1d9b 100644 --- a/src/mode_convert.f90 +++ b/src/mode_convert.f90 @@ -11,13 +11,14 @@ module mode_convert subroutine convert !This subroutine converts a single input file from one format to another character(len=100) :: infile, outfile - + real(kind = dp) :: temp_box_bd(6) !We have to allocate the element and atom arrays with a size of 1 for the read in code to work call alloc_ele_arrays(1,1) !First read in the file call get_command_argument(2, infile) call get_in_file(infile) - call read_in + call read_in(1, (/0.0_dp,0.0_dp,0.0_dp/), temp_box_bd) + call grow_box(temp_box_bd) !Now get the outfile, writing is done after all the codes complete call get_command_argument(3, outfile) diff --git a/src/mode_create.f90 b/src/mode_create.f90 index 50b5f4c..b82cc82 100644 --- a/src/mode_create.f90 +++ b/src/mode_create.f90 @@ -137,8 +137,12 @@ module mode_create !The last thing we do is setup the sub_box_boundaries call alloc_sub_box(1) + sub_box_num = 1 sub_box_ori(:,:,1) = orient sub_box_bd(:,1) = box_bd + sub_box_array_bd(1,:,1) = 1 + sub_box_array_bd(2,1,1) = atom_num + sub_box_array_bd(2,2,1) = ele_num end subroutine create !This subroutine parses the command and pulls out information needed for mode_create subroutine parse_command()