The 3D-FFT block performs three dimensional forward and inverse Fast Fourier Transforms on the QMMR and QMMI charge grid memories. The input data is in 2’s complement fixed-point format. Figure 30 shows the simplified view of the FFT block.

Figure 30 - Simplified View of the 3D-FFT Block

4.9.1.2.FFT Detailed Implementation

The pseudo code and the block diagram of the 3D-FFT block are illustrated in Figure 31 and 32 respectively. When the MC finished composing the charge grid QMMR, the system controller issues a “SYS_FFT_Start” signal to notify the 3D-FFT block to start the transformation. The 3D-FFT is broken down into three 1D FFTs. The 1D FFT is done for each direction and for each 1D pass, a row FFT is performed on all rows of the charge grid. The row FFT is performed using the Xilinx FFT LogiCore. The Xilinx LogiCore implements the Cooley-Tukey decimation-in-time (DIT) strategy with a maximum number of precision for the data sample and phase factor of 24 bits. The overflow output of the LogiCore is relayed to a RSCE status register bit such that an overflow condition in the 3D-FFT operation can be observed.
A point counter, a row counter, and a column counter are used to keep track of the memory location of the QMM element. The equation to calculate the memory address from the value of these counters is different for each direction’s 1D FFT. Diagrams in Figures 33, 34, and 35 and the pseudo code in Figure 31 illustrate the address generation for the 1D FFT operations. As an example, assume that the simulation box is a 16x16x16 grid. For the 1D FFT in the x direction, the next grid point for the row FFT is just one memory address away; while for the y direction 1D FFT, the memory address of the next point can be 16 memory addresses away. Furthermore, when all row FFTs in a plane are done, the memory address calculation to locate the next grid point in the next plane is different for each direction as well.
To allow for continuous loading and unloading to the Xilinx FFT LogiCore, the transformed real and imaginary rows are unloaded in digit-reverse [8] order and are written to two BRAMs. The transformed rows, along with the corresponding grid indexes are sent to the EC block where they are written back into the QMM memories. After the x and y direction 1D FFTs are done, the 3D-FFT block asserts a “LastDim” signal to notify the EC block that the upcoming real and imaginary row data can be used to calculate the reciprocal energy. That is, the EC block starts to calculate the energy and update the QMM memories when the 3D-FFT of a particular row is complete. Before the assertion of the “LastDim” signal, the EC block simply writes the row data into the QMM memory without modification and it generates a “WriteDone” signal to the 3D-FFT block to notify the memory write is complete so that the 3D-FFT block can start reading for a new row.
Look from the X direction

The Energy Calculator calculates the reciprocal energy by summing up the energy contribution of all grid points. The summation is shown in Equation 19. The calculation is simplified by looking up the energy term for grid points. The energy terms, as defined in Equation 20, are stored in the ETM memory. The entry content for the ETM memory is shown in Table 10. The energy term, when multiplied with the square of the 3D-IFFT transformed grid point value, results in the reciprocal energy contribution of the particular grid point. Figure 36 shows the simplified view of the EC blocks.

Equation 19 - Reciprocal Energy

Equation 20 - Energy Term

Figure 36 - Simplified View of the EC Block Table 10 - ETM Memory Description

Memory:

Energy Term Memory (ETM)

Description:

It holds the energy term which used in energy calculation.

Note:

Energy term is a signed 32-bit fixed-point number. The size of this memory limits the mesh size. Max # of mesh points is directly proportional to the depth of memory. For a 512Kx32 ZBT memory, 64x64x64, 64x64x128, 32x32x256, 32x64x128, 16x32x256, etc. can be supported.

31 -------------- 24

23 -------------- 16

15 ---------------- 8

7 ------------------ 0

0

signed etm[0][0][0] [31:0]

1

signed etm[0][0][1] [31:0]

2

signed etm[0][0][2] [31:0]

3

signed etm[0][0][3] [31:0]

:

:

4.9.2.2.EC Detailed implementation

The pseudo code and the block diagram of the EC block are shown in Figures 37 and 38 respectively. The energy calculation starts when a row from the 3D-FFT block has been 3D-IFFT transformed. This is indicated by the “LastDim” signal from the 3D-FFT block. Before the “LastDim” signal is asserted, the real and imaginary data are written to the QMM memories directly. When the LastDim signal is asserted, the real and imaginary data is multiplied by the eterm before being written into the QMM memories. Furthermore, when the LastDim is asserted, the energy calculation can start. According to the statement “m’ = m where m’ is < K/2 and m’ = m – K otherwise” [1], the index m’ used to lookup the energy terms and the index m used to indicate the grid point in the charge mesh Q are different. To simplify the hardware, the ETM memory is programmed such that the same index can use to read from the ETM memory and access the QMM memories.
for each grid point

lookup the corresponding eterm[m1][m2][m3]

access the corresponding charge grid qi[k1][k2][k3] & qr[k1][k2][k3]

calculate energy += eterm[m1][m2][m3] * (qi^2 + qr^2)

update charge grid:

qi = qi*eterm

qr = qr*eterm.

end for

Figure 37 - Pseudo Code for the EC Block

Figure 38 - Block Diagram of the EC Block As shown in the block diagram in Figure 38, there are five multiplications involved in the QMM update and reciprocal energy calculation; their precisions are listed in Table 11. As seen in Table 11, the precision of the energy calculation is limited by the precision of the 3D-FFT block.

As seen from the plots in Figure 39 and Figure 40, the energy term function is not a smooth one. Thus, the value of the energy term is stored explicitly for each grid point, hence, there is no interpolation involved in the eterm lookup. The EC block reads the energy term from the ETM memory and uses it directly to calculate the reciprocal energy. Thus, the number of the ETM memory entries required is the number of the grid points in the simulation system. For a cubical simulation box, since the energy terms for etermgrids [1][2][3] , = eterm[1][3][2], = eterm[[2][1][3] = ,eterm [2][3][1] = eterm, [3][1][2], and = eterm[3][2][1] are the same, only one sixth of the memory entries are actually required. Thus, substantial savings in terms of the memory requirement can be realized. However, this memory saving method complicates the hardware design and makes the designs inflexible for different simulation system configurations. Therefore, it is not implemented in the current implementation.
One problem of looking up the energy term is that the dynamic range of the energy term increases as the number of the charge grid increases. The dynamic range of the energy term for different grid sizes is shown in Table 12. As seen in the table, for a 128x128x128 mesh, the smallest energy term is 2.72e-121 while the largest one is 5.12e-03, it would require many bits in a fixed-point number to represent this dynamic range accurately. Since the eterm of a grid point is directly related to its energy contribution, this extreme small value of eterm should be insignificant to the summation of the total reciprocal energy. To lessen the effect of this dynamic range problem and increase the precision of the calculated energy and force, the eterm is shifted left by S_{L} bits before it is stored in the ETM memory. The number S_{L} is the position of the 1^{st} non-zero value in the binary representation of all eterm values. For example, if the eterm values are 0b00001, 0b00010, 0b00011 and 0b00100, the value of S_{L} is calculated to be 2. The value of S_{L} is calculated by the host when it is filling the ETM memory. When using the shifted eterm, the host needs to shift the calculated energy and forces to right by S_{L} bits to obtain the correct result.

Table 12 - Dynamic Range of Energy Term (β=0.349, V=224866.6)

Grid Size

Max

Min

8x8x8

2.77e-02

2.07e-03

32x32x32

5.190e-03

2.40e-10

64x64x64

5.14e-03

6.76e-33

128x128x128

5.12e-03

2.72e-121

Figure 39 - Energy Term for a (8x8x8) Mesh

Figure 40 - Energy Term for a (32x32x32) Mesh

4.9.3.Force Calculator (FC)

4.9.3.1.Functional Description

The Force Calculator calculates the directional forces F_{xi}, F_{yi}, and F_{zi} exerted on the particle i by the nearby interpolated P×P×P mesh points. The equation for reciprocal force calculation is shown in Equation 21. When the FC starts its operation, the convolution of (θrec*Q) should be already inside the QMMR memory. Furthermore, the partial derivatives of the charge grid, ∂Q/∂r, can be calculated using the charge, the coefficients and the derivatives of the particle. Figure 41 shows the simplified view of the FC block.

The pseudo code and the block diagram of the FC block are shown in Figures 42 and 43 respectively. Similar to the operation of the MC step, the FC block goes through each particle, identifies the P×P×P interpolated grid points, and calculates the force exerted on the particle by the interpolated grid points. There are two main differences between the MC operation and the FC operation.
Firstly, the reciprocal force calculation requires the B-Spline coefficients and their corresponding derivatives from the BCC block. They are needed to calculate the partial derivatives of the charge grid Q based on Equation 22.

Equation 22 - Partial Derivatives of the Charge Grid Q

For the x direction:

For the y direction:
For the z direction:
Secondly, there are three directional force calculations (the x, y, and z components of the force) for each particle. These three calculations can be parallelized since there is no dependency between the force components calculations. The end result can be written into the PIM memory. This PIM memory overwriting is allowed because the particle information is no longer necessary when the forces exerted on the particle are calculated. However, due to the resource limitation in the XCV2000 FPGA, the force computation for each direction is done sequentially. To further reduce the logic resource requirement, the FC block is actually reusing the logic and multipliers in the MC block for its calculations. A signal “ComputeForce” from the top-level state machine is used to signify if the current operation is for force calculation or for mesh composition. This logic resource sharing is possible because the MC block is idle after the mesh is composed. Furthermore, due to the adoption of sequential force computation, instead of the overwriting the particle information stored in the upper portion of the PIM memory, the calculated forces are written into the lower half of the PIM memory to further simplify the design. This lessens the maximum number of particles to N=13107265536.

for each particle i:

Use IntX to locate the P interpolating grid points in x direction.

for each of the P mesh points in x direction (P_{x} = 0..P-1)

Use intY to locate the P grid points in y direction.

for each of the P mesh points in y direction (P_{y} = 0..P-1)

Use intZ to locate the P grid points in z direction.

for each of the P mesh points in y direction (P_{z} = 0..P-1)

Calculate the Fxi = q_{i}*dθ_{xi}*θ_{yi}*θ_{zi}*Q[ ][ ][ ].

Calculate the Fyi = q_{i}*θ_{xi}*dθ_{yi}*θ_{zi}*Q[ ][ ][ ].

Calculate the Fzi = q_{i}*θ_{xi}*θ_{yi}*dθ_{zi}*Q[ ][ ][ ].

end for

end for

end for

end for

Figure 42 - Pseudo Code for the FC Block

Figure 43 - FC Block Diagram As shown in the FC block diagram in Figure 43; there are four multiplications involved in the reciprocal force calculation. The multipliers st1, st2, and st3 are shared with the MC block. The precision of multiplications is shown in Table 13. The precision of the multipliers st1, st2, and st3 are the same as the MC stage. The precision of the multiplier st4 is designed to carry all integer bits of the multiplication. Since the precision of the QMM is limited to {14.10} SFXP, it is adequate to set the precision of force accumulation to {22.10} SFXP which accommodates the entry width of the PIM memory.

Table 13 - FC Arithmetic Stages (For the X Directional Force)