Octopus
grid.F90
Go to the documentation of this file.
1!! Copyright (C) 2002-2006 M. Marques, A. Castro, A. Rubio, G. Bertsch
2!! Copyright (C) 2021 S. Ohlmann
3!!
4!! This program is free software; you can redistribute it and/or modify
5!! it under the terms of the GNU General Public License as published by
6!! the Free Software Foundation; either version 2, or (at your option)
7!! any later version.
8!!
9!! This program is distributed in the hope that it will be useful,
10!! but WITHOUT ANY WARRANTY; without even the implied warranty of
11!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12!! GNU General Public License for more details.
13!!
14!! You should have received a copy of the GNU General Public License
15!! along with this program; if not, write to the Free Software
16!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17!! 02110-1301, USA.
18!!
19
20#include "global.h"
21
23
24module grid_oct_m
25 use accel_oct_m
27 use box_oct_m
29 use debug_oct_m
32 use cube_oct_m
37 use global_oct_m
39 use mesh_oct_m
42 use mpi_oct_m
46 use parser_oct_m
48 use space_oct_m
53 use unit_oct_m
56
57 implicit none
58
59 private
60 public :: &
61 grid_t, &
65 grid_end, &
74
76 type, extends(mesh_t) :: grid_t
77 ! Components are public by default
78 type(derivatives_t) :: der
79 type(stencil_t) :: stencil
80 type(symmetries_t) :: symm
81 type(symmetrizer_t) :: symmetrizer
82 end type grid_t
83
84 integer, parameter :: &
85 CURV_AFFINE = 1, &
86 curv_gygi = 2, &
87 curv_briggs = 3, &
88 curv_modine = 4
89
90contains
91
92 !-------------------------------------------------------------------
101 subroutine grid_init_stage_1(gr, namespace, space, grp, symm, latt, n_sites, site_position, variable_cell)
102 type(grid_t), intent(inout) :: gr
103 type(namespace_t), intent(in) :: namespace
104 class(space_t), intent(in) :: space
105 type(mpi_grp_t), intent(in) :: grp
106 type(symmetries_t), optional, intent(in) :: symm
107 type(lattice_vectors_t), optional, intent(in) :: latt
108 integer, optional, intent(in) :: n_sites
109 real(real64), contiguous, optional, intent(in) :: site_position(:,:)
110 logical, optional, intent(in) :: variable_cell
111
112 type(stencil_t) :: cube
113 integer :: enlarge(space%dim)
114 type(block_t) :: blk
115 integer :: idir
116 real(real64) :: grid_spacing(space%dim)
117
118 push_sub(grid_init_stage_1)
119
120 gr%box => box_factory_create(namespace, space, latt=latt, n_sites=n_sites, site_position=site_position)
121
122 if (present(symm)) then
123 gr%symm = symm
124 end if
125
126 !%Variable Spacing
127 !%Type float
128 !%Section Mesh
129 !%Description
130 !% The spacing between the points in the mesh. This controls the
131 !% quality of the discretization: smaller spacing gives more
132 !% precise results but increased computational cost.
133 !%
134 !% When using curvilinear coordinates, this is a canonical spacing
135 !% that will be changed locally by the transformation. In periodic
136 !% directions, your spacing may be slightly different than what
137 !% you request here, since the box size must be an integer
138 !% multiple of the spacing.
139 !%
140 !% There is no special default otherwise.
141 !%
142 !% It is possible to have a different spacing in each one of the Cartesian directions
143 !% if we define <tt>Spacing</tt> as block of the form
144 !%
145 !% <tt>%Spacing
146 !% <br>&nbsp;&nbsp;spacing_x | spacing_y | spacing_z
147 !% <br>%</tt>
148 !%End
149
150 if(parse_block(namespace, 'Spacing', blk) == 0) then
151 if(parse_block_cols(blk,0) < space%dim) call messages_input_error(namespace, 'Spacing')
152 do idir = 1, space%dim
153 call parse_block_float(blk, 0, idir - 1, grid_spacing(idir), units_inp%length)
154 end do
155 call parse_block_end(blk)
156 else
157 call parse_variable(namespace, 'Spacing', -m_one, grid_spacing(1), units_inp%length)
158 grid_spacing = grid_spacing(1)
159 end if
160
161 if (any(grid_spacing(1:space%dim) < m_epsilon)) then
162 message(1) = " Your input for 'Spacing' is negative or zero."
163 call messages_fatal(1, namespace=namespace)
164 end if
165
166 !%Variable PeriodicBoundaryMask
167 !%Type block
168 !%Section Mesh
169 !%Description
170 !% (Experimental) Defines a mask for which periodic boundaries are replaced by zero boundary conditions.
171 !%End
172 if (parse_block(namespace, 'PeriodicBoundaryMask', blk) < 0) then
173 gr%masked_periodic_boundaries = .false.
174 else
175 gr%masked_periodic_boundaries = .true.
176 call parse_block_string(blk, 0, 0, gr%periodic_boundary_mask)
177 call messages_experimental('PeriodicBoundaryMask')
178 call parse_block_end(blk)
179 end if
180
181 ! Initialize coordinate system
182 call initialize_coordinate_system(gr, namespace, space, grid_spacing, latt, n_sites, site_position)
183
184 ! initialize derivatives
185 call nl_operator_global_init(namespace)
186 call derivatives_init(gr%der, namespace, space, gr%coord_system, gr%symm)
187 ! the stencil used to generate the grid is a union of a cube (for
188 ! multigrid) and the Laplacian
189 ! In case of a variable cell, we generate the boundary points with the full cube of the
190 ! same order as the Laplacian, to be sure that all necessary points exist in case of a
191 ! change of symmetry.
192 if (.not. optional_default(variable_cell, .false.)) then
193 call stencil_cube_get_lapl(cube, space%dim, order = 2)
194 else
195 call stencil_cube_get_lapl(cube, space%dim, order = gr%der%order)
196 end if
197 call stencil_union(cube, gr%der%lapl%stencil, gr%stencil)
198 call stencil_end(cube)
199
200 enlarge = 2
201 enlarge = max(enlarge, gr%der%n_ghost)
202
203 call mesh_init_stage_1(gr, namespace, space, gr%box, gr%coord_system, grid_spacing, enlarge)
204 call mesh_init_stage_2(gr, namespace, space, gr%box, gr%stencil, grp)
205
206 pop_sub(grid_init_stage_1)
207 end subroutine grid_init_stage_1
208
209 !--------------------------------------------------------------------
211 subroutine grid_init_from_grid_stage_1(gr, original_gr, namespace, space, grp, variable_cell, &
212 box, spacing_prefactor, latt, n_sites, site_position)
213 type(grid_t), intent(inout) :: gr
214 type(grid_t), intent(in) :: original_gr
215 type(namespace_t), intent(in) :: namespace
216 class(space_t), intent(in) :: space
217 type(mpi_grp_t), intent(in) :: grp
218 logical, intent(in) :: variable_cell
219 class(box_t), target, optional, intent(in) :: box
220 real(real64), contiguous, optional, intent(in) :: spacing_prefactor(:)
221 type(lattice_vectors_t), optional, intent(in) :: latt
222 integer, optional, intent(in) :: n_sites
223 real(real64), contiguous, optional, intent(in) :: site_position(:,:)
224
225 type(stencil_t) :: cube
226 integer :: enlarge(space%dim)
227
229
230 ! First of all, create and associate the box that contains the grid
231 if (.not. present(box)) then
232 gr%box => box_factory_create(namespace, space)
233 else
234 gr%box => box
235 end if
236
237 !!! Copy all data !!!
238 ! Symmetries
239 gr%symm = original_gr%symm
240 ! Spacing
241 if (present(spacing_prefactor)) then
242 gr%spacing = spacing_prefactor * original_gr%spacing
243 if (any(abs(spacing_prefactor - m_one) > m_epsilon)) then
244 write(message(1), '(a)') "The two grids have different spacings, it will not be possible to establish a map between them"
245 call messages_warning(1)
246 end if
247 else
248 gr%spacing = original_gr%spacing
249 end if
250 ! Periodic boundaries
251 gr%masked_periodic_boundaries = original_gr%masked_periodic_boundaries
252 if (gr%masked_periodic_boundaries) gr%periodic_boundary_mask = original_gr%periodic_boundary_mask
253 ! Coordinate System
254 call initialize_coordinate_system(gr, namespace, space, gr%spacing, latt, n_sites, site_position)
255
256 ! initialize derivatives
257 call nl_operator_global_init(namespace)
258 call derivatives_init(gr%der, namespace, space, gr%coord_system, gr%symm)
259 ! the stencil used to generate the grid is a union of a cube (for
260 ! multigrid) and the Laplacian
261 ! In case of a variable cell, we generate the boundary points with the full cube of the
262 ! same order as the Laplacian, to be sure that all necessary points exist in case of a
263 ! change of symmetry.
264 if (.not. variable_cell) then
265 call stencil_cube_get_lapl(cube, space%dim, order = 2)
266 else
267 call stencil_cube_get_lapl(cube, space%dim, order = gr%der%order)
268 end if
269 call stencil_union(cube, gr%der%lapl%stencil, gr%stencil)
270 call stencil_end(cube)
271
272 enlarge = 2
273 enlarge = max(enlarge, gr%der%n_ghost)
274
275 call mesh_init_stage_1(gr, namespace, space, gr%box, gr%coord_system, gr%spacing, enlarge)
276 call mesh_init_stage_2(gr, namespace, space, gr%box, gr%stencil, grp)
277
279 end subroutine grid_init_from_grid_stage_1
280
281
282 !--------------------------------------------------------------------
286 subroutine initialize_coordinate_system(gr, namespace, space, grid_spacing, latt, n_sites, site_position)
287 type(grid_t), intent(inout) :: gr
288 type(namespace_t), intent(in) :: namespace
289 class(space_t), intent(in) :: space
290 real(real64), contiguous, intent(in) :: grid_spacing(:)
291 type(lattice_vectors_t), optional, intent(in) :: latt
292 integer, optional, intent(in) :: n_sites
293 real(real64), contiguous, optional, intent(in) :: site_position(:,:)
294
295 integer :: cv_method
296
298
299 !%Variable CurvMethod
300 !%Type integer
301 !%Default curv_affine
302 !%Section Mesh::Curvilinear
303 !%Description
304 !% The relevant functions in octopus are represented on a mesh in real space.
305 !% This mesh may be an evenly spaced regular rectangular grid (standard mode),
306 !% or else an adaptive or curvilinear grid. We have implemented
307 !% three kinds of adaptive meshes, although only the one invented by F. Gygi
308 !% (<tt>curv_gygi</tt>) is well tested; the other two are flagged as experimental and
309 !% require <tt>ExperimentalFeatures = yes</tt>. All are experimental with domain
310 !% parallelization, and none of them is available on GPUs.
311 !%Option curv_affine 1
312 !% Regular, uniform rectangular grid.
313 !%Option curv_gygi 2
314 !% The deformation of the grid is done according to the scheme described by
315 !% F. Gygi [F. Gygi and G. Galli, <i>Phys. Rev. B</i> <b>52</b>, R2229 (1995)].
316 !%Option curv_briggs 3
317 !% The deformation of the grid is done according to the scheme described by
318 !% Briggs [E.L. Briggs, D.J. Sullivan, and J. Bernholc, <i>Phys. Rev. B</i> <b>54</b> 14362 (1996)]
319 !%Option curv_modine 4
320 !% The deformation of the grid is done according to the scheme described by
321 !% Modine [N.A. Modine, G. Zumbach and E. Kaxiras, <i>Phys. Rev. B</i> <b>55</b>, 10289 (1997)]
322 !%End
323 call parse_variable(namespace, 'CurvMethod', curv_affine, cv_method)
324 if (.not. varinfo_valid_option('CurvMethod', cv_method)) call messages_input_error(namespace, 'CurvMethod')
325 if (cv_method /= curv_affine .and. accel_is_enabled()) then
326 call messages_write('Curvilinear coordinates on GPUs is not implemented')
327 call messages_fatal(namespace=namespace)
328 end if
329 if (present(latt)) then
330 if (cv_method /= curv_affine .and. latt%nonorthogonal) then
331 call messages_input_error(namespace, 'CurvMethod', 'Curvilinear coordinates with non-orthogonal cells are not implemented')
332 end if
333 end if
334 call messages_print_var_option("CurvMethod", cv_method, namespace=namespace)
335
336 ! FIXME: The other two methods are apparently not working
337 select case (cv_method)
338 case (curv_briggs)
339 call messages_experimental('Curvilinear coordinates method curv_briggs', namespace=namespace)
340 case (curv_modine)
341 call messages_experimental('Curvilinear coordinates method curv_modine', namespace=namespace)
342 end select
343
344 select case (cv_method)
345 case (curv_briggs)
346 gr%coord_system => curv_briggs_t(namespace, space%dim, &
347 gr%box%bounding_box_l(1:space%dim), grid_spacing(1:space%dim))
348 case (curv_gygi)
349 if (present(site_position) .and. present(n_sites)) then
350 gr%coord_system => curv_gygi_t(namespace, space%dim, n_sites, site_position)
351 else
352 message(1) = "Option CurvMethod = curv_gygi is not currently implemented without ions present."
353 call messages_fatal(1, namespace=namespace)
354 end if
355 case (curv_modine)
356 if (present(site_position) .and. present(n_sites)) then
357 gr%coord_system => curv_modine_t(namespace, space%dim, n_sites, site_position, &
358 gr%box%bounding_box_l(1:space%dim), grid_spacing(1:space%dim))
359 else
360 message(1) = "Option CurvMethod = curv_modine is not currently implemented without ions present."
361 call messages_fatal(1, namespace=namespace)
362 end if
363 case (curv_affine)
364 if (present(latt)) then
365 if (latt%nonorthogonal) then
366 gr%coord_system => affine_coordinates_t(namespace, space%dim, latt%rlattice_primitive)
367 else
368 gr%coord_system => cartesian_t(namespace, space%dim)
369 end if
370 else
371 gr%coord_system => cartesian_t(namespace, space%dim)
372 end if
373 end select
374
376 end subroutine initialize_coordinate_system
377
378
379 !-------------------------------------------------------------------
387 subroutine grid_init_stage_2(gr, namespace, space, mc, qvector)
388 type(grid_t), target, intent(inout) :: gr
389 type(namespace_t), intent(in) :: namespace
390 class(space_t), intent(in) :: space
391 type(multicomm_t), intent(in) :: mc
392 real(real64), contiguous, optional, intent(in) :: qvector(:)
393
394 push_sub(grid_init_stage_2)
395
396 call mesh_init_stage_3(gr, namespace, space, gr%stencil, mc)
397
398 call derivatives_build(gr%der, namespace, space, gr, gr%stencil, qvector)
399
400 ! print info concerning the grid
401 call grid_write_info(gr, namespace=namespace)
402
403 if(space%dim == 3) then
404 call symmetrizer_init(gr%symmetrizer, gr, gr%symm)
405 end if
406
407 pop_sub(grid_init_stage_2)
408 end subroutine grid_init_stage_2
409
410
411 !-------------------------------------------------------------------
414 subroutine grid_end(gr)
415 type(grid_t), intent(inout) :: gr
416
417 class(coordinate_system_t), pointer :: coord_system
418 class(box_t), pointer :: box
419
420 push_sub(grid_end)
421
423
424 call derivatives_end(gr%der)
425
426 ! We need to take a pointer here, otherwise we run into a gfortran bug.
427 coord_system => gr%coord_system
428 safe_deallocate_p(coord_system)
429 box => gr%box
430 safe_deallocate_p(box)
431
432 call mesh_end(gr)
433
434 call stencil_end(gr%stencil)
435
436 call symmetrizer_end(gr%symmetrizer)
437
438 pop_sub(grid_end)
439 end subroutine grid_end
440
441
442 !-------------------------------------------------------------------
443 subroutine grid_write_info(gr, iunit, namespace)
444 type(grid_t), intent(in) :: gr
445 integer, optional, intent(in) :: iunit
446 type(namespace_t), optional, intent(in) :: namespace
447
448 push_sub(grid_write_info)
449
450 call messages_print_with_emphasis(msg="Grid", iunit=iunit, namespace=namespace)
451
452 message(1) = 'Simulation Box:'
453 call messages_info(1, iunit=iunit, namespace=namespace)
454 call gr%box%write_info(iunit, namespace)
455
456 message(1) = "Main mesh:"
457 call messages_info(1, iunit=iunit, namespace=namespace)
458 call mesh_write_info(gr, iunit, namespace)
460 if (gr%use_curvilinear) then
461 call gr%coord_system%write_info(iunit, namespace)
462 end if
463
464 call messages_print_with_emphasis(iunit=iunit, namespace=namespace)
465
466 pop_sub(grid_write_info)
467 end subroutine grid_write_info
468
469 !-------------------------------------------------------------------
473 subroutine grid_lattice_vectors_update(gr, space, namespace, mc, new_latt)
474 type(grid_t), intent(inout) :: gr
475 type(space_t), intent(in) :: space
476 type(namespace_t), intent(in) :: namespace
477 type(multicomm_t), intent(in) :: mc
478 type(lattice_vectors_t), intent(in) :: new_latt
479
480 real(real64) :: new_box_bounds(2, space%dim)
481
483
484 call new_latt%write_info(namespace)
485
486 ! Regenerate the coordinate system
487 select type (coord_system=>gr%coord_system)
488 type is (affine_coordinates_t)
489 if (new_latt%nonorthogonal) then
490 deallocate(gr%coord_system)
491 gr%coord_system => affine_coordinates_t(namespace, space%dim, new_latt%rlattice_primitive)
492 end if
493 end select
494
495 ! Regenerate the grid keeping the same number of points
496 select type (coord_system=>gr%coord_system)
497 class is (affine_coordinates_t)
498 new_box_bounds = gr%box%bounds(coord_system%basis)
499 gr%spacing = (new_box_bounds(2,:)-new_box_bounds(1,:))/gr%idx%ll(:)
500 write(message(1), '(a)') trim(gr%box%short_info(unit_angstrom))
501 call messages_info(1, namespace=namespace)
502 call messages_new_line()
503 end select
504
505 safe_deallocate_a(gr%x)
506 safe_deallocate_a(gr%x_t)
507 safe_deallocate_a(gr%chi)
508 safe_deallocate_a(gr%vol_pp)
509 safe_deallocate_a(gr%jacobian_inverse)
510 call mesh_init_stage_3(gr, namespace, space, gr%stencil, mc, regenerate=.true.)
511
512 call derivates_set_coordinates_system(gr%der, gr%coord_system)
513 call derivatives_build(gr%der, namespace, space, gr, gr%stencil, regenerate=.true., verbose=.false.)
514
516 end subroutine grid_lattice_vectors_update
517
518#include "undef.F90"
519#include "real.F90"
520#include "grid_inc.F90"
521
522#include "undef.F90"
523#include "complex.F90"
524#include "grid_inc.F90"
525
526end module grid_oct_m
527
528!! Local Variables:
529!! mode: f90
530!! coding: utf-8
531!! End:
pure logical function, public accel_is_enabled()
Definition: accel.F90:391
Module, implementing a factory for boxes.
Definition: box_factory.F90:99
class(box_t) function, pointer, public box_factory_create(namespace, space, latt, n_sites, site_position)
initialize a box of any type
This module implements the curvilinear coordinates given in E.L. Briggs, D.J. Sullivan,...
Definition: curv_briggs.F90:98
This module implements the curvilinear coordinates given in F. Gygi and G. Galli, PRB 52 R2229 (1996)...
Definition: curv_gygi.F90:97
This module implements the curvilinear coordinates given in N. A. Modine, G. Zumbach,...
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public derivatives_build(der, namespace, space, mesh, stencil, qvector, regenerate, verbose)
build the derivatives object:
subroutine, public derivatives_end(der)
subroutine, public derivatives_init(der, namespace, space, coord_system, symm, order)
subroutine, public derivates_set_coordinates_system(der, coord_system)
real(real64), parameter, public m_epsilon
Definition: global.F90:189
real(real64), parameter, public m_one
Definition: global.F90:174
This module implements the underlying real-space grid.
Definition: grid.F90:96
subroutine initialize_coordinate_system(gr, namespace, space, grid_spacing, latt, n_sites, site_position)
this subroutine initializes the coordinate system
Definition: grid.F90:359
integer, parameter curv_gygi
Definition: grid.F90:156
integer, parameter curv_briggs
Definition: grid.F90:156
subroutine, public zgrid_symmetrize_scalar_field(gr, field, suppress_warning)
Definition: grid.F90:798
subroutine, public grid_init_stage_1(gr, namespace, space, grp, symm, latt, n_sites, site_position, variable_cell)
First stage of the grid initialization.
Definition: grid.F90:174
subroutine, public grid_init_from_grid_stage_1(gr, original_gr, namespace, space, grp, variable_cell, box, spacing_prefactor, latt, n_sites, site_position)
this subroutine allows to create a grid from an existing grid
Definition: grid.F90:285
subroutine, public zgrid_symmetrize_single(gr, iop, field, symm_field)
Definition: grid.F90:852
subroutine, public zgrid_symmetrize_vector_field(gr, field, suppress_warning)
Definition: grid.F90:824
subroutine, public grid_init_stage_2(gr, namespace, space, mc, qvector)
Second stage of the grid initialization.
Definition: grid.F90:460
subroutine, public dgrid_symmetrize_vector_field(gr, field, suppress_warning)
Definition: grid.F90:685
subroutine, public grid_write_info(gr, iunit, namespace)
Definition: grid.F90:516
subroutine, public grid_lattice_vectors_update(gr, space, namespace, mc, new_latt)
Regenerate the grid information after update of the lattice vectors.
Definition: grid.F90:546
subroutine, public dgrid_symmetrize_single(gr, iop, field, symm_field)
Definition: grid.F90:713
subroutine, public grid_end(gr)
finalize a grid object
Definition: grid.F90:487
subroutine, public dgrid_symmetrize_scalar_field(gr, field, suppress_warning)
Definition: grid.F90:659
integer, parameter curv_modine
Definition: grid.F90:156
This module contains subroutines, related to the initialization of the mesh.
Definition: mesh_init.F90:96
subroutine, public mesh_init_stage_3(mesh, namespace, space, stencil, mc, parent, regenerate)
When running parallel in domains, stencil and np_stencil are needed to compute the ghost points....
Definition: mesh_init.F90:514
subroutine, public mesh_init_stage_1(mesh, namespace, space, box, coord_system, spacing, enlarge)
First stage mesh initialization.
Definition: mesh_init.F90:151
subroutine, public mesh_init_stage_2(mesh, namespace, space, box, stencil, grp, regenerate)
This subroutine creates the global array of spatial indices and the inverse mapping.
Definition: mesh_init.F90:275
This module defines the meshes, which are used in Octopus.
Definition: mesh.F90:97
subroutine, public mesh_write_info(this, iunit, namespace)
Definition: mesh.F90:292
recursive subroutine, public mesh_end(this)
Definition: mesh.F90:668
subroutine, public messages_print_with_emphasis(msg, iunit, namespace)
Definition: messages.F90:878
character(len=512), private msg
Definition: messages.F90:143
subroutine, public messages_warning(no_lines, all_nodes, namespace)
Definition: messages.F90:501
subroutine, public messages_new_line()
Definition: messages.F90:1069
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
Definition: messages.F90:138
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
Definition: messages.F90:386
subroutine, public messages_input_error(namespace, var, details, row, column)
Definition: messages.F90:671
subroutine, public messages_experimental(name, namespace)
Definition: messages.F90:1020
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
Definition: messages.F90:570
This module handles the communicators for the various parallelization strategies.
Definition: multicomm.F90:124
This module defines non-local operators.
Definition: nl_operator.F90:95
subroutine, public nl_operator_global_init(namespace)
initialize global settings for non-local operators
subroutine, public nl_operator_global_end()
subroutine, public parse_block_string(blk, l, c, res, convert_to_c)
Definition: parser.F90:795
integer function, public parse_block(namespace, name, blk, check_varinfo_)
Definition: parser.F90:600
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
Definition: profiling.F90:122
This module defines routines, generating operators for a cubic stencil.
subroutine, public stencil_cube_get_lapl(this, dim, order)
This module defines stencils used in Octopus.
Definition: stencil.F90:114
subroutine, public stencil_end(this)
Definition: stencil.F90:194
subroutine, public stencil_union(st1, st2, stu)
Definition: stencil.F90:206
subroutine, public symmetrizer_end(this)
subroutine, public symmetrizer_init(this, mesh, symm)
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
Definition: unit.F90:111
This module defines the unit system, used for input and output.
type(unit_t), public unit_angstrom
For XYZ files.
type(unit_system_t), public units_inp
the units systems for reading and writing
class to tell whether a point is inside or outside
Definition: box.F90:120
abstract class to describe coordinate systems
Description of the grid, containing information on derivatives, stencil, and symmetries.
Definition: grid.F90:148
Describes mesh distribution to nodes.
Definition: mesh.F90:165
This is defined even when running serial.
Definition: mpi.F90:121
Stores all communicators and groups.
Definition: multicomm.F90:185
The class representing the stencil, which is used for non-local mesh operations.
Definition: stencil.F90:142
int true(void)