Version: SMASH-3.2
Public Types | Public Member Functions | Protected Attributes | Private Member Functions | List of all members
smash::RectangularLattice< T > Class Template Reference

#include <lattice.h>

template<typename T>
class smash::RectangularLattice< T >

A container class to hold all the arrays on the lattice and access them.

Template Parameters
TThe type of the contained values.

Definition at line 49 of file lattice.h.

Public Types

using iterator = typename std::vector< T >::iterator
 Iterator of lattice. More...
 
using const_iterator = typename std::vector< T >::const_iterator
 Const interator of lattice. More...
 

Public Member Functions

 RectangularLattice (const std::array< double, 3 > &l, const std::array< int, 3 > &n, const std::array< double, 3 > &orig, bool per, const LatticeUpdate upd)
 Rectangular lattice constructor. More...
 
 RectangularLattice (RectangularLattice< T > const &rl)
 Copy-constructor. More...
 
void reset ()
 Sets all values on lattice to zeros. More...
 
bool out_of_bounds (int ix, int iy, int iz) const
 Checks if 3D index is out of lattice bounds. More...
 
ThreeVector cell_center (int ix, int iy, int iz) const
 Find the coordinates of a given cell. More...
 
ThreeVector cell_center (int index) const
 Find the coordinate of cell center given the 1d index of the cell. More...
 
const std::array< double, 3 > & lattice_sizes () const
 
const std::array< int, 3 > & n_cells () const
 
const std::array< double, 3 > & cell_sizes () const
 
const std::array< double, 3 > & origin () const
 
bool periodic () const
 
LatticeUpdate when_update () const
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
T & operator[] (std::size_t i)
 
const T & operator[] (std::size_t i) const
 
std::size_t size () const
 
void assign_value (int lattice_index, T value)
 Overwrite with a template value T at a given node. More...
 
int index1d (int ix, int iy, int iz)
 Return the index of a given cell. More...
 
int index_left (int ix, int iy, int iz)
 Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -x direction ("left"). More...
 
int index_right (int ix, int iy, int iz)
 Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +x direction ("right"). More...
 
int index_down (int ix, int iy, int iz)
 Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -y direction ("down"). More...
 
int index_up (int ix, int iy, int iz)
 Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +y direction ("up"). More...
 
int index_backward (int ix, int iy, int iz)
 Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -z direction ("backward"). More...
 
int index_forward (int ix, int iy, int iz)
 Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +z direction ("forward"). More...
 
void compute_gradient_lattice (RectangularLattice< ThreeVector > &grad_lat) const
 Compute a gradient on a lattice of doubles via the finite difference method. More...
 
void compute_four_gradient_lattice (RectangularLattice< FourVector > &old_lat, double time_step, RectangularLattice< std::array< FourVector, 4 >> &grad_lat) const
 Compute a fourgradient on a lattice of FourVectors jmu via the finite difference method. More...
 
const T & node (int ix, int iy, int iz) const
 Take the value of a cell given its 3-D indices. More...
 
bool value_at (const ThreeVector &r, T &value) const
 Interpolates lattice quantity to coordinate r. More...
 
template<typename F >
void iterate_sublattice (const std::array< int, 3 > &lower_bounds, const std::array< int, 3 > &upper_bounds, F &&func)
 A sub-lattice iterator, which iterates in a 3D-structured manner and calls a function on every cell. More...
 
template<typename F >
void iterate_in_cube (const ThreeVector &point, const double r_cut, F &&func)
 Iterates only nodes whose cell centers lie not further than r_cut in x, y, z directions from the given point, that is iterates within a cube of side length 2*r_cut, and applies a function to each node. More...
 
template<typename F >
void integrate_volume (F &integral, F(*integrand)(ThreeVector, T &, ThreeVector), const double rcut, const ThreeVector &point)
 Calculate a volume integral with given integrand. More...
 
template<typename F >
void iterate_in_rectangle (const ThreeVector &point, const std::array< double, 3 > &rectangle, F &&func)
 Iterates only nodes whose cell centers lie not further than d_x in x-, d_y in y-, and d_z in z-direction from the given point, that is iterates within a rectangle of side lengths (2*dx, 2*dy, 2*dz), and applies a function to each node. More...
 
template<typename F >
void iterate_nearest_neighbors (const ThreeVector &point, F &&func)
 Iterates only over nodes corresponding to the center cell (the cell containing the given point) and its nearest neighbors in the -x, +x, -y, +y, -z, +z directions, and applies a function to each node. More...
 
template<typename L >
bool identical_to_lattice (const L *lat) const
 Checks if lattices of possibly different types have identical structure. More...
 
void reset_and_resize (std::optional< std::array< double, 3 >> new_length, std::optional< std::array< double, 3 >> new_origin, std::optional< std::array< int, 3 >> new_cells)
 Rebuilds the lattice with a different size, reseting it to zero values. More...
 

Protected Attributes

std::vector< T > lattice_
 The lattice itself, array containing physical quantities. More...
 
std::array< double, 3 > lattice_sizes_
 Lattice sizes in x, y, z directions. More...
 
std::array< int, 3 > n_cells_
 Number of cells in x,y,z directions. More...
 
std::array< double, 3 > cell_sizes_
 Cell sizes in x, y, z directions. More...
 
double cell_volume_
 Volume of a cell. More...
 
std::array< double, 3 > origin_
 Coordinates of the left down nearer corner. More...
 
const bool periodic_
 Whether the lattice is periodic. More...
 
const LatticeUpdate when_update_
 When the lattice should be recalculated. More...
 

Private Member Functions

int positive_modulo (int i, int n) const
 Returns division modulo, which is always between 0 and n-1 in is not suitable, because it returns results from -(n-1) to n-1. More...
 

Member Typedef Documentation

◆ iterator

template<typename T >
using smash::RectangularLattice< T >::iterator = typename std::vector<T>::iterator

Iterator of lattice.

Definition at line 174 of file lattice.h.

◆ const_iterator

template<typename T >
using smash::RectangularLattice< T >::const_iterator = typename std::vector<T>::const_iterator

Const interator of lattice.

Definition at line 176 of file lattice.h.

Constructor & Destructor Documentation

◆ RectangularLattice() [1/2]

template<typename T >
smash::RectangularLattice< T >::RectangularLattice ( const std::array< double, 3 > &  l,
const std::array< int, 3 > &  n,
const std::array< double, 3 > &  orig,
bool  per,
const LatticeUpdate  upd 
)
inline

Rectangular lattice constructor.

Parameters
[in]l3-dimensional array (lx,ly,lz) indicates the size of the lattice in x, y, z directions respectively [fm].
[in]n3-dimensional array (nx,ny,nz) indicates the number of cells of the lattice in x, y, z directions respectively. Each cell in the lattice is labeled by three integers i, j, k where \(i\in[0, nx-1]\), \(j\in[0, ny-1]\), \(k\in[0, nz-1]\). The sizes of each cell are given by lx/nx, ly/ny, lz/nz in x,y,z directions respectively.
[in]origA 3-dimensional array indicating the coordinates of the origin [fm].
[in]perBoolean indicating whether a periodic boundary condition is applied.
[in]updEnum indicating how frequently the lattice is updated.

Definition at line 68 of file lattice.h.

72  : lattice_sizes_(l),
73  n_cells_(n),
74  cell_sizes_{l[0] / n[0], l[1] / n[1], l[2] / n[2]},
75  cell_volume_{cell_sizes_[0] * cell_sizes_[1] * cell_sizes_[2]},
76  origin_(orig),
77  periodic_(per),
78  when_update_(upd) {
79  lattice_.resize(n_cells_[0] * n_cells_[1] * n_cells_[2]);
80  logg[LLattice].debug(
81  "Rectangular lattice created: sizes[fm] = (", lattice_sizes_[0], ",",
82  lattice_sizes_[1], ",", lattice_sizes_[2], "), dims = (", n_cells_[0],
83  ",", n_cells_[1], ",", n_cells_[2], "), origin = (", origin_[0], ",",
84  origin_[1], ",", origin_[2], "), periodic: ", periodic_);
85  if (n_cells_[0] < 1 || n_cells_[1] < 1 || n_cells_[2] < 1 ||
86  lattice_sizes_[0] < 0.0 || lattice_sizes_[1] < 0.0 ||
87  lattice_sizes_[2] < 0.0) {
88  throw std::invalid_argument(
89  "Lattice sizes should be positive, "
90  "number of lattice cells should be > 0.");
91  }
92  }
smash::RectangularLattice::periodic_
const bool periodic_
Whether the lattice is periodic.
Definition: lattice.h:847
smash::RectangularLattice::cell_sizes_
std::array< double, 3 > cell_sizes_
Cell sizes in x, y, z directions.
Definition: lattice.h:841
smash::RectangularLattice::when_update_
const LatticeUpdate when_update_
When the lattice should be recalculated.
Definition: lattice.h:849
smash::RectangularLattice::n_cells_
std::array< int, 3 > n_cells_
Number of cells in x,y,z directions.
Definition: lattice.h:839
smash::RectangularLattice::origin_
std::array< double, 3 > origin_
Coordinates of the left down nearer corner.
Definition: lattice.h:845
smash::RectangularLattice::lattice_sizes_
std::array< double, 3 > lattice_sizes_
Lattice sizes in x, y, z directions.
Definition: lattice.h:837
smash::RectangularLattice::cell_volume_
double cell_volume_
Volume of a cell.
Definition: lattice.h:843
smash::RectangularLattice::lattice_
std::vector< T > lattice_
The lattice itself, array containing physical quantities.
Definition: lattice.h:835
smash::logg
std::array< einhard::Logger<>, std::tuple_size< LogArea::AreaTuple >::value > logg
An array that stores all pre-configured Logger objects.
Definition: logging.cc:40
smash::pdg::n
constexpr int n
Neutron.
Definition: pdgcode_constants.h:30
smash::LLattice
static constexpr int LLattice
Definition: lattice.h:27

◆ RectangularLattice() [2/2]

template<typename T >
smash::RectangularLattice< T >::RectangularLattice ( RectangularLattice< T > const &  rl)
inline

Copy-constructor.

Definition at line 95 of file lattice.h.

96  : lattice_(rl.lattice_),
97  lattice_sizes_(rl.lattice_sizes_),
98  n_cells_(rl.n_cells_),
99  cell_sizes_(rl.cell_sizes_),
100  cell_volume_(rl.cell_volume_),
101  origin_(rl.origin_),
102  periodic_(rl.periodic_),
103  when_update_(rl.when_update_) {}

Member Function Documentation

◆ reset()

template<typename T >
void smash::RectangularLattice< T >::reset ( )
inline

Sets all values on lattice to zeros.

Definition at line 106 of file lattice.h.

106 { std::fill(lattice_.begin(), lattice_.end(), T()); }

◆ out_of_bounds()

template<typename T >
bool smash::RectangularLattice< T >::out_of_bounds ( int  ix,
int  iy,
int  iz 
) const
inline

Checks if 3D index is out of lattice bounds.

Parameters
[in]ixThe index of the cell in x direction.
[in]iyThe index of the cell in y direction.
[in]izThe index of the cell in z direction.
Returns
Whether the cell is out of the lattice.

Definition at line 116 of file lattice.h.

116  {
117  // clang-format off
118  return !periodic_ &&
119  (ix < 0 || ix >= n_cells_[0] ||
120  iy < 0 || iy >= n_cells_[1] ||
121  iz < 0 || iz >= n_cells_[2]);
122  // clang-format on
123  }

◆ cell_center() [1/2]

template<typename T >
ThreeVector smash::RectangularLattice< T >::cell_center ( int  ix,
int  iy,
int  iz 
) const
inline

Find the coordinates of a given cell.

Parameters
[in]ixThe index of the cell in x direction.
[in]iyThe index of the cell in y direction.
[in]izThe index of the cell in z direction.
Returns
Coordinates of the center of the given cell [fm].

Definition at line 133 of file lattice.h.

133  {
134  return ThreeVector(origin_[0] + cell_sizes_[0] * (ix + 0.5),
135  origin_[1] + cell_sizes_[1] * (iy + 0.5),
136  origin_[2] + cell_sizes_[2] * (iz + 0.5));
137  }

◆ cell_center() [2/2]

template<typename T >
ThreeVector smash::RectangularLattice< T >::cell_center ( int  index) const
inline

Find the coordinate of cell center given the 1d index of the cell.

Parameters
[in]index1-dimensional index of the given cell. It can be related to a 3-dimensional one by index = ix + nx (iy + iz * ny).
Returns
Coordinates of the center of the given cell [fm].

Definition at line 147 of file lattice.h.

147  {
148  const int ix = index % n_cells_[0];
149  index = index / n_cells_[0];
150  const int iy = index % n_cells_[1];
151  const int iz = index / n_cells_[1];
152  return cell_center(ix, iy, iz);
153  }
smash::RectangularLattice::cell_center
ThreeVector cell_center(int ix, int iy, int iz) const
Find the coordinates of a given cell.
Definition: lattice.h:133

◆ lattice_sizes()

template<typename T >
const std::array<double, 3>& smash::RectangularLattice< T >::lattice_sizes ( ) const
inline
Returns
Lengths of the lattice in x, y, z directions.

Definition at line 156 of file lattice.h.

156 { return lattice_sizes_; }

◆ n_cells()

template<typename T >
const std::array<int, 3>& smash::RectangularLattice< T >::n_cells ( ) const
inline
Returns
Number of cells in x, y, z directions.

Definition at line 159 of file lattice.h.

159 { return n_cells_; }

◆ cell_sizes()

template<typename T >
const std::array<double, 3>& smash::RectangularLattice< T >::cell_sizes ( ) const
inline
Returns
Lengths of one cell in x, y, z directions.

Definition at line 162 of file lattice.h.

162 { return cell_sizes_; }

◆ origin()

template<typename T >
const std::array<double, 3>& smash::RectangularLattice< T >::origin ( ) const
inline
Returns
Lattice origin: left, down, near corner coordinates.

Definition at line 165 of file lattice.h.

165 { return origin_; }

◆ periodic()

template<typename T >
bool smash::RectangularLattice< T >::periodic ( ) const
inline
Returns
If lattice is periodic or not.

Definition at line 168 of file lattice.h.

168 { return periodic_; }

◆ when_update()

template<typename T >
LatticeUpdate smash::RectangularLattice< T >::when_update ( ) const
inline
Returns
The enum, which tells at which time lattice needs to be updated.

Definition at line 171 of file lattice.h.

171 { return when_update_; }

◆ begin() [1/2]

template<typename T >
iterator smash::RectangularLattice< T >::begin ( )
inline
Returns
First element of lattice.

Definition at line 178 of file lattice.h.

178 { return lattice_.begin(); }

◆ begin() [2/2]

template<typename T >
const_iterator smash::RectangularLattice< T >::begin ( ) const
inline
Returns
First element of lattice (const).

Definition at line 180 of file lattice.h.

180 { return lattice_.begin(); }

◆ end() [1/2]

template<typename T >
iterator smash::RectangularLattice< T >::end ( )
inline
Returns
Last element of lattice.

Definition at line 182 of file lattice.h.

182 { return lattice_.end(); }

◆ end() [2/2]

template<typename T >
const_iterator smash::RectangularLattice< T >::end ( ) const
inline
Returns
Last element of lattice (const).

Definition at line 184 of file lattice.h.

184 { return lattice_.end(); }

◆ operator[]() [1/2]

template<typename T >
T& smash::RectangularLattice< T >::operator[] ( std::size_t  i)
inline
Returns
ith element of lattice.

Definition at line 186 of file lattice.h.

186 { return lattice_[i]; }

◆ operator[]() [2/2]

template<typename T >
const T& smash::RectangularLattice< T >::operator[] ( std::size_t  i) const
inline
Returns
ith element of lattice (const).

Definition at line 188 of file lattice.h.

188 { return lattice_[i]; }

◆ size()

template<typename T >
std::size_t smash::RectangularLattice< T >::size ( ) const
inline
Returns
Size of lattice.

Definition at line 190 of file lattice.h.

190 { return lattice_.size(); }

◆ assign_value()

template<typename T >
void smash::RectangularLattice< T >::assign_value ( int  lattice_index,
T  value 
)
inline

Overwrite with a template value T at a given node.

Definition at line 195 of file lattice.h.

195  {
196  lattice_[lattice_index] = value;
197  }

◆ index1d()

template<typename T >
int smash::RectangularLattice< T >::index1d ( int  ix,
int  iy,
int  iz 
)
inline

Return the index of a given cell.

Parameters
[in]ixindex of a cell in the x-direction
[in]iyindex of a cell in the y-direction
[in]izindex of a cell in the z-direction
Returns
index of cell

Definition at line 207 of file lattice.h.

207  {
208  assert(ix < n_cells_[0]);
209  assert(iy < n_cells_[1]);
210  assert(iz < n_cells_[2]);
211  return (ix + n_cells_[0] * (iy + iz * n_cells_[1]));
212  }

◆ index_left()

template<typename T >
int smash::RectangularLattice< T >::index_left ( int  ix,
int  iy,
int  iz 
)
inline

Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -x direction ("left").

Parameters
[in]ixindex of a cell in the x-direction
[in]iyindex of a cell in the y-direction
[in]izindex of a cell in the z-direction
Returns
index of the nearest cell in the "left" direction (ix-1) with respect to the current cell

Definition at line 223 of file lattice.h.

223  {
224  if (unlikely(ix == 0)) {
225  return periodic_ ? index1d(n_cells_[0] - 1, iy, iz) : index1d(ix, iy, iz);
226  } else {
227  return index1d(ix - 1, iy, iz);
228  }
229  }
smash::RectangularLattice::index1d
int index1d(int ix, int iy, int iz)
Return the index of a given cell.
Definition: lattice.h:207
unlikely
#define unlikely(x)
Tell the branch predictor that this expression is likely false.
Definition: macros.h:16

◆ index_right()

template<typename T >
int smash::RectangularLattice< T >::index_right ( int  ix,
int  iy,
int  iz 
)
inline

Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +x direction ("right").

Parameters
[in]ixindex of a cell in the x-direction
[in]iyindex of a cell in the y-direction
[in]izindex of a cell in the z-direction
Returns
index of the nearest cell in the "right" direction (ix+1) with respect to the current cell

Definition at line 240 of file lattice.h.

240  {
241  if (unlikely(ix == (n_cells_[0] - 1))) {
242  return periodic_ ? index1d(0, iy, iz) : index1d(ix, iy, iz);
243  } else {
244  return index1d(ix + 1, iy, iz);
245  }
246  }

◆ index_down()

template<typename T >
int smash::RectangularLattice< T >::index_down ( int  ix,
int  iy,
int  iz 
)
inline

Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -y direction ("down").

Parameters
[in]ixindex of a cell in the x-direction
[in]iyindex of a cell in the y-direction
[in]izindex of a cell in the z-direction
Returns
index of the nearest cell in the "down" direction (iy-1) with respect to the current cell

Definition at line 257 of file lattice.h.

257  {
258  if (unlikely(iy == 0)) {
259  return periodic_ ? index1d(ix, n_cells_[1] - 1, iz) : index1d(ix, iy, iz);
260  } else {
261  return index1d(ix, iy - 1, iz);
262  }
263  }

◆ index_up()

template<typename T >
int smash::RectangularLattice< T >::index_up ( int  ix,
int  iy,
int  iz 
)
inline

Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +y direction ("up").

Parameters
[in]ixindex of a cell in the x-direction
[in]iyindex of a cell in the y-direction
[in]izindex of a cell in the z-direction
Returns
index of the nearest cell in the "up" direction (iy+1) with respect to the current cell

Definition at line 274 of file lattice.h.

274  {
275  if (unlikely(iy == (n_cells_[1] - 1))) {
276  return periodic_ ? index1d(ix, 0, iz) : index1d(ix, iy, iz);
277  } else {
278  return index1d(ix, iy + 1, iz);
279  }
280  }

◆ index_backward()

template<typename T >
int smash::RectangularLattice< T >::index_backward ( int  ix,
int  iy,
int  iz 
)
inline

Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -z direction ("backward").

Parameters
[in]ixindex of a cell in the x-direction
[in]iyindex of a cell in the y-direction
[in]izindex of a cell in the z-direction
Returns
index of the nearest cell in the "backward" direction (iz-1) with respect to the current cell

Definition at line 291 of file lattice.h.

291  {
292  if (unlikely(iz == 0)) {
293  return periodic_ ? index1d(ix, iy, n_cells_[2] - 1) : index1d(ix, iy, iz);
294  } else {
295  return index1d(ix, iy, iz - 1);
296  }
297  }

◆ index_forward()

template<typename T >
int smash::RectangularLattice< T >::index_forward ( int  ix,
int  iy,
int  iz 
)
inline

Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +z direction ("forward").

Parameters
[in]ixindex of a cell in the x-direction
[in]iyindex of a cell in the y-direction
[in]izindex of a cell in the z-direction
Returns
index of the nearest cell in the "forward" direction (iz+1) with respect to the current cell

Definition at line 308 of file lattice.h.

308  {
309  if (unlikely(iz == (n_cells_[2] - 1))) {
310  return periodic_ ? index1d(ix, iy, 0) : index1d(ix, iy, iz);
311  } else {
312  return index1d(ix, iy, iz + 1);
313  }
314  }

◆ compute_gradient_lattice()

template<typename T >
void smash::RectangularLattice< T >::compute_gradient_lattice ( RectangularLattice< ThreeVector > &  grad_lat) const
inline

Compute a gradient on a lattice of doubles via the finite difference method.

return a lattice of ThreeVectors which are gradients of the values on the original lattice

Definition at line 322 of file lattice.h.

323  {
324  if (n_cells_[0] < 2 || n_cells_[1] < 2 || n_cells_[2] < 2) {
325  // Gradient calculation is impossible
326  throw std::runtime_error(
327  "Lattice is too small for gradient calculation"
328  " (should be at least 2x2x2)");
329  }
330  if (!identical_to_lattice(&grad_lat)) {
331  // Lattice for gradient should have identical origin/dims/periodicity
332  throw std::invalid_argument(
333  "Lattice for gradient should have the"
334  " same origin/dims/periodicity as the original one.");
335  }
336  const double inv_2dx = 0.5 / cell_sizes_[0];
337  const double inv_2dy = 0.5 / cell_sizes_[1];
338  const double inv_2dz = 0.5 / cell_sizes_[2];
339  const int dix = 1;
340  const int diy = n_cells_[0];
341  const int diz = n_cells_[0] * n_cells_[1];
342  const int d = diz * n_cells_[2];
343 
344  for (int iz = 0; iz < n_cells_[2]; iz++) {
345  const int z_offset = diz * iz;
346  for (int iy = 0; iy < n_cells_[1]; iy++) {
347  const int y_offset = diy * iy + z_offset;
348  for (int ix = 0; ix < n_cells_[0]; ix++) {
349  const int index = ix + y_offset;
350  if (unlikely(ix == 0)) {
351  (grad_lat)[index].set_x1(
352  periodic_
353  ? (lattice_[index + dix] - lattice_[index + diy - dix]) *
354  inv_2dx
355  : (lattice_[index + dix] - lattice_[index]) * 2.0 *
356  inv_2dx);
357  } else if (unlikely(ix == n_cells_[0] - 1)) {
358  (grad_lat)[index].set_x1(
359  periodic_
360  ? (lattice_[index - diy + dix] - lattice_[index - dix]) *
361  inv_2dx
362  : (lattice_[index] - lattice_[index - dix]) * 2.0 *
363  inv_2dx);
364  } else {
365  (grad_lat)[index].set_x1(
366  (lattice_[index + dix] - lattice_[index - dix]) * inv_2dx);
367  }
368 
369  if (unlikely(iy == 0)) {
370  (grad_lat)[index].set_x2(
371  periodic_
372  ? (lattice_[index + diy] - lattice_[index + diz - diy]) *
373  inv_2dy
374  : (lattice_[index + diy] - lattice_[index]) * 2.0 *
375  inv_2dy);
376  } else if (unlikely(iy == n_cells_[1] - 1)) {
377  (grad_lat)[index].set_x2(
378  periodic_
379  ? (lattice_[index - diz + diy] - lattice_[index - diy]) *
380  inv_2dy
381  : (lattice_[index] - lattice_[index - diy]) * 2.0 *
382  inv_2dy);
383  } else {
384  (grad_lat)[index].set_x2(
385  (lattice_[index + diy] - lattice_[index - diy]) * inv_2dy);
386  }
387 
388  if (unlikely(iz == 0)) {
389  (grad_lat)[index].set_x3(
390  periodic_
391  ? (lattice_[index + diz] - lattice_[index + d - diz]) *
392  inv_2dz
393  : (lattice_[index + diz] - lattice_[index]) * 2.0 *
394  inv_2dz);
395  } else if (unlikely(iz == n_cells_[2] - 1)) {
396  (grad_lat)[index].set_x3(
397  periodic_
398  ? (lattice_[index - d + diz] - lattice_[index - diz]) *
399  inv_2dz
400  : (lattice_[index] - lattice_[index - diz]) * 2.0 *
401  inv_2dz);
402  } else {
403  (grad_lat)[index].set_x3(
404  (lattice_[index + diz] - lattice_[index - diz]) * inv_2dz);
405  }
406  }
407  }
408  }
409  }
smash::RectangularLattice::identical_to_lattice
bool identical_to_lattice(const L *lat) const
Checks if lattices of possibly different types have identical structure.
Definition: lattice.h:783

◆ compute_four_gradient_lattice()

template<typename T >
void smash::RectangularLattice< T >::compute_four_gradient_lattice ( RectangularLattice< FourVector > &  old_lat,
double  time_step,
RectangularLattice< std::array< FourVector, 4 >> &  grad_lat 
) const
inline

Compute a fourgradient on a lattice of FourVectors jmu via the finite difference method.

Parameters
[in]old_latthe lattice of FourVectors jmu at a previous time step
[in]time_stepthe used time step, needed for the time derivative
[out]grad_lata lattice of 4-arrays of 4-vectors with the following structure: [djmu_dt, djmu_dx, djmu_dy, djmu_dz]

Definition at line 420 of file lattice.h.

422  {
423  if (n_cells_[0] < 2 || n_cells_[1] < 2 || n_cells_[2] < 2) {
424  // Gradient calculation is impossible
425  throw std::runtime_error(
426  "Lattice is too small for gradient calculation"
427  " (should be at least 2x2x2)");
428  }
429  if (!identical_to_lattice(&grad_lat)) {
430  // Lattice for gradient should have identical origin/dims/periodicity
431  throw std::invalid_argument(
432  "Lattice for gradient should have the"
433  " same origin/dims/periodicity as the original one.");
434  }
435  const double inv_2dx = 0.5 / cell_sizes_[0];
436  const double inv_2dy = 0.5 / cell_sizes_[1];
437  const double inv_2dz = 0.5 / cell_sizes_[2];
438  const int dix = 1;
439  const int diy = n_cells_[0];
440  const int diz = n_cells_[0] * n_cells_[1];
441  const int d = diz * n_cells_[2];
442 
443  for (int iz = 0; iz < n_cells_[2]; iz++) {
444  const int z_offset = diz * iz;
445  for (int iy = 0; iy < n_cells_[1]; iy++) {
446  const int y_offset = diy * iy + z_offset;
447  for (int ix = 0; ix < n_cells_[0]; ix++) {
448  const int index = ix + y_offset;
449 
450  // auxiliary vectors used for the calculation of gradients
451  FourVector grad_t_jmu(0.0, 0.0, 0.0, 0.0);
452  FourVector grad_x_jmu(0.0, 0.0, 0.0, 0.0);
453  FourVector grad_y_jmu(0.0, 0.0, 0.0, 0.0);
454  FourVector grad_z_jmu(0.0, 0.0, 0.0, 0.0);
455  // t direction
456  grad_t_jmu = (lattice_[index] - (old_lat)[index]) * (1.0 / time_step);
457  // x direction
458  if (unlikely(ix == 0)) {
459  grad_x_jmu =
460  periodic_
461  ? (lattice_[index + dix] - lattice_[index + diy - dix]) *
462  inv_2dx
463  : (lattice_[index + dix] - lattice_[index]) * 2.0 * inv_2dx;
464  } else if (unlikely(ix == n_cells_[0] - 1)) {
465  grad_x_jmu =
466  periodic_
467  ? (lattice_[index - diy + dix] - lattice_[index - dix]) *
468  inv_2dx
469  : (lattice_[index] - lattice_[index - dix]) * 2.0 * inv_2dx;
470  } else {
471  grad_x_jmu =
472  (lattice_[index + dix] - lattice_[index - dix]) * inv_2dx;
473  }
474  // y direction
475  if (unlikely(iy == 0)) {
476  grad_y_jmu =
477  periodic_
478  ? (lattice_[index + diy] - lattice_[index + diz - diy]) *
479  inv_2dy
480  : (lattice_[index + diy] - lattice_[index]) * 2.0 * inv_2dy;
481  } else if (unlikely(iy == n_cells_[1] - 1)) {
482  grad_y_jmu =
483  periodic_
484  ? (lattice_[index - diz + diy] - lattice_[index - diy]) *
485  inv_2dy
486  : (lattice_[index] - lattice_[index - diy]) * 2.0 * inv_2dy;
487  } else {
488  grad_y_jmu =
489  (lattice_[index + diy] - lattice_[index - diy]) * inv_2dy;
490  }
491  // z direction
492  if (unlikely(iz == 0)) {
493  grad_z_jmu =
494  periodic_
495  ? (lattice_[index + diz] - lattice_[index + d - diz]) *
496  inv_2dz
497  : (lattice_[index + diz] - lattice_[index]) * 2.0 * inv_2dz;
498  } else if (unlikely(iz == n_cells_[2] - 1)) {
499  grad_z_jmu =
500  periodic_
501  ? (lattice_[index - d + diz] - lattice_[index - diz]) *
502  inv_2dz
503  : (lattice_[index] - lattice_[index - diz]) * 2.0 * inv_2dz;
504  } else {
505  grad_z_jmu =
506  (lattice_[index + diz] - lattice_[index - diz]) * inv_2dz;
507  }
508  // fill
509  (grad_lat)[index][0] = grad_t_jmu;
510  (grad_lat)[index][1] = grad_x_jmu;
511  (grad_lat)[index][2] = grad_y_jmu;
512  (grad_lat)[index][3] = grad_z_jmu;
513  }
514  }
515  }
516  }

◆ node()

template<typename T >
const T& smash::RectangularLattice< T >::node ( int  ix,
int  iy,
int  iz 
) const
inline

Take the value of a cell given its 3-D indices.

Parameters
[in]ixThe index of the cell in x direction.
[in]iyThe index of the cell in y direction.
[in]izThe index of the cell in z direction.
Returns
Physical quantity evaluated at the cell center.
Note
This serves as an accessor to the lattice node, since (prios to C++23) the overload of operator[] can only receive one argument. Because we do not want to allow for localized changes from outside the class, only the const version is implemented.

Definition at line 531 of file lattice.h.

531  {
532  return periodic_
533  ? lattice_[positive_modulo(ix, n_cells_[0]) +
534  n_cells_[0] *
535  (positive_modulo(iy, n_cells_[1]) +
536  n_cells_[1] * positive_modulo(iz, n_cells_[2]))]
537  : lattice_[ix + n_cells_[0] * (iy + n_cells_[1] * iz)];
538  }
smash::RectangularLattice::positive_modulo
int positive_modulo(int i, int n) const
Returns division modulo, which is always between 0 and n-1 in is not suitable, because it returns res...
Definition: lattice.h:860

◆ value_at()

template<typename T >
bool smash::RectangularLattice< T >::value_at ( const ThreeVector &  r,
T &  value 
) const
inline

Interpolates lattice quantity to coordinate r.

Result is stored in the value variable. Returns true if coordinate r is on the lattice, false if out of the lattice. In the latter case, the value is set to the default value (usually 0).

Parameters
[in]rPosition where the physical quantity would be evaluated.
[out]valuePhysical quantity evaluated at the nearest cell to the given position.
Returns
Boolean indicates whether the position r is located inside the lattice.
Todo:
(oliiny): maybe 1-order interpolation instead of 0-order?

Definition at line 554 of file lattice.h.

554  {
555  const int ix =
556  numeric_cast<int>(std::floor((r.x1() - origin_[0]) / cell_sizes_[0]));
557  const int iy =
558  numeric_cast<int>(std::floor((r.x2() - origin_[1]) / cell_sizes_[1]));
559  const int iz =
560  numeric_cast<int>(std::floor((r.x3() - origin_[2]) / cell_sizes_[2]));
561  if (out_of_bounds(ix, iy, iz)) {
562  value = T();
563  return false;
564  } else {
565  value = node(ix, iy, iz);
566  return true;
567  }
568  }
smash::RectangularLattice::out_of_bounds
bool out_of_bounds(int ix, int iy, int iz) const
Checks if 3D index is out of lattice bounds.
Definition: lattice.h:116
smash::RectangularLattice::node
const T & node(int ix, int iy, int iz) const
Take the value of a cell given its 3-D indices.
Definition: lattice.h:531

◆ iterate_sublattice()

template<typename T >
template<typename F >
void smash::RectangularLattice< T >::iterate_sublattice ( const std::array< int, 3 > &  lower_bounds,
const std::array< int, 3 > &  upper_bounds,
F &&  func 
)
inline

A sub-lattice iterator, which iterates in a 3D-structured manner and calls a function on every cell.

Template Parameters
FType of the function. Arguments are the current node and the 3 integer indices of the cell.
Parameters
[in]lower_boundsStarting numbers for iterating ix, iy, iz.
[in]upper_boundsEnding numbers for iterating ix, iy, iz.
[in]funcFunction acting on the cells (such as taking value).

Definition at line 581 of file lattice.h.

582  {
583  logg[LLattice].debug(
584  "Iterating sublattice with lower bound index (", lower_bounds[0], ",",
585  lower_bounds[1], ",", lower_bounds[2], "), upper bound index (",
586  upper_bounds[0], ",", upper_bounds[1], ",", upper_bounds[2], ")");
587 
588  if (periodic_) {
589  for (int iz = lower_bounds[2]; iz < upper_bounds[2]; iz++) {
590  const int z_offset = positive_modulo(iz, n_cells_[2]) * n_cells_[1];
591  for (int iy = lower_bounds[1]; iy < upper_bounds[1]; iy++) {
592  const int y_offset =
593  n_cells_[0] * (positive_modulo(iy, n_cells_[1]) + z_offset);
594  for (int ix = lower_bounds[0]; ix < upper_bounds[0]; ix++) {
595  const int index = positive_modulo(ix, n_cells_[0]) + y_offset;
596  func(lattice_[index], ix, iy, iz);
597  }
598  }
599  }
600  } else {
601  for (int iz = lower_bounds[2]; iz < upper_bounds[2]; iz++) {
602  const int z_offset = iz * n_cells_[1];
603  for (int iy = lower_bounds[1]; iy < upper_bounds[1]; iy++) {
604  const int y_offset = n_cells_[0] * (iy + z_offset);
605  for (int ix = lower_bounds[0]; ix < upper_bounds[0]; ix++) {
606  func(lattice_[ix + y_offset], ix, iy, iz);
607  }
608  }
609  }
610  }
611  }

◆ iterate_in_cube()

template<typename T >
template<typename F >
void smash::RectangularLattice< T >::iterate_in_cube ( const ThreeVector &  point,
const double  r_cut,
F &&  func 
)
inline

Iterates only nodes whose cell centers lie not further than r_cut in x, y, z directions from the given point, that is iterates within a cube of side length 2*r_cut, and applies a function to each node.

Useful for adding quantities from one particle to the lattice.

Template Parameters
FType of the function. Arguments are the current node and the 3 integer indices of the cell.
Parameters
[in]pointPosition, usually the position of particle [fm].
[in]r_cutMaximum distance from the cell center to the given position. [fm]
[in]funcFunction acting on the cells (such as taking value).

Definition at line 627 of file lattice.h.

627  {
628  std::array<int, 3> l_bounds, u_bounds;
629 
630  /* Array holds value at the cell center: r_center = r_0 + (i+0.5)cell_size,
631  * where i is index in any direction. Therefore we want cells with condition
632  * (r-r_cut)/csize - 0.5 < i < (r+r_cut)/csize - 0.5, r = r_center - r_0 */
633  for (int i = 0; i < 3; i++) {
634  l_bounds[i] = numeric_cast<int>(
635  std::ceil((point[i] - origin_[i] - r_cut) / cell_sizes_[i] - 0.5));
636  u_bounds[i] = numeric_cast<int>(
637  std::ceil((point[i] - origin_[i] + r_cut) / cell_sizes_[i] - 0.5));
638  }
639 
640  if (!periodic_) {
641  for (int i = 0; i < 3; i++) {
642  if (l_bounds[i] < 0) {
643  l_bounds[i] = 0;
644  }
645  if (u_bounds[i] > n_cells_[i]) {
646  u_bounds[i] = n_cells_[i];
647  }
648  if (l_bounds[i] > n_cells_[i] || u_bounds[i] < 0) {
649  return;
650  }
651  }
652  }
653  iterate_sublattice(l_bounds, u_bounds, std::forward<F>(func));
654  }
smash::RectangularLattice::iterate_sublattice
void iterate_sublattice(const std::array< int, 3 > &lower_bounds, const std::array< int, 3 > &upper_bounds, F &&func)
A sub-lattice iterator, which iterates in a 3D-structured manner and calls a function on every cell.
Definition: lattice.h:581

◆ integrate_volume()

template<typename T >
template<typename F >
void smash::RectangularLattice< T >::integrate_volume ( F &  integral,
F(*)(ThreeVector, T &, ThreeVector)  integrand,
const double  rcut,
const ThreeVector &  point 
)
inline

Calculate a volume integral with given integrand.

Template Parameters
Freturn type of the integrand
Parameters
[out]integralvariable to store rsult in. Input should be 0.
[in]integrandFunction to be integrated
[in]rcutsize of the integration volume. In total the intgration volume will be a cube with edge length 2*rcut
[in]pointcenter of the integration volume

Definition at line 668 of file lattice.h.

670  {
671  iterate_in_rectangle(
672  point, {rcut, rcut, rcut},
673  [&point, &integral, &integrand, this](T value, int ix, int iy, int iz) {
674  ThreeVector pos = this->cell_center(ix, iy, iz);
675  integral += integrand(pos, value, point) * this->cell_volume_;
676  });
677  }
smash::RectangularLattice::iterate_in_rectangle
void iterate_in_rectangle(const ThreeVector &point, const std::array< double, 3 > &rectangle, F &&func)
Iterates only nodes whose cell centers lie not further than d_x in x-, d_y in y-, and d_z in z-direct...
Definition: lattice.h:693

◆ iterate_in_rectangle()

template<typename T >
template<typename F >
void smash::RectangularLattice< T >::iterate_in_rectangle ( const ThreeVector &  point,
const std::array< double, 3 > &  rectangle,
F &&  func 
)
inline

Iterates only nodes whose cell centers lie not further than d_x in x-, d_y in y-, and d_z in z-direction from the given point, that is iterates within a rectangle of side lengths (2*dx, 2*dy, 2*dz), and applies a function to each node.

Useful for adding quantities from one particle to the lattice.

Template Parameters
FType of the function. Arguments are the current node and the 3 integer indices of the cell.
Parameters
[in]pointPosition, usually the position of particle [fm].
[in]rectangleMaximum distances in the x-, y-, and z-directions from the cell center to the given position. [fm]
[in]funcFunction acting on the cells (such as taking value).

Definition at line 693 of file lattice.h.

694  {
695  std::array<int, 3> l_bounds, u_bounds;
696 
697  /* Array holds value at the cell center: r_center = r_0 + (i+0.5)cell_size,
698  * where i is index in any direction. Therefore we want cells with condition
699  * (r[i]-rectangle[i])/csize - 0.5 < i < (r[i]+rectangle[i])/csize - 0.5,
700  * r[i] = r_center[i] - r_0[i]
701  */
702  for (int i = 0; i < 3; i++) {
703  l_bounds[i] = numeric_cast<int>(std::ceil(
704  (point[i] - origin_[i] - rectangle[i]) / cell_sizes_[i] - 0.5));
705  u_bounds[i] = numeric_cast<int>(std::ceil(
706  (point[i] - origin_[i] + rectangle[i]) / cell_sizes_[i] - 0.5));
707  }
708 
709  if (!periodic_) {
710  for (int i = 0; i < 3; i++) {
711  if (l_bounds[i] < 0) {
712  l_bounds[i] = 0;
713  }
714  if (u_bounds[i] > n_cells_[i]) {
715  u_bounds[i] = n_cells_[i];
716  }
717  if (l_bounds[i] > n_cells_[i] || u_bounds[i] < 0) {
718  return;
719  }
720  }
721  }
722  iterate_sublattice(l_bounds, u_bounds, std::forward<F>(func));
723  }

◆ iterate_nearest_neighbors()

template<typename T >
template<typename F >
void smash::RectangularLattice< T >::iterate_nearest_neighbors ( const ThreeVector &  point,
F &&  func 
)
inline

Iterates only over nodes corresponding to the center cell (the cell containing the given point) and its nearest neighbors in the -x, +x, -y, +y, -z, +z directions, and applies a function to each node.

Useful for adding quantities from one particle to the lattice.

Template Parameters
FType of the function. Arguments are the current node and the 3 integer indices of the cell.
Parameters
[in]pointPosition, usually the position of particle [fm].
[in]funcFunction acting on the cells (such as taking value).

Definition at line 737 of file lattice.h.

737  {
738  // get the 3D indices of the cell containing the given point
739  const int ix = numeric_cast<int>(
740  std::floor((point.x1() - origin_[0]) / cell_sizes_[0]));
741  const int iy = numeric_cast<int>(
742  std::floor((point.x2() - origin_[1]) / cell_sizes_[1]));
743  const int iz = numeric_cast<int>(
744  std::floor((point.x3() - origin_[2]) / cell_sizes_[2]));
745 
746  logg[LLattice].debug(
747  "Iterating over nearest neighbors of the cell at ix = ", ix,
748  ", iy = ", iy, ", iz = ", iz);
749 
750  // determine the 1D index of the center cell
751  const int i = index1d(ix, iy, iz);
752  func(lattice_[i], i, i);
753 
754  // determine the indeces of nearby cells, perform function on them
755  int ileft = index_left(ix, iy, iz);
756  func(lattice_[ileft], ileft, i);
757 
758  int iright = index_right(ix, iy, iz);
759  func(lattice_[iright], iright, i);
760 
761  int idown = index_down(ix, iy, iz);
762  func(lattice_[idown], idown, i);
763 
764  int iup = index_up(ix, iy, iz);
765  func(lattice_[iup], iup, i);
766 
767  int ibackward = index_backward(ix, iy, iz);
768  func(lattice_[ibackward], ibackward, i);
769 
770  int iforward = index_forward(ix, iy, iz);
771  func(lattice_[iforward], iforward, i);
772  }
smash::RectangularLattice::index_right
int index_right(int ix, int iy, int iz)
Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +x...
Definition: lattice.h:240
smash::RectangularLattice::index_left
int index_left(int ix, int iy, int iz)
Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -x...
Definition: lattice.h:223
smash::RectangularLattice::index_up
int index_up(int ix, int iy, int iz)
Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +y...
Definition: lattice.h:274
smash::RectangularLattice::index_backward
int index_backward(int ix, int iy, int iz)
Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -z...
Definition: lattice.h:291
smash::RectangularLattice::index_forward
int index_forward(int ix, int iy, int iz)
Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the +z...
Definition: lattice.h:308
smash::RectangularLattice::index_down
int index_down(int ix, int iy, int iz)
Given the indices of a cell in the x, y, and z directions, return index of the nearest cell in the -y...
Definition: lattice.h:257

◆ identical_to_lattice()

template<typename T >
template<typename L >
bool smash::RectangularLattice< T >::identical_to_lattice ( const L *  lat) const
inline

Checks if lattices of possibly different types have identical structure.

Template Parameters
LType of the other lattice.
Parameters
[in]latThe other lattice being compared with the current one
Returns
Whether the two lattices have the same sizes, cell numbers, origins, and boundary conditions.

Definition at line 783 of file lattice.h.

783  {
784  return n_cells_[0] == lat->n_cells()[0] &&
785  n_cells_[1] == lat->n_cells()[1] &&
786  n_cells_[2] == lat->n_cells()[2] &&
787  std::abs(lattice_sizes_[0] - lat->lattice_sizes()[0]) <
788  really_small &&
789  std::abs(lattice_sizes_[1] - lat->lattice_sizes()[1]) <
790  really_small &&
791  std::abs(lattice_sizes_[2] - lat->lattice_sizes()[2]) <
792  really_small &&
793  std::abs(origin_[0] - lat->origin()[0]) < really_small &&
794  std::abs(origin_[1] - lat->origin()[1]) < really_small &&
795  std::abs(origin_[2] - lat->origin()[2]) < really_small &&
796  periodic_ == lat->periodic();
797  }
smash::really_small
constexpr double really_small
Numerical error tolerance.
Definition: constants.h:37

◆ reset_and_resize()

template<typename T >
void smash::RectangularLattice< T >::reset_and_resize ( std::optional< std::array< double, 3 >>  new_length,
std::optional< std::array< double, 3 >>  new_origin,
std::optional< std::array< int, 3 >>  new_cells 
)
inline

Rebuilds the lattice with a different size, reseting it to zero values.

The parameters are all optional with different types, if none are passed the function throws.

Parameters
[in]new_length3-dimensional array indicates the new size of the lattice [fm].
[in]new_origin3-dimensional array (nx,ny,nz) indicates the origin of the lattice.
[in]new_cells3-dimensional array with the new number of lattice cells.
Exceptions
std::invalid_argumentif no arguments are given.

Definition at line 812 of file lattice.h.

814  {
815  if (!new_length && !new_origin && !new_cells) {
816  throw std::invalid_argument(
817  "RectangularLattice::reset_and_resize called "
818  "without arguments, lattice was not changed.");
819  }
820  reset();
821  if (new_length)
822  lattice_sizes_ = *new_length;
823  if (new_origin)
824  origin_ = *new_origin;
825  if (new_cells)
826  n_cells_ = *new_cells;
827  cell_sizes_ = {lattice_sizes_[0] / n_cells_[0],
828  lattice_sizes_[1] / n_cells_[1],
829  lattice_sizes_[2] / n_cells_[2]};
830  cell_volume_ = cell_sizes_[0] * cell_sizes_[1] * cell_sizes_[2];
831  }
smash::RectangularLattice::reset
void reset()
Sets all values on lattice to zeros.
Definition: lattice.h:106

◆ positive_modulo()

template<typename T >
int smash::RectangularLattice< T >::positive_modulo ( int  i,
int  n 
) const
inlineprivate

Returns division modulo, which is always between 0 and n-1 in is not suitable, because it returns results from -(n-1) to n-1.

Parameters
[in]iDividend.
[in]nDivisor.
Returns
Positive remainder.

Definition at line 860 of file lattice.h.

860  {
861  /* (i % n + n) % n would be correct, but slow.
862  * Instead I rely on the fact that i should never go too far
863  * in negative region and replace i%n + n by i + 256 * n = i + (n << 8) */
864  // FIXME: This should use asserts, also checking for under- or overflows.
865  return (i + (n << 8)) % n;
866  }

Member Data Documentation

◆ lattice_

template<typename T >
std::vector<T> smash::RectangularLattice< T >::lattice_
protected

The lattice itself, array containing physical quantities.

Definition at line 835 of file lattice.h.

◆ lattice_sizes_

template<typename T >
std::array<double, 3> smash::RectangularLattice< T >::lattice_sizes_
protected

Lattice sizes in x, y, z directions.

Definition at line 837 of file lattice.h.

◆ n_cells_

template<typename T >
std::array<int, 3> smash::RectangularLattice< T >::n_cells_
protected

Number of cells in x,y,z directions.

Definition at line 839 of file lattice.h.

◆ cell_sizes_

template<typename T >
std::array<double, 3> smash::RectangularLattice< T >::cell_sizes_
protected

Cell sizes in x, y, z directions.

Definition at line 841 of file lattice.h.

◆ cell_volume_

template<typename T >
double smash::RectangularLattice< T >::cell_volume_
protected

Volume of a cell.

Definition at line 843 of file lattice.h.

◆ origin_

template<typename T >
std::array<double, 3> smash::RectangularLattice< T >::origin_
protected

Coordinates of the left down nearer corner.

Definition at line 845 of file lattice.h.

◆ periodic_

template<typename T >
const bool smash::RectangularLattice< T >::periodic_
protected

Whether the lattice is periodic.

Definition at line 847 of file lattice.h.

◆ when_update_

template<typename T >
const LatticeUpdate smash::RectangularLattice< T >::when_update_
protected

When the lattice should be recalculated.

Definition at line 849 of file lattice.h.

The documentation for this class was generated from the following file: