Updates to box variables adding new sub_box variables and propagating changes through all of the modes

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

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

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)

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)

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