Page 110 - The Combined Finite-Discrete Element Method
P. 110

SCREENING CONTACT DETECTION ALGORITHM         93

           Further mapping of discrete elements onto the cells after the discrete elements have
           moved does not require initialisation. Instead, discrete elements are simply removed from
           the singly connected lists, and all singly connected lists are thus made empty before the
           mapping process (step 1) starts again.
             Removing of discrete elements from the singly connected lists is done by looping over
           all discrete elements, integerising its coordinates and setting the corresponding number
           of array C and also the corresponding number of array E to −1, indicating empty lists:

               Loop over discrete elements (k=1; k≤N; k++)
               {  Integerise current coordinates using equation (26) and set

                                        int         x k − x min
                                    i =  x k = 1 + Int
                                                       d
                                                                                 (3.36)

                                        int         y k − y min
                                    j =  y k = 1 + Int
                                                       d
                  Empty the corresponding singly connected list by
                                          setting E[k] =−1
                                                                                 (3.37)
                                          and C[i][j] =−1
               }
           Once the discrete elements have been mapped onto the cells, detection of contacts is
           performed. This involves looping over all discrete elements, and finding out which cell a
           particular discrete element is mapped onto. Once the particular cell has been identified,
           direct check against all discrete elements from the central and neighbouring cells (as
           shown in Figure 3.18) is performed:

               Loop over discrete elements (k=1; k≤N; k++)
               {  Integerise current coordinates using equation (26) and set


                                        int         x k − x min
                                    i =  x k = 1 + Int                           (3.38)
                                                       d

                                                    y k − y min
                                        int
                                    j =  y k = 1 + Int
                                                       d
                  if C[i][j]≤N                                                   (3.39)
                  { C[i][j]=C[i][j]+N
                     loop over all discrete elements from C[i][j]list
                     { loop over all discrete elements from neighbouring
                       cells, i.e. lists C[i-1][j-1],C[i][j-1],
                       C[i+1][j-1],C[i-1][j],C[i][j]
                       { direct check for contact between discrete elements
                   }} }
               }

           Note that no loop over cells is used. Loops over discrete elements are used instead. In
           this way, the total number of algebraic operations involved is made independent of the
           total number of cells, i.e. independent of the size of array C.
   105   106   107   108   109   110   111   112   113   114   115