diff --git a/.github/workflows/style-check.yml b/.github/workflows/style-check.yml index 7be2c4fc46..e3567140fb 100644 --- a/.github/workflows/style-check.yml +++ b/.github/workflows/style-check.yml @@ -35,3 +35,4 @@ jobs: make check-permissions make check-homepage make check-errordocs + make check-fmtlib diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt index ce7b9f30f9..ff0d69e316 100644 --- a/cmake/CMakeLists.txt +++ b/cmake/CMakeLists.txt @@ -98,21 +98,24 @@ check_for_autogen_files(${LAMMPS_SOURCE_DIR}) ##################################################################### include(CheckIncludeFileCXX) -# set required compiler flags, apply checks, and compiler/CPU arch specific optimizations +# set required compiler flags and compiler/CPU arch specific optimizations if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") - # Intel classic compilers version 19 are broken and fail to compile the embedded fmtlib - if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 20.0) - message(ERROR "Intel classic compiler version ${CMAKE_CXX_COMPILER_VERSION} is too old") - endif() - if(CMAKE_SYSTEM_NAME STREQUAL "Windows") if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Qrestrict") endif() - set(CMAKE_TUNE_DEFAULT "/QxHost") + if(CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 17.3 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 17.4) + set(CMAKE_TUNE_DEFAULT "/QxCOMMON-AVX512") + else() + set(CMAKE_TUNE_DEFAULT "/QxHost") + endif() else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -restrict") - set(CMAKE_TUNE_DEFAULT "-xHost -fp-model fast=2 -no-prec-div -qoverride-limits -diag-disable=10441 -diag-disable=11074 -diag-disable=11076 -diag-disable=2196") + if(CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 17.3 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 17.4) + set(CMAKE_TUNE_DEFAULT "-xCOMMON-AVX512") + else() + set(CMAKE_TUNE_DEFAULT "-xHost -fp-model fast=2 -no-prec-div -qoverride-limits -diag-disable=10441 -diag-disable=11074 -diag-disable=11076 -diag-disable=2196") + endif() endif() endif() diff --git a/cmake/Modules/Packages/PLUMED.cmake b/cmake/Modules/Packages/PLUMED.cmake index 8dab157a24..5e5d110626 100644 --- a/cmake/Modules/Packages/PLUMED.cmake +++ b/cmake/Modules/Packages/PLUMED.cmake @@ -32,9 +32,9 @@ endif() # Note: must also adjust check for supported API versions in # fix_plumed.cpp when version changes from v2.n.x to v2.n+1.y -set(PLUMED_URL "https://github.com/plumed/plumed2/releases/download/v2.9.2/plumed-src-2.9.2.tgz" +set(PLUMED_URL "https://github.com/plumed/plumed2/releases/download/v2.9.3/plumed-src-2.9.3.tgz" CACHE STRING "URL for PLUMED tarball") -set(PLUMED_MD5 "04862602a372c1013bdfee2d6d03bace" CACHE STRING "MD5 checksum of PLUMED tarball") +set(PLUMED_MD5 "ee1249805fe94bccee17d10610d3f6f1" CACHE STRING "MD5 checksum of PLUMED tarball") mark_as_advanced(PLUMED_URL) mark_as_advanced(PLUMED_MD5) diff --git a/doc/src/Build_basics.rst b/doc/src/Build_basics.rst index 7014762cdc..be4b312578 100644 --- a/doc/src/Build_basics.rst +++ b/doc/src/Build_basics.rst @@ -196,13 +196,18 @@ LAMMPS. .. tab:: CMake build - By default CMake will use the compiler it finds according to + By default CMake will use the compiler it finds according to its internal preferences, and it will add optimization flags appropriate to that compiler and any :doc:`accelerator packages ` you have included in the build. CMake will check if the detected or selected compiler is compatible with the C++ support requirements of LAMMPS and stop with an error, if this - is not the case. + is not the case. A C++11 compatible compiler is currently + required, but a transition to require C++17 is in progress and + planned to be completed in Summer 2025. Currently, setting + ``-DLAMMPS_CXX11=yes`` is required when configuring with CMake while + using a C++11 compatible compiler that does not support C++17, + otherwise setting ``-DCMAKE_CXX_STANDARD=17`` is preferred. You can tell CMake to look for a specific compiler with setting CMake variables (listed below) during configuration. For a few @@ -223,6 +228,8 @@ LAMMPS. -D CMAKE_C_COMPILER=name # name of C compiler -D CMAKE_Fortran_COMPILER=name # name of Fortran compiler + -D CMAKE_CXX_STANDARD=17 # put compiler in C++17 mode + -D LAMMPS_CXX11=yes # enforce compilation in C++11 mode -D CMAKE_CXX_FLAGS=string # flags to use with C++ compiler -D CMAKE_C_FLAGS=string # flags to use with C compiler -D CMAKE_Fortran_FLAGS=string # flags to use with Fortran compiler @@ -321,15 +328,23 @@ LAMMPS. you would have to install a newer compiler that supports C++11; either as a binary package or through compiling from source. - If you build LAMMPS with any :doc:`Speed_packages` included, - there may be specific compiler or linker flags that are either - required or recommended to enable required features and to - achieve optimal performance. You need to include these in the - ``CCFLAGS`` and ``LINKFLAGS`` settings above. For details, see the - documentation for the individual packages listed on the - :doc:`Speed_packages` page. Or examine these files in the - ``src/MAKE/OPTIONS`` directory. They correspond to each of the 5 - accelerator packages and their hardware variants: + While a C++11 compatible compiler is currently sufficient to compile + LAMMPS, a transition to require C++17 is in progress and planned to + be completed in Summer 2025. Currently, setting ``-DLAMMPS_CXX11`` + in the ``LMP_INC =`` line in the machine makefile is required when + using a C++11 compatible compiler that does not support C++17. + Otherwise, to enable C++17 support (if not enabled by default) using + a compiler flag like ``-std=c++17`` in CCFLAGS may needed. + + If you build LAMMPS with any :doc:`Speed_packages` included, + there may be specific compiler or linker flags that are either + required or recommended to enable required features and to + achieve optimal performance. You need to include these in the + ``CCFLAGS`` and ``LINKFLAGS`` settings above. For details, see the + documentation for the individual packages listed on the + :doc:`Speed_packages` page. Or examine these files in the + ``src/MAKE/OPTIONS`` directory. They correspond to each of the 5 + accelerator packages and their hardware variants: .. code-block:: bash diff --git a/doc/src/Commands_compute.rst b/doc/src/Commands_compute.rst index fd68ce3e39..7c73583a4f 100644 --- a/doc/src/Commands_compute.rst +++ b/doc/src/Commands_compute.rst @@ -58,6 +58,7 @@ KOKKOS, o = OPENMP, t = OPT. * :doc:`fep/ta ` * :doc:`force/tally ` * :doc:`fragment/atom ` + * :doc:`gaussian/grid/local (k) ` * :doc:`global/atom ` * :doc:`group/group ` * :doc:`gyration ` @@ -140,8 +141,8 @@ KOKKOS, o = OPENMP, t = OPT. * :doc:`smd/vol ` * :doc:`snap ` * :doc:`sna/atom ` - * :doc:`sna/grid ` - * :doc:`sna/grid/local ` + * :doc:`sna/grid (k) ` + * :doc:`sna/grid/local (k) ` * :doc:`snad/atom ` * :doc:`snav/atom ` * :doc:`sph/e/atom ` diff --git a/doc/src/Commands_pair.rst b/doc/src/Commands_pair.rst index 75a7bb83cb..048a54ed37 100644 --- a/doc/src/Commands_pair.rst +++ b/doc/src/Commands_pair.rst @@ -115,7 +115,9 @@ OPT. * :doc:`gw/zbl ` * :doc:`harmonic/cut (o) ` * :doc:`hbond/dreiding/lj (o) ` + * :doc:`hbond/dreiding/lj/angleoffset (o) ` * :doc:`hbond/dreiding/morse (o) ` + * :doc:`hbond/dreiding/morse/angleoffset (o) ` * :doc:`hdnnp ` * :doc:`hippo (g) ` * :doc:`ilp/graphene/hbn (t) ` diff --git a/doc/src/Developer_code_design.rst b/doc/src/Developer_code_design.rst index 974266ec7f..9213efa18f 100644 --- a/doc/src/Developer_code_design.rst +++ b/doc/src/Developer_code_design.rst @@ -203,6 +203,7 @@ processed in the expected order before types are removed from dynamic dispatch. .. admonition:: Important Notes + :class: note In order to be able to detect incompatibilities at compile time and to avoid unexpected behavior, it is crucial that all member functions @@ -300,18 +301,24 @@ Formatting with the {fmt} library The LAMMPS source code includes a copy of the `{fmt} library `_, which is preferred over formatting with the -"printf()" family of functions. The primary reason is that it allows -a typesafe default format for any type of supported data. This is +"printf()" family of functions. The primary reason is that it allows a +typesafe default format for any type of supported data. This is particularly useful for formatting integers of a given size (32-bit or -64-bit) which may require different format strings depending on -compile time settings or compilers/operating systems. Furthermore, -{fmt} gives better performance, has more functionality, a familiar -formatting syntax that has similarities to ``format()`` in Python, and -provides a facility that can be used to integrate format strings and a -variable number of arguments into custom functions in a much simpler -way than the varargs mechanism of the C library. Finally, {fmt} has -been included into the C++20 language standard, so changes to adopt it -are future-proof. +64-bit) which may require different format strings depending on compile +time settings or compilers/operating systems. Furthermore, {fmt} gives +better performance, has more functionality, a familiar formatting syntax +that has similarities to ``format()`` in Python, and provides a facility +that can be used to integrate format strings and a variable number of +arguments into custom functions in a much simpler way than the varargs +mechanism of the C library. Finally, {fmt} has been included into the +C++20 language standard as ``std::format()``, so changes to adopt it are +future-proof, for as long as they are not using any extensions that are +not (yet) included into C++. + +The long-term plan is to switch to using ``std::format()`` instead of +``fmt::format()`` when the minimum C++ standard required for LAMMPS will +be set to C++20. See the :ref:`basic build instructions ` for +more details. Formatted strings are frequently created by calling the ``fmt::format()`` function, which will return a string as a @@ -319,11 +326,13 @@ Formatted strings are frequently created by calling the ``printf()``, the {fmt} library uses ``{}`` to embed format descriptors. In the simplest case, no additional characters are needed, as {fmt} will choose the default format based on the data type of the argument. -Otherwise, the ``fmt::print()`` function may be used instead of -``printf()`` or ``fprintf()``. In addition, several LAMMPS output -functions, that originally accepted a single string as argument have -been overloaded to accept a format string with optional arguments as -well (e.g., ``Error::all()``, ``Error::one()``, ``utils::logmesg()``). +Otherwise, the :cpp:func:`utils::print() ` +function may be used instead of ``printf()`` or ``fprintf()``. In +addition, several LAMMPS output functions, that originally accepted a +single string as argument have been overloaded to accept a format string +with optional arguments as well (e.g., ``Error::all()``, +``Error::one()``, :cpp:func:`utils::logmesg() +`). Summary of the {fmt} format syntax ================================== diff --git a/doc/src/Developer_flow.rst b/doc/src/Developer_flow.rst index 17d75879ca..5efbfaa51d 100644 --- a/doc/src/Developer_flow.rst +++ b/doc/src/Developer_flow.rst @@ -209,7 +209,7 @@ nve, nvt, npt. At the end of the timestep, fixes that contain an ``end_of_step()`` method are invoked. These typically perform a diagnostic calculation, -e.g. the ave/time and ave/spatial fixes. The final operation of the +e.g. the ave/time and ave/chunk fixes. The final operation of the timestep is to perform any requested output, via the ``write()`` method of the Output class. There are 3 kinds of LAMMPS output: thermodynamic output to the screen and log file, snapshots of atom data to a dump diff --git a/doc/src/Developer_utils.rst b/doc/src/Developer_utils.rst index 86a536f0cd..866945fc88 100644 --- a/doc/src/Developer_utils.rst +++ b/doc/src/Developer_utils.rst @@ -238,6 +238,12 @@ Convenience functions .. doxygenfunction:: logmesg(LAMMPS *lmp, const std::string &mesg) :project: progguide +.. doxygenfunction:: print(FILE *fp, const std::string &format, Args&&... args) + :project: progguide + +.. doxygenfunction:: print(FILE *fp, const std::string &mesg) + :project: progguide + .. doxygenfunction:: errorurl :project: progguide diff --git a/doc/src/Developer_write_fix.rst b/doc/src/Developer_write_fix.rst index afa569b05d..1b578823bd 100644 --- a/doc/src/Developer_write_fix.rst +++ b/doc/src/Developer_write_fix.rst @@ -96,8 +96,8 @@ Here the we specify which methods of the fix should be called during MPI_Allreduce(localAvgVel, globalAvgVel, 4, MPI_DOUBLE, MPI_SUM, world); scale3(1.0 / globalAvgVel[3], globalAvgVel); if ((comm->me == 0) && screen) { - fmt::print(screen,"{}, {}, {}\n", - globalAvgVel[0], globalAvgVel[1], globalAvgVel[2]); + utils::print(screen, "{}, {}, {}\n", + globalAvgVel[0], globalAvgVel[1], globalAvgVel[2]); } } diff --git a/doc/src/Fortran.rst b/doc/src/Fortran.rst index bc641a237f..53dc5b8897 100644 --- a/doc/src/Fortran.rst +++ b/doc/src/Fortran.rst @@ -323,6 +323,12 @@ of the contents of the :f:mod:`LIBLAMMPS` Fortran interface to LAMMPS. :ftype set_internal_variable: subroutine :f eval: :f:func:`eval` :ftype eval: function + :f clearstep_compute: :f:subr:`clearstep_compute` + :ftype clearstep_compute: subroutine + :f addstep_compute: :f:subr:`addstep_compute` + :ftype addstep_compute: subroutine + :f addstep_compute_all: :f:subr:`addstep_compute_all` + :ftype addstep_compute_all: subroutine :f gather_atoms: :f:subr:`gather_atoms` :ftype gather_atoms: subroutine :f gather_atoms_concat: :f:subr:`gather_atoms_concat` @@ -956,6 +962,7 @@ Procedures Bound to the :f:type:`lammps` Derived Type :f:func:`extract_atom` between runs. .. admonition:: Array index order + :class: tip Two-dimensional arrays returned from :f:func:`extract_atom` will be **transposed** from equivalent arrays in C, and they will be indexed @@ -1068,6 +1075,7 @@ Procedures Bound to the :f:type:`lammps` Derived Type you based on data from the :cpp:class:`Compute` class. .. admonition:: Array index order + :class: tip Two-dimensional arrays returned from :f:func:`extract_compute` will be **transposed** from equivalent arrays in C, and they will be indexed @@ -1326,6 +1334,7 @@ Procedures Bound to the :f:type:`lammps` Derived Type :rtype data: polymorphic .. admonition:: Array index order + :class: tip Two-dimensional global, per-atom, or local array data from :f:func:`extract_fix` will be **transposed** from equivalent arrays in @@ -1450,11 +1459,62 @@ Procedures Bound to the :f:type:`lammps` Derived Type an internal-style variable, an error is generated. :p character(len=*) name: name of the variable - :p read(c_double) val: new value to assign to the variable + :p real(c_double) val: new value to assign to the variable :to: :cpp:func:`lammps_set_internal_variable` -------- +.. f:function:: eval(expr) + + This function is a wrapper around :cpp:func:`lammps_eval` that takes a + LAMMPS equal style variable string, evaluates it and returns the resulting + scalar value as a floating-point number. + + .. versionadded:: TBD + + :p character(len=\*) expr: string to be evaluated + :to: :cpp:func:`lammps_eval` + :r value [real(c_double)]: result of the evaluated string + +-------- + +.. f:subroutine:: clearstep_compute() + + Clear whether a compute has been invoked + + .. versionadded:: TBD + + :to: :cpp:func:`lammps_clearstep_compute` + +-------- + +.. f:subroutine:: addstep_compute(nextstep) + + Add timestep to list of future compute invocations + if the compute has been invoked on the current timestep + + .. versionadded:: TBD + + overloaded for 32-bit and 64-bit integer arguments + + :p integer(kind=8 or kind=4) nextstep: next timestep + :to: :cpp:func:`lammps_addstep_compute` + +-------- + +.. f:subroutine:: addstep_compute_all(nextstep) + + Add timestep to list of future compute invocations + + .. versionadded:: TBD + + overloaded for 32-bit and 64-bit integer arguments + + :p integer(kind=8 or kind=4) nextstep: next timestep + :to: :cpp:func:`lammps_addstep_compute_all` + +-------- + .. f:subroutine:: gather_atoms(name, count, data) This function calls :cpp:func:`lammps_gather_atoms` to gather the named diff --git a/doc/src/Howto_barostat.rst b/doc/src/Howto_barostat.rst index 0c25e2c53c..89ff4d183f 100644 --- a/doc/src/Howto_barostat.rst +++ b/doc/src/Howto_barostat.rst @@ -10,20 +10,21 @@ and/or pressure (P) is specified by the user, and the thermostat or barostat attempts to equilibrate the system to the requested T and/or P. -Barostatting in LAMMPS is performed by :doc:`fixes `. Two +Barostatting in LAMMPS is performed by :doc:`fixes `. Three barostatting methods are currently available: Nose-Hoover (npt and -nph) and Berendsen: +nph), Berendsen, and various linear controllers in deform/pressure: * :doc:`fix npt ` * :doc:`fix npt/sphere ` * :doc:`fix npt/asphere ` * :doc:`fix nph ` * :doc:`fix press/berendsen ` +* :doc:`fix deform/pressure ` The :doc:`fix npt ` commands include a Nose-Hoover thermostat and barostat. :doc:`Fix nph ` is just a Nose/Hoover barostat; -it does no thermostatting. Both :doc:`fix nph ` and :doc:`fix press/berendsen ` can be used in conjunction -with any of the thermostatting fixes. +it does no thermostatting. The fixes :doc:`nph `, :doc:`press/berendsen `, and :doc:`deform/pressure ` +can be used in conjunction with any of the thermostatting fixes. As with the :doc:`thermostats `, :doc:`fix npt ` and :doc:`fix nph ` only use translational motion of the @@ -44,9 +45,9 @@ a temperature or pressure compute to a barostatting fix. .. note:: As with the thermostats, the Nose/Hoover methods (:doc:`fix npt ` and :doc:`fix nph `) perform time integration. - :doc:`Fix press/berendsen ` does NOT, so it should - be used with one of the constant NVE fixes or with one of the NVT - fixes. + :doc:`Fix press/berendsen ` and :doc:`fix deform/pressure ` + do NOT, so they should be used with one of the constant NVE fixes or with + one of the NVT fixes. Thermodynamic output, which can be setup via the :doc:`thermo_style ` command, often includes pressure diff --git a/doc/src/Install_git.rst b/doc/src/Install_git.rst index 5108009a73..d01bc6a4c5 100644 --- a/doc/src/Install_git.rst +++ b/doc/src/Install_git.rst @@ -52,6 +52,7 @@ your machine and "release" is one of the 3 branches listed above. between them at any time using "git checkout ".) .. admonition:: Saving time and disk space when using ``git clone`` + :class: note The complete git history of the LAMMPS project is quite large because it contains the entire commit history of the project since fall 2006, diff --git a/doc/src/Library_objects.rst b/doc/src/Library_objects.rst index 53edfce9e6..86b6d253f0 100644 --- a/doc/src/Library_objects.rst +++ b/doc/src/Library_objects.rst @@ -13,6 +13,9 @@ fixes, or variables in LAMMPS using the following functions: - :cpp:func:`lammps_set_internal_variable` - :cpp:func:`lammps_variable_info` - :cpp:func:`lammps_eval` +- :cpp:func:`lammps_clearstep_compute` +- :cpp:func:`lammps_addstep_compute_all` +- :cpp:func:`lammps_addstep_compute` ----------------------- @@ -61,6 +64,21 @@ fixes, or variables in LAMMPS using the following functions: ----------------------- +.. doxygenfunction:: lammps_clearstep_compute + :project: progguide + +----------------------- + +.. doxygenfunction:: lammps_addstep_compute_all + :project: progguide + +----------------------- + +.. doxygenfunction:: lammps_addstep_compute + :project: progguide + +----------------------- + .. doxygenenum:: _LMP_DATATYPE_CONST .. doxygenenum:: _LMP_STYLE_CONST diff --git a/doc/src/Modify_compute.rst b/doc/src/Modify_compute.rst index bf580a6561..ea603985dd 100644 --- a/doc/src/Modify_compute.rst +++ b/doc/src/Modify_compute.rst @@ -45,6 +45,8 @@ class. See compute.h for details. +-----------------------+------------------------------------------------------------------+ | pair_tally_callback | callback function for *tally*\ -style computes (optional). | +-----------------------+------------------------------------------------------------------+ +| modify_param | called when a compute_modify request is executed (optional) | ++-----------------------+------------------------------------------------------------------+ | memory_usage | tally memory usage (optional) | +-----------------------+------------------------------------------------------------------+ diff --git a/doc/src/compute.rst b/doc/src/compute.rst index 082f93a6c4..9a8a1734fb 100644 --- a/doc/src/compute.rst +++ b/doc/src/compute.rst @@ -236,6 +236,7 @@ The individual style names on the :doc:`Commands compute ` pag * :doc:`fep/ta ` - compute free energies for a test area perturbation * :doc:`force/tally ` - force between two groups of atoms via the tally callback mechanism * :doc:`fragment/atom ` - fragment ID for each atom +* :doc:`gaussian/grid/local ` - local array of Gaussian atomic contributions on a regular grid * :doc:`global/atom ` - assign global values to each atom from arrays of global values * :doc:`group/group ` - energy/force between two groups of atoms * :doc:`gyration ` - radius of gyration of group of atoms diff --git a/doc/src/compute_gaussian_grid_local.rst b/doc/src/compute_gaussian_grid_local.rst new file mode 100644 index 0000000000..46fac9fab3 --- /dev/null +++ b/doc/src/compute_gaussian_grid_local.rst @@ -0,0 +1,99 @@ +.. index:: compute gaussian/grid/local +.. index:: compute gaussian/grid/local/kk + +compute gaussian/grid/local command +=================================== + +Accelerator Variants: *gaussian/grid/local/kk* + +Syntax +"""""" + +.. code-block:: LAMMPS + + compute ID group-ID gaussian/grid/local grid nx ny nz rcutfac R_1 R_2 ... sigma_1 sigma_2 + +* ID, group-ID are documented in :doc:`compute ` command +* gaussian/grid/local = style name of this compute command +* *grid* values = nx, ny, nz, number of grid points in x, y, and z directions (positive integer) +* *rcutfac* = scale factor applied to all cutoff radii (positive real) +* *R_1, R_2,...* = list of cutoff radii, one for each type (distance units) +* *sigma_1, sigma_2,...* = Gaussian widths, one for each type (distance units) + +Examples +"""""""" + +.. code-block:: LAMMPS + + compute mygrid all gaussian/grid/local grid 40 40 40 4.0 0.5 0.5 0.4 0.4 + +Description +""""""""""" + +.. versionadded:: TBD + +Define a computation that calculates a Gaussian representation of the ionic +structure. This representation is used for the efficient evaluation +of quantities related to the structure factor in a grid-based workflow, +such as the ML-DFT workflow MALA :ref:`(Ellis) `, for which it was originally +implemented. Usage of the workflow is described in a separate publication :ref:`(Fiedler) `. + +For each LAMMPS type, a separate sum of Gaussians is calculated, using +a separate Gaussian broadening per type. The computation +is always performed on the numerical grid, no atom-based version of this +compute exists. The Gaussian representation can only be executed in a local +fashion, thus the output array only contains rows for grid points +that are local to the processor subdomain. The layout of the grid is the same +as for the see :doc:`sna/grid/local ` command. + +Namely, the array contains one row for each of the +local grid points, looping over the global index *ix* fastest, +then *iy*, and *iz* slowest. Each row of the array contains +the global indexes *ix*, *iy*, and *iz* first, followed by the *x*, *y*, +and *z* coordinates of the grid point, followed by the values of the Gaussians +(one floating point number per type per grid point). + +---------- + + +.. include:: accel_styles.rst + + + +---------- + +Output info +""""""""""" + +Compute *gaussian/grid/local* evaluates a local array. +The array contains one row for each of the +local grid points, looping over the global index *ix* fastest, +then *iy*, and *iz* slowest. The array contains math :math:`ntypes+6` columns, +where *ntypes* is the number of LAMMPS types. The first three columns are +the global indexes *ix*, *iy*, and *iz*, followed by the *x*, *y*, +and *z* coordinates of the grid point, followed by the *ntypes* columns +containing the values of the Gaussians for each type. + +Restrictions +"""""""""""" + +These computes are part of the ML-SNAP package. They are only enabled +if LAMMPS was built with that package. See the :doc:`Build package +` page for more info. + +Related commands +"""""""""""""""" + +:doc:`compute sna/grid/local ` + +---------- + +.. _Ellis2021b: + +**(Ellis)** Ellis, Fiedler, Popoola, Modine, Stephens, Thompson, Cangi, Rajamanickam, `Phys. Rev. B, 104, 035120, (2021) `_ + +.. _Fiedler2023: + +**(Fiedler)** Fiedler, Modine, Schmerler, Vogel, Popoola, Thompson, Rajamanickam, and Cangi, +`npj Comp. Mater., 9, 115 (2023) `_ + diff --git a/doc/src/compute_sna_atom.rst b/doc/src/compute_sna_atom.rst index 179c362dc6..2572093499 100644 --- a/doc/src/compute_sna_atom.rst +++ b/doc/src/compute_sna_atom.rst @@ -3,7 +3,9 @@ .. index:: compute snav/atom .. index:: compute snap .. index:: compute sna/grid +.. index:: compute sna/grid/kk .. index:: compute sna/grid/local +.. index:: compute sna/grid/local/kk compute sna/atom command ======================== @@ -20,9 +22,14 @@ compute snap command compute sna/grid command ======================== +compute sna/grid/kk command +=========================== + compute sna/grid/local command ============================== +Accelerator Variants: *sna/grid/local/kk* + Syntax """""" @@ -33,17 +40,17 @@ Syntax compute ID group-ID snav/atom rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ... compute ID group-ID snap rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ... compute ID group-ID snap rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ... - compute ID group-ID sna/grid nx ny nz rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ... - compute ID group-ID sna/grid/local nx ny nz rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ... + compute ID group-ID sna/grid grid nx ny nz rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ... + compute ID group-ID sna/grid/local grid nx ny nz rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ... * ID, group-ID are documented in :doc:`compute ` command * sna/atom = style name of this compute command -* rcutfac = scale factor applied to all cutoff radii (positive real) -* rfac0 = parameter in distance to angle conversion (0 < rcutfac < 1) -* twojmax = band limit for bispectrum components (non-negative integer) -* R_1, R_2,... = list of cutoff radii, one for each type (distance units) -* w_1, w_2,... = list of neighbor weights, one for each type -* nx, ny, nz = number of grid points in x, y, and z directions (positive integer) +* *rcutfac* = scale factor applied to all cutoff radii (positive real) +* *rfac0* = parameter in distance to angle conversion (0 < rcutfac < 1) +* *twojmax* = band limit for bispectrum components (non-negative integer) +* *R_1, R_2,...* = list of cutoff radii, one for each type (distance units) +* *w_1, w_2,...* = list of neighbor weights, one for each type +* *grid* values = nx, ny, nz, number of grid points in x, y, and z directions (positive integer) * zero or more keyword/value pairs may be appended * keyword = *rmin0* or *switchflag* or *bzeroflag* or *quadraticflag* or *chem* or *bnormflag* or *wselfallflag* or *bikflag* or *switchinnerflag* or *sinner* or *dinner* or *dgradflag* or *nnn* or *wmode* or *delta* @@ -103,7 +110,7 @@ Examples compute snap all snap 1.4 0.95 6 2.0 1.0 compute snap all snap 1.0 0.99363 6 3.81 3.83 1.0 0.93 chem 2 0 1 compute snap all snap 1.0 0.99363 6 3.81 3.83 1.0 0.93 switchinnerflag 1 sinner 1.35 1.6 dinner 0.25 0.3 - compute bgrid all sna/grid/local 200 200 200 1.4 0.95 6 2.0 1.0 + compute bgrid all sna/grid/local grid 200 200 200 1.4 0.95 6 2.0 1.0 compute bnnn all sna/atom 9.0 0.99363 8 0.5 1.0 rmin0 0.0 nnn 24 wmode 1 delta 0.2 Description @@ -252,7 +259,8 @@ for finite-temperature Kohn-Sham density functional theory (:ref:`Ellis et al. `) Neighbor atoms not in the group do not contribute to the bispectrum components of the grid points. The distance cutoff :math:`R_{ii'}` assumes that *i* has the same type as the neighbor atom -*i'*. +*i'*. Both computes can be hardware accelerated with Kokkos by using the +*sna/grid/kk* and *sna/grid/local/kk* commands, respectively. Compute *sna/grid* calculates a global array containing bispectrum components for a regular grid of points. @@ -463,6 +471,12 @@ fluctuations in the resulting local atomic environment fingerprint. The detailed formalism is given in the paper by Lafourcade et al. :ref:`(Lafourcade) `. +---------- + + +.. include:: accel_styles.rst + + ---------- Output info @@ -654,7 +668,7 @@ of Angular Momentum, World Scientific, Singapore (1987). .. _Ellis2021: -**(Ellis)** Ellis, Fiedler, Popoola, Modine, Stephens, Thompson, Cangi, Rajamanickam, Phys Rev B, 104, 035120, (2021) +**(Ellis)** Ellis, Fiedler, Popoola, Modine, Stephens, Thompson, Cangi, Rajamanickam, `Phys. Rev. B, 104, 035120, (2021) `_ .. _Lafourcade2023_2: diff --git a/doc/src/fix_python_invoke.rst b/doc/src/fix_python_invoke.rst index ad55882270..4f33f5483b 100644 --- a/doc/src/fix_python_invoke.rst +++ b/doc/src/fix_python_invoke.rst @@ -66,6 +66,15 @@ gives access to the LAMMPS state from Python. from these callbacks, trying to execute input script commands will in the best case not work or in the worst case result in undefined behavior. +Restart, fix_modify, output, run start/stop, minimize info +""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" + +No information about this fix is written to :doc:`binary restart files `. None of the :doc:`fix_modify ` options +are relevant to this fix. No global or per-atom quantities are stored +by this fix for access by various :doc:`output commands `. +No parameter of this fix can be used with the *start/stop* keywords of +the :doc:`run ` command. This fix is not invoked during :doc:`energy minimization `. + Restrictions """""""""""" diff --git a/doc/src/fix_reaxff_species.rst b/doc/src/fix_reaxff_species.rst index 107695f0f6..068d1de995 100644 --- a/doc/src/fix_reaxff_species.rst +++ b/doc/src/fix_reaxff_species.rst @@ -200,8 +200,8 @@ The 2 values in the global vector are as follows: The per-atom vector stores the molecule ID for each atom as identified by the fix. If an atom is not in a molecule, its ID will be 0. For atoms in the same molecule, the molecule ID for all of them -will be the same and will be equal to the smallest atom ID of -any atom in the molecule. +will be the same, and molecule IDs will range from 1 to the number +of molecules. No parameter of this fix can be used with the *start/stop* keywords of the :doc:`run ` command. diff --git a/doc/src/fix_wall_gran.rst b/doc/src/fix_wall_gran.rst index 25d659241c..81a411ffc8 100644 --- a/doc/src/fix_wall_gran.rst +++ b/doc/src/fix_wall_gran.rst @@ -222,10 +222,10 @@ restart file, so that the operation of the fix continues in an uninterrupted fashion. If the :code:`contacts` option is used, this fix generates a per-atom array -with 8 columns as output, containing the contact information for owned +with at least 8 columns as output, containing the contact information for owned particles (nlocal on each processor). All columns in this per-atom array will -be zero if no contact has occurred. The values of these columns are listed in -the following table: +be zero if no contact has occurred. The first 8 values of these columns are +listed in the following table. +-------+----------------------------------------------------+----------------+ | Index | Value | Units | @@ -248,6 +248,14 @@ the following table: | 8 | Radius :math:`r` of atom | distance units | +-------+----------------------------------------------------+----------------+ +If a granular sub-model calculates additional contact information (e.g. the +heat sub-models calculate the amount of heat exchanged), these quantities +are appended to the end of this array. First, any extra values from the +normal sub-model are appended followed by the damping, tangential, rolling, +twisting, then heat models. See the descriptions of granular sub-models in +the :doc:`pair granular ` page for information on any extra +quantities. + None of the :doc:`fix_modify ` options are relevant to this fix. No parameter of this fix can be used with the *start/stop* keywords of the :doc:`run ` command. This fix is not invoked during :doc:`energy diff --git a/doc/src/fix_wall_gran_region.rst b/doc/src/fix_wall_gran_region.rst index 0a4343493b..4ad3b9d6c5 100644 --- a/doc/src/fix_wall_gran_region.rst +++ b/doc/src/fix_wall_gran_region.rst @@ -243,10 +243,10 @@ uninterrupted fashion. with a different region ID. If the :code:`contacts` option is used, this fix generates a per-atom array -with 8 columns as output, containing the contact information for owned +with at least 8 columns as output, containing the contact information for owned particles (nlocal on each processor). All columns in this per-atom array will -be zero if no contact has occurred. The values of these columns are listed in -the following table: +be zero if no contact has occurred. The first 8 values of these columns are +listed in the following table. +-------+----------------------------------------------------+----------------+ | Index | Value | Units | @@ -269,6 +269,14 @@ the following table: | 8 | Radius :math:`r` of atom | distance units | +-------+----------------------------------------------------+----------------+ +If a granular sub-model calculates additional contact information (e.g. the +heat sub-models calculate the amount of heat exchanged), these quantities +are appended to the end of this array. First, any extra values from the +normal sub-model are appended followed by the damping, tangential, rolling, +twisting, then heat models. See the descriptions of granular sub-models in +the :doc:`pair granular ` page for information on any extra +quantities. + None of the :doc:`fix_modify ` options are relevant to this fix. No parameter of this fix can be used with the *start/stop* keywords of the :doc:`run ` command. This fix is not invoked during :doc:`energy diff --git a/doc/src/kspace_modify.rst b/doc/src/kspace_modify.rst index c40ba70ef0..b300213a3b 100644 --- a/doc/src/kspace_modify.rst +++ b/doc/src/kspace_modify.rst @@ -412,11 +412,9 @@ slab correction has also been extended to point dipole interactions .. note:: If you wish to apply an electric field in the Z-direction, in - conjunction with the *slab* keyword, you should do it by adding - explicit charged particles to the +/- Z surfaces. If you do it via - the :doc:`fix efield ` command, it will not give the correct - dielectric constant due to the Yeh/Berkowitz :ref:`(Yeh) ` correction - not being compatible with how :doc:`fix efield ` works. + conjunction with the *slab* keyword, you can do it either by + adding explicit oppositely charged particles to the +/- Z surfaces, + or by using the :doc:`fix efield ` command. ---------- diff --git a/doc/src/pair_granular.rst b/doc/src/pair_granular.rst index 11a460e9ca..f54079daf1 100644 --- a/doc/src/pair_granular.rst +++ b/doc/src/pair_granular.rst @@ -40,6 +40,9 @@ Examples pair_style granular pair_coeff * * hertz 1000.0 50.0 tangential mindlin 1000.0 1.0 0.4 heat area 0.1 + pair_style granular + pair_coeff * * mdr 5e6 0.4 1.9e5 2.0 0.5 0.5 tangential linear_history 940.0 0.0 0.7 rolling sds 2.7e5 0.0 0.6 damping none + Description """"""""""" @@ -82,6 +85,7 @@ and their required arguments are: 3. *hertz/material* : E, :math:`\eta_{n0}` (or :math:`e`), :math:`\nu` 4. *dmt* : E, :math:`\eta_{n0}` (or :math:`e`), :math:`\nu`, :math:`\gamma` 5. *jkr* : E, :math:`\eta_{n0}` (or :math:`e`), :math:`\nu`, :math:`\gamma` +6. *mdr* : :math:`E`, :math:`\nu`, :math:`Y`, :math:`\Delta\gamma`, :math:`\psi_b`, :math:`e` Here, :math:`k_n` is spring stiffness (with units that depend on model choice, see below); :math:`\eta_{n0}` is a damping prefactor (or, in its @@ -162,6 +166,144 @@ initially will not experience force until they come into contact experience a tensile force up to :math:`3\pi\gamma R`, at which point they lose contact. +The *mdr* model is a mechanically-derived contact model designed to capture the +contact response between adhesive elastic-plastic particles into large deformation. +The theoretical foundations of the *mdr* model are detailed in the +two-part series :ref:`Zunker and Kamrin Part I ` and +:ref:`Zunker and Kamrin Part II `. Further development +and demonstrations of its application to industrially relevant powder +compaction processes are presented in :ref:`Zunker et al. `. + +The model requires the following inputs: + + 1. *Young's modulus* :math:`E > 0` : The Young's modulus is commonly reported + for various powders. + + 2. *Poisson's ratio* :math:`0 \le \nu \le 0.5` : The Poisson's ratio is commonly + reported for various powders. + + 3. *Yield stress* :math:`Y \ge 0` : The yield stress is often known for powders + composed of materials such as metals but may be unreported for ductile organic + materials, in which case it can be treated as a free parameter. + + 4. *Effective surface energy* :math:`\Delta\gamma \ge 0` : The effective surface + energy for powder compaction applications is most easily determined through its + relation to the more commonly reported critical stress intensity factor + :math:`K_{Ic} = \sqrt{2\Delta\gamma E/(1-\nu^2)}`. + + 5. *Critical confinement ratio* :math:`0 \le \psi_b \le 1` : The critical confinement + ratio is a tunable parameter that determines when the bulk elastic response is + triggered. Lower values of :math:`\psi_b` delay the onset of the bulk elastic + response. + + 6. *Coefficient of restitution* :math:`0 \le e \le 1` : The coefficient of + restitution is a tunable parameter that controls damping in the normal direction. + +.. note:: + + The values for :math:`E`, :math:`\nu`, :math:`Y`, and :math:`\Delta\gamma` (i.e., + :math:`K_{Ic}`) should be selected for zero porosity to reflect the intrinsic + material property rather than the bulk powder property. + +The *mdr* model produces a nonlinear force-displacement response, therefore the +critical timestep :math:`\Delta t` depends on the inputs and level of +deformation. As a conservative starting point the timestep can be assumed to be +dictated by the bulk elastic response such that +:math:`\Delta t = 0.35\sqrt{m/k_\textrm{bulk}}`, where :math:`m` is the mass of +the smallest particle and :math:`k_\textrm{bulk} = \kappa R_\textrm{min}` is an +effective stiffness related to the bulk elastic response. +Here, :math:`\kappa = E/(3(1-2\nu))` is the bulk modulus and +:math:`R_\textrm{min}` is the radius of the smallest particle. + +.. note:: + + The *mdr* model requires some specific settings to function properly, + please read the following text carefully to ensure all requirements are + followed. + +The *atom_style* must be set to *sphere 1* to enable dynamic particle +radii. The *mdr* model is designed to respect the incompressibility of +plastic deformation and inherently tracks free surface displacements +induced by all particle contacts. In practice, this means that all particles +begin with an initial radius, however as compaction occurs and plastic +deformation is accumulated, a new enlarged apparent radius is defined to +ensure that that volume change due to plastic deformation is not lost. +This apparent radius is stored as the *atom radius* meaning it is used +for subsequent neighbor list builds and contact detection checks. The +advantage of this is that multi-neighbor dependent effects such as +formation of secondary contacts caused by radial expansion are captured +by the *mdr* model. Setting *atom_style sphere 1* ensures that updates to +the particle radii are properly reflected throughout the simulation. + +.. code-block:: LAMMPS + + atom_style sphere 1 + +Newton's third law must be set to *off*. This ensures that the neighbor lists +are constructed properly for the topological penalty algorithm used to screen +for non-physical contacts occurring through obstructing particles, an issue +prevalent under large deformation conditions. For more information on this +algorithm see :ref:`Zunker et al. `. + +.. code-block:: LAMMPS + + newton off + +The damping model must be set to *none*. The *mdr* model already has a built +in damping model. + +.. code-block:: LAMMPS + + pair_coeff * * mdr 5e6 0.4 1.9e5 2 0.5 0.5 damping none + +The definition of multiple *mdr* models in the *pair_style* is currently not +supported. Similarly, the *mdr* model cannot be combined with a different normal +model in the *pair_style*. Physically this means that only one homogeneous +collection of particles governed by a single *mdr* model is allowed. + +The *mdr* model currently only supports *fix wall/gran/region*, not +*fix wall/gran*. If the *mdr* model is specified for the *pair_style* +any *fix wall/gran/region* commands must also use the *mdr* model. +Additionally, the following *mdr* inputs must match between the +*pair_style* and *fix wall/gran/region* definitions: :math:`E`, +:math:`\nu`, :math:`Y`, :math:`\psi_b`, and :math:`e`. The exception +is :math:`\Delta\gamma`, which may vary, permitting different +adhesive behaviors between particle-particle and particle-wall interactions. + +.. note:: + + The *mdr* model has a number of custom *property/atom* and *pair/local* definitions that + can be called in the input file. The useful properties for visualization + and analysis are described below. + +In addition to contact forces the *mdr* model also tracks the following +quantities for each particle: elastic volume change, average normal +stress components, total surface area involved in +contact, and individual contact areas. In the input script, these quantities are +initialized by calling *run 0* and can then be accessed using subsequent *compute* +commands. The last *compute* command uses *pair/local p13* to calculate the pairwise +contact areas for each active contact in the *group-ID*. Due to the use of an apparent +radius in the *mdr* model, the keyword/arg pair *cutoff radius* must be specified for +*pair/local* to properly detect existing contacts. + +.. code-block:: LAMMPS + + run 0 + compute ID group-ID property/atom d_Velas + compute ID group-ID property/atom d_sigmaxx + compute ID group-ID property/atom d_sigmayy + compute ID group-ID property/atom d_sigmazz + compute ID group-ID property/atom d_Acon1 + compute ID group-ID pair/local p13 cutoff radius + +.. note:: + + The *mdr* model has two example input scripts within the + *examples/granular* directory. The first is a die compaction + simulation involving 200 particles named *in.tableting.200*. + The second is a triaxial compaction simulation involving 12 + particles named *in.triaxial.compaction.12*. + ---------- In addition, the normal force is augmented by a damping term of the @@ -674,7 +816,10 @@ supported are: 2. *radius* : :math:`k_{s}` 3. *area* : :math:`h_{s}` -If the *heat* keyword is not specified, the model defaults to *none*. +If the *heat* keyword is not specified, the model defaults to *none*. All +heat models calculate an additional pairwise quantity accessible by the +single() function (described below) which is the heat conducted between the +two particles. For *heat* *radius*, the heat :math:`Q` conducted between two particles is given by @@ -789,7 +934,7 @@ The single() function of these pair styles returns 0.0 for the energy of a pairwise interaction, since energy is not conserved in these dissipative potentials. It also returns only the normal component of the pairwise interaction force. However, the single() function also -calculates 13 extra pairwise quantities. The first 3 are the +calculates at least 13 extra pairwise quantities. The first 3 are the components of the tangential force between particles I and J, acting on particle I. The fourth is the magnitude of this tangential force. The next 3 (5-7) are the components of the rolling torque acting on @@ -797,9 +942,17 @@ particle I. The next entry (8) is the magnitude of the rolling torque. The next entry (9) is the magnitude of the twisting torque acting about the vector connecting the two particle centers. The next 3 (10-12) are the components of the vector connecting -the centers of the two particles (x_I - x_J). The last quantity (13) -is the heat flow between the two particles, set to 0 if no heat model -is active. +the centers of the two particles (x_I - x_J). If a granular sub-model +calculates additional contact information (e.g. the heat sub-models +calculate the amount of heat exchanged), these quantities are appended +to the end of this list. First, any extra values from the normal sub-model +are appended followed by the damping, tangential, rolling, twisting, then +heat models. See the descriptions of specific granular sub-models above +for information on any extra quantities. If two or more models are +defined by pair coefficients, the size of the array is set by the +maximum number of extra quantities in a model but the order of quantities +is determined by each model's specific set of sub-models. Any unused +quantities are zeroed. These extra quantities can be accessed by the :doc:`compute pair/local ` command, as *p1*, *p2*, ..., *p12*\ . @@ -870,10 +1023,32 @@ solids. Proc. R. Soc. Lond. A, 324(1558), 301-313. .. _DMT1975: -**Derjaguin et al, 1975)** Derjaguin, B. V., Muller, V. M., & Toporov, +**(Derjaguin et al, 1975)** Derjaguin, B. V., Muller, V. M., & Toporov, Y. P. (1975). Effect of contact deformations on the adhesion of particles. Journal of Colloid and interface science, 53(2), 314-326. +.. _Zunker2024I: + +**(Zunker and Kamrin, 2024)** Zunker, W., & Kamrin, K. (2024). +A mechanically-derived contact model for adhesive elastic-perfectly +plastic particles, Part I: Utilizing the method of dimensionality +reduction. Journal of the Mechanics and Physics of Solids, 183, 105492. + +.. _Zunker2024II: + +**(Zunker and Kamrin, 2024)** Zunker, W., & Kamrin, K. (2024). +A mechanically-derived contact model for adhesive elastic-perfectly +plastic particles, Part II: Contact under high compaction-modeling +a bulk elastic response. Journal of the Mechanics and Physics of Solids, +183, 105493. + +.. _Zunker2025: + +**(Zunker et al, 2025)** Zunker, W., Dunatunga, S., Thakur, S., +Tang, P., & Kamrin, K. (2025). Experimentally validated DEM for large +deformation powder compaction: mechanically-derived contact model and +screening of non-physical contacts. + .. _Luding2008: **(Luding, 2008)** Luding, S. (2008). Cohesive, frictional powders: diff --git a/doc/src/pair_hbond_dreiding.rst b/doc/src/pair_hbond_dreiding.rst index ce19ff9e38..e059fdf2ba 100644 --- a/doc/src/pair_hbond_dreiding.rst +++ b/doc/src/pair_hbond_dreiding.rst @@ -1,30 +1,46 @@ .. index:: pair_style hbond/dreiding/lj .. index:: pair_style hbond/dreiding/lj/omp +.. index:: pair_style hbond/dreiding/lj/angleoffset +.. index:: pair_style hbond/dreiding/lj/angleoffset/omp .. index:: pair_style hbond/dreiding/morse .. index:: pair_style hbond/dreiding/morse/omp +.. index:: pair_style hbond/dreiding/morse/angleoffset +.. index:: pair_style hbond/dreiding/morse/angleoffset/omp pair_style hbond/dreiding/lj command ==================================== Accelerator Variants: *hbond/dreiding/lj/omp* +pair_style hbond/dreiding/lj/angleoffset command +================================================ + +Accelerator Variants: *hbond/dreiding/lj/angleoffset/omp* + pair_style hbond/dreiding/morse command ======================================= Accelerator Variants: *hbond/dreiding/morse/omp* +pair_style hbond/dreiding/morse/angleoffset command +=================================================== + +Accelerator Variants: *hbond/dreiding/morse/angleoffset/omp* + + Syntax """""" .. code-block:: LAMMPS - pair_style style N inner_distance_cutoff outer_distance_cutoff angle_cutoff + pair_style style N inner_distance_cutoff outer_distance_cutoff angle_cutoff equilibrium_angle -* style = *hbond/dreiding/lj* or *hbond/dreiding/morse* +* style = *hbond/dreiding/lj* or *hbond/dreiding/morse* or *hbond/dreiding/lj/angleoffset* or *hbond/dreiding/morse/angleoffset* * N = power of cosine of angle theta (integer) * inner_distance_cutoff = global inner cutoff for Donor-Acceptor interactions (distance units) * outer_distance_cutoff = global cutoff for Donor-Acceptor interactions (distance units) * angle_cutoff = global angle cutoff for Acceptor-Hydrogen-Donor interactions (degrees) +* (with style angleoffset) equilibrium_angle = global equilibrium angle for Acceptor-Hydrogen-Donor interactions (degrees) Examples """""""" @@ -40,6 +56,9 @@ Examples labelmap atom 1 C 2 O 3 H pair_coeff C O hbond/dreiding/morse H i 3.88 1.7241379 2.9 2 9.0 11.0 90.0 + pair_style hybrid/overlay lj/cut 10.0 hbond/dreiding/lj 4 9.0 11.0 90 170.0 + pair_coeff 1 2 hbond/dreiding/lj 3 i 9.5 2.75 4 9.0 11.0 90.0 + Description """"""""""" @@ -74,42 +93,53 @@ hydrogen (H) and the donor atoms: .. image:: JPG/dreiding_hbond.jpg :align: center -These 3-body interactions can be defined for pairs of acceptor and -donor atoms, based on atom types. For each donor/acceptor atom pair, -the third atom in the interaction is a hydrogen permanently bonded to -the donor atom, e.g. in a bond list read in from a data file via the +These 3-body interactions can be defined for pairs of acceptor and donor +atoms, based on atom types. For each donor/acceptor atom pair, the +third atom in the interaction is a hydrogen permanently bonded to the +donor atom, e.g. in a bond list read in from a data file via the :doc:`read_data ` command. The atom types of possible hydrogen atoms for each donor/acceptor type pair are specified by the :doc:`pair_coeff ` command (see below). Style *hbond/dreiding/lj* is the original DREIDING potential of -:ref:`(Mayo) `. It uses a LJ 12/10 functional for the Donor-Acceptor -interactions. To match the results in the original paper, use n = 4. +:ref:`(Mayo) `. It uses a LJ 12/10 functional for the +Donor-Acceptor interactions. To match the results in the original paper, +use n = 4. Style *hbond/dreiding/morse* is an improved version using a Morse potential for the Donor-Acceptor interactions. :ref:`(Liu) ` showed that the Morse form gives improved results for Dendrimer simulations, when n = 2. +.. versionadded:: TBD + +The style variants *hbond/dreiding/lj/angleoffset* and +*hbond/dreiding/lj/angleoffset* take the equilibrium angle of the AHD as +input, allowing it to reach 180 degrees. This variant option was added +to account for cases (especially in some coarse-grained models) in which +the equilibrium state of the bonds may equal the minimum energy state. + See the :doc:`Howto bioFF ` page for more information on the DREIDING force field. .. note:: - Because the Dreiding hydrogen bond potential is only one portion - of an overall force field which typically includes other pairwise - interactions, it is common to use it as a sub-style in a :doc:`pair_style hybrid/overlay ` command, where another pair style - provides the repulsive core interaction between pairs of atoms, e.g. a - 1/r\^12 Lennard-Jones repulsion. + Because the Dreiding hydrogen bond potential is only one portion of + an overall force field which typically includes other pairwise + interactions, it is common to use it as a sub-style in a + :doc:`pair_style hybrid/overlay ` command, where another + pair style provides the repulsive core interaction between pairs of + atoms, e.g. a 1/r\^12 Lennard-Jones repulsion. .. note:: - When using the hbond/dreiding pair styles with :doc:`pair_style hybrid/overlay `, you should explicitly define pair + When using the hbond/dreiding pair styles with :doc:`pair_style + hybrid/overlay `, you should explicitly define pair interactions between the donor atom and acceptor atoms, (as well as between these atoms and ALL other atoms in your system). Whenever - :doc:`pair_style hybrid/overlay ` is used, ordinary mixing - rules are not applied to atoms like the donor and acceptor atoms - because they are typically referenced in multiple pair styles. + :doc:`pair_style hybrid/overlay ` is used, ordinary + mixing rules are not applied to atoms like the donor and acceptor + atoms because they are typically referenced in multiple pair styles. Neglecting to do this can cause difficult-to-detect physics problems. .. note:: @@ -119,6 +149,13 @@ on the DREIDING force field. special_bonds command (e.g. "special_bonds lj 0.0 0.0 1.0") to turn these interactions on. +.. note:: + + For the *angleoffset* variants, the referenced angle offset is the + supplementary angle of the equilibrium angle parameter. It means if + the equilibrium angle is 166.6 degrees, the calculated angle offset + is 13.4 degrees. + ---------- The following coefficients must be defined for pairs of eligible @@ -169,7 +206,10 @@ follows: * distance cutoff :math:`r_{out}` (distance units) * angle cutoff (degrees) -A single hydrogen atom type K can be specified, or a wild-card asterisk +For both the *hbond/dreiding/lj/angleoffset* and *hbond/dreiding/morse/angleoffset* styles an additional parameter is added: +* equilibrium angle (degrees) + +For all styles, a single hydrogen atom type K can be specified, or a wild-card asterisk can be used in place of or in conjunction with the K arguments to select multiple types as hydrogen atoms. This takes the form "\*" or "\*n" or "n\*" or "m\*n". See the :doc:`pair_coeff ` @@ -245,8 +285,7 @@ heading) the following commands could be included in an input script: Restrictions """""""""""" -This pair style can only be used if LAMMPS was built with the -MOLECULE package. See the :doc:`Build package ` doc page +The base pair styles can only be used if LAMMPS was built with the MOLECULE package. The *angleoffset* variant also requires the EXTRA-MOLECULE package. See the :doc:`Build package ` doc page for more info. Related commands diff --git a/doc/src/pair_mliap.rst b/doc/src/pair_mliap.rst index e325de0aa6..7f8b36bb83 100644 --- a/doc/src/pair_mliap.rst +++ b/doc/src/pair_mliap.rst @@ -145,6 +145,7 @@ per line. The detail of *nn* module implementation can be found at :ref:`(Yanxon) `. .. admonition:: Notes on mliappy models + :class: note When the *model* keyword is *mliappy*, if the filename ends in '.pt', or '.pth', it will be loaded using pytorch; otherwise, it will be diff --git a/doc/src/pair_reaxff.rst b/doc/src/pair_reaxff.rst index 495572dc0e..45532bc2a6 100644 --- a/doc/src/pair_reaxff.rst +++ b/doc/src/pair_reaxff.rst @@ -158,11 +158,36 @@ drops to zero. Optional keywords *safezone*, *mincap*, and *minhbonds* are used for allocating reaxff arrays. Increasing these values can avoid memory problems, such as segmentation faults and bondchk failed errors, that -could occur under certain conditions. These keywords are not used by +could occur under certain conditions. These keywords are **not** used by the Kokkos version, which instead uses a more robust memory allocation scheme that checks if the sizes of the arrays have been exceeded and automatically allocates more memory. +.. admonition:: Memory management problems with ReaxFF + :class: tip + + The LAMMPS implementation of ReaxFF is adapted from a standalone MD + program written in C called `PuReMD + `_. It inherits from this code + a heuristic memory management that is different from what the rest of + LAMMPS uses. It assumes that a system is dense and already well + equilibrated, so that there are no large changes in how many and what + types of neighbors atoms have. However, not all systems are like + that, and thus there can be errors or segmentation faults if the + system changes too much. If you run into problems, here are three + options to avoid them: + + - Use the KOKKOS version of ReaxFF (KOKKOS is not only for GPUs, + but can also be compiled for serial or OpenMP execution) which + uses a different memory management approach. + - Break down a run command during which memory related errors happen + into multiple smaller segments so that the memory management + heuristics are re-initialized for each segment before they become + invalid. + - Increase the values for *safezone*, *mincap*, and *minhbonds* as + needed. This can lead to significant increase of memory consumption + through. + The keyword *tabulate* controls the size of interpolation table for Lennard-Jones and Coulomb interactions. Tabulation may also be set in the control file (see below). If tabulation is set in both the input script and the diff --git a/doc/src/pair_style.rst b/doc/src/pair_style.rst index 93e02422d2..bdf06d6b66 100644 --- a/doc/src/pair_style.rst +++ b/doc/src/pair_style.rst @@ -207,7 +207,9 @@ accelerated styles exist. * :doc:`gw/zbl ` - Gao-Weber potential with a repulsive ZBL core * :doc:`harmonic/cut ` - repulsive-only harmonic potential * :doc:`hbond/dreiding/lj ` - DREIDING hydrogen bonding LJ potential +* :doc:`hbond/dreiding/lj/angleoffset ` - DREIDING hydrogen bonding LJ potential with offset for hbond angle * :doc:`hbond/dreiding/morse ` - DREIDING hydrogen bonding Morse potential +* :doc:`hbond/dreiding/morse/angleoffset ` - DREIDING hydrogen bonding Morse potential with offset for hbond angle * :doc:`hdnnp ` - High-dimensional neural network potential * :doc:`hippo ` - * :doc:`ilp/graphene/hbn ` - registry-dependent interlayer potential (ILP) diff --git a/doc/src/variable.rst b/doc/src/variable.rst index 3ec3ce4a65..2b59aeb65d 100644 --- a/doc/src/variable.rst +++ b/doc/src/variable.rst @@ -56,7 +56,7 @@ Syntax random(x,y,z), normal(x,y,z), ceil(x), floor(x), round(x), ternary(x,y,z), ramp(x,y), stagger(x,y), logfreq(x,y,z), logfreq2(x,y,z), logfreq3(x,y,z), stride(x,y,z), stride2(x,y,z,a,b,c), - vdisplace(x,y), swiggle(x,y,z), cwiggle(x,y,z) + vdisplace(x,y), swiggle(x,y,z), cwiggle(x,y,z), sign(x) group functions = count(group), mass(group), charge(group), xcm(group,dim), vcm(group,dim), fcm(group,dim), bound(group,dir), gyration(group), ke(group), @@ -532,37 +532,37 @@ functions, special functions, feature functions, atom values, atom vectors, custom atom properties, compute references, fix references, and references to other variables. -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Number | 0.2, 100, 1.0e20, -15.4, etc | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Constant | PI, version, on, off, true, false, yes, no | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Thermo keywords | vol, pe, ebond, etc | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Math operators | (), -x, x+y, x-y, x\*y, x/y, x\^y, x%y, x == y, x != y, x < y, x <= y, x > y, x >= y, x && y, x \|\| y, x \|\^ y, !x | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Math functions | sqrt(x), exp(x), ln(x), log(x), abs(x), sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), atan2(y,x), random(x,y,z), normal(x,y,z), ceil(x), floor(x), round(x), ternary(x,y,z), ramp(x,y), stagger(x,y), logfreq(x,y,z), logfreq2(x,y,z), logfreq3(x,y,z), stride(x,y,z), stride2(x,y,z,a,b,c), vdisplace(x,y), swiggle(x,y,z), cwiggle(x,y,z) | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Group functions | count(ID), mass(ID), charge(ID), xcm(ID,dim), vcm(ID,dim), fcm(ID,dim), bound(ID,dir), gyration(ID), ke(ID), angmom(ID,dim), torque(ID,dim), inertia(ID,dimdim), omega(ID,dim) | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Region functions | count(ID,IDR), mass(ID,IDR), charge(ID,IDR), xcm(ID,dim,IDR), vcm(ID,dim,IDR), fcm(ID,dim,IDR), bound(ID,dir,IDR), gyration(ID,IDR), ke(ID,IDR), angmom(ID,dim,IDR), torque(ID,dim,IDR), inertia(ID,dimdim,IDR), omega(ID,dim,IDR) | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Special functions | sum(x), min(x), max(x), ave(x), trap(x), slope(x), sort(x), rsort(x), gmask(x), rmask(x), grmask(x,y), next(x), is_file(name), is_os(name), extract_setting(name), label2type(kind,label), is_typelabel(kind,label), is_timeout() | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Feature functions | is_available(category,feature), is_active(category,feature), is_defined(category,id) | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Atom values | id[i], mass[i], type[i], mol[i], x[i], y[i], z[i], vx[i], vy[i], vz[i], fx[i], fy[i], fz[i], q[i] | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Atom vectors | id, mass, type, mol, x, y, z, vx, vy, vz, fx, fy, fz, q | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Custom atom properties | i_name, d_name, i_name[i], d_name[i], i2_name[i], d2_name[i], i2_name[i][j], d_name[i][j] | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Compute references | c_ID, c_ID[i], c_ID[i][j], C_ID, C_ID[i] | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Fix references | f_ID, f_ID[i], f_ID[i][j], F_ID, F_ID[i] | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Other variables | v_name, v_name[i] | -+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Number | 0.2, 100, 1.0e20, -15.4, etc | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Constant | PI, version, on, off, true, false, yes, no | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Thermo keywords | vol, pe, ebond, etc | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Math operators | (), -x, x+y, x-y, x\*y, x/y, x\^y, x%y, x == y, x != y, x < y, x <= y, x > y, x >= y, x && y, x \|\| y, x \|\^ y, !x | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Math functions | sqrt(x), exp(x), ln(x), log(x), abs(x), sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), atan2(y,x), random(x,y,z), normal(x,y,z), ceil(x), floor(x), round(x), ternary(x,y,z), ramp(x,y), stagger(x,y), logfreq(x,y,z), logfreq2(x,y,z), logfreq3(x,y,z), stride(x,y,z), stride2(x,y,z,a,b,c), vdisplace(x,y), swiggle(x,y,z), cwiggle(x,y,z), sign(x) | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Group functions | count(ID), mass(ID), charge(ID), xcm(ID,dim), vcm(ID,dim), fcm(ID,dim), bound(ID,dir), gyration(ID), ke(ID), angmom(ID,dim), torque(ID,dim), inertia(ID,dimdim), omega(ID,dim) | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Region functions | count(ID,IDR), mass(ID,IDR), charge(ID,IDR), xcm(ID,dim,IDR), vcm(ID,dim,IDR), fcm(ID,dim,IDR), bound(ID,dir,IDR), gyration(ID,IDR), ke(ID,IDR), angmom(ID,dim,IDR), torque(ID,dim,IDR), inertia(ID,dimdim,IDR), omega(ID,dim,IDR) | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Special functions | sum(x), min(x), max(x), ave(x), trap(x), slope(x), sort(x), rsort(x), gmask(x), rmask(x), grmask(x,y), next(x), is_file(name), is_os(name), extract_setting(name), label2type(kind,label), is_typelabel(kind,label), is_timeout() | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Feature functions | is_available(category,feature), is_active(category,feature), is_defined(category,id) | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Atom values | id[i], mass[i], type[i], mol[i], x[i], y[i], z[i], vx[i], vy[i], vz[i], fx[i], fy[i], fz[i], q[i] | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Atom vectors | id, mass, type, mol, x, y, z, vx, vy, vz, fx, fy, fz, q | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Custom atom properties | i_name, d_name, i_name[i], d_name[i], i2_name[i], d2_name[i], i2_name[i][j], d_name[i][j] | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Compute references | c_ID, c_ID[i], c_ID[i][j], C_ID, C_ID[i] | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Fix references | f_ID, f_ID[i], f_ID[i][j], F_ID, F_ID[i] | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Other variables | v_name, v_name[i] | ++------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ Most of the formula elements produce a scalar value. Some produce a global or per-atom vector of values. Global vectors can be produced @@ -860,6 +860,9 @@ run, according to one of these formulas, where omega = 2 PI / period: where dt = the timestep size. +The sign(x) function returns 1.0 if the value is greater than or equal +to 0.0, and -1.0 otherwise. + The run begins on startstep. Startstep can span multiple runs, using the *start* keyword of the :doc:`run ` command. See the :doc:`run ` command for details of how to do this. Note that the diff --git a/doc/utils/sphinx-config/false_positives.txt b/doc/utils/sphinx-config/false_positives.txt index f272af6dec..f9fb3a0f8a 100644 --- a/doc/utils/sphinx-config/false_positives.txt +++ b/doc/utils/sphinx-config/false_positives.txt @@ -108,6 +108,7 @@ Andrienko Andzelm Ang anglegrad +angleoffset angletangrad angmom angmomx @@ -1236,6 +1237,7 @@ fp fphi fPIC fplo +fprintf Fqq Fraige framerate @@ -1582,6 +1584,7 @@ Impropers imulator includelink incompressible +incompressibility incrementing indenter indenters @@ -1761,6 +1764,7 @@ Kadiri Kai Kalia Kamberaj +Kamrin Kantorovich Kapfer Kapil @@ -2531,6 +2535,7 @@ Nevery Nevins newfile Newns +newstep newtype nextsort Neyts @@ -3380,6 +3385,7 @@ Schilfgarde Schimansky Schiotz Schlitter +Schmerler Schmid Schnieders Schoen @@ -3729,6 +3735,7 @@ tgnpt tgnvt th Thakkar +Thakur Thaokar thb thei @@ -3767,6 +3774,7 @@ Tigran Tij Tildesley Timan +timeflag timeI timespan timestamp @@ -3829,6 +3837,7 @@ Tref Tretyakov tri triangleflag +triaxial Tribello triclinic Triclinic @@ -4042,6 +4051,7 @@ VMDARCH VMDHOME vn Voigt +Vogel volfactor Volkov Volpe diff --git a/examples/COUPLE/plugin/liblammpsplugin.c b/examples/COUPLE/plugin/liblammpsplugin.c index 99e38df32b..619b8828fc 100644 --- a/examples/COUPLE/plugin/liblammpsplugin.c +++ b/examples/COUPLE/plugin/liblammpsplugin.c @@ -118,6 +118,9 @@ liblammpsplugin_t *liblammpsplugin_load(const char *lib) ADDSYM(set_internal_variable); ADDSYM(variable_info); ADDSYM(eval); + ADDSYM(clearstep_compute); + ADDSYM(addstep_compute); + ADDSYM(addstep_compute_all); ADDSYM(gather_atoms); ADDSYM(gather_atoms_concat); diff --git a/examples/COUPLE/plugin/liblammpsplugin.h b/examples/COUPLE/plugin/liblammpsplugin.h index dd1c9628f5..c765b0adc3 100644 --- a/examples/COUPLE/plugin/liblammpsplugin.h +++ b/examples/COUPLE/plugin/liblammpsplugin.h @@ -164,6 +164,9 @@ struct _liblammpsplugin { int (*set_internal_variable)(void *, const char *, double); int (*variable_info)(void *, int, char *, int); double (*eval)(void *, const char *); + void (*clearstep_compute)(void *); + void (*addstep_compute)(void *, void *); + void (*addstep_compute_all)(void *, void *); void (*gather_atoms)(void *, const char *, int, int, void *); void (*gather_atoms_concat)(void *, const char *, int, int, void *); diff --git a/examples/COUPLE/plugin/simple.c b/examples/COUPLE/plugin/simple.c index 9151f92848..5e7c2e98f5 100644 --- a/examples/COUPLE/plugin/simple.c +++ b/examples/COUPLE/plugin/simple.c @@ -21,6 +21,7 @@ #include +#include #include #include #include @@ -63,7 +64,7 @@ int main(int narg, char **arg) nprocs_lammps = atoi(arg[1]); if (nprocs_lammps > nprocs) { if (me == 0) - printf("ERROR: LAMMPS cannot use more procs than available\n"); + printf("ERROR: LAMMPS cannot use more procs than available: %d\n", nprocs); MPI_Abort(MPI_COMM_WORLD,1); } @@ -76,7 +77,7 @@ int main(int narg, char **arg) if (me == 0) { fp = fopen(arg[2],"r"); if (fp == NULL) { - printf("ERROR: Could not open LAMMPS input script\n"); + printf("ERROR: Could not open LAMMPS input script %s: %s\n", arg[2], strerror(errno)); MPI_Abort(MPI_COMM_WORLD,1); } } @@ -87,9 +88,10 @@ int main(int narg, char **arg) all LAMMPS procs call lammps_command() on the line */ if (lammps == 1) { + errno = 0; plugin = liblammpsplugin_load(arg[3]); if (plugin == NULL) { - if (me == 0) printf("ERROR: Could not load shared LAMMPS library\n"); + if (me == 0) printf("ERROR: Could not load shared LAMMPS library file %s: %s\n", arg[3], strerror(errno)); MPI_Abort(MPI_COMM_WORLD,1); } /* must match the plugin ABI version */ diff --git a/examples/PACKAGES/stressprofile/in.flat b/examples/PACKAGES/stressprofile/in.flat index 8b484a423f..a0aea07d83 100644 --- a/examples/PACKAGES/stressprofile/in.flat +++ b/examples/PACKAGES/stressprofile/in.flat @@ -32,7 +32,7 @@ fix 1 all nvt temp 0.7 0.7 0.2 #dump_modify 3 pad 3 fix 2 all recenter NULL NULL 15 units lattice -compute p1 all stress/cartesian z 0.5 +compute p1 all stress/cartesian z 0.5 NULL 0 fix 3 all ave/time 100 1 100 c_p1[*] file flat.out mode vector thermo 50 diff --git a/examples/granular/in.tableting.200 b/examples/granular/in.tableting.200 new file mode 100644 index 0000000000..41723c72af --- /dev/null +++ b/examples/granular/in.tableting.200 @@ -0,0 +1,149 @@ +##################################### SIMULATION SETTINGS ################################################### + +atom_style sphere 1 +atom_modify map array +comm_modify vel yes +units si +newton off +neighbor 1.0e-3 bin +neigh_modify every 10 delay 60 check no +timestep 4e-6 +#processors 2 2 1 + +############################## SIMULATION BOUNDING BOX AND INSERT PARTICLES ################################# + +boundary f f f +read_data spheres200.data + +#################################### ADD DIE AND ATOM PARAMETERIZATION ###################################### + +variable atomRadius equal 0.44e-3*1.25 +variable atomDiameter equal 2*${atomRadius} +variable atomDensity equal 1560 +variable atomMassAvg equal ${atomDensity}*4.0/3.0*PI*${atomRadius}^3.0 +variable dieRadius equal 4e-3 +variable dieHeight equal 1e-2 + +############################## PARTICLE MATERIAL PROPERTIES AND FORCE MODEL ################################## + +pair_style granular + +# mdr = E, nu, Y, gamma, psi_b, CoR +variable YoungsModulus equal 5e6 +variable YieldStress equal 1.9e5 +variable PoissonsRatio equal 0.4 +variable SurfaceEnergy equal 2 +variable SurfaceEnergyWall equal 0.0 +variable CoR equal 0.5 +variable psi_b equal 0.5 + +# linear_history = k_t, x_gammat, mu_s +variable kt equal 2/7*${YoungsModulus}*${atomRadius} +variable kt_wall equal 2/7*${YoungsModulus}*${atomRadius} +variable xgammat equal 0.0 +variable mu_s equal 0.7 +variable mu_s_wall equal 0.1 + +# sds = mu_roll, k_roll, gamma_roll +variable mu_roll equal 0.6 +variable k_roll equal 2.25*${mu_roll}*${mu_roll}*${YoungsModulus}*${atomRadius} +variable gamma_roll equal 0.0 + +pair_coeff * * mdr ${YoungsModulus} ${PoissonsRatio} ${YieldStress} ${SurfaceEnergy} ${psi_b} ${CoR} tangential linear_history ${kt} ${xgammat} ${mu_s} rolling sds ${k_roll} ${gamma_roll} ${mu_roll} damping none + +######################################### ADD DIE AND PUNCH WALLS ############################################ + +variable disp_upper equal 0.0 +variable disp_lower equal 0.0 + +variable wall_contact_string string "granular mdr ${YoungsModulus} ${PoissonsRatio} ${YieldStress} ${SurfaceEnergyWall} ${psi_b} ${CoR} tangential linear_history ${kt_wall} ${xgammat} ${mu_s_wall} rolling sds ${k_roll} ${gamma_roll} ${mu_roll} damping none" + +variable dieHeight2 equal 2*${dieHeight} + +region lowerPunch plane 0 0 0 0 0 1 side in units box move NULL NULL v_disp_lower units box +region upperPunch plane 0 0 ${dieHeight} 0 0 -1 side in move NULL NULL v_disp_upper units box +region die cylinder z 0 0 ${dieRadius} 0 ${dieHeight2} side in units box + +fix lowerPunch all wall/gran/region ${wall_contact_string} region lowerPunch contacts +fix upperPunch all wall/gran/region ${wall_contact_string} region upperPunch contacts +fix die all wall/gran/region ${wall_contact_string} region die contacts + +compute avgUpperPunchForce all reduce sum f_upperPunch[4] +variable avgUpperPunchForce equal c_avgUpperPunchForce +compute avgLowerPunchForce all reduce sum f_lowerPunch[4] +variable avgLowerPunchForce equal c_avgLowerPunchForce + +fix printFD all print 1 "${disp_upper} ${avgUpperPunchForce} ${avgLowerPunchForce}" file punch_force_disp_tableting200.csv screen no + +##################################### INTEGRATION AND GRAVITY ################################################# + +fix 1 all nve/sphere +fix grav all gravity 9.81 vector 0 0 -1 + +########################################### SCREEN OUTPUT #################################################### + +compute 1 all erotate/sphere +thermo_style custom dt step atoms ke vol v_disp_upper +thermo 100 +thermo_modify lost ignore norm no + +##################################### SET UP DUMP OUTPUTS #################################################### + +compute ke all ke/atom +variable output_rate equal round(1e-3/dt) + +run 0 + +compute sigmaxx all property/atom d_sigmaxx +compute sigmayy all property/atom d_sigmayy +compute sigmazz all property/atom d_sigmazz +compute Velas all property/atom d_Velas + +compute sigmaxx_ave all reduce ave c_sigmaxx +compute sigmayy_ave all reduce ave c_sigmayy +compute sigmazz_ave all reduce ave c_sigmazz +compute Velas_sum all reduce sum c_Velas + +variable sxx_ave equal c_sigmaxx_ave +variable syy_ave equal c_sigmayy_ave +variable szz_ave equal c_sigmazz_ave +variable Vparticles equal c_Velas_sum + +fix log all print 1 "${sxx_ave} ${syy_ave} ${szz_ave} ${Vparticles}" file average_normal_stresses_tableting200.csv screen no +dump dumpParticles all custom ${output_rate} tableting200.dump id type mass diameter x y z vx vy vz fx fy fz c_ke c_sigmaxx c_sigmayy c_sigmazz +#dump dumpParticlesVTK all vtk ${output_rate} post/particles_*.vtk id x y z fx fy fz vx vy vz c_ke radius c_sigmaxx c_sigmayy c_sigmazz + +############################################## RUN SIMULATION ################################################# + +variable upper_punch_stroke equal 0.6733*${dieHeight} +variable vel_upper equal 0.25 + +variable settling_steps equal round(0.02/dt) +variable compression_steps equal 2*round(${upper_punch_stroke}/${vel_upper}/dt) +variable ejection_steps equal ${compression_steps} +variable free_float_steps equal round(0.02/dt) + +##### SETTLING ##### + +run ${settling_steps} + +##### Compression & Release ##### + +variable punch_frequency equal PI/2/(dt*${compression_steps}/2) +variable disp_upper equal -${upper_punch_stroke}*sin(${punch_frequency}*elapsed*dt) +variable short_release equal round(${compression_steps}*1.0) +run ${short_release} + +##### EJECTION ##### + +variable punch_frequency equal PI/2/(dt*${ejection_steps}) +variable disp_lower equal ${dieHeight}*sin(${punch_frequency}*elapsed*dt) +variable disp_upper equal 0.9*v_disp_lower +run ${ejection_steps} + +##### FREE FLOAT ##### + +variable disp_lower equal ${dieHeight} +variable disp_upper equal ${dieHeight}*0.9 +variable max_disp equal ${dieRadius}*0.75 +run ${free_float_steps} \ No newline at end of file diff --git a/examples/granular/in.triaxial.compaction.12 b/examples/granular/in.triaxial.compaction.12 new file mode 100644 index 0000000000..eee9a2bfd8 --- /dev/null +++ b/examples/granular/in.triaxial.compaction.12 @@ -0,0 +1,109 @@ +############################### SIMULATION SETTINGS ################################################### + +atom_style sphere 1 +atom_modify map array +comm_modify vel yes +units si +newton off +neighbor 2 bin +neigh_modify delay 0 +timestep 1e-6 + +##################### SIMULATION BOUNDING BOX, INSERT PARTICLES, AND INTEGRATION ####################### + +boundary f f f +read_data spheres12.data +fix integr all nve/sphere + +# create pair group for contact area outputs +group particles_1_12 id 1 12 + +########################### PARTICLE MATERIAL PROPERTIES AND FORCE MODEL ############################### + +variable atomRadius equal 0.5 + +pair_style granular + +# mdr = E, nu, Y, gamma, psi_b, CoR +variable YoungsModulus equal 1e9 +variable PoissonsRatio equal 0.3 +variable YieldStress equal 50e6 +variable SurfaceEnergy equal 0.0 +variable psi_b equal 0.5 +variable CoR equal 0.5 + +# linear_history = k_t, x_gamma,t, mu_s +variable kt equal 2/7*${YoungsModulus}*${atomRadius} +variable xgammat equal 0.0 +variable mu_s equal 0.5 + +pair_coeff * * mdr ${YoungsModulus} ${PoissonsRatio} ${YieldStress} ${SurfaceEnergy} ${psi_b} ${CoR} tangential linear_history ${kt} ${xgammat} ${mu_s} damping none + +######################################### ADD IN PLANES ################################################ + +variable boxWidth equal 3 +variable halfBoxWidth equal ${boxWidth}/2 + +variable plane_disp equal 0.0 +variable plane_disp_neg equal 0.0 + +region plane_yz_pos plane ${halfBoxWidth} 0 0 -1 0 0 side in move v_plane_disp_neg NULL NULL units box +region plane_yz_neg plane -${halfBoxWidth} 0 0 1 0 0 side in move v_plane_disp NULL NULL units box +region plane_xz_pos plane 0 ${halfBoxWidth} 0 0 -1 0 side in move NULL v_plane_disp_neg NULL units box +region plane_xz_neg plane 0 -${halfBoxWidth} 0 0 1 0 side in move NULL v_plane_disp NULL units box +region plane_xy_pos plane 0 0 ${halfBoxWidth} 0 0 -1 side in move NULL NULL v_plane_disp_neg units box +region plane_xy_neg plane 0 0 -${halfBoxWidth} 0 0 1 side in move NULL NULL v_plane_disp units box + +variable wall_contact_string string "granular mdr ${YoungsModulus} ${PoissonsRatio} ${YieldStress} ${SurfaceEnergy} ${psi_b} ${CoR} tangential linear_history ${kt} ${xgammat} ${mu_s} damping none" + +fix plane_yz_pos all wall/gran/region ${wall_contact_string} region plane_yz_pos contacts +fix plane_yz_neg all wall/gran/region ${wall_contact_string} region plane_yz_neg contacts +fix plane_xz_pos all wall/gran/region ${wall_contact_string} region plane_xz_pos contacts +fix plane_xz_neg all wall/gran/region ${wall_contact_string} region plane_xz_neg contacts +fix plane_xy_pos all wall/gran/region ${wall_contact_string} region plane_xy_pos contacts +fix plane_xy_neg all wall/gran/region ${wall_contact_string} region plane_xy_neg contacts + +compute plane_xy_neg_force all reduce sum f_plane_xy_neg[4] +variable plane_xy_neg_force equal c_plane_xy_neg_force + +compute plane_xz_neg_force all reduce sum f_plane_xz_neg[3] +variable plane_xz_neg_force equal c_plane_xz_neg_force + +compute plane_yz_neg_force all reduce sum f_plane_yz_neg[2] +variable plane_yz_neg_force equal c_plane_yz_neg_force + +fix print1 all print 1 "${plane_disp} ${plane_xy_neg_force} ${plane_xz_neg_force} ${plane_yz_neg_force}" file force_disp_triaxial12.csv screen no + +######################################## SCREEN OUTPUT #################################################### + +compute 1 all erotate/sphere +thermo_style custom dt step atoms ke c_1 vol +thermo 100 +thermo_modify lost ignore norm no + +##################################### DEFINE WALL MOVEMENT ################################################# + +variable disp_max equal 0.499 +variable ddisp equal 0.00001 +variable compression_steps equal round(${disp_max}/${ddisp}) +variable output_rate equal round(${compression_steps}/100) + +##################################### SET UP DUMP OUTPUTS #################################################### + +dump dumpParticles all custom ${output_rate} triaxial_compaction_12.dump id type mass x y z vx vy vz fx fy fz radius +#dump dmp all vtk ${output_rate} post/triaxial12particles_*.vtk id type mass x y z vx vy vz fx fy fz radius + +#################################### COMPRESS THE PARTICLES ################################################## + +run 0 + +# print out contact area evolution for particles 1 and 12 +compute Ac_1_12 particles_1_12 pair/local p13 cutoff radius +compute Ac_1_12_sum particles_1_12 reduce sum c_Ac_1_12 inputs local +variable Ac_1_12 equal c_Ac_1_12_sum +fix logArea all print 100 "${plane_disp} ${Ac_1_12}" file pair_1_12_contact_area_triaxial12.csv screen no + +variable plane_disp equal ${ddisp}*elapsed +variable plane_disp_neg equal -${ddisp}*elapsed + +run ${compression_steps} \ No newline at end of file diff --git a/examples/granular/spheres12.data b/examples/granular/spheres12.data new file mode 100644 index 0000000000..b4f07511ac --- /dev/null +++ b/examples/granular/spheres12.data @@ -0,0 +1,23 @@ +#LAMMPS data file created by matlab. +12 atoms + +1 atom types + +-10.0000000000 10.0000000000 xlo xhi +-10.0000000000 10.0000000000 ylo yhi +-10.0000000000 10.0000000000 zlo zhi + +Atoms + +1 1 0.8000000000 1000.0000000000 0.0717535226 -0.2092222842 0.3662146798 +2 1 1.2000000000 1000.0000000000 -0.8233763986 -0.7426114800 -0.8263932264 +3 1 0.8000000000 1000.0000000000 -1.0685863278 -0.4494609702 0.2196698078 +4 1 0.8000000000 1000.0000000000 0.5829432471 -1.0098803839 -0.7607543861 +5 1 0.8000000000 1000.0000000000 -0.8658471132 0.6951192569 0.0107556658 +6 1 1.2000000000 1000.0000000000 0.3966456126 0.7215053869 -0.7540113087 +7 1 1.2000000000 1000.0000000000 0.7316242921 0.8996483982 0.6751483031 +8 1 1.0000000000 1000.0000000000 0.6267527768 -0.8419367233 0.6964197101 +9 1 0.8000000000 1000.0000000000 -0.0409043189 -0.1452314035 -1.0102948313 +10 1 0.8000000000 1000.0000000000 -0.9495107709 0.6760151650 -0.9220534482 +11 1 1.0000000000 1000.0000000000 -0.7488486472 0.2188003421 0.7892021020 +12 1 1.2000000000 1000.0000000000 0.8968590780 -0.2350366437 -0.2006719701 diff --git a/examples/granular/spheres200.data b/examples/granular/spheres200.data new file mode 100644 index 0000000000..f39724477d --- /dev/null +++ b/examples/granular/spheres200.data @@ -0,0 +1,211 @@ +#LAMMPS data file created by matlab. +200 atoms + +1 atom types + +-0.005000 0.005000 xlo xhi +-0.005000 0.005000 ylo yhi +-0.001000 0.020000 zlo zhi + +Atoms + +1 1 0.001206 1560.000000 -0.000938 0.000556 0.000883 +2 1 0.000953 1560.000000 -0.002626 -0.000145 0.002778 +3 1 0.001035 1560.000000 -0.000434 0.000172 0.008458 +4 1 0.001225 1560.000000 -0.003126 -0.000604 0.004986 +5 1 0.001119 1560.000000 0.000772 0.002972 0.002568 +6 1 0.001243 1560.000000 -0.000363 0.001184 0.004927 +7 1 0.001173 1560.000000 0.000218 0.000243 0.005475 +8 1 0.000937 1560.000000 0.000033 0.000029 0.003141 +9 1 0.001055 1560.000000 -0.001660 0.001975 0.008611 +10 1 0.000938 1560.000000 -0.001818 0.002352 0.002534 +11 1 0.000990 1560.000000 0.001592 0.000435 0.004416 +12 1 0.000927 1560.000000 -0.001659 -0.000004 0.005901 +13 1 0.001272 1560.000000 0.002972 0.000553 0.007291 +14 1 0.001226 1560.000000 0.002090 0.000983 0.001406 +15 1 0.000957 1560.000000 0.002241 -0.001608 0.001304 +16 1 0.001020 1560.000000 -0.001944 0.001290 0.002030 +17 1 0.001289 1560.000000 -0.002256 -0.001173 0.003474 +18 1 0.000998 1560.000000 0.000771 0.002127 0.000906 +19 1 0.000927 1560.000000 0.000186 0.000567 0.001207 +20 1 0.001095 1560.000000 -0.000937 -0.003179 0.008173 +21 1 0.001006 1560.000000 -0.001736 0.000751 0.004618 +22 1 0.001037 1560.000000 0.000784 0.001844 0.002380 +23 1 0.001297 1560.000000 0.000234 -0.001597 0.008560 +24 1 0.001017 1560.000000 0.002454 -0.000505 0.001171 +25 1 0.001110 1560.000000 -0.000803 -0.000415 0.003714 +26 1 0.001192 1560.000000 0.002283 0.000648 0.003048 +27 1 0.000992 1560.000000 -0.000065 -0.000545 0.007062 +28 1 0.001116 1560.000000 0.002174 -0.001463 0.005830 +29 1 0.001258 1560.000000 0.001602 0.001853 0.007246 +30 1 0.001055 1560.000000 -0.001535 -0.002770 0.007196 +31 1 0.000958 1560.000000 -0.000438 -0.000260 0.004709 +32 1 0.001188 1560.000000 0.000339 -0.000355 0.009171 +33 1 0.001166 1560.000000 0.002513 -0.001215 0.004434 +34 1 0.000907 1560.000000 0.001905 -0.000373 0.004921 +35 1 0.001245 1560.000000 -0.000091 -0.002620 0.004150 +36 1 0.001302 1560.000000 0.003292 0.000184 0.005377 +37 1 0.001305 1560.000000 0.002099 0.001261 0.008939 +38 1 0.000988 1560.000000 0.003274 0.000136 0.003667 +39 1 0.000892 1560.000000 0.001798 -0.002104 0.008610 +40 1 0.001247 1560.000000 -0.003058 -0.000575 0.000948 +41 1 0.000900 1560.000000 -0.000258 -0.000469 0.001478 +42 1 0.000945 1560.000000 -0.001434 -0.001711 0.004610 +43 1 0.000977 1560.000000 -0.001410 0.002808 0.004963 +44 1 0.000930 1560.000000 -0.002110 -0.001362 0.006749 +45 1 0.000931 1560.000000 0.001256 -0.000876 0.000844 +46 1 0.000901 1560.000000 0.000899 -0.001189 0.005316 +47 1 0.000940 1560.000000 -0.002189 -0.000047 0.007240 +48 1 0.001217 1560.000000 -0.000108 -0.001333 0.002257 +49 1 0.001088 1560.000000 0.001364 -0.000594 0.002789 +50 1 0.001143 1560.000000 -0.000311 -0.001425 0.006092 +51 1 0.001054 1560.000000 0.002262 0.002312 0.004315 +52 1 0.001016 1560.000000 -0.000724 0.000741 0.003295 +53 1 0.001051 1560.000000 0.000527 -0.001987 0.003307 +54 1 0.000905 1560.000000 0.000827 0.001457 0.005868 +55 1 0.001195 1560.000000 -0.001176 -0.000645 0.000798 +56 1 0.001253 1560.000000 0.002583 -0.001847 0.003310 +57 1 0.000982 1560.000000 0.001551 -0.002803 0.005076 +58 1 0.000945 1560.000000 -0.000481 0.000354 0.007220 +59 1 0.001040 1560.000000 -0.002736 0.001076 0.008769 +60 1 0.000917 1560.000000 0.000826 -0.001887 0.006449 +61 1 0.000914 1560.000000 -0.001171 -0.001592 0.007266 +62 1 0.000959 1560.000000 0.000834 -0.002671 0.007105 +63 1 0.000990 1560.000000 -0.000251 -0.001327 0.004339 +64 1 0.001220 1560.000000 0.001384 0.002896 0.005874 +65 1 0.000949 1560.000000 -0.001340 -0.000608 0.007496 +66 1 0.001306 1560.000000 0.002187 0.002068 0.002629 +67 1 0.001206 1560.000000 0.000148 0.001506 0.008517 +68 1 0.001123 1560.000000 0.001288 -0.000303 0.006613 +69 1 0.001151 1560.000000 -0.000876 0.001549 0.001740 +70 1 0.001315 1560.000000 -0.001902 -0.002590 0.001344 +71 1 0.000927 1560.000000 0.002285 -0.000866 0.006900 +72 1 0.001279 1560.000000 -0.000165 0.002689 0.007449 +73 1 0.000910 1560.000000 0.001009 0.001054 0.005049 +74 1 0.001148 1560.000000 -0.002229 -0.001285 0.008736 +75 1 0.001067 1560.000000 -0.000261 -0.002945 0.002157 +76 1 0.000993 1560.000000 -0.001641 0.002272 0.007601 +77 1 0.001228 1560.000000 0.001939 -0.000214 0.008903 +78 1 0.001076 1560.000000 0.000767 0.001172 0.003556 +79 1 0.001105 1560.000000 -0.000561 0.002493 0.004214 +80 1 0.001195 1560.000000 0.002694 -0.000817 0.007949 +81 1 0.001239 1560.000000 -0.000968 -0.003145 0.006096 +82 1 0.001083 1560.000000 -0.000808 0.001813 0.006396 +83 1 0.000923 1560.000000 0.000632 -0.001437 0.001310 +84 1 0.000981 1560.000000 -0.001842 0.002774 0.006508 +85 1 0.000998 1560.000000 -0.002775 0.001616 0.001453 +86 1 0.000979 1560.000000 -0.002520 0.001715 0.007741 +87 1 0.001002 1560.000000 -0.001465 -0.001931 0.006048 +88 1 0.000958 1560.000000 0.003264 0.000707 0.001189 +89 1 0.001052 1560.000000 -0.001314 -0.000701 0.002721 +90 1 0.001096 1560.000000 0.001154 0.002129 0.004403 +91 1 0.001104 1560.000000 0.002118 0.001977 0.000794 +92 1 0.001263 1560.000000 -0.001499 -0.002764 0.003441 +93 1 0.001086 1560.000000 -0.001096 0.002514 0.001154 +94 1 0.000895 1560.000000 0.001130 0.000029 0.001045 +95 1 0.000964 1560.000000 0.000905 -0.003200 0.000542 +96 1 0.000898 1560.000000 -0.000868 0.003148 0.008306 +97 1 0.000907 1560.000000 -0.001406 0.001144 0.007862 +98 1 0.001176 1560.000000 0.001246 -0.001074 0.004327 +99 1 0.001148 1560.000000 0.001512 -0.002739 0.003346 +100 1 0.000922 1560.000000 0.001470 -0.000036 0.007695 +101 1 0.001031 1560.000000 -0.002751 0.000928 0.004124 +102 1 0.001030 1560.000000 -0.000177 -0.002370 0.005374 +103 1 0.000915 1560.000000 0.000824 0.000521 0.007070 +104 1 0.001085 1560.000000 -0.002281 -0.000023 0.009123 +105 1 0.001004 1560.000000 -0.000167 0.002610 0.008905 +106 1 0.001060 1560.000000 -0.000389 -0.002220 0.007688 +107 1 0.000920 1560.000000 -0.000483 0.003231 0.006505 +108 1 0.001122 1560.000000 0.001781 -0.001547 0.002237 +109 1 0.001172 1560.000000 -0.002650 0.000830 0.005429 +110 1 0.001137 1560.000000 -0.000030 -0.003246 0.001024 +111 1 0.001315 1560.000000 0.001470 -0.001735 0.007580 +112 1 0.001245 1560.000000 0.000481 -0.003067 0.006025 +113 1 0.000904 1560.000000 0.000632 -0.000184 0.002010 +114 1 0.000883 1560.000000 -0.001828 0.002191 0.003819 +115 1 0.000974 1560.000000 0.002167 0.001616 0.006226 +116 1 0.001150 1560.000000 0.000871 -0.002731 0.002136 +117 1 0.001312 1560.000000 -0.000326 -0.001971 0.001000 +118 1 0.000914 1560.000000 0.001020 0.000810 0.002086 +119 1 0.001136 1560.000000 -0.000101 -0.003277 0.007246 +120 1 0.000991 1560.000000 -0.001944 0.000576 0.003215 +121 1 0.001216 1560.000000 -0.000913 -0.001165 0.008857 +122 1 0.001045 1560.000000 -0.003110 0.001062 0.002973 +123 1 0.000918 1560.000000 0.000348 0.000365 0.004046 +124 1 0.001279 1560.000000 -0.000884 0.003087 0.002268 +125 1 0.001065 1560.000000 -0.002238 0.001309 0.006452 +126 1 0.001012 1560.000000 -0.002059 -0.001354 0.001935 +127 1 0.001142 1560.000000 -0.003011 0.000567 0.001739 +128 1 0.000921 1560.000000 0.001764 0.002804 0.008177 +129 1 0.001151 1560.000000 -0.003105 -0.000384 0.006602 +130 1 0.000967 1560.000000 0.000932 0.000588 0.008823 +131 1 0.000908 1560.000000 -0.001873 -0.001947 0.007825 +132 1 0.000923 1560.000000 -0.002993 0.000883 0.007425 +133 1 0.001171 1560.000000 0.003310 -0.000405 0.006558 +134 1 0.000977 1560.000000 -0.000098 -0.000180 0.000492 +135 1 0.000938 1560.000000 -0.000706 -0.000129 0.006085 +136 1 0.001008 1560.000000 -0.000256 0.002333 0.000550 +137 1 0.001073 1560.000000 0.000534 -0.000055 0.008080 +138 1 0.000890 1560.000000 0.000351 0.001695 0.007195 +139 1 0.000973 1560.000000 0.002593 0.001907 0.005394 +140 1 0.001176 1560.000000 -0.001862 -0.000534 0.004494 +141 1 0.001306 1560.000000 -0.000951 0.001053 0.009299 +142 1 0.001103 1560.000000 -0.001937 -0.002711 0.008485 +143 1 0.001262 1560.000000 -0.002947 -0.001470 0.007682 +144 1 0.000914 1560.000000 0.002047 0.000811 0.005504 +145 1 0.000954 1560.000000 0.001935 -0.002349 0.006632 +146 1 0.001003 1560.000000 0.000766 -0.002635 0.008483 +147 1 0.001137 1560.000000 0.000102 0.003195 0.004922 +148 1 0.001006 1560.000000 -0.001982 0.001014 0.000685 +149 1 0.001255 1560.000000 -0.000718 0.001939 0.003056 +150 1 0.001057 1560.000000 -0.001189 -0.001717 0.003045 +151 1 0.001228 1560.000000 0.001581 0.002926 0.003510 +152 1 0.001052 1560.000000 -0.002172 0.001949 0.004831 +153 1 0.000979 1560.000000 -0.001817 0.000291 0.002048 +154 1 0.001286 1560.000000 -0.002647 -0.001839 0.004620 +155 1 0.001085 1560.000000 -0.000081 0.000850 0.002139 +156 1 0.000990 1560.000000 -0.000081 0.002105 0.005587 +157 1 0.001043 1560.000000 0.001636 -0.000112 0.001860 +158 1 0.001309 1560.000000 0.003216 -0.000851 0.002791 +159 1 0.000913 1560.000000 0.000608 0.003148 0.006565 +160 1 0.000919 1560.000000 0.000536 -0.003106 0.003249 +161 1 0.000943 1560.000000 0.003145 -0.000528 0.008915 +162 1 0.000993 1560.000000 -0.002811 -0.000099 0.008110 +163 1 0.001125 1560.000000 0.001415 -0.002271 0.000643 +164 1 0.000919 1560.000000 -0.001406 0.000223 0.006781 +165 1 0.001040 1560.000000 0.000690 0.003193 0.008329 +166 1 0.001055 1560.000000 0.001075 0.002584 0.009093 +167 1 0.001176 1560.000000 0.000851 0.003176 0.000591 +168 1 0.001003 1560.000000 -0.001462 0.001511 0.005544 +169 1 0.001126 1560.000000 -0.000077 0.003324 0.001347 +170 1 0.001068 1560.000000 0.003110 0.000810 0.008495 +171 1 0.001011 1560.000000 -0.001661 0.000117 0.008201 +172 1 0.001066 1560.000000 -0.000359 -0.003279 0.009094 +173 1 0.001303 1560.000000 0.003066 0.001188 0.004082 +174 1 0.000983 1560.000000 0.000354 0.002261 0.003558 +175 1 0.001137 1560.000000 0.002860 -0.001571 0.009180 +176 1 0.001070 1560.000000 0.001246 -0.001279 0.009104 +177 1 0.000886 1560.000000 0.002271 -0.000316 0.003675 +178 1 0.000983 1560.000000 -0.001987 -0.002490 0.005377 +179 1 0.000939 1560.000000 0.000601 -0.000861 0.003477 +180 1 0.001177 1560.000000 0.001522 0.002902 0.001690 +181 1 0.001036 1560.000000 -0.001200 -0.002874 0.004750 +182 1 0.000898 1560.000000 -0.001705 -0.001140 0.005503 +183 1 0.001315 1560.000000 0.002732 0.001766 0.007885 +184 1 0.001318 1560.000000 -0.002909 -0.001610 0.005936 +185 1 0.001218 1560.000000 0.003213 0.000884 0.002316 +186 1 0.001234 1560.000000 -0.002394 -0.002298 0.002575 +187 1 0.001160 1560.000000 -0.003313 -0.000065 0.003625 +188 1 0.001022 1560.000000 -0.003096 -0.001048 0.002151 +189 1 0.000966 1560.000000 0.001891 -0.002093 0.004404 +190 1 0.001048 1560.000000 -0.002367 0.002338 0.000697 +191 1 0.000995 1560.000000 -0.001204 -0.001912 0.002030 +192 1 0.001136 1560.000000 -0.001152 -0.002402 0.009223 +193 1 0.001083 1560.000000 -0.002588 -0.001768 0.000753 +194 1 0.000946 1560.000000 -0.001338 -0.000741 0.006527 +195 1 0.000943 1560.000000 -0.000073 0.003254 0.003663 +196 1 0.001059 1560.000000 0.000087 0.000958 0.006388 +197 1 0.001131 1560.000000 0.001030 0.001019 0.000752 +198 1 0.001257 1560.000000 -0.001365 0.002946 0.009266 +199 1 0.000891 1560.000000 -0.000445 -0.000273 0.002382 +200 1 0.001055 1560.000000 0.001781 0.000748 0.006583 diff --git a/examples/multi/in.granular b/examples/multi/in.granular index 468d0dcbf1..6abbd8da3b 100644 --- a/examples/multi/in.granular +++ b/examples/multi/in.granular @@ -1,4 +1,4 @@ -# Big colloid particles and small LJ particles +# Binary granular system units lj atom_style sphere diff --git a/examples/snap/README.md b/examples/snap/README.md index 305f920ae8..1df24acf1f 100644 --- a/examples/snap/README.md +++ b/examples/snap/README.md @@ -9,5 +9,11 @@ in.snap.Mo_Chen # SNAP linear Mo potential in.snap.compute # SNAP compute for training a linear model in.snap.compute.quadratic # SNAP compute for training a quadratic model in.snap.scale.Ni_Zuo_JCPA2020 # SNAP linear Ni potential with thermodynamic integration (fix adapt scale) +in.C_SNAP # SNAP carbon potential compute_snap_dgrad.py # SNAP compute with dgradflag (dBi/dRj) for training a non-linear model + +in.snap.grid # SNAP descriptors on a grid +in.snap.grid.triclinic # SNAP descriptors on a grid, triclinic +in.gaussian.grid # Gaussian descriptors on a grid + diff --git a/examples/snap/in.gaussian.grid b/examples/snap/in.gaussian.grid new file mode 100644 index 0000000000..48aeec1632 --- /dev/null +++ b/examples/snap/in.gaussian.grid @@ -0,0 +1,68 @@ +# Demonstrate calculation of Gaussian descriptors on a grid +# for a cell with two atoms of type 1 and type 2. +# The output in dump.glocal shows that for grid points +# sitting on an atom of type 1 or 2: +# val1 = 1.0/(0.1355*sqrt(2.0*pi))**3 = 25.5219 +# val2 = 1.0/(0.2 *sqrt(2.0*pi))**3 = 7.93670 +# These values are extracted to the log file +# + +variable nrep index 1 +variable a index 3.316 +variable ngrid index 2 + +units metal +atom_modify map hash + +# generate the box and atom positions using a BCC lattice + +variable nx equal ${nrep} +variable ny equal ${nrep} +variable nz equal ${nrep} + +boundary p p p + +lattice custom $a & + a1 1 0 0 & + a2 0 1 0 & + a3 0 0 1 & + basis 0 0 0 & + basis 0.5 0.5 0.5 & + +region box block 0 ${nx} 0 ${ny} 0 ${nz} +create_box 2 box +create_atoms 1 box basis 1 1 basis 2 2 + +mass * 180.88 + +# define atom compute and grid compute + +variable rcutfac equal 4.67637 +variable radelem1 equal 0.5 +variable radelem2 equal 0.5 +variable sigmaelem1 equal 0.1355 +variable sigmaelem2 equal 0.2 +variable gaussian_options string & + "${rcutfac} ${radelem1} ${radelem2} ${sigmaelem1} ${sigmaelem2}" + +# build zero potential to force ghost atom creation + +pair_style zero ${rcutfac} +pair_coeff * * + +# define atom and grid computes + +compute mygridlocal all gaussian/grid/local grid ${ngrid} ${ngrid} ${ngrid} & + ${gaussian_options} + +# define output + +dump 1 all local 1000 dump.glocal c_mygridlocal[*] +dump 2 all custom 1000 dump.gatom id x y z +compute val1 all reduce max c_mygridlocal[7] inputs local +compute val2 all reduce max c_mygridlocal[8] inputs local +thermo_style custom step c_val1 c_val2 + +# run + +run 0 diff --git a/examples/snap/in.grid.snap b/examples/snap/in.snap.grid similarity index 100% rename from examples/snap/in.grid.snap rename to examples/snap/in.snap.grid diff --git a/examples/snap/in.grid.tri b/examples/snap/in.snap.grid.triclinic similarity index 99% rename from examples/snap/in.grid.tri rename to examples/snap/in.snap.grid.triclinic index 95a14f3bb4..59063f576e 100644 --- a/examples/snap/in.grid.tri +++ b/examples/snap/in.snap.grid.triclinic @@ -47,7 +47,6 @@ lattice custom $a & basis 0.0 0.0 0.5 & spacing 1 1 1 -box tilt large region box prism 0 ${nx} 0 ${ny} 0 ${nz} ${ny} ${nz} ${nz} create_box 1 box create_atoms 1 box diff --git a/examples/snap/log.10Dec24.gaussian.grid.g++.1 b/examples/snap/log.10Dec24.gaussian.grid.g++.1 new file mode 100644 index 0000000000..b158ac07d0 --- /dev/null +++ b/examples/snap/log.10Dec24.gaussian.grid.g++.1 @@ -0,0 +1,129 @@ +LAMMPS (19 Nov 2024 - Development - patch_19Nov2024-59-g16e0a7788a) +OMP_NUM_THREADS environment is not set. Defaulting to 1 thread. (src/comm.cpp:99) + using 1 OpenMP thread(s) per MPI task +# Demonstrate calculation of Gaussian descriptors on a grid +# for a cell with two atoms of type 1 and type 2. +# The output in dump.glocal shows that for grid points +# sitting on an atom of type 1 or 2: +# val1 = 1.0/(0.1355*sqrt(2.0*pi))**3 = 25.5219 +# val2 = 1.0/(0.2 *sqrt(2.0*pi))**3 = 7.93670 +# These values are extracted to the log file +# + +variable nrep index 1 +variable a index 3.316 +variable ngrid index 2 + +units metal +atom_modify map hash + +# generate the box and atom positions using a BCC lattice + +variable nx equal ${nrep} +variable nx equal 1 +variable ny equal ${nrep} +variable ny equal 1 +variable nz equal ${nrep} +variable nz equal 1 + +boundary p p p + +lattice custom $a a1 1 0 0 a2 0 1 0 a3 0 0 1 basis 0 0 0 basis 0.5 0.5 0.5 +lattice custom 3.316 a1 1 0 0 a2 0 1 0 a3 0 0 1 basis 0 0 0 basis 0.5 0.5 0.5 +Lattice spacing in x,y,z = 3.316 3.316 3.316 +region box block 0 ${nx} 0 ${ny} 0 ${nz} +region box block 0 1 0 ${ny} 0 ${nz} +region box block 0 1 0 1 0 ${nz} +region box block 0 1 0 1 0 1 +create_box 2 box +Created orthogonal box = (0 0 0) to (3.316 3.316 3.316) + 1 by 1 by 1 MPI processor grid +create_atoms 1 box basis 1 1 basis 2 2 +Created 2 atoms + using lattice units in orthogonal box = (0 0 0) to (3.316 3.316 3.316) + create_atoms CPU = 0.001 seconds + +mass * 180.88 + +# define atom compute and grid compute + +variable rcutfac equal 4.67637 +variable radelem1 equal 0.5 +variable radelem2 equal 0.5 +variable sigmaelem1 equal 0.1355 +variable sigmaelem2 equal 0.2 +variable gaussian_options string "${rcutfac} ${radelem1} ${radelem2} ${sigmaelem1} ${sigmaelem2}" +4.67637 ${radelem1} ${radelem2} ${sigmaelem1} ${sigmaelem2} +4.67637 0.5 ${radelem2} ${sigmaelem1} ${sigmaelem2} +4.67637 0.5 0.5 ${sigmaelem1} ${sigmaelem2} +4.67637 0.5 0.5 0.1355 ${sigmaelem2} +4.67637 0.5 0.5 0.1355 0.2 + +# build zero potential to force ghost atom creation + +pair_style zero ${rcutfac} +pair_style zero 4.67637 +pair_coeff * * + +# define atom and grid computes + +compute mygridlocal all gaussian/grid/local grid ${ngrid} ${ngrid} ${ngrid} ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 ${ngrid} ${ngrid} ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 2 ${ngrid} ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 2 2 ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 2 2 4.67637 0.5 0.5 0.1355 0.2 + +# define output + +dump 1 all local 1000 dump.glocal c_mygridlocal[*] +dump 2 all custom 1000 dump.gatom id x y z +compute val1 all reduce max c_mygridlocal[7] inputs local +compute val2 all reduce max c_mygridlocal[8] inputs local +thermo_style custom step c_val1 c_val2 + +# run + +run 0 +WARNING: No fixes with time integration, atoms won't move (src/verlet.cpp:60) +Generated 0 of 1 mixed pair_coeff terms from geometric mixing rule +Neighbor list info ... + update: every = 1 steps, delay = 0 steps, check = yes + max neighbors/atom: 2000, page size: 100000 + master list distance cutoff = 6.67637 + ghost atom cutoff = 6.67637 + binsize = 3.338185, bins = 1 1 1 + 1 neighbor lists, perpetual/occasional/extra = 1 0 0 + (1) pair zero, perpetual + attributes: half, newton on + pair build: half/bin/atomonly/newton + stencil: half/bin/3d + bin: standard +Per MPI rank memory allocation (min/avg/max) = 3.492 | 3.492 | 3.492 Mbytes + Step c_val1 c_val2 + 0 25.521859 7.9367045 +Loop time of 1.088e-06 on 1 procs for 0 steps with 2 atoms + +183.8% CPU use with 1 MPI tasks x 1 OpenMP threads + +MPI task timing breakdown: +Section | min time | avg time | max time |%varavg| %total +--------------------------------------------------------------- +Pair | 0 | 0 | 0 | 0.0 | 0.00 +Neigh | 0 | 0 | 0 | 0.0 | 0.00 +Comm | 0 | 0 | 0 | 0.0 | 0.00 +Output | 0 | 0 | 0 | 0.0 | 0.00 +Modify | 0 | 0 | 0 | 0.0 | 0.00 +Other | | 1.088e-06 | | |100.00 + +Nlocal: 2 ave 2 max 2 min +Histogram: 1 0 0 0 0 0 0 0 0 0 +Nghost: 339 ave 339 max 339 min +Histogram: 1 0 0 0 0 0 0 0 0 0 +Neighs: 64 ave 64 max 64 min +Histogram: 1 0 0 0 0 0 0 0 0 0 + +Total # of neighbors = 64 +Ave neighs/atom = 32 +Neighbor list builds = 0 +Dangerous builds = 0 +Total wall time: 0:00:00 diff --git a/examples/snap/log.10Dec24.gaussian.grid.g++.4 b/examples/snap/log.10Dec24.gaussian.grid.g++.4 new file mode 100644 index 0000000000..54cc842bc7 --- /dev/null +++ b/examples/snap/log.10Dec24.gaussian.grid.g++.4 @@ -0,0 +1,130 @@ +LAMMPS (19 Nov 2024 - Development - patch_19Nov2024-59-g16e0a7788a) +OMP_NUM_THREADS environment is not set. Defaulting to 1 thread. (src/comm.cpp:99) + using 1 OpenMP thread(s) per MPI task +# Demonstrate calculation of Gaussian descriptors on a grid +# for a cell with two atoms of type 1 and type 2. +# The output in dump.glocal shows that for grid points +# sitting on an atom of type 1 or 2: +# val1 = 1.0/(0.1355*sqrt(2.0*pi))**3 = 25.5219 +# val2 = 1.0/(0.2 *sqrt(2.0*pi))**3 = 7.93670 +# These values are extracted to the log file +# + +variable nrep index 1 +variable a index 3.316 +variable ngrid index 2 + +units metal +atom_modify map hash + +# generate the box and atom positions using a BCC lattice + +variable nx equal ${nrep} +variable nx equal 1 +variable ny equal ${nrep} +variable ny equal 1 +variable nz equal ${nrep} +variable nz equal 1 + +boundary p p p + +lattice custom $a a1 1 0 0 a2 0 1 0 a3 0 0 1 basis 0 0 0 basis 0.5 0.5 0.5 +lattice custom 3.316 a1 1 0 0 a2 0 1 0 a3 0 0 1 basis 0 0 0 basis 0.5 0.5 0.5 +Lattice spacing in x,y,z = 3.316 3.316 3.316 +region box block 0 ${nx} 0 ${ny} 0 ${nz} +region box block 0 1 0 ${ny} 0 ${nz} +region box block 0 1 0 1 0 ${nz} +region box block 0 1 0 1 0 1 +create_box 2 box +Created orthogonal box = (0 0 0) to (3.316 3.316 3.316) + 1 by 2 by 2 MPI processor grid +create_atoms 1 box basis 1 1 basis 2 2 +Created 2 atoms + using lattice units in orthogonal box = (0 0 0) to (3.316 3.316 3.316) + create_atoms CPU = 0.001 seconds + +mass * 180.88 + +# define atom compute and grid compute + +variable rcutfac equal 4.67637 +variable radelem1 equal 0.5 +variable radelem2 equal 0.5 +variable sigmaelem1 equal 0.1355 +variable sigmaelem2 equal 0.2 +variable gaussian_options string "${rcutfac} ${radelem1} ${radelem2} ${sigmaelem1} ${sigmaelem2}" +4.67637 ${radelem1} ${radelem2} ${sigmaelem1} ${sigmaelem2} +4.67637 0.5 ${radelem2} ${sigmaelem1} ${sigmaelem2} +4.67637 0.5 0.5 ${sigmaelem1} ${sigmaelem2} +4.67637 0.5 0.5 0.1355 ${sigmaelem2} +4.67637 0.5 0.5 0.1355 0.2 + +# build zero potential to force ghost atom creation + +pair_style zero ${rcutfac} +pair_style zero 4.67637 +pair_coeff * * + +# define atom and grid computes + +compute mygridlocal all gaussian/grid/local grid ${ngrid} ${ngrid} ${ngrid} ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 ${ngrid} ${ngrid} ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 2 ${ngrid} ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 2 2 ${gaussian_options} +compute mygridlocal all gaussian/grid/local grid 2 2 2 4.67637 0.5 0.5 0.1355 0.2 + +# define output + +dump 1 all local 1000 dump.glocal c_mygridlocal[*] +dump 2 all custom 1000 dump.gatom id x y z +compute val1 all reduce max c_mygridlocal[7] inputs local +compute val2 all reduce max c_mygridlocal[8] inputs local +thermo_style custom step c_val1 c_val2 + +# run + +run 0 +WARNING: No fixes with time integration, atoms won't move (src/verlet.cpp:60) +Generated 0 of 1 mixed pair_coeff terms from geometric mixing rule +Neighbor list info ... + update: every = 1 steps, delay = 0 steps, check = yes + max neighbors/atom: 2000, page size: 100000 + master list distance cutoff = 6.67637 + ghost atom cutoff = 6.67637 + binsize = 3.338185, bins = 1 1 1 + 1 neighbor lists, perpetual/occasional/extra = 1 0 0 + (1) pair zero, perpetual + attributes: half, newton on + pair build: half/bin/atomonly/newton + stencil: half/bin/3d + bin: standard +WARNING: Proc sub-domain size < neighbor skin, could lead to lost atoms (src/domain.cpp:1202) +Per MPI rank memory allocation (min/avg/max) = 3.522 | 3.523 | 3.524 Mbytes + Step c_val1 c_val2 + 0 25.521859 7.9367045 +Loop time of 2.238e-06 on 4 procs for 0 steps with 2 atoms + +89.4% CPU use with 4 MPI tasks x 1 OpenMP threads + +MPI task timing breakdown: +Section | min time | avg time | max time |%varavg| %total +--------------------------------------------------------------- +Pair | 0 | 0 | 0 | 0.0 | 0.00 +Neigh | 0 | 0 | 0 | 0.0 | 0.00 +Comm | 0 | 0 | 0 | 0.0 | 0.00 +Output | 0 | 0 | 0 | 0.0 | 0.00 +Modify | 0 | 0 | 0 | 0.0 | 0.00 +Other | | 2.238e-06 | | |100.00 + +Nlocal: 0.5 ave 1 max 0 min +Histogram: 2 0 0 0 0 0 0 0 0 2 +Nghost: 274.5 ave 275 max 274 min +Histogram: 2 0 0 0 0 0 0 0 0 2 +Neighs: 16 ave 40 max 0 min +Histogram: 2 0 0 0 0 0 1 0 0 1 + +Total # of neighbors = 64 +Ave neighs/atom = 32 +Neighbor list builds = 0 +Dangerous builds = 0 +Total wall time: 0:00:00 diff --git a/fortran/lammps.f90 b/fortran/lammps.f90 index 552b3dfad3..2cfd4422b0 100644 --- a/fortran/lammps.f90 +++ b/fortran/lammps.f90 @@ -127,6 +127,16 @@ MODULE LIBLAMMPS PROCEDURE :: set_string_variable => lmp_set_string_variable PROCEDURE :: set_internal_variable => lmp_set_internal_variable PROCEDURE :: eval => lmp_eval + + PROCEDURE :: clearstep_compute => lmp_clearstep_compute + PROCEDURE, PRIVATE :: lmp_addstep_compute_smallint + PROCEDURE, PRIVATE :: lmp_addstep_compute_bigint + GENERIC :: addstep_compute => lmp_addstep_compute_smallint, lmp_addstep_compute_bigint + PROCEDURE, PRIVATE :: lmp_addstep_compute_all_smallint + PROCEDURE, PRIVATE :: lmp_addstep_compute_all_bigint + GENERIC :: addstep_compute_all => lmp_addstep_compute_all_smallint, & + lmp_addstep_compute_all_bigint + PROCEDURE, PRIVATE :: lmp_gather_atoms_int PROCEDURE, PRIVATE :: lmp_gather_atoms_double GENERIC :: gather_atoms => lmp_gather_atoms_int, & @@ -626,6 +636,24 @@ MODULE LIBLAMMPS REAL(c_double) :: lammps_eval END FUNCTION lammps_eval + SUBROUTINE lammps_clearstep_compute(handle) BIND(C) + IMPORT :: c_ptr + IMPLICIT NONE + TYPE(c_ptr), VALUE :: handle + END SUBROUTINE lammps_clearstep_compute + + SUBROUTINE lammps_addstep_compute(handle, step) BIND(C) + IMPORT :: c_ptr + IMPLICIT NONE + TYPE(c_ptr), VALUE :: handle, step + END SUBROUTINE lammps_addstep_compute + + SUBROUTINE lammps_addstep_compute_all(handle, step) BIND(C) + IMPORT :: c_ptr + IMPLICIT NONE + TYPE(c_ptr), VALUE :: handle, step + END SUBROUTINE lammps_addstep_compute_all + SUBROUTINE lammps_gather_atoms(handle, name, TYPE, count, DATA) BIND(C) IMPORT :: c_int, c_ptr IMPLICIT NONE @@ -1846,6 +1874,80 @@ CONTAINS CALL lammps_free(Cexpr) END FUNCTION lmp_eval + ! equivalent subroutine to lammps_clearstep_compute + SUBROUTINE lmp_clearstep_compute(self) + CLASS(lammps), INTENT(IN) :: self + CALL lammps_clearstep_compute(self%handle) + END SUBROUTINE lmp_clearstep_compute + + ! equivalent subroutine to lammps_addstep_compute + SUBROUTINE lmp_addstep_compute_bigint(self, nextstep) + CLASS(lammps), INTENT(IN) :: self + INTEGER(kind=8), INTENT(IN) :: nextstep + INTEGER(c_int), TARGET :: smallstep + INTEGER(c_int64_t), TARGET :: bigstep + TYPE(c_ptr) :: ptrstep + IF (SIZE_BIGINT == 4_c_int) THEN + smallstep = INT(nextstep,kind=c_int) + ptrstep = C_LOC(smallstep) + ELSE + bigstep = nextstep + ptrstep = C_LOC(bigstep) + END IF + CALL lammps_addstep_compute(self%handle, ptrstep) + END SUBROUTINE lmp_addstep_compute_bigint + + ! equivalent subroutine to lammps_addstep_compute + SUBROUTINE lmp_addstep_compute_smallint(self, nextstep) + CLASS(lammps), INTENT(IN) :: self + INTEGER(kind=4), INTENT(IN) :: nextstep + INTEGER(c_int), TARGET :: smallstep + INTEGER(c_int64_t), TARGET :: bigstep + TYPE(c_ptr) :: ptrstep + IF (SIZE_BIGINT == 4_c_int) THEN + smallstep = nextstep + ptrstep = C_LOC(smallstep) + ELSE + bigstep = nextstep + ptrstep = C_LOC(bigstep) + END IF + CALL lammps_addstep_compute(self%handle, ptrstep) + END SUBROUTINE lmp_addstep_compute_smallint + + ! equivalent subroutine to lammps_addstep_compute_all + SUBROUTINE lmp_addstep_compute_all_bigint(self, nextstep) + CLASS(lammps), INTENT(IN) :: self + INTEGER(kind=8), INTENT(IN) :: nextstep + INTEGER(c_int), TARGET :: smallstep + INTEGER(c_int64_t), TARGET :: bigstep + TYPE(c_ptr) :: ptrstep + IF (SIZE_BIGINT == 4_c_int) THEN + smallstep = INT(nextstep,kind=c_int) + ptrstep = C_LOC(smallstep) + ELSE + bigstep = nextstep + ptrstep = C_LOC(bigstep) + END IF + CALL lammps_addstep_compute_all(self%handle, ptrstep) + END SUBROUTINE lmp_addstep_compute_all_bigint + + ! equivalent subroutine to lammps_addstep_compute_all + SUBROUTINE lmp_addstep_compute_all_smallint(self, nextstep) + CLASS(lammps), INTENT(IN) :: self + INTEGER(kind=4), INTENT(IN) :: nextstep + INTEGER(c_int), TARGET :: smallstep + INTEGER(c_int64_t), TARGET :: bigstep + TYPE(c_ptr) :: ptrstep + IF (SIZE_BIGINT == 4_c_int) THEN + smallstep = nextstep + ptrstep = C_LOC(smallstep) + ELSE + bigstep = nextstep + ptrstep = C_LOC(bigstep) + END IF + CALL lammps_addstep_compute_all(self%handle, ptrstep) + END SUBROUTINE lmp_addstep_compute_all_smallint + ! equivalent function to lammps_gather_atoms (for integers) SUBROUTINE lmp_gather_atoms_int(self, name, count, data) CLASS(lammps), INTENT(IN) :: self diff --git a/lib/plumed/Install.py b/lib/plumed/Install.py index 485845b67a..7cbc9f0e76 100644 --- a/lib/plumed/Install.py +++ b/lib/plumed/Install.py @@ -19,7 +19,7 @@ parser = ArgumentParser(prog='Install.py', # Note: must also adjust check for supported API versions in # fix_plumed.cpp when version changes from v2.n.x to v2.n+1.y -version = "2.9.2" +version = "2.9.3" mode = "static" # help message @@ -52,6 +52,7 @@ checksums = { \ '2.9.0' : '661eabeebee05cf84bbf9dc23d7d5f46', \ '2.9.1' : 'c3b2d31479c1e9ce211719d40e9efbd7', \ '2.9.2' : '04862602a372c1013bdfee2d6d03bace', \ + '2.9.3' : 'ee1249805fe94bccee17d10610d3f6f1', \ } # parse and process arguments diff --git a/python/lammps/core.py b/python/lammps/core.py index 3eb74cb550..089517bab7 100644 --- a/python/lammps/core.py +++ b/python/lammps/core.py @@ -422,6 +422,10 @@ class lammps(object): self.lib.lammps_extract_variable_datatype.argtypes = [c_void_p, c_char_p] self.lib.lammps_extract_variable_datatype.restype = c_int + self.lib.lammps_clearstep_compute.argtype = [c_void_p] + self.lib.lammps_addstep_compute.argtype = [c_void_p, c_void_p] + self.lib.lammps_addstep_compute_all.argtype = [c_void_p, c_void_p] + self.lib.lammps_eval.argtypes = [c_void_p, c_char_p] self.lib.lammps_eval.restype = c_double @@ -1594,6 +1598,26 @@ class lammps(object): # ------------------------------------------------------------------------- + def clearstep_compute(self, nextstep): + with ExceptionCheck(self): + return self.lib.lammps_clearstep_compute(self.lmp) + + # ------------------------------------------------------------------------- + + def addstep_compute(self, nextstep): + with ExceptionCheck(self): + nextstep = self.c_bigint(nextstep) + return self.lib.lammps_addstep_compute(self.lmp, POINTER(nextstep)) + + # ------------------------------------------------------------------------- + + def addstep_compute_all(self, nextstep): + with ExceptionCheck(self): + nextstep = self.c_bigint(nextstep) + return self.lib.lammps_addstep_compute_all(self.lmp, POINTER(nextstep)) + + # ------------------------------------------------------------------------- + def flush_buffers(self): """Flush output buffers @@ -1694,7 +1718,6 @@ class lammps(object): with ExceptionCheck(self): return self.lib.lammps_eval(self.lmp, newexpr) - return None # ------------------------------------------------------------------------- diff --git a/src/.gitignore b/src/.gitignore index c1f6b6e892..3630d940de 100644 --- a/src/.gitignore +++ b/src/.gitignore @@ -252,6 +252,8 @@ /*rheo*.cpp /*rheo*.h +/compute_gaussian_grid_local.cpp +/compute_gaussian_grid_local.h /compute_grid.cpp /compute_grid.h /compute_grid_local.cpp @@ -849,6 +851,8 @@ /fix_ffl.h /fix_filter_corotate.cpp /fix_filter_corotate.h +/fix_granular_mdr.cpp +/fix_granular_mdr.h /fix_viscosity.cpp /fix_viscosity.h /fix_ehex.cpp @@ -1277,6 +1281,10 @@ /pair_hbond_dreiding_lj.h /pair_hbond_dreiding_morse.cpp /pair_hbond_dreiding_morse.h +/pair_hbond_dreiding_lj_angleoffset.cpp +/pair_hbond_dreiding_lj_angleoffset.h +/pair_hbond_dreiding_morse_angleoffset.cpp +/pair_hbond_dreiding_morse_angleoffset.h /pair_hdnnp.cpp /pair_hdnnp.h /pair_ilp_graphene_hbn.cpp diff --git a/src/AMOEBA/fix_amoeba_pitorsion.cpp b/src/AMOEBA/fix_amoeba_pitorsion.cpp index 33af4a3c31..352e559d6b 100644 --- a/src/AMOEBA/fix_amoeba_pitorsion.cpp +++ b/src/AMOEBA/fix_amoeba_pitorsion.cpp @@ -773,9 +773,9 @@ bigint FixAmoebaPiTorsion::read_data_skip_lines(char *keyword) void FixAmoebaPiTorsion::write_data_header(FILE *fp, int mth) { - if (mth == 0) fmt::print(fp,"{} pitorsions\n",npitorsions); + if (mth == 0) utils::print(fp,"{} pitorsions\n",npitorsions); else if (mth == 1) - fmt::print(fp, "{} pitorsion types\n",npitorsion_types); + utils::print(fp, "{} pitorsion types\n",npitorsion_types); } /* ---------------------------------------------------------------------- diff --git a/src/BODY/body_nparticle.cpp b/src/BODY/body_nparticle.cpp index 4a34f31f54..14841e6054 100644 --- a/src/BODY/body_nparticle.cpp +++ b/src/BODY/body_nparticle.cpp @@ -261,22 +261,22 @@ int BodyNparticle::write_data_body(FILE *fp, double *buf) // atomID ninteger ndouble - fmt::print(fp,"{} {} {}\n",ubuf(buf[m]).i,ubuf(buf[m+1]).i,ubuf(buf[m+2]).i); + utils::print(fp,"{} {} {}\n",ubuf(buf[m]).i,ubuf(buf[m+1]).i,ubuf(buf[m+2]).i); m += 3; const int nsub = (int) ubuf(buf[m++]).i; - fmt::print(fp,"{}\n",nsub); + utils::print(fp,"{}\n",nsub); // inertia - fmt::print(fp,"{} {} {} {} {} {}\n", + utils::print(fp,"{} {} {} {} {} {}\n", buf[m+0],buf[m+1],buf[m+2],buf[m+3],buf[m+4],buf[m+5]); m += 6; // nsub vertices for (int i = 0; i < nsub; i++) { - fmt::print(fp,"{} {} {}\n",buf[m],buf[m+1],buf[m+2]); + utils::print(fp,"{} {} {}\n",buf[m],buf[m+1],buf[m+2]); m += 3; } diff --git a/src/BODY/body_rounded_polygon.cpp b/src/BODY/body_rounded_polygon.cpp index 5de0654d25..366db6264f 100644 --- a/src/BODY/body_rounded_polygon.cpp +++ b/src/BODY/body_rounded_polygon.cpp @@ -398,27 +398,27 @@ int BodyRoundedPolygon::write_data_body(FILE *fp, double *buf) // atomID ninteger ndouble - fmt::print(fp,"{} {} {}\n",ubuf(buf[m]).i,ubuf(buf[m+1]).i,ubuf(buf[m+2]).i); + utils::print(fp,"{} {} {}\n",ubuf(buf[m]).i,ubuf(buf[m+1]).i,ubuf(buf[m+2]).i); m += 3; const int nsub = (int) ubuf(buf[m++]).i; - fmt::print(fp,"{}\n",nsub); + utils::print(fp,"{}\n",nsub); // inertia - fmt::print(fp,"{} {} {} {} {} {}\n", + utils::print(fp,"{} {} {} {} {} {}\n", buf[m+0],buf[m+1],buf[m+2],buf[m+3],buf[m+4],buf[m+5]); m += 6; // nsub vertices for (int i = 0; i < nsub; i++, m+=3) - fmt::print(fp,"{} {} {}\n",buf[m],buf[m+1],buf[m+2]); + utils::print(fp,"{} {} {}\n",buf[m],buf[m+1],buf[m+2]); // rounded diameter double diameter = buf[m++]; - fmt::print(fp,"{}\n",diameter); + utils::print(fp,"{}\n",diameter); return m; } diff --git a/src/BODY/body_rounded_polyhedron.cpp b/src/BODY/body_rounded_polyhedron.cpp index f34a212087..bd16dac96c 100644 --- a/src/BODY/body_rounded_polyhedron.cpp +++ b/src/BODY/body_rounded_polyhedron.cpp @@ -476,7 +476,7 @@ int BodyRoundedPolyhedron::write_data_body(FILE *fp, double *buf) // atomID ninteger ndouble - fmt::print(fp,"{} {} {}\n",ubuf(buf[m]).i,ubuf(buf[m+1]).i,ubuf(buf[m+2]).i); + utils::print(fp,"{} {} {}\n",ubuf(buf[m]).i,ubuf(buf[m+1]).i,ubuf(buf[m+2]).i); m += 3; // nvert, nedge, nface @@ -484,27 +484,27 @@ int BodyRoundedPolyhedron::write_data_body(FILE *fp, double *buf) const int nsub = (int) ubuf(buf[m++]).i; const int nedge = (int) ubuf(buf[m++]).i; const int nface = (int) ubuf(buf[m++]).i; - fmt::print(fp,"{} {} {}\n",nsub,nedge,nface); + utils::print(fp,"{} {} {}\n",nsub,nedge,nface); // inertia - fmt::print(fp,"{} {} {} {} {} {}\n", + utils::print(fp,"{} {} {} {} {} {}\n", buf[m+0],buf[m+1],buf[m+2],buf[m+3],buf[m+4],buf[m+5]); m += 6; // nsub vertices for (int i = 0; i < nsub; i++, m+=3) - fmt::print(fp,"{} {} {}\n",buf[m],buf[m+1],buf[m+2]); + utils::print(fp,"{} {} {}\n",buf[m],buf[m+1],buf[m+2]); // nedge 2-tuples and nface 4-tuples // unless nsub = 1 or 2 if (nsub > 2) { for (int i = 0; i < nedge; i++, m+=2) - fmt::print(fp,"{} {}\n",static_cast (buf[m]),static_cast (buf[m+1])); + utils::print(fp,"{} {}\n",static_cast (buf[m]),static_cast (buf[m+1])); for (int i = 0; i < nface; i++, m+=4) - fmt::print(fp,"{} {} {} {}\n", + utils::print(fp,"{} {} {} {}\n", static_cast (buf[m]),static_cast (buf[m+1]), static_cast (buf[m+2]),static_cast (buf[m+3])); } @@ -512,7 +512,7 @@ int BodyRoundedPolyhedron::write_data_body(FILE *fp, double *buf) // rounded diameter double diameter = buf[m++]; - fmt::print(fp,"{}\n",diameter); + utils::print(fp,"{}\n",diameter); return m; } diff --git a/src/DPD-REACT/fix_rx.cpp b/src/DPD-REACT/fix_rx.cpp index fe7538bd10..71a90607e5 100644 --- a/src/DPD-REACT/fix_rx.cpp +++ b/src/DPD-REACT/fix_rx.cpp @@ -119,7 +119,7 @@ FixRX::FixRX(LAMMPS *lmp, int narg, char **arg) : + " expected \"sparse\" or \"dense\"\n"); if (comm->me == 0 && Verbosity > 1) - error->message(FLERR, fmt::format("FixRX: matrix format is {}",word)); + error->message(FLERR, fmt::format("FixRX: matrix format is {}", word)); } // Determine the ODE solver/stepper strategy in arg[6]. @@ -157,7 +157,7 @@ FixRX::FixRX(LAMMPS *lmp, int narg, char **arg) : minSteps = utils::inumeric(FLERR,arg[iarg++],false,lmp); if (comm->me == 0 && Verbosity > 1) - error->message(FLERR,fmt::format("FixRX: RK4 numSteps= {}", minSteps)); + error->message(FLERR, fmt::format("FixRX: RK4 numSteps= {}", minSteps)); } else if (odeIntegrationFlag == ODE_LAMMPS_RK4 && narg>8) { error->all(FLERR,"Illegal fix rx command. Too many arguments for RK4 solver."); } else if (odeIntegrationFlag == ODE_LAMMPS_RKF45) { @@ -307,12 +307,19 @@ void FixRX::post_constructor() id_fix_species = utils::strdup(std::string(id)+"_SPECIES"); id_fix_species_old = utils::strdup(std::string(id)+"_SPECIES_OLD"); - const std::string fmtstr = "{} {} property/atom "; - auto newcmd1 = fmt::format(fmtstr,id_fix_species,group->names[igroup]); - auto newcmd2 = fmt::format(fmtstr,id_fix_species_old,group->names[igroup]); + std::string newcmd1 = id_fix_species; + newcmd1 += " "; + newcmd1 += group->names[igroup]; + newcmd1 += " property/atom "; + + std::string newcmd2 = id_fix_species_old; + newcmd2 += " "; + newcmd2 += group->names[igroup]; + newcmd2 += " property/atom "; + for (int ii=0; iiall(FLERR,"Illegal compute temp command"); + if (narg != 3) error->all(FLERR, "Incorrect number of arguments for compute temp/drude"); vector_flag = 1; scalar_flag = 1; @@ -42,7 +40,7 @@ ComputeTempDrude::ComputeTempDrude(LAMMPS *lmp, int narg, char **arg) : extlist = new int[6]; extlist[0] = extlist[1] = 0; extlist[2] = extlist[3] = extlist[4] = extlist[5] = 1; - tempflag = 0; // because does not compute a single temperature (scalar and vector) + tempflag = 0; // because does not compute a single temperature (scalar and vector) vector = new double[size_vector]; fix_drude = nullptr; @@ -65,11 +63,13 @@ void ComputeTempDrude::init() { // Fix drude already checks that there is only one fix drude instance auto &fixes = modify->get_fix_by_style("^drude$"); - if (fixes.size() == 0) error->all(FLERR, "compute temp/drude requires fix drude"); + if (fixes.size() == 0) + error->all(FLERR, Error::NOLASTLINE, "compute temp/drude requires fix drude"); fix_drude = dynamic_cast(fixes[0]); if (!comm->ghost_velocity) - error->all(FLERR,"compute temp/drude requires ghost velocities. Use comm_modify vel yes"); + error->all(FLERR, Error::NOLASTLINE, + "compute temp/drude requires ghost velocities. Use comm_modify vel yes"); } /* ---------------------------------------------------------------------- */ @@ -93,15 +93,15 @@ void ComputeTempDrude::dof_compute() bigint dof_core_loc = 0, dof_drude_loc = 0; for (int i = 0; i < nlocal; i++) { if (atom->mask[i] & groupbit) { - if (drudetype[type[i]] == DRUDE_TYPE) // Non-polarizable atom - dof_drude_loc++; + if (drudetype[type[i]] == DRUDE_TYPE) // Non-polarizable atom + dof_drude_loc++; else - dof_core_loc++; + dof_core_loc++; } } dof_core_loc *= dim; dof_drude_loc *= dim; - MPI_Allreduce(&dof_core_loc, &dof_core, 1, MPI_LMP_BIGINT, MPI_SUM, world); + MPI_Allreduce(&dof_core_loc, &dof_core, 1, MPI_LMP_BIGINT, MPI_SUM, world); MPI_Allreduce(&dof_drude_loc, &dof_drude, 1, MPI_LMP_BIGINT, MPI_SUM, world); dof_core -= fix_dof; vector[2] = dof_core; @@ -112,19 +112,19 @@ void ComputeTempDrude::dof_compute() int ComputeTempDrude::modify_param(int narg, char **arg) { - if (strcmp(arg[0],"temp") == 0) { - if (narg < 2) error->all(FLERR,"Illegal fix_modify command"); - delete [] id_temp; + if (strcmp(arg[0], "temp") == 0) { + if (narg < 2) utils::missing_cmd_args(FLERR, "compute_modify temp", error); + delete[] id_temp; id_temp = utils::strdup(arg[1]); temperature = modify->get_compute_by_id(id_temp); if (!temperature) - error->all(FLERR,"Could not find fix_modify temperature compute {}", id_temp); + error->all(FLERR, "Could not find fix_modify temperature compute {}", id_temp); if (temperature->tempflag == 0) error->all(FLERR, "Fix_modify temperature compute {} does not compute temperature", id_temp); if (temperature->igroup != igroup && comm->me == 0) - error->warning(FLERR,"Group for fix_modify temp != fix group"); + error->warning(FLERR, "Group for fix_modify temp != fix group"); return 2; } return 0; @@ -134,83 +134,95 @@ int ComputeTempDrude::modify_param(int narg, char **arg) void ComputeTempDrude::compute_vector() { - invoked_vector = update->ntimestep; + invoked_vector = update->ntimestep; - int nlocal = atom->nlocal; - int *mask = atom->mask; - int *type = atom->type; - double *rmass = atom->rmass, *mass = atom->mass; - double **v = atom->v; - tagint *drudeid = fix_drude->drudeid; - int *drudetype = fix_drude->drudetype; - int dim = domain->dimension; - double mvv2e = force->mvv2e, kb = force->boltz; + int nlocal = atom->nlocal; + int *mask = atom->mask; + int *type = atom->type; + double *rmass = atom->rmass, *mass = atom->mass; + double **v = atom->v; + tagint *drudeid = fix_drude->drudeid; + int *drudetype = fix_drude->drudetype; + int dim = domain->dimension; + double mvv2e = force->mvv2e, kb = force->boltz; - double mcore, mdrude; - double ecore, edrude; - double *vcore, *vdrude; - double kineng_core_loc = 0., kineng_drude_loc = 0.; - for (int i=0; iremove_bias(i, vcore); - for (int k=0; krestore_bias(i, vcore); - if (rmass) mcore = rmass[i]; - else mcore = mass[type[i]]; - kineng_core_loc += mcore * ecore; - } else { // CORE_TYPE - int j = atom->map(drudeid[i]); - if (rmass) { - mcore = rmass[i]; - mdrude = rmass[j]; - } else { - mcore = mass[type[i]]; - mdrude = mass[type[j]]; - } - double mtot_inv = 1. / (mcore + mdrude); - ecore = 0.; - edrude = 0.; - vcore = v[i]; - vdrude = v[j]; - if (temperature) { - temperature->remove_bias(i, vcore); - temperature->remove_bias(j, vdrude); - } - for (int k=0; krestore_bias(i, vcore); - temperature->restore_bias(j, vdrude); - } - kineng_core_loc += mtot_inv * ecore; - kineng_drude_loc += mtot_inv * mcore * mdrude * edrude; - } + double mcore, mdrude; + double ecore, edrude; + double *vcore, *vdrude; + double kineng_core_loc = 0.0, kineng_drude_loc = 0.0; + for (int i = 0; i < nlocal; i++) { + vdrude = nullptr; + vcore = nullptr; + if (groupbit & mask[i] && drudetype[type[i]] != DRUDE_TYPE) { + if (drudetype[type[i]] == NOPOL_TYPE) { + ecore = 0.0; + vcore = v[i]; + if (temperature) temperature->remove_bias(i, vcore); + for (int k = 0; k < dim; k++) ecore += vcore[k] * vcore[k]; + if (temperature) temperature->restore_bias(i, vcore); + if (rmass) + mcore = rmass[i]; + else + mcore = mass[type[i]]; + kineng_core_loc += mcore * ecore; + } else { // CORE_TYPE + int j = atom->map(drudeid[i]); + if (j < 0) { + if (drudeid[i] == 0) { + error->one(FLERR, "Drude atom for core atom ID {} is not defined", atom->tag[i]); + } else { + error->one(FLERR, "Drude atom ID {} for core atom ID {} is out of range", drudeid[i], + atom->tag[i]); + } } + if (rmass) { + mcore = rmass[i]; + mdrude = rmass[j]; + } else { + mcore = mass[type[i]]; + mdrude = mass[type[j]]; + } + double mtot_inv = 1.0 / (mcore + mdrude); + ecore = 0.0; + edrude = 0.0; + vcore = v[i]; + vdrude = v[j]; + if (temperature) { + temperature->remove_bias(i, vcore); + temperature->remove_bias(j, vdrude); + } + for (int k = 0; k < dim; k++) { + double v1 = mdrude * vdrude[k] + mcore * vcore[k]; + ecore += v1 * v1; + double v2 = vdrude[k] - vcore[k]; + edrude += v2 * v2; + } + if (temperature) { + temperature->restore_bias(i, vcore); + temperature->restore_bias(j, vdrude); + } + kineng_core_loc += mtot_inv * ecore; + kineng_drude_loc += mtot_inv * mcore * mdrude * edrude; + } } + } - if (dynamic) dof_compute(); - kineng_core_loc *= 0.5 * mvv2e; - kineng_drude_loc *= 0.5 * mvv2e; - MPI_Allreduce(&kineng_core_loc,&kineng_core,1,MPI_DOUBLE,MPI_SUM,world); - MPI_Allreduce(&kineng_drude_loc,&kineng_drude,1,MPI_DOUBLE,MPI_SUM,world); - temp_core = 2.0 * kineng_core / (dof_core * kb); - temp_drude = 2.0 * kineng_drude / (dof_drude * kb); - vector[0] = temp_core; - vector[1] = temp_drude; - vector[4] = kineng_core; - vector[5] = kineng_drude; + if (dynamic) dof_compute(); + kineng_core_loc *= 0.5 * mvv2e; + kineng_drude_loc *= 0.5 * mvv2e; + MPI_Allreduce(&kineng_core_loc, &kineng_core, 1, MPI_DOUBLE, MPI_SUM, world); + MPI_Allreduce(&kineng_drude_loc, &kineng_drude, 1, MPI_DOUBLE, MPI_SUM, world); + temp_core = 2.0 * kineng_core / (dof_core * kb); + temp_drude = 2.0 * kineng_drude / (dof_drude * kb); + vector[0] = temp_core; + vector[1] = temp_drude; + vector[4] = kineng_core; + vector[5] = kineng_drude; } -double ComputeTempDrude::compute_scalar() { - compute_vector(); - scalar = vector[0]; - return scalar; +double ComputeTempDrude::compute_scalar() +{ + compute_vector(); + scalar = vector[0]; + return scalar; } - diff --git a/src/DRUDE/compute_temp_drude.h b/src/DRUDE/compute_temp_drude.h index 096bb7ae54..06152d8c90 100644 --- a/src/DRUDE/compute_temp_drude.h +++ b/src/DRUDE/compute_temp_drude.h @@ -32,7 +32,7 @@ class ComputeTempDrude : public Compute { void setup() override; void compute_vector() override; double compute_scalar() override; - int modify_param(int, char **); + int modify_param(int, char **) override; private: class FixDrude *fix_drude; diff --git a/src/DRUDE/fix_drude.cpp b/src/DRUDE/fix_drude.cpp index 6c0c84861a..478b3ae35b 100644 --- a/src/DRUDE/fix_drude.cpp +++ b/src/DRUDE/fix_drude.cpp @@ -33,7 +33,9 @@ using namespace FixConst; FixDrude::FixDrude(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg) { - if (narg != 3 + atom->ntypes) error->all(FLERR,"Illegal fix drude command"); + if (narg != 3 + atom->ntypes) + error->all(FLERR,"Incorrect number of arguments ({} instead of {}) for fix drude command", + narg, 3 + atom->ntypes); comm_border = 1; // drudeid special_alter_flag = 1; @@ -49,7 +51,7 @@ FixDrude::FixDrude(LAMMPS *lmp, int narg, char **arg) : else if (arg[i][0] == 'd' || arg[i][0] == 'D' || arg[i][0] == '2') drudetype[i-2] = DRUDE_TYPE; else - error->all(FLERR, "Illegal fix drude command"); + error->all(FLERR, i, "Unknown drude type {} for atom type {}", arg[i], i-2); } drudeid = nullptr; @@ -82,7 +84,8 @@ FixDrude::~FixDrude() void FixDrude::init() { - if (modify->get_fix_by_style("^drude$").size() > 1) error->all(FLERR,"More than one fix drude"); + if (modify->get_fix_by_style("^drude$").size() > 1) + error->all(FLERR, Error::NOLASTLINE, "More than one fix drude"); if (!rebuildflag) rebuild_special(); } @@ -106,8 +109,7 @@ void FixDrude::build_drudeid() { std::vector core_drude_vec; partner_set = new std::set[nlocal]; // Temporary sets of bond partner tags - if (atom->molecular == Atom::MOLECULAR) - { + if (atom->molecular == Atom::MOLECULAR) { // Build list of my atoms' bond partners for (int i=0; ibond_atom[i][k]); } } - } - else - { + } else { // Template case class Molecule **atommols; atommols = atom->avec->onemols; @@ -157,10 +157,17 @@ void FixDrude::build_drudeid() { // At this point each of my Drudes knows its core. // Send my list of Drudes to other procs and myself // so that each core finds its Drude. - comm->ring(drude_vec.size(), sizeof(tagint), - (char *) drude_vec.data(), + comm->ring(drude_vec.size(), sizeof(tagint), (char *) drude_vec.data(), 3, ring_search_drudeid, nullptr, (void *)this, 1); - delete [] partner_set; + delete[] partner_set; + + // Check if all cores have a drude particle attached + for (int i=0; ione(FLERR, Error::NOLASTLINE, "Core atom ID {} has no drude atom", atom->tag[i]); + } + } } /* ---------------------------------------------------------------------- @@ -347,7 +354,8 @@ void FixDrude::rebuild_special() { utils::logmesg(lmp, "New max number of 1-2 to 1-4 neighbors: {} (+{})\n", nspecmax, nspecmax - nspecmax_old); if (atom->maxspecial < nspecmax) - error->all(FLERR, "Not enough space in special: extra/special/per/atom should be at least {}", nspecmax - nspecmax_old); + error->all(FLERR, Error::NOLASTLINE, "Not enough space for special neighbors list: " + "use extra/special/per/atom with at least a value of {}", nspecmax - nspecmax_old); // Build list of cores' special lists to communicate to ghost drude particles for (int i=0; itype[i]] != NOPOL_TYPE) { if (atom->nspecial[i] == nullptr) - error->all(FLERR, "Polarizable atoms cannot be inserted with special lists info from the molecule template"); + error->all(FLERR, Error::NOLASTLINE, "Polarizable atoms cannot be inserted " + "with special lists info from the molecule template"); drudeid[i] = atom->special[i][0]; // Drude partner should be at first place in the special list } else { drudeid[i] = 0; diff --git a/src/ELECTRODE/fix_electrode_conp.cpp b/src/ELECTRODE/fix_electrode_conp.cpp index a50984fe17..a64eb5f71d 100644 --- a/src/ELECTRODE/fix_electrode_conp.cpp +++ b/src/ELECTRODE/fix_electrode_conp.cpp @@ -1363,10 +1363,10 @@ int FixElectrodeConp::setmask() void FixElectrodeConp::write_to_file(FILE *file, const std::vector &tags, const std::vector> &mat) { - for (const auto &t : tags) fmt::print(file, "{:20}", t); + for (const auto &t : tags) utils::print(file, "{:20}", t); fputs("\n", file); for (const auto &vec : mat) { - for (const auto &x : vec) fmt::print(file, "{:20.11e}", x); + for (const auto &x : vec) utils::print(file, "{:20.11e}", x); fputs("\n", file); } } diff --git a/src/EXTRA-COMMAND/group2ndx.cpp b/src/EXTRA-COMMAND/group2ndx.cpp index 56bf848923..e19d16f0f5 100644 --- a/src/EXTRA-COMMAND/group2ndx.cpp +++ b/src/EXTRA-COMMAND/group2ndx.cpp @@ -93,7 +93,7 @@ void Group2Ndx::write_group(FILE *fp, int gid) if (gid == 0) { fputs("[ System ]\n", fp); } else { - fmt::print(fp, "[ {} ]\n", group->names[gid]); + utils::print(fp, "[ {} ]\n", group->names[gid]); } width = log10((double) atom->natoms) + 2; cols = 80 / width; @@ -142,7 +142,7 @@ void Group2Ndx::write_group(FILE *fp, int gid) if (fp) { int i, j; for (i = 0, j = 0; i < gcount; ++i) { - fmt::print(fp, "{:>{}}", recvlist[i], width); + utils::print(fp, "{:>{}}", recvlist[i], width); ++j; if (j == cols) { fputs("\n", fp); diff --git a/src/EXTRA-COMPUTE/compute_adf.cpp b/src/EXTRA-COMPUTE/compute_adf.cpp index 108e03e371..2481b441d9 100644 --- a/src/EXTRA-COMPUTE/compute_adf.cpp +++ b/src/EXTRA-COMPUTE/compute_adf.cpp @@ -39,8 +39,6 @@ using MathConst::RAD2DEG; enum { DEGREE, RADIAN, COSINE }; -static constexpr double BIG = 1.0e20; - /* ---------------------------------------------------------------------- compute angular distribution functions for I, J, K atoms ---------------------------------------------------------------------- */ diff --git a/src/EXTRA-COMPUTE/compute_stress_cartesian.cpp b/src/EXTRA-COMPUTE/compute_stress_cartesian.cpp index b8946b3647..9d3bcb92ca 100644 --- a/src/EXTRA-COMPUTE/compute_stress_cartesian.cpp +++ b/src/EXTRA-COMPUTE/compute_stress_cartesian.cpp @@ -284,9 +284,9 @@ void ComputeStressCartesian::compute_array() // calculate number density and kinetic contribution to pressure if (compute_ke) { for (int i = 0; i < nlocal; i++) { - int bin1 = (int) ((x[i][dir1] - boxlo[dir1]) / bin_width1) % nbins1; + int bin1 = (int) floor((x[i][dir1] - boxlo[dir1]) / bin_width1) % nbins1; int bin2 = 0; - if (dims == 2) bin2 = (int) ((x[i][dir2] - boxlo[dir2]) / bin_width2) % nbins2; + if (dims == 2) bin2 = (int) floor((x[i][dir2] - boxlo[dir2]) / bin_width2) % nbins2; // Apply periodic boundary conditions and avoid out of range access if (domain->periodicity[dir1] == 1) { @@ -453,27 +453,6 @@ void ComputeStressCartesian::compute_pressure(double fpair, double xi, double yi int bin1 = next_bin1; int bin2 = next_bin2; - double l1; - if (rij1 > 0) - l1 = ((bin1 + 1) * bin_width1 - xi) / rij1; - else - l1 = (bin1 * bin_width1 - xi) / rij1; - - double l2; - if (rij2 > 0) - l2 = ((bin2 + 1) * bin_width2 - yi) / rij2; - else - l2 = (bin2 * bin_width2 - yi) / rij2; - - if ((l1 < l2 || l2 < lb + SMALL) && l1 <= 1.0 && l1 > lb) { - lb = l1; - next_bin1 = bin1 + (int) (rij1 / fabs(rij1)); - } else if (l2 <= 1.0 && l2 > lb) { - lb = l2; - next_bin2 = bin2 + (int) (rij2 / fabs(rij2)); - } else - lb = 1.0; - // Periodic boundary conditions if (domain->periodicity[dir1] == 1) { if (bin1 < 0) @@ -495,6 +474,33 @@ void ComputeStressCartesian::compute_pressure(double fpair, double xi, double yi else if (bin2 >= nbins2) bin2 = nbins2 - 1; + double l1; + double tmp1[3] = {0.0, 0.0, 0.0}; + if (rij1 > 0) + tmp1[dir1] = (bin1 + 1) * bin_width1 - xi; + else + tmp1[dir1] = bin1 * bin_width1 - xi; + domain->minimum_image(tmp1[0],tmp1[1],tmp1[2]); + l1 = tmp1[dir1] / rij1; + + double l2; + double tmp2[3] = {0.0, 0.0, 0.0}; + if (rij2 > 0) + tmp2[dir2] = (bin2 + 1) * bin_width2 - yi; + else + tmp2[dir2] = bin2 * bin_width2 - yi; + domain->minimum_image(tmp2[0],tmp2[1],tmp2[2]); + l2 = tmp2[dir2] / rij2; + + if ((dims == 1 || l1 < l2 || l2 < lb + SMALL) && l1 <= 1.0 && l1 > lb) { + lb = l1; + next_bin1 = bin1 + (int) (rij1 / fabs(rij1)); + } else if (dims == 2 && l2 <= 1.0 && l2 > lb) { + lb = l2; + next_bin2 = bin2 + (int) (rij2 / fabs(rij2)); + } else + lb = 1.0; + if (bin1 + bin2 * nbins1 > nbins1 * nbins2) error->all(FLERR, "Bin outside: lb={:.16g}", lb); tpcxx[bin1 + bin2 * nbins1] += (fpair * delx * delx * (lb - la)); diff --git a/src/EXTRA-DUMP/dump_yaml.cpp b/src/EXTRA-DUMP/dump_yaml.cpp index 6c21c24f77..c26b0591e2 100644 --- a/src/EXTRA-DUMP/dump_yaml.cpp +++ b/src/EXTRA-DUMP/dump_yaml.cpp @@ -94,31 +94,31 @@ void DumpYAML::write_header(bigint ndump) if (comm->me == 0) { const std::string boundary(boundstr); - fmt::print(fp, "---\ncreator: LAMMPS\ntimestep: {}\n", update->ntimestep); - if (unit_flag) fmt::print(fp, "units: {}\n", update->unit_style); - if (time_flag) fmt::print(fp, "time: {:.16g}\n", compute_time()); + utils::print(fp, "---\ncreator: LAMMPS\ntimestep: {}\n", update->ntimestep); + if (unit_flag) utils::print(fp, "units: {}\n", update->unit_style); + if (time_flag) utils::print(fp, "time: {:.16g}\n", compute_time()); - fmt::print(fp, "natoms: {}\n", ndump); + utils::print(fp, "natoms: {}\n", ndump); fputs("boundary: [ ", fp); for (const auto &bflag : boundary) { if (bflag == ' ') continue; - fmt::print(fp, "{}, ", bflag); + utils::print(fp, "{}, ", bflag); } fputs("]\n", fp); - if (thermo) fmt::print(fp, thermo_data); + if (thermo) utils::print(fp, thermo_data); - fmt::print(fp, "box:\n - [ {}, {} ]\n", boxxlo, boxxhi); - fmt::print(fp, " - [ {}, {} ]\n", boxylo, boxyhi); - fmt::print(fp, " - [ {}, {} ]\n", boxzlo, boxzhi); - if (domain->triclinic) fmt::print(fp, " - [ {}, {}, {} ]\n", boxxy, boxxz, boxyz); + utils::print(fp, "box:\n - [ {}, {} ]\n", boxxlo, boxxhi); + utils::print(fp, " - [ {}, {} ]\n", boxylo, boxyhi); + utils::print(fp, " - [ {}, {} ]\n", boxzlo, boxzhi); + if (domain->triclinic) utils::print(fp, " - [ {}, {}, {} ]\n", boxxy, boxxz, boxyz); - fmt::print(fp, "keywords: [ "); + utils::print(fp, "keywords: [ "); for (const auto &item : utils::split_words(columns)) { if (item.find_first_of(special_chars) == std::string::npos) - fmt::print(fp, "{}, ", item); + utils::print(fp, "{}, ", item); else - fmt::print(fp, "'{}', ", item); + utils::print(fp, "'{}', ", item); } fputs(" ]\ndata:\n", fp); } else // reset so that the remainder of the output is not multi-proc diff --git a/src/EXTRA-FIX/fix_ave_correlate_long.cpp b/src/EXTRA-FIX/fix_ave_correlate_long.cpp index abb1ad87de..557e416275 100644 --- a/src/EXTRA-FIX/fix_ave_correlate_long.cpp +++ b/src/EXTRA-FIX/fix_ave_correlate_long.cpp @@ -489,7 +489,7 @@ void FixAveCorrelateLong::end_of_step() if (fp && comm->me == 0) { clearerr(fp); if (overwrite) (void) platform::fseek(fp,filepos); - fmt::print(fp,"# Timestep: {}\n", ntimestep); + utils::print(fp,"# Timestep: {}\n", ntimestep); for (unsigned int i=0; i < npcorr; ++i) { fprintf(fp, "%lg ", t[i]*update->dt*nevery); for (int j=0; j < npair; ++j) { diff --git a/src/EXTRA-FIX/fix_electron_stopping_fit.cpp b/src/EXTRA-FIX/fix_electron_stopping_fit.cpp index 2657ddc85f..c9cca2679d 100644 --- a/src/EXTRA-FIX/fix_electron_stopping_fit.cpp +++ b/src/EXTRA-FIX/fix_electron_stopping_fit.cpp @@ -68,7 +68,8 @@ FixElectronStoppingFit::FixElectronStoppingFit(LAMMPS *lmp, int narg, char **arg error->all(FLERR,"Incorrect number of fix electron/stopping/fit arguments"); } - scalar_flag = 1; + scalar_flag = 1; // intensive total energy loss since start of run + extscalar = 0; global_freq = 1; energy_coh_in = new double[atom->ntypes+1]; diff --git a/src/EXTRA-FIX/fix_tmd.cpp b/src/EXTRA-FIX/fix_tmd.cpp index 242efcf41c..aac069dc9d 100644 --- a/src/EXTRA-FIX/fix_tmd.cpp +++ b/src/EXTRA-FIX/fix_tmd.cpp @@ -270,7 +270,7 @@ void FixTMD::initial_integrate(int /*vflag*/) work_lambda += lambda*(rho_target - rho_old); if (!(update->ntimestep % nfileevery) && (previous_stat != update->ntimestep)) { - fmt::print(fp, "{} {} {} {} {} {} {} {}\n", update->ntimestep,rho_target,rho_old, + utils::print(fp, "{} {} {} {} {} {} {} {}\n", update->ntimestep,rho_target,rho_old, gamma_back,gamma_forward,lambda,work_lambda,work_analytical); fflush(fp); previous_stat = update->ntimestep; diff --git a/src/EXTRA-FIX/fix_ttm.cpp b/src/EXTRA-FIX/fix_ttm.cpp index f5f3aa457e..1609d6285a 100644 --- a/src/EXTRA-FIX/fix_ttm.cpp +++ b/src/EXTRA-FIX/fix_ttm.cpp @@ -523,7 +523,7 @@ void FixTTM::write_electron_temperatures(const std::string &filename) FILE *fp = fopen(filename.c_str(),"w"); if (!fp) error->one(FLERR,"Fix ttm could not open output file {}: {}", filename,utils::getsyserror()); - fmt::print(fp,"# DATE: {} UNITS: {} COMMENT: Electron temperature on " + utils::print(fp,"# DATE: {} UNITS: {} COMMENT: Electron temperature on " "{}x{}x{} grid at step {} - created by fix {}\n", utils::current_date(), update->unit_style, nxgrid, nygrid, nzgrid, update->ntimestep, style); diff --git a/src/EXTRA-FIX/fix_ttm_grid.cpp b/src/EXTRA-FIX/fix_ttm_grid.cpp index d9c6f13e2f..49a186a3ee 100644 --- a/src/EXTRA-FIX/fix_ttm_grid.cpp +++ b/src/EXTRA-FIX/fix_ttm_grid.cpp @@ -411,7 +411,7 @@ void FixTTMGrid::write_restart_file(const char *file) if (fpout == nullptr) error->one(FLERR,"Cannot open fix ttm/grid restart file {}: {}",outfile,utils::getsyserror()); - fmt::print(fpout,"# DATE: {} UNITS: {} COMMENT: " + utils::print(fpout,"# DATE: {} UNITS: {} COMMENT: " "Electron temperature on {}x{}x{} grid at step {} - " "created by fix {}\n", utils::current_date(),update->unit_style, diff --git a/src/EXTRA-FIX/fix_ttm_mod.cpp b/src/EXTRA-FIX/fix_ttm_mod.cpp index 6ad3ca1b0a..6d6e9c0638 100644 --- a/src/EXTRA-FIX/fix_ttm_mod.cpp +++ b/src/EXTRA-FIX/fix_ttm_mod.cpp @@ -628,7 +628,7 @@ void FixTTMMod::write_electron_temperatures(const std::string &filename) FILE *fp = fopen(filename.c_str(),"w"); if (!fp) error->one(FLERR,"Fix ttm/mod could not open output file {}: {}", filename, utils::getsyserror()); - fmt::print(fp,"# DATE: {} UNITS: {} COMMENT: Electron temperature " + utils::print(fp,"# DATE: {} UNITS: {} COMMENT: Electron temperature " "{}x{}x{} grid at step {}. Created by fix {}\n", utils::current_date(), update->unit_style, nxgrid, nygrid, nzgrid, update->ntimestep, style); diff --git a/src/EXTRA-MOLECULE/pair_hbond_dreiding_lj_angleoffset.cpp b/src/EXTRA-MOLECULE/pair_hbond_dreiding_lj_angleoffset.cpp new file mode 100644 index 0000000000..02ac009773 --- /dev/null +++ b/src/EXTRA-MOLECULE/pair_hbond_dreiding_lj_angleoffset.cpp @@ -0,0 +1,131 @@ +// clang-format off +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing author: Tod A Pascal (Caltech), Don Xu/EiPi Fun +------------------------------------------------------------------------- */ + +#include "pair_hbond_dreiding_lj_angleoffset.h" + +#include "atom.h" +#include "atom_vec.h" +#include "domain.h" +#include "error.h" +#include "force.h" +#include "math_const.h" +#include "math_special.h" +#include "memory.h" +#include "molecule.h" +#include "neigh_list.h" +#include "neighbor.h" + +#include +#include + +static constexpr double SMALL = 0.001; +static constexpr int CHUNK = 8; + +using namespace LAMMPS_NS; +using namespace MathConst; +// using namespace MathSpecial; + +/* ---------------------------------------------------------------------- */ + +PairHbondDreidingLJAngleoffset::PairHbondDreidingLJAngleoffset(LAMMPS *lmp) + : PairHbondDreidingLJ(lmp) { + + angle_offset_flag = 1; +} + +/* ---------------------------------------------------------------------- + set coeffs for one or more type pairs +------------------------------------------------------------------------- */ + +void PairHbondDreidingLJAngleoffset::coeff(int narg, char **arg) +{ + if (narg < 6 || narg > 11) + error->all(FLERR,"Incorrect args for pair coefficients"); + if (!allocated) allocate(); + + int ilo,ihi,jlo,jhi,klo,khi; + utils::bounds(FLERR, arg[0], 1, atom->ntypes, ilo, ihi, error); + utils::bounds(FLERR, arg[1], 1, atom->ntypes, jlo, jhi, error); + utils::bounds_typelabel(FLERR, arg[2], 1, atom->ntypes, klo, khi, lmp, Atom::ATOM); + + int donor_flag; + if (strcmp(arg[3],"i") == 0) donor_flag = 0; + else if (strcmp(arg[3],"j") == 0) donor_flag = 1; + else error->all(FLERR,"Incorrect args for pair coefficients"); + + double epsilon_one = utils::numeric(FLERR, arg[4], false, lmp); + double sigma_one = utils::numeric(FLERR, arg[5], false, lmp); + + int ap_one = ap_global; + if (narg > 6) ap_one = utils::inumeric(FLERR, arg[6], false, lmp); + double cut_inner_one = cut_inner_global; + double cut_outer_one = cut_outer_global; + if (narg > 8) { + cut_inner_one = utils::numeric(FLERR, arg[7], false, lmp); + cut_outer_one = utils::numeric(FLERR, arg[8], false, lmp); + } + if (cut_inner_one>cut_outer_one) + error->all(FLERR,"Pair inner cutoff >= Pair outer cutoff"); + double cut_angle_one = cut_angle_global; + if (narg > 9) cut_angle_one = utils::numeric(FLERR, arg[9], false, lmp) * MY_PI/180.0; + double angle_offset_one = angle_offset_global; + if (narg == 11) angle_offset_one = (180.0 - utils::numeric(FLERR, arg[10], false, lmp)) * MY_PI/180.0; + if (angle_offset_one < 0.0 || angle_offset_one > 90.0 * MY_PI/180.0) + error->all(FLERR,"Illegal angle offset"); + + // grow params array if necessary + + if (nparams == maxparam) { + maxparam += CHUNK; + params = (Param *) memory->srealloc(params, maxparam*sizeof(Param), + "pair:params"); + + // make certain all addional allocated storage is initialized + // to avoid false positives when checking with valgrind + + memset(params + nparams, 0, CHUNK*sizeof(Param)); + } + + params[nparams].epsilon = epsilon_one; + params[nparams].sigma = sigma_one; + params[nparams].ap = ap_one; + params[nparams].cut_inner = cut_inner_one; + params[nparams].cut_outer = cut_outer_one; + params[nparams].cut_innersq = cut_inner_one*cut_inner_one; + params[nparams].cut_outersq = cut_outer_one*cut_outer_one; + params[nparams].cut_angle = cut_angle_one; + params[nparams].angle_offset = angle_offset_one; + params[nparams].denom_vdw = + (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq); + + // flag type2param with either i,j = D,A or j,i = D,A + + int count = 0; + for (int i = ilo; i <= ihi; i++) + for (int j = MAX(jlo,i); j <= jhi; j++) + for (int k = klo; k <= khi; k++) { + if (donor_flag == 0) type2param[i][j][k] = nparams; + else type2param[j][i][k] = nparams; + count++; + } + nparams++; + + if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients"); +} diff --git a/src/EXTRA-MOLECULE/pair_hbond_dreiding_lj_angleoffset.h b/src/EXTRA-MOLECULE/pair_hbond_dreiding_lj_angleoffset.h new file mode 100644 index 0000000000..5ae1fcba28 --- /dev/null +++ b/src/EXTRA-MOLECULE/pair_hbond_dreiding_lj_angleoffset.h @@ -0,0 +1,38 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#ifdef PAIR_CLASS +// clang-format off +PairStyle(hbond/dreiding/lj/angleoffset,PairHbondDreidingLJAngleoffset); +// clang-format on +#else + +#ifndef LMP_PAIR_HBOND_DREIDING_LJ_ANGLEOFFSET_H +#define LMP_PAIR_HBOND_DREIDING_LJ_ANGLEOFFSET_H + +#include "pair_hbond_dreiding_lj.h" + +namespace LAMMPS_NS { + +class PairHbondDreidingLJAngleoffset : public PairHbondDreidingLJ { + + public: + PairHbondDreidingLJAngleoffset(class LAMMPS *); + void coeff(int, char **) override; + +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/EXTRA-MOLECULE/pair_hbond_dreiding_morse_angleoffset.cpp b/src/EXTRA-MOLECULE/pair_hbond_dreiding_morse_angleoffset.cpp new file mode 100644 index 0000000000..21f26ea8d1 --- /dev/null +++ b/src/EXTRA-MOLECULE/pair_hbond_dreiding_morse_angleoffset.cpp @@ -0,0 +1,129 @@ +// clang-format off +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. + ------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing author: Tod A Pascal (Caltech), Don Xu/EiPi Fun +------------------------------------------------------------------------- */ + +#include "pair_hbond_dreiding_morse_angleoffset.h" + +#include "atom.h" +#include "atom_vec.h" +#include "domain.h" +#include "error.h" +#include "force.h" +#include "math_const.h" +#include "math_special.h" +#include "memory.h" +#include "molecule.h" +#include "neigh_list.h" +#include "neighbor.h" + +#include +#include + +using namespace LAMMPS_NS; +using namespace MathConst; + +static constexpr int CHUNK = 8; + +/* ---------------------------------------------------------------------- */ + +PairHbondDreidingMorseAngleoffset::PairHbondDreidingMorseAngleoffset(LAMMPS *lmp) : + PairHbondDreidingMorse(lmp) { + + angle_offset_flag = 1; +} + +/* ---------------------------------------------------------------------- + * set coeffs for one or more type pairs + * ---------------------------------------------------------------------- */ + +void PairHbondDreidingMorseAngleoffset::coeff(int narg, char **arg) +{ + if (narg < 7 || narg > 12) + error->all(FLERR,"Incorrect args for pair coefficients"); + if (!allocated) allocate(); + + int ilo,ihi,jlo,jhi,klo,khi; + utils::bounds(FLERR, arg[0], 1, atom->ntypes, ilo, ihi, error); + utils::bounds(FLERR, arg[1], 1, atom->ntypes, jlo, jhi, error); + utils::bounds_typelabel(FLERR, arg[2], 1, atom->ntypes, klo, khi, lmp, Atom::ATOM); + + int donor_flag; + if (strcmp(arg[3],"i") == 0) donor_flag = 0; + else if (strcmp(arg[3],"j") == 0) donor_flag = 1; + else error->all(FLERR,"Incorrect args for pair coefficients"); + + double d0_one = utils::numeric(FLERR, arg[4], false, lmp); + double alpha_one = utils::numeric(FLERR, arg[5], false, lmp); + double r0_one = utils::numeric(FLERR, arg[6], false, lmp); + + int ap_one = ap_global; + if (narg > 7) ap_one = utils::inumeric(FLERR, arg[7], false, lmp); + double cut_inner_one = cut_inner_global; + double cut_outer_one = cut_outer_global; + if (narg > 9) { + cut_inner_one = utils::numeric(FLERR, arg[8], false, lmp); + cut_outer_one = utils::numeric(FLERR, arg[9], false, lmp); + } + if (cut_inner_one>cut_outer_one) + error->all(FLERR,"Pair inner cutoff >= Pair outer cutoff"); + double cut_angle_one = cut_angle_global; + if (narg > 10) cut_angle_one = utils::numeric(FLERR, arg[10], false, lmp) * MY_PI/180.0; + double angle_offset_one = angle_offset_global; + if (narg == 12) angle_offset_one = (180.0 - utils::numeric(FLERR, arg[11], false, lmp)) * MY_PI/180.0; + if (angle_offset_one < 0.0 || angle_offset_one > 90.0 * MY_PI/180.0) + error->all(FLERR,"Illegal angle offset {}", angle_offset_one); + + // grow params array if necessary + + if (nparams == maxparam) { + maxparam += CHUNK; + params = (Param *) memory->srealloc(params, maxparam*sizeof(Param),"pair:params"); + + // make certain all addional allocated storage is initialized + // to avoid false positives when checking with valgrind + + memset(params + nparams, 0, CHUNK*sizeof(Param)); + } + + params[nparams].d0 = d0_one; + params[nparams].alpha = alpha_one; + params[nparams].r0 = r0_one; + params[nparams].ap = ap_one; + params[nparams].cut_inner = cut_inner_one; + params[nparams].cut_outer = cut_outer_one; + params[nparams].cut_innersq = cut_inner_one*cut_inner_one; + params[nparams].cut_outersq = cut_outer_one*cut_outer_one; + params[nparams].cut_angle = cut_angle_one; + params[nparams].angle_offset = angle_offset_one; + params[nparams].denom_vdw = (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq); + + // flag type2param with either i,j = D,A or j,i = D,A + + int count = 0; + for (int i = ilo; i <= ihi; i++) + for (int j = MAX(jlo,i); j <= jhi; j++) + for (int k = klo; k <= khi; k++) { + if (donor_flag == 0) type2param[i][j][k] = nparams; + else type2param[j][i][k] = nparams; + count++; + } + nparams++; + + if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients"); +} diff --git a/src/EXTRA-MOLECULE/pair_hbond_dreiding_morse_angleoffset.h b/src/EXTRA-MOLECULE/pair_hbond_dreiding_morse_angleoffset.h new file mode 100644 index 0000000000..20d2a8698d --- /dev/null +++ b/src/EXTRA-MOLECULE/pair_hbond_dreiding_morse_angleoffset.h @@ -0,0 +1,38 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#ifdef PAIR_CLASS +// clang-format off +PairStyle(hbond/dreiding/morse/angleoffset,PairHbondDreidingMorseAngleoffset); +// clang-format on +#else + +#ifndef LMP_PAIR_HBOND_DREIDING_MORSE_ANGLEOFFSET_H +#define LMP_PAIR_HBOND_DREIDING_MORSE_ANGLEOFFSET_H + +#include "pair_hbond_dreiding_morse.h" + +namespace LAMMPS_NS { + +class PairHbondDreidingMorseAngleoffset : public PairHbondDreidingMorse { + + public: + PairHbondDreidingMorseAngleoffset(class LAMMPS *); + void coeff(int, char **) override; + +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/GRANULAR/fix_granular_mdr.cpp b/src/GRANULAR/fix_granular_mdr.cpp new file mode 100644 index 0000000000..207d18d7aa --- /dev/null +++ b/src/GRANULAR/fix_granular_mdr.cpp @@ -0,0 +1,702 @@ +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing authors: + William Zunker (MIT), Sachith Dunatunga (MIT), + Dan Bolintineanu (SNL), Joel Clemmer (SNL) +----------------------------------------------------------------------- */ + +#include "fix_granular_mdr.h" + +#include "atom.h" +#include "comm.h" +#include "error.h" +#include "fix_wall_gran_region.h" +#include "fix_neigh_history.h" +#include "force.h" +#include "granular_model.h" +#include "gran_sub_mod_normal.h" +#include "input.h" +#include "math_const.h" +#include "memory.h" +#include "modify.h" +#include "neigh_list.h" +#include "pair.h" +#include "pair_granular.h" +#include "region.h" +#include "update.h" +#include "variable.h" + +using namespace LAMMPS_NS; +using namespace Granular_NS; +using namespace Granular_MDR_NS; +using namespace FixConst; +using MathConst::MY_PI; + +static constexpr double EPSILON = 1e-16; +static constexpr double OVERLAP_LIMIT = 0.75; + +enum {COMM_1, COMM_2}; + +/* ---------------------------------------------------------------------- */ + +FixGranularMDR::FixGranularMDR(LAMMPS *lmp, int narg, char **arg) : + Fix(lmp, narg, arg) +{ + comm_forward = 5; + create_attribute = 1; + + id_fix = nullptr; +} + +/* ---------------------------------------------------------------------- */ + +FixGranularMDR::~FixGranularMDR() +{ + if (id_fix && modify->nfix) + modify->delete_fix(id_fix); + delete[] id_fix; +} + +/* ---------------------------------------------------------------------- */ + +int FixGranularMDR::setmask() +{ + int mask = 0; + mask |= PRE_FORCE; + return mask; +} + +/* ---------------------------------------------------------------------- */ + +void FixGranularMDR::post_constructor() +{ + int tmp1, tmp2; + id_fix = utils::strdup("MDR_PARTICLE_HISTORY_VARIABLES"); + modify->add_fix(fmt::format("{} all property/atom d_Ro d_Vcaps d_Vgeo d_Velas d_eps_bar d_dRnumerator d_dRdenominator d_Acon0 d_Acon1 d_Atot d_Atot_sum d_ddelta_bar d_psi d_history_setup_flag d_sigmaxx d_sigmayy d_sigmazz ghost yes", id_fix)); + + index_Ro = atom->find_custom("Ro", tmp1, tmp2); + index_Vcaps = atom->find_custom("Vcaps", tmp1, tmp2); + index_Vgeo = atom->find_custom("Vgeo", tmp1, tmp2); + index_Velas = atom->find_custom("Velas", tmp1, tmp2); + index_eps_bar = atom->find_custom("eps_bar", tmp1, tmp2); + index_dRnumerator = atom->find_custom("dRnumerator", tmp1, tmp2); + index_dRdenominator = atom->find_custom("dRdenominator", tmp1, tmp2); + index_Acon0 = atom->find_custom("Acon0", tmp1, tmp2); + index_Acon1 = atom->find_custom("Acon1", tmp1, tmp2); + index_Atot = atom->find_custom("Atot", tmp1, tmp2); + index_Atot_sum = atom->find_custom("Atot_sum", tmp1, tmp2); + index_ddelta_bar = atom->find_custom("ddelta_bar", tmp1, tmp2); + index_psi = atom->find_custom("psi", tmp1, tmp2); + index_history_setup_flag = atom->find_custom("history_setup_flag", tmp1, tmp2); + index_sigmaxx = atom->find_custom("sigmaxx", tmp1, tmp2); + index_sigmayy = atom->find_custom("sigmayy", tmp1, tmp2); + index_sigmazz = atom->find_custom("sigmazz", tmp1, tmp2); +} + +/* ---------------------------------------------------------------------- */ + +void FixGranularMDR::setup_pre_force(int /*vflag*/) +{ + pair = dynamic_cast(force->pair_match("granular", 1)); + if (pair == nullptr) + error->all(FLERR, "Must use pair granular with MDR model"); + + if (force->newton) + error->all(FLERR, "MDR contact model requires Newton off"); + + // Confirm all MDR models are consistent + + class GranularModel *pair_model, *fix_model; + class GranularModel **models_list = pair->models_list; + class GranSubModNormalMDR *norm_model = nullptr; + for (int i = 0; i < pair->nmodels; i++) { + pair_model = models_list[i]; + if (pair_model->normal_model->name == "mdr") { + if (norm_model != nullptr) + error->all(FLERR, "Cannot currently define multiple MDR normal models in the pairstyle"); + norm_model = dynamic_cast(pair_model->normal_model); + } else { + error->all(FLERR, "Cannot combine MDR normal model with a different normal model in the pairstyle"); + } + } + + if (norm_model == nullptr) + error->all(FLERR, "Must specify MDR normal model with pair granular"); + psi_b_coeff = norm_model->psi_b; + + fix_wall_list = modify->get_fix_by_style("wall/gran/region"); + class GranSubModNormalMDR *norm_model2; + class FixWallGranRegion *fix; + for (int i = 0; i < fix_wall_list.size(); i++) { + if (!utils::strmatch(fix_wall_list[i]->style, "wall/gran/region")) + error->all(FLERR, "MDR model currently only supports fix wall/gran/region, not fix wall/gran"); + + fix = dynamic_cast(fix_wall_list[i]); + if (fix->model->normal_model->name != "mdr") + error->all(FLERR, "Fix wall/gran/region must use an MDR normal model when using an MDR pair model"); + + norm_model2 = dynamic_cast(fix->model->normal_model); + + if (norm_model->E != norm_model2->E) + error->all(FLERR, "Young's modulus in pair style, {}, does not agree with value {} in fix gran/wall/region", + norm_model->E, norm_model2->E); + if (norm_model->nu != norm_model2->nu) + error->all(FLERR, "Poisson's ratio in pair style, {}, does not agree with value {} in fix gran/wall/region", + norm_model->nu, norm_model2->nu); + if (norm_model->Y != norm_model2->Y) + error->all(FLERR, "Yield stress in pair style, {}, does not agree with value {} in fix gran/wall/region", + norm_model->Y, norm_model2->Y); + if (norm_model->psi_b != norm_model2->psi_b) + error->all(FLERR, "Bulk response trigger in pair style, {}, does not agree with value {} in fix gran/wall/region", + norm_model->psi_b, norm_model2->psi_b); + if (norm_model->CoR != norm_model2->CoR) + error->all(FLERR, "Coefficient of restitution in pair style, {}, does not agree with value {} in fix gran/wall/region", + norm_model->CoR, norm_model2->CoR); + } + + fix_history = dynamic_cast(modify->get_fix_by_id("NEIGH_HISTORY_GRANULAR")); + + pre_force(0); +} + +/* ---------------------------------------------------------------------- */ + +void FixGranularMDR::pre_force(int) +{ + double *radius = atom->radius; + double *Ro = atom->dvector[index_Ro]; + double *Vgeo = atom->dvector[index_Vgeo]; + double *Velas = atom->dvector[index_Velas]; + double *Vcaps = atom->dvector[index_Vcaps]; + double *eps_bar = atom->dvector[index_eps_bar]; + double *dRnumerator = atom->dvector[index_dRnumerator]; + double *dRdenominator = atom->dvector[index_dRdenominator]; + double *Acon0 = atom->dvector[index_Acon0]; + double *Acon1 = atom->dvector[index_Acon1]; + double *Atot = atom->dvector[index_Atot]; + double *Atot_sum = atom->dvector[index_Atot_sum]; + double *psi = atom->dvector[index_psi]; + double *ddelta_bar = atom->dvector[index_ddelta_bar]; + double *sigmaxx = atom->dvector[index_sigmaxx]; + double *sigmayy = atom->dvector[index_sigmayy]; + double *sigmazz = atom->dvector[index_sigmazz]; + double *history_setup_flag = atom->dvector[index_history_setup_flag]; + + int new_atom; + int nlocal = atom->nlocal; + int ntotal = nlocal + atom->nghost; + for (int i = 0; i < ntotal; i++) { + // initialize new atoms + new_atom = 0; + if (history_setup_flag[i] < EPSILON) { + Ro[i] = radius[i]; + Acon0[i] = 0.0; + Acon1[i] = 0.0; + Vcaps[i] = 0.0; + eps_bar[i] = 0.0; + dRnumerator[i] = 0.0; + dRdenominator[i] = 0.0; + Atot_sum[i] = 0.0; + ddelta_bar[i] = 0.0; + sigmaxx[i] = 0.0; + sigmayy[i] = 0.0; + sigmazz[i] = 0.0; + history_setup_flag[i] = 1.0; + new_atom = 1; + } + + // update apparent radius + + // will forward to ghosts + if (i >= nlocal) continue; + + // only update outside of setup (unless a new atom) + if (update->setupflag && (!new_atom)) continue; + + const double R = radius[i]; + const double Vo = 4.0 / 3.0 * MY_PI * pow(Ro[i], 3.0); + const double Vgeoi = 4.0 / 3.0 * MY_PI * pow(R, 3.0) - Vcaps[i]; + + Vgeo[i] = MIN(Vgeoi, Vo); + Velas[i] = Vo * (1.0 + eps_bar[i]); + Atot[i] = 4.0 * MY_PI * pow(R, 2.0) + Atot_sum[i]; + psi[i] = (Atot[i] - Acon1[i]) / Atot[i]; + + if (psi_b_coeff < psi[i]) { + const double dR = MAX(dRnumerator[i] / (dRdenominator[i] - 4.0 * MY_PI * pow(R, 2.0)), 0.0); + if ((radius[i] + dR) < (1.5 * Ro[i])) + radius[i] += dR; + } + Acon0[i] = Acon1[i]; + } + + comm_stage = COMM_1; + comm->forward_comm(this, 5); + + // rezero temporary variables for all atoms, no need to communicate + for (int i = 0; i < ntotal; i++) { + ddelta_bar[i] = 0.0; + if (!update->setupflag) { + Vcaps[i] = 0.0; + eps_bar[i] = 0.0; + dRnumerator[i] = 0.0; + dRdenominator[i] = 0.0; + Acon1[i] = 0.0; + Atot_sum[i] = 0.0; + sigmaxx[i] = 0.0; + sigmayy[i] = 0.0; + sigmazz[i] = 0.0; + } + } + if (!update->setupflag) { + calculate_contact_penalty(); + mean_surf_disp(); + update_fix_gran_wall(); + } + + comm_stage = COMM_2; + comm->forward_comm(this, 1); +} + +/* ---------------------------------------------------------------------- */ + +int FixGranularMDR::pack_forward_comm(int n, int *list, double *buf, int /*pbc_flag*/,int * /*pbc*/) +{ + double **dvector = atom->dvector; + int m = 0; + if (comm_stage == COMM_1) { + for (int i = 0; i < n; i++) { + int j = list[i]; + buf[m++] = dvector[index_Vgeo][j]; // 2 + buf[m++] = dvector[index_Velas][j]; // 3 + buf[m++] = dvector[index_Acon0][j]; // 8 + buf[m++] = dvector[index_Atot][j]; // 10 + buf[m++] = dvector[index_psi][j]; // 13 + } + } else { + for (int i = 0; i < n; i++) { + int j = list[i]; + buf[m++] = dvector[index_ddelta_bar][j]; + } + } + return m; +} + +/* ---------------------------------------------------------------------- */ + +void FixGranularMDR::unpack_forward_comm(int n, int first, double *buf) +{ + double **dvector = atom->dvector; + int m = 0; + int last = first + n; + + if (comm_stage == COMM_1) { + for (int i = first; i < last; i++) { + dvector[index_Vgeo][i] = buf[m++]; // 2 + dvector[index_Velas][i] = buf[m++]; // 3 + dvector[index_Acon0][i] = buf[m++]; // 8 + dvector[index_Atot][i] = buf[m++]; // 10 + dvector[index_psi][i] = buf[m++]; // 13 + } + } else { + for (int i = first; i < last; i++) { + dvector[index_ddelta_bar][i] = buf[m++]; + } + } +} + +/* ---------------------------------------------------------------------- + initialize setup flag to zero, called when atom is created +------------------------------------------------------------------------- */ + +void FixGranularMDR::set_arrays(int i) +{ + atom->dvector[index_history_setup_flag][i] = 0.0; +} + +/* ---------------------------------------------------------------------- + Screen for non-physical contacts occuring through obstructing particles. + Assign non-zero penalties to these contacts to adjust force evaluation. +------------------------------------------------------------------------- */ + +void FixGranularMDR::calculate_contact_penalty() +{ + NeighList * list = pair->list; + const int size_history = pair->get_size_history(); + + int i, j, k, lv1, ii, jj, inum, jnum; + + int *ilist, *jlist, *numneigh, **firstneigh; + int *touch, **firsttouch; + double *history, *history_ij, *history_ik, *history_jk, *history_kj; + double *allhistory, *allhistory_j, *allhistory_k, **firsthistory; + + bool touchflag = false; + + double **x = atom->x; + double *radius = atom->radius; + int nlocal = atom->nlocal; + + inum = list->inum; + ilist = list->ilist; + numneigh = list->numneigh; + firstneigh = list->firstneigh; + firsttouch = fix_history->firstflag; + firsthistory = fix_history->firstvalue; + + // zero existing penalties + + for (ii = 0; ii < inum; ii++) { + i = ilist[ii]; + allhistory = firsthistory[i]; + jnum = numneigh[i]; + for (jj = 0; jj < jnum; jj++) + (&allhistory[size_history * jj])[PENALTY] = 0.0; + } + + // contact penalty calculation + for (ii = 0; ii < inum; ii++) { + i = ilist[ii]; + const double xtmp = x[i][0]; + const double ytmp = x[i][1]; + const double ztmp = x[i][2]; + allhistory = firsthistory[i]; + double radi = radius[i]; + jlist = firstneigh[i]; + jnum = numneigh[i]; + for (jj = 0; jj < jnum; jj++) { + j = jlist[jj]; + j &= NEIGHMASK; + + double radj = radius[j]; + const double delx_ij = x[j][0] - xtmp; + const double dely_ij = x[j][1] - ytmp; + const double delz_ij = x[j][2] - ztmp; + const double rsq_ij = delx_ij * delx_ij + dely_ij * dely_ij + delz_ij * delz_ij; + const double r_ij = sqrt(rsq_ij); + const double rinv_ij = 1.0 / r_ij; + const double radsum_ij = radi + radj; + const double deltan_ij = radsum_ij - r_ij; + if (deltan_ij < 0.0) continue; + for (int kk = jj + 1; kk < jnum; kk++) { + k = jlist[kk]; + k &= NEIGHMASK; + + const double delx_ik = x[k][0] - xtmp; + const double dely_ik = x[k][1] - ytmp; + const double delz_ik = x[k][2] - ztmp; + const double rsq_ik = delx_ik * delx_ik + dely_ik * dely_ik + delz_ik *delz_ik; + const double r_ik = sqrt(rsq_ik); + const double rinv_ik = 1.0 / r_ik; + const double radk = radius[k]; + const double radsum_ik = radi + radk; + const double deltan_ik = radsum_ik - r_ik; + + if (deltan_ik < 0.0) continue; + + const double delx_jk = x[k][0] - x[j][0]; + const double dely_jk = x[k][1] - x[j][1]; + const double delz_jk = x[k][2] - x[j][2]; + const double rsq_jk = delx_jk * delx_jk + dely_jk * dely_jk + delz_jk *delz_jk; + const double r_jk = sqrt(rsq_jk); + const double rinv_jk = 1.0 / r_jk; + const double radsum_jk = radj + radk; + const double deltan_jk = radsum_jk - r_jk; + + if (deltan_jk < 0.0) continue; + + // pull ij history + history_ij = &allhistory[size_history * jj]; + double * pij = &history_ij[PENALTY]; // penalty for contact i and j + + // pull ik history + history_ik = &allhistory[size_history * kk]; + double * pik = &history_ik[PENALTY]; // penalty for contact i and k + + // Find pair of atoms with the smallest overlap, atoms a & b, 3rd atom c is central + // if a & b are both local: + // calculate ab penalty and add to the pab[0] history entry + // if a is local & b is ghost or vice versa: + // each processor has a-b in nlist and independently calculates + adds penalty + // if a & b are both ghosts: + // skip calculation since it's performed on other proc + // This process requires newton off, or nlist may not include ab, ac, & bc + + const double r_max = MAX(r_ij, MAX(r_ik, r_jk)); + if (r_ij == r_max) { // the central particle is k + const double enx_ki = -delx_ik * rinv_ik; + const double eny_ki = -dely_ik * rinv_ik; + const double enz_ki = -delz_ik * rinv_ik; + const double enx_kj = -delx_jk * rinv_jk; + const double eny_kj = -dely_jk * rinv_jk; + const double enz_kj = -delz_jk * rinv_jk; + const double alpha = std::acos(enx_ki * enx_kj + eny_ki * eny_kj + enz_ki * enz_kj); + pij[0] += 1.0 / (1.0 + std::exp(-50.0 * (alpha / MY_PI - 0.5))); + } else if (r_ik == r_max) { // the central particle is j + const double enx_ji = -delx_ij * rinv_ij; + const double eny_ji = -dely_ij * rinv_ij; + const double enz_ji = -delz_ij * rinv_ij; + const double enx_jk = delx_jk * rinv_jk; + const double eny_jk = dely_jk * rinv_jk; + const double enz_jk = delz_jk * rinv_jk; + const double alpha = std::acos(enx_ji * enx_jk + eny_ji * eny_jk + enz_ji * enz_jk); + pik[0] += 1.0 / (1.0 + std::exp(-50.0 * (alpha / MY_PI - 0.5))); + } else { // the central particle is i + if (j < atom->nlocal || k < atom->nlocal) { + const double enx_ij = delx_ij * rinv_ij; + const double eny_ij = dely_ij * rinv_ij; + const double enz_ij = delz_ij * rinv_ij; + const double enx_ik = delx_ik * rinv_ik; + const double eny_ik = dely_ik * rinv_ik; + const double enz_ik = delz_ik * rinv_ik; + const double alpha = std::acos(enx_ij * enx_ik + eny_ij * eny_ik + enz_ij * enz_ik); + + // don't know who owns the contact, k may be in j's nlist or vice versa + // need to search both to find owner + double * pjk = nullptr; + if (j < atom->nlocal) { + int * const jklist = firstneigh[j]; + const int jknum = numneigh[j]; + for (int jk = 0; jk < jknum; jk++) { + const int kneigh = jklist[jk] & NEIGHMASK; + if (k == kneigh) { + allhistory_j = firsthistory[j]; + history_jk = &allhistory_j[size_history * jk]; + pjk = &history_jk[PENALTY]; // penalty for contact j and k + break; + } + } + } + + // check if j is in the neighbor list of k + if (pjk == nullptr && k < atom->nlocal) { + int * const kjlist = firstneigh[k]; + const int kjnum = numneigh[k]; + for (int kj = 0; kj < kjnum; kj++) { + const int jneigh = kjlist[kj] & NEIGHMASK; + if (j == jneigh) { + allhistory_k = firsthistory[k]; + history_kj = &allhistory_k[size_history * kj]; + pjk = &history_kj[PENALTY]; // penalty for contact j and k + break; + } + } + } + + if (pjk == nullptr) + error->one(FLERR, "Contact between a pair of particles was detected by the MDR model, however it is not reflected in the neighbor lists. To solve this issue either build the neighbor lists more frequently or increase their size (e.g. increase the skin distance)."); + + pjk[0] += 1.0 / (1.0 + std::exp(-50.0 * (alpha / MY_PI - 0.5))); + } + } + } + } + } +} + + +/* ---------------------------------------------------------------------- + Calculate mean surface displacement increment for each particle +------------------------------------------------------------------------- */ + +void FixGranularMDR::mean_surf_disp() +{ + NeighList * list = pair->list; + + const int size_history = pair->get_size_history(); + int i, j, k, ii, jj, inum, jnum, itype, jtype; + int *ilist, *jlist, *numneigh, **firstneigh; + int *touch, **firsttouch; + double *history, *allhistory, **firsthistory; + + bool touchflag = false; + class GranularModel* model; + class GranularModel** models_list = pair->models_list; + int ** types_indices = pair->types_indices; + + double **x = atom->x; + int *type = atom->type; + double *radius = atom->radius; + int nlocal = atom->nlocal; + + double *Acon0 = atom->dvector[index_Acon0]; + double *ddelta_bar = atom->dvector[index_ddelta_bar]; + + inum = list->inum; + ilist = list->ilist; + numneigh = list->numneigh; + firstneigh = list->firstneigh; + firsttouch = fix_history->firstflag; + firsthistory = fix_history->firstvalue; + + for (ii = 0; ii < inum; ii++) { + i = ilist[ii]; + itype = type[i]; + touch = firsttouch[i]; + allhistory = firsthistory[i]; + jlist = firstneigh[i]; + jnum = numneigh[i]; + + for (jj = 0; jj < jnum; jj++) { + j = jlist[jj]; + j &= NEIGHMASK; + + jtype = type[j]; + model = models_list[types_indices[itype][jtype]]; + + // Reset model and copy initial geometric data + model->xi = x[i]; + model->xj = x[j]; + model->radi = radius[i]; + model->radj = radius[j]; + model->i = i; + model->j = j; + model->touch = touch[jj]; + touchflag = model->check_contact(); + + // is it necessary to clear the history here??? + if (!touchflag) { + touch[jj] = 0; + history = &allhistory[size_history * jj]; + for (k = 0; k < size_history; k++) history[k] = 0.0; + continue; + } + + touch[jj] = 1; + + history = &allhistory[size_history * jj]; + model->history = history; + + const double delta = model->radsum - sqrt(model->rsq); + + double deltamax = history[DELTA_MAX]; + double deltap0 = history[DELTAP_0]; + double deltap1 = history[DELTAP_1]; + + if (delta > deltamax) deltamax = delta; + + double delta0old = history[DELTA_0]; + double delta1old = history[DELTA_1]; + + int i0; + int i1; + if (atom->tag[i] > atom->tag[j]) { + i0 = i; + i1 = j; + } else { + i0 = j; + i1 = i; + } + + double R0 = radius[i0]; + double R1 = radius[i1]; + + double delta_geo0; + double delta_geo1; + double deltaOpt1 = deltamax * (deltamax - 2.0 * R1) / (2.0 * (deltamax - R0 - R1)); + double deltaOpt2 = deltamax * (deltamax - 2.0 * R0) / (2.0 * (deltamax - R0 - R1)); + (R0 < R1) ? delta_geo0 = MAX(deltaOpt1, deltaOpt2) : delta_geo0 = MIN(deltaOpt1, deltaOpt2); + (R0 < R1) ? delta_geo1 = MIN(deltaOpt1, deltaOpt2) : delta_geo1 = MAX(deltaOpt1, deltaOpt2); + + if (delta_geo0 / R0 > OVERLAP_LIMIT) { + delta_geo0 = R0 * OVERLAP_LIMIT; + delta_geo1 = deltamax - delta_geo0; + } else if (delta_geo1 / R1 > OVERLAP_LIMIT) { + delta_geo1 = R1 * OVERLAP_LIMIT; + delta_geo0 = deltamax - delta_geo1; + } + + double deltap = deltap0 + deltap1; + + double delta0 = delta_geo0 + (deltap0 - delta_geo0) / (deltap - deltamax) * (delta - deltamax); + double delta1 = delta_geo1 + (deltap1 - delta_geo1) / (deltap - deltamax) * (delta - deltamax); + + double ddel0 = delta0 - delta0old; + double ddel1 = delta1 - delta1old; + + if (Acon0[i0] != 0.0) { + const double Ac_offset0 = history[AC_0]; + ddelta_bar[i0] += Ac_offset0 / Acon0[i0] * ddel0; + } + + if (Acon0[i1] != 0.0) { + const double Ac_offset1 = history[AC_1]; + ddelta_bar[i1] += Ac_offset1 / Acon0[i1] * ddel1; + } + } + } +} + +/* ---------------------------------------------------------------------- + Update instance of fix gran/wall +------------------------------------------------------------------------- */ + +void FixGranularMDR::update_fix_gran_wall() +{ + int i, m, nc, iwall; + + double **x = atom->x; + double *radius = atom->radius; + int *mask = atom->mask; + int nlocal = atom->nlocal; + + double *Acon0 = atom->dvector[index_Acon0]; + double *ddelta_bar = atom->dvector[index_ddelta_bar]; + + for (int w = 0; w < fix_wall_list.size(); w++) { + FixWallGranRegion *fix = dynamic_cast(fix_wall_list[w]); + GranularModel *model = fix->model; + const int size_history = model->size_history; + Region *region = fix->region; + + if (region->dynamic_check()) + region->prematch(); + + for (i = 0; i < nlocal; i++) { + if (!(mask[i] & groupbit)) continue; + if (! region->match(x[i][0], x[i][1], x[i][2])) continue; + + nc = region->surface(x[i][0], x[i][1], x[i][2], radius[i] + model->pulloff_distance(radius[i], 0.0)); + + if (nc == 0) { + fix->ncontact[i] = 0; + continue; + } + if (nc == 1) { + fix->c2r[0] = 0; + iwall = region->contact[0].iwall; + if (fix->ncontact[i] == 0) { + fix->ncontact[i] = 1; + fix->walls[i][0] = iwall; + for (m = 0; m < size_history; m++) fix->history_many[i][0] [m] = 0.0; + } else if (fix->ncontact[i] > 1 || iwall != fix->walls[i][0]) + fix->update_contacts(i, nc); + } else + fix->update_contacts(i, nc); + + // process current contacts + for (int ic = 0; ic < nc; ic++) { + const double wij = 1.0; + if (Acon0[i] != 0.0) { + const double delta = radius[i] - region->contact[ic].r; + const double delta_offset0 = fix->history_many[i][fix->c2r[ic]][0]; + const double ddelta = delta - delta_offset0; + const double Ac_offset0 = fix->history_many[i][fix->c2r[ic]][18]; + ddelta_bar[i] += wij * Ac_offset0 / Acon0[i] * ddelta; + } + } + } + } +} diff --git a/src/GRANULAR/fix_granular_mdr.h b/src/GRANULAR/fix_granular_mdr.h new file mode 100644 index 0000000000..f0ba76d155 --- /dev/null +++ b/src/GRANULAR/fix_granular_mdr.h @@ -0,0 +1,107 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#ifdef FIX_CLASS +// clang-format off +FixStyle(GRANULAR/MDR,FixGranularMDR); +// clang-format on +#else + +#ifndef LMP_FIX_GRANULAR_MDR_H +#define LMP_FIX_GRANULAR_MDR_H + +#include "fix.h" + +namespace LAMMPS_NS { +namespace Granular_MDR_NS { + + enum HistoryIndex { + DELTA_0 = 0, // apparent overlap + DELTA_1, + DELTAO_0, // displacement + DELTAO_1, + DELTA_MDR_0, // MDR apparent overlap + DELTA_MDR_1, + DELTA_BULK_0, // bulk displacement + DELTA_BULK_1, + DELTAMAX_MDR_0, // maximum MDR apparent overlap + DELTAMAX_MDR_1, + YFLAG_0, // yield flag + YFLAG_1, + DELTAY_0, // yield displacement + DELTAY_1, + CA_0, // contact area intercept + CA_1, + AADH_0, // adhesive contact radius + AADH_1, + AC_0, // contact area + AC_1, + EPS_BAR_0, // volume-averaged infinitesimal sor + EPS_BAR_1, + PENALTY, // contact penalty + DELTA_MAX, + DELTAP_0, + DELTAP_1 + }; + +} // namespace Granular_MDR_NS + +class FixGranularMDR : public Fix { + public: + FixGranularMDR(class LAMMPS *, int, char **); + ~FixGranularMDR() override; + int setmask() override; + void post_constructor() override; + void setup_pre_force(int) override; + void pre_force(int) override; + int pack_forward_comm(int, int *, double *, int, int *) override; + void unpack_forward_comm(int, int, double *) override; + void set_arrays(int) override; + + private: + int comm_stage; + char *id_fix; + double psi_b_coeff; + class PairGranular *pair; + class FixNeighHistory *fix_history; + std::vector fix_wall_list; + + void mean_surf_disp(); + void calculate_contact_penalty(); + void update_fix_gran_wall(); + + int index_Ro; // initial radius + int index_Vgeo; // geometric particle volume of apparent particle afterremoving spherical cap volume + int index_Velas; // particle volume from linear elasticity + int index_Vcaps; // spherical cap volume from intersection of apparentradius particle and contact planes + int index_eps_bar; // volume-averaged infinitesimal strain tensor + int index_dRnumerator; // summation of numerator terms in calculation of dR + int index_dRdenominator; // summation of denominator terms in calculation of dR + int index_Acon0; // total area involved in contacts: Acon^{n} + int index_Acon1; // total area involved in contacts: Acon^{n+1} + int index_Atot; // total particle area + int index_Atot_sum; // running sum of contact area minus cap area + int index_ddelta_bar; // change in mean surface displacement + int index_psi; // ratio of free surface area to total surface area + int index_sigmaxx; // xx-component of the stress tensor, not necessary forforce calculation + int index_sigmayy; // yy-component of the stress tensor, not necessary forforce calculation + int index_sigmazz; // zz-component of the stress tensor, not necessary forforce calculation + int index_history_setup_flag; // flag to check if history variables have beeninitialized + int index_contacts; // total contacts on particle + int index_adhesive_length; // total length of adhesive contact on a particle +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/GRANULAR/fix_wall_gran.cpp b/src/GRANULAR/fix_wall_gran.cpp index 4832f07849..d0c623aa92 100644 --- a/src/GRANULAR/fix_wall_gran.cpp +++ b/src/GRANULAR/fix_wall_gran.cpp @@ -200,7 +200,7 @@ FixWallGran::FixWallGran(LAMMPS *lmp, int narg, char **arg) : iarg += 3; } else if (strcmp(arg[iarg],"contacts") == 0) { peratom_flag = 1; - size_peratom_cols = 8; + size_peratom_cols = 8 + model->nsvector; peratom_freq = 1; iarg += 1; } else if (strcmp(arg[iarg],"temperature") == 0) { @@ -365,7 +365,7 @@ void FixWallGran::setup(int vflag) void FixWallGran::post_force(int /*vflag*/) { - int i,j; + int i,j,n; double dx,dy,dz,del1,del2,delxy,delr,rwall,meff; double *forces, *torquesi; double vwall[3]; @@ -437,7 +437,9 @@ void FixWallGran::post_force(int /*vflag*/) rwall = 0.0; + model->calculate_svector = 0; if (peratom_flag) { + model->calculate_svector = 1; clear_stored_contacts(); } @@ -546,6 +548,9 @@ void FixWallGran::post_force(int /*vflag*/) array_atom[i][5] = x[i][1] - dy; array_atom[i][6] = x[i][2] - dz; array_atom[i][7] = radius[i]; + + for (n = 0; n < model->nsvector; n++) + array_atom[i][8 + n] = model->svector[n]; } } } diff --git a/src/GRANULAR/fix_wall_gran.h b/src/GRANULAR/fix_wall_gran.h index cd1e8778c3..e3d35fcc36 100644 --- a/src/GRANULAR/fix_wall_gran.h +++ b/src/GRANULAR/fix_wall_gran.h @@ -50,14 +50,14 @@ class FixWallGran : public Fix { int maxsize_restart() override; void reset_dt() override; + // for granular model choices + class Granular_NS::GranularModel *model; + protected: int wallstyle, wiggle, wshear, axis; int nlevels_respa; bigint time_origin; - // for granular model choices - class Granular_NS::GranularModel *model; - double lo, hi, cylradius; double amplitude, period, omega, vshear; double dt; @@ -84,7 +84,7 @@ class FixWallGran : public Fix { // store particle interactions - int store; + int nsvector; void clear_stored_contacts(); }; diff --git a/src/GRANULAR/fix_wall_gran_region.cpp b/src/GRANULAR/fix_wall_gran_region.cpp index b90620f3aa..2009b5974b 100644 --- a/src/GRANULAR/fix_wall_gran_region.cpp +++ b/src/GRANULAR/fix_wall_gran_region.cpp @@ -118,7 +118,7 @@ void FixWallGranRegion::init() void FixWallGranRegion::post_force(int /*vflag*/) { - int i, m, nc, iwall; + int i, n, m, nc, iwall; double *forces, *torquesi; double meff, vwall[3], w0[3] = {0.0, 0.0, 0.0}; bool touchflag = false; @@ -174,7 +174,11 @@ void FixWallGranRegion::post_force(int /*vflag*/) region->set_velocity(); } - if (peratom_flag) clear_stored_contacts(); + model->calculate_svector = 0; + if (peratom_flag) { + model->calculate_svector = 1; + clear_stored_contacts(); + } // Define constant wall properties (atom j) model->radj = 0.0; @@ -195,10 +199,10 @@ void FixWallGranRegion::post_force(int /*vflag*/) if (nc > tmax) error->one(FLERR, "Too many wallgran/region contacts for one particle"); // shear history maintenance - // update ncontact,walls,shear2many for particle I - // to reflect new and persistent shear historyvalues - // also set c2r[] = indices into region->contact[]for each of N contacts - // process zero or one contact here, otherwiseinvoke update_contacts() + // update ncontact, walls, shear2many for particle I + // to reflect new and persistent shear history values + // also set c2r[] = indices into region->contact[] for each of N contacts + // process zero or one contact here, otherwise invoke update_contacts() if (use_history) { if (nc == 0) { @@ -228,6 +232,9 @@ void FixWallGranRegion::post_force(int /*vflag*/) model->radi = radius[i]; model->radj = region->contact[ic].radius; model->r = region->contact[ic].r; + model->i = i; + model->j = ic; + if (model->beyond_contact) model->touch = history_many[i][c2r[ic]][0]; touchflag = model->check_contact(); @@ -280,6 +287,9 @@ void FixWallGranRegion::post_force(int /*vflag*/) array_atom[i][5] = x[i][1] - model->dx[1]; array_atom[i][6] = x[i][2] - model->dx[2]; array_atom[i][7] = radius[i]; + + for (n = 0; n < model->nsvector; n++) + array_atom[i][8 + n] = model->svector[n]; } } } diff --git a/src/GRANULAR/fix_wall_gran_region.h b/src/GRANULAR/fix_wall_gran_region.h index 72e1080268..2e455b316e 100644 --- a/src/GRANULAR/fix_wall_gran_region.h +++ b/src/GRANULAR/fix_wall_gran_region.h @@ -44,9 +44,8 @@ class FixWallGranRegion : public FixWallGran { int size_restart(int) override; int maxsize_restart() override; - private: class Region *region; - int nregion; + void update_contacts(int, int); // shear history for multiple contacts per particle @@ -57,10 +56,11 @@ class FixWallGranRegion : public FixWallGran { int *c2r; // contact to region mapping // c2r[i] = index of Ith contact in // region-contact[] list of contacts + private: + + int nregion; int motion_resetflag; // used by restart to indicate that region // vel info is to be reset - - void update_contacts(int, int); }; } // namespace LAMMPS_NS diff --git a/src/GRANULAR/gran_sub_mod.cpp b/src/GRANULAR/gran_sub_mod.cpp index bac9c9edfe..c31fbd7241 100644 --- a/src/GRANULAR/gran_sub_mod.cpp +++ b/src/GRANULAR/gran_sub_mod.cpp @@ -42,6 +42,7 @@ GranSubMod::GranSubMod(class GranularModel *gm, LAMMPS *lmp) : Pointers(lmp) beyond_contact = 0; num_coeffs = 0; contact_radius_flag = 0; + nsvector = 0; nondefault_history_transfer = 0; transfer_history_factor = nullptr; diff --git a/src/GRANULAR/gran_sub_mod.h b/src/GRANULAR/gran_sub_mod.h index 88e77eb77b..857f70cc59 100644 --- a/src/GRANULAR/gran_sub_mod.h +++ b/src/GRANULAR/gran_sub_mod.h @@ -46,6 +46,8 @@ namespace Granular_NS { GranularModel *gm; + int nsvector, index_svector; + protected: int allocated; diff --git a/src/GRANULAR/gran_sub_mod_heat.cpp b/src/GRANULAR/gran_sub_mod_heat.cpp index 5378a72fd4..c26501c584 100644 --- a/src/GRANULAR/gran_sub_mod_heat.cpp +++ b/src/GRANULAR/gran_sub_mod_heat.cpp @@ -50,6 +50,7 @@ GranSubModHeatRadius::GranSubModHeatRadius(GranularModel *gm, LAMMPS *lmp) : Gra num_coeffs = 1; contact_radius_flag = 1; conductivity = 0.0; + nsvector = 1; } /* ---------------------------------------------------------------------- */ @@ -65,7 +66,9 @@ void GranSubModHeatRadius::coeffs_to_local() double GranSubModHeatRadius::calculate_heat() { - return 2 * conductivity * gm->contact_radius * (gm->Tj - gm->Ti); + double heat = 2 * conductivity * gm->contact_radius * (gm->Tj - gm->Ti); + if (gm->calculate_svector) gm->svector[index_svector] = heat; + return heat; } @@ -78,6 +81,7 @@ GranSubModHeatArea::GranSubModHeatArea(GranularModel *gm, LAMMPS *lmp) : GranSub num_coeffs = 1; contact_radius_flag = 1; heat_transfer_coeff = 0.0; + nsvector = 1; } /* ---------------------------------------------------------------------- */ @@ -93,5 +97,7 @@ void GranSubModHeatArea::coeffs_to_local() double GranSubModHeatArea::calculate_heat() { - return heat_transfer_coeff * MY_PI * gm->contact_radius * gm->contact_radius * (gm->Tj - gm->Ti); + double heat = heat_transfer_coeff * MY_PI * gm->contact_radius * gm->contact_radius * (gm->Tj - gm->Ti); + if (gm->calculate_svector) gm->svector[index_svector] = heat; + return heat; } diff --git a/src/GRANULAR/gran_sub_mod_normal.cpp b/src/GRANULAR/gran_sub_mod_normal.cpp index f049d2b5e2..a26d846f5c 100644 --- a/src/GRANULAR/gran_sub_mod_normal.cpp +++ b/src/GRANULAR/gran_sub_mod_normal.cpp @@ -13,24 +13,69 @@ #include "gran_sub_mod_normal.h" +#include "atom.h" #include "error.h" +#include "citeme.h" +#include "fix_granular_mdr.h" #include "granular_model.h" #include "math_const.h" +#include "modify.h" +#include "update.h" #include +#include +#include using namespace LAMMPS_NS; using namespace Granular_NS; +using namespace MathConst; -using MathConst::MY_2PI; -using MathConst::MY_PI; +static constexpr double PISQ = 9.8696044010893579923; // PI^2 +static constexpr double PIINV = 0.318309886183790691216; // 1/PI +static constexpr double PI27SQ = 266.479318829412648029; // 27*PI^2 +static constexpr double PITOFIVETHIRDS = 6.73880859569814116838; // PI^(5/3) +static constexpr double CBRT2 = 1.25992104989487319067; // cbrt(2) +static constexpr double SQRTHALFPI = 1.25331413731550012081; // sqrt(PI/2) +static constexpr double CBRTHALFPI = 1.16244735150962652526; // cbrt(PI/2) +static constexpr double FOURTHIRDS = 1.33333333333333333333; // 4/3 +static constexpr double THREEROOT3 = 5.19615242270663202362; // 3*sqrt(3) +static constexpr double SIXROOT6 = 14.69693845669906728801; // 6*sqrt(6) +static constexpr double INVROOT6 = 0.40824829046386307274; // 1/sqrt(6) +static constexpr double JKRPREFIX = 1.2277228507842888; // cbrt(3*PI**2/16) -static constexpr double PI27SQ = 266.47931882941264802866; // 27*PI**2 -static constexpr double THREEROOT3 = 5.19615242270663202362; // 3*sqrt(3) -static constexpr double SIXROOT6 = 14.69693845669906728801; // 6*sqrt(6) -static constexpr double INVROOT6 = 0.40824829046386307274; // 1/sqrt(6) -static constexpr double FOURTHIRDS = (4.0 / 3.0); // 4/3 -static constexpr double JKRPREFIX = 1.2277228507842888; // cbrt(3*PI**2/16) +static constexpr int MDR_MAX_IT = 100; // Newton-Raphson for MDR +static constexpr double MDR_EPSILON1 = 1e-10; // Newton-Raphson for MDR +static constexpr double MDR_EPSILON2 = 1e-16; // Newton-Raphson for MDR +static constexpr double MDR_EPSILON3 = 1e-20; // For precision checks +static constexpr double MDR_OVERLAP_LIMIT = 0.75; // Maximum contact overlap for MDR + +static const char cite_mdr[] = + "MDR contact model command: (i) https://doi.org/10.1016/j.jmps.2023.105492 || (ii) https://doi.org/10.1016/j.jmps.2023.105493 || (iii) https://doi.org/10.31224/4289\n\n" + "@Article{zunker2024mechanicallyI,\n" + " author = {Zunker, William and Kamrin, Ken},\n" + " title = {A mechanically-derived contact model for adhesive elastic-perfectly plastic particles,\n" + " Part I: Utilizing the method of dimensionality reduction},\n" + " journal = {Journal of the Mechanics and Physics of Solids},\n" + " year = {2024},\n" + " volume = {183},\n" + " pages = {105492},\n" + "}\n\n" + "@Article{zunker2024mechanicallyII,\n" + " author = {Zunker, William and Kamrin, Ken},\n" + " title = {A mechanically-derived contact model for adhesive elastic-perfectly plastic particles,\n" + " Part II: Contact under high compaction—modeling a bulk elastic response},\n" + " journal = {Journal of the Mechanics and Physics of Solids},\n" + " year = {2024},\n" + " volume = {183},\n" + " pages = {105493},\n" + "}\n\n" + "@Article{zunker2025experimentally,\n" + " author = {Zunker, William and Dunatunga, Sachith and Thakur, Subhash and Tang, Pingjun and Kamrin, Ken},\n" + " title = {Experimentally validated DEM for large deformation powder compaction:\n" + " mechanically-derived contact model and screening of non-physical contacts},\n" + " year = {2025},\n" + " journal = {engrXiv},\n" + "}\n\n"; /* ---------------------------------------------------------------------- Default normal model @@ -381,3 +426,574 @@ void GranSubModNormalJKR::set_fncrit() { Fncrit = fabs(Fne + 2.0 * F_pulloff); } + +/* ---------------------------------------------------------------------- + MDR contact model + + Contributing authors: + William Zunker (MIT), Sachith Dunatunga (MIT), + Dan Bolintineanu (SNL), Joel Clemmer (SNL) +------------------------------------------------------------------------- */ + +GranSubModNormalMDR::GranSubModNormalMDR(GranularModel *gm, LAMMPS *lmp) : + GranSubModNormal(gm, lmp) +{ + if (lmp->citeme) lmp->citeme->add(cite_mdr); + + num_coeffs = 6; + contact_radius_flag = 1; + size_history = 26; + nsvector = 1; + fix_mdr_flag = 0; + id_fix = nullptr; + + nondefault_history_transfer = 1; + transfer_history_factor = new double[size_history]; + for (int i = 0; i < size_history; i++) { + transfer_history_factor[i] = +1; + } +} + +/* ---------------------------------------------------------------------- */ + +GranSubModNormalMDR::~GranSubModNormalMDR() +{ + if (id_fix && modify->nfix) + modify->delete_fix(id_fix); + delete[] id_fix; +} + +/* ---------------------------------------------------------------------- */ + +void GranSubModNormalMDR::coeffs_to_local() +{ + E = coeffs[0]; // Young's modulus + nu = coeffs[1]; // Poisson's ratio + Y = coeffs[2]; // yield stress + gamma = coeffs[3]; // effective surface energy + psi_b = coeffs[4]; // bulk response trigger based on ratio of remaining free area: A_{free}/A_{total} + CoR = coeffs[5]; // coefficent of restitution + + if (E <= 0.0) error->all(FLERR, "Illegal MDR normal model, Young's modulus must be greater than 0"); + if (nu < 0.0 || nu > 0.5) error->all(FLERR, "Illegal MDR normal model, Poisson's ratio must be between 0 and 0.5"); + if (Y < 0.0) error->all(FLERR, "Illegal MDR normal model, yield stress must be greater than or equal to 0"); + if (gamma < 0.0) error->all(FLERR, "Illegal MDR normal model, effective surface energy must be greater than or equal to 0"); + if (psi_b < 0.0 || psi_b > 1.0) error->all(FLERR, "Illegal MDR normal model, psi_b must be between 0 and 1.0"); + if (CoR < 0.0 || CoR > 1.0) error->all(FLERR, "Illegal MDR normal model, coefficent of restitution must be between 0 and 1.0"); + + G = E / (2.0 * (1.0 + nu)); // shear modulus + kappa = E / (3.0 * (1.0 - 2.0 * nu)); // bulk modulus + Eeff = E / (1.0 - pow(nu, 2.0)); // composite plane strain modulus + + // precomputing factors + + Eeffinv = 1.0 / Eeff; + Eeffsq = Eeff * Eeff; + Eeffsqinv = Eeffinv * Eeffinv; + + gammasq = gamma * gamma; + gamma3 = gammasq * gamma; + gamma4 = gammasq * gammasq; + + warn_flag = 1; +} + +/* ---------------------------------------------------------------------- */ + +void GranSubModNormalMDR::init() +{ + if (!fix_mdr_flag) { + if (modify->get_fix_by_style("GRANULAR/MDR").size() == 0) { + id_fix = utils::strdup("MDR"); + modify->add_fix(fmt::format("{} all GRANULAR/MDR", id_fix)); + } + fix_mdr_flag = 1; + } + + // initialize particle history variables + int tmp1, tmp2; + index_Ro = atom->find_custom("Ro", tmp1, tmp2); // initial radius + index_Vcaps = atom->find_custom("Vcaps", tmp1, tmp2); // spherical cap volume from intersection of apparent radius particle and contact planes + index_Vgeo = atom->find_custom("Vgeo", tmp1, tmp2); // geometric particle volume of apparent particle after removing spherical cap volume + index_Velas = atom->find_custom("Velas", tmp1, tmp2); // particle volume from linear elasticity + index_eps_bar = atom->find_custom("eps_bar", tmp1, tmp2); // volume-averaged infinitesimal strain tensor + index_dRnumerator = atom->find_custom("dRnumerator", tmp1, tmp2); // summation of numerator terms in calculation of dR + index_dRdenominator = atom->find_custom("dRdenominator", tmp1, tmp2); // summation of denominator terms in calculation of dR + index_Acon0 = atom->find_custom("Acon0", tmp1, tmp2); // total area involved in contacts: Acon^{n} + index_Acon1 = atom->find_custom("Acon1", tmp1, tmp2); // total area involved in contacts: Acon^{n+1} + index_Atot = atom->find_custom("Atot", tmp1, tmp2); // total particle area + index_Atot_sum = atom->find_custom("Atot_sum", tmp1, tmp2); // running sum of contact area minus cap area + index_ddelta_bar = atom->find_custom("ddelta_bar", tmp1, tmp2); // change in mean surface displacement + index_psi = atom->find_custom("psi", tmp1, tmp2); // ratio of free surface area to total surface area + index_sigmaxx = atom->find_custom("sigmaxx", tmp1, tmp2); // xx-component of the stress tensor, not necessary for force calculation + index_sigmayy = atom->find_custom("sigmayy", tmp1, tmp2); // yy-component of the stress tensor, not necessary for force calculation + index_sigmazz = atom->find_custom("sigmazz", tmp1, tmp2); // zz-component of the stress tensor, not necessary for force calculation +} + +/* ---------------------------------------------------------------------- */ + +double GranSubModNormalMDR::calculate_forces() +{ + using namespace Granular_MDR_NS; + // To understand the structure of the overall code it is important to consider + // the following: + // + // The MDR contact model was developed by imagining individual particles being + // squished between a number of rigid flats (references below). To allow + // for many interacting particles, we extend the idea of isolated particles surrounded + // by rigid flats. In particular, we imagine placing rigid flats at the overlaps + // between particles. The force is calculated seperately on both sides + // of the contact assuming interaction with a rigid flat. The two forces are then + // averaged on either side of the contact to determine the final force. If the + // contact is between a particle and wall then only one force evaluation is required. + // + // Zunker and Kamrin, 2024, Part I: https://doi.org/10.1016/j.jmps.2023.105492 + // Zunker and Kamrin, 2024, Part II: https://doi.org/10.1016/j.jmps.2023.105493 + // Zunker, Dunatunga, Thakur, Tang, and Kamrin, 2025: + + double *Rinitial = atom->dvector[index_Ro]; + double *Vgeo = atom->dvector[index_Vgeo]; + double *Velas = atom->dvector[index_Velas]; + double *Vcaps = atom->dvector[index_Vcaps]; + double *eps_bar = atom->dvector[index_eps_bar]; + double *dRnumerator = atom->dvector[index_dRnumerator]; + double *dRdenominator = atom->dvector[index_dRdenominator]; + double *Acon0 = atom->dvector[index_Acon0]; + double *Acon1 = atom->dvector[index_Acon1]; + double *Atot = atom->dvector[index_Atot]; + double *Atot_sum = atom->dvector[index_Atot_sum]; + double *ddelta_bar = atom->dvector[index_ddelta_bar]; + double *psi = atom->dvector[index_psi]; + double *sigmaxx = atom->dvector[index_sigmaxx]; + double *sigmayy = atom->dvector[index_sigmayy]; + double *sigmazz = atom->dvector[index_sigmazz]; + + const int itag_true = atom->tag[gm->i]; // true i particle tag + const int jtag_true = atom->tag[gm->j]; // true j particle tag + const int i_true = gm->i; // true i particle index + const int j_true = gm->j; // true j particle index + const double radi_true = gm->radi; // true i particle initial radius + const double radj_true = gm->radj; // true j particle initial radius + + double F = 0.0; // average force + double F0 = 0.0; // force on contact side 0 + double F1 = 0.0; // force on contact side 1 + double delta = gm->delta; // apparent overlap + double Ac_avg = 0.0; // average contact area across both sides + + double *history = & gm->history[history_index]; // load in all history variables + int history_update = gm->history_update; + + // Rigid flat placement scheme + double *deltamax_offset = & history[DELTA_MAX]; + double *deltap_offset0 = & history[DELTAP_0]; + double *deltap_offset1 = & history[DELTAP_1]; + double deltap0 = *deltap_offset0; + double deltap1 = *deltap_offset1; + + // always update deltamax since gm->delta won't change until initial integrate + // also need to define deltamax if an atom is created with an overlap + double deltamaxi = *deltamax_offset; + if (gm->delta >= *deltamax_offset) *deltamax_offset = gm->delta; + double deltamax = *deltamax_offset; + + + for (int contactSide = 0; contactSide < 2; contactSide++) { + + double *delta_offset, *deltao_offset, *delta_MDR_offset, *delta_BULK_offset; + double *deltamax_MDR_offset, *Yflag_offset, *deltaY_offset, *cA_offset, *aAdh_offset; + double *Ac_offset, *eps_bar_offset, *penalty_offset, *deltap_offset; + + if (gm->contact_type == PAIR) { + // displacement partitioning only necessary for particle-particle contact + + // itag and jtag persist after neighbor list builds, use tags to compare to match + // contact history variables consistently across steps for a particle pair. + if ((contactSide == 0 && itag_true > jtag_true) || (contactSide != 0 && itag_true < jtag_true)) { + gm->i = i_true; + gm->j = j_true; + gm->radi = radi_true; + gm->radj = radj_true; + } else { + gm->i = j_true; + gm->j = i_true; + gm->radi = radj_true; + gm->radj = radi_true; + } + + // determine the two maximum experienced geometric overlaps on either side of rigid flat + double delta_geo, delta_geo_alt; + double denom = 1.0 / (2.0 * (deltamax - gm->radi - gm->radj)); + double delta_geoOpt1 = deltamax * (deltamax - 2.0 * gm->radj) * denom; + double delta_geoOpt2 = deltamax * (deltamax - 2.0 * gm->radi) * denom; + if (gm->radi < gm->radj) { + delta_geo = MAX(delta_geoOpt1, delta_geoOpt2); + delta_geo_alt = MIN(delta_geoOpt1,delta_geoOpt2); + } else { + delta_geo = MIN(delta_geoOpt1, delta_geoOpt2); + delta_geo_alt = MAX(delta_geoOpt1, delta_geoOpt2); + } + + // cap displacement if exceeds the overlap limit, parition the remaining to the other side + if (delta_geo / gm->radi > MDR_OVERLAP_LIMIT) { + delta_geo = gm->radi * MDR_OVERLAP_LIMIT; + } else if (delta_geo_alt / gm->radj > MDR_OVERLAP_LIMIT) { + delta_geo = deltamax - gm->radj * MDR_OVERLAP_LIMIT; + } + + // determine final delta used for subsequent calculations + double deltap = deltap0 + deltap1; + if (contactSide == 0) { + delta = delta_geo + (deltap0 - delta_geo) * (gm->delta - deltamax) / (deltap - deltamax); + } else { + delta = delta_geo + (deltap1 - delta_geo) * (gm->delta - deltamax) / (deltap - deltamax); + } + } else if (gm->contact_type != PAIR && contactSide != 0) { + // contact with particle-wall requires only one evaluation + break; + } + + delta_offset = &history[DELTA_0 + contactSide]; + deltao_offset = &history[DELTAO_0 + contactSide]; + delta_MDR_offset = &history[DELTA_MDR_0 + contactSide]; + delta_BULK_offset = &history[DELTA_BULK_0 + contactSide]; + deltamax_MDR_offset = &history[DELTAMAX_MDR_0 + contactSide]; + Yflag_offset = &history[YFLAG_0 + contactSide]; + deltaY_offset = &history[DELTAY_0 + contactSide]; + cA_offset = &history[CA_0 + contactSide]; + aAdh_offset = &history[AADH_0 + contactSide]; + Ac_offset = &history[AC_0 + contactSide]; + eps_bar_offset = &history[EPS_BAR_0 + contactSide]; + deltap_offset = &history[DELTAP_0 + contactSide]; + + // temporary i and j indices + const int i = gm->i; + const int j = gm->j; + + // geometric property definitions + const double Ro = Rinitial[i]; // initial radius + const double R = gm->radi; // apparent radius + + // kinematics + const double ddelta = delta - *delta_offset; + if (history_update) *delta_offset = delta; + + const double deltao = delta - (R - Ro); + const double ddeltao = deltao - *deltao_offset; + if (history_update) *deltao_offset = deltao; + + double ddelta_MDR, ddelta_BULK; + if (psi[i] < psi_b) { + // bulk response triggered, split displacement increment between MDR and BULK components + ddelta_MDR = MIN(ddelta - ddelta_bar[i], delta - *delta_MDR_offset); + ddelta_BULK = ddelta_bar[i]; + } else { + // no bulk response, full displacement increment goes to the MDR component + ddelta_BULK = 0.0; + ddelta_MDR = ddelta; + } + + // calculate and update MDR/BULK displacements + const double delta_MDR = *delta_MDR_offset + ddelta_MDR; + if (history_update) *delta_MDR_offset = delta_MDR; + const double delta_BULK = MAX(0.0, *delta_BULK_offset + ddelta_BULK); + if (history_update) *delta_BULK_offset = delta_BULK; + + if (delta_MDR > *deltamax_MDR_offset) *deltamax_MDR_offset = delta_MDR; + const double deltamax_MDR = *deltamax_MDR_offset; + + // average pressure along yield surface + const double pY = Y * (1.75 * exp(-4.4 * deltamax_MDR / R) + 1.0); + + if (*Yflag_offset == 0.0 && delta_MDR >= deltamax_MDR) { + const double phertz = 4 * Eeff * sqrt(delta_MDR) / (3 * MY_PI * sqrt(R)); + if (!history_update && warn_flag && deltamaxi == 0 && phertz > pY) { + error->warning(FLERR, "The newly inserted particles have pre-existing overlaps that " + "have caused immediate plastic deformation. This could lead to " + "non-physical results in the MDR model, as it handles some aspects " + "related to plastic deformation incrementally."); + warn_flag = 0; + } + if (history_update && phertz > pY) { + *Yflag_offset = 1.0; + *deltaY_offset = delta_MDR; + *cA_offset = MY_PI * (pow(*deltaY_offset, 2) - *deltaY_offset * R); + } + } + + // MDR force calculation + double F_MDR; + double A, Ainv; // height of elliptical indenter + double B; // width of elliptical indenter + double deltae1D; // transformed elastic displacement + double deltaR; // displacement correction + double amax, amaxsq; // maximum experienced contact radius + const double cA = *cA_offset; // contact area intercept + + if (*Yflag_offset == 0.0) { + // elastic contact + A = 4.0 * R; + Ainv = 1.0 / A; + B = 2.0 * R; + deltae1D = delta_MDR; + amax = sqrt(deltamax_MDR * R); + } else { + // plastic contact + amax = sqrt(2.0 * deltamax_MDR * R - pow(deltamax_MDR, 2) + cA * PIINV); + amaxsq = amax * amax; + A = 4.0 * pY * Eeffinv * amax; + Ainv = 1.0 / A; + B = 2.0 * amax; + + // maximum transformed elastic displacement + const double deltae1Dmax = A * 0.5; + + // force caused by full submersion of elliptical indenter to depth of A/2 + double Fmax = Eeff * (A * B * 0.25) * acos(1 - 2 * deltae1Dmax * Ainv); + Fmax -= (2 - 4 * deltae1Dmax * Ainv) * sqrt(deltae1Dmax * Ainv - pow(deltae1Dmax * Ainv, 2)); + + // depth of particle center + const double zR = R - (deltamax_MDR - deltae1Dmax); + + deltaR = 2 * amaxsq * (-1 + nu) - (-1 + 2 * nu) * zR * (-zR + sqrt(amaxsq + pow(zR, 2))); + deltaR *= Fmax / (MY_2PI * amaxsq * G * sqrt(amaxsq + pow(zR, 2))); + + // transformed elastic displacement + deltae1D = (delta_MDR - deltamax_MDR + deltae1Dmax + deltaR) / (1 + deltaR / deltae1Dmax); + + // added for rigid flat placement + if (history_update) *deltap_offset = deltamax_MDR - (deltae1Dmax + deltaR); + } + + double a_na; + double a_fac = 0.99; + (deltae1D >= 0.0) ? a_na = B * sqrt(A - deltae1D) * sqrt(deltae1D) * Ainv : a_na = 0.0; + double aAdh = *aAdh_offset; + if (aAdh > a_fac * amax) aAdh = a_fac * amax; + + double Ainvsq = Ainv * Ainv; + double Asq = A * A; + double A3 = Asq * A; + double A4 = Asq * Asq; + + double Binv = 1.0 / B; + double Bsq = B * B; + double B4 = Bsq * Bsq; + + if (gamma <= 0.0) { + // non-adhesive contact + + if (deltae1D <= 0.0) { + F_MDR = 0.0; + } else { + F_MDR = calculate_nonadhesive_mdr_force(deltae1D, Ainv, Eeff, A, B); + } + + if (std::isnan(F_MDR)) { + error->one(FLERR, "F_MDR is NaN, non-adhesive case"); + } + + if (history_update) *aAdh_offset = a_na; + } else { + // adhesive contact + double g_aAdh; + + if (delta_MDR == deltamax_MDR || a_na >= aAdh) { + // case 1: no tensile springs, purely compressive contact + + if (deltae1D <= 0.0) { + F_MDR = 0.0; + } else { + F_MDR = calculate_nonadhesive_mdr_force(deltae1D, Ainv, Eeff, A, B); + } + + if (std::isnan(F_MDR)) + error->one(FLERR, "F_MDR is NaN, case 1: no tensile springs"); + + if (history_update) *aAdh_offset = a_fac * a_na; + } else { + // case 2+3, tensile springs + const double lmax = sqrt(MY_2PI * aAdh * gamma * Eeffinv); + g_aAdh = A * 0.5 - A * Binv * sqrt(Bsq * 0.25 - pow(aAdh, 2)); + g_aAdh = round_up_negative_epsilon(g_aAdh); + + double tmp = 27 * A4 * B4 * gamma * Eeffinv; + tmp -= 2 * pow(B, 6) * gamma3 * PISQ * pow(Eeffinv, 3); + tmp += sqrt(27) * Asq * B4 * sqrt(27 * A4 * Eeffsq * gammasq - 4 * Bsq * gamma4 * PISQ) * Eeffsqinv; + tmp = cbrt(tmp); + + double acrit = -Bsq * gamma * MY_PI * Ainvsq * Eeffinv; + acrit += CBRT2 * B4 * gammasq * PITOFIVETHIRDS / (Asq * Eeffsq * tmp); + acrit += CBRTHALFPI * tmp * Ainvsq; + acrit /= 6; + + if ((deltae1D + lmax - g_aAdh) >= 0.0) { + // case 2: tensile springs do not exceed critical length --> deltae + lmax - g(aAdhes) >= 0 + const double deltaeAdh = g_aAdh; + const double F_na = calculate_nonadhesive_mdr_force(deltaeAdh, Ainv, Eeff, A, B); + const double F_Adhes = 2.0 * Eeff * (deltae1D - deltaeAdh) * aAdh; + F_MDR = F_na + F_Adhes; + if (std::isnan(F_MDR)) + error->one(FLERR, "F_MDR is NaN, case 2: tensile springs, but not exceeding critical length"); + } else { + // case 3: tensile springs exceed critical length --> deltae + lmax - g(aAdhes) = 0 + + if (aAdh < acrit) { + aAdh = 0.0; + F_MDR = 0.0; + } else { + // newton-raphson to find aAdh + double aAdh_tmp = aAdh; + double fa, fa2, fa_tmp, dfda; + for (int lv1 = 0; lv1 < MDR_MAX_IT; ++lv1) { + fa_tmp = deltae1D - A * 0.5 + A * sqrt(Bsq * 0.25 - pow(aAdh_tmp, 2)) * Binv; + fa = fa_tmp + sqrt(MY_2PI * aAdh_tmp * gamma * Eeffinv); + if (abs(fa) < MDR_EPSILON1) { + break; + } + dfda = -aAdh_tmp * A / (B * sqrt(-pow(aAdh_tmp, 2) + Bsq * 0.25)); + dfda += gamma * SQRTHALFPI / sqrt(aAdh_tmp * gamma * Eeff); + aAdh_tmp = aAdh_tmp - fa / dfda; + fa2 = fa_tmp + sqrt(MY_2PI * aAdh_tmp * gamma * Eeffinv); + if (abs(fa - fa2) < MDR_EPSILON2) { + break; + } + if (lv1 == MDR_MAX_IT - 1) { + aAdh_tmp = 0.0; + } + } + aAdh = aAdh_tmp; + + g_aAdh = A * 0.5 - A * Binv * sqrt(Bsq * 0.25 - pow(aAdh, 2)); + g_aAdh = round_up_negative_epsilon(g_aAdh); + + const double deltaeAdh = g_aAdh; + const double F_na = calculate_nonadhesive_mdr_force(deltaeAdh, Ainv, Eeff, A, B); + const double F_Adhes = 2.0 * Eeff * (deltae1D - deltaeAdh) * aAdh; + F_MDR = F_na + F_Adhes; + if (std::isnan(F_MDR)) + error->one(FLERR, "F_MDR is NaN, case 3: tensile springs exceed critical length"); + } + if (history_update) *aAdh_offset = aAdh; + } + } + } + + // contact penalty scheme + penalty_offset = &history[PENALTY]; + double pij = *penalty_offset; + const double wij = MAX(1.0 - pij, 0.0); + + // area related calculations + double Ac; + (*Yflag_offset == 0.0) ? Ac = MY_PI * delta * R : Ac = MY_PI * (2.0 * delta * R - pow(delta, 2)) + cA; + if (Ac < 0.0) Ac = 0.0; + if (history_update) { + Atot_sum[i] += wij * (Ac - MY_2PI * R * (deltamax_MDR + delta_BULK)); + Acon1[i] += wij * Ac; + } + Ac_avg += wij * Ac; + + // bulk force calculation + double F_BULK; + (delta_BULK <= 0.0) ? F_BULK = 0.0 : F_BULK = (1.0 / Vgeo[i]) * Acon0[i] * delta_BULK * kappa * Ac; + + // total force calculation + (contactSide == 0) ? F0 = F_MDR + F_BULK : F1 = F_MDR + F_BULK; + + if (history_update) { + // mean surface displacement calculation + *Ac_offset = wij * Ac; + + // radius update scheme quantity calculation + Vcaps[i] += MY_PI * THIRD * pow(delta, 2) * (3.0 * R - delta); + } + + const double Fntmp = wij * (F_MDR + F_BULK); + const double fx = Fntmp * gm->nx[0]; + const double fy = Fntmp * gm->nx[1]; + const double fz = Fntmp * gm->nx[2]; + const double bx = -(Ro - deltao) * gm->nx[0]; + const double by = -(Ro - deltao) * gm->nx[1]; + const double bz = -(Ro - deltao) * gm->nx[2]; + const double eps_bar_contact = (fx * bx + fy * by + fz * bz) / (3 * kappa * Velas[i]); + if (history_update) eps_bar[i] += eps_bar_contact; + + double desp_bar_contact = eps_bar_contact - *eps_bar_offset; + if (history_update && delta_MDR == deltamax_MDR && *Yflag_offset > 0.0 && F_MDR > 0.0) { + const double Vo = FOURTHIRDS * MY_PI * pow(Ro, 3); + dRnumerator[i] -= Vo * (eps_bar_contact - *eps_bar_offset); + dRnumerator[i] -= wij * MY_PI * ddeltao * (2 * deltao * Ro - pow(deltao, 2) + pow(R, 2) - pow(Ro, 2)); + dRdenominator[i] += wij * 2.0 * MY_PI * R * (deltao + R - Ro); + } + + if (history_update) { + *eps_bar_offset = eps_bar_contact; + sigmaxx[i] += fx * bx / Velas[i]; + sigmayy[i] += fy * by / Velas[i]; + sigmazz[i] += fz * bz / Velas[i]; + } + } + + // save contact area + if (gm->calculate_svector) gm->svector[index_svector] = Ac_avg * 0.5; + + gm->i = i_true; + gm->j = j_true; + gm->radi = radi_true; + gm->radj = radj_true; + + double *penalty_offset = &history[PENALTY]; + const double pij = *penalty_offset; + const double wij = MAX(1.0 - pij, 0.0); + + // assign final force + if (gm->contact_type != PAIR) { + F = wij * F0; + } else { + F = wij * (F0 + F1) * 0.5; + } + + // calculate damping force + if (F > 0.0) { + double Eeff2; + double Reff2; + if (gm->contact_type == PAIR) { + Eeff2 = E / (2.0 * (1.0 - pow(nu, 2))); + Reff2 = 1.0 / ((1.0 / gm->radi + 1.0 / gm->radj)); + } else { + Eeff2 = E / (1.0 - pow(nu, 2)); + Reff2 = gm->radi; + } + const double kn = Eeff2 * Reff2; + const double beta = -log(CoR) / sqrt(pow(log(CoR), 2) + PISQ); + const double damp_prefactor = beta * sqrt(gm->meff * kn); + const double F_DAMP = -damp_prefactor * gm->vnnr; + + F += wij * F_DAMP; + } + + return F; +} + + +/* ---------------------------------------------------------------------- */ + +double GranSubModNormalMDR::calculate_nonadhesive_mdr_force(double delta, double Ainv, double Eeff, double A, double B) +{ + double F_na = acos(1.0 - 2.0 * delta * Ainv); + F_na -= (2 - 4 * delta * Ainv) * sqrt(delta * Ainv - pow(delta * Ainv, 2)); + F_na *= 0.25 * Eeff * A * B; + + return F_na; +} + +/* ---------------------------------------------------------------------- + round values within (-EPSILON,0.0) due to machine precision errors to zero +------------------------------------------------------------------------- */ + +double GranSubModNormalMDR::round_up_negative_epsilon(double value) +{ + if (value < 0.0 && value > -MDR_EPSILON3) value = 0.0; + return value; +} diff --git a/src/GRANULAR/gran_sub_mod_normal.h b/src/GRANULAR/gran_sub_mod_normal.h index c1ed36b6e1..db96227f13 100644 --- a/src/GRANULAR/gran_sub_mod_normal.h +++ b/src/GRANULAR/gran_sub_mod_normal.h @@ -19,6 +19,7 @@ GranSubModStyle(hertz,GranSubModNormalHertz,NORMAL); GranSubModStyle(hertz/material,GranSubModNormalHertzMaterial,NORMAL); GranSubModStyle(dmt,GranSubModNormalDMT,NORMAL); GranSubModStyle(jkr,GranSubModNormalJKR,NORMAL); +GranSubModStyle(mdr,GranSubModNormalMDR,NORMAL); // clang-format on #else @@ -133,6 +134,35 @@ namespace Granular_NS { int mixed_coefficients; }; + /* ---------------------------------------------------------------------- */ + + class GranSubModNormalMDR : public GranSubModNormal { + public: + GranSubModNormalMDR(class GranularModel *, class LAMMPS *); + ~GranSubModNormalMDR() override; + void coeffs_to_local() override; + void init() override; + double calculate_forces() override; + double E, nu, Y, gamma, CoR, psi_b; // specified coeffs + + protected: + double G, kappa, Eeff; // derived coeffs + double Eeffsq, Eeffinv, Eeffsqinv; + double gammasq, gamma3, gamma4; + + int warn_flag; + + int index_Ro, index_Vgeo, index_Velas, index_Vcaps, index_eps_bar, index_dRnumerator; + int index_dRdenominator, index_Acon0, index_Acon1, index_Atot, index_Atot_sum, index_ddelta_bar; + int index_psi, index_sigmaxx, index_sigmayy, index_sigmazz, index_contacts, index_adhesive_length; + int fix_mdr_flag; + + char *id_fix; + + inline double calculate_nonadhesive_mdr_force(double, double, double, double, double); + inline double round_up_negative_epsilon(double); + }; + } // namespace Granular_NS } // namespace LAMMPS_NS diff --git a/src/GRANULAR/granular_model.cpp b/src/GRANULAR/granular_model.cpp index 9764ec42e9..cb89cc1bd1 100644 --- a/src/GRANULAR/granular_model.cpp +++ b/src/GRANULAR/granular_model.cpp @@ -27,6 +27,7 @@ #include "force.h" #include "gran_sub_mod.h" #include "math_extra.h" +#include "memory.h" #include "style_gran_sub_mod.h" // IWYU pragma: keep @@ -64,6 +65,10 @@ GranularModel::GranularModel(LAMMPS *lmp) : Pointers(lmp) twisting_model = nullptr; heat_model = nullptr; + calculate_svector = 0; + nsvector = 0; + svector = nullptr; + for (int i = 0; i < NSUBMODELS; i++) sub_models[i] = nullptr; transfer_history_factor = nullptr; @@ -100,6 +105,7 @@ GranularModel::~GranularModel() delete[] gran_sub_mod_class; delete[] gran_sub_mod_names; delete[] gran_sub_mod_types; + delete[] svector; for (int i = 0; i < NSUBMODELS; i++) delete sub_models[i]; } @@ -243,7 +249,12 @@ void GranularModel::init() // Must have valid normal, damping, and tangential models if (normal_model->name == "none") error->all(FLERR, "Must specify normal granular model"); - if (damping_model->name == "none") error->all(FLERR, "Must specify damping granular model"); + if (normal_model->name == "mdr") { + if (damping_model->name != "none") + error->all(FLERR, "MDR require 'none' damping model. To damp, specify a coefficient of restitution < 1."); + } else { + if (damping_model->name == "none") error->all(FLERR, "Must specify damping granular model"); + } if (tangential_model->name == "none") error->all(FLERR, "Must specify tangential granular model"); // Twisting, rolling, and heat are optional @@ -293,6 +304,21 @@ void GranularModel::init() } for (int i = 0; i < NSUBMODELS; i++) sub_models[i]->init(); + + nsvector = 0; + int index_svector = 0; + for (int i = 0; i < NSUBMODELS; i++) { + if (sub_models[i]->nsvector != 0) { + sub_models[i]->index_svector = index_svector; + nsvector += sub_models[i]->nsvector; + index_svector += sub_models[i]->nsvector; + } + } + + if (nsvector != 0) { + delete[] svector; + svector = new double[nsvector]; + } } /* ---------------------------------------------------------------------- */ @@ -493,9 +519,8 @@ void GranularModel::calculate_forces() if (contact_type == PAIR) sub3(torquesj, tortwist, torquesj); } - if (heat_defined) { + if (heat_defined) dq = heat_model->calculate_heat(); - } } /* ---------------------------------------------------------------------- diff --git a/src/GRANULAR/granular_model.h b/src/GRANULAR/granular_model.h index a2e1f14776..67df1410d9 100644 --- a/src/GRANULAR/granular_model.h +++ b/src/GRANULAR/granular_model.h @@ -74,6 +74,9 @@ class GranularModel : protected Pointers { int beyond_contact, limit_damping, history_update; ContactType contact_type; + // Particle identifiers + int i, j, itype, jtype; + // History variables int size_history, nondefault_history_transfer; double *transfer_history_factor; @@ -93,6 +96,10 @@ class GranularModel : protected Pointers { double magtwist; bool touch; + // Extra output + int calculate_svector, nsvector; + double *svector; + protected: int rolling_defined, twisting_defined, heat_defined; // Flag optional sub models int classic_model; // Flag original pair/gran calculations diff --git a/src/GRANULAR/pair_granular.cpp b/src/GRANULAR/pair_granular.cpp index cb19a8c025..bae3371ebc 100644 --- a/src/GRANULAR/pair_granular.cpp +++ b/src/GRANULAR/pair_granular.cpp @@ -199,6 +199,11 @@ void PairGranular::compute(int eflag, int vflag) model->xj = x[j]; model->radi = radius[i]; model->radj = radius[j]; + model->i = i; + model->j = j; + model->itype = itype; + model->jtype = jtype; + if (use_history) model->touch = touch[jj]; touchflag = model->check_contact(); @@ -412,8 +417,10 @@ void PairGranular::init_style() error->all(FLERR,"Heat conduction in pair granular requires atom style with heatflow property"); } - // allocate history and initialize models + // allocate history and aggregate model information class GranularModel* model; + double nsvector_total; + extra_svector = 0; int size_max[NSUBMODELS] = {0}; for (int n = 0; n < nmodels; n++) { model = models_list[n]; @@ -424,13 +431,23 @@ void PairGranular::init_style() } if (model->size_history != 0) use_history = 1; - for (int i = 0; i < NSUBMODELS; i++) + nsvector_total = 0; + for (int i = 0; i < NSUBMODELS; i++) { + nsvector_total += model->sub_models[i]->nsvector; if (model->sub_models[i]->size_history > size_max[i]) size_max[i] = model->sub_models[i]->size_history; + } + extra_svector = MAX(extra_svector, nsvector_total); if (model->nondefault_history_transfer) nondefault_history_transfer = 1; } + if (extra_svector != 0) { + single_extra = 12 + extra_svector; + delete[] svector; + svector = new double[single_extra]; + } + size_history = 0; if (use_history) { for (int i = 0; i < NSUBMODELS; i++) size_history += size_max[i]; @@ -711,6 +728,10 @@ double PairGranular::single(int i, int j, int itype, int jtype, model->xj = x[j]; model->radi = radius[i]; model->radj = radius[j]; + model->i = i; + model->j = j; + model->itype = itype; + model->jtype = jtype; model->history_update = 0; // Don't update history // If history is needed @@ -765,7 +786,9 @@ double PairGranular::single(int i, int j, int itype, int jtype, model->omegaj = omega[j]; model->history = history; + model->calculate_svector = 1; model->calculate_forces(); + model->calculate_svector = 0; // apply forces & torques // Calculate normal component, normalized by r @@ -785,6 +808,14 @@ double PairGranular::single(int i, int j, int itype, int jtype, svector[10] = model->dx[1]; svector[11] = model->dx[2]; + // add submodel-specific quantities + for (int n = 0; n < model->nsvector; n++) + svector[12 + n] = model->svector[n]; + + // zero any values unused by this specific model + for (int n = 12 + model->nsvector; n < single_extra; n++) + svector[n] = 0.0; + return 0.0; } diff --git a/src/GRANULAR/pair_granular.h b/src/GRANULAR/pair_granular.h index f94f4f5dff..b3b8d350f0 100644 --- a/src/GRANULAR/pair_granular.h +++ b/src/GRANULAR/pair_granular.h @@ -46,6 +46,12 @@ class PairGranular : public Pair { double memory_usage() override; double atom2cut(int) override; double radii2cut(double, double) override; + int get_size_history() const { return size_history; } + + // granular models + class Granular_NS::GranularModel** models_list; + int **types_indices; + int nmodels, maxmodels; protected: int freeze_group_bit; @@ -73,14 +79,11 @@ class PairGranular : public Pair { int size_history; int heat_flag; - // granular models - int nmodels, maxmodels; - class Granular_NS::GranularModel **models_list; - int **types_indices; - // optional user-specified global cutoff, per-type user-specified cutoffs double **cutoff_type; double cutoff_global; + + int extra_svector; }; } // namespace LAMMPS_NS diff --git a/src/INTEL/verlet_lrt_intel.cpp b/src/INTEL/verlet_lrt_intel.cpp index 9df17d8cef..3e18295461 100644 --- a/src/INTEL/verlet_lrt_intel.cpp +++ b/src/INTEL/verlet_lrt_intel.cpp @@ -94,7 +94,7 @@ void VerletLRTIntel::setup(int flag) if (comm->me == 0 && screen) { fputs("Setting up VerletLRTIntel run ...\n",screen); if (flag) { - fmt::print(screen," Unit style : {}\n" + utils::print(screen," Unit style : {}\n" " Current step : {}\n" " Time step : {}\n", update->unit_style,update->ntimestep,update->dt); diff --git a/src/KOKKOS/Install.sh b/src/KOKKOS/Install.sh index 4269e64189..d34d5eb9ee 100755 --- a/src/KOKKOS/Install.sh +++ b/src/KOKKOS/Install.sh @@ -119,6 +119,14 @@ action compute_composition_atom_kokkos.cpp compute_composition_atom.cpp action compute_composition_atom_kokkos.h compute_composition_atom.h action compute_orientorder_atom_kokkos.cpp action compute_orientorder_atom_kokkos.h +action compute_sna_grid_kokkos.cpp compute_sna_grid.cpp +action compute_sna_grid_kokkos.h compute_sna_grid.h +action compute_sna_grid_kokkos_impl.h compute_sna_grid.cpp +action compute_sna_grid_local_kokkos.cpp compute_sna_grid_local.cpp +action compute_sna_grid_local_kokkos.h compute_sna_grid_local.h +action compute_sna_grid_local_kokkos_impl.h compute_sna_grid_local.cpp +action compute_gaussian_grid_local_kokkos.cpp compute_gaussian_grid_local.cpp +action compute_gaussian_grid_local_kokkos.h compute_gaussian_grid_local.h action compute_temp_deform_kokkos.cpp action compute_temp_deform_kokkos.h action compute_temp_kokkos.cpp diff --git a/src/KOKKOS/compute_gaussian_grid_local_kokkos.cpp b/src/KOKKOS/compute_gaussian_grid_local_kokkos.cpp new file mode 100644 index 0000000000..e324976f30 --- /dev/null +++ b/src/KOKKOS/compute_gaussian_grid_local_kokkos.cpp @@ -0,0 +1,308 @@ +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing author: Drew Rohskopf (SNL) +------------------------------------------------------------------------- */ + +#include "compute_gaussian_grid_local_kokkos.h" + +#include "atom_kokkos.h" +#include "atom_masks.h" +#include "comm.h" +#include "domain.h" +#include "error.h" +#include "force.h" +#include "memory_kokkos.h" +#include "modify.h" +#include "neigh_list.h" +#include "neigh_request.h" +#include "neighbor_kokkos.h" +#include "pair.h" +#include "update.h" + +#include +#include + +using namespace LAMMPS_NS; + +/* ---------------------------------------------------------------------- */ + +template +ComputeGaussianGridLocalKokkos::ComputeGaussianGridLocalKokkos(LAMMPS *lmp, int narg, char **arg) : + ComputeGaussianGridLocal(lmp, narg, arg) +{ + kokkosable = 1; + atomKK = (AtomKokkos *) atom; + execution_space = ExecutionSpaceFromDevice::space; + datamask_read = EMPTY_MASK; + datamask_modify = EMPTY_MASK; + + k_cutsq = tdual_fparams("ComputeSNAGridKokkos::cutsq",atom->ntypes+1,atom->ntypes+1); + auto d_cutsq = k_cutsq.template view(); + rnd_cutsq = d_cutsq; + + host_flag = (execution_space == Host); + + for (int i = 1; i <= atom->ntypes; i++) { + for (int j = 1; j <= atom->ntypes; j++){ + k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutsq[i][j]; //cutsq_tmp; + k_cutsq.template modify(); + } + } + // Set up element lists + int n = atom->ntypes; + MemKK::realloc_kokkos(d_radelem,"ComputeSNAGridKokkos::radelem",n); + MemKK::realloc_kokkos(d_sigmaelem,"ComputeSNAGridKokkos::sigmaelem",n+1); + MemKK::realloc_kokkos(d_prefacelem,"ComputeSNAGridKokkos::prefacelem",n+1); + MemKK::realloc_kokkos(d_argfacelem,"ComputeSNAGridKokkos::argfacelem",n+1); + MemKK::realloc_kokkos(d_map,"ComputeSNAGridKokkos::map",n+1); + auto h_radelem = Kokkos::create_mirror_view(d_radelem); + auto h_sigmaelem = Kokkos::create_mirror_view(d_sigmaelem); + auto h_prefacelem = Kokkos::create_mirror_view(d_prefacelem); + auto h_argfacelem = Kokkos::create_mirror_view(d_argfacelem); + auto h_map = Kokkos::create_mirror_view(d_map); + // start from index 1 because of how compute sna/grid is + for (int i = 1; i <= atom->ntypes; i++) { + h_radelem(i-1) = radelem[i]; + h_sigmaelem(i-1) = sigmaelem[i]; + h_prefacelem(i-1) = prefacelem[i]; + h_argfacelem(i-1) = argfacelem[i]; + } + Kokkos::deep_copy(d_radelem,h_radelem); + Kokkos::deep_copy(d_sigmaelem,h_sigmaelem); + Kokkos::deep_copy(d_prefacelem, h_prefacelem); + Kokkos::deep_copy(d_argfacelem, h_argfacelem); + Kokkos::deep_copy(d_map,h_map); + +} + +/* ---------------------------------------------------------------------- */ + +template +ComputeGaussianGridLocalKokkos::~ComputeGaussianGridLocalKokkos() +{ + if (copymode) return; + + memoryKK->destroy_kokkos(k_cutsq,cutsq); + memoryKK->destroy_kokkos(k_alocal,alocal); + //gridlocal_allocated = 0; + +} + +/* ---------------------------------------------------------------------- */ + +template +void ComputeGaussianGridLocalKokkos::setup() +{ + + ComputeGridLocal::setup(); + + // allocate arrays + memoryKK->create_kokkos(k_alocal, alocal, size_local_rows, size_local_cols, "grid:alocal"); + array_local = alocal; + d_alocal = k_alocal.template view(); + +} + +/* ---------------------------------------------------------------------- */ + +template +void ComputeGaussianGridLocalKokkos::init() +{ + ComputeGaussianGridLocal::init(); +} + +/* ---------------------------------------------------------------------- */ + +template +void ComputeGaussianGridLocalKokkos::compute_local() +{ + if (host_flag) { + return; + } + + invoked_local = update->ntimestep; + + copymode = 1; + + zlen = nzhi-nzlo+1; + ylen = nyhi-nylo+1; + xlen = nxhi-nxlo+1; + total_range = (nzhi-nzlo+1)*(nyhi-nylo+1)*(nxhi-nxlo+1); + + atomKK->sync(execution_space,X_MASK|F_MASK|TYPE_MASK); + x = atomKK->k_x.view(); + type = atomKK->k_type.view(); + k_cutsq.template sync(); + + // max_neighs is defined here - think of more elaborate methods. + max_neighs = 100; + + // Pair snap/kk uses grow_ij with some max number of neighs but compute sna/grid uses total + // number of atoms. + ntotal = atomKK->nlocal + atomKK->nghost; + // Allocate view for number of neighbors per grid point + MemKK::realloc_kokkos(d_ninside,"ComputeSNAGridKokkos:ninside",total_range); + + // "chunksize" variable is default 32768 in compute_sna_grid.cpp, and set by user + // `total_range` is the number of grid points which may be larger than chunk size. + // printf(">>> total_range: %d\n", total_range); + chunksize = 32768; // 100*32768 + chunk_size = MIN(chunksize, total_range); + chunk_offset = 0; + + int vector_length_default = 1; + int team_size_default = 1; + if (!host_flag) + team_size_default = 1; // cost will increase with increasing team size //32;//max_neighs; + + if (triclinic){ + h0 = domain->h[0]; + h1 = domain->h[1]; + h2 = domain->h[2]; + h3 = domain->h[3]; + h4 = domain->h[4]; + h5 = domain->h[5]; + lo0 = domain->boxlo[0]; + lo1 = domain->boxlo[1]; + lo2 = domain->boxlo[2]; + } + + while (chunk_offset < total_range) { // chunk up loop to prevent running out of memory + + if (chunk_size > total_range - chunk_offset) + chunk_size = total_range - chunk_offset; + + //Neigh + { + int vector_length = vector_length_default; + int team_size = team_size_default; + check_team_size_for(chunk_size,team_size,vector_length); + typename Kokkos::TeamPolicy policy_neigh(chunk_size,team_size,vector_length); + Kokkos::parallel_for("ComputeGaussianGridLocalNeigh",policy_neigh,*this); + } + + // Proceed to the next chunk. + chunk_offset += chunk_size; + } // end while + + copymode = 0; + + k_alocal.template modify(); + k_alocal.template sync(); + +} + +/* ---------------------------------------------------------------------- */ + +template +KOKKOS_INLINE_FUNCTION +void ComputeGaussianGridLocalKokkos::operator() (TagComputeGaussianGridLocalNeigh,const typename Kokkos::TeamPolicy::member_type& team) const +{ + const int ii = team.league_rank(); + + if (ii >= chunk_size) return; + + // extract grid index + int igrid = ii + chunk_offset; + + // convert to grid indices + + int iz = igrid/(xlen*ylen); + int i2 = igrid - (iz*xlen*ylen); + int iy = i2/xlen; + int ix = i2 % xlen; + iz += nzlo; + iy += nylo; + ix += nxlo; + + double xgrid[3]; + + // index ii already captures the proper grid point + //int igrid = iz * (nx * ny) + iy * nx + ix; + + // grid2x converts igrid to ix,iy,iz like we've done before + // multiply grid integers by grid spacing delx, dely, delz + //grid2x(igrid, xgrid); + xgrid[0] = ix * delx; + xgrid[1] = iy * dely; + xgrid[2] = iz * delz; + + if (triclinic) { + + // Do a conversion on `xgrid` here like we do in the CPU version. + + // Can't do this: + // domainKK->lamda2x(xgrid, xgrid); + // Because calling a __host__ function("lamda2x") from a __host__ __device__ function("operator()") is not allowed + + // Using domainKK-> gives segfault, use domain-> instead since we're just accessing floats. + xgrid[0] = h0*xgrid[0] + h5*xgrid[1] + h4*xgrid[2] + lo0; + xgrid[1] = h1*xgrid[1] + h3*xgrid[2] + lo1; + xgrid[2] = h2*xgrid[2] + lo2; + } + + const F_FLOAT xtmp = xgrid[0]; + const F_FLOAT ytmp = xgrid[1]; + const F_FLOAT ztmp = xgrid[2]; + + // Zeroing out the components, which are filled as a sum. + for (int icol = size_local_cols_base; icol < size_local_cols; icol++){ + d_alocal(igrid, icol) = 0.0; + } + + // Fill grid info columns + d_alocal(igrid, 0) = ix; + d_alocal(igrid, 1) = iy; + d_alocal(igrid, 2) = iz; + d_alocal(igrid, 3) = xtmp; + d_alocal(igrid, 4) = ytmp; + d_alocal(igrid, 5) = ztmp; + + // Looping over ntotal for now. + for (int j = 0; j < ntotal; j++){ + const F_FLOAT dx = x(j,0) - xtmp; + const F_FLOAT dy = x(j,1) - ytmp; + const F_FLOAT dz = x(j,2) - ztmp; + int jtype = type(j); + const F_FLOAT rsq = dx*dx + dy*dy + dz*dz; + + if (rsq < rnd_cutsq(jtype, jtype) ) { + int icol = size_local_cols_base + jtype - 1; + d_alocal(igrid, icol) += d_prefacelem(jtype-1) * exp(-rsq * d_argfacelem(jtype-1)); + } + } +} + +/* ---------------------------------------------------------------------- + check max team size +------------------------------------------------------------------------- */ + +template +template +void ComputeGaussianGridLocalKokkos::check_team_size_for(int inum, int &team_size, int vector_length) { + int team_size_max; + + team_size_max = Kokkos::TeamPolicy(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelForTag()); + + if (team_size*vector_length > team_size_max) + team_size = team_size_max/vector_length; +} + +namespace LAMMPS_NS { +template class ComputeGaussianGridLocalKokkos; +#ifdef LMP_KOKKOS_GPU +template class ComputeGaussianGridLocalKokkos; +#endif +} diff --git a/src/KOKKOS/compute_gaussian_grid_local_kokkos.h b/src/KOKKOS/compute_gaussian_grid_local_kokkos.h new file mode 100644 index 0000000000..34e12bc4af --- /dev/null +++ b/src/KOKKOS/compute_gaussian_grid_local_kokkos.h @@ -0,0 +1,96 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#ifdef COMPUTE_CLASS +// clang-format off +ComputeStyle(gaussian/grid/local/kk,ComputeGaussianGridLocalKokkos); +ComputeStyle(gaussian/grid/local/kk/device,ComputeGaussianGridLocalKokkos); +ComputeStyle(gaussian/grid/local/kk/host,ComputeGaussianGridLocalKokkos); +// clang-format on + +#else + +#ifndef LMP_COMPUTE_GAUSSIAN_GRID_LOCAL_KOKKOS_H +#define LMP_COMPUTE_GAUSSIAN_GRID_LOCAL_KOKKOS_H + +#include "compute_gaussian_grid_local.h" +#include "kokkos_type.h" + +namespace LAMMPS_NS { + +// clang-format off +struct TagComputeGaussianGridLocalNeigh{}; +// clang-format on + +template class ComputeGaussianGridLocalKokkos : public ComputeGaussianGridLocal { + public: + typedef DeviceType device_type; + typedef ArrayTypes AT; + + // Static team/tile sizes for device offload + +#ifdef KOKKOS_ENABLE_HIP + static constexpr int team_size_compute_neigh = 2; +#else + static constexpr int team_size_compute_neigh = 4; +#endif + + ComputeGaussianGridLocalKokkos(class LAMMPS *, int, char **); + ~ComputeGaussianGridLocalKokkos() override; + void setup() override; + void init() override; + void compute_local() override; + + template + void check_team_size_for(int, int&, int); + + KOKKOS_INLINE_FUNCTION + void operator() (TagComputeGaussianGridLocalNeigh, const typename Kokkos::TeamPolicy::member_type& team) const; + + private: + Kokkos::View d_radelem; // element radii + Kokkos::View d_sigmaelem; + Kokkos::View d_prefacelem; + Kokkos::View d_argfacelem; + Kokkos::View d_ninside; // ninside for all atoms in list + Kokkos::View d_map; // mapping from atom types to elements + + typedef Kokkos::DualView tdual_fparams; + tdual_fparams k_cutsq; + typedef Kokkos::View > t_fparams_rnd; + t_fparams_rnd rnd_cutsq; + + + int max_neighs, inum, chunk_size, chunk_offset; + int host_flag; + int total_range; // total number of loop iterations in grid + int xlen, ylen, zlen; + int chunksize; + int ntotal; + + typename AT::t_x_array_randomread x; + typename AT::t_int_1d_randomread type; + + DAT::tdual_float_2d k_alocal; + typename AT::t_float_2d d_alocal; + + // triclinic vars + double h0, h1, h2, h3, h4, h5; + double lo0, lo1, lo2; +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/KOKKOS/compute_sna_grid_kokkos.cpp b/src/KOKKOS/compute_sna_grid_kokkos.cpp new file mode 100644 index 0000000000..197234cf1d --- /dev/null +++ b/src/KOKKOS/compute_sna_grid_kokkos.cpp @@ -0,0 +1,25 @@ +// clang-format off +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#include "compute_sna_grid_kokkos.h" +#include "compute_sna_grid_kokkos_impl.h" + +namespace LAMMPS_NS { + +template class ComputeSNAGridKokkosDevice; +#ifdef LMP_KOKKOS_GPU +template class ComputeSNAGridKokkosHost; +#endif + +} diff --git a/src/KOKKOS/compute_sna_grid_kokkos.h b/src/KOKKOS/compute_sna_grid_kokkos.h new file mode 100644 index 0000000000..8a7d87acbb --- /dev/null +++ b/src/KOKKOS/compute_sna_grid_kokkos.h @@ -0,0 +1,297 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#ifdef COMPUTE_CLASS +// clang-format off +ComputeStyle(sna/grid/kk,ComputeSNAGridKokkosDevice); +ComputeStyle(sna/grid/kk/device,ComputeSNAGridKokkosDevice); +#ifdef LMP_KOKKOS_GPU +ComputeStyle(sna/grid/kk/host,ComputeSNAGridKokkosHost); +#else +ComputeStyle(sna/grid/kk/host,ComputeSNAGridKokkosDevice); +#endif +// clang-format on +#else + +// clang-format off +#ifndef LMP_COMPUTE_SNA_GRID_KOKKOS_H +#define LMP_COMPUTE_SNA_GRID_KOKKOS_H + +#include "compute_sna_grid.h" +#include "kokkos_type.h" +#include "sna_kokkos.h" + +namespace LAMMPS_NS { + +// Routines for both the CPU and GPU backend + +// GPU backend only +struct TagCSNAGridComputeNeigh{}; +struct TagCSNAGridComputeCayleyKlein{}; +struct TagCSNAGridPreUi{}; +struct TagCSNAGridComputeUiSmall{}; // more parallelism, more divergence +struct TagCSNAGridComputeUiLarge{}; // less parallelism, no divergence +struct TagCSNAGridTransformUi{}; // re-order ulisttot from SoA to AoSoA, zero ylist +template struct TagCSNAGridComputeZi{}; +template struct TagCSNAGridComputeBi{}; +struct TagCSNAGridLocalFill{}; // fill the gridlocal array + +struct TagComputeSNAGridLoop{}; +struct TagComputeSNAGrid3D{}; + +// CPU backend only +struct TagComputeSNAGridLoopCPU{}; + +//template +template +class ComputeSNAGridKokkos : public ComputeSNAGrid { + public: + typedef DeviceType device_type; + typedef ArrayTypes AT; + + static constexpr int vector_length = vector_length_; + using real_type = real_type_; + using complex = SNAComplex; + + // Static team/tile sizes for device offload + +#ifdef KOKKOS_ENABLE_HIP + static constexpr int team_size_compute_neigh = 2; + static constexpr int tile_size_compute_ck = 2; + static constexpr int tile_size_pre_ui = 2; + static constexpr int team_size_compute_ui = 2; + static constexpr int tile_size_transform_ui = 2; + static constexpr int tile_size_compute_zi = 2; + static constexpr int min_blocks_compute_zi = 0; // no minimum bound + static constexpr int tile_size_compute_bi = 2; + static constexpr int tile_size_compute_yi = 2; + static constexpr int min_blocks_compute_yi = 0; // no minimum bound + static constexpr int team_size_compute_fused_deidrj = 2; +#else + static constexpr int team_size_compute_neigh = 4; + static constexpr int tile_size_compute_ck = 4; + static constexpr int tile_size_pre_ui = 4; + static constexpr int team_size_compute_ui = sizeof(real_type) == 4 ? 8 : 4; + static constexpr int tile_size_transform_ui = 4; + static constexpr int tile_size_compute_zi = 8; + static constexpr int tile_size_compute_bi = 4; + static constexpr int tile_size_compute_yi = 8; + static constexpr int team_size_compute_fused_deidrj = sizeof(real_type) == 4 ? 4 : 2; + + // this empirically reduces perf fluctuations from compiler version to compiler version + static constexpr int min_blocks_compute_zi = 4; + static constexpr int min_blocks_compute_yi = 4; +#endif + + // Custom MDRangePolicy, Rank3, to reduce verbosity of kernel launches + // This hides the Kokkos::IndexType and Kokkos::Rank<3...> + // and reduces the verbosity of the LaunchBound by hiding the explicit + // multiplication by vector_length + template + using Snap3DRangePolicy = typename Kokkos::MDRangePolicy, Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Left>, Kokkos::LaunchBounds, TagComputeSNA>; + + // MDRangePolicy for the 3D grid loop: + template + using CSNAGrid3DPolicy = typename Kokkos::MDRangePolicy, Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Left>>; + + // Testing out team policies + template + using CSNAGridTeamPolicy = typename Kokkos::TeamPolicy, TagComputeSNA>; + //using CSNAGridTeamPolicy = typename Kokkos::TeamPolicy, Kokkos::IndexType, Kokkos::IndexType, TagComputeSNA>; + //using team_member = typename team_policy::member_type; + + // Custom SnapAoSoATeamPolicy to reduce the verbosity of kernel launches + // This hides the LaunchBounds abstraction by hiding the explicit + // multiplication by vector length + template + using SnapAoSoATeamPolicy = typename Kokkos::TeamPolicy, TagComputeSNA>; + + // Helper routine that returns a CPU or a GPU policy as appropriate + template + auto snap_get_policy(const int& chunk_size_div, const int& second_loop) { + return Snap3DRangePolicy({0, 0, 0}, + {vector_length, second_loop, chunk_size_div}, + {vector_length, num_tiles, 1}); + } + + ComputeSNAGridKokkos(class LAMMPS *, int, char **); + ~ComputeSNAGridKokkos() override; + + void setup() override; + void compute_array() override; + + // Utility functions for teams + + template + void check_team_size_for(int, int&); + + template + void check_team_size_reduce(int, int&); + + // operator function for example team policy + //KOKKOS_INLINE_FUNCTION + + KOKKOS_INLINE_FUNCTION + void operator() (TagComputeSNAGridLoop, const int& ) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagComputeSNAGridLoopCPU, const int&) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeNeigh,const typename Kokkos::TeamPolicy::member_type& team) const; + + // 3D case - used by parallel_for + KOKKOS_INLINE_FUNCTION + void operator()(TagComputeSNAGrid3D, const int& iz, const int& iy, const int& ix) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeCayleyKlein, const int iatom_mod, const int jnbor, const int iatom_div) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridPreUi, const int& iatom_mod, const int& j, const int& iatom_div) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridPreUi, const int& iatom, const int& j) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridPreUi, const int& iatom) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeUiSmall,const typename Kokkos::TeamPolicy::member_type& team) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeUiLarge,const typename Kokkos::TeamPolicy::member_type& team) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridTransformUi, const int& iatom_mod, const int& idxu, const int& iatom_div) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridTransformUi, const int& iatom, const int& idxu) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridTransformUi, const int& iatom) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeZi, const int& iatom_mod, const int& idxz, const int& iatom_div) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeZi, const int& iatom, const int& idxz) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeZi, const int& iatom) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeBi, const int& iatom_mod, const int& idxb, const int& iatom_div) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeBi, const int& iatom, const int& idxb) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridComputeBi, const int& iatom) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalFill,const int& ii) const; + + protected: + + SNAKokkos snaKK; + + int max_neighs, chunk_size, chunk_offset; + int host_flag; + int ntotal; + int total_range; // total number of loop iterations in grid + int zlen; //= nzhi-nzlo+1; + int ylen; //= nyhi-nylo+1; + int xlen; //= nxhi-nxlo+1; + + double cutsq_tmp; // temporary cutsq until we get a view + + Kokkos::View d_radelem; // element radii + Kokkos::View d_wjelem; // elements weights + Kokkos::View d_coeffelem; // element bispectrum coefficients + Kokkos::View d_sinnerelem; // element inner cutoff midpoint + Kokkos::View d_dinnerelem; // element inner cutoff half-width + Kokkos::View d_ninside; // ninside for all atoms in list + Kokkos::View d_map; // mapping from atom types to elements + Kokkos::View d_test; // test view + + typedef Kokkos::DualView tdual_fparams; + tdual_fparams k_cutsq; + typedef Kokkos::View > t_fparams_rnd; + t_fparams_rnd rnd_cutsq; + + typename AT::t_x_array_randomread x; + typename AT::t_int_1d_randomread type; + DAT::tdual_float_2d k_grid; + DAT::tdual_float_2d k_gridall; + typename AT::t_float_2d d_grid; + typename AT::t_float_2d d_gridall; + + DAT::tdual_float_4d k_gridlocal; + typename AT::t_float_4d d_gridlocal; + + + // Utility routine which wraps computing per-team scratch size requirements for + // ComputeNeigh, ComputeUi, and ComputeFusedDeidrj + template + int scratch_size_helper(int values_per_team); + + class DomainKokkos *domainKK; + + // triclinic vars + double h0, h1, h2, h3, h4, h5; + double lo0, lo1, lo2; + + // Make SNAKokkos a friend + friend class SNAKokkos; +}; + +// These wrapper classes exist to make the compute style factory happy/avoid having +// to extend the compute style factory to support Compute classes w/an arbitrary number +// of extra template parameters + +template +class ComputeSNAGridKokkosDevice : public ComputeSNAGridKokkos { + + private: + using Base = ComputeSNAGridKokkos; + + public: + + ComputeSNAGridKokkosDevice(class LAMMPS *, int, char **); + + void compute_array() override; + +}; + +#ifdef LMP_KOKKOS_GPU +template +class ComputeSNAGridKokkosHost : public ComputeSNAGridKokkos { + + private: + using Base = ComputeSNAGridKokkos; + + public: + + ComputeSNAGridKokkosHost(class LAMMPS *, int, char **); + + void compute_array() override; + +}; +#endif + +} + +#endif +#endif diff --git a/src/KOKKOS/compute_sna_grid_kokkos_impl.h b/src/KOKKOS/compute_sna_grid_kokkos_impl.h new file mode 100644 index 0000000000..665a1b67e7 --- /dev/null +++ b/src/KOKKOS/compute_sna_grid_kokkos_impl.h @@ -0,0 +1,786 @@ +// clang-format off +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing authors: Christian Trott (SNL), Stan Moore (SNL), + Evan Weinberg (NVIDIA) +------------------------------------------------------------------------- */ + +#include "compute_sna_grid_kokkos.h" +#include "pair_snap_kokkos.h" + +#include "atom_kokkos.h" +#include "atom_masks.h" +#include "comm.h" +#include "error.h" +#include "memory_kokkos.h" +#include "modify.h" +#include "neigh_list.h" +#include "neigh_request.h" +#include "neighbor_kokkos.h" +#include "domain.h" +#include "domain_kokkos.h" +#include "sna.h" +#include "update.h" + +#include +#include +#include + +#include + +#define MAXLINE 1024 +#define MAXWORD 3 + +namespace LAMMPS_NS { + +// Constructor + +template +ComputeSNAGridKokkos::ComputeSNAGridKokkos(LAMMPS *lmp, int narg, char **arg) : ComputeSNAGrid(lmp, narg, arg) +{ + kokkosable = 1; + atomKK = (AtomKokkos *) atom; + domainKK = (DomainKokkos *) domain; + execution_space = ExecutionSpaceFromDevice::space; + datamask_read = EMPTY_MASK; + datamask_modify = EMPTY_MASK; + + k_cutsq = tdual_fparams("ComputeSNAGridKokkos::cutsq",atom->ntypes+1,atom->ntypes+1); + auto d_cutsq = k_cutsq.template view(); + rnd_cutsq = d_cutsq; + + host_flag = (execution_space == Host); + + // TODO: Extract cutsq in double loop below, no need for cutsq_tmp + + cutsq_tmp = cutsq[1][1]; + + for (int i = 1; i <= atom->ntypes; i++) { + for (int j = 1; j <= atom->ntypes; j++){ + k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutsq_tmp; + k_cutsq.template modify(); + } + } + + // Set up element lists + MemKK::realloc_kokkos(d_radelem,"ComputeSNAGridKokkos::radelem",nelements); + MemKK::realloc_kokkos(d_wjelem,"ComputeSNAGridKokkos:wjelem",nelements); + MemKK::realloc_kokkos(d_sinnerelem,"ComputeSNAGridKokkos:sinnerelem",nelements); + MemKK::realloc_kokkos(d_dinnerelem,"ComputeSNAGridKokkos:dinnerelem",nelements); + // test + MemKK::realloc_kokkos(d_test, "ComputeSNAGridKokkos::test", nelements); + + int n = atom->ntypes; + MemKK::realloc_kokkos(d_map,"ComputeSNAGridKokkos::map",n+1); + + auto h_radelem = Kokkos::create_mirror_view(d_radelem); + auto h_wjelem = Kokkos::create_mirror_view(d_wjelem); + auto h_sinnerelem = Kokkos::create_mirror_view(d_sinnerelem); + auto h_dinnerelem = Kokkos::create_mirror_view(d_dinnerelem); + auto h_map = Kokkos::create_mirror_view(d_map); + // test + auto h_test = Kokkos::create_mirror_view(d_test); + h_test(0) = 2.0; + + // start from index 1 because of how compute sna/grid is + for (int i = 1; i <= atom->ntypes; i++) { + h_radelem(i-1) = radelem[i]; + h_wjelem(i-1) = wjelem[i]; + if (switchinnerflag){ + h_sinnerelem(i) = sinnerelem[i]; + h_dinnerelem(i) = dinnerelem[i]; + } + } + + // In pair snap some things like `map` get allocated regardless of chem flag. + if (chemflag){ + for (int i = 1; i <= atom->ntypes; i++) { + h_map(i) = map[i]; + } + } + + Kokkos::deep_copy(d_radelem,h_radelem); + Kokkos::deep_copy(d_wjelem,h_wjelem); + if (switchinnerflag){ + Kokkos::deep_copy(d_sinnerelem,h_sinnerelem); + Kokkos::deep_copy(d_dinnerelem,h_dinnerelem); + } + if (chemflag){ + Kokkos::deep_copy(d_map,h_map); + } + Kokkos::deep_copy(d_test,h_test); + + snaKK = SNAKokkos(*this); + snaKK.grow_rij(0,0); + snaKK.init(); +} + +// Destructor + +template +ComputeSNAGridKokkos::~ComputeSNAGridKokkos() +{ + if (copymode) return; + + memoryKK->destroy_kokkos(k_cutsq,cutsq); + memoryKK->destroy_kokkos(k_gridall, gridall); +} + +// Setup + +template +void ComputeSNAGridKokkos::setup() +{ + // Do not call ComputeGrid::setup(), we don't wanna allocate the grid array there. + // Instead, call ComputeGrid::set_grid_global and set_grid_local to set the n indices. + + ComputeGrid::set_grid_global(); + ComputeGrid::set_grid_local(); + + // allocate arrays + memoryKK->create_kokkos(k_gridall, gridall, size_array_rows, size_array_cols, "grid:gridall"); + + // do not use or allocate gridlocal for now + + gridlocal_allocated = 0; + array = gridall; + + d_gridlocal = k_gridlocal.template view(); + d_gridall = k_gridall.template view(); +} + +// Compute + +template +void ComputeSNAGridKokkos::compute_array() +{ + if (host_flag) { + ComputeSNAGrid::compute_array(); + return; + } + + copymode = 1; + + zlen = nzhi-nzlo+1; + ylen = nyhi-nylo+1; + xlen = nxhi-nxlo+1; + total_range = (nzhi-nzlo+1)*(nyhi-nylo+1)*(nxhi-nxlo+1); + + atomKK->sync(execution_space,X_MASK|F_MASK|TYPE_MASK); + x = atomKK->k_x.view(); + type = atomKK->k_type.view(); + k_cutsq.template sync(); + + // max_neighs is defined here - think of more elaborate methods. + max_neighs = 100; + + // Pair snap/kk uses grow_ij with some max number of neighs but compute sna/grid uses total + // number of atoms. + + ntotal = atomKK->nlocal + atomKK->nghost; + // Allocate view for number of neighbors per grid point + MemKK::realloc_kokkos(d_ninside,"ComputeSNAGridKokkos:ninside",total_range); + + // "chunksize" variable is default 32768 in compute_sna_grid.cpp, and set by user + // `total_range` is the number of grid points which may be larger than chunk size. + chunk_size = MIN(chunksize, total_range); + chunk_offset = 0; + snaKK.grow_rij(chunk_size, max_neighs); + + // Pre-compute ceil(chunk_size / vector_length) for code cleanliness + const int chunk_size_div = (chunk_size + vector_length - 1) / vector_length; + + if (triclinic) { + h0 = domain->h[0]; + h1 = domain->h[1]; + h2 = domain->h[2]; + h3 = domain->h[3]; + h4 = domain->h[4]; + h5 = domain->h[5]; + lo0 = domain->boxlo[0]; + lo1 = domain->boxlo[1]; + lo2 = domain->boxlo[2]; + } + + while (chunk_offset < total_range) { // chunk up loop to prevent running out of memory + + if (chunk_size > total_range - chunk_offset) + chunk_size = total_range - chunk_offset; + + + //ComputeNeigh + { + int scratch_size = scratch_size_helper(team_size_compute_neigh * max_neighs); //ntotal); + + SnapAoSoATeamPolicy + policy_neigh(chunk_size, team_size_compute_neigh, vector_length); + policy_neigh = policy_neigh.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); + Kokkos::parallel_for("ComputeNeigh",policy_neigh,*this); + } + + //ComputeCayleyKlein + { + // tile_size_compute_ck is defined in `compute_sna_grid_kokkos.h` + Snap3DRangePolicy + policy_compute_ck({0,0,0}, {vector_length, max_neighs, chunk_size_div}, {vector_length, tile_size_compute_ck, 1}); + Kokkos::parallel_for("ComputeCayleyKlein", policy_compute_ck, *this); + } + + //PreUi + { + auto policy_pre_ui = snap_get_policy(chunk_size_div, twojmax + 1); + Kokkos::parallel_for("PreUi", policy_pre_ui, *this); + } + + // ComputeUi w/ vector parallelism, shared memory, direct atomicAdd into ulisttot + { + // team_size_compute_ui is defined in `compute_sna_grid_kokkos.h` + // scratch size: 32 atoms * (twojmax+1) cached values, no double buffer + const int tile_size = vector_length * (twojmax + 1); + const int scratch_size = scratch_size_helper(team_size_compute_ui * tile_size); + + if (chunk_size < parallel_thresh) + { + // Version with parallelism over j_bend + + // total number of teams needed: (natoms / 32) * (ntotal) * ("bend" locations) + const int n_teams = chunk_size_div * max_neighs * (twojmax + 1); + const int n_teams_div = (n_teams + team_size_compute_ui - 1) / team_size_compute_ui; + + SnapAoSoATeamPolicy + policy_ui(n_teams_div, team_size_compute_ui, vector_length); + policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); + Kokkos::parallel_for("ComputeUiSmall", policy_ui, *this); + } else { + // Version w/out parallelism over j_bend + + // total number of teams needed: (natoms / 32) * (ntotal) + const int n_teams = chunk_size_div * max_neighs; + const int n_teams_div = (n_teams + team_size_compute_ui - 1) / team_size_compute_ui; + + SnapAoSoATeamPolicy + policy_ui(n_teams_div, team_size_compute_ui, vector_length); + policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); + Kokkos::parallel_for("ComputeUiLarge", policy_ui, *this); + } + } + + //TransformUi: un-"fold" ulisttot, zero ylist + { + // Expand ulisttot_re,_im -> ulisttot + // Zero out ylist + auto policy_transform_ui = snap_get_policy(chunk_size_div, snaKK.idxu_max); + Kokkos::parallel_for("TransformUi", policy_transform_ui, *this); + } + + //Compute bispectrum + // team_size_[compute_zi, compute_bi, transform_bi] are defined in `pair_snap_kokkos.h` + + //ComputeZi and Bi + if (nelements > 1) { + auto policy_compute_zi = snap_get_policy, min_blocks_compute_zi>(chunk_size_div, snaKK.idxz_max); + Kokkos::parallel_for("ComputeZiChemsnap", policy_compute_zi, *this); + + auto policy_compute_bi = snap_get_policy>(chunk_size_div, snaKK.idxb_max); + Kokkos::parallel_for("ComputeBiChemsnap", policy_compute_bi, *this); + } else { + auto policy_compute_zi = snap_get_policy, min_blocks_compute_zi>(chunk_size_div, snaKK.idxz_max); + Kokkos::parallel_for("ComputeZi", policy_compute_zi, *this); + + auto policy_compute_bi = snap_get_policy>(chunk_size_div, snaKK.idxb_max); + Kokkos::parallel_for("ComputeBi", policy_compute_bi, *this); + } + + // Fill the grid array with bispectrum values + { + typename Kokkos::RangePolicy policy_fill(0,chunk_size); + Kokkos::parallel_for(policy_fill, *this); + } + + // Proceed to the next chunk. + chunk_offset += chunk_size; + + } // end while + + copymode = 0; + + k_gridlocal.template modify(); + k_gridlocal.template sync(); + + k_gridall.template modify(); + k_gridall.template sync(); +} + +/* ---------------------------------------------------------------------- + Begin routines that are unique to the GPU codepath. These take advantage + of AoSoA data layouts and scratch memory for recursive polynomials +------------------------------------------------------------------------- */ + +/* + Simple team policy functor seeing how many layers deep we can go with the parallelism. + */ +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeNeigh,const typename Kokkos::TeamPolicy::member_type& team) const { + + // This function follows similar procedure as ComputeNeigh of PairSNAPKokkos. + // Main difference is that we don't use the neighbor class or neighbor variables here. + // This is because the grid points are not atoms and therefore do not get assigned + // neighbors in LAMMPS. + // TODO: If we did make a neighborlist for each grid point, we could use current + // routines and avoid having to loop over all atoms (which limits us to + // natoms = max team size). + + // basic quantities associated with this team: + // team_rank : rank of thread in this team + // league_rank : rank of team in this league + // team_size : number of threads in this team + + // extract loop index + int ii = team.team_rank() + team.league_rank() * team.team_size(); + + if (ii >= chunk_size) return; + + // extract grid index + int igrid = ii + chunk_offset; + + // get a pointer to scratch memory + // This is used to cache whether or not an atom is within the cutoff. + // If it is, type_cache is assigned to the atom type. + // If it's not, it's assigned to -1. + //const int tile_size = ntotal; //max_neighs; // number of elements per thread + //const int team_rank = team.team_rank(); + //const int scratch_shift = team_rank * tile_size; // offset into pointer for entire team + //int* type_cache = (int*)team.team_shmem().get_shmem(team.team_size() * tile_size * sizeof(int), 0) + scratch_shift; + + // convert to grid indices + + int iz = igrid/(xlen*ylen); + int i2 = igrid - (iz*xlen*ylen); + int iy = i2/xlen; + int ix = i2 % xlen; + iz += nzlo; + iy += nylo; + ix += nxlo; + + double xgrid[3]; + + // index ii already captures the proper grid point + //int igrid = iz * (nx * ny) + iy * nx + ix; + + // grid2x converts igrid to ix,iy,iz like we've done before + // multiply grid integers by grid spacing delx, dely, delz + //grid2x(igrid, xgrid); + xgrid[0] = ix * delx; + xgrid[1] = iy * dely; + xgrid[2] = iz * delz; + + if (triclinic) { + + // Do a conversion on `xgrid` here like we do in the CPU version. + + // Can't do this: + // domainKK->lamda2x(xgrid, xgrid); + // Because calling a __host__ function("lamda2x") from a __host__ __device__ function("operator()") is not allowed + + // Using domainKK-> gives segfault, use domain-> instead since we're just accessing floats. + xgrid[0] = h0*xgrid[0] + h5*xgrid[1] + h4*xgrid[2] + lo0; + xgrid[1] = h1*xgrid[1] + h3*xgrid[2] + lo1; + xgrid[2] = h2*xgrid[2] + lo2; + } + + const F_FLOAT xtmp = xgrid[0]; + const F_FLOAT ytmp = xgrid[1]; + const F_FLOAT ztmp = xgrid[2]; + + // currently, all grid points are type 1 + // not clear what a better choice would be + + const int itype = 1; + int ielem = 0; + if (chemflag) ielem = d_map[itype]; + //const double radi = d_radelem[ielem]; + + // Compute the number of neighbors, store rsq + int ninside = 0; + + // Looping over ntotal for now. + for (int j = 0; j < ntotal; j++){ + const F_FLOAT dx = x(j,0) - xtmp; + const F_FLOAT dy = x(j,1) - ytmp; + const F_FLOAT dz = x(j,2) - ztmp; + int jtype = type(j); + const F_FLOAT rsq = dx*dx + dy*dy + dz*dz; + + // don't include atoms that share location with grid point + if (rsq >= rnd_cutsq(itype,jtype) || rsq < 1e-20) { + jtype = -1; // use -1 to signal it's outside the radius + } + + if (jtype >= 0) + ninside++; + } + + d_ninside(ii) = ninside; + + // TODO: Adjust for multi-element, currently we set jelem = 0 regardless of type. + int offset = 0; + for (int j = 0; j < ntotal; j++){ + //const int jtype = type_cache[j]; + //if (jtype >= 0) { + const F_FLOAT dx = x(j,0) - xtmp; + const F_FLOAT dy = x(j,1) - ytmp; + const F_FLOAT dz = x(j,2) - ztmp; + const F_FLOAT rsq = dx*dx + dy*dy + dz*dz; + int jtype = type(j); + if (rsq < rnd_cutsq(itype,jtype) && rsq > 1e-20) { + int jelem = 0; + if (chemflag) jelem = d_map[jtype]; + snaKK.rij(ii,offset,0) = static_cast(dx); + snaKK.rij(ii,offset,1) = static_cast(dy); + snaKK.rij(ii,offset,2) = static_cast(dz); + // pair snap uses jelem here, but we use jtype, see compute_sna_grid.cpp + // actually since the views here have values starting at 0, let's use jelem + snaKK.wj(ii,offset) = static_cast(d_wjelem[jelem]); + snaKK.rcutij(ii,offset) = static_cast((2.0 * d_radelem[jelem])*rcutfac); + snaKK.inside(ii,offset) = j; + if (switchinnerflag) { + snaKK.sinnerij(ii,offset) = 0.5*(d_sinnerelem[ielem] + d_sinnerelem[jelem]); + snaKK.dinnerij(ii,offset) = 0.5*(d_dinnerelem[ielem] + d_dinnerelem[jelem]); + } + if (chemflag) + snaKK.element(ii,offset) = jelem; + else + snaKK.element(ii,offset) = 0; + offset++; + } + } +} + +/* ---------------------------------------------------------------------- + Pre-compute the Cayley-Klein parameters for reuse in later routines +------------------------------------------------------------------------- */ + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeCayleyKlein,const int iatom_mod, const int jnbor, const int iatom_div) const { + + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + + const int ninside = d_ninside(iatom); + if (jnbor >= ninside) return; + + snaKK.compute_cayley_klein(iatom, jnbor); +} + +/* ---------------------------------------------------------------------- + Initialize the "ulisttot" structure with non-zero on-diagonal terms + and zero terms elsewhere +------------------------------------------------------------------------- */ + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridPreUi, const int& iatom_mod, const int& j, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + + int itype = type(iatom); + int ielem = d_map[itype]; + + snaKK.pre_ui(iatom, j, ielem); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridPreUi, const int& iatom, const int& j) const { + if (iatom >= chunk_size) return; + + int itype = type(iatom); + int ielem = d_map[itype]; + + snaKK.pre_ui(iatom, j, ielem); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridPreUi, const int& iatom) const { + if (iatom >= chunk_size) return; + + const int itype = type(iatom); + const int ielem = d_map[itype]; + + for (int j = 0; j <= twojmax; j++) + snaKK.pre_ui(iatom, j, ielem); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeUiSmall,const typename Kokkos::TeamPolicy::member_type& team) const { + + // extract flattened atom_div / neighbor number / bend location + int flattened_idx = team.team_rank() + team.league_rank() * team_size_compute_ui; + + // extract neighbor index, iatom_div + int iatom_div = flattened_idx / (max_neighs * (twojmax + 1)); // removed "const" to work around GCC 7 bug + const int jj_jbend = flattened_idx - iatom_div * (max_neighs * (twojmax + 1)); + const int jbend = jj_jbend / max_neighs; + int jj = jj_jbend - jbend * max_neighs; // removed "const" to work around GCC 7 bug + + Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, vector_length), + [&] (const int iatom_mod) { + const int ii = iatom_mod + vector_length * iatom_div; + if (ii >= chunk_size) return; + + const int ninside = d_ninside(ii); + if (jj >= ninside) return; + + snaKK.compute_ui_small(team, iatom_mod, jbend, jj, iatom_div); + }); + +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeUiLarge,const typename Kokkos::TeamPolicy::member_type& team) const { + + // extract flattened atom_div / neighbor number / bend location + int flattened_idx = team.team_rank() + team.league_rank() * team_size_compute_ui; + + // extract neighbor index, iatom_div + int iatom_div = flattened_idx / max_neighs; // removed "const" to work around GCC 7 bug + int jj = flattened_idx - iatom_div * max_neighs; + + Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, vector_length), + [&] (const int iatom_mod) { + const int ii = iatom_mod + vector_length * iatom_div; + if (ii >= chunk_size) return; + + const int ninside = d_ninside(ii); + if (jj >= ninside) return; + + snaKK.compute_ui_large(team,iatom_mod, jj, iatom_div); + }); +} + +/* ---------------------------------------------------------------------- + De-symmetrize ulisttot_re and _im and pack it into a unified ulisttot + structure. Zero-initialize ylist. CPU and GPU. +------------------------------------------------------------------------- */ + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridTransformUi, const int& iatom_mod, const int& idxu, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + if (idxu >= snaKK.idxu_max) return; + snaKK.transform_ui(iatom, idxu); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridTransformUi, const int& iatom, const int& idxu) const { + if (iatom >= chunk_size) return; + snaKK.transform_ui(iatom, idxu); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridTransformUi, const int& iatom) const { + if (iatom >= chunk_size) return; + for (int idxu = 0; idxu < snaKK.idxu_max; idxu++) + snaKK.transform_ui(iatom, idxu); +} + +/* ---------------------------------------------------------------------- + Compute all elements of the Z tensor and store them into the `zlist` + view +------------------------------------------------------------------------- */ + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeZi, const int& iatom_mod, const int& jjz, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + if (jjz >= snaKK.idxz_max) return; + snaKK.template compute_zi(iatom, jjz); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeZi, const int& iatom, const int& jjz) const { + if (iatom >= chunk_size) return; + snaKK.template compute_zi(iatom, jjz); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeZi, const int& iatom) const { + if (iatom >= chunk_size) return; + for (int jjz = 0; jjz < snaKK.idxz_max; jjz++) + snaKK.template compute_zi(iatom, jjz); +} + +/* ---------------------------------------------------------------------- + Compute the energy triple products and store in the "blist" view +------------------------------------------------------------------------- */ + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeBi, const int& iatom_mod, const int& jjb, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + if (jjb >= snaKK.idxb_max) return; + snaKK.template compute_bi(iatom, jjb); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeBi, const int& iatom, const int& jjb) const { + if (iatom >= chunk_size) return; + snaKK.template compute_bi(iatom, jjb); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridComputeBi, const int& iatom) const { + if (iatom >= chunk_size) return; + for (int jjb = 0; jjb < snaKK.idxb_max; jjb++) + snaKK.template compute_bi(iatom, jjb); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridKokkos::operator() (TagCSNAGridLocalFill, const int& ii) const { + + // extract grid index + int igrid = ii + chunk_offset; + + // convert to grid indices + + int iz = igrid/(xlen*ylen); + int i2 = igrid - (iz*xlen*ylen); + int iy = i2/xlen; + int ix = i2 % xlen; + iz += nzlo; + iy += nylo; + ix += nxlo; + + double xgrid[3]; + + // index ii already captures the proper grid point + // int igrid = iz * (nx * ny) + iy * nx + ix; + // printf("ii igrid: %d %d\n", ii, igrid); + + // grid2x converts igrid to ix,iy,iz like we've done before + //grid2x(igrid, xgrid); + xgrid[0] = ix * delx; + xgrid[1] = iy * dely; + xgrid[2] = iz * delz; + if (triclinic) { + + // Do a conversion on `xgrid` here like we do in the CPU version. + + // Can't do this: + // domainKK->lamda2x(xgrid, xgrid); + // Because calling a __host__ function("lamda2x") from a __host__ __device__ function("operator()") is not allowed + + // Using domainKK-> gives segfault, use domain-> instead since we're just accessing floats. + xgrid[0] = h0*xgrid[0] + h5*xgrid[1] + h4*xgrid[2] + lo0; + xgrid[1] = h1*xgrid[1] + h3*xgrid[2] + lo1; + xgrid[2] = h2*xgrid[2] + lo2; + } + + const F_FLOAT xtmp = xgrid[0]; + const F_FLOAT ytmp = xgrid[1]; + const F_FLOAT ztmp = xgrid[2]; + d_gridall(igrid,0) = xtmp; + d_gridall(igrid,1) = ytmp; + d_gridall(igrid,2) = ztmp; + + const auto idxb_max = snaKK.idxb_max; + + // linear contributions + + for (int icoeff = 0; icoeff < ncoeff; icoeff++) { + const auto idxb = icoeff % idxb_max; + const auto idx_chem = icoeff / idxb_max; + d_gridall(igrid,icoeff+3) = snaKK.blist(ii,idx_chem,idxb); + } + +} + +/* ---------------------------------------------------------------------- + utility functions +------------------------------------------------------------------------- */ + +template +template +void ComputeSNAGridKokkos::check_team_size_for(int inum, int &team_size) { + int team_size_max; + + team_size_max = Kokkos::TeamPolicy(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelForTag()); + + if (team_size*vector_length > team_size_max) + team_size = team_size_max/vector_length; +} + +template +template +void ComputeSNAGridKokkos::check_team_size_reduce(int inum, int &team_size) { + int team_size_max; + + team_size_max = Kokkos::TeamPolicy(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelReduceTag()); + + if (team_size*vector_length > team_size_max) + team_size = team_size_max/vector_length; +} + +template +template +int ComputeSNAGridKokkos::scratch_size_helper(int values_per_team) { + typedef Kokkos::View > ScratchViewType; + + return ScratchViewType::shmem_size(values_per_team); +} + +/* ---------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + routines used by template reference classes +------------------------------------------------------------------------- */ + + +template +ComputeSNAGridKokkosDevice::ComputeSNAGridKokkosDevice(class LAMMPS *lmp, int narg, char **arg) + : ComputeSNAGridKokkos(lmp, narg, arg) { ; } + +template +void ComputeSNAGridKokkosDevice::compute_array() +{ + Base::compute_array(); +} + +#ifdef LMP_KOKKOS_GPU +template +ComputeSNAGridKokkosHost::ComputeSNAGridKokkosHost(class LAMMPS *lmp, int narg, char **arg) + : ComputeSNAGridKokkos(lmp, narg, arg) { ; } + +template +void ComputeSNAGridKokkosHost::compute_array() +{ + Base::compute_array(); +} +#endif + +} diff --git a/src/KOKKOS/compute_sna_grid_local_kokkos.cpp b/src/KOKKOS/compute_sna_grid_local_kokkos.cpp new file mode 100644 index 0000000000..3835a56bf8 --- /dev/null +++ b/src/KOKKOS/compute_sna_grid_local_kokkos.cpp @@ -0,0 +1,25 @@ +// clang-format off +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#include "compute_sna_grid_local_kokkos.h" +#include "compute_sna_grid_local_kokkos_impl.h" + +namespace LAMMPS_NS { + +template class ComputeSNAGridLocalKokkosDevice; +#ifdef LMP_KOKKOS_GPU +template class ComputeSNAGridLocalKokkosHost; +#endif + +} diff --git a/src/KOKKOS/compute_sna_grid_local_kokkos.h b/src/KOKKOS/compute_sna_grid_local_kokkos.h new file mode 100644 index 0000000000..2ffc050b2d --- /dev/null +++ b/src/KOKKOS/compute_sna_grid_local_kokkos.h @@ -0,0 +1,288 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#ifdef COMPUTE_CLASS +// clang-format off +ComputeStyle(sna/grid/local/kk,ComputeSNAGridLocalKokkosDevice); +ComputeStyle(sna/grid/local/kk/device,ComputeSNAGridLocalKokkosDevice); +#ifdef LMP_KOKKOS_GPU +ComputeStyle(sna/grid/local/kk/host,ComputeSNAGridLocalKokkosHost); +#else +ComputeStyle(sna/grid/local/kk/host,ComputeSNAGridLocalKokkosDevice); +#endif +// clang-format on +#else + +// clang-format off +#ifndef LMP_COMPUTE_SNA_GRID_LOCAL_KOKKOS_H +#define LMP_COMPUTE_SNA_GRID_LOCAL_KOKKOS_H + +#include "compute_sna_grid_local.h" +#include "kokkos_type.h" +#include "sna_kokkos.h" + +namespace LAMMPS_NS { + +// Routines for both the CPU and GPU backend + +// GPU backend only +struct TagCSNAGridLocalComputeNeigh{}; +struct TagCSNAGridLocalComputeCayleyKlein{}; +struct TagCSNAGridLocalPreUi{}; +struct TagCSNAGridLocalComputeUiSmall{}; // more parallelism, more divergence +struct TagCSNAGridLocalComputeUiLarge{}; // less parallelism, no divergence +struct TagCSNAGridLocalTransformUi{}; // re-order ulisttot from SoA to AoSoA, zero ylist +template struct TagCSNAGridLocalComputeZi{}; +template struct TagCSNAGridLocalComputeBi{}; +struct TagCSNAGridLocal2Fill{}; // fill the gridlocal array + +struct TagComputeSNAGridLocalLoop{}; +struct TagComputeSNAGridLocal3D{}; + +// CPU backend only +struct TagComputeSNAGridLocalLoopCPU{}; + +//template +template +class ComputeSNAGridLocalKokkos : public ComputeSNAGridLocal { + public: + typedef DeviceType device_type; + typedef ArrayTypes AT; + + static constexpr int vector_length = vector_length_; + using real_type = real_type_; + using complex = SNAComplex; + + // Static team/tile sizes for device offload + +#ifdef KOKKOS_ENABLE_HIP + static constexpr int team_size_compute_neigh = 2; + static constexpr int tile_size_compute_ck = 2; + static constexpr int tile_size_pre_ui = 2; + static constexpr int team_size_compute_ui = 2; + static constexpr int tile_size_transform_ui = 2; + static constexpr int tile_size_compute_zi = 2; + static constexpr int min_blocks_compute_zi = 0; // no minimum bound + static constexpr int tile_size_compute_bi = 2; + static constexpr int tile_size_compute_yi = 2; + static constexpr int min_blocks_compute_yi = 0; // no minimum bound + static constexpr int team_size_compute_fused_deidrj = 2; +#else + static constexpr int team_size_compute_neigh = 4; + static constexpr int tile_size_compute_ck = 4; + static constexpr int tile_size_pre_ui = 4; + static constexpr int team_size_compute_ui = sizeof(real_type) == 4 ? 8 : 4; + static constexpr int tile_size_transform_ui = 4; + static constexpr int tile_size_compute_zi = 8; + static constexpr int tile_size_compute_bi = 4; + static constexpr int tile_size_compute_yi = 8; + static constexpr int team_size_compute_fused_deidrj = sizeof(real_type) == 4 ? 4 : 2; + + // this empirically reduces perf fluctuations from compiler version to compiler version + static constexpr int min_blocks_compute_zi = 4; + static constexpr int min_blocks_compute_yi = 4; +#endif + + // Custom MDRangePolicy, Rank3, to reduce verbosity of kernel launches + // This hides the Kokkos::IndexType and Kokkos::Rank<3...> + // and reduces the verbosity of the LaunchBound by hiding the explicit + // multiplication by vector_length + template + using Snap3DRangePolicy = typename Kokkos::MDRangePolicy, Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Left>, Kokkos::LaunchBounds, TagComputeSNA>; + + // MDRangePolicy for the 3D grid loop: + template + using CSNAGridLocal3DPolicy = typename Kokkos::MDRangePolicy, Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Left>>; + + // Testing out team policies + template + using CSNAGridLocalTeamPolicy = typename Kokkos::TeamPolicy, TagComputeSNA>; + + // Custom SnapAoSoATeamPolicy to reduce the verbosity of kernel launches + // This hides the LaunchBounds abstraction by hiding the explicit + // multiplication by vector length + template + using SnapAoSoATeamPolicy = typename Kokkos::TeamPolicy, TagComputeSNA>; + + // Helper routine that returns a CPU or a GPU policy as appropriate + template + auto snap_get_policy(const int& chunk_size_div, const int& second_loop) { + return Snap3DRangePolicy({0, 0, 0}, + {vector_length, second_loop, chunk_size_div}, + {vector_length, num_tiles, 1}); + } + + ComputeSNAGridLocalKokkos(class LAMMPS *, int, char **); + ~ComputeSNAGridLocalKokkos() override; + + void setup() override; + void compute_local() override; + + // Utility functions for teams + + template + void check_team_size_for(int, int&); + + template + void check_team_size_reduce(int, int&); + + KOKKOS_INLINE_FUNCTION + void operator() (TagComputeSNAGridLocalLoop, const int& ) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagComputeSNAGridLocalLoopCPU, const int&) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeNeigh,const typename Kokkos::TeamPolicy::member_type& team) const; + + // 3D case - used by parallel_for + KOKKOS_INLINE_FUNCTION + void operator()(TagComputeSNAGridLocal3D, const int& iz, const int& iy, const int& ix) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeCayleyKlein, const int iatom_mod, const int jnbor, const int iatom_div) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalPreUi, const int& iatom_mod, const int& j, const int& iatom_div) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalPreUi, const int& iatom, const int& j) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalPreUi, const int& iatom) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeUiSmall,const typename Kokkos::TeamPolicy::member_type& team) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeUiLarge,const typename Kokkos::TeamPolicy::member_type& team) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalTransformUi, const int& iatom_mod, const int& idxu, const int& iatom_div) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalTransformUi, const int& iatom, const int& idxu) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalTransformUi, const int& iatom) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeZi, const int& iatom_mod, const int& idxz, const int& iatom_div) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeZi, const int& iatom, const int& idxz) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeZi, const int& iatom) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeBi, const int& iatom_mod, const int& idxb, const int& iatom_div) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeBi, const int& iatom, const int& idxb) const; + + template KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocalComputeBi, const int& iatom) const; + + KOKKOS_INLINE_FUNCTION + void operator() (TagCSNAGridLocal2Fill,const int& ii) const; + + protected: + + SNAKokkos snaKK; + + int max_neighs, chunk_size, chunk_offset; + int host_flag; + int ntotal; + int total_range; // total number of loop iterations in grid + int zlen; //= nzhi-nzlo+1; + int ylen; //= nyhi-nylo+1; + int xlen; //= nxhi-nxlo+1; + + double cutsq_tmp; // temporary cutsq until we get a view + + Kokkos::View d_radelem; // element radii + Kokkos::View d_wjelem; // elements weights + Kokkos::View d_coeffelem; // element bispectrum coefficients + Kokkos::View d_sinnerelem; // element inner cutoff midpoint + Kokkos::View d_dinnerelem; // element inner cutoff half-width + Kokkos::View d_ninside; // ninside for all atoms in list + Kokkos::View d_map; // mapping from atom types to elements + Kokkos::View d_test; // test view + + typedef Kokkos::DualView tdual_fparams; + tdual_fparams k_cutsq; + typedef Kokkos::View > t_fparams_rnd; + t_fparams_rnd rnd_cutsq; + + typename AT::t_x_array_randomread x; + typename AT::t_int_1d_randomread type; + + DAT::tdual_float_2d k_alocal; + typename AT::t_float_2d d_alocal; + + + // Utility routine which wraps computing per-team scratch size requirements for + // ComputeNeigh, ComputeUi, and ComputeFusedDeidrj + template + int scratch_size_helper(int values_per_team); + + class DomainKokkos *domainKK; + + // triclinic vars + double h0, h1, h2, h3, h4, h5; + double lo0, lo1, lo2; + + // Make SNAKokkos a friend + friend class SNAKokkos; +}; + +// These wrapper classes exist to make the compute style factory happy/avoid having +// to extend the compute style factory to support Compute classes w/an arbitrary number +// of extra template parameters + +template +class ComputeSNAGridLocalKokkosDevice : public ComputeSNAGridLocalKokkos { + + private: + using Base = ComputeSNAGridLocalKokkos; + + public: + + ComputeSNAGridLocalKokkosDevice(class LAMMPS *, int, char **); + + void compute_local() override; + +}; + +#ifdef LMP_KOKKOS_GPU +template +class ComputeSNAGridLocalKokkosHost : public ComputeSNAGridLocalKokkos { + + private: + using Base = ComputeSNAGridLocalKokkos; + + public: + + ComputeSNAGridLocalKokkosHost(class LAMMPS *, int, char **); + + void compute_local() override; + +}; +#endif + +} + +#endif +#endif diff --git a/src/KOKKOS/compute_sna_grid_local_kokkos_impl.h b/src/KOKKOS/compute_sna_grid_local_kokkos_impl.h new file mode 100644 index 0000000000..01bb2b427b --- /dev/null +++ b/src/KOKKOS/compute_sna_grid_local_kokkos_impl.h @@ -0,0 +1,783 @@ +// clang-format off +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing authors: Andrew Rohskopf (SNL) +------------------------------------------------------------------------- */ + +#include "compute_sna_grid_local_kokkos.h" +#include "pair_snap_kokkos.h" + +#include "atom_kokkos.h" +#include "atom_masks.h" +#include "comm.h" +#include "error.h" +#include "memory_kokkos.h" +#include "modify.h" +#include "neigh_list.h" +#include "neigh_request.h" +#include "neighbor_kokkos.h" +#include "domain.h" +#include "domain_kokkos.h" +#include "sna.h" +#include "update.h" + +#include +#include +#include + +#include + +#define MAXLINE 1024 +#define MAXWORD 3 + +namespace LAMMPS_NS { + +// Constructor + +template +ComputeSNAGridLocalKokkos::ComputeSNAGridLocalKokkos(LAMMPS *lmp, int narg, char **arg) : ComputeSNAGridLocal(lmp, narg, arg) +{ + kokkosable = 1; + atomKK = (AtomKokkos *) atom; + domainKK = (DomainKokkos *) domain; + execution_space = ExecutionSpaceFromDevice::space; + datamask_read = EMPTY_MASK; + datamask_modify = EMPTY_MASK; + + k_cutsq = tdual_fparams("ComputeSNAGridLocalKokkos::cutsq",atom->ntypes+1,atom->ntypes+1); + auto d_cutsq = k_cutsq.template view(); + rnd_cutsq = d_cutsq; + + host_flag = (execution_space == Host); + + // TODO: Extract cutsq in double loop below, no need for cutsq_tmp + + cutsq_tmp = cutsq[1][1]; + + for (int i = 1; i <= atom->ntypes; i++) { + for (int j = 1; j <= atom->ntypes; j++){ + k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutsq_tmp; + k_cutsq.template modify(); + } + } + + // Set up element lists + MemKK::realloc_kokkos(d_radelem,"ComputeSNAGridLocalKokkos::radelem",nelements); + MemKK::realloc_kokkos(d_wjelem,"ComputeSNAGridLocalKokkos:wjelem",nelements); + MemKK::realloc_kokkos(d_sinnerelem,"ComputeSNAGridLocalKokkos:sinnerelem",nelements); + MemKK::realloc_kokkos(d_dinnerelem,"ComputeSNAGridLocalKokkos:dinnerelem",nelements); + // test + MemKK::realloc_kokkos(d_test, "ComputeSNAGridLocalKokkos::test", nelements); + + int n = atom->ntypes; + MemKK::realloc_kokkos(d_map,"ComputeSNAGridLocalKokkos::map",n+1); + + auto h_radelem = Kokkos::create_mirror_view(d_radelem); + auto h_wjelem = Kokkos::create_mirror_view(d_wjelem); + auto h_sinnerelem = Kokkos::create_mirror_view(d_sinnerelem); + auto h_dinnerelem = Kokkos::create_mirror_view(d_dinnerelem); + auto h_map = Kokkos::create_mirror_view(d_map); + // test + auto h_test = Kokkos::create_mirror_view(d_test); + h_test(0) = 2.0; + + // start from index 1 because of how compute sna/grid is + for (int i = 1; i <= atom->ntypes; i++) { + h_radelem(i-1) = radelem[i]; + h_wjelem(i-1) = wjelem[i]; + if (switchinnerflag){ + h_sinnerelem(i) = sinnerelem[i]; + h_dinnerelem(i) = dinnerelem[i]; + } + } + + // In pair snap some things like `map` get allocated regardless of chem flag. + if (chemflag){ + for (int i = 1; i <= atom->ntypes; i++) { + h_map(i) = map[i]; + } + } + + Kokkos::deep_copy(d_radelem,h_radelem); + Kokkos::deep_copy(d_wjelem,h_wjelem); + if (switchinnerflag){ + Kokkos::deep_copy(d_sinnerelem,h_sinnerelem); + Kokkos::deep_copy(d_dinnerelem,h_dinnerelem); + } + if (chemflag){ + Kokkos::deep_copy(d_map,h_map); + } + Kokkos::deep_copy(d_test,h_test); + + snaKK = SNAKokkos(*this); + snaKK.grow_rij(0,0); + snaKK.init(); +} + +// Destructor + +template +ComputeSNAGridLocalKokkos::~ComputeSNAGridLocalKokkos() +{ + if (copymode) return; + + memoryKK->destroy_kokkos(k_cutsq,cutsq); + memoryKK->destroy_kokkos(k_alocal,alocal); +} + +// Setup + +template +void ComputeSNAGridLocalKokkos::setup() +{ + + ComputeGridLocal::setup(); + + // allocate arrays + memoryKK->create_kokkos(k_alocal, alocal, size_local_rows, size_local_cols, "grid:alocal"); + array_local = alocal; + d_alocal = k_alocal.template view(); +} + +// Compute + +template +void ComputeSNAGridLocalKokkos::compute_local() +{ + if (host_flag) { + ComputeSNAGridLocal::compute_array(); + return; + } + + copymode = 1; + + zlen = nzhi-nzlo+1; + ylen = nyhi-nylo+1; + xlen = nxhi-nxlo+1; + total_range = (nzhi-nzlo+1)*(nyhi-nylo+1)*(nxhi-nxlo+1); + + atomKK->sync(execution_space,X_MASK|F_MASK|TYPE_MASK); + x = atomKK->k_x.view(); + type = atomKK->k_type.view(); + k_cutsq.template sync(); + + // max_neighs is defined here - think of more elaborate methods. + max_neighs = 100; + + // Pair snap/kk uses grow_ij with some max number of neighs but compute sna/grid uses total + // number of atoms. + + ntotal = atomKK->nlocal + atomKK->nghost; + // Allocate view for number of neighbors per grid point + MemKK::realloc_kokkos(d_ninside,"ComputeSNAGridLocalKokkos:ninside",total_range); + + // "chunksize" variable is default 32768 in compute_sna_grid.cpp, and set by user + // `total_range` is the number of grid points which may be larger than chunk size. + chunk_size = MIN(chunksize, total_range); + chunk_offset = 0; + //snaKK.grow_rij(chunk_size, ntotal); + snaKK.grow_rij(chunk_size, max_neighs); + + //chunk_size = total_range; + + // Pre-compute ceil(chunk_size / vector_length) for code cleanliness + const int chunk_size_div = (chunk_size + vector_length - 1) / vector_length; + + if (triclinic) { + h0 = domain->h[0]; + h1 = domain->h[1]; + h2 = domain->h[2]; + h3 = domain->h[3]; + h4 = domain->h[4]; + h5 = domain->h[5]; + lo0 = domain->boxlo[0]; + lo1 = domain->boxlo[1]; + lo2 = domain->boxlo[2]; + } + + while (chunk_offset < total_range) { // chunk up loop to prevent running out of memory + + if (chunk_size > total_range - chunk_offset) + chunk_size = total_range - chunk_offset; + + + //ComputeNeigh + { + int scratch_size = scratch_size_helper(team_size_compute_neigh * max_neighs); //ntotal); + + SnapAoSoATeamPolicy + policy_neigh(chunk_size, team_size_compute_neigh, vector_length); + policy_neigh = policy_neigh.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); + Kokkos::parallel_for("ComputeNeigh",policy_neigh,*this); + } + + //ComputeCayleyKlein + { + // tile_size_compute_ck is defined in `compute_sna_grid_kokkos.h` + Snap3DRangePolicy + policy_compute_ck({0,0,0}, {vector_length, max_neighs, chunk_size_div}, {vector_length, tile_size_compute_ck, 1}); + Kokkos::parallel_for("ComputeCayleyKlein", policy_compute_ck, *this); + } + + //PreUi + { + auto policy_pre_ui = snap_get_policy(chunk_size_div, twojmax + 1); + Kokkos::parallel_for("PreUi", policy_pre_ui, *this); + } + + // ComputeUi w/ vector parallelism, shared memory, direct atomicAdd into ulisttot + { + // team_size_compute_ui is defined in `compute_sna_grid_kokkos.h` + // scratch size: 32 atoms * (twojmax+1) cached values, no double buffer + const int tile_size = vector_length * (twojmax + 1); + const int scratch_size = scratch_size_helper(team_size_compute_ui * tile_size); + + if (chunk_size < parallel_thresh) + { + // Version with parallelism over j_bend + + // total number of teams needed: (natoms / 32) * (ntotal) * ("bend" locations) + const int n_teams = chunk_size_div * max_neighs * (twojmax + 1); + const int n_teams_div = (n_teams + team_size_compute_ui - 1) / team_size_compute_ui; + + SnapAoSoATeamPolicy + policy_ui(n_teams_div, team_size_compute_ui, vector_length); + policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); + Kokkos::parallel_for("ComputeUiSmall", policy_ui, *this); + } else { + // Version w/out parallelism over j_bend + + // total number of teams needed: (natoms / 32) * (ntotal) + const int n_teams = chunk_size_div * max_neighs; + const int n_teams_div = (n_teams + team_size_compute_ui - 1) / team_size_compute_ui; + + SnapAoSoATeamPolicy + policy_ui(n_teams_div, team_size_compute_ui, vector_length); + policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); + Kokkos::parallel_for("ComputeUiLarge", policy_ui, *this); + } + } + + //TransformUi: un-"fold" ulisttot, zero ylist + { + // Expand ulisttot_re,_im -> ulisttot + // Zero out ylist + auto policy_transform_ui = snap_get_policy(chunk_size_div, snaKK.idxu_max); + Kokkos::parallel_for("TransformUi", policy_transform_ui, *this); + } + + //Compute bispectrum + // team_size_[compute_zi, compute_bi, transform_bi] are defined in `pair_snap_kokkos.h` + + //ComputeZi and Bi + if (nelements > 1) { + auto policy_compute_zi = snap_get_policy, min_blocks_compute_zi>(chunk_size_div, snaKK.idxz_max); + Kokkos::parallel_for("ComputeZiChemsnap", policy_compute_zi, *this); + + auto policy_compute_bi = snap_get_policy>(chunk_size_div, snaKK.idxb_max); + Kokkos::parallel_for("ComputeBiChemsnap", policy_compute_bi, *this); + } else { + auto policy_compute_zi = snap_get_policy, min_blocks_compute_zi>(chunk_size_div, snaKK.idxz_max); + Kokkos::parallel_for("ComputeZi", policy_compute_zi, *this); + + auto policy_compute_bi = snap_get_policy>(chunk_size_div, snaKK.idxb_max); + Kokkos::parallel_for("ComputeBi", policy_compute_bi, *this); + } + + // Fill the grid array with bispectrum values + { + typename Kokkos::RangePolicy policy_fill(0,chunk_size); + Kokkos::parallel_for(policy_fill, *this); + } + + // Proceed to the next chunk. + chunk_offset += chunk_size; + + } // end while + + copymode = 0; + + k_alocal.template modify(); + k_alocal.template sync(); +} + +/* ---------------------------------------------------------------------- + Begin routines that are unique to the GPU codepath. These take advantage + of AoSoA data layouts and scratch memory for recursive polynomials +------------------------------------------------------------------------- */ + +/* + Simple team policy functor seeing how many layers deep we can go with the parallelism. + */ +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeNeigh,const typename Kokkos::TeamPolicy::member_type& team) const { + + // This function follows similar procedure as ComputeNeigh of PairSNAPKokkos. + // Main difference is that we don't use the neighbor class or neighbor variables here. + // This is because the grid points are not atoms and therefore do not get assigned + // neighbors in LAMMPS. + // TODO: If we did make a neighborlist for each grid point, we could use current + // routines and avoid having to loop over all atoms (which limits us to + // natoms = max team size). + + // basic quantities associated with this team: + // team_rank : rank of thread in this team + // league_rank : rank of team in this league + // team_size : number of threads in this team + + // extract loop index + int ii = team.team_rank() + team.league_rank() * team.team_size(); + + if (ii >= chunk_size) return; + + // extract grid index + int igrid = ii + chunk_offset; + + // get a pointer to scratch memory + // This is used to cache whether or not an atom is within the cutoff. + // If it is, type_cache is assigned to the atom type. + // If it's not, it's assigned to -1. + //const int tile_size = ntotal; //max_neighs; // number of elements per thread + //const int team_rank = team.team_rank(); + //const int scratch_shift = team_rank * tile_size; // offset into pointer for entire team + //int* type_cache = (int*)team.team_shmem().get_shmem(team.team_size() * tile_size * sizeof(int), 0) + scratch_shift; + + // convert to grid indices + + int iz = igrid/(xlen*ylen); + int i2 = igrid - (iz*xlen*ylen); + int iy = i2/xlen; + int ix = i2 % xlen; + iz += nzlo; + iy += nylo; + ix += nxlo; + + double xgrid[3]; + + // index ii already captures the proper grid point + //int igrid = iz * (nx * ny) + iy * nx + ix; + + // grid2x converts igrid to ix,iy,iz like we've done before + // multiply grid integers by grid spacing delx, dely, delz + //grid2x(igrid, xgrid); + xgrid[0] = ix * delx; + xgrid[1] = iy * dely; + xgrid[2] = iz * delz; + + if (triclinic) { + + // Do a conversion on `xgrid` here like we do in the CPU version. + + // Can't do this: + // domainKK->lamda2x(xgrid, xgrid); + // Because calling a __host__ function("lamda2x") from a __host__ __device__ function("operator()") is not allowed + + // Using domainKK-> gives segfault, use domain-> instead since we're just accessing floats. + xgrid[0] = h0*xgrid[0] + h5*xgrid[1] + h4*xgrid[2] + lo0; + xgrid[1] = h1*xgrid[1] + h3*xgrid[2] + lo1; + xgrid[2] = h2*xgrid[2] + lo2; + } + + const F_FLOAT xtmp = xgrid[0]; + const F_FLOAT ytmp = xgrid[1]; + const F_FLOAT ztmp = xgrid[2]; + + // Zeroing out the components, which are filled as a sum. + for (int icol = size_local_cols_base; icol < size_local_cols; icol++){ + d_alocal(igrid, icol) = 0.0; + } + + // Fill grid info columns + d_alocal(igrid, 0) = ix; + d_alocal(igrid, 1) = iy; + d_alocal(igrid, 2) = iz; + d_alocal(igrid, 3) = xtmp; + d_alocal(igrid, 4) = ytmp; + d_alocal(igrid, 5) = ztmp; + + // currently, all grid points are type 1 + // not clear what a better choice would be + + const int itype = 1; + int ielem = 0; + if (chemflag) ielem = d_map[itype]; + //const double radi = d_radelem[ielem]; + + // Compute the number of neighbors, store rsq + int ninside = 0; + + // Looping over ntotal for now. + for (int j = 0; j < ntotal; j++){ + const F_FLOAT dx = x(j,0) - xtmp; + const F_FLOAT dy = x(j,1) - ytmp; + const F_FLOAT dz = x(j,2) - ztmp; + int jtype = type(j); + const F_FLOAT rsq = dx*dx + dy*dy + dz*dz; + + // don't include atoms that share location with grid point + if (rsq >= rnd_cutsq(itype,jtype) || rsq < 1e-20) { + jtype = -1; // use -1 to signal it's outside the radius + } + + if (jtype >= 0) + ninside++; + } + + d_ninside(ii) = ninside; + + // TODO: Adjust for multi-element, currently we set jelem = 0 regardless of type. + int offset = 0; + for (int j = 0; j < ntotal; j++){ + //const int jtype = type_cache[j]; + //if (jtype >= 0) { + const F_FLOAT dx = x(j,0) - xtmp; + const F_FLOAT dy = x(j,1) - ytmp; + const F_FLOAT dz = x(j,2) - ztmp; + const F_FLOAT rsq = dx*dx + dy*dy + dz*dz; + int jtype = type(j); + if (rsq < rnd_cutsq(itype,jtype) && rsq > 1e-20) { + int jelem = 0; + if (chemflag) jelem = d_map[jtype]; + snaKK.rij(ii,offset,0) = static_cast(dx); + snaKK.rij(ii,offset,1) = static_cast(dy); + snaKK.rij(ii,offset,2) = static_cast(dz); + // pair snap uses jelem here, but we use jtype, see compute_sna_grid.cpp + // actually since the views here have values starting at 0, let's use jelem + snaKK.wj(ii,offset) = static_cast(d_wjelem[jelem]); + snaKK.rcutij(ii,offset) = static_cast((2.0 * d_radelem[jelem])*rcutfac); + snaKK.inside(ii,offset) = j; + if (switchinnerflag) { + snaKK.sinnerij(ii,offset) = 0.5*(d_sinnerelem[ielem] + d_sinnerelem[jelem]); + snaKK.dinnerij(ii,offset) = 0.5*(d_dinnerelem[ielem] + d_dinnerelem[jelem]); + } + if (chemflag) + snaKK.element(ii,offset) = jelem; + else + snaKK.element(ii,offset) = 0; + offset++; + } + } +} + +/* ---------------------------------------------------------------------- + Pre-compute the Cayley-Klein parameters for reuse in later routines +------------------------------------------------------------------------- */ + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeCayleyKlein,const int iatom_mod, const int jnbor, const int iatom_div) const { + + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + + const int ninside = d_ninside(iatom); + if (jnbor >= ninside) return; + + snaKK.compute_cayley_klein(iatom, jnbor); +} + +/* ---------------------------------------------------------------------- + Initialize the "ulisttot" structure with non-zero on-diagonal terms + and zero terms elsewhere +------------------------------------------------------------------------- */ + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalPreUi, const int& iatom_mod, const int& j, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + + int itype = type(iatom); + int ielem = d_map[itype]; + + snaKK.pre_ui(iatom, j, ielem); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalPreUi, const int& iatom, const int& j) const { + if (iatom >= chunk_size) return; + + int itype = type(iatom); + int ielem = d_map[itype]; + + snaKK.pre_ui(iatom, j, ielem); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalPreUi, const int& iatom) const { + if (iatom >= chunk_size) return; + + const int itype = type(iatom); + const int ielem = d_map[itype]; + + for (int j = 0; j <= twojmax; j++) + snaKK.pre_ui(iatom, j, ielem); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeUiSmall,const typename Kokkos::TeamPolicy::member_type& team) const { + + // extract flattened atom_div / neighbor number / bend location + int flattened_idx = team.team_rank() + team.league_rank() * team_size_compute_ui; + + // extract neighbor index, iatom_div + int iatom_div = flattened_idx / (max_neighs * (twojmax + 1)); // removed "const" to work around GCC 7 bug + const int jj_jbend = flattened_idx - iatom_div * (max_neighs * (twojmax + 1)); + const int jbend = jj_jbend / max_neighs; + int jj = jj_jbend - jbend * max_neighs; // removed "const" to work around GCC 7 bug + + Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, vector_length), + [&] (const int iatom_mod) { + const int ii = iatom_mod + vector_length * iatom_div; + if (ii >= chunk_size) return; + + const int ninside = d_ninside(ii); + if (jj >= ninside) return; + + snaKK.compute_ui_small(team, iatom_mod, jbend, jj, iatom_div); + }); + +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeUiLarge,const typename Kokkos::TeamPolicy::member_type& team) const { + + // extract flattened atom_div / neighbor number / bend location + int flattened_idx = team.team_rank() + team.league_rank() * team_size_compute_ui; + + // extract neighbor index, iatom_div + int iatom_div = flattened_idx / max_neighs; // removed "const" to work around GCC 7 bug + int jj = flattened_idx - iatom_div * max_neighs; + + Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, vector_length), + [&] (const int iatom_mod) { + const int ii = iatom_mod + vector_length * iatom_div; + if (ii >= chunk_size) return; + + const int ninside = d_ninside(ii); + if (jj >= ninside) return; + + snaKK.compute_ui_large(team,iatom_mod, jj, iatom_div); + }); +} + +/* ---------------------------------------------------------------------- + De-symmetrize ulisttot_re and _im and pack it into a unified ulisttot + structure. Zero-initialize ylist. CPU and GPU. +------------------------------------------------------------------------- */ + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalTransformUi, const int& iatom_mod, const int& idxu, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + if (idxu >= snaKK.idxu_max) return; + snaKK.transform_ui(iatom, idxu); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalTransformUi, const int& iatom, const int& idxu) const { + if (iatom >= chunk_size) return; + snaKK.transform_ui(iatom, idxu); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalTransformUi, const int& iatom) const { + if (iatom >= chunk_size) return; + for (int idxu = 0; idxu < snaKK.idxu_max; idxu++) + snaKK.transform_ui(iatom, idxu); +} + +/* ---------------------------------------------------------------------- + Compute all elements of the Z tensor and store them into the `zlist` + view +------------------------------------------------------------------------- */ + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeZi, const int& iatom_mod, const int& jjz, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + if (jjz >= snaKK.idxz_max) return; + snaKK.template compute_zi(iatom, jjz); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeZi, const int& iatom, const int& jjz) const { + if (iatom >= chunk_size) return; + snaKK.template compute_zi(iatom, jjz); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeZi, const int& iatom) const { + if (iatom >= chunk_size) return; + for (int jjz = 0; jjz < snaKK.idxz_max; jjz++) + snaKK.template compute_zi(iatom, jjz); +} + +/* ---------------------------------------------------------------------- + Compute the energy triple products and store in the "blist" view +------------------------------------------------------------------------- */ + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeBi, const int& iatom_mod, const int& jjb, const int& iatom_div) const { + const int iatom = iatom_mod + iatom_div * vector_length; + if (iatom >= chunk_size) return; + if (jjb >= snaKK.idxb_max) return; + snaKK.template compute_bi(iatom, jjb); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeBi, const int& iatom, const int& jjb) const { + if (iatom >= chunk_size) return; + snaKK.template compute_bi(iatom, jjb); +} + +template +template KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocalComputeBi, const int& iatom) const { + if (iatom >= chunk_size) return; + for (int jjb = 0; jjb < snaKK.idxb_max; jjb++) + snaKK.template compute_bi(iatom, jjb); +} + +template +KOKKOS_INLINE_FUNCTION +void ComputeSNAGridLocalKokkos::operator() (TagCSNAGridLocal2Fill, const int& ii) const { + + // extract grid index + int igrid = ii + chunk_offset; + + // convert to grid indices + + int iz = igrid/(xlen*ylen); + int i2 = igrid - (iz*xlen*ylen); + int iy = i2/xlen; + int ix = i2 % xlen; + iz += nzlo; + iy += nylo; + ix += nxlo; + + double xgrid[3]; + + // index ii already captures the proper grid point + // int igrid = iz * (nx * ny) + iy * nx + ix; + // printf("ii igrid: %d %d\n", ii, igrid); + + // grid2x converts igrid to ix,iy,iz like we've done before + //grid2x(igrid, xgrid); + xgrid[0] = ix * delx; + xgrid[1] = iy * dely; + xgrid[2] = iz * delz; + if (triclinic) { + + // Do a conversion on `xgrid` here like we do in the CPU version. + + // Can't do this: + // domainKK->lamda2x(xgrid, xgrid); + // Because calling a __host__ function("lamda2x") from a __host__ __device__ function("operator()") is not allowed + + // Using domainKK-> gives segfault, use domain-> instead since we're just accessing floats. + xgrid[0] = h0*xgrid[0] + h5*xgrid[1] + h4*xgrid[2] + lo0; + xgrid[1] = h1*xgrid[1] + h3*xgrid[2] + lo1; + xgrid[2] = h2*xgrid[2] + lo2; + } + + + const auto idxb_max = snaKK.idxb_max; + + // linear contributions + + for (int icoeff = 0; icoeff < ncoeff; icoeff++) { + const auto idxb = icoeff % idxb_max; + const auto idx_chem = icoeff / idxb_max; + d_alocal(igrid,icoeff+6) = snaKK.blist(ii,idx_chem,idxb); + } + +} + +/* ---------------------------------------------------------------------- + utility functions +------------------------------------------------------------------------- */ + +template +template +void ComputeSNAGridLocalKokkos::check_team_size_for(int inum, int &team_size) { + int team_size_max; + + team_size_max = Kokkos::TeamPolicy(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelForTag()); + + if (team_size*vector_length > team_size_max) + team_size = team_size_max/vector_length; +} + +template +template +void ComputeSNAGridLocalKokkos::check_team_size_reduce(int inum, int &team_size) { + int team_size_max; + + team_size_max = Kokkos::TeamPolicy(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelReduceTag()); + + if (team_size*vector_length > team_size_max) + team_size = team_size_max/vector_length; +} + +template +template +int ComputeSNAGridLocalKokkos::scratch_size_helper(int values_per_team) { + typedef Kokkos::View > ScratchViewType; + + return ScratchViewType::shmem_size(values_per_team); +} + +/* ---------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + routines used by template reference classes +------------------------------------------------------------------------- */ + + +template +ComputeSNAGridLocalKokkosDevice::ComputeSNAGridLocalKokkosDevice(class LAMMPS *lmp, int narg, char **arg) + : ComputeSNAGridLocalKokkos(lmp, narg, arg) { ; } + +template +void ComputeSNAGridLocalKokkosDevice::compute_local() +{ + Base::compute_local(); +} + +#ifdef LMP_KOKKOS_GPU +template +ComputeSNAGridLocalKokkosHost::ComputeSNAGridLocalKokkosHost(class LAMMPS *lmp, int narg, char **arg) + : ComputeSNAGridLocalKokkos(lmp, narg, arg) { ; } + +template +void ComputeSNAGridLocalKokkosHost::compute_local() +{ + Base::compute_local(); +} +#endif + +} diff --git a/src/KOKKOS/fix_acks2_reaxff_kokkos.cpp b/src/KOKKOS/fix_acks2_reaxff_kokkos.cpp index bfcb66e525..5f82b778c1 100644 --- a/src/KOKKOS/fix_acks2_reaxff_kokkos.cpp +++ b/src/KOKKOS/fix_acks2_reaxff_kokkos.cpp @@ -225,7 +225,8 @@ void FixACKS2ReaxFFKokkos::pre_force(int /*vflag*/) allocate_array(); - if (!allocated_flag || last_allocate < neighbor->lastcall) { + if (!allocated_flag || last_allocate < neighbor->lastcall + || nlocal_last_allocate != nlocal) { // get max number of neighbor @@ -281,6 +282,7 @@ void FixACKS2ReaxFFKokkos::pre_force(int /*vflag*/) prev_last_rows_rank = last_rows_rank; last_allocate = update->ntimestep; + nlocal_last_allocate = nlocal; } // compute_H @@ -430,8 +432,6 @@ void FixACKS2ReaxFFKokkos::num_neigh_item(int ii, bigint &totneigh) template void FixACKS2ReaxFFKokkos::allocate_matrix() { - nmax = atom->nmax; - // determine the total space for the H matrix m_cap_big = 0; @@ -456,15 +456,15 @@ void FixACKS2ReaxFFKokkos::allocate_matrix() // H matrix - d_firstnbr = typename AT::t_bigint_1d("acks2/kk:firstnbr",nmax); - d_numnbrs = typename AT::t_int_1d("acks2/kk:numnbrs",nmax); + d_firstnbr = typename AT::t_bigint_1d("acks2/kk:firstnbr",nlocal); + d_numnbrs = typename AT::t_int_1d("acks2/kk:numnbrs",nlocal); d_jlist = typename AT::t_int_1d("acks2/kk:jlist",m_cap_big); d_val = typename AT::t_ffloat_1d("acks2/kk:val",m_cap_big); // X matrix - d_firstnbr_X = typename AT::t_bigint_1d("acks2/kk:firstnbr_X",nmax); - d_numnbrs_X = typename AT::t_int_1d("acks2/kk:numnbrs_X",nmax); + d_firstnbr_X = typename AT::t_bigint_1d("acks2/kk:firstnbr_X",nlocal); + d_numnbrs_X = typename AT::t_int_1d("acks2/kk:numnbrs_X",nlocal); d_jlist_X = typename AT::t_int_1d("acks2/kk:jlist_X",m_cap_big); d_val_X = typename AT::t_ffloat_1d("acks2/kk:val_X",m_cap_big); } diff --git a/src/KOKKOS/fix_acks2_reaxff_kokkos.h b/src/KOKKOS/fix_acks2_reaxff_kokkos.h index 6adca39d17..d3e4dff53c 100644 --- a/src/KOKKOS/fix_acks2_reaxff_kokkos.h +++ b/src/KOKKOS/fix_acks2_reaxff_kokkos.h @@ -243,7 +243,7 @@ class FixACKS2ReaxFFKokkos : public FixACKS2ReaxFF, public KokkosBase { void calculate_Q() override; int neighflag; - int nlocal,nall,nmax,newton_pair; + int nlocal,nlocal_last_allocate,nall,nmax,newton_pair; int count, isuccess; double alpha, beta, omega, cutsq; diff --git a/src/KOKKOS/fix_qeq_reaxff_kokkos.cpp b/src/KOKKOS/fix_qeq_reaxff_kokkos.cpp index 7ef4505b06..100a7ca322 100644 --- a/src/KOKKOS/fix_qeq_reaxff_kokkos.cpp +++ b/src/KOKKOS/fix_qeq_reaxff_kokkos.cpp @@ -215,9 +215,11 @@ void FixQEqReaxFFKokkos::pre_force(int /*vflag*/) // get max number of neighbor - if (!allocated_flag || last_allocate < neighbor->lastcall) { + if (!allocated_flag || last_allocate < neighbor->lastcall + || nlocal_last_allocate != nlocal) { allocate_matrix(); last_allocate = update->ntimestep; + nlocal_last_allocate = nlocal; } // compute_H @@ -313,8 +315,6 @@ void FixQEqReaxFFKokkos::num_neigh_item(int ii, bigint &totneigh) co template void FixQEqReaxFFKokkos::allocate_matrix() { - nmax = atom->nmax; - // determine the total space for the H matrix m_cap_big = 0; @@ -332,8 +332,8 @@ void FixQEqReaxFFKokkos::allocate_matrix() d_jlist = typename AT::t_int_1d(); d_val = typename AT::t_ffloat_1d(); - d_firstnbr = typename AT::t_bigint_1d("qeq/kk:firstnbr",nmax); - d_numnbrs = typename AT::t_int_1d("qeq/kk:numnbrs",nmax); + d_firstnbr = typename AT::t_bigint_1d("qeq/kk:firstnbr",nlocal); + d_numnbrs = typename AT::t_int_1d("qeq/kk:numnbrs",nlocal); d_jlist = typename AT::t_int_1d("qeq/kk:jlist",m_cap_big); d_val = typename AT::t_ffloat_1d("qeq/kk:val",m_cap_big); } diff --git a/src/KOKKOS/fix_qeq_reaxff_kokkos.h b/src/KOKKOS/fix_qeq_reaxff_kokkos.h index 0733a518a2..b9c3a66302 100644 --- a/src/KOKKOS/fix_qeq_reaxff_kokkos.h +++ b/src/KOKKOS/fix_qeq_reaxff_kokkos.h @@ -273,7 +273,7 @@ class FixQEqReaxFFKokkos : public FixQEqReaxFF, public KokkosBase { void calculate_q(); int neighflag, pack_flag; - int nlocal,nall,nmax,newton_pair; + int nlocal,nlocal_last_allocate,nall,nmax,newton_pair; int count, isuccess; F_FLOAT alpha[2]; F_FLOAT beta[2]; diff --git a/src/KOKKOS/kokkos_type.h b/src/KOKKOS/kokkos_type.h index bfd9bba8aa..ae86e17b50 100644 --- a/src/KOKKOS/kokkos_type.h +++ b/src/KOKKOS/kokkos_type.h @@ -792,6 +792,14 @@ typedef tdual_float_3d::t_dev_um t_float_3d_um; typedef tdual_float_3d::t_dev_const_um t_float_3d_const_um; typedef tdual_float_3d::t_dev_const_randomread t_float_3d_randomread; +//4d float array n +typedef Kokkos::DualView tdual_float_4d; +typedef tdual_float_4d::t_dev t_float_4d; +typedef tdual_float_4d::t_dev_const t_float_4d_const; +typedef tdual_float_4d::t_dev_um t_float_4d_um; +typedef tdual_float_4d::t_dev_const_um t_float_4d_const_um; +typedef tdual_float_4d::t_dev_const_randomread t_float_4d_randomread; + #ifdef LMP_KOKKOS_NO_LEGACY typedef Kokkos::DualView tdual_float_1d_4; #else @@ -1126,6 +1134,14 @@ typedef tdual_float_3d::t_host_um t_float_3d_um; typedef tdual_float_3d::t_host_const_um t_float_3d_const_um; typedef tdual_float_3d::t_host_const_randomread t_float_3d_randomread; +//4d float array n +typedef Kokkos::DualView tdual_float_4d; +typedef tdual_float_4d::t_host t_float_4d; +typedef tdual_float_4d::t_host_const t_float_4d_const; +typedef tdual_float_4d::t_host_um t_float_4d_um; +typedef tdual_float_4d::t_host_const_um t_float_4d_const_um; +typedef tdual_float_4d::t_host_const_randomread t_float_4d_randomread; + #ifdef LMP_KOKKOS_NO_LEGACY typedef Kokkos::DualView tdual_float_1d_4; #else diff --git a/src/KOKKOS/memory_kokkos.h b/src/KOKKOS/memory_kokkos.h index c194cc173f..a94d9eb1e6 100644 --- a/src/KOKKOS/memory_kokkos.h +++ b/src/KOKKOS/memory_kokkos.h @@ -101,6 +101,7 @@ template { data = TYPE(std::string(name),n1,n2); h_data = Kokkos::create_mirror_view(data); + //printf(">>> name: %s\n", name); return data; } @@ -111,6 +112,7 @@ TYPE create_kokkos(TYPE &data, typename TYPE::value_type **&array, data = TYPE(std::string(name),n1,n2); bigint nbytes = ((bigint) sizeof(typename TYPE::value_type *)) * n1; array = (typename TYPE::value_type **) smalloc(nbytes,name); + //printf(">>> name %s nbytes %d\n", name, nbytes); for (int i = 0; i < n1; i++) { if (n2 == 0) @@ -121,6 +123,56 @@ TYPE create_kokkos(TYPE &data, typename TYPE::value_type **&array, return data; } +/* ---------------------------------------------------------------------- + create a 4d array with indices 2,3,4 offset, but not first + 2nd index from n2lo to n2hi inclusive + 3rd index from n3lo to n3hi inclusive + 4th index from n4lo to n4hi inclusive + cannot grow it +------------------------------------------------------------------------- */ + +template +TYPE create4d_offset_kokkos(TYPE &data, typename TYPE::value_type ****&array, + int n1, int n2lo, int n2hi, int n3lo, int n3hi, int n4lo, int n4hi, + const char *name) +{ + //if (n1 <= 0 || n2lo > n2hi || n3lo > n3hi || n4lo > n4hi) array = nullptr; + + printf("^^^^^ memoryKK->create_4d_offset_kokkos\n"); + + int n2 = n2hi - n2lo + 1; + int n3 = n3hi - n3lo + 1; + int n4 = n4hi - n4lo + 1; + data = TYPE(std::string(name),n1,n2,n3,n4); + bigint nbytes = ((bigint) sizeof(typename TYPE::value_type ***)) * n1; + array = (typename TYPE::value_type ****) smalloc(nbytes,name); + + for (int i = 0; i < n1; i++) { + if (n2 == 0) { + array[i] = nullptr; + } else { + nbytes = ((bigint) sizeof(typename TYPE::value_type **)) * n2; + array[i] = (typename TYPE::value_type ***) smalloc(nbytes,name); + for (int j = 0; j < n2; j++){ + if (n3 == 0){ + array[i][j] = nullptr; + } else { + nbytes = ((bigint) sizeof(typename TYPE::value_type *)) * n3; + array[i][j] = (typename TYPE::value_type **) smalloc(nbytes, name); + for (int k = 0; k < n3; k++){ + if (n4 == 0) + array[i][j][k] = nullptr; + else + array[i][j][k] = &data.h_view(i,j,k,0); + } + } + } + } + } + + return data; +} + template TYPE create_kokkos(TYPE &data, HTYPE &h_data, typename TYPE::value_type **&array, int n1, int n2, diff --git a/src/KOKKOS/min_kokkos.cpp b/src/KOKKOS/min_kokkos.cpp index 3460fe9009..fca7a16e62 100644 --- a/src/KOKKOS/min_kokkos.cpp +++ b/src/KOKKOS/min_kokkos.cpp @@ -73,10 +73,10 @@ void MinKokkos::init() void MinKokkos::setup(int flag) { if (comm->me == 0 && screen) { - fmt::print(screen,"Setting up {} style minimization ...\n", update->minimize_style); + utils::print(screen,"Setting up {} style minimization ...\n", update->minimize_style); if (flag) { - fmt::print(screen," Unit style : {}\n", update->unit_style); - fmt::print(screen," Current step : {}\n", update->ntimestep); + utils::print(screen," Unit style : {}\n", update->unit_style); + utils::print(screen," Current step : {}\n", update->ntimestep); timer->print_timeout(screen); } } diff --git a/src/KOKKOS/pair_mliap_kokkos.cpp b/src/KOKKOS/pair_mliap_kokkos.cpp index 3c5bb7d910..599c49f523 100644 --- a/src/KOKKOS/pair_mliap_kokkos.cpp +++ b/src/KOKKOS/pair_mliap_kokkos.cpp @@ -240,6 +240,7 @@ void PairMLIAPKokkos::coeff(int narg, char **arg) { if (strcmp(elemname,descriptor->elements[jelem]) == 0) break; + //printf(">>> nelements: %d\n", descriptor->nelements); if (jelem < descriptor->nelements) map[i] = jelem; else if (strcmp(elemname,"NULL") == 0) map[i] = -1; diff --git a/src/KOKKOS/pair_snap_kokkos.h b/src/KOKKOS/pair_snap_kokkos.h index 660503eed8..27c30b0603 100644 --- a/src/KOKKOS/pair_snap_kokkos.h +++ b/src/KOKKOS/pair_snap_kokkos.h @@ -174,12 +174,6 @@ class PairSNAPKokkos : public PairSNAP { void compute(int, int) override; double memory_usage() override; - template - void check_team_size_for(int, int&); - - template - void check_team_size_reduce(int, int&); - // CPU and GPU backend template KOKKOS_INLINE_FUNCTION @@ -375,7 +369,6 @@ class PairSNAPKokkos : public PairSNAP { // Make SNAKokkos a friend friend class SNAKokkos; - }; diff --git a/src/KOKKOS/pair_snap_kokkos_impl.h b/src/KOKKOS/pair_snap_kokkos_impl.h index 2b9b862645..03daa14e01 100644 --- a/src/KOKKOS/pair_snap_kokkos_impl.h +++ b/src/KOKKOS/pair_snap_kokkos_impl.h @@ -3,12 +3,10 @@ LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories LAMMPS development team: developers@lammps.org - Copyright (2003) Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software. This software is distributed under the GNU General Public License. - See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ @@ -39,17 +37,6 @@ namespace LAMMPS_NS { -// Outstanding issues with quadratic term -// 1. there seems to a problem with compute_optimized energy calc -// it does not match compute_regular, even when quadratic coeffs = 0 - -//static double t1 = 0.0; -//static double t2 = 0.0; -//static double t3 = 0.0; -//static double t4 = 0.0; -//static double t5 = 0.0; -//static double t6 = 0.0; -//static double t7 = 0.0; /* ---------------------------------------------------------------------- */ template @@ -177,10 +164,6 @@ void PairSNAPKokkos::compute(int eflag_in, max_neighs = 0; Kokkos::parallel_reduce("PairSNAPKokkos::find_max_neighs",inum, FindMaxNumNeighs(k_list), Kokkos::Max(max_neighs)); - int team_size_default = 1; - if constexpr (!host_flag) - team_size_default = 32;//max_neighs; - if (beta_max < inum) { beta_max = inum; // padded allocation, similar to within grow_rij @@ -211,15 +194,15 @@ void PairSNAPKokkos::compute(int eflag_in, // ComputeNeigh if constexpr (host_flag) { - int team_size = team_size_default; - check_team_size_for(chunk_size,team_size); + int team_size = 1; typename Kokkos::TeamPolicy policy_neigh(chunk_size,team_size,vector_length); Kokkos::parallel_for("ComputeNeighCPU",policy_neigh,*this); } else { // team_size_compute_neigh is defined in `pair_snap_kokkos.h` int scratch_size = scratch_size_helper(team_size_compute_neigh * max_neighs); - SnapAoSoATeamPolicy policy_neigh(chunk_size,team_size_compute_neigh,vector_length); + SnapAoSoATeamPolicy + policy_neigh(chunk_size,team_size_compute_neigh,vector_length); policy_neigh = policy_neigh.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); Kokkos::parallel_for("ComputeNeigh",policy_neigh,*this); } @@ -259,7 +242,8 @@ void PairSNAPKokkos::compute(int eflag_in, const int n_teams = chunk_size_div * max_neighs * (twojmax + 1); const int n_teams_div = (n_teams + team_size_compute_ui - 1) / team_size_compute_ui; - SnapAoSoATeamPolicy policy_ui(n_teams_div, team_size_compute_ui, vector_length); + SnapAoSoATeamPolicy + policy_ui(n_teams_div, team_size_compute_ui, vector_length); policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); Kokkos::parallel_for("ComputeUiSmall",policy_ui,*this); } else { @@ -269,7 +253,8 @@ void PairSNAPKokkos::compute(int eflag_in, const int n_teams = chunk_size_div * max_neighs; const int n_teams_div = (n_teams + team_size_compute_ui - 1) / team_size_compute_ui; - SnapAoSoATeamPolicy policy_ui(n_teams_div, team_size_compute_ui, vector_length); + SnapAoSoATeamPolicy + policy_ui(n_teams_div, team_size_compute_ui, vector_length); policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam(scratch_size)); Kokkos::parallel_for("ComputeUiLarge",policy_ui,*this); } @@ -536,8 +521,7 @@ void PairSNAPKokkos::coeff(int narg, char Kokkos::deep_copy(d_dinnerelem,h_dinnerelem); Kokkos::deep_copy(d_map,h_map); - snaKK = SNAKokkos(*this); //rfac0,twojmax, - //rmin0,switchflag,bzeroflag,chemflag,bnormflag,wselfallflag,nelements,switchinnerflag); + snaKK = SNAKokkos(*this); snaKK.grow_rij(0,0); snaKK.init(); } @@ -1359,30 +1343,6 @@ double PairSNAPKokkos::memory_usage() return bytes; } -/* ---------------------------------------------------------------------- */ - -template -template -void PairSNAPKokkos::check_team_size_for(int inum, int &team_size) { - int team_size_max; - - team_size_max = Kokkos::TeamPolicy(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelForTag()); - - if (team_size*vector_length > team_size_max) - team_size = team_size_max/vector_length; -} - -template -template -void PairSNAPKokkos::check_team_size_reduce(int inum, int &team_size) { - int team_size_max; - - team_size_max = Kokkos::TeamPolicy(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelReduceTag()); - - if (team_size*vector_length > team_size_max) - team_size = team_size_max/vector_length; -} - template template int PairSNAPKokkos::scratch_size_helper(int values_per_team) { diff --git a/src/KOKKOS/rand_pool_wrap_kokkos.h b/src/KOKKOS/rand_pool_wrap_kokkos.h index 60e9776039..da30b350e6 100644 --- a/src/KOKKOS/rand_pool_wrap_kokkos.h +++ b/src/KOKKOS/rand_pool_wrap_kokkos.h @@ -56,10 +56,10 @@ class RandPoolWrap : protected Pointers { RandWrap rand_wrap; +#ifndef LMP_KOKKOS_GPU typedef Kokkos::Experimental::UniqueToken< LMPHostType, Kokkos::Experimental::UniqueTokenScope::Global> unique_token_type; -#ifndef LMP_KOKKOS_GPU unique_token_type unique_token; int tid = (int) unique_token.acquire(); rand_wrap.rng = random_thr[tid]; diff --git a/src/KOKKOS/sna_kokkos.h b/src/KOKKOS/sna_kokkos.h index a438ccd25e..61aebaf97d 100644 --- a/src/KOKKOS/sna_kokkos.h +++ b/src/KOKKOS/sna_kokkos.h @@ -29,7 +29,9 @@ #endif namespace LAMMPS_NS { - +// copied from pair_snap_kokkos.h +// pre-declare so sna_kokkos.h can refer to it +template class PairSNAPKokkos; template struct WignerWrapper { using real_type = real_type_; @@ -170,9 +172,9 @@ class SNAKokkos { KOKKOS_INLINE_FUNCTION SNAKokkos(const SNAKokkos& sna, const typename Kokkos::TeamPolicy::member_type& team); + template inline - //SNAKokkos(real_type, int, real_type, int, int, int, int, int, int, int); - SNAKokkos(const PairSNAPKokkos&); + SNAKokkos(const CopyClass&); KOKKOS_INLINE_FUNCTION ~SNAKokkos(); diff --git a/src/KOKKOS/sna_kokkos_impl.h b/src/KOKKOS/sna_kokkos_impl.h index 9a97f229b5..36da303499 100644 --- a/src/KOKKOS/sna_kokkos_impl.h +++ b/src/KOKKOS/sna_kokkos_impl.h @@ -29,17 +29,18 @@ static const double MY_PI = 3.14159265358979323846; // pi static const double MY_PI2 = 1.57079632679489661923; // pi/2 template +template inline -SNAKokkos::SNAKokkos(const PairSNAPKokkos& psk) - : rfac0(psk.rfac0), rmin0(psk.rmin0), switch_flag(psk.switchflag), - bzero_flag(psk.bzeroflag), chem_flag(psk.chemflag), bnorm_flag(psk.bnormflag), - wselfall_flag(psk.wselfallflag), switch_inner_flag(psk.switchinnerflag), - quadratic_flag(psk.quadraticflag), twojmax(psk.twojmax), d_coeffelem(psk.d_coeffelem) +SNAKokkos::SNAKokkos(const CopyClass& copy) + : twojmax(copy.twojmax), d_coeffelem(copy.d_coeffelem), rmin0(copy.rmin0), + rfac0(copy.rfac0), switch_flag(copy.switchflag), switch_inner_flag(copy.switchinnerflag), + chem_flag(copy.chemflag), bnorm_flag(copy.bnormflag), wselfall_flag(copy.wselfallflag), + quadratic_flag(copy.quadraticflag), bzero_flag(copy.bzeroflag) { wself = static_cast(1.0); if (chem_flag) - nelements = psk.nelements; + nelements = copy.nelements; else nelements = 1; @@ -611,7 +612,6 @@ void SNAKokkos::evaluate_ui_jbend(const Wi } ulist_wrapper.set(ma, ulist_accum); - mb++; } @@ -830,7 +830,6 @@ typename SNAKokkos::complex SNAKokkos::compute_bi(const int& iato if constexpr (chemsnap) { int itriple = 0; - int idouble = 0; for (int elem1 = 0; elem1 < nelements; elem1++) { for (int elem2 = 0; elem2 < nelements; elem2++) { for (int elem3 = 0; elem3 < nelements; elem3++) { blist(iatom, itriple, jjb) = evaluate_bi(j, jjz, jju, iatom, elem1, elem2, elem3); itriple++; } // end loop over elem3 - idouble++; } // end loop over elem2 } // end loop over elem1 } else { diff --git a/src/KOKKOS/verlet_kokkos.cpp b/src/KOKKOS/verlet_kokkos.cpp index d839362aa5..a492b5a9c9 100644 --- a/src/KOKKOS/verlet_kokkos.cpp +++ b/src/KOKKOS/verlet_kokkos.cpp @@ -77,7 +77,7 @@ void VerletKokkos::setup(int flag) if (comm->me == 0 && screen) { fputs("Setting up Verlet run ...\n",screen); if (flag) { - fmt::print(screen," Unit style : {}\n" + utils::print(screen," Unit style : {}\n" " Current step : {}\n" " Time step : {}\n", update->unit_style,update->ntimestep,update->dt); diff --git a/src/KSPACE/pair_lj_long_coul_long.cpp b/src/KSPACE/pair_lj_long_coul_long.cpp index 5f3c0327db..2955b24fe8 100644 --- a/src/KSPACE/pair_lj_long_coul_long.cpp +++ b/src/KSPACE/pair_lj_long_coul_long.cpp @@ -410,7 +410,7 @@ void PairLJLongCoulLong::read_restart_settings(FILE *fp) void PairLJLongCoulLong::write_data(FILE *fp) { for (int i = 1; i <= atom->ntypes; i++) - fmt::print(fp,"{} {} {}\n",i,epsilon_read[i][i],sigma_read[i][i]); + utils::print(fp,"{} {} {}\n",i,epsilon_read[i][i],sigma_read[i][i]); } /* ---------------------------------------------------------------------- @@ -423,10 +423,10 @@ void PairLJLongCoulLong::write_data_all(FILE *fp) for (int i = 1; i <= atom->ntypes; i++) { for (int j = i; j <= atom->ntypes; j++) { if (ewald_order & (1<<6)) { - fmt::print(fp,"{} {} {} {}\n",i,j, + utils::print(fp,"{} {} {} {}\n",i,j, epsilon[i][j],sigma[i][j]); } else { - fmt::print(fp,"{} {} {} {} {}\n",i,j, + utils::print(fp,"{} {} {} {} {}\n",i,j, epsilon[i][j],sigma[i][j],cut_lj[i][j]); } } diff --git a/src/LATBOLTZ/fix_lb_fluid.cpp b/src/LATBOLTZ/fix_lb_fluid.cpp index 773f60cf0e..286b56cab5 100644 --- a/src/LATBOLTZ/fix_lb_fluid.cpp +++ b/src/LATBOLTZ/fix_lb_fluid.cpp @@ -2364,7 +2364,7 @@ void FixLbFluid::dump(const bigint step) bigint offset = frameindex * block * (1 + 3); double time = dump_time_index ? update->ntimestep * dt_lb : frameindex; - fmt::print(dump_file_handle_xdmf, + utils::print(dump_file_handle_xdmf, " \n" " \n\n"); + utils::print(dump_file_handle_xdmf, " \n\n"); frameindex++; } @@ -3726,18 +3726,18 @@ void FixLbFluid::initializeGeometry() if (!outfile) error->one(FLERR, " file {} could not be opened: {}", datfile, utils::getsyserror()); - fmt::print(outfile, "\n me: {} px: {} py: {} pz: {}\n", me, comm->myloc[0], comm->myloc[1], + utils::print(outfile, "\n me: {} px: {} py: {} pz: {}\n", me, comm->myloc[0], comm->myloc[1], comm->myloc[2]); for (i = 0; i < subNbx; i++) { - fmt::print(outfile, "i={}\n", i); + utils::print(outfile, "i={}\n", i); for (k = subNbz - 1; k > -1; k--) { if (k == subNbz - 2 || k == 0) { for (j = 0; j < subNby + 2; j++) fputs("---", outfile); fputs("\n", outfile); } for (j = 0; j < subNby; j++) { - fmt::print(outfile, " {} ", sublattice[i][j][k].type); + utils::print(outfile, " {} ", sublattice[i][j][k].type); if (j == 0 || j == subNby - 2) fputs(" | ", outfile); if (j == subNby - 1) fputs("\n", outfile); } @@ -3754,16 +3754,16 @@ void FixLbFluid::initializeGeometry() if (!outfile) error->one(FLERR, " file {} could not be opened: {}", datfile, utils::getsyserror()); - fmt::print("\nme: {}\n", me); + utils::print("\nme: {}\n", me); for (i = 0; i < subNbx; i++) { - fmt::print("i={}\n", i); + utils::print("i={}\n", i); for (k = subNbz - 1; k > -1; k--) { if (k == subNbz - 2 || k == 0) { for (j = 0; j < subNby + 2; j++) fputs("---", outfile); fputs("\bn", outfile); } for (j = 0; j < subNby; j++) { - fmt::print(outfile, " {} ", sublattice[i][j][k].orientation); + utils::print(outfile, " {} ", sublattice[i][j][k].orientation); if (j == 0 || j == subNby - 2) fputs(" | ", outfile); if (j == subNby - 1) fputs("\n", outfile); } diff --git a/src/MANYBODY/fix_qeq_comb.cpp b/src/MANYBODY/fix_qeq_comb.cpp index 6edd2fbbb0..88c6fb4be4 100644 --- a/src/MANYBODY/fix_qeq_comb.cpp +++ b/src/MANYBODY/fix_qeq_comb.cpp @@ -203,7 +203,7 @@ void FixQEQComb::post_force(int /*vflag*/) // charge-equilibration loop if (me == 0 && fp) - fmt::print(fp,"Charge equilibration on step {}\n", update->ntimestep); + utils::print(fp,"Charge equilibration on step {}\n", update->ntimestep); heatpq = 0.05; qmass = 0.016; @@ -268,7 +268,7 @@ void FixQEQComb::post_force(int /*vflag*/) if (enegchk <= precision && enegmax <= 100.0*precision) break; if (me == 0 && fp) - fmt::print(fp," iteration: {}, enegtot {:.6g}, " + utils::print(fp," iteration: {}, enegtot {:.6g}, " "enegmax {:.6g}, fq deviation: {:.6g}\n", iloop,enegtot,enegmax,enegchk); @@ -281,9 +281,9 @@ void FixQEQComb::post_force(int /*vflag*/) if (me == 0 && fp) { if (iloop == loopmax) - fmt::print(fp,"Charges did not converge in {} iterations\n",iloop); + utils::print(fp,"Charges did not converge in {} iterations\n",iloop); else - fmt::print(fp,"Charges converged in {} iterations to {:.10f} tolerance\n", + utils::print(fp,"Charges converged in {} iterations to {:.10f} tolerance\n", iloop,enegchk); } } diff --git a/src/MANYBODY/pair_comb3.cpp b/src/MANYBODY/pair_comb3.cpp index b4228dbb4f..3a02ed73b1 100644 --- a/src/MANYBODY/pair_comb3.cpp +++ b/src/MANYBODY/pair_comb3.cpp @@ -164,7 +164,7 @@ void PairComb3::settings(int narg, char **arg) else error->all(FLERR,"Illegal pair_style command"); if (comm->me == 0 && screen) - fmt::print(screen," PairComb3: polarization is {} \n", + utils::print(screen," PairComb3: polarization is {} \n", pol_flag ? "on" : "off"); } diff --git a/src/MISC/fix_imd.cpp b/src/MISC/fix_imd.cpp index 04adcabd34..13a451cf6c 100644 --- a/src/MISC/fix_imd.cpp +++ b/src/MISC/fix_imd.cpp @@ -768,8 +768,7 @@ void FixIMD::setup(int) { if (imd_version == 2) { setup_v2(); - } - else { + } else { setup_v3(); } } @@ -914,11 +913,9 @@ void FixIMD::setup_v3() struct commdata *buf = nullptr; if (imdsinfo->coords) { buf = static_cast(coord_data); - } - else if (imdsinfo->velocities) { + } else if (imdsinfo->velocities) { buf = static_cast(vel_data); - } - else if (imdsinfo->forces) { + } else if (imdsinfo->forces) { buf = static_cast(force_data); } @@ -1025,8 +1022,7 @@ void FixIMD::post_force(int /*vflag*/) fflush(screen); if (imd_version == 2) { handle_step_v2(); - } - else if (imd_version == 3) { + } else if (imd_version == 3) { handle_client_input_v3(); } @@ -1493,8 +1489,7 @@ void FixIMD::handle_client_input_v3() { /* Change IMD waiting behavior mid-session */ if (length) { nowait_flag = 0; - } - else { + } else { nowait_flag = 1; } break; @@ -1626,7 +1621,7 @@ void FixIMD::handle_output_v3() { } } - int ntotal, nmax, nme=0; + int ntotal, nme=0; for (int i=0; i < nlocal; ++i) if (mask[i] & groupbit) ++nme; @@ -1654,7 +1649,7 @@ void FixIMD::handle_output_v3() { if (imdsinfo->coords) { commdata *recvcoord = nullptr; memory->destroy(coord_data); - coord_data = memory->smalloc(nme*size_one, "imd:coord_data"); + coord_data = memory->smalloc((bigint)nme * size_one, "imd:coord_data"); buf = static_cast(coord_data); int idx = 0; if (imdsinfo->unwrap) { @@ -1672,21 +1667,19 @@ void FixIMD::handle_output_v3() { if (domain->triclinic) { buf[idx].tag = tag[i]; - buf[idx].x = x[i][0]; + ix * xprd + iy * xy + iz * xz; - buf[idx].y = x[i][1]; + iy * yprd + iz * yz; - buf[idx].z = x[i][2]; + iz * zprd; - } - else { + buf[idx].x = x[i][0] + ix * xprd + iy * xy + iz * xz; + buf[idx].y = x[i][1] + iy * yprd + iz * yz; + buf[idx].z = x[i][2] + iz * zprd; + } else { buf[idx].tag = tag[i]; - buf[idx].x = x[i][0]; + ix * xprd; - buf[idx].y = x[i][1]; + iy * yprd; - buf[idx].z = x[i][2]; + iz * zprd; + buf[idx].x = x[i][0] + ix * xprd; + buf[idx].y = x[i][1] + iy * yprd; + buf[idx].z = x[i][2] + iz * zprd; } ++idx; } } - } - else { + } else { for (int i = 0; i < nlocal; ++i) { if (mask[i] & groupbit) { buf[idx].tag = tag[i]; @@ -1720,7 +1713,7 @@ void FixIMD::handle_output_v3() { if (imdsinfo->velocities) { commdata *recvvel = nullptr; memory->destroy(vel_data); - vel_data = memory->smalloc(nme*size_one, "imd:vel_data"); + vel_data = memory->smalloc((bigint)nme * size_one, "imd:vel_data"); buf = static_cast(vel_data); int idx = 0; for (int i = 0; i < nlocal; ++i) { @@ -1755,7 +1748,7 @@ void FixIMD::handle_output_v3() { if (imdsinfo->forces) { commdata *recvforce = nullptr; memory->destroy(force_data); - force_data = memory->smalloc(nme*size_one, "imd:force_data"); + force_data = memory->smalloc((bigint)nme * size_one, "imd:force_data"); buf = static_cast(force_data); int idx = 0; for (int i = 0; i < nlocal; ++i) { @@ -2057,10 +2050,11 @@ static int32 imd_readn(void *s, char *ptr, int32 n) { nleft = n; while (nleft > 0) { if ((nread = imdsock_read(s, ptr, nleft)) < 0) { - if (errno == EINTR) + if (errno == EINTR) { nread = 0; /* and call read() again */ - else + } else { return -1; + } } else if (nread == 0) break; /* EOF */ nleft -= nread; @@ -2078,10 +2072,11 @@ static int32 imd_writen(void *s, const char *ptr, int32 n) { nleft = n; while (nleft > 0) { if ((nwritten = imdsock_write(s, ptr, nleft)) <= 0) { - if (errno == EINTR) + if (errno == EINTR) { nwritten = 0; - else + } else { return -1; + } } nleft -= nwritten; ptr += nwritten; diff --git a/src/MISC/pair_srp.cpp b/src/MISC/pair_srp.cpp index 8decae5aca..1fe19bc30c 100644 --- a/src/MISC/pair_srp.cpp +++ b/src/MISC/pair_srp.cpp @@ -397,10 +397,11 @@ void PairSRP::coeff(int narg, char **arg) error->all(FLERR,"PairSRP: Incorrect args for pair coeff"); if (!allocated) allocate(); - if (btype_str.size() > 0) + if (btype_str.size() > 0) { btype = utils::expand_type_int(FLERR, btype_str, Atom::BOND, lmp); - if ((btype > atom->nbondtypes) || (btype <= 0)) - error->all(FLERR,"Invalid bond type {} for pair style srp", btype); + if ((btype > atom->nbondtypes) || (btype <= 0)) + error->all(FLERR,"Invalid bond type {} for pair style srp", btype); + } if (bptype_str.size() > 0) bptype = utils::expand_type_int(FLERR, bptype_str, Atom::ATOM, lmp); diff --git a/src/ML-POD/fitpod_command.cpp b/src/ML-POD/fitpod_command.cpp index fbe9ecd396..ea8e5e22d3 100644 --- a/src/ML-POD/fitpod_command.cpp +++ b/src/ML-POD/fitpod_command.cpp @@ -163,15 +163,15 @@ void FitPOD::command(int narg, char **arg) n2 = fastpodptr->nComponents * fastpodptr->nClusters * fastpodptr->nelements; } - fmt::print(fp, "model_coefficients: {} {} {}\n", nCoeffAll, n1, n2); + utils::print(fp, "model_coefficients: {} {} {}\n", nCoeffAll, n1, n2); for (int count = 0; count < nCoeffAll; count++) { - fmt::print(fp, "{:<10.{}f}\n", desc.c[count], traindata.precision); + utils::print(fp, "{:<10.{}f}\n", desc.c[count], traindata.precision); } for (int count = 0; count < n1; count++) { - fmt::print(fp, "{:<10.{}f}\n", fastpodptr->Proj[count], 14); + utils::print(fp, "{:<10.{}f}\n", fastpodptr->Proj[count], 14); } for (int count = 0; count < n2; count++) { - fmt::print(fp, "{:<10.{}f}\n", fastpodptr->Centroids[count], 14); + utils::print(fp, "{:<10.{}f}\n", fastpodptr->Centroids[count], 14); } fclose(fp); } @@ -1751,7 +1751,7 @@ void FitPOD::print_analysis(const datastruct &data, double *outarray, double *er data.training ? "Training" : "Test"); utils::logmesg(lmp, mystr); - fmt::print(fp_errors, mystr); + utils::print(fp_errors, mystr); std::string sa(lm + 80, '-'); sa += '\n'; @@ -1759,12 +1759,12 @@ void FitPOD::print_analysis(const datastruct &data, double *outarray, double *er " {:^{}} | # configs | # atoms | MAE energy | RMSE energy | MAE force | RMSE force\n", "File", lm); utils::logmesg(lmp, sa + sb + sa); - fmt::print(fp_errors, sa + sb + sa); + utils::print(fp_errors, sa + sb + sa); int ci = 0, m = 8, nc = 0, nf = 0; for (int file = 0; file < nfiles; file++) { - fmt::print(fp_analysis, "# {}\n", data.filenames[file]); - fmt::print(fp_analysis, + utils::print(fp_analysis, "# {}\n", data.filenames[file]); + utils::print(fp_analysis, " config # atoms volume energy DFT energy energy error " " force DFT force force error\n"); @@ -1772,14 +1772,14 @@ void FitPOD::print_analysis(const datastruct &data, double *outarray, double *er int nconfigs = data.num_config[file]; nc += nconfigs; for (int ii = 0; ii < nconfigs; ii++) { // loop over each configuration in a file - fmt::print(fp_analysis, "{:6} {:8} ", outarray[m * ci], outarray[1 + m * ci]); + utils::print(fp_analysis, "{:6} {:8} ", outarray[m * ci], outarray[1 + m * ci]); double vol = latticevolume(&data.lattice[9 * ci]); - fmt::print(fp_analysis, "{:<15.10} ", vol); + utils::print(fp_analysis, "{:<15.10} ", vol); for (int count = 2; count < m; count++) - fmt::print(fp_analysis, "{:<15.10} ", outarray[count + m * ci]); - fmt::print(fp_analysis, "\n"); + utils::print(fp_analysis, "{:<15.10} ", outarray[count + m * ci]); + utils::print(fp_analysis, "\n"); nforceall += 3 * data.num_atom[ci]; ci += 1; @@ -1792,23 +1792,23 @@ void FitPOD::print_analysis(const datastruct &data, double *outarray, double *er data.filenames[file], lm, nconfigs, nforceall / 3, errors[0 + 4 * q], errors[1 + 4 * q], errors[2 + 4 * q], errors[3 + 4 * q]); utils::logmesg(lmp, s); - fmt::print(fp_errors, s); + utils::print(fp_errors, s); } utils::logmesg(lmp, sa); - fmt::print(fp_errors, sa); + utils::print(fp_errors, sa); auto s = fmt::format("{:<{}} {:>10} {:>11} {:<10.6f} {:<10.6f} {:<10.6f} {:<10.6f}\n", "All files", lm, nc, nf / 3, errors[0], errors[1], errors[2], errors[3]); utils::logmesg(lmp, s + sa); - fmt::print(fp_errors, "{}", s + sa); + utils::print(fp_errors, "{}", s + sa); mystr = fmt::format("**************** End of Error Analysis for the {} Data Set ****************\n", data.training ? "Training" : "Test"); utils::logmesg(lmp, mystr); - fmt::print(fp_errors, mystr); + utils::print(fp_errors, mystr); fclose(fp_errors); fclose(fp_analysis); @@ -2254,14 +2254,14 @@ void FitPOD::savedata2textfile(std::string filename, std::string text, double *A int precision = 15; FILE *fp = fopen(filename.c_str(), "w"); if (dim == 1) { - fmt::print(fp, text, n); - for (int i = 0; i < n; i++) fmt::print(fp, "{:<10.{}f} \n", A[i], precision); + utils::print(fp, text, n); + for (int i = 0; i < n; i++) utils::print(fp, "{:<10.{}f} \n", A[i], precision); } else if (dim == 2) { - fmt::print(fp, text, n); - fmt::print(fp, "{} \n", m); + utils::print(fp, text, n); + utils::print(fp, "{} \n", m); for (int j = 0; j < n; j++) { - for (int i = 0; i < m; i++) fmt::print(fp, "{:<10.{}f} ", A[j + i * n], precision); - fmt::print(fp, " \n"); + for (int i = 0; i < m; i++) utils::print(fp, "{:<10.{}f} ", A[j + i * n], precision); + utils::print(fp, " \n"); } } fclose(fp); diff --git a/src/ML-SNAP/compute_gaussian_grid_local.cpp b/src/ML-SNAP/compute_gaussian_grid_local.cpp new file mode 100644 index 0000000000..8a747a7908 --- /dev/null +++ b/src/ML-SNAP/compute_gaussian_grid_local.cpp @@ -0,0 +1,166 @@ +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/ Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#include "compute_gaussian_grid_local.h" + +#include "atom.h" +#include "comm.h" +#include "error.h" +#include "force.h" +#include "math_const.h" +#include "math_special.h" +#include "memory.h" +#include "modify.h" +#include "update.h" + +#include +#include + +using namespace LAMMPS_NS; +using MathConst::MY_2PI; +using MathSpecial::powint; + +ComputeGaussianGridLocal::ComputeGaussianGridLocal(LAMMPS *lmp, int narg, char **arg) : + ComputeGridLocal(lmp, narg, arg), cutsq(nullptr), radelem(nullptr), + sigmaelem(nullptr), prefacelem(nullptr), argfacelem(nullptr) +{ + // skip over arguments used by base class + // so that argument positions are identical to + // regular per-atom compute + + arg += nargbase; + narg -= nargbase; + + //double rfac0, rmin0; + //int twojmax, switchflag, bzeroflag, bnormflag, wselfallflag; + + int ntypes = atom->ntypes; + int nargmin = 4 + 2 * ntypes; + + if (narg < nargmin) error->all(FLERR, "Illegal compute {} command", style); + + // process required arguments + + memory->create(radelem, ntypes + 1, "gaussian/atom:radelem"); // offset by 1 to match up with types + memory->create(sigmaelem, ntypes + 1, "gaussian/atom:sigmaelem"); + memory->create(prefacelem, ntypes + 1, "gaussian/atom:prefacelem"); + memory->create(argfacelem, ntypes + 1, "gaussian/atom:argfacelem"); + + rcutfac = utils::numeric(FLERR, arg[3], false, lmp); + + for (int i = 0; i < ntypes; i++) radelem[i + 1] = utils::numeric(FLERR, arg[4 + i], false, lmp); + for (int i = 0; i < ntypes; i++) + sigmaelem[i + 1] = utils::numeric(FLERR, arg[ntypes + 4 + i], false, lmp); + + // construct cutsq + double cut; + cutmax = 0.0; + memory->create(cutsq, ntypes + 1, ntypes + 1, "gaussian/atom:cutsq"); + for (int i = 1; i <= ntypes; i++) { + cut = 2.0 * radelem[i] * rcutfac; + if (cut > cutmax) cutmax = cut; + cutsq[i][i] = cut * cut; + for (int j = i + 1; j <= ntypes; j++) { + cut = (radelem[i] + radelem[j]) * rcutfac; + cutsq[i][j] = cutsq[j][i] = cut * cut; + } + } + + size_local_cols = size_local_cols_base + ntypes; + + // pre-compute coefficients + for (int i = 0; i < ntypes; i++) { + prefacelem[i + 1] = 1.0/powint(sigmaelem[i + 1] * sqrt(MY_2PI), 3); + argfacelem[i + 1] = 1.0/(2.0 * sigmaelem[i + 1] * sigmaelem[i + 1]); + } +} + +/* ---------------------------------------------------------------------- */ + +ComputeGaussianGridLocal::~ComputeGaussianGridLocal() +{ + if (copymode) return; + memory->destroy(radelem); + memory->destroy(sigmaelem); + memory->destroy(prefacelem); + memory->destroy(argfacelem); + memory->destroy(cutsq); +} + +/* ---------------------------------------------------------------------- */ + +void ComputeGaussianGridLocal::init() +{ + if ((modify->get_compute_by_style("^gaussian/grid/local$").size() > 1) && (comm->me == 0)) + error->warning(FLERR, "More than one instance of compute gaussian/grid/local"); +} + +/* ---------------------------------------------------------------------- */ + +void ComputeGaussianGridLocal::compute_local() +{ + invoked_local = update->ntimestep; + + // compute gaussian for each gridpoint + + double **const x = atom->x; + const int *const mask = atom->mask; + int *const type = atom->type; + const int ntotal = atom->nlocal + atom->nghost; + + int igrid = 0; + for (int iz = nzlo; iz <= nzhi; iz++) + for (int iy = nylo; iy <= nyhi; iy++) + for (int ix = nxlo; ix <= nxhi; ix++) { + double xgrid[3]; + grid2x(ix, iy, iz, xgrid); + const double xtmp = xgrid[0]; + const double ytmp = xgrid[1]; + const double ztmp = xgrid[2]; + + // Zeroing out the components, which are filled as a sum. + for (int icol = size_local_cols_base; icol < size_local_cols; icol++){ + alocal[igrid][icol] = 0.0; + } + + for (int j = 0; j < ntotal; j++) { + + // check that j is in compute group + + if (!(mask[j] & groupbit)) continue; + + const double delx = xtmp - x[j][0]; + const double dely = ytmp - x[j][1]; + const double delz = ztmp - x[j][2]; + const double rsq = delx * delx + dely * dely + delz * delz; + int jtype = type[j]; + if (rsq < cutsq[jtype][jtype]) { + int icol = size_local_cols_base + jtype - 1; + alocal[igrid][icol] += prefacelem[jtype] * exp(-rsq * argfacelem[jtype]); + } + } + igrid++; + } +} + +/* ---------------------------------------------------------------------- + memory usage +------------------------------------------------------------------------- */ + +double ComputeGaussianGridLocal::memory_usage() +{ + int n = atom->ntypes + 1; + int nbytes = (double) n * sizeof(int); // map + + return nbytes; +} diff --git a/src/ML-SNAP/compute_gaussian_grid_local.h b/src/ML-SNAP/compute_gaussian_grid_local.h new file mode 100644 index 0000000000..77f88a7a8e --- /dev/null +++ b/src/ML-SNAP/compute_gaussian_grid_local.h @@ -0,0 +1,51 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/ Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +#ifdef COMPUTE_CLASS +// clang-format off +ComputeStyle(gaussian/grid/local,ComputeGaussianGridLocal); +// clang-format on +#else + +#ifndef LMP_COMPUTE_GAUSSIAN_GRID_LOCAL_H +#define LMP_COMPUTE_GAUSSIAN_GRID_LOCAL_H + +#include "compute_grid_local.h" + +namespace LAMMPS_NS { + +class ComputeGaussianGridLocal : public ComputeGridLocal { + public: + ComputeGaussianGridLocal(class LAMMPS *, int, char **); + ~ComputeGaussianGridLocal() override; + void init() override; + void compute_local() override; + double memory_usage() override; + + protected: + int ncoeff; + double **cutsq; + double rcutfac; // global cut-off scale + double *radelem; // cut-off radius of each atom type + double *sigmaelem; // Gaussian width of each atom type + double *prefacelem; // Gaussian prefactor of each atom type + double *argfacelem; // Gaussian argument factor of each atom type + int *map; // map types to [0,nelements) + int nelements; + double cutmax; +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/ML-SNAP/compute_grid.cpp b/src/ML-SNAP/compute_grid.cpp index 2179bb8ebd..12135c705d 100644 --- a/src/ML-SNAP/compute_grid.cpp +++ b/src/ML-SNAP/compute_grid.cpp @@ -57,6 +57,7 @@ ComputeGrid::ComputeGrid(LAMMPS *lmp, int narg, char **arg) : ComputeGrid::~ComputeGrid() { + if (copymode) return; deallocate(); } @@ -111,7 +112,6 @@ void ComputeGrid::assign_coords_all() void ComputeGrid::allocate() { // allocate arrays - memory->create(grid, size_array_rows, size_array_cols, "grid:grid"); memory->create(gridall, size_array_rows, size_array_cols, "grid:gridall"); if (nxlo <= nxhi && nylo <= nyhi && nzlo <= nzhi) { diff --git a/src/ML-SNAP/compute_grid_local.cpp b/src/ML-SNAP/compute_grid_local.cpp index 0f275a9aae..80feb75be5 100644 --- a/src/ML-SNAP/compute_grid_local.cpp +++ b/src/ML-SNAP/compute_grid_local.cpp @@ -119,6 +119,8 @@ void ComputeGridLocal::allocate() void ComputeGridLocal::deallocate() { + if (copymode) return; + if (gridlocal_allocated) { gridlocal_allocated = 0; memory->destroy(alocal); diff --git a/src/ML-SNAP/compute_sna_grid.cpp b/src/ML-SNAP/compute_sna_grid.cpp index 4243202545..95c3fa70a8 100644 --- a/src/ML-SNAP/compute_sna_grid.cpp +++ b/src/ML-SNAP/compute_sna_grid.cpp @@ -31,14 +31,13 @@ ComputeSNAGrid::ComputeSNAGrid(LAMMPS *lmp, int narg, char **arg) : // skip over arguments used by base class // so that argument positions are identical to // regular per-atom compute - arg += nargbase; narg -= nargbase; // begin code common to all SNAP computes - double rfac0, rmin0; - int twojmax, switchflag, bzeroflag, bnormflag, wselfallflag; + //double rfac0, rmin0; + //int twojmax, switchflag, bzeroflag, bnormflag, wselfallflag; int ntypes = atom->ntypes; int nargmin = 6 + 2 * ntypes; @@ -56,6 +55,8 @@ ComputeSNAGrid::ComputeSNAGrid(LAMMPS *lmp, int narg, char **arg) : wselfallflag = 0; switchinnerflag = 0; nelements = 1; + chunksize = 32768; + parallel_thresh = 8192; // process required arguments @@ -67,8 +68,9 @@ ComputeSNAGrid::ComputeSNAGrid(LAMMPS *lmp, int narg, char **arg) : twojmax = utils::inumeric(FLERR, arg[5], false, lmp); for (int i = 0; i < ntypes; i++) radelem[i + 1] = utils::numeric(FLERR, arg[6 + i], false, lmp); - for (int i = 0; i < ntypes; i++) + for (int i = 0; i < ntypes; i++) { wjelem[i + 1] = utils::numeric(FLERR, arg[6 + ntypes + i], false, lmp); + } // construct cutsq @@ -181,11 +183,12 @@ ComputeSNAGrid::ComputeSNAGrid(LAMMPS *lmp, int narg, char **arg) : ComputeSNAGrid::~ComputeSNAGrid() { + if (copymode) return; + memory->destroy(radelem); memory->destroy(wjelem); memory->destroy(cutsq); delete snaptr; - if (chemflag) memory->destroy(map); } @@ -202,6 +205,7 @@ void ComputeSNAGrid::init() void ComputeSNAGrid::compute_array() { + invoked_array = update->ntimestep; // compute sna for each gridpoint diff --git a/src/ML-SNAP/compute_sna_grid.h b/src/ML-SNAP/compute_sna_grid.h index 3a5a373826..a158c2342f 100644 --- a/src/ML-SNAP/compute_sna_grid.h +++ b/src/ML-SNAP/compute_sna_grid.h @@ -31,21 +31,27 @@ class ComputeSNAGrid : public ComputeGrid { void init() override; void compute_array() override; double memory_usage() override; + int ncoeff,nelements; // public for kokkos, but could go in the protected block now - private: - int ncoeff; + protected: + //int ncoeff; double **cutsq; double rcutfac; double *radelem; double *wjelem; int *map; // map types to [0,nelements) - int nelements, chemflag; + int chemflag; int switchinnerflag; double *sinnerelem; double *dinnerelem; + int parallel_thresh; class SNA *snaptr; double cutmax; int quadraticflag; + double rfac0, rmin0; + int twojmax, switchflag, bzeroflag, bnormflag, wselfallflag; + int chunksize; + }; } // namespace LAMMPS_NS diff --git a/src/ML-SNAP/compute_sna_grid_local.cpp b/src/ML-SNAP/compute_sna_grid_local.cpp index 1d42a42c05..db49063920 100644 --- a/src/ML-SNAP/compute_sna_grid_local.cpp +++ b/src/ML-SNAP/compute_sna_grid_local.cpp @@ -37,8 +37,8 @@ ComputeSNAGridLocal::ComputeSNAGridLocal(LAMMPS *lmp, int narg, char **arg) : // begin code common to all SNAP computes - double rfac0, rmin0; - int twojmax, switchflag, bzeroflag, bnormflag, wselfallflag; + //double rfac0, rmin0; + //int twojmax, switchflag, bzeroflag, bnormflag, wselfallflag; int ntypes = atom->ntypes; int nargmin = 6 + 2 * ntypes; @@ -56,6 +56,8 @@ ComputeSNAGridLocal::ComputeSNAGridLocal(LAMMPS *lmp, int narg, char **arg) : wselfallflag = 0; switchinnerflag = 0; nelements = 1; + chunksize = 32768; + parallel_thresh = 8192; // process required arguments @@ -180,6 +182,7 @@ ComputeSNAGridLocal::ComputeSNAGridLocal(LAMMPS *lmp, int narg, char **arg) : ComputeSNAGridLocal::~ComputeSNAGridLocal() { + if (copymode) return; memory->destroy(radelem); memory->destroy(wjelem); memory->destroy(cutsq); diff --git a/src/ML-SNAP/compute_sna_grid_local.h b/src/ML-SNAP/compute_sna_grid_local.h index 0475212e13..85662ad509 100644 --- a/src/ML-SNAP/compute_sna_grid_local.h +++ b/src/ML-SNAP/compute_sna_grid_local.h @@ -32,7 +32,7 @@ class ComputeSNAGridLocal : public ComputeGridLocal { void compute_local() override; double memory_usage() override; - private: + protected: int ncoeff; double **cutsq; double rcutfac; @@ -46,6 +46,10 @@ class ComputeSNAGridLocal : public ComputeGridLocal { class SNA *snaptr; double cutmax; int quadraticflag; + double rfac0, rmin0; + int twojmax, switchflag, bzeroflag, bnormflag, wselfallflag; + int chunksize; + int parallel_thresh; }; } // namespace LAMMPS_NS diff --git a/src/MOLECULE/fix_cmap.cpp b/src/MOLECULE/fix_cmap.cpp index 02116965b5..29fa8e4072 100644 --- a/src/MOLECULE/fix_cmap.cpp +++ b/src/MOLECULE/fix_cmap.cpp @@ -1051,7 +1051,7 @@ bigint FixCMAP::read_data_skip_lines(char * /*keyword*/) void FixCMAP::write_data_header(FILE *fp, int /*mth*/) { - fmt::print(fp,"{} crossterms\n",ncmap); + utils::print(fp,"{} crossterms\n",ncmap); } /* ---------------------------------------------------------------------- @@ -1129,7 +1129,7 @@ void FixCMAP::write_data_section(int /*mth*/, FILE *fp, int n, double **buf, int index) { for (int i = 0; i < n; i++) - fmt::print(fp,"{} {} {} {} {} {} {}\n", + utils::print(fp,"{} {} {} {} {} {} {}\n", index+i,ubuf(buf[i][0]).i, ubuf(buf[i][1]).i, ubuf(buf[i][2]).i, ubuf(buf[i][3]).i,ubuf(buf[i][4]).i,ubuf(buf[i][5]).i); } diff --git a/src/MOLECULE/pair_hbond_dreiding_lj.cpp b/src/MOLECULE/pair_hbond_dreiding_lj.cpp index 4536cc8e05..fd0e61edd2 100644 --- a/src/MOLECULE/pair_hbond_dreiding_lj.cpp +++ b/src/MOLECULE/pair_hbond_dreiding_lj.cpp @@ -13,7 +13,7 @@ ------------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- - Contributing author: Tod A Pascal (Caltech) + Contributing authors: Tod A Pascal (Caltech), Don Xu/EiPi Fun ------------------------------------------------------------------------- */ #include "pair_hbond_dreiding_lj.h" @@ -55,6 +55,9 @@ PairHbondDreidingLJ::PairHbondDreidingLJ(LAMMPS *lmp) : Pair(lmp) nextra = 2; pvector = new double[2]; + + angle_offset_flag = 0; + angle_offset_global = 0.0; } /* ---------------------------------------------------------------------- */ @@ -82,7 +85,7 @@ void PairHbondDreidingLJ::compute(int eflag, int vflag) tagint tagprev; double delx,dely,delz,rsq,rsq1,rsq2,r1,r2; double factor_hb,force_angle,force_kernel,evdwl,eng_lj,ehbond,force_switch; - double c,s,a,b,ac,a11,a12,a22,vx1,vx2,vy1,vy2,vz1,vz2,d; + double c,s,a,b,d,ac,a11,a12,a22,vx1,vx2,vy1,vy2,vz1,vz2; double fi[3],fj[3],delr1[3],delr2[3]; double r2inv,r10inv; double switch1,switch2; @@ -178,6 +181,13 @@ void PairHbondDreidingLJ::compute(int eflag, int vflag) if (c < -1.0) c = -1.0; ac = acos(c); + if (angle_offset_flag){ + ac = ac + pm.angle_offset; + c = cos(ac); + if (c > 1.0) c = 1.0; + if (c < -1.0) c = -1.0; + } + if (ac > pm.cut_angle && ac < (2.0*MY_PI - pm.cut_angle)) { s = sqrt(1.0 - c*c); if (s < SMALL) s = SMALL; @@ -186,15 +196,12 @@ void PairHbondDreidingLJ::compute(int eflag, int vflag) r2inv = 1.0/rsq; r10inv = r2inv*r2inv*r2inv*r2inv*r2inv; - force_kernel = r10inv*(pm.lj1*r2inv - pm.lj2)*r2inv * - powint(c,pm.ap); - force_angle = pm.ap * r10inv*(pm.lj3*r2inv - pm.lj4) * - powint(c,pm.ap-1)*s; + force_kernel = r10inv*(pm.lj1*r2inv - pm.lj2)*r2inv * powint(c,pm.ap); + force_angle = pm.ap * r10inv*(pm.lj3*r2inv - pm.lj4) * powint(c,pm.ap-1)*s; + force_switch = 0.0; eng_lj = r10inv*(pm.lj3*r2inv - pm.lj4); - force_switch=0.0; - if (rsq > pm.cut_innersq) { switch1 = (pm.cut_outersq-rsq) * (pm.cut_outersq-rsq) * (pm.cut_outersq + 2.0*rsq - 3.0*pm.cut_innersq) / @@ -300,12 +307,19 @@ void PairHbondDreidingLJ::allocate() void PairHbondDreidingLJ::settings(int narg, char **arg) { - if (narg != 4) error->all(FLERR,"Illegal pair_style command"); + + // narg = 4 for standard form, narg = 5 or 6 if angleoffset LJ or Morse variants respectively (from EXTRA-MOLECULE) + if (narg != 4 && narg != 5) error->all(FLERR,"Illegal pair_style command"); ap_global = utils::inumeric(FLERR,arg[0],false,lmp); cut_inner_global = utils::numeric(FLERR,arg[1],false,lmp); cut_outer_global = utils::numeric(FLERR,arg[2],false,lmp); cut_angle_global = utils::numeric(FLERR,arg[3],false,lmp) * MY_PI/180.0; + + // update when using angleoffset variant + if (angle_offset_flag) { + angle_offset_global = (180.0 - utils::numeric(FLERR, arg[4], false, lmp)) * MY_PI/180.0; + } } /* ---------------------------------------------------------------------- @@ -314,8 +328,14 @@ void PairHbondDreidingLJ::settings(int narg, char **arg) void PairHbondDreidingLJ::coeff(int narg, char **arg) { - if (narg < 6 || narg > 10) + // account for angleoffset variant in EXTRA-MOLECULE + int maxarg = 10; + if (angle_offset_flag == 1) maxarg = 11; + + // check settings + if (narg < 6 || narg > maxarg) error->all(FLERR,"Incorrect args for pair coefficients"); + if (!allocated) allocate(); int ilo,ihi,jlo,jhi,klo,khi; @@ -343,16 +363,15 @@ void PairHbondDreidingLJ::coeff(int narg, char **arg) error->all(FLERR,"Pair inner cutoff >= Pair outer cutoff"); double cut_angle_one = cut_angle_global; if (narg == 10) cut_angle_one = utils::numeric(FLERR, arg[9], false, lmp) * MY_PI/180.0; + // grow params array if necessary if (nparams == maxparam) { maxparam += CHUNK; - params = (Param *) memory->srealloc(params, maxparam*sizeof(Param), - "pair:params"); + params = (Param *) memory->srealloc(params, maxparam*sizeof(Param), "pair:params"); // make certain all addional allocated storage is initialized // to avoid false positives when checking with valgrind - memset(params + nparams, 0, CHUNK*sizeof(Param)); } @@ -540,6 +559,13 @@ double PairHbondDreidingLJ::single(int i, int j, int itype, int jtype, if (c < -1.0) c = -1.0; ac = acos(c); + if (angle_offset_flag){ + ac = ac + pm.angle_offset; + c = cos(ac); + if (c > 1.0) c = 1.0; + if (c < -1.0) c = -1.0; + } + if (ac < pm.cut_angle || ac > (2.0*MY_PI - pm.cut_angle)) return 0.0; s = sqrt(1.0 - c*c); if (s < SMALL) s = SMALL; diff --git a/src/MOLECULE/pair_hbond_dreiding_lj.h b/src/MOLECULE/pair_hbond_dreiding_lj.h index 91a906c5cb..131f3946b3 100644 --- a/src/MOLECULE/pair_hbond_dreiding_lj.h +++ b/src/MOLECULE/pair_hbond_dreiding_lj.h @@ -25,6 +25,7 @@ PairStyle(hbond/dreiding/lj,PairHbondDreidingLJ); namespace LAMMPS_NS { class PairHbondDreidingLJ : public Pair { + public: PairHbondDreidingLJ(class LAMMPS *); ~PairHbondDreidingLJ() override; @@ -38,6 +39,8 @@ class PairHbondDreidingLJ : public Pair { protected: double cut_inner_global, cut_outer_global, cut_angle_global; int ap_global; + int angle_offset_flag; // 1 if angle offset variant used + double angle_offset_global; // updated if angle offset variant used struct Param { double epsilon, sigma; @@ -45,7 +48,7 @@ class PairHbondDreidingLJ : public Pair { double d0, alpha, r0; double morse1; double denom_vdw; - double cut_inner, cut_outer, cut_innersq, cut_outersq, cut_angle, offset; + double cut_inner, cut_outer, cut_innersq, cut_outersq, cut_angle, offset, angle_offset; int ap; }; diff --git a/src/MOLECULE/pair_hbond_dreiding_morse.cpp b/src/MOLECULE/pair_hbond_dreiding_morse.cpp index d976b66460..8506765984 100644 --- a/src/MOLECULE/pair_hbond_dreiding_morse.cpp +++ b/src/MOLECULE/pair_hbond_dreiding_morse.cpp @@ -148,6 +148,13 @@ void PairHbondDreidingMorse::compute(int eflag, int vflag) if (c < -1.0) c = -1.0; ac = acos(c); + if (angle_offset_flag){ + ac = ac + pm.angle_offset; + c = cos(ac); + if (c > 1.0) c = 1.0; + if (c < -1.0) c = -1.0; + } + if (ac > pm.cut_angle && ac < (2.0*MY_PI - pm.cut_angle)) { s = sqrt(1.0 - c*c); if (s < SMALL) s = SMALL; @@ -158,6 +165,7 @@ void PairHbondDreidingMorse::compute(int eflag, int vflag) dr = r - pm.r0; dexp = exp(-pm.alpha * dr); eng_morse = pm.d0 * (dexp*dexp - 2.0*dexp); + force_kernel = pm.morse1*(dexp*dexp - dexp)/r * powint(c,pm.ap); force_angle = pm.ap * eng_morse * powint(c,pm.ap-1)*s; force_switch = 0.0; @@ -196,12 +204,12 @@ void PairHbondDreidingMorse::compute(int eflag, int vflag) vz1 = a11*delr1[2] + a12*delr2[2]; vz2 = a22*delr2[2] + a12*delr1[2]; - fi[0] = vx1 + (b+d)*delx; - fi[1] = vy1 + (b+d)*dely; - fi[2] = vz1 + (b+d)*delz; - fj[0] = vx2 - (b+d)*delx; - fj[1] = vy2 - (b+d)*dely; - fj[2] = vz2 - (b+d)*delz; + fi[0] = vx1 + b*delx + d*delx; + fi[1] = vy1 + b*dely + d*dely; + fi[2] = vz1 + b*delz + d*delz; + fj[0] = vx2 - b*delx - d*delx; + fj[1] = vy2 - b*dely - d*dely; + fj[2] = vz2 - b*delz - d*delz; f[i][0] += fi[0]; f[i][1] += fi[1]; @@ -238,7 +246,9 @@ void PairHbondDreidingMorse::compute(int eflag, int vflag) void PairHbondDreidingMorse::coeff(int narg, char **arg) { - if (narg < 7 || narg > 11) + int maxarg = 12; + if (angle_offset_flag == 1) maxarg = 12; + if (narg < 7 || narg > maxarg) error->all(FLERR,"Incorrect args for pair coefficients"); if (!allocated) allocate(); @@ -443,6 +453,13 @@ double PairHbondDreidingMorse::single(int i, int j, int itype, int jtype, if (c < -1.0) c = -1.0; ac = acos(c); + if (angle_offset_flag){ + ac = ac + pm.angle_offset; + c = cos(ac); + if (c > 1.0) c = 1.0; + if (c < -1.0) c = -1.0; + } + if (ac < pm.cut_angle || ac > (2.0*MY_PI - pm.cut_angle)) return 0.0; s = sqrt(1.0 - c*c); if (s < SMALL) s = SMALL; diff --git a/src/Makefile b/src/Makefile index 4d8b02458a..3de8eb85d5 100644 --- a/src/Makefile +++ b/src/Makefile @@ -480,7 +480,7 @@ tar: @cd STUBS; $(MAKE) @echo "Created $(ROOT)_src.tar.gz" -check: check-whitespace check-permissions check-homepage check-errordocs check-docs check-version +check: check-whitespace check-permissions check-homepage check-errordocs check-fmtlib check-docs check-version check-whitespace: $(PYTHON) ../tools/coding_standard/whitespace.py .. @@ -506,6 +506,12 @@ check-errordocs: fix-errordocs: $(PYTHON) ../tools/coding_standard/errordocs.py .. -f +check-fmtlib: + $(PYTHON) ../tools/coding_standard/fmtlib.py .. + +fix-fmtlib: + $(PYTHON) ../tools/coding_standard/fmtlib.py .. -f + check-docs: $(MAKE) $(MFLAGS) -C ../doc anchor_check style_check package_check role_check diff --git a/src/OPENMP/fix_qeq_comb_omp.cpp b/src/OPENMP/fix_qeq_comb_omp.cpp index a2fcf85367..8d5eb284cc 100644 --- a/src/OPENMP/fix_qeq_comb_omp.cpp +++ b/src/OPENMP/fix_qeq_comb_omp.cpp @@ -99,7 +99,7 @@ void FixQEQCombOMP::post_force(int /* vflag */) // charge-equilibration loop - if (me == 0 && fp) fmt::print(fp, "Charge equilibration on step {}\n", update->ntimestep); + if (me == 0 && fp) utils::print(fp, "Charge equilibration on step {}\n", update->ntimestep); heatpq = 0.05; qmass = 0.016; diff --git a/src/OPENMP/pair_hbond_dreiding_lj_angleoffset_omp.cpp b/src/OPENMP/pair_hbond_dreiding_lj_angleoffset_omp.cpp new file mode 100644 index 0000000000..11c09ed549 --- /dev/null +++ b/src/OPENMP/pair_hbond_dreiding_lj_angleoffset_omp.cpp @@ -0,0 +1,127 @@ +// clang-format off +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + This software is distributed under the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing author: Axel Kohlmeyer (Temple U), Don Xu/EiPi Fun +------------------------------------------------------------------------- */ + +#include "pair_hbond_dreiding_lj_angleoffset_omp.h" + +#include "atom.h" +#include "atom_vec.h" +#include "comm.h" +#include "domain.h" +#include "force.h" +#include "math_const.h" +#include "math_special.h" +#include "memory.h" +#include "molecule.h" +#include "neigh_list.h" +#include "suffix.h" + +#include + +#include "omp_compat.h" +using namespace LAMMPS_NS; +using namespace MathConst; +using namespace MathSpecial; + +static constexpr int CHUNK = 8; + +/* ---------------------------------------------------------------------- */ + +PairHbondDreidingLJAngleoffsetOMP::PairHbondDreidingLJAngleoffsetOMP(LAMMPS *lmp) : + PairHbondDreidingLJOMP(lmp) { + angle_offset_flag = 1; +} + +/* ---------------------------------------------------------------------- + set coeffs for one or more type pairs +------------------------------------------------------------------------- */ + +void PairHbondDreidingLJAngleoffsetOMP::coeff(int narg, char **arg) +{ + auto mylmp = PairHbondDreidingLJ::lmp; + if (narg < 6 || narg > 11) + error->all(FLERR,"Incorrect args for pair coefficients"); + if (!allocated) allocate(); + + int ilo,ihi,jlo,jhi,klo,khi; + utils::bounds(FLERR, arg[0], 1, atom->ntypes, ilo, ihi, error); + utils::bounds(FLERR, arg[1], 1, atom->ntypes, jlo, jhi, error); + utils::bounds_typelabel(FLERR, arg[2], 1, atom->ntypes, klo, khi, mylmp, Atom::ATOM); + + int donor_flag; + if (strcmp(arg[3],"i") == 0) donor_flag = 0; + else if (strcmp(arg[3],"j") == 0) donor_flag = 1; + else error->all(FLERR,"Incorrect args for pair coefficients"); + + double epsilon_one = utils::numeric(FLERR, arg[4], false, mylmp); + double sigma_one = utils::numeric(FLERR, arg[5], false, mylmp); + + int ap_one = ap_global; + if (narg > 6) ap_one = utils::inumeric(FLERR, arg[6], false, mylmp); + double cut_inner_one = cut_inner_global; + double cut_outer_one = cut_outer_global; + if (narg > 8) { + cut_inner_one = utils::numeric(FLERR, arg[7], false, mylmp); + cut_outer_one = utils::numeric(FLERR, arg[8], false, mylmp); + } + if (cut_inner_one>cut_outer_one) + error->all(FLERR,"Pair inner cutoff >= Pair outer cutoff"); + double cut_angle_one = cut_angle_global; + if (narg > 9) cut_angle_one = utils::numeric(FLERR, arg[9], false, mylmp) * MY_PI/180.0; + double angle_offset_one = angle_offset_global; + if (narg == 11) angle_offset_one = (180.0 - utils::numeric(FLERR, arg[10], false, mylmp)) * MY_PI/180.0; + if (angle_offset_one < 0.0 || angle_offset_one > 90.0 * MY_PI/180.0) + error->all(FLERR,"Illegal angle offset"); + + // grow params array if necessary + + if (nparams == maxparam) { + maxparam += CHUNK; + params = (Param *) memory->srealloc(params, maxparam*sizeof(Param), + "pair:params"); + + // make certain all addional allocated storage is initialized + // to avoid false positives when checking with valgrind + + memset(params + nparams, 0, CHUNK*sizeof(Param)); + } + + params[nparams].epsilon = epsilon_one; + params[nparams].sigma = sigma_one; + params[nparams].ap = ap_one; + params[nparams].cut_inner = cut_inner_one; + params[nparams].cut_outer = cut_outer_one; + params[nparams].cut_innersq = cut_inner_one*cut_inner_one; + params[nparams].cut_outersq = cut_outer_one*cut_outer_one; + params[nparams].cut_angle = cut_angle_one; + params[nparams].angle_offset = angle_offset_one; + params[nparams].denom_vdw = + (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq); + + // flag type2param with either i,j = D,A or j,i = D,A + + int count = 0; + for (int i = ilo; i <= ihi; i++) + for (int j = MAX(jlo,i); j <= jhi; j++) + for (int k = klo; k <= khi; k++) { + if (donor_flag == 0) type2param[i][j][k] = nparams; + else type2param[j][i][k] = nparams; + count++; + } + nparams++; + + if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients"); +} diff --git a/src/OPENMP/pair_hbond_dreiding_lj_angleoffset_omp.h b/src/OPENMP/pair_hbond_dreiding_lj_angleoffset_omp.h new file mode 100644 index 0000000000..03d3392e4d --- /dev/null +++ b/src/OPENMP/pair_hbond_dreiding_lj_angleoffset_omp.h @@ -0,0 +1,41 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing author: Axel Kohlmeyer (Temple U), Don Xu/EiPi Fun +------------------------------------------------------------------------- */ + +#ifdef PAIR_CLASS +// clang-format off +PairStyle(hbond/dreiding/lj/angleoffset/omp,PairHbondDreidingLJAngleoffsetOMP); +// clang-format on +#else + +#ifndef LMP_PAIR_HBOND_DREIDING_LJ_ANGLEOFFSET_OMP_H +#define LMP_PAIR_HBOND_DREIDING_LJ_ANGLEOFFSET_OMP_H + +#include "pair_hbond_dreiding_lj_omp.h" + +namespace LAMMPS_NS { + +class PairHbondDreidingLJAngleoffsetOMP : public PairHbondDreidingLJOMP { + + public: + PairHbondDreidingLJAngleoffsetOMP(class LAMMPS *); + void coeff(int, char **) override; +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/OPENMP/pair_hbond_dreiding_lj_omp.cpp b/src/OPENMP/pair_hbond_dreiding_lj_omp.cpp index b0f6dcfb5b..60ec8938fe 100644 --- a/src/OPENMP/pair_hbond_dreiding_lj_omp.cpp +++ b/src/OPENMP/pair_hbond_dreiding_lj_omp.cpp @@ -120,15 +120,16 @@ void PairHbondDreidingLJOMP::eval(int iifrom, int iito, ThrData * const thr) int i,j,k,m,ii,jj,kk,jnum,knum,itype,jtype,ktype,iatom,imol; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq,rsq1,rsq2,r1,r2; - double factor_hb,force_angle,force_kernel,evdwl,eng_lj; - double c,s,a,b,ac,a11,a12,a22,vx1,vx2,vy1,vy2,vz1,vz2; + double factor_hb,force_angle,force_kernel,evdwl,eng_lj,ehbond,force_switch; + double c,s,a,b,d,ac,a11,a12,a22,vx1,vx2,vy1,vy2,vz1,vz2; double fi[3],fj[3],delr1[3],delr2[3]; double r2inv,r10inv; double switch1,switch2; int *ilist,*jlist,*numneigh,**firstneigh; const tagint *klist; - evdwl = 0.0; + evdwl = ehbond = 0.0; + int hbcount = 0; const auto * _noalias const x = (dbl3_t *) atom->x[0]; auto * _noalias const f = (dbl3_t *) thr->get_f()[0]; @@ -151,9 +152,6 @@ void PairHbondDreidingLJOMP::eval(int iifrom, int iito, ThrData * const thr) // jj = loop over acceptors // kk = loop over hydrogens bonded to donor - int hbcount = 0; - double hbeng = 0.0; - for (ii = iifrom; ii < iito; ++ii) { i = ilist[ii]; itype = type[i]; @@ -222,6 +220,13 @@ void PairHbondDreidingLJOMP::eval(int iifrom, int iito, ThrData * const thr) if (c < -1.0) c = -1.0; ac = acos(c); + if (angle_offset_flag){ + ac = ac + pm.angle_offset; + c = cos(ac); + if (c > 1.0) c = 1.0; + if (c < -1.0) c = -1.0; + } + if (ac > pm.cut_angle && ac < (2.0*MY_PI - pm.cut_angle)) { s = sqrt(1.0 - c*c); if (s < SMALL) s = SMALL; @@ -230,30 +235,34 @@ void PairHbondDreidingLJOMP::eval(int iifrom, int iito, ThrData * const thr) r2inv = 1.0/rsq; r10inv = r2inv*r2inv*r2inv*r2inv*r2inv; - force_kernel = r10inv*(pm.lj1*r2inv - pm.lj2)*r2inv * - powint(c,pm.ap); - force_angle = pm.ap * r10inv*(pm.lj3*r2inv - pm.lj4) * - powint(c,pm.ap-1)*s; + force_kernel = r10inv*(pm.lj1*r2inv - pm.lj2)*r2inv * powint(c,pm.ap); + force_angle = pm.ap * r10inv*(pm.lj3*r2inv - pm.lj4) * powint(c,pm.ap-1)*s; + force_switch = 0.0; eng_lj = r10inv*(pm.lj3*r2inv - pm.lj4); + if (rsq > pm.cut_innersq) { switch1 = (pm.cut_outersq-rsq) * (pm.cut_outersq-rsq) * (pm.cut_outersq + 2.0*rsq - 3.0*pm.cut_innersq) / pm.denom_vdw; switch2 = 12.0*rsq * (pm.cut_outersq-rsq) * (rsq-pm.cut_innersq) / pm.denom_vdw; - force_kernel = force_kernel*switch1 + eng_lj*switch2/rsq; - force_angle *= switch1; - eng_lj *= switch1; + + force_kernel *= switch1; + force_angle *= switch1; + force_switch = eng_lj*switch2/rsq; + eng_lj *= switch1; } if (EFLAG) { evdwl = eng_lj * powint(c,pm.ap); evdwl *= factor_hb; + ehbond += evdwl; } a = factor_hb*force_angle/s; b = factor_hb*force_kernel; + d = factor_hb*force_switch; a11 = a*c / rsq1; a12 = -a / (r1*r2); @@ -266,12 +275,12 @@ void PairHbondDreidingLJOMP::eval(int iifrom, int iito, ThrData * const thr) vz1 = a11*delr1[2] + a12*delr2[2]; vz2 = a22*delr2[2] + a12*delr1[2]; - fi[0] = vx1 + b*delx; - fi[1] = vy1 + b*dely; - fi[2] = vz1 + b*delz; - fj[0] = vx2 - b*delx; - fj[1] = vy2 - b*dely; - fj[2] = vz2 - b*delz; + fi[0] = vx1 + b*delx + d*delx; + fi[1] = vy1 + b*dely + d*dely; + fi[2] = vz1 + b*delz + d*delz; + fj[0] = vx2 - b*delx - d*delx; + fj[1] = vy2 - b*dely - d*dely; + fj[2] = vz2 - b*delz - d*delz; fxtmp += fi[0]; fytmp += fi[1]; @@ -290,7 +299,7 @@ void PairHbondDreidingLJOMP::eval(int iifrom, int iito, ThrData * const thr) if (EVFLAG) ev_tally3_thr(this,k,i,j,evdwl,0.0,fi,fj,delr1,delr2,thr); if (EFLAG) { hbcount++; - hbeng += evdwl; + ehbond += evdwl; } } } @@ -302,7 +311,7 @@ void PairHbondDreidingLJOMP::eval(int iifrom, int iito, ThrData * const thr) } const int tid = thr->get_tid(); hbcount_thr[tid] = static_cast(hbcount); - hbeng_thr[tid] = hbeng; + hbeng_thr[tid] = ehbond; } /* ---------------------------------------------------------------------- */ diff --git a/src/OPENMP/pair_hbond_dreiding_morse_angleoffset_omp.cpp b/src/OPENMP/pair_hbond_dreiding_morse_angleoffset_omp.cpp new file mode 100644 index 0000000000..e7c75f29e4 --- /dev/null +++ b/src/OPENMP/pair_hbond_dreiding_morse_angleoffset_omp.cpp @@ -0,0 +1,127 @@ +// clang-format off +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + This software is distributed under the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing author: Axel Kohlmeyer (Temple U), Don Xu/EiPi Fun +------------------------------------------------------------------------- */ + +#include "pair_hbond_dreiding_morse_angleoffset_omp.h" + +#include "atom.h" +#include "atom_vec.h" +#include "comm.h" +#include "domain.h" +#include "force.h" +#include "math_const.h" +#include "math_special.h" +#include "memory.h" +#include "molecule.h" +#include "neigh_list.h" +#include "suffix.h" + +#include + +#include "omp_compat.h" +using namespace LAMMPS_NS; +using namespace MathConst; +using namespace MathSpecial; + +static constexpr int CHUNK = 8; + +/* ---------------------------------------------------------------------- */ + +PairHbondDreidingMorseAngleoffsetOMP::PairHbondDreidingMorseAngleoffsetOMP(LAMMPS *lmp) : + PairHbondDreidingMorseOMP(lmp) { + angle_offset_flag = 1; +} + +/* ---------------------------------------------------------------------- + * set coeffs for one or more type pairs + * ---------------------------------------------------------------------- */ + +void PairHbondDreidingMorseAngleoffsetOMP::coeff(int narg, char **arg) +{ + auto mylmp = PairHbondDreidingMorse::lmp; + if (narg < 7 || narg > 12) + error->all(FLERR,"Incorrect args for pair coefficients"); + if (!allocated) allocate(); + + int ilo,ihi,jlo,jhi,klo,khi; + utils::bounds(FLERR, arg[0], 1, atom->ntypes, ilo, ihi, error); + utils::bounds(FLERR, arg[1], 1, atom->ntypes, jlo, jhi, error); + utils::bounds_typelabel(FLERR, arg[2], 1, atom->ntypes, klo, khi, mylmp, Atom::ATOM); + + int donor_flag; + if (strcmp(arg[3],"i") == 0) donor_flag = 0; + else if (strcmp(arg[3],"j") == 0) donor_flag = 1; + else error->all(FLERR,"Incorrect args for pair coefficients"); + + double d0_one = utils::numeric(FLERR, arg[4], false, mylmp); + double alpha_one = utils::numeric(FLERR, arg[5], false, mylmp); + double r0_one = utils::numeric(FLERR, arg[6], false, mylmp); + + int ap_one = ap_global; + if (narg > 7) ap_one = utils::inumeric(FLERR, arg[7], false, mylmp); + double cut_inner_one = cut_inner_global; + double cut_outer_one = cut_outer_global; + if (narg > 9) { + cut_inner_one = utils::numeric(FLERR, arg[8], false, mylmp); + cut_outer_one = utils::numeric(FLERR, arg[9], false, mylmp); + } + if (cut_inner_one>cut_outer_one) + error->all(FLERR,"Pair inner cutoff >= Pair outer cutoff"); + double cut_angle_one = cut_angle_global; + if (narg > 10) cut_angle_one = utils::numeric(FLERR, arg[10], false, mylmp) * MY_PI/180.0; + double angle_offset_one = angle_offset_global; + if (narg == 12) angle_offset_one = (180.0 - utils::numeric(FLERR, arg[11], false, mylmp)) * MY_PI/180.0; + if (angle_offset_one < 0.0 || angle_offset_one > 90.0 * MY_PI/180.0) + error->all(FLERR,"Illegal angle offset {}", angle_offset_one); + + // grow params array if necessary + + if (nparams == maxparam) { + maxparam += CHUNK; + params = (Param *) memory->srealloc(params, maxparam*sizeof(Param),"pair:params"); + + // make certain all addional allocated storage is initialized + // to avoid false positives when checking with valgrind + + memset(params + nparams, 0, CHUNK*sizeof(Param)); + } + + params[nparams].d0 = d0_one; + params[nparams].alpha = alpha_one; + params[nparams].r0 = r0_one; + params[nparams].ap = ap_one; + params[nparams].cut_inner = cut_inner_one; + params[nparams].cut_outer = cut_outer_one; + params[nparams].cut_innersq = cut_inner_one*cut_inner_one; + params[nparams].cut_outersq = cut_outer_one*cut_outer_one; + params[nparams].cut_angle = cut_angle_one; + params[nparams].angle_offset = angle_offset_one; + params[nparams].denom_vdw = (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq) * + (params[nparams].cut_outersq-params[nparams].cut_innersq); + + // flag type2param with either i,j = D,A or j,i = D,A + + int count = 0; + for (int i = ilo; i <= ihi; i++) + for (int j = MAX(jlo,i); j <= jhi; j++) + for (int k = klo; k <= khi; k++) { + if (donor_flag == 0) type2param[i][j][k] = nparams; + else type2param[j][i][k] = nparams; + count++; + } + nparams++; + + if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients"); +} diff --git a/src/OPENMP/pair_hbond_dreiding_morse_angleoffset_omp.h b/src/OPENMP/pair_hbond_dreiding_morse_angleoffset_omp.h new file mode 100644 index 0000000000..40a797ac33 --- /dev/null +++ b/src/OPENMP/pair_hbond_dreiding_morse_angleoffset_omp.h @@ -0,0 +1,42 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + https://www.lammps.org/, Sandia National Laboratories + LAMMPS development team: developers@lammps.org + + Copyright (2003) Sandia Corporation. Under the terms of Contract + DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains + certain rights in this software. This software is distributed under + the GNU General Public License. + + See the README file in the top-level LAMMPS directory. +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- + Contributing author: Axel Kohlmeyer (Temple U), Don Xu/EiPi Fun +------------------------------------------------------------------------- */ + +#ifdef PAIR_CLASS +// clang-format off +PairStyle(hbond/dreiding/morse/angleoffset/omp,PairHbondDreidingMorseAngleoffsetOMP); +// clang-format on +#else + +#ifndef LMP_PAIR_HBOND_DREIDING_MORSE_ANGLEOFFSET_OMP_H +#define LMP_PAIR_HBOND_DREIDING_MORSE_ANGLEOFFSET_OMP_H + +#include "pair_hbond_dreiding_morse_omp.h" + +namespace LAMMPS_NS { + +class PairHbondDreidingMorseAngleoffsetOMP : + public PairHbondDreidingMorseOMP { + + public: + PairHbondDreidingMorseAngleoffsetOMP(class LAMMPS *); + void coeff(int, char **) override; +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/OPENMP/pair_hbond_dreiding_morse_omp.cpp b/src/OPENMP/pair_hbond_dreiding_morse_omp.cpp index 0e43e2a037..7772ea69fa 100644 --- a/src/OPENMP/pair_hbond_dreiding_morse_omp.cpp +++ b/src/OPENMP/pair_hbond_dreiding_morse_omp.cpp @@ -120,14 +120,14 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) int i,j,k,m,ii,jj,kk,jnum,knum,itype,jtype,ktype,imol,iatom; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq,rsq1,rsq2,r1,r2; - double factor_hb,force_angle,force_kernel,evdwl; - double c,s,a,b,ac,a11,a12,a22,vx1,vx2,vy1,vy2,vz1,vz2; + double factor_hb,force_angle,force_kernel,force_switch,evdwl,ehbond; + double c,s,a,b,d,ac,a11,a12,a22,vx1,vx2,vy1,vy2,vz1,vz2; double fi[3],fj[3],delr1[3],delr2[3]; double r,dr,dexp,eng_morse,switch1,switch2; int *ilist,*jlist,*numneigh,**firstneigh; const tagint *klist; - evdwl = 0.0; + evdwl = ehbond = 0.0; const auto * _noalias const x = (dbl3_t *) atom->x[0]; auto * _noalias const f = (dbl3_t *) thr->get_f()[0]; @@ -151,7 +151,6 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) // kk = loop over hydrogens bonded to donor int hbcount = 0; - double hbeng = 0.0; for (ii = iifrom; ii < iito; ++ii) { @@ -222,6 +221,13 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) if (c < -1.0) c = -1.0; ac = acos(c); + if (angle_offset_flag){ + ac = ac + pm.angle_offset; + c = cos(ac); + if (c > 1.0) c = 1.0; + if (c < -1.0) c = -1.0; + } + if (ac > pm.cut_angle && ac < (2.0*MY_PI - pm.cut_angle)) { s = sqrt(1.0 - c*c); if (s < SMALL) s = SMALL; @@ -232,8 +238,10 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) dr = r - pm.r0; dexp = exp(-pm.alpha * dr); eng_morse = pm.d0 * (dexp*dexp - 2.0*dexp); + force_kernel = pm.morse1*(dexp*dexp - dexp)/r * powint(c,pm.ap); force_angle = pm.ap * eng_morse * powint(c,pm.ap-1)*s; + force_switch = 0.0; if (rsq > pm.cut_innersq) { switch1 = (pm.cut_outersq-rsq) * (pm.cut_outersq-rsq) * @@ -241,18 +249,22 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) pm.denom_vdw; switch2 = 12.0*rsq * (pm.cut_outersq-rsq) * (rsq-pm.cut_innersq) / pm.denom_vdw; - force_kernel = force_kernel*switch1 + eng_morse*switch2/rsq; + + force_kernel *= switch1; force_angle *= switch1; + force_switch = eng_morse*switch2/rsq; eng_morse *= switch1; } if (EFLAG) { evdwl = eng_morse * powint(c,pm.ap); evdwl *= factor_hb; + ehbond += evdwl; } a = factor_hb*force_angle/s; b = factor_hb*force_kernel; + d = factor_hb*force_switch; a11 = a*c / rsq1; a12 = -a / (r1*r2); @@ -265,12 +277,12 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) vz1 = a11*delr1[2] + a12*delr2[2]; vz2 = a22*delr2[2] + a12*delr1[2]; - fi[0] = vx1 + b*delx; - fi[1] = vy1 + b*dely; - fi[2] = vz1 + b*delz; - fj[0] = vx2 - b*delx; - fj[1] = vy2 - b*dely; - fj[2] = vz2 - b*delz; + fi[0] = vx1 + b*delx + d*delx; + fi[1] = vy1 + b*dely + d*dely; + fi[2] = vz1 + b*delz + d*delz; + fj[0] = vx2 - b*delx - d*delx; + fj[1] = vy2 - b*dely - d*dely; + fj[2] = vz2 - b*delz - d*delz; fxtmp += fi[0]; fytmp += fi[1]; @@ -289,7 +301,7 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) if (EVFLAG) ev_tally3_thr(this,k,i,j,evdwl,0.0,fi,fj,delr1,delr2,thr); if (EFLAG) { hbcount++; - hbeng += evdwl; + ehbond += evdwl; } } } @@ -301,7 +313,7 @@ void PairHbondDreidingMorseOMP::eval(int iifrom, int iito, ThrData * const thr) } const int tid = thr->get_tid(); hbcount_thr[tid] = static_cast(hbcount); - hbeng_thr[tid] = hbeng; + hbeng_thr[tid] = ehbond; } /* ---------------------------------------------------------------------- */ diff --git a/src/PHONON/dynamical_matrix.cpp b/src/PHONON/dynamical_matrix.cpp index c2ba34c4c2..a0199747c4 100644 --- a/src/PHONON/dynamical_matrix.cpp +++ b/src/PHONON/dynamical_matrix.cpp @@ -282,7 +282,7 @@ void DynamicalMatrix::calculateMatrix() if (me == 0 && screen) { fputs("Calculating Dynamical Matrix ...\n", screen); - fmt::print(screen," Total # of atoms = {}\n" + utils::print(screen," Total # of atoms = {}\n" " Atoms in group = {}\n" " Total dynamical matrix elements = {}\n", natoms, gcount, dynlen*dynlen); diff --git a/src/PHONON/fix_phonon.cpp b/src/PHONON/fix_phonon.cpp index 74670ebde5..37f84b6f12 100644 --- a/src/PHONON/fix_phonon.cpp +++ b/src/PHONON/fix_phonon.cpp @@ -186,21 +186,21 @@ FixPhonon::FixPhonon(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg) flog = fopen(logfile, "w"); if (flog == nullptr) error->one(FLERR,"Can not open output file {}: {}", logfile,utils::getsyserror()); - fmt::print(flog,"############################################################\n"); - fmt::print(flog,"# group name of the atoms under study : {}\n", group->names[igroup]); - fmt::print(flog,"# total number of atoms in the group : {}\n", ngroup); - fmt::print(flog,"# dimension of the system : {} D\n", sysdim); - fmt::print(flog,"# number of atoms per unit cell : {}\n", nucell); - fmt::print(flog,"# dimension of the FFT mesh : {} x {} x {}\n", nx, ny, nz); - fmt::print(flog,"# number of wait steps before measurement : {}\n", waitsteps); - fmt::print(flog,"# frequency of the measurement : {}\n", nevery); - fmt::print(flog,"# output result after this many measurement: {}\n", nfreq); - fmt::print(flog,"# number of processors used by this run : {}\n", nprocs); - fmt::print(flog,"############################################################\n"); - fmt::print(flog,"# mapping information between lattice indices and atom id\n"); - fmt::print(flog,"# nx ny nz nucell\n"); - fmt::print(flog,"{} {} {} {}\n", nx, ny, nz, nucell); - fmt::print(flog,"# l1 l2 l3 k atom_id\n"); + utils::print(flog,"############################################################\n"); + utils::print(flog,"# group name of the atoms under study : {}\n", group->names[igroup]); + utils::print(flog,"# total number of atoms in the group : {}\n", ngroup); + utils::print(flog,"# dimension of the system : {} D\n", sysdim); + utils::print(flog,"# number of atoms per unit cell : {}\n", nucell); + utils::print(flog,"# dimension of the FFT mesh : {} x {} x {}\n", nx, ny, nz); + utils::print(flog,"# number of wait steps before measurement : {}\n", waitsteps); + utils::print(flog,"# frequency of the measurement : {}\n", nevery); + utils::print(flog,"# output result after this many measurement: {}\n", nfreq); + utils::print(flog,"# number of processors used by this run : {}\n", nprocs); + utils::print(flog,"############################################################\n"); + utils::print(flog,"# mapping information between lattice indices and atom id\n"); + utils::print(flog,"# nx ny nz nucell\n"); + utils::print(flog,"{} {} {} {}\n", nx, ny, nz, nucell); + utils::print(flog,"# l1 l2 l3 k atom_id\n"); int ix, iy, iz, iu; for (idx = 0; idx < ngroup; ++idx) { itag = surf2tag[idx]; @@ -208,9 +208,9 @@ FixPhonon::FixPhonon(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg) iz = (idx/nucell)%nz; iy = (idx/(nucell*nz))%ny; ix = (idx/(nucell*nz*ny))%nx; - fmt::print(flog,"{} {} {} {} {}\n", ix, iy, iz, iu, itag); + utils::print(flog,"{} {} {} {} {}\n", ix, iy, iz, iu, itag); } - fmt::print(flog,"############################################################\n"); + utils::print(flog,"############################################################\n"); fflush(flog); } surf2tag.clear(); @@ -737,16 +737,16 @@ void FixPhonon::postprocess( ) fclose(fp_bin); // write log file, here however, it is the dynamical matrix that is written - fmt::print(flog,"############################################################\n"); - fmt::print(flog,"# Current time step : {}\n", update->ntimestep); - fmt::print(flog,"# Total number of measurements : {}\n", neval); - fmt::print(flog,"# Average temperature of the measurement : {}\n", TempAve); - fmt::print(flog,"# Boltzmann constant under current units : {}\n", boltz); - fmt::print(flog,"# basis vector A1 = [{} {} {}]\n", basevec[0], basevec[1], basevec[2]); - fmt::print(flog,"# basis vector A2 = [{} {} {}]\n", basevec[3], basevec[4], basevec[5]); - fmt::print(flog,"# basis vector A3 = [{} {} {}]\n", basevec[6], basevec[7], basevec[8]); - fmt::print(flog,"############################################################\n"); - fmt::print(flog,"# qx\t qy \t qz \t\t Phi(q)\n"); + utils::print(flog,"############################################################\n"); + utils::print(flog,"# Current time step : {}\n", update->ntimestep); + utils::print(flog,"# Total number of measurements : {}\n", neval); + utils::print(flog,"# Average temperature of the measurement : {}\n", TempAve); + utils::print(flog,"# Boltzmann constant under current units : {}\n", boltz); + utils::print(flog,"# basis vector A1 = [{} {} {}]\n", basevec[0], basevec[1], basevec[2]); + utils::print(flog,"# basis vector A2 = [{} {} {}]\n", basevec[3], basevec[4], basevec[5]); + utils::print(flog,"# basis vector A3 = [{} {} {}]\n", basevec[6], basevec[7], basevec[8]); + utils::print(flog,"############################################################\n"); + utils::print(flog,"# qx\t qy \t qz \t\t Phi(q)\n"); EnforceASR(); @@ -765,10 +765,10 @@ void FixPhonon::postprocess( ) double qy = double(iy)/double(ny); for (int iz = 0; iz < nz; ++iz) { double qz = double(iz)/double(nz); - fmt::print(flog,"{} {} {}", qx, qy, qz); + utils::print(flog,"{} {} {}", qx, qy, qz); for (idim = 0; idim < fft_dim2; ++idim) - fmt::print(flog, " {} {}", std::real(Phi_all[idq][idim]), std::imag(Phi_all[idq][idim])); - fmt::print(flog, "\n"); + utils::print(flog, " {} {}", std::real(Phi_all[idq][idim]), std::imag(Phi_all[idq][idim])); + utils::print(flog, "\n"); ++idq; } } diff --git a/src/PHONON/third_order.cpp b/src/PHONON/third_order.cpp index c31aae0086..378905bd29 100644 --- a/src/PHONON/third_order.cpp +++ b/src/PHONON/third_order.cpp @@ -295,7 +295,7 @@ void ThirdOrder::calculateMatrix() if (comm->me == 0 && screen) { fputs("Calculating Third Order ...\n", screen); - fmt::print(screen," Total # of atoms = {}\n" + utils::print(screen," Total # of atoms = {}\n" " Atoms in group = {}\n" " Total third order elements = {}\n", natoms, gcount, dynlen*dynlen*dynlen); @@ -432,7 +432,7 @@ void ThirdOrder::writeMatrix(double *dynmat, bigint i, int a, bigint j, int b) for (int k = 0; k < atom->natoms; k++){ norm = square(dynmat[k*3])+square(dynmat[k*3+1])+square(dynmat[k*3+2]); if (norm > 1.0e-16) - fmt::print(fp, "{} {} {} {} {} {:17.8f} {:17.8f} {:17.8f}\n", + utils::print(fp, "{} {} {} {} {} {:17.8f} {:17.8f} {:17.8f}\n", i+1, a+1, j+1, b+1, k+1, dynmat[k*3] * conversion, dynmat[k*3+1] * conversion, dynmat[k*3+2] * conversion); } @@ -440,7 +440,7 @@ void ThirdOrder::writeMatrix(double *dynmat, bigint i, int a, bigint j, int b) for (int k = 0; k < gcount; k++){ norm = square(dynmat[k*3])+square(dynmat[k*3+1])+square(dynmat[k*3+2]); if (norm > 1.0e-16) - fmt::print(fp, "{} {} {} {} {} {:17.8f} {:17.8f} {:17.8f}\n", + utils::print(fp, "{} {} {} {} {} {:17.8f} {:17.8f} {:17.8f}\n", i+1, a+1, j+1, b+1, groupmap[k]+1, dynmat[k*3] * conversion, dynmat[k*3+1] * conversion, dynmat[k*3+2] * conversion); } diff --git a/src/PYTHON/fix_python_invoke.cpp b/src/PYTHON/fix_python_invoke.cpp index 7fd3ad88f7..6f27831438 100644 --- a/src/PYTHON/fix_python_invoke.cpp +++ b/src/PYTHON/fix_python_invoke.cpp @@ -22,6 +22,7 @@ #include "lmppython.h" #include "python_compat.h" #include "python_utils.h" +#include "modify.h" #include "update.h" #include @@ -70,6 +71,12 @@ FixPythonInvoke::FixPythonInvoke(LAMMPS *lmp, int narg, char **arg) : } lmpPtr = PY_VOID_POINTER(lmp); + + // nvalid = next step on which end_of_step or post_force does something + // add nextvalid() to all computes that store invocation times + // since we don't know a priori which are invoked by python code + nvalid = nextvalid(); + modify->addstep_compute_all(nvalid); } /* ---------------------------------------------------------------------- */ @@ -89,8 +96,23 @@ int FixPythonInvoke::setmask() /* ---------------------------------------------------------------------- */ +void FixPythonInvoke::init() +{ + // need to reset nvalid if nvalid < ntimestep b/c minimize was performed + + if (nvalid < update->ntimestep) { + nvalid = nextvalid(); + modify->addstep_compute_all(nvalid); + } +} + +/* ---------------------------------------------------------------------- */ + void FixPythonInvoke::end_of_step() { + // python code may invoke computes so wrap with clear/add + modify->clearstep_compute(); + PyUtils::GIL lock; PyObject * result = PyObject_CallFunction((PyObject*)pFunc, (char *)"O", (PyObject*)lmpPtr); @@ -101,6 +123,9 @@ void FixPythonInvoke::end_of_step() } Py_CLEAR(result); + + nvalid = nextvalid(); + modify->addstep_compute(nvalid); } /* ---------------------------------------------------------------------- */ @@ -116,6 +141,9 @@ void FixPythonInvoke::post_force(int vflag) { if (update->ntimestep % nevery != 0) return; + // python code may invoke computes so wrap with clear/add + modify->clearstep_compute(); + PyUtils::GIL lock; char fmt[] = "Oi"; @@ -127,4 +155,14 @@ void FixPythonInvoke::post_force(int vflag) } Py_CLEAR(result); + + nvalid = nextvalid(); + modify->addstep_compute(nvalid); +} + +/* ---------------------------------------------------------------------- */ + +bigint FixPythonInvoke::nextvalid() +{ + return (update->ntimestep/nevery + 1)*nevery; } diff --git a/src/PYTHON/fix_python_invoke.h b/src/PYTHON/fix_python_invoke.h index 09382e5780..fdb931b69c 100644 --- a/src/PYTHON/fix_python_invoke.h +++ b/src/PYTHON/fix_python_invoke.h @@ -31,6 +31,7 @@ class FixPythonInvoke : public Fix { ~FixPythonInvoke() override; int setmask() override; void setup(int) override; + void init() override; void end_of_step() override; void post_force(int) override; @@ -38,6 +39,8 @@ class FixPythonInvoke : public Fix { void *lmpPtr; void *pFunc; int selected_callback; + bigint nextvalid(); + bigint nvalid; }; } // namespace LAMMPS_NS diff --git a/src/QTB/fix_qbmsst.cpp b/src/QTB/fix_qbmsst.cpp index 7dd7547efd..883e65b09e 100644 --- a/src/QTB/fix_qbmsst.cpp +++ b/src/QTB/fix_qbmsst.cpp @@ -360,7 +360,7 @@ void FixQBMSST::init() h_timestep=alpha*dtv; } if (comm->me == 0 && screen) - fmt::print(screen,"The effective maximum frequency is now {} inverse time unit " + utils::print(screen,"The effective maximum frequency is now {} inverse time unit " "with alpha value as {}!\n", 0.5/h_timestep, alpha); //gfactor is the random force \sqrt{\frac{2\gamma{}m_{i}}{\alpha*\delta{}t}}, \sqrt{12} makes the random array variance equal to unit. diff --git a/src/QTB/fix_qtb.cpp b/src/QTB/fix_qtb.cpp index 8f73a04927..4324238b97 100644 --- a/src/QTB/fix_qtb.cpp +++ b/src/QTB/fix_qtb.cpp @@ -170,7 +170,7 @@ void FixQTB::init() h_timestep=alpha*dtv; } if (comm->me == 0 && screen) - fmt::print(screen,"The effective maximum frequency is now {} inverse time unit " + utils::print(screen,"The effective maximum frequency is now {} inverse time unit " "with alpha value as {}!\n", 0.5/h_timestep, alpha); // set force prefactors diff --git a/src/REAXFF/fix_reaxff_bonds.cpp b/src/REAXFF/fix_reaxff_bonds.cpp index a5ce478c1d..54ad593486 100644 --- a/src/REAXFF/fix_reaxff_bonds.cpp +++ b/src/REAXFF/fix_reaxff_bonds.cpp @@ -253,11 +253,11 @@ void FixReaxFFBonds::RecvBuffer(double *buf, int nbuf, int nbuf_local, MPI_Request irequest, irequest2; if (me == 0) { - fmt::print(fp,"# Timestep {}\n#\n",ntimestep); - fmt::print(fp,"# Number of particles {}\n#\n",natoms); - fmt::print(fp,"# Max number of bonds per atom {} with coarse bond order cutoff {:5.3f}\n", + utils::print(fp,"# Timestep {}\n#\n",ntimestep); + utils::print(fp,"# Number of particles {}\n#\n",natoms); + utils::print(fp,"# Max number of bonds per atom {} with coarse bond order cutoff {:5.3f}\n", maxnum,cutof3); - fmt::print(fp,"# Particle connection table and bond orders\n" + utils::print(fp,"# Particle connection table and bond orders\n" "# id type nb id_1...id_nb mol bo_1...bo_nb abo nlp q\n"); } @@ -292,7 +292,7 @@ void FixReaxFFBonds::RecvBuffer(double *buf, int nbuf, int nbuf_local, j += (1+numbonds); mesg += fmt::format("{:14.3f}{:14.3f}{:14.3f}\n",sbotmp,nlptmp,avqtmp); - fmt::print(fp, mesg); + utils::print(fp, mesg); } } } else { diff --git a/src/REAXFF/fix_reaxff_species.cpp b/src/REAXFF/fix_reaxff_species.cpp index 4ef7799c24..09c3884c34 100644 --- a/src/REAXFF/fix_reaxff_species.cpp +++ b/src/REAXFF/fix_reaxff_species.cpp @@ -26,6 +26,7 @@ #include "domain.h" #include "error.h" #include "fix_ave_atom.h" +#include "fix_property_atom.h" #include "force.h" #include "group.h" #include "input.h" @@ -141,13 +142,6 @@ FixReaxFFSpecies::FixReaxFFSpecies(LAMMPS *lmp, int narg, char **arg) : } x0 = nullptr; - clusterID = nullptr; - - int ntmp = atom->nmax; - memory->create(x0, ntmp, "reaxff/species:x0"); - memory->create(clusterID, ntmp, "reaxff/species:clusterID"); - memset(clusterID, 0, sizeof(double) * ntmp); - vector_atom = clusterID; nmax = 0; setupflag = 0; @@ -304,7 +298,6 @@ FixReaxFFSpecies::FixReaxFFSpecies(LAMMPS *lmp, int narg, char **arg) : FixReaxFFSpecies::~FixReaxFFSpecies() { memory->destroy(BOCut); - memory->destroy(clusterID); memory->destroy(x0); memory->destroy(nd); @@ -330,6 +323,7 @@ FixReaxFFSpecies::~FixReaxFFSpecies() try { modify->delete_compute(fmt::format("SPECATOM_{}", id)); modify->delete_fix(fmt::format("SPECBOND_{}", id)); + modify->delete_fix(fmt::format("clusterID_{}", id)); } catch (std::exception &) { } } @@ -372,9 +366,6 @@ void FixReaxFFSpecies::init() reaxff->fixspecies_flag = 1; - // reset next output timestep if not yet set or timestep has been reset - if (nvalid != update->ntimestep) nvalid = update->ntimestep + nfreq; - if (!setupflag) { // create a compute to store properties modify->add_compute(fmt::format("SPECATOM_{} all SPEC/ATOM q x y z vx vy vz abo01 abo02 " @@ -387,11 +378,25 @@ void FixReaxFFSpecies::init() auto fixcmd = fmt::format("SPECBOND_{} all ave/atom {} {} {}", id, nevery, nrepeat, nfreq); for (int i = 1; i < 32; ++i) fixcmd += fmt::format(" c_SPECATOM_{}[{}]", id, i); f_SPECBOND = dynamic_cast(modify->add_fix(fixcmd)); + + // create a fix to point to fix_property_atom for storing clusterID + fixcmd = fmt::format("clusterID_{} all property/atom d_clusterID ghost yes", id); + f_clusterID = dynamic_cast(modify->add_fix(fixcmd)); + + // per-atom property for clusterID + int flag,cols; + int index1 = atom->find_custom("clusterID",flag,cols); + clusterID = atom->dvector[index1]; + vector_atom = clusterID; + + int ntmp = atom->nmax; + memory->create(x0, ntmp, "reaxff/species:x0"); + setupflag = 1; } // check for valid variable name for delete Nlimit keyword - if (delete_Nsteps > 0) { + if (delete_Nsteps > 0 && delete_Nlimit_varid > -1) { delete_Nlimit_varid = input->variable->find(delete_Nlimit_varname.c_str()); if (delete_Nlimit_varid < 0) error->all(FLERR, "Fix reaxff/species: Variable name {} does not exist", @@ -424,10 +429,16 @@ void FixReaxFFSpecies::Output_ReaxFF_Bonds(bigint ntimestep, FILE * /*fp*/) { int Nmole, Nspec; + // per-atom property for clusterID + int flag,cols; + int index1 = atom->find_custom("clusterID",flag,cols); + clusterID = atom->dvector[index1]; + vector_atom = clusterID; + // point to fix_ave_atom f_SPECBOND->end_of_step(); - if (ntimestep != nvalid) { + if (ntimestep != nvalid && nvalid != -1) { // push back delete_Tcount on every step if (delete_Nsteps > 0) for (int i = delete_Nsteps - 1; i > 0; i--) delete_Tcount[i] = delete_Tcount[i - 1]; @@ -439,11 +450,7 @@ void FixReaxFFSpecies::Output_ReaxFF_Bonds(bigint ntimestep, FILE * /*fp*/) if (atom->nmax > nmax) { nmax = atom->nmax; memory->destroy(x0); - memory->destroy(clusterID); memory->create(x0, nmax, "reaxff/species:x0"); - memory->create(clusterID, nmax, "reaxff/species:clusterID"); - memset(clusterID, 0, sizeof(double) * nmax); - vector_atom = clusterID; } for (int i = 0; i < nmax; i++) { x0[i].x = x0[i].y = x0[i].z = 0.0; } @@ -464,9 +471,14 @@ void FixReaxFFSpecies::Output_ReaxFF_Bonds(bigint ntimestep, FILE * /*fp*/) if (comm->me == 0) fflush(pos); } - if (delflag) DeleteSpecies(Nmole, Nspec); + if (delflag && nvalid != -1) { + DeleteSpecies(Nmole, Nspec); - nvalid += nfreq; + // reset molecule ID to index from 1 + SortMolecule(Nmole); + } + + nvalid = ntimestep + nfreq; } /* ---------------------------------------------------------------------- */ @@ -794,12 +806,12 @@ void FixReaxFFSpecies::WriteFormulas(int Nmole, int Nspec) if (itemp != 1) molname += std::to_string(itemp); } } - fmt::print(fp, " {:>11}", molname); + utils::print(fp, " {:>11}", molname); } fputs("\n", fp); - fmt::print(fp, "{:>11} {:>11} {:>11}", ntimestep, Nmole, Nspec); - for (i = 0; i < Nmoltype; i++) fmt::print(fp, " {:>11}", NMol[i]); + utils::print(fp, "{:>11} {:>11} {:>11}", ntimestep, Nmole, Nspec); + for (i = 0; i < Nmoltype; i++) utils::print(fp, " {:>11}", NMol[i]); fputs("\n", fp); } @@ -826,7 +838,8 @@ void FixReaxFFSpecies::WritePos(int Nmole, int Nspec) int count, count_tmp, m, n, k; int *Nameall; int *mask = atom->mask; - double avq, avq_tmp, avx[3], avx_tmp, box[3], halfbox[3]; + double *rmass = atom->rmass; + double totq, totq_tmp, com[3], com_tmp, thism, totm, box[3], halfbox[3]; double **spec_atom = f_SPECBOND->array_atom; if (multipos) OpenPos(); @@ -838,13 +851,13 @@ void FixReaxFFSpecies::WritePos(int Nmole, int Nspec) for (int j = 0; j < 3; j++) halfbox[j] = box[j] / 2; if (comm->me == 0) { - fmt::print(pos, + utils::print(pos, "Timestep {} NMole {} NSpec {} xlo {:f} " "xhi {:f} ylo {:f} yhi {:f} zlo {:f} zhi {:f}\n", update->ntimestep, Nmole, Nspec, domain->boxlo[0], domain->boxhi[0], domain->boxlo[1], domain->boxhi[1], domain->boxlo[2], domain->boxhi[2]); - fprintf(pos, "ID\tAtom_Count\tType\tAve_q\t\tCoM_x\t\tCoM_y\t\tCoM_z\n"); + fprintf(pos, "ID\tAtom_Count\tType\tTot_q\t\tCoM_x\t\tCoM_y\t\tCoM_z\n"); } Nameall = nullptr; @@ -853,8 +866,9 @@ void FixReaxFFSpecies::WritePos(int Nmole, int Nspec) for (m = 1; m <= Nmole; m++) { count = 0; - avq = 0.0; - for (n = 0; n < 3; n++) avx[n] = 0.0; + totq = 0.0; + totm = 0.0; + for (n = 0; n < 3; n++) com[n] = 0.0; for (n = 0; n < nutypes; n++) Name[n] = 0; for (i = 0; i < nlocal; i++) { @@ -864,30 +878,37 @@ void FixReaxFFSpecies::WritePos(int Nmole, int Nspec) itype = ele2uele[atom->type[i] - 1]; Name[itype]++; count++; - avq += spec_atom[i][0]; + totq += spec_atom[i][0]; if ((x0[i].x - spec_atom[i][1]) > halfbox[0]) spec_atom[i][1] += box[0]; if ((spec_atom[i][1] - x0[i].x) > halfbox[0]) spec_atom[i][1] -= box[0]; if ((x0[i].y - spec_atom[i][2]) > halfbox[1]) spec_atom[i][2] += box[1]; if ((spec_atom[i][2] - x0[i].y) > halfbox[1]) spec_atom[i][2] -= box[1]; if ((x0[i].z - spec_atom[i][3]) > halfbox[2]) spec_atom[i][3] += box[2]; if ((spec_atom[i][3] - x0[i].z) > halfbox[2]) spec_atom[i][3] -= box[2]; - for (n = 0; n < 3; n++) avx[n] += spec_atom[i][n + 1]; + if (rmass) thism = rmass[i]; + else thism = atom->mass[atom->type[i]]; + for (n = 0; n < 3; n++) com[n] += spec_atom[i][n+1]*thism; + totm += thism; } } - avq_tmp = 0.0; - MPI_Allreduce(&avq, &avq_tmp, 1, MPI_DOUBLE, MPI_SUM, world); - avq = avq_tmp; + totq_tmp = 0.0; + MPI_Allreduce(&totq, &totq_tmp, 1, MPI_DOUBLE, MPI_SUM, world); + totq = totq_tmp; for (n = 0; n < 3; n++) { - avx_tmp = 0.0; - MPI_Reduce(&avx[n], &avx_tmp, 1, MPI_DOUBLE, MPI_SUM, 0, world); - avx[n] = avx_tmp; + com_tmp = 0.0; + MPI_Reduce(&com[n], &com_tmp, 1, MPI_DOUBLE, MPI_SUM, 0, world); + com[n] = com_tmp; } MPI_Reduce(&count, &count_tmp, 1, MPI_INT, MPI_SUM, 0, world); count = count_tmp; + com_tmp = 0.0; + MPI_Reduce(&totm, &com_tmp, 1, MPI_DOUBLE, MPI_SUM, 0, world); + totm = com_tmp; + MPI_Reduce(Name, Nameall, nutypes, MPI_INT, MPI_SUM, 0, world); for (n = 0; n < nutypes; n++) Name[n] = Nameall[n]; @@ -900,16 +921,15 @@ void FixReaxFFSpecies::WritePos(int Nmole, int Nspec) } } if (count > 0) { - avq /= count; for (k = 0; k < 3; k++) { - avx[k] /= count; - if (avx[k] >= domain->boxhi[k]) avx[k] -= box[k]; - if (avx[k] < domain->boxlo[k]) avx[k] += box[k]; + com[k] /= totm; + if (com[k] >= domain->boxhi[k]) com[k] -= box[k]; + if (com[k] < domain->boxlo[k]) com[k] += box[k]; - avx[k] -= domain->boxlo[k]; - avx[k] /= box[k]; + com[k] -= domain->boxlo[k]; + com[k] /= box[k]; } - fprintf(pos, "\t%.8f \t%.8f \t%.8f \t%.8f", avq, avx[0], avx[1], avx[2]); + fprintf(pos, "\t%.8f \t%.8f \t%.8f \t%.8f", totq, com[0], com[1], com[2]); } fprintf(pos, "\n"); } @@ -922,21 +942,29 @@ void FixReaxFFSpecies::WritePos(int Nmole, int Nspec) void FixReaxFFSpecies::DeleteSpecies(int Nmole, int Nspec) { - int ndeletions; + int i, ndeletions; int headroom = -1; if (delete_Nsteps > 0) { - if (delete_Tcount[delete_Nsteps - 1] == -1) return; + if (delete_Tcount[delete_Nsteps - 1] == -1) { + for (i = delete_Nsteps - 1; i > 0; i--) delete_Tcount[i] = delete_Tcount[i - 1]; + return; + } ndeletions = delete_Tcount[0] - delete_Tcount[delete_Nsteps - 1]; if (delete_Nlimit_varid > -1) delete_Nlimit = input->variable->compute_equal(delete_Nlimit_varid); headroom = MAX(0, delete_Nlimit - ndeletions); - if (headroom == 0) return; + if (headroom == 0) { + for (i = delete_Nsteps - 1; i > 0; i--) delete_Tcount[i] = delete_Tcount[i - 1]; + return; + } } - int i, j, m, n, itype, cid; + int j, m, n, itype, cid; int ndel, ndelone, count, count_tmp; int *Nameall; int *mask = atom->mask; + double *mass = atom->mass; + double *rmass = atom->rmass; double localmass, totalmass; std::string species_str; @@ -989,7 +1017,8 @@ void FixReaxFFSpecies::DeleteSpecies(int Nmole, int Nspec) Name[itype]++; count++; marklist[nmarklist++] = i; - localmass += atom->mass[atom->type[i]]; + if (rmass) localmass += rmass[i]; + else localmass += atom->mass[atom->type[i]]; } } @@ -1062,7 +1091,7 @@ void FixReaxFFSpecies::DeleteSpecies(int Nmole, int Nspec) for (int m = 0; m < Nspec; m++) { if (deletecount[m] > 0) { if (printflag == 0) { - fmt::print(fdel, "Timestep {}", update->ntimestep); + utils::print(fdel, "Timestep {}", update->ntimestep); printflag = 1; } fprintf(fdel, " %g ", deletecount[m]); @@ -1085,7 +1114,7 @@ void FixReaxFFSpecies::DeleteSpecies(int Nmole, int Nspec) if (deletecount[i]) writeflag = 1; if (writeflag) { - fmt::print(fdel, "{}", update->ntimestep); + utils::print(fdel, "{}", update->ntimestep); for (i = 0; i < ndelspec; i++) { fprintf(fdel, "\t%g", deletecount[i]); } fprintf(fdel, "\n"); fflush(fdel); @@ -1177,7 +1206,7 @@ double FixReaxFFSpecies::memory_usage() { double bytes; - bytes = 4 * nmax * sizeof(double); // clusterID + x0 + bytes = 3 * nmax * sizeof(double); // x0 return bytes; } diff --git a/src/REAXFF/fix_reaxff_species.h b/src/REAXFF/fix_reaxff_species.h index b9afc5466a..d378065a82 100644 --- a/src/REAXFF/fix_reaxff_species.h +++ b/src/REAXFF/fix_reaxff_species.h @@ -88,6 +88,7 @@ class FixReaxFFSpecies : public Fix { class NeighList *list; class FixAveAtom *f_SPECBOND; + class FixPropertyAtom *f_clusterID; class PairReaxFF *reaxff; }; } // namespace LAMMPS_NS diff --git a/src/REAXFF/reaxff_control.cpp b/src/REAXFF/reaxff_control.cpp index 99e498b428..2d700e1eec 100644 --- a/src/REAXFF/reaxff_control.cpp +++ b/src/REAXFF/reaxff_control.cpp @@ -57,8 +57,8 @@ namespace ReaxFF { class control_parser_error : public std::exception { std::string message; public: - explicit control_parser_error(const std::string &format, const std::string &keyword) { - message = fmt::format(format, keyword); + explicit control_parser_error(const std::string &msg) { + message = msg; } const char *what() const noexcept override { return message.c_str(); } }; @@ -92,11 +92,11 @@ namespace ReaxFF { auto keyword = values.next_string(); if (!values.has_next()) - throw control_parser_error("No value(s) for control parameter: {}\n", keyword); + throw control_parser_error( + fmt::format("No value(s) for control parameter: {}\n", keyword)); if (inactive_keywords.find(keyword) != inactive_keywords.end()) { - error->warning(FLERR,fmt::format("Ignoring inactive control " - "parameter: {}",keyword)); + error->warning(FLERR,fmt::format("Ignoring inactive control parameter: {}", keyword)); } else if (keyword == "nbrhood_cutoff") { control->bond_cut = values.next_double(); } else if (keyword == "bond_graph_cutoff") { @@ -114,7 +114,7 @@ namespace ReaxFF { error->warning(FLERR,"Support for writing native trajectories has " "been removed after LAMMPS version 8 April 2021"); } else { - throw control_parser_error("Unknown parameter {} in control file", keyword); + throw control_parser_error(fmt::format("Unknown parameter {} in control file", keyword)); } } } catch (LAMMPS_NS::EOFException &) { diff --git a/src/REPLICA/fix_alchemy.cpp b/src/REPLICA/fix_alchemy.cpp index f3b79d0956..69a2c3f36a 100644 --- a/src/REPLICA/fix_alchemy.cpp +++ b/src/REPLICA/fix_alchemy.cpp @@ -242,8 +242,8 @@ void FixAlchemy::setup(int vflag) if (universe->me == 0) { progress = 0; auto msg = fmt::format("Starting alchemical run\n"); - if (universe->uscreen) fmt::print(universe->uscreen, msg); - if (universe->ulogfile) fmt::print(universe->ulogfile, msg); + if (universe->uscreen) utils::print(universe->uscreen, msg); + if (universe->ulogfile) utils::print(universe->ulogfile, msg); } // recheck domain decomposition, atom ordering, and synchronize positions @@ -325,8 +325,8 @@ void FixAlchemy::post_force(int /*vflag*/) if ((status / 10) > (progress / 10)) { progress = status; auto msg = fmt::format(" Alchemical run progress: {:>3d}%\n", progress); - if (universe->uscreen) fmt::print(universe->uscreen, msg); - if (universe->ulogfile) fmt::print(universe->ulogfile, msg); + if (universe->uscreen) utils::print(universe->uscreen, msg); + if (universe->ulogfile) utils::print(universe->ulogfile, msg); } } } diff --git a/src/REPLICA/neb.cpp b/src/REPLICA/neb.cpp index b14748565b..4b242965c8 100644 --- a/src/REPLICA/neb.cpp +++ b/src/REPLICA/neb.cpp @@ -241,19 +241,19 @@ void NEB::run() if (me_universe == 0) { if (uscreen) { - fmt::print(uscreen, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", + utils::print(uscreen, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", "MaxReplicaForce", "MaxAtomForce", "GradV0", "GradV1", "GradVc", "EBF", "EBR", "RDT"); if (print_mode != TERSE) { for (int i = 1; i <= nreplica; ++i) - fmt::print(uscreen, "{:^14} {:^14} ", "RD" + std::to_string(i), "PE" + std::to_string(i)); + utils::print(uscreen, "{:^14} {:^14} ", "RD" + std::to_string(i), "PE" + std::to_string(i)); } if (print_mode == VERBOSE) { for (int i = 1; i <= nreplica; ++i) { auto idx = std::to_string(i); - fmt::print(uscreen, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, + utils::print(uscreen, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, "angletangrad" + idx, "anglegrad" + idx, "gradV" + idx, "RepForce" + idx, "MaxAtomForce" + idx); } @@ -262,20 +262,20 @@ void NEB::run() } if (ulogfile) { - fmt::print(ulogfile, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", + utils::print(ulogfile, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", "MaxReplicaForce", "MaxAtomForce", "GradV0", "GradV1", "GradVc", "EBF", "EBR", "RDT"); if (print_mode != TERSE) { for (int i = 1; i <= nreplica; ++i) - fmt::print(ulogfile, "{:^14} {:^14} ", "RD" + std::to_string(i), + utils::print(ulogfile, "{:^14} {:^14} ", "RD" + std::to_string(i), "PE" + std::to_string(i)); } if (print_mode == VERBOSE) { for (int i = 1; i <= nreplica; ++i) { auto idx = std::to_string(i); - fmt::print(ulogfile, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, + utils::print(ulogfile, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, "angletangrad" + idx, "anglegrad" + idx, "gradV" + idx, "RepForce" + idx, "MaxAtomForce" + idx); } @@ -340,19 +340,19 @@ void NEB::run() if (me_universe == 0) { if (uscreen) { - fmt::print(uscreen, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", + utils::print(uscreen, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", "MaxReplicaForce", "MaxAtomForce", "GradV0", "GradV1", "GradVc", "EBF", "EBR", "RDT"); if (print_mode != TERSE) { for (int i = 1; i <= nreplica; ++i) - fmt::print(uscreen, "{:^14} {:^14} ", "RD" + std::to_string(i), "PE" + std::to_string(i)); + utils::print(uscreen, "{:^14} {:^14} ", "RD" + std::to_string(i), "PE" + std::to_string(i)); } if (print_mode == VERBOSE) { for (int i = 1; i <= nreplica; ++i) { auto idx = std::to_string(i); - fmt::print(uscreen, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, + utils::print(uscreen, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, "angletangrad" + idx, "anglegrad" + idx, "gradV" + idx, "RepForce" + idx, "MaxAtomForce" + idx); } @@ -361,20 +361,20 @@ void NEB::run() } if (ulogfile) { - fmt::print(ulogfile, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", + utils::print(ulogfile, " Step {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} {:^14} ", "MaxReplicaForce", "MaxAtomForce", "GradV0", "GradV1", "GradVc", "EBF", "EBR", "RDT"); if (print_mode != TERSE) { for (int i = 1; i <= nreplica; ++i) - fmt::print(ulogfile, "{:^14} {:^14} ", "RD" + std::to_string(i), + utils::print(ulogfile, "{:^14} {:^14} ", "RD" + std::to_string(i), "PE" + std::to_string(i)); } if (print_mode == VERBOSE) { for (int i = 1; i <= nreplica; ++i) { auto idx = std::to_string(i); - fmt::print(ulogfile, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, + utils::print(ulogfile, "{:^12}{:^12}{:^12} {:^12} {:^12}{:^12} ", "pathangle" + idx, "angletangrad" + idx, "anglegrad" + idx, "gradV" + idx, "RepForce" + idx, "MaxAtomForce" + idx); } diff --git a/src/REPLICA/prd.cpp b/src/REPLICA/prd.cpp index 252f74a4e3..91150d8a38 100644 --- a/src/REPLICA/prd.cpp +++ b/src/REPLICA/prd.cpp @@ -417,8 +417,8 @@ void PRD::command(int narg, char **arg) if (me_universe == 0) { auto mesg = fmt::format("Loop time of {} on {} procs for {} steps with {} atoms\n", timer->get_wall(Timer::TOTAL), nprocs_universe, nsteps,atom->natoms); - if (universe->uscreen) fmt::print(universe->uscreen, mesg); - if (universe->ulogfile) fmt::print(universe->ulogfile, mesg); + if (universe->uscreen) utils::print(universe->uscreen, mesg); + if (universe->ulogfile) utils::print(universe->ulogfile, mesg); } if (me == 0) utils::logmesg(lmp,"\nPRD done\n"); @@ -725,8 +725,8 @@ void PRD::log_event() fix_event->event_number, fix_event->correlated_event, fix_event->ncoincident, fix_event->replica_number); - if (universe->uscreen) fmt::print(universe->uscreen, mesg); - if (universe->ulogfile) fmt::print(universe->ulogfile, mesg); + if (universe->uscreen) utils::print(universe->uscreen, mesg); + if (universe->ulogfile) utils::print(universe->ulogfile, mesg); } } diff --git a/src/REPLICA/tad.cpp b/src/REPLICA/tad.cpp index b9b04a63d5..38ddfceb84 100644 --- a/src/REPLICA/tad.cpp +++ b/src/REPLICA/tad.cpp @@ -366,8 +366,8 @@ void TAD::command(int narg, char **arg) if (me_universe == 0) { auto mesg = fmt::format("Loop time of {} on {} procs for {} steps with {} atoms\n", timer->get_wall(Timer::TOTAL), nprocs_universe, nsteps,atom->natoms); - if (universe->uscreen) fmt::print(universe->uscreen, mesg); - if (universe->ulogfile) fmt::print(universe->ulogfile, mesg); + if (universe->uscreen) utils::print(universe->uscreen, mesg); + if (universe->ulogfile) utils::print(universe->ulogfile, mesg); } if ((me_universe == 0) && ulogfile_neb) fclose(ulogfile_neb); @@ -504,8 +504,8 @@ void TAD::log_event(int ievent) fix_event->event_number, ievent, "E ", fix_event->ebarrier, tfrac, fix_event->tlo, deltfirst); - if (universe->uscreen) fmt::print(universe->uscreen, mesg); - if (universe->ulogfile) fmt::print(universe->ulogfile, mesg); + if (universe->uscreen) utils::print(universe->uscreen, mesg); + if (universe->ulogfile) utils::print(universe->ulogfile, mesg); } // dump snapshot of quenched coords @@ -895,8 +895,8 @@ void TAD::compute_tlo(int ievent) fix_event->event_number, ievent, statstr, ebarrier, tfrac, fix_event->tlo, deltlo); - if (universe->uscreen) fmt::print(universe->uscreen, mesg); - if (universe->ulogfile) fmt::print(universe->ulogfile, mesg); + if (universe->uscreen) utils::print(universe->uscreen, mesg); + if (universe->ulogfile) utils::print(universe->ulogfile, mesg); } } diff --git a/src/RHEO/compute_rheo_interface.cpp b/src/RHEO/compute_rheo_interface.cpp index bbc00bd8d8..9c92e21166 100644 --- a/src/RHEO/compute_rheo_interface.cpp +++ b/src/RHEO/compute_rheo_interface.cpp @@ -114,7 +114,7 @@ void ComputeRHEOInterface::init_list(int /*id*/, NeighList *ptr) void ComputeRHEOInterface::compute_peratom() { - int a, i, j, ii, jj, jnum, itype, jtype, fluidi, fluidj, status_match; + int a, i, j, ii, jj, jnum, itype, fluidi, fluidj, status_match; double xtmp, ytmp, ztmp, rsq, w, dot, dx[3]; int inum, *ilist, *jlist, *numneigh, **firstneigh; @@ -166,7 +166,6 @@ void ComputeRHEOInterface::compute_peratom() rsq = lensq3(dx); if (rsq < cutsq) { - jtype = type[j]; fluidj = !(status[j] & PHASECHECK); w = compute_kernel->calc_w_quintic(sqrt(rsq)); diff --git a/src/RHEO/compute_rheo_property_atom.cpp b/src/RHEO/compute_rheo_property_atom.cpp index 4805c21903..6d122a2ec1 100644 --- a/src/RHEO/compute_rheo_property_atom.cpp +++ b/src/RHEO/compute_rheo_property_atom.cpp @@ -433,7 +433,6 @@ void ComputeRHEOPropertyAtom::pack_cv(int n) void ComputeRHEOPropertyAtom::pack_pressure(int n) { - int *type = atom->type; int *mask = atom->mask; double *rho = atom->rho; int nlocal = atom->nlocal; @@ -477,7 +476,6 @@ void ComputeRHEOPropertyAtom::pack_total_stress(int n) double **gradv = compute_grad->gradv; double *viscosity = atom->viscosity; double *rho = atom->rho; - int *type = atom->type; int *mask = atom->mask; int nlocal = atom->nlocal; int index = col_index[n]; diff --git a/src/RHEO/fix_rheo_pressure.cpp b/src/RHEO/fix_rheo_pressure.cpp index d972f19ffa..121473f7e3 100644 --- a/src/RHEO/fix_rheo_pressure.cpp +++ b/src/RHEO/fix_rheo_pressure.cpp @@ -273,11 +273,13 @@ double FixRHEOPressure::calc_rho(double p, int i) error->one(FLERR, "Rho calculation from pressure not yet supported for cubic pressure equation"); } else if (pressure_style[type] == TAITWATER) { - rho = pow(7.0 * p + csq[type] * rho0[type], SEVENTH); + double tmp = 7.0 * p + csq[type] * rho0[type]; + rho = pow(MAX(0.0, tmp), SEVENTH); rho *= pow(rho0[type], 6.0 * SEVENTH); rho *= pow(csq[type], -SEVENTH); } else if (pressure_style[type] == TAITGENERAL) { - rho = pow(tpower[type] * p + csq[type] * rho0[type], 1.0 / tpower[type]); + double tmp = tpower[type] * p + csq[type] * rho0[type]; + rho = pow(MAX(0.0, tmp), 1.0 / tpower[type]); rho *= pow(rho0[type], 1.0 - 1.0 / tpower[type]); rho *= pow(csq[type], -1.0 / tpower[type]); } else if (pressure_style[type] == IDEAL) { diff --git a/src/RIGID/fix_rigid.cpp b/src/RIGID/fix_rigid.cpp index 421a6cce2b..b0c6d46ee4 100644 --- a/src/RIGID/fix_rigid.cpp +++ b/src/RIGID/fix_rigid.cpp @@ -1,3 +1,4 @@ + /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -119,7 +120,7 @@ FixRigid::FixRigid(LAMMPS *lmp, int narg, char **arg) : int nlocal = atom->nlocal; int custom_flag = strcmp(arg[3], "custom") == 0; if (custom_flag) { - if (narg < 5) utils::missing_cmd_args(FLERR, fmt::format("fix {} custom"), error); + if (narg < 5) utils::missing_cmd_args(FLERR, fmt::format("fix {} custom", style), error); // determine whether atom-style variable or atom property is used @@ -219,11 +220,12 @@ FixRigid::FixRigid(LAMMPS *lmp, int narg, char **arg) : // error if atom belongs to more than 1 rigid body } else if (strcmp(arg[3], "group") == 0) { - if (narg < 5) utils::missing_cmd_args(FLERR, fmt::format("fix {} group"), error); + if (narg < 5) utils::missing_cmd_args(FLERR, fmt::format("fix {} group", style), error); rstyle = GROUP; nbody = utils::inumeric(FLERR, arg[4], false, lmp); if (nbody <= 0) error->all(FLERR, "Illegal fix {} number of groups {}", style, nbody); - if (narg < 5 + nbody) utils::missing_cmd_args(FLERR, fmt::format("fix {} group"), error); + if (narg < 5 + nbody) + utils::missing_cmd_args(FLERR, fmt::format("fix {} group", style), error); iarg = 5 + nbody; int *igroups = new int[nbody]; @@ -2435,8 +2437,8 @@ void FixRigid::write_restart_file(const char *file) if (fp == nullptr) error->one(FLERR,"Cannot open fix rigid restart file {}: {}",outfile,utils::getsyserror()); - fmt::print(fp,"# fix rigid mass, COM, inertia tensor info for {} bodies on timestep {}\n\n",nbody,update->ntimestep); - fmt::print(fp,"{}\n",nbody); + utils::print(fp,"# fix rigid mass, COM, inertia tensor info for {} bodies on timestep {}\n\n",nbody,update->ntimestep); + utils::print(fp,"{}\n",nbody); // compute I tensor against xyz axes from diagonalized I and current quat // Ispace = P Idiag P_transpose diff --git a/src/RIGID/fix_rigid_small.cpp b/src/RIGID/fix_rigid_small.cpp index 0bfd8032c5..6ba2e5eb1c 100644 --- a/src/RIGID/fix_rigid_small.cpp +++ b/src/RIGID/fix_rigid_small.cpp @@ -2625,9 +2625,9 @@ void FixRigidSmall::write_restart_file(const char *file) error->one(FLERR, "Cannot open fix {} restart file {}: {}", style, outfile, utils::getsyserror()); - fmt::print(fp,"# fix rigid mass, COM, inertia tensor info for " + utils::print(fp,"# fix rigid mass, COM, inertia tensor info for " "{} bodies on timestep {}\n\n",nbody,update->ntimestep); - fmt::print(fp,"{}\n",nbody); + utils::print(fp,"{}\n",nbody); } // communication buffer for all my rigid body info diff --git a/src/SPIN/neb_spin.cpp b/src/SPIN/neb_spin.cpp index b1b9dc077e..00b92b906a 100644 --- a/src/SPIN/neb_spin.cpp +++ b/src/SPIN/neb_spin.cpp @@ -805,7 +805,7 @@ void NEBSpin::print_status() FILE *uscreen = universe->uscreen; FILE *ulogfile = universe->ulogfile; if (uscreen) { - fmt::print(uscreen,"{} {:12.8g} {:12.8g} ",update->ntimestep,fmaxreplica,fmaxatom); + utils::print(uscreen,"{} {:12.8g} {:12.8g} ",update->ntimestep,fmaxreplica,fmaxatom); fprintf(uscreen,"%12.8g %12.8g %12.8g ",gradvnorm0,gradvnorm1,gradvnormc); fprintf(uscreen,"%12.8g %12.8g %12.8g ",ebf,ebr,endpt); for (int i = 0; i < nreplica; i++) @@ -819,7 +819,7 @@ void NEBSpin::print_status() } if (ulogfile) { - fmt::print(ulogfile,"{} {:12.8} {:12.8g} ",update->ntimestep,fmaxreplica,fmaxatom); + utils::print(ulogfile,"{} {:12.8} {:12.8g} ",update->ntimestep,fmaxreplica,fmaxatom); fprintf(ulogfile,"%12.8g %12.8g %12.8g ",gradvnorm0,gradvnorm1,gradvnormc); fprintf(ulogfile,"%12.8g %12.8g %12.8g ",ebf,ebr,endpt); for (int i = 0; i < nreplica; i++) diff --git a/src/SRD/fix_srd.cpp b/src/SRD/fix_srd.cpp index 9b153a1c28..6b8ce1e9d6 100644 --- a/src/SRD/fix_srd.cpp +++ b/src/SRD/fix_srd.cpp @@ -3956,7 +3956,7 @@ void FixSRD::print_collision(int i, int j, int ibounce, double t_remain, double double **v = atom->v; if (type != WALL) { - fmt::print("COLLISION between SRD {} and BIG {}\n", atom->tag[i], atom->tag[j]); + utils::print("COLLISION between SRD {} and BIG {}\n", atom->tag[i], atom->tag[j]); printf(" bounce # = %d\n", ibounce + 1); printf(" local indices: %d %d\n", i, j); printf(" timestep = %g\n", dt); @@ -3997,7 +3997,7 @@ void FixSRD::print_collision(int i, int j, int ibounce, double t_remain, double } else { int dim = wallwhich[j] / 2; - fmt::print("COLLISION between SRD {} and WALL {}\n", atom->tag[i], j); + utils::print("COLLISION between SRD {} and WALL {}\n", atom->tag[i], j); printf(" bounce # = %d\n", ibounce + 1); printf(" local indices: %d %d\n", i, j); printf(" timestep = %g\n", dt); diff --git a/src/UEF/dump_cfg_uef.cpp b/src/UEF/dump_cfg_uef.cpp index 776c4675f3..f2a9ae69aa 100644 --- a/src/UEF/dump_cfg_uef.cpp +++ b/src/UEF/dump_cfg_uef.cpp @@ -84,7 +84,7 @@ void DumpCFGUef::write_header(bigint n) if (atom->peri_flag) scale = atom->pdscale; else if (unwrapflag == 1) scale = UNWRAPEXPAND; - fmt::print(fp,"Number of particles = {}\n",n); + utils::print(fp,"Number of particles = {}\n",n); fprintf(fp,"A = %g Angstrom (basic length-scale)\n",scale); // in box[][] columns are cell edges // in H0, rows are cell edges diff --git a/src/angle_write.cpp b/src/angle_write.cpp index 1be5f1acac..863183995b 100644 --- a/src/angle_write.cpp +++ b/src/angle_write.cpp @@ -106,7 +106,7 @@ void AngleWrite::command(int narg, char **arg) utils::current_date()); fp = fopen(table_file.c_str(), "w"); if (fp) - fmt::print(fp, "# DATE: {} UNITS: {} Created by angle_write\n", utils::current_date(), + utils::print(fp, "# DATE: {} UNITS: {} Created by angle_write\n", utils::current_date(), update->unit_style); } if (fp == nullptr) @@ -173,9 +173,9 @@ void AngleWrite::command(int narg, char **arg) // evaluate energy and force at each of N distances - fmt::print(fp, "# Angle potential {} for angle type {}: i,theta,energy,force\n", + utils::print(fp, "# Angle potential {} for angle type {}: i,theta,energy,force\n", force->angle_style, atype); - fmt::print(fp, "\n{}\nN {} EQ {:.15g}\n\n", keyword, n, theta0); + utils::print(fp, "\n{}\nN {} EQ {:.15g}\n\n", keyword, n, theta0); #define GET_ENERGY(myphi, mytheta) \ theta = mytheta; \ diff --git a/src/atom_vec.cpp b/src/atom_vec.cpp index 0529d5cb54..bdcbc90997 100644 --- a/src/atom_vec.cpp +++ b/src/atom_vec.cpp @@ -1797,7 +1797,7 @@ void AtomVec::write_data(FILE *fp, int n, double **buf) int i, j, m, nn, datatype, cols; for (i = 0; i < n; i++) { - fmt::print(fp, "{}", ubuf(buf[i][0]).i); + utils::print(fp, "{}", ubuf(buf[i][0]).i); j = 1; for (nn = 1; nn < ndata_atom; nn++) { @@ -1805,30 +1805,30 @@ void AtomVec::write_data(FILE *fp, int n, double **buf) cols = mdata_atom.cols[nn]; if (datatype == Atom::DOUBLE) { if (cols == 0) { - fmt::print(fp, " {:.16}", buf[i][j++]); + utils::print(fp, " {:.16}", buf[i][j++]); } else { - for (m = 0; m < cols; m++) fmt::print(fp, " {}", buf[i][j++]); + for (m = 0; m < cols; m++) utils::print(fp, " {}", buf[i][j++]); } } else if (datatype == Atom::INT) { if (cols == 0) { if (atom->types_style == Atom::LABELS && atom->peratom[mdata_atom.index[nn]].name == "type") { - fmt::print(fp, " {}", atom->lmap->typelabel[ubuf(buf[i][j++]).i - 1]); + utils::print(fp, " {}", atom->lmap->typelabel[ubuf(buf[i][j++]).i - 1]); } else - fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + utils::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) utils::print(fp, " {}", ubuf(buf[i][j++]).i); } } else if (datatype == Atom::BIGINT) { if (cols == 0) { - fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + utils::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) utils::print(fp, " {}", ubuf(buf[i][j++]).i); } } } - fmt::print(fp, " {} {} {}\n", ubuf(buf[i][j]).i, ubuf(buf[i][j + 1]).i, ubuf(buf[i][j + 2]).i); + utils::print(fp, " {} {} {}\n", ubuf(buf[i][j]).i, ubuf(buf[i][j + 1]).i, ubuf(buf[i][j + 2]).i); } } @@ -1940,7 +1940,7 @@ void AtomVec::write_vel(FILE *fp, int n, double **buf) int i, j, m, nn, datatype, cols; for (i = 0; i < n; i++) { - fmt::print(fp, "{}", ubuf(buf[i][0]).i); + utils::print(fp, "{}", ubuf(buf[i][0]).i); j = 1; for (nn = 1; nn < ndata_vel; nn++) { @@ -1948,21 +1948,21 @@ void AtomVec::write_vel(FILE *fp, int n, double **buf) cols = mdata_vel.cols[nn]; if (datatype == Atom::DOUBLE) { if (cols == 0) { - fmt::print(fp, " {}", buf[i][j++]); + utils::print(fp, " {}", buf[i][j++]); } else { - for (m = 0; m < cols; m++) fmt::print(fp, " {}", buf[i][j++]); + for (m = 0; m < cols; m++) utils::print(fp, " {}", buf[i][j++]); } } else if (datatype == Atom::INT) { if (cols == 0) { - fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + utils::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) utils::print(fp, " {}", ubuf(buf[i][j++]).i); } } else if (datatype == Atom::BIGINT) { if (cols == 0) { - fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + utils::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) utils::print(fp, " {}", ubuf(buf[i][j++]).i); } } } @@ -2026,7 +2026,7 @@ void AtomVec::write_bond(FILE *fp, int n, tagint **buf, int index) for (int i = 0; i < n; i++) { typestr = std::to_string(buf[i][0]); if (atom->types_style == Atom::LABELS) typestr = atom->lmap->btypelabel[buf[i][0] - 1]; - fmt::print(fp, "{} {} {} {}\n", index, typestr, buf[i][1], buf[i][2]); + utils::print(fp, "{} {} {} {}\n", index, typestr, buf[i][1], buf[i][2]); index++; } } @@ -2091,7 +2091,7 @@ void AtomVec::write_angle(FILE *fp, int n, tagint **buf, int index) for (int i = 0; i < n; i++) { typestr = std::to_string(buf[i][0]); if (atom->types_style == Atom::LABELS) typestr = atom->lmap->atypelabel[buf[i][0] - 1]; - fmt::print(fp, "{} {} {} {} {}\n", index, typestr, buf[i][1], buf[i][2], buf[i][3]); + utils::print(fp, "{} {} {} {} {}\n", index, typestr, buf[i][1], buf[i][2], buf[i][3]); index++; } } @@ -2154,7 +2154,7 @@ void AtomVec::write_dihedral(FILE *fp, int n, tagint **buf, int index) for (int i = 0; i < n; i++) { typestr = std::to_string(buf[i][0]); if (atom->types_style == Atom::LABELS) typestr = atom->lmap->dtypelabel[buf[i][0] - 1]; - fmt::print(fp, "{} {} {} {} {} {}\n", index, typestr, buf[i][1], buf[i][2], buf[i][3], + utils::print(fp, "{} {} {} {} {} {}\n", index, typestr, buf[i][1], buf[i][2], buf[i][3], buf[i][4]); index++; } @@ -2218,7 +2218,7 @@ void AtomVec::write_improper(FILE *fp, int n, tagint **buf, int index) for (int i = 0; i < n; i++) { typestr = std::to_string(buf[i][0]); if (atom->types_style == Atom::LABELS) typestr = atom->lmap->itypelabel[buf[i][0] - 1]; - fmt::print(fp, "{} {} {} {} {} {}\n", index, typestr, buf[i][1], buf[i][2], buf[i][3], + utils::print(fp, "{} {} {} {} {} {}\n", index, typestr, buf[i][1], buf[i][2], buf[i][3], buf[i][4]); index++; } diff --git a/src/atom_vec_ellipsoid.cpp b/src/atom_vec_ellipsoid.cpp index 417c3cf5fa..cd54729798 100644 --- a/src/atom_vec_ellipsoid.cpp +++ b/src/atom_vec_ellipsoid.cpp @@ -530,7 +530,7 @@ void AtomVecEllipsoid::write_data_bonus(FILE *fp, int n, double *buf, int /*flag { int i = 0; while (i < n) { - fmt::print(fp, "{} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3], + utils::print(fp, "{} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3], buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7]); i += size_data_bonus; } diff --git a/src/atom_vec_line.cpp b/src/atom_vec_line.cpp index 6ec4836770..ef5056c93c 100644 --- a/src/atom_vec_line.cpp +++ b/src/atom_vec_line.cpp @@ -564,7 +564,7 @@ void AtomVecLine::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/) { int i = 0; while (i < n) { - fmt::print(fp, "{} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3], + utils::print(fp, "{} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3], buf[i + 4]); i += size_data_bonus; } diff --git a/src/atom_vec_tri.cpp b/src/atom_vec_tri.cpp index 888ed954fc..21e7682b32 100644 --- a/src/atom_vec_tri.cpp +++ b/src/atom_vec_tri.cpp @@ -780,7 +780,7 @@ void AtomVecTri::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/) { int i = 0; while (i < n) { - fmt::print(fp, "{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], + utils::print(fp, "{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3], buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7], buf[i + 8], buf[i + 9]); i += size_data_bonus; } diff --git a/src/balance.cpp b/src/balance.cpp index 42463752f9..fa4e68a8b8 100644 --- a/src/balance.cpp +++ b/src/balance.cpp @@ -1219,7 +1219,7 @@ void Balance::dumpout(bigint tstep) double *boxlo = domain->boxlo; double *boxhi = domain->boxhi; - fmt::print(fp,"ITEM: TIMESTEP\n{}\n",tstep); + utils::print(fp,"ITEM: TIMESTEP\n{}\n",tstep); fprintf(fp,"ITEM: NUMBER OF NODES\n"); if (dimension == 2) fprintf(fp,"%d\n",4*nprocs); else fprintf(fp,"%d\n",8*nprocs); @@ -1294,7 +1294,7 @@ void Balance::dumpout(bigint tstep) // write out one square/cube per processor for 2d/3d - fmt::print(fp,"ITEM: TIMESTEP\n{}\n",tstep); + utils::print(fp,"ITEM: TIMESTEP\n{}\n",tstep); if (dimension == 2) fprintf(fp,"ITEM: NUMBER OF SQUARES\n"); else fprintf(fp,"ITEM: NUMBER OF CUBES\n"); fprintf(fp,"%d\n",nprocs); @@ -1339,13 +1339,13 @@ void Balance::debug_shift_output(int idim, int m, int np, double *split) fprintf(stderr,"Dimension %s, Iteration %d\n",dim,m); fprintf(stderr," Count:"); - for (i = 0; i <= np; i++) fmt::print(stderr," {}",count[i]); + for (i = 0; i <= np; i++) utils::print(stderr," {}",count[i]); fprintf(stderr,"\n"); fprintf(stderr," Sum:"); - for (i = 0; i <= np; i++) fmt::print(stderr," {}",sum[i]); + for (i = 0; i <= np; i++) utils::print(stderr," {}",sum[i]); fprintf(stderr,"\n"); fprintf(stderr," Target:"); - for (i = 0; i <= np; i++) fmt::print(stderr," {}",target[i]); + for (i = 0; i <= np; i++) utils::print(stderr," {}",target[i]); fprintf(stderr,"\n"); fprintf(stderr," Actual cut:"); for (i = 0; i <= np; i++) @@ -1358,13 +1358,13 @@ void Balance::debug_shift_output(int idim, int m, int np, double *split) for (i = 0; i <= np; i++) fprintf(stderr," %g",lo[i]); fprintf(stderr,"\n"); fprintf(stderr," Low-sum:"); - for (i = 0; i <= np; i++) fmt::print(stderr," {}",losum[i]); + for (i = 0; i <= np; i++) utils::print(stderr," {}",losum[i]); fprintf(stderr,"\n"); fprintf(stderr," Hi:"); for (i = 0; i <= np; i++) fprintf(stderr," %g",hi[i]); fprintf(stderr,"\n"); fprintf(stderr," Hi-sum:"); - for (i = 0; i <= np; i++) fmt::print(stderr," {}",hisum[i]); + for (i = 0; i <= np; i++) utils::print(stderr," {}",hisum[i]); fprintf(stderr,"\n"); fprintf(stderr," Delta:"); for (i = 0; i < np; i++) fprintf(stderr," %g",split[i+1]-split[i]); diff --git a/src/bond.cpp b/src/bond.cpp index e0ca37aa73..f5af30062e 100644 --- a/src/bond.cpp +++ b/src/bond.cpp @@ -388,7 +388,7 @@ void Bond::write_file(int narg, char **arg) utils::current_date()); fp = fopen(table_file.c_str(), "w"); if (fp) - fmt::print(fp, "# DATE: {} UNITS: {} Created by bond_write\n", utils::current_date(), + utils::print(fp, "# DATE: {} UNITS: {} Created by bond_write\n", utils::current_date(), update->unit_style); } if (fp == nullptr) diff --git a/src/citeme.cpp b/src/citeme.cpp index 56ba7fa3a4..949ae38305 100644 --- a/src/citeme.cpp +++ b/src/citeme.cpp @@ -19,13 +19,13 @@ using namespace LAMMPS_NS; -static const char cite_separator[] = +static constexpr char cite_separator[] = "CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE\n\n"; -static const char cite_nagline[] = +static constexpr char cite_nagline[] = "Your simulation uses code contributions which should be cited:\n"; -static const char cite_file[] = "The {} {} lists these citations in BibTeX format.\n\n"; +static constexpr char cite_file[] = "The {} {} lists these citations in BibTeX format.\n\n"; // define hash function static std::hash get_hash; diff --git a/src/compute.cpp b/src/compute.cpp index d703cbfe6a..06f58e817b 100644 --- a/src/compute.cpp +++ b/src/compute.cpp @@ -137,19 +137,20 @@ void Compute::modify_params(int narg, char **arg) int iarg = 0; while (iarg < narg) { - // added more specific keywords in Mar17 - // at some point, remove generic extra and dynamic - if (strcmp(arg[iarg],"extra") == 0 || - strcmp(arg[iarg],"extra/dof") == 0) { - if (iarg+2 > narg) error->all(FLERR,"Illegal compute_modify command"); + if (strcmp(arg[iarg],"extra/dof") == 0) { + if (iarg+2 > narg) utils::missing_cmd_args(FLERR,"compute_modify extra/dof", error); extra_dof = utils::numeric(FLERR,arg[iarg+1],false,lmp); iarg += 2; - } else if (strcmp(arg[iarg],"dynamic") == 0 || - strcmp(arg[iarg],"dynamic/dof") == 0) { - if (iarg+2 > narg) error->all(FLERR,"Illegal compute_modify command"); + } else if (strcmp(arg[iarg],"dynamic/dof") == 0) { + if (iarg+2 > narg) utils::missing_cmd_args(FLERR,"compute_modify dynamic/dof", error); dynamic_user = utils::logical(FLERR,arg[iarg+1],false,lmp); iarg += 2; - } else error->all(FLERR,"Illegal compute_modify command"); + } else { + int n = modify_param(narg-iarg, &arg[iarg]); + if (n== 0) + error->all(FLERR, iarg + 1, "Compute {} {} does not support compute_modify {} command", + id, style, arg[iarg]); + } } } diff --git a/src/compute.h b/src/compute.h index 0b077d7695..870d9ae088 100644 --- a/src/compute.h +++ b/src/compute.h @@ -113,6 +113,7 @@ class Compute : protected Pointers { Compute(class LAMMPS *, int, char **); ~Compute() override; void modify_params(int, char **); + virtual int modify_param(int, char **) { return 0; } virtual void reset_extra_dof(); void init_flags(); diff --git a/src/compute_pressure.cpp b/src/compute_pressure.cpp index 2c90af5fc1..65cb612390 100644 --- a/src/compute_pressure.cpp +++ b/src/compute_pressure.cpp @@ -16,6 +16,7 @@ #include "angle.h" #include "atom.h" +#include "atom_masks.h" #include "bond.h" #include "dihedral.h" #include "domain.h" @@ -132,6 +133,11 @@ ComputePressure::ComputePressure(LAMMPS *lmp, int narg, char **arg) : vector = new double[size_vector]; nvirial = 0; vptr = nullptr; + + // KOKKOS + + datamask_read = EMPTY_MASK; + datamask_modify = EMPTY_MASK; } /* ---------------------------------------------------------------------- */ diff --git a/src/dihedral_write.cpp b/src/dihedral_write.cpp index 51041c46fc..11d283dc27 100644 --- a/src/dihedral_write.cpp +++ b/src/dihedral_write.cpp @@ -107,7 +107,7 @@ void DihedralWrite::command(int narg, char **arg) utils::current_date()); fp = fopen(table_file.c_str(), "w"); if (fp) - fmt::print(fp, "# DATE: {} UNITS: {} Created by dihedral_write\n", utils::current_date(), + utils::print(fp, "# DATE: {} UNITS: {} Created by dihedral_write\n", utils::current_date(), update->unit_style); } if (fp == nullptr) @@ -169,9 +169,9 @@ void DihedralWrite::command(int narg, char **arg) // evaluate energy and force at each of N distances - fmt::print(fp, "# Dihedral potential {} for dihedral type {}: i,theta,energy,force\n", + utils::print(fp, "# Dihedral potential {} for dihedral type {}: i,theta,energy,force\n", force->dihedral_style, dtype); - fmt::print(fp, "\n{}\nN {} DEGREES\n\n", keyword, n); + utils::print(fp, "\n{}\nN {} DEGREES\n\n", keyword, n); #define GET_ENERGY(myphi, mytheta) \ theta = mytheta; \ diff --git a/src/dump_atom.cpp b/src/dump_atom.cpp index 2238a3a81d..e81157b4ad 100644 --- a/src/dump_atom.cpp +++ b/src/dump_atom.cpp @@ -369,19 +369,19 @@ void DumpAtom::header_item(bigint ndump) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp, "ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); + utils::print(fp, "ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); - fmt::print(fp,"ITEM: BOX BOUNDS {}\n" + utils::print(fp,"ITEM: BOX BOUNDS {}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxylo,boxyhi,boxzlo,boxzhi); - fmt::print(fp,"ITEM: ATOMS {}\n",columns); + utils::print(fp,"ITEM: ATOMS {}\n",columns); } /* ---------------------------------------------------------------------- */ @@ -390,19 +390,19 @@ void DumpAtom::header_item_triclinic(bigint ndump) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp, "ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); + utils::print(fp, "ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); - fmt::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" + utils::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxxy,boxylo,boxyhi,boxxz,boxzlo,boxzhi,boxyz); - fmt::print(fp,"ITEM: ATOMS {}\n",columns); + utils::print(fp,"ITEM: ATOMS {}\n",columns); } /* ---------------------------------------------------------------------- */ @@ -411,13 +411,13 @@ void DumpAtom::header_item_triclinic_general(bigint ndump) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp,"ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); + utils::print(fp,"ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); - fmt::print(fp,"ITEM: BOX BOUNDS abc origin {}\n" + utils::print(fp,"ITEM: BOX BOUNDS abc origin {}\n" "{:>1.16e} {:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e} {:>1.16e}\n", @@ -426,7 +426,7 @@ void DumpAtom::header_item_triclinic_general(bigint ndump) domain->bvec[0],domain->bvec[1],domain->bvec[2],domain->boxlo[1], domain->cvec[0],domain->cvec[1],domain->cvec[2],domain->boxlo[2]); - fmt::print(fp,"ITEM: ATOMS {}\n",columns); + utils::print(fp,"ITEM: ATOMS {}\n",columns); } /* ---------------------------------------------------------------------- */ diff --git a/src/dump_cfg.cpp b/src/dump_cfg.cpp index 0d22ece2c3..d756977487 100644 --- a/src/dump_cfg.cpp +++ b/src/dump_cfg.cpp @@ -142,7 +142,7 @@ void DumpCFG::write_header(bigint n) header += fmt::format("auxiliary[{}] = {}\n",i-5,keyword_user[i]); else header += fmt::format("auxiliary[{}] = {}\n",i-5,auxname[i-5]); - fmt::print(fp, header); + utils::print(fp, header); } /* ---------------------------------------------------------------------- diff --git a/src/dump_custom.cpp b/src/dump_custom.cpp index fdba2e5477..dd53511e09 100644 --- a/src/dump_custom.cpp +++ b/src/dump_custom.cpp @@ -647,21 +647,21 @@ void DumpCustom::header_item(bigint ndump) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp,"ITEM: TIMESTEP\n{}\n" + utils::print(fp,"ITEM: TIMESTEP\n{}\n" "ITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); - fmt::print(fp,"ITEM: BOX BOUNDS {}\n" + utils::print(fp,"ITEM: BOX BOUNDS {}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxylo,boxyhi,boxzlo,boxzhi); - fmt::print(fp,"ITEM: ATOMS {}\n",columns); + utils::print(fp,"ITEM: ATOMS {}\n",columns); } /* ---------------------------------------------------------------------- */ @@ -670,21 +670,21 @@ void DumpCustom::header_item_triclinic(bigint ndump) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp,"ITEM: TIMESTEP\n{}\n" + utils::print(fp,"ITEM: TIMESTEP\n{}\n" "ITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); - fmt::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" + utils::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxxy,boxylo,boxyhi,boxxz,boxzlo,boxzhi,boxyz); - fmt::print(fp,"ITEM: ATOMS {}\n",columns); + utils::print(fp,"ITEM: ATOMS {}\n",columns); } /* ---------------------------------------------------------------------- */ @@ -693,13 +693,13 @@ void DumpCustom::header_item_triclinic_general(bigint ndump) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp,"ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); + utils::print(fp,"ITEM: TIMESTEP\n{}\nITEM: NUMBER OF ATOMS\n{}\n", update->ntimestep, ndump); - fmt::print(fp,"ITEM: BOX BOUNDS abc origin {}\n" + utils::print(fp,"ITEM: BOX BOUNDS abc origin {}\n" "{:>1.16e} {:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e} {:>1.16e}\n", @@ -708,7 +708,7 @@ void DumpCustom::header_item_triclinic_general(bigint ndump) domain->bvec[0],domain->bvec[1],domain->bvec[2],domain->boxlo[1], domain->cvec[0],domain->cvec[1],domain->cvec[2],domain->boxlo[2]); - fmt::print(fp,"ITEM: ATOMS {}\n",columns); + utils::print(fp,"ITEM: ATOMS {}\n",columns); } /* ---------------------------------------------------------------------- */ diff --git a/src/dump_grid.cpp b/src/dump_grid.cpp index b052712e95..2d3d9a105b 100644 --- a/src/dump_grid.cpp +++ b/src/dump_grid.cpp @@ -431,19 +431,19 @@ void DumpGrid::header_item(bigint /*ndump*/) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp,"ITEM: TIMESTEP\n{}\n",update->ntimestep); - fmt::print(fp,"ITEM: BOX BOUNDS {}\n" + utils::print(fp,"ITEM: TIMESTEP\n{}\n",update->ntimestep); + utils::print(fp,"ITEM: BOX BOUNDS {}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxylo,boxyhi,boxzlo,boxzhi); - fmt::print(fp,"ITEM: DIMENSION\n{}\n",domain->dimension); - fmt::print(fp,"ITEM: GRID SIZE nx ny nz\n{} {} {}\n",nxgrid,nygrid,nzgrid); - fmt::print(fp,"ITEM: GRID CELLS {}\n",columns); + utils::print(fp,"ITEM: DIMENSION\n{}\n",domain->dimension); + utils::print(fp,"ITEM: GRID SIZE nx ny nz\n{} {} {}\n",nxgrid,nygrid,nzgrid); + utils::print(fp,"ITEM: GRID CELLS {}\n",columns); } /* ---------------------------------------------------------------------- */ @@ -452,19 +452,19 @@ void DumpGrid::header_item_triclinic(bigint /*ndump*/) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp,"ITEM: TIMESTEP\n{}\n",update->ntimestep); - fmt::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" + utils::print(fp,"ITEM: TIMESTEP\n{}\n",update->ntimestep); + utils::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxxy,boxylo,boxyhi,boxxz,boxzlo,boxzhi,boxyz); - fmt::print(fp,"ITEM: DIMENSION\n{}\n",domain->dimension); - fmt::print(fp,"ITEM: GRID SIZE nx ny nz\n{} {} {}\n",nxgrid,nygrid,nzgrid); - fmt::print(fp,"ITEM: GRID CELLS {}\n",columns); + utils::print(fp,"ITEM: DIMENSION\n{}\n",domain->dimension); + utils::print(fp,"ITEM: GRID SIZE nx ny nz\n{} {} {}\n",nxgrid,nygrid,nzgrid); + utils::print(fp,"ITEM: GRID CELLS {}\n",columns); } /* ---------------------------------------------------------------------- */ diff --git a/src/dump_image.cpp b/src/dump_image.cpp index abf4d366d5..ee44db0945 100644 --- a/src/dump_image.cpp +++ b/src/dump_image.cpp @@ -124,7 +124,6 @@ DumpImage::DumpImage(LAMMPS *lmp, int narg, char **arg) : atomflag = YES; gridflag = NO; lineflag = triflag = bodyflag = fixflag = NO; - id_grid_compute = id_grid_fix = nullptr; if (atom->nbondtypes == 0) bondflag = NO; else { @@ -188,10 +187,13 @@ DumpImage::DumpImage(LAMMPS *lmp, int narg, char **arg) : igrid,idata,index,lmp); if (iflag < 0) error->all(FLERR,"Invalid grid reference in dump image command"); - delete[] id_grid_compute; - delete[] id_grid_fix; - if (iflag == ArgInfo::COMPUTE) id_grid_compute = utils::strdup(id); - else if (iflag == ArgInfo::FIX) id_grid_fix = utils::strdup(id); + if (iflag == ArgInfo::COMPUTE) { + delete[] id_grid_compute; + id_grid_compute = utils::strdup(id); + } else if (iflag == ArgInfo::FIX) { + delete[] id_grid_fix; + id_grid_fix = utils::strdup(id); + } delete[] id; grid_igrid = igrid; grid_idata = idata; @@ -465,15 +467,8 @@ DumpImage::DumpImage(LAMMPS *lmp, int narg, char **arg) : // local data - grid_compute = nullptr; - grid_fix = nullptr; - maxbufcopy = 0; - chooseghost = nullptr; - bufcopy = nullptr; - maxgrid = 0; - gbuf = nullptr; } /* ---------------------------------------------------------------------- */ diff --git a/src/dump_local.cpp b/src/dump_local.cpp index bcf2a3a757..7394ec4481 100644 --- a/src/dump_local.cpp +++ b/src/dump_local.cpp @@ -292,29 +292,29 @@ void DumpLocal::write_header(bigint ndump) if (me == 0) { if (unit_flag && !unit_count) { ++unit_count; - fmt::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); + utils::print(fp,"ITEM: UNITS\n{}\n",update->unit_style); } - if (time_flag) fmt::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); + if (time_flag) utils::print(fp,"ITEM: TIME\n{:.16}\n",compute_time()); - fmt::print(fp,"ITEM: TIMESTEP\n{}\n" + utils::print(fp,"ITEM: TIMESTEP\n{}\n" "ITEM: NUMBER OF {}\n{}\n", update->ntimestep, label, ndump); if (domain->triclinic) { - fmt::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" + utils::print(fp,"ITEM: BOX BOUNDS xy xz yz {}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxxy,boxylo,boxyhi,boxxz,boxzlo,boxzhi,boxyz); } else { - fmt::print(fp,"ITEM: BOX BOUNDS {}\n" + utils::print(fp,"ITEM: BOX BOUNDS {}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n" "{:>1.16e} {:>1.16e}\n", boundstr,boxxlo,boxxhi,boxylo,boxyhi,boxzlo,boxzhi); } - fmt::print(fp,"ITEM: {} {}\n", label, columns); + utils::print(fp,"ITEM: {} {}\n", label, columns); } } diff --git a/src/dump_xyz.cpp b/src/dump_xyz.cpp index 84a8ead6fd..69892888bc 100644 --- a/src/dump_xyz.cpp +++ b/src/dump_xyz.cpp @@ -161,8 +161,7 @@ void DumpXYZ::write_header(bigint n) auto header = fmt::format("{}\n Atoms. Timestep: {}", n, update->ntimestep); if (time_flag) header += fmt::format(" Time: {:.6f}", compute_time()); - header += "\n"; - fmt::print(fp, header); + utils::print(fp, header + "\n"); } } diff --git a/src/error.cpp b/src/error.cpp index 6dbd0a20b3..946cc19fd6 100644 --- a/src/error.cpp +++ b/src/error.cpp @@ -85,6 +85,7 @@ void Error::universe_one(const std::string &file, int line, const std::string &s std::string mesg = fmt::format("ERROR on proc {}: {} ({}:{})\n", universe->me,str,truncpath(file),line); if (universe->uscreen) fputs(mesg.c_str(),universe->uscreen); + utils::flush_buffers(lmp); // allow commands if an exception was caught in a run // update may be a null pointer when catching command-line errors @@ -103,7 +104,7 @@ void Error::universe_warn(const std::string &file, int line, const std::string & ++numwarn; if ((maxwarn != 0) && ((numwarn > maxwarn) || (allwarn > maxwarn) || (maxwarn < 0))) return; if (universe->uscreen) - fmt::print(universe->uscreen,"WARNING on proc {}: {} ({}:{})\n", + utils::print(universe->uscreen,"WARNING on proc {}: {} ({}:{})\n", universe->me,str,truncpath(file),line); } @@ -118,13 +119,19 @@ void Error::all(const std::string &file, int line, int failed, const std::string { MPI_Barrier(world); + // must get rank from communicator since "comm" instance may not yet exist + + int me = 0; + MPI_Comm_rank(world, &me); + std::string lastcmd = "(unknown)"; std::string mesg = "ERROR: " + str + fmt::format(" ({}:{})\n", truncpath(file), line); // add text about the input following the error message if (failed > NOLASTLINE) mesg += utils::point_to_error(input, failed); - if (comm->me == 0) utils::logmesg(lmp,mesg); + if (me == 0) utils::logmesg(lmp,mesg); + utils::flush_buffers(lmp); // allow commands if an exception was caught in a run // update may be a null pointer when catching command-line errors @@ -148,8 +155,12 @@ void Error::one(const std::string &file, int line, int failed, const std::string { std::string lastcmd = "(unknown)"; - std::string mesg = fmt::format("ERROR on proc {}: {} ({}:{})\n", comm->me, str, - truncpath(file), line); + // must get rank from communicator since "comm" instance may not yet exist + + int me = 0; + MPI_Comm_rank(world, &me); + + std::string mesg = fmt::format("ERROR on proc {}: {} ({}:{})\n", me, str, truncpath(file), line); if (failed > NOPOINTER) mesg += utils::point_to_error(input, failed); utils::logmesg(lmp,mesg); @@ -157,6 +168,7 @@ void Error::one(const std::string &file, int line, int failed, const std::string if (universe->uscreen) fputs(mesg.c_str(),universe->uscreen); + utils::flush_buffers(lmp); // allow commands if an exception was caught in a run // update may be a null pointer when catching command-line errors @@ -255,6 +267,7 @@ void Error::_message(const std::string &file, int line, fmt::string_view format, void Error::done(int status) { + utils::flush_buffers(lmp); MPI_Barrier(world); if (output) delete output; diff --git a/src/fix_ave_chunk.cpp b/src/fix_ave_chunk.cpp index 6a3c2e2032..f5dc36eac9 100644 --- a/src/fix_ave_chunk.cpp +++ b/src/fix_ave_chunk.cpp @@ -902,7 +902,7 @@ void FixAveChunk::end_of_step() if (overwrite) (void) platform::fseek(fp,filepos); double count = 0.0; for (m = 0; m < nchunk; m++) count += count_total[m]; - fmt::print(fp,"{} {} {}\n",ntimestep,nchunk,count); + utils::print(fp,"{} {} {}\n",ntimestep,nchunk,count); int compress = cchunk->compress; int *chunkID = cchunk->chunkID; diff --git a/src/fix_ave_correlate.cpp b/src/fix_ave_correlate.cpp index 08cd673122..a99ffd3d68 100644 --- a/src/fix_ave_correlate.cpp +++ b/src/fix_ave_correlate.cpp @@ -466,7 +466,7 @@ void FixAveCorrelate::end_of_step() if (fp && comm->me == 0) { clearerr(fp); if (overwrite) platform::fseek(fp,filepos); - fmt::print(fp,"{} {}\n",ntimestep,nrepeat); + utils::print(fp,"{} {}\n",ntimestep,nrepeat); for (i = 0; i < nrepeat; i++) { fprintf(fp,"%d %d %d",i+1,i*nevery,count[i]); if (count[i]) diff --git a/src/fix_ave_histo.cpp b/src/fix_ave_histo.cpp index 35fd3fc4f9..b990f46997 100644 --- a/src/fix_ave_histo.cpp +++ b/src/fix_ave_histo.cpp @@ -42,7 +42,7 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg), nvalues(0), fp(nullptr), stats_list(nullptr), bin(nullptr), bin_total(nullptr), bin_all(nullptr), bin_list(nullptr), coord(nullptr), vector(nullptr) { - auto mycmd = fmt::format("fix {}", style); + const auto mycmd = fmt::format("fix {}", style); if (narg < 10) utils::missing_cmd_args(FLERR, mycmd, error); nevery = utils::inumeric(FLERR, arg[3], false, lmp); @@ -67,8 +67,9 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : // then read options so know mode = SCALAR/VECTOR before re-reading values nvalues = 0; - - int iarg = 9; + // the first 9 arguments have fixed positions + const int ioffset = 9; + int iarg = ioffset; while (iarg < narg) { if (strcmp(arg[iarg],"x") == 0 || strcmp(arg[iarg],"y") == 0 || @@ -87,7 +88,9 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : } else break; } - if (nvalues == 0) error->all(FLERR,"No values in {} command", mycmd); + if (nvalues == 0) + error->all(FLERR, ioffset, + "No values in from computes, fixes, or variables used in {} command", mycmd); options(iarg,narg,arg); @@ -96,9 +99,10 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : int expand = 0; char **earg; - nvalues = utils::expand_args(FLERR, nvalues, &arg[9], mode, earg, lmp); + int *amap = nullptr; + nvalues = utils::expand_args(FLERR, nvalues, &arg[ioffset], mode, earg, lmp, &amap); - if (earg != &arg[9]) expand = 1; + if (earg != &arg[ioffset]) expand = 1; arg = earg; // parse values @@ -113,42 +117,62 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : if (strcmp(arg[i],"x") == 0) { val.which = ArgInfo::X; val.argindex = 0; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"y") == 0) { val.which = ArgInfo::X; val.argindex = 1; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"z") == 0) { val.which = ArgInfo::X; val.argindex = 2; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"vx") == 0) { val.which = ArgInfo::V; val.argindex = 0; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"vy") == 0) { val.which = ArgInfo::V; val.argindex = 1; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"vz") == 0) { val.which = ArgInfo::V; val.argindex = 2; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"fx") == 0) { val.which = ArgInfo::F; val.argindex = 0; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"fy") == 0) { val.which = ArgInfo::F; val.argindex = 1; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else if (strcmp(arg[i],"fz") == 0) { val.which = ArgInfo::F; val.argindex = 2; + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; } else { ArgInfo argi(arg[i]); if (argi.get_type() == ArgInfo::NONE) break; if ((argi.get_type() == ArgInfo::UNKNOWN) || (argi.get_dim() > 1)) - error->all(FLERR,"Invalid {} argument: {}", mycmd, arg[i]); + error->all(FLERR, amap[i] + ioffset, "Invalid {} argument: {}", mycmd, arg[i]); val.which = argi.get_type(); val.argindex = argi.get_index1(); + if (expand) val.iarg = amap[i] + ioffset; + else val.iarg = i + ioffset; val.id = argi.get_name(); } values.push_back(val); @@ -156,24 +180,17 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : if (nvalues != (int)values.size()) error->all(FLERR, "Could not parse value data consistently for {}", mycmd); - // if wildcard expansion occurred, free earg memory from expand_args() - - if (expand) { - for (int i = 0; i < nvalues; i++) delete[] earg[i]; - memory->sfree(earg); - } - // check input args for kind consistency // inputs must all be all either global, per-atom, or local if (nevery <= 0) - error->all(FLERR,"Illegal {} nevery value: {}", mycmd, nevery); + error->all(FLERR, 3, "Illegal {} nevery value: {}", mycmd, nevery); if (nrepeat <= 0) - error->all(FLERR,"Illegal {} nrepeat value: {}", mycmd, nrepeat); + error->all(FLERR, 4, "Illegal {} nrepeat value: {}", mycmd, nrepeat); if (nfreq <= 0) - error->all(FLERR,"Illegal {} nfreq value: {}", mycmd, nfreq); + error->all(FLERR, 5, "Illegal {} nfreq value: {}", mycmd, nfreq); if (nfreq % nevery || nrepeat*nevery > nfreq) - error->all(FLERR,"Inconsistent {} nevery/nrepeat/nfreq values", mycmd); + error->all(FLERR, "Inconsistent {} nevery/nrepeat/nfreq values", mycmd); if (ave != RUNNING && overwrite) error->all(FLERR,"{} overwrite keyword requires ave running setting", mycmd); @@ -186,7 +203,8 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : } else if (val.which == ArgInfo::COMPUTE) { val.val.c = modify->get_compute_by_id(val.id); - if (!val.val.c) error->all(FLERR,"Compute ID {} for {} does not exist", val.id, mycmd); + if (!val.val.c) + error->all(FLERR, val.iarg, "Compute ID {} for {} does not exist", val.id, mycmd); // computes can produce multiple kinds of output if (val.val.c->scalar_flag || val.val.c->vector_flag || val.val.c->array_flag) kindglobal = 1; @@ -195,7 +213,8 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : } else if (val.which == ArgInfo::FIX) { val.val.f = modify->get_fix_by_id(val.id); - if (!val.val.f) error->all(FLERR,"Fix ID {} for {} does not exist", val.id, mycmd); + if (!val.val.f) + error->all(FLERR, val.iarg, "Fix ID {} for {} does not exist", val.id, mycmd); // fixes can produce multiple kinds of output if (val.val.f->scalar_flag || val.val.f->vector_flag || val.val.f->array_flag) kindglobal = 1; @@ -205,32 +224,40 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : } else if (val.which == ArgInfo::VARIABLE) { val.val.v = input->variable->find(val.id.c_str()); if (val.val.v < 0) - error->all(FLERR,"Variable name {} for {} does not exist", val.id, mycmd); + error->all(FLERR, val.iarg, "Variable name {} for {} does not exist", val.id, mycmd); // variables only produce one kind of output if (input->variable->equalstyle(val.val.v) || input->variable->vectorstyle(val.val.v)) kindglobal = 1; else if (input->variable->atomstyle(val.val.v)) kindperatom = 1; - else error->all(FLERR,"{} variable {} is incompatible style", mycmd, val.id); + else error->all(FLERR, val.iarg, "{} variable {} is incompatible style", mycmd, val.id); } if (kind == DEFAULT) { if (kindglobal + kindperatom + kindlocal > 1) - error->all(FLERR,"{} input kind is ambiguous", mycmd); + error->all(FLERR, val.iarg, "{} input kind is ambiguous", mycmd); if (kindglobal) kind = GLOBAL; if (kindperatom) kind = PERATOM; if (kindlocal) kind = LOCAL; } else if (kind == GLOBAL) { if (!kindglobal) - error->all(FLERR,"{} input kind is not global", mycmd); + error->all(FLERR, val.iarg, "{} input kind is not global", mycmd); } else if (kind == PERATOM) { if (!kindperatom) - error->all(FLERR,"{} input kind is not peratom", mycmd); + error->all(FLERR, val.iarg, "{} input kind is not peratom", mycmd); } else if (kind == LOCAL) { if (!kindlocal) - error->all(FLERR,"{} input kind is not local", mycmd); + error->all(FLERR, val.iarg, "{} input kind is not local", mycmd); } } + // if wildcard expansion occurred, free earg memory from expand_args() + + if (expand) { + for (int i = 0; i < nvalues; i++) delete[] earg[i]; + memory->sfree(earg); + memory->sfree(amap); + } + // more error checks // for fix inputs, check that fix frequency is acceptable @@ -242,98 +269,98 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : for (auto &val : values) { if (val.which == ArgInfo::COMPUTE && kind == GLOBAL && mode == SCALAR) { if (val.argindex == 0 && val.val.c->scalar_flag == 0) - error->all(FLERR, "{} compute {} does not calculate a global scalar", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a global scalar", mycmd, val.id); if (val.argindex && val.val.c->vector_flag == 0) - error->all(FLERR, "{} compute {} does not calculate a global vector", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a global vector", mycmd, val.id); if (val.argindex && val.argindex > val.val.c->size_vector) - error->all(FLERR, "{} compute {} vector is accessed out-of-range", mycmd, val.id); + error->all(FLERR,val.iarg, "{} compute {} vector is accessed out-of-range", mycmd, val.id); } else if (val.which == ArgInfo::COMPUTE && kind == GLOBAL && mode == VECTOR) { if (val.argindex == 0 && val.val.c->vector_flag == 0) - error->all(FLERR, "{} compute {} does not calculate a global vector", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a global vector", mycmd, val.id); if (val.argindex && val.val.c->array_flag == 0) - error->all(FLERR, "{} compute {} does not calculate a global array", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a global array", mycmd, val.id); if (val.argindex && val.argindex > val.val.c->size_array_cols) - error->all(FLERR, "{} compute {} array is accessed out-of-range", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} array is accessed out-of-range", mycmd, val.id); } else if (val.which == ArgInfo::COMPUTE && kind == PERATOM) { if (val.val.c->peratom_flag == 0) - error->all(FLERR, "{} compute {} does not calculate per-atom values", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate per-atom values", mycmd, val.id); if (val.argindex == 0 && val.val.c->size_peratom_cols != 0) - error->all(FLERR, "{} compute {} does not calculate a per-atom vector", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a per-atom vector", mycmd, val.id); if (val.argindex && val.val.c->size_peratom_cols == 0) - error->all(FLERR, "{} compute {} does not calculate a per-atom array", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a per-atom array", mycmd, val.id); if (val.argindex && val.argindex > val.val.c->size_peratom_cols) - error->all(FLERR, "{} compute {} array is accessed out-of-range", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} array is accessed out-of-range", mycmd, val.id); } else if (val.which == ArgInfo::COMPUTE && kind == LOCAL) { if (val.val.c->local_flag == 0) - error->all(FLERR, "{} compute {} does not calculate local values", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate local values", mycmd, val.id); if (val.argindex == 0 && val.val.c->size_local_cols != 0) - error->all(FLERR, "{} compute {} does not calculate a local vector", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a local vector", mycmd, val.id); if (val.argindex && val.val.c->size_local_cols == 0) - error->all(FLERR, "{} compute {} does not calculate a local array", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} does not calculate a local array", mycmd, val.id); if (val.argindex && val.argindex > val.val.c->size_local_cols) - error->all(FLERR, "{} compute {} array is accessed out-of-range", mycmd, val.id); + error->all(FLERR, val.iarg, "{} compute {} array is accessed out-of-range", mycmd, val.id); } else if (val.which == ArgInfo::FIX && kind == GLOBAL && mode == SCALAR) { if (val.argindex == 0 && val.val.f->scalar_flag == 0) - error->all(FLERR, "{} fix {} does not calculate a global scalar", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not calculate a global scalar", mycmd, val.id); if (val.argindex && val.val.f->vector_flag == 0) - error->all(FLERR, "{} fix {} does not calculate a global vector", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not calculate a global vector", mycmd, val.id); if (val.argindex && val.argindex > val.val.f->size_vector) - error->all(FLERR, "{} fix {} vector is accessed out-of-range", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} vector is accessed out-of-range", mycmd, val.id); if (nevery % val.val.f->global_freq) - error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd); + error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd); } else if (val.which == ArgInfo::FIX && kind == GLOBAL && mode == VECTOR) { if (val.argindex == 0 && val.val.f->vector_flag == 0) - error->all(FLERR, "{} fix {} does not calculate a global vector", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not calculate a global vector", mycmd, val.id); if (val.argindex && val.val.f->array_flag == 0) - error->all(FLERR, "{} fix {} does not calculate a global array", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not calculate a global array", mycmd, val.id); if (val.argindex && val.argindex > val.val.f->size_array_cols) - error->all(FLERR, "{} fix {} array is accessed out-of-range", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} array is accessed out-of-range", mycmd, val.id); if (nevery % val.val.f->global_freq) - error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd); + error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd); } else if (val.which == ArgInfo::FIX && kind == PERATOM) { if (val.val.f->peratom_flag == 0) - error->all(FLERR, "{} fix {} does not calculate per-atom values", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not calculate per-atom values", mycmd, val.id); if (val.argindex == 0 && val.val.f->size_peratom_cols != 0) - error->all(FLERR," {} fix {} does not calculate a per-atom vector", mycmd, val.id); + error->all(FLERR, val.iarg, " {} fix {} does not calculate a per-atom vector", mycmd, val.id); if (val.argindex && val.val.f->size_peratom_cols == 0) - error->all(FLERR, "{} fix {} does not ""calculate a per-atom array", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not ""calculate a per-atom array", mycmd, val.id); if (val.argindex && val.argindex > val.val.f->size_peratom_cols) - error->all(FLERR, "{} fix {} array is accessed out-of-range", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} array is accessed out-of-range", mycmd, val.id); if (nevery % val.val.f->global_freq) - error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd); + error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd); } else if (val.which == ArgInfo::FIX && kind == LOCAL) { if (val.val.f->local_flag == 0) - error->all(FLERR, "{} fix {} does not calculate local values", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not calculate local values", mycmd, val.id); if (val.argindex == 0 && val.val.f->size_local_cols != 0) - error->all(FLERR, "{} fix {} does not calculate a local vector", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} does not calculate a local vector", mycmd, val.id); if (val.argindex && val.val.f->size_local_cols == 0) - error->all(FLERR, "{} fix does not calculate a local array", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix does not calculate a local array", mycmd, val.id); if (val.argindex && val.argindex > val.val.f->size_local_cols) - error->all(FLERR, "{} fix {} array is accessed out-of-range", mycmd, val.id); + error->all(FLERR, val.iarg, "{} fix {} array is accessed out-of-range", mycmd, val.id); if (nevery % val.val.f->global_freq) - error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd); + error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd); } else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL && mode == SCALAR) { if (val.argindex == 0 && input->variable->equalstyle(val.val.v) == 0) - error->all(FLERR,"{} variable {} is not equal-style variable", mycmd, val.id); + error->all(FLERR, val.iarg, "{} variable {} is not equal-style variable", mycmd, val.id); if (val.argindex && input->variable->vectorstyle(val.val.v) == 0) - error->all(FLERR,"{} variable {} is not vector-style variable" , mycmd, val.id); + error->all(FLERR, val.iarg, "{} variable {} is not vector-style variable" , mycmd, val.id); } else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL && mode == VECTOR) { if (val.argindex == 0 && input->variable->vectorstyle(val.val.v) == 0) - error->all(FLERR,"{} variable {} is not vector-style variable", mycmd, val.id); + error->all(FLERR, val.iarg, "{} variable {} is not vector-style variable", mycmd, val.id); if (val.argindex) error->all(FLERR,"{} variable {} cannot be indexed", mycmd, val.id); } else if (val.which == ArgInfo::VARIABLE && kind == PERATOM) { if (val.argindex == 0 && input->variable->atomstyle(val.val.v) == 0) - error->all(FLERR,"{} variable {} is not atom-style variable", mycmd, val.id); + error->all(FLERR, val.iarg, "{} variable {} is not atom-style variable", mycmd, val.id); if (val.argindex) error->all(FLERR,"{} variable {} cannot be indexed", mycmd, val.id); } } @@ -350,7 +377,7 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) : if (title3) fprintf(fp,"%s\n",title3); else fprintf(fp,"# Bin Coord Count Count/Total\n"); - if (ferror(fp)) error->one(FLERR,"Error writing file header: {}", utils::getsyserror()); + if (ferror(fp)) error->one(FLERR, "Error writing file header: {}", utils::getsyserror()); filepos = platform::ftell(fp); } @@ -450,13 +477,17 @@ void FixAveHisto::init() for (auto &val : values) { if (val.which == ArgInfo::COMPUTE) { val.val.c = modify->get_compute_by_id(val.id); - if (!val.val.c) error->all(FLERR,"Compute ID {} for {} does not exist", val.id, mycmd); + if (!val.val.c) + error->all(FLERR, Error::NOLASTLINE, "Compute ID {} for {} does not exist", val.id, mycmd); } else if (val.which == ArgInfo::FIX) { val.val.f = modify->get_fix_by_id(val.id); - if (!val.val.f) error->all(FLERR,"Fix ID {} for {} does not exist", val.id, mycmd); + if (!val.val.f) + error->all(FLERR, Error::NOLASTLINE, "Fix ID {} for {} does not exist", val.id, mycmd); } else if (val.which == ArgInfo::VARIABLE) { val.val.v = input->variable->find(val.id.c_str()); - if (val.val.v < 0) error->all(FLERR,"Variable name {} for {} does not exist", val.id, mycmd); + if (val.val.v < 0) + error->all(FLERR, Error::NOLASTLINE, + "Variable name {} for {} does not exist", val.id, mycmd); } } @@ -717,7 +748,7 @@ void FixAveHisto::end_of_step() if (fp && comm->me == 0) { clearerr(fp); if (overwrite) (void) platform::fseek(fp,filepos); - fmt::print(fp,"{} {} {} {} {} {}\n",ntimestep,nbins, + utils::print(fp,"{} {} {} {} {} {}\n",ntimestep,nbins, stats_total[0],stats_total[1],stats_total[2],stats_total[3]); if (stats_total[0] != 0.0) for (int i = 0; i < nbins; i++) @@ -728,13 +759,13 @@ void FixAveHisto::end_of_step() fprintf(fp,"%d %g %g %g\n",i+1,coord[i],0.0,0.0); if (ferror(fp)) - error->one(FLERR,"Error writing out histogram data"); + error->one(FLERR, Error::NOLASTLINE, "Error writing out histogram data"); fflush(fp); if (overwrite) { bigint fileend = platform::ftell(fp); if ((fileend > 0) && (platform::ftruncate(fp,fileend))) - error->warning(FLERR,"Error while tuncating output: {}",utils::getsyserror()); + error->warning(FLERR, "Error while tuncating output: {}",utils::getsyserror()); } } } @@ -839,56 +870,57 @@ void FixAveHisto::options(int iarg, int narg, char **arg) title3 = nullptr; // optional args - auto mycmd = fmt::format("fix {}", style); + auto mycmd = fmt::format("fix {} ", style); while (iarg < narg) { if ((strcmp(arg[iarg],"file") == 0) || (strcmp(arg[iarg],"append") == 0)) { if (iarg+2 > narg) - utils::missing_cmd_args(FLERR, std::string("fix ave/histo ")+arg[iarg], error); + utils::missing_cmd_args(FLERR, mycmd + arg[iarg], error); if (comm->me == 0) { if (strcmp(arg[iarg],"file") == 0) fp = fopen(arg[iarg+1],"w"); else fp = fopen(arg[iarg+1],"a"); if (fp == nullptr) - error->one(FLERR, "Cannot open fix ave/histo file {}: {}", + error->one(FLERR, iarg+1, "Cannot open fix ave/histo file {}: {}", arg[iarg+1], utils::getsyserror()); } iarg += 2; } else if (strcmp(arg[iarg],"kind") == 0) { - if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " kind", error); + if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "kind", error); if (strcmp(arg[iarg+1],"global") == 0) kind = GLOBAL; else if (strcmp(arg[iarg+1],"peratom") == 0) kind = PERATOM; else if (strcmp(arg[iarg+1],"local") == 0) kind = LOCAL; - else error->all(FLERR,"Unknown fix ave/histo kind option: {}", arg[iarg+1]); + else error->all(FLERR, iarg+1, "Unknown fix ave/histo kind option: {}", arg[iarg+1]); iarg += 2; } else if (strcmp(arg[iarg],"ave") == 0) { - if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " ave", error); + if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "ave", error); if (strcmp(arg[iarg+1],"one") == 0) ave = ONE; else if (strcmp(arg[iarg+1],"running") == 0) ave = RUNNING; else if (strcmp(arg[iarg+1],"window") == 0) ave = WINDOW; - else error->all(FLERR,"Unknown fix ave/histo ave option: {}", arg[iarg+1]); + else error->all(FLERR, iarg + 1, "Unknown fix ave/histo ave option: {}", arg[iarg+1]); if (ave == WINDOW) { - if (iarg+3 > narg) utils::missing_cmd_args(FLERR, mycmd + " ave window", error); + if (iarg+3 > narg) utils::missing_cmd_args(FLERR, mycmd + "ave window", error); nwindow = utils::inumeric(FLERR,arg[iarg+2],false,lmp); - if (nwindow <= 0) error->all(FLERR,"Illegal fix ave/histo ave window size: {}", nwindow); + if (nwindow <= 0) + error->all(FLERR, iarg + 2, "Illegal fix ave/histo ave window size: {}", nwindow); } iarg += 2; if (ave == WINDOW) iarg++; } else if (strcmp(arg[iarg],"start") == 0) { - if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " start", error); + if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "start", error); startstep = utils::inumeric(FLERR,arg[iarg+1],false,lmp); iarg += 2; } else if (strcmp(arg[iarg],"mode") == 0) { - if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " mode", error); + if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "mode", error); if (strcmp(arg[iarg+1],"scalar") == 0) mode = SCALAR; else if (strcmp(arg[iarg+1],"vector") == 0) mode = VECTOR; - else error->all(FLERR,"Unknown fix ave/histo mode option: {}", arg[iarg+1]); + else error->all(FLERR, iarg + 1, "Unknown fix ave/histo mode option: {}", arg[iarg+1]); iarg += 2; } else if (strcmp(arg[iarg],"beyond") == 0) { - if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " beyond", error); + if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "beyond", error); if (strcmp(arg[iarg+1],"ignore") == 0) beyond = IGNORE; else if (strcmp(arg[iarg+1],"end") == 0) beyond = END; else if (strcmp(arg[iarg+1],"extra") == 0) beyond = EXTRA; - else error->all(FLERR,"Unknown fix ave/histo beyond option: {}", arg[iarg+1]); + else error->all(FLERR, iarg + 1, "Unknown fix ave/histo beyond option: {}", arg[iarg+1]); iarg += 2; } else if (strcmp(arg[iarg],"overwrite") == 0) { overwrite = 1; @@ -908,7 +940,7 @@ void FixAveHisto::options(int iarg, int narg, char **arg) delete[] title3; title3 = utils::strdup(arg[iarg+1]); iarg += 2; - } else error->all(FLERR,"Unknown {} option: {}", mycmd, arg[iarg]); + } else error->all(FLERR, iarg, "Unknown {}option: {}", mycmd, arg[iarg]); } } diff --git a/src/fix_ave_histo.h b/src/fix_ave_histo.h index 7f21b49006..a8c4c2ecd8 100644 --- a/src/fix_ave_histo.h +++ b/src/fix_ave_histo.h @@ -39,6 +39,7 @@ class FixAveHisto : public Fix { struct value_t { int which; // type of data: COMPUTE, FIX, VARIABLE int argindex; // 1-based index if data is vector, else 0 + int iarg; // argument index in original argument list std::string id; // compute/fix/variable ID union { class Compute *c; diff --git a/src/fix_ave_histo_weight.cpp b/src/fix_ave_histo_weight.cpp index c6f9b6ad22..e5a47881a5 100644 --- a/src/fix_ave_histo_weight.cpp +++ b/src/fix_ave_histo_weight.cpp @@ -454,7 +454,7 @@ void FixAveHistoWeight::end_of_step() if (fp && comm->me == 0) { clearerr(fp); if (overwrite) (void) platform::fseek(fp,filepos); - fmt::print(fp,"{} {} {} {} {} {}\n",ntimestep,nbins, + utils::print(fp,"{} {} {} {} {} {}\n",ntimestep,nbins, stats_total[0],stats_total[1],stats_total[2],stats_total[3]); if (stats_total[0] != 0.0) for (int i = 0; i < nbins; i++) diff --git a/src/fix_ave_time.cpp b/src/fix_ave_time.cpp index b48b5cd7ba..3246e0ff10 100644 --- a/src/fix_ave_time.cpp +++ b/src/fix_ave_time.cpp @@ -83,7 +83,7 @@ FixAveTime::FixAveTime(LAMMPS *lmp, int narg, char **arg) : int expand = 0; char **earg; int *amap = nullptr; - nvalues = utils::expand_args(FLERR,nvalues,&arg[ioffset],mode,earg,lmp,&amap); + nvalues = utils::expand_args(FLERR, nvalues, &arg[ioffset], mode, earg, lmp, &amap); key2col.clear(); if (earg != &arg[ioffset]) expand = 1; @@ -667,14 +667,14 @@ void FixAveTime::invoke_scalar(bigint ntimestep) if (!yaml_header || overwrite) { yaml_header = true; fputs("keywords: ['Step', ", fp); - for (const auto &val : values) fmt::print(fp, "'{}', ", val.keyword); + for (const auto &val : values) utils::print(fp, "'{}', ", val.keyword); fputs("]\ndata:\n", fp); } - fmt::print(fp, " - [{}, ", ntimestep); - for (i = 0; i < nvalues; i++) fmt::print(fp,"{}, ",vector_total[i]/norm); + utils::print(fp, " - [{}, ", ntimestep); + for (i = 0; i < nvalues; i++) utils::print(fp,"{}, ",vector_total[i]/norm); fputs("]\n", fp); } else { - fmt::print(fp,"{}",ntimestep); + utils::print(fp,"{}",ntimestep); for (i = 0; i < nvalues; i++) fprintf(fp,format,vector_total[i]/norm); fprintf(fp,"\n"); if (ferror(fp)) @@ -885,17 +885,17 @@ void FixAveTime::invoke_vector(bigint ntimestep) if (!yaml_header || overwrite) { yaml_header = true; fputs("keywords: [", fp); - for (const auto &val : values) fmt::print(fp, "'{}', ", val.keyword); + for (const auto &val : values) utils::print(fp, "'{}', ", val.keyword); fputs("]\ndata:\n", fp); } - fmt::print(fp, " {}:\n", ntimestep); + utils::print(fp, " {}:\n", ntimestep); for (int i = 0; i < nrows; i++) { fputs(" - [", fp); - for (int j = 0; j < nvalues; j++) fmt::print(fp,"{}, ",array_total[i][j]/norm); + for (int j = 0; j < nvalues; j++) utils::print(fp,"{}, ",array_total[i][j]/norm); fputs("]\n", fp); } } else { - fmt::print(fp,"{} {}\n",ntimestep,nrows); + utils::print(fp,"{} {}\n",ntimestep,nrows); for (int i = 0; i < nrows; i++) { fprintf(fp,"%d",i+1); for (int j = 0; j < nvalues; j++) fprintf(fp,format,array_total[i][j]/norm); diff --git a/src/fix_print.cpp b/src/fix_print.cpp index 8e0a4a1921..1d60addfa4 100644 --- a/src/fix_print.cpp +++ b/src/fix_print.cpp @@ -181,7 +181,7 @@ void FixPrint::end_of_step() if (comm->me == 0) { if (screenflag) utils::logmesg(lmp, std::string(copy) + "\n"); if (fp) { - fmt::print(fp, "{}\n", copy); + utils::print(fp, "{}\n", copy); fflush(fp); } } diff --git a/src/fix_property_atom.cpp b/src/fix_property_atom.cpp index f88d6551b4..d1cc65adad 100644 --- a/src/fix_property_atom.cpp +++ b/src/fix_property_atom.cpp @@ -543,7 +543,7 @@ void FixPropertyAtom::write_data_section(int /*mth*/, FILE *fp, int n, double ** icol += ncol; } } - fmt::print(fp, line + "\n"); + utils::print(fp, line + "\n"); } } diff --git a/src/fix_restrain.cpp b/src/fix_restrain.cpp index cc95fc93f3..9b157ee90f 100644 --- a/src/fix_restrain.cpp +++ b/src/fix_restrain.cpp @@ -616,7 +616,7 @@ void FixRestrain::restrain_dihedral(int m) me,update->ntimestep,atom->tag[i1], atom->tag[i2],atom->tag[i3],atom->tag[i4]); error->warning(FLERR,str); - fmt::print(screen," 1st atom: {} {} {} {}\n" + utils::print(screen," 1st atom: {} {} {} {}\n" " 2nd atom: {} {} {} {}\n" " 3rd atom: {} {} {} {}\n" " 4th atom: {} {} {} {}\n", diff --git a/src/fmt/args.h b/src/fmt/args.h index 3ff4788074..b77a2d0661 100644 --- a/src/fmt/args.h +++ b/src/fmt/args.h @@ -8,15 +8,14 @@ #ifndef FMT_ARGS_H_ #define FMT_ARGS_H_ -#ifndef FMT_MODULE -# include // std::reference_wrapper -# include // std::unique_ptr -# include -#endif +#include // std::reference_wrapper +#include // std::unique_ptr +#include #include "format.h" // std_string_view FMT_BEGIN_NAMESPACE + namespace detail { template struct is_reference_wrapper : std::false_type {}; @@ -29,18 +28,15 @@ auto unwrap(const std::reference_wrapper& v) -> const T& { return static_cast(v); } -// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC -// 2022 (v17.10.0). -// -// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for -// templates it doesn't complain about inability to deduce single translation -// unit for placing vtable. So node is made a fake template. -template struct node { - virtual ~node() = default; - std::unique_ptr> next; -}; - class dynamic_arg_list { + // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for + // templates it doesn't complain about inability to deduce single translation + // unit for placing vtable. So storage_node_base is made a fake template. + template struct node { + virtual ~node() = default; + std::unique_ptr> next; + }; + template struct typed_node : node<> { T value; @@ -66,18 +62,28 @@ class dynamic_arg_list { } // namespace detail /** - * A dynamic list of formatting arguments with storage. - * - * It can be implicitly converted into `fmt::basic_format_args` for passing - * into type-erased formatting functions such as `fmt::vformat`. + \rst + A dynamic version of `fmt::format_arg_store`. + It's equipped with a storage to potentially temporary objects which lifetimes + could be shorter than the format arguments object. + + It can be implicitly converted into `~fmt::basic_format_args` for passing + into type-erased formatting functions such as `~fmt::vformat`. + \endrst */ -template class dynamic_format_arg_store { +template +class dynamic_format_arg_store +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 + // Workaround a GCC template argument substitution bug. + : public basic_format_args +#endif +{ private: using char_type = typename Context::char_type; template struct need_copy { static constexpr detail::type mapped_type = - detail::mapped_type_constant::value; + detail::mapped_type_constant::value; enum { value = !(detail::is_reference_wrapper::value || @@ -90,7 +96,7 @@ template class dynamic_format_arg_store { }; template - using stored_t = conditional_t< + using stored_type = conditional_t< std::is_convertible>::value && !detail::is_reference_wrapper::value, std::basic_string, T>; @@ -105,72 +111,80 @@ template class dynamic_format_arg_store { friend class basic_format_args; + auto get_types() const -> unsigned long long { + return detail::is_unpacked_bit | data_.size() | + (named_info_.empty() + ? 0ULL + : static_cast(detail::has_named_args_bit)); + } + auto data() const -> const basic_format_arg* { return named_info_.empty() ? data_.data() : data_.data() + 1; } template void emplace_arg(const T& arg) { - data_.emplace_back(arg); + data_.emplace_back(detail::make_arg(arg)); } template void emplace_arg(const detail::named_arg& arg) { - if (named_info_.empty()) - data_.insert(data_.begin(), basic_format_arg(nullptr, 0)); - data_.emplace_back(detail::unwrap(arg.value)); + if (named_info_.empty()) { + constexpr const detail::named_arg_info* zero_ptr{nullptr}; + data_.insert(data_.begin(), {zero_ptr, 0}); + } + data_.emplace_back(detail::make_arg(detail::unwrap(arg.value))); auto pop_one = [](std::vector>* data) { data->pop_back(); }; std::unique_ptr>, decltype(pop_one)> guard{&data_, pop_one}; named_info_.push_back({arg.name, static_cast(data_.size() - 2u)}); - data_[0] = {named_info_.data(), named_info_.size()}; + data_[0].value_.named_args = {named_info_.data(), named_info_.size()}; guard.release(); } public: constexpr dynamic_format_arg_store() = default; - operator basic_format_args() const { - return basic_format_args(data(), static_cast(data_.size()), - !named_info_.empty()); - } - /** - * Adds an argument into the dynamic store for later passing to a formatting - * function. - * - * Note that custom types and string types (but not string views) are copied - * into the store dynamically allocating memory if necessary. - * - * **Example**: - * - * fmt::dynamic_format_arg_store store; - * store.push_back(42); - * store.push_back("abc"); - * store.push_back(1.5f); - * std::string result = fmt::vformat("{} and {} and {}", store); - */ + \rst + Adds an argument into the dynamic store for later passing to a formatting + function. + + Note that custom types and string types (but not string views) are copied + into the store dynamically allocating memory if necessary. + + **Example**:: + + fmt::dynamic_format_arg_store store; + store.push_back(42); + store.push_back("abc"); + store.push_back(1.5f); + std::string result = fmt::vformat("{} and {} and {}", store); + \endrst + */ template void push_back(const T& arg) { if (detail::const_check(need_copy::value)) - emplace_arg(dynamic_args_.push>(arg)); + emplace_arg(dynamic_args_.push>(arg)); else emplace_arg(detail::unwrap(arg)); } /** - * Adds a reference to the argument into the dynamic store for later passing - * to a formatting function. - * - * **Example**: - * - * fmt::dynamic_format_arg_store store; - * char band[] = "Rolling Stones"; - * store.push_back(std::cref(band)); - * band[9] = 'c'; // Changing str affects the output. - * std::string result = fmt::vformat("{}", store); - * // result == "Rolling Scones" - */ + \rst + Adds a reference to the argument into the dynamic store for later passing to + a formatting function. + + **Example**:: + + fmt::dynamic_format_arg_store store; + char band[] = "Rolling Stones"; + store.push_back(std::cref(band)); + band[9] = 'c'; // Changing str affects the output. + std::string result = fmt::vformat("{}", store); + // result == "Rolling Scones" + \endrst + */ template void push_back(std::reference_wrapper arg) { static_assert( need_copy::value, @@ -179,40 +193,41 @@ template class dynamic_format_arg_store { } /** - * Adds named argument into the dynamic store for later passing to a - * formatting function. `std::reference_wrapper` is supported to avoid - * copying of the argument. The name is always copied into the store. - */ + Adds named argument into the dynamic store for later passing to a formatting + function. ``std::reference_wrapper`` is supported to avoid copying of the + argument. The name is always copied into the store. + */ template void push_back(const detail::named_arg& arg) { const char_type* arg_name = dynamic_args_.push>(arg.name).c_str(); if (detail::const_check(need_copy::value)) { emplace_arg( - fmt::arg(arg_name, dynamic_args_.push>(arg.value))); + fmt::arg(arg_name, dynamic_args_.push>(arg.value))); } else { emplace_arg(fmt::arg(arg_name, arg.value)); } } - /// Erase all elements from the store. + /** Erase all elements from the store */ void clear() { data_.clear(); named_info_.clear(); - dynamic_args_ = {}; + dynamic_args_ = detail::dynamic_arg_list(); } - /// Reserves space to store at least `new_cap` arguments including - /// `new_cap_named` named arguments. + /** + \rst + Reserves space to store at least *new_cap* arguments including + *new_cap_named* named arguments. + \endrst + */ void reserve(size_t new_cap, size_t new_cap_named) { FMT_ASSERT(new_cap >= new_cap_named, - "set of arguments includes set of named arguments"); + "Set of arguments includes set of named arguments"); data_.reserve(new_cap); named_info_.reserve(new_cap_named); } - - /// Returns the number of elements in the store. - size_t size() const noexcept { return data_.size(); } }; FMT_END_NAMESPACE diff --git a/src/fmt/base.h b/src/fmt/base.h deleted file mode 100644 index efa957d8d2..0000000000 --- a/src/fmt/base.h +++ /dev/null @@ -1,2970 +0,0 @@ -// Formatting library for C++ - the base API for char/UTF-8 -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_BASE_H_ -#define FMT_BASE_H_ - -#if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE) -# define FMT_MODULE -#endif - -#ifndef FMT_MODULE -# include // CHAR_BIT -# include // FILE -# include // memcmp - -# include // std::enable_if -#endif - -// The fmt library version in the form major * 10000 + minor * 100 + patch. -#define FMT_VERSION 110102 - -// Detect compiler versions. -#if defined(__clang__) && !defined(__ibmxl__) -# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) -#else -# define FMT_CLANG_VERSION 0 -#endif -#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) -# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) -#else -# define FMT_GCC_VERSION 0 -#endif -#if defined(__ICL) -# define FMT_ICC_VERSION __ICL -#elif defined(__INTEL_COMPILER) -# define FMT_ICC_VERSION __INTEL_COMPILER -#else -# define FMT_ICC_VERSION 0 -#endif -#if defined(_MSC_VER) -# define FMT_MSC_VERSION _MSC_VER -#else -# define FMT_MSC_VERSION 0 -#endif - -// Detect standard library versions. -#ifdef _GLIBCXX_RELEASE -# define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE -#else -# define FMT_GLIBCXX_RELEASE 0 -#endif -#ifdef _LIBCPP_VERSION -# define FMT_LIBCPP_VERSION _LIBCPP_VERSION -#else -# define FMT_LIBCPP_VERSION 0 -#endif - -#ifdef _MSVC_LANG -# define FMT_CPLUSPLUS _MSVC_LANG -#else -# define FMT_CPLUSPLUS __cplusplus -#endif - -// Detect __has_*. -#ifdef __has_feature -# define FMT_HAS_FEATURE(x) __has_feature(x) -#else -# define FMT_HAS_FEATURE(x) 0 -#endif -#ifdef __has_include -# define FMT_HAS_INCLUDE(x) __has_include(x) -#else -# define FMT_HAS_INCLUDE(x) 0 -#endif -#ifdef __has_builtin -# define FMT_HAS_BUILTIN(x) __has_builtin(x) -#else -# define FMT_HAS_BUILTIN(x) 0 -#endif -#ifdef __has_cpp_attribute -# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) -#else -# define FMT_HAS_CPP_ATTRIBUTE(x) 0 -#endif - -#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ - (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) - -#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ - (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) - -// Detect C++14 relaxed constexpr. -#ifdef FMT_USE_CONSTEXPR -// Use the provided definition. -#elif FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L -// GCC only allows throw in constexpr since version 6: -// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371. -# define FMT_USE_CONSTEXPR 1 -#elif FMT_ICC_VERSION -# define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628 -#elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 -# define FMT_USE_CONSTEXPR 1 -#else -# define FMT_USE_CONSTEXPR 0 -#endif -#if FMT_USE_CONSTEXPR -# define FMT_CONSTEXPR constexpr -#else -# define FMT_CONSTEXPR -#endif - -// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated. -// LAMMPS customization. Using consteval is not compatible with how we use libfmt -#if 1 -# define FMT_USE_CONSTEVAL 0 -#elif !defined(__cpp_lib_is_constant_evaluated) -# define FMT_USE_CONSTEVAL 0 -#elif FMT_CPLUSPLUS < 201709L -# define FMT_USE_CONSTEVAL 0 -#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10 -# define FMT_USE_CONSTEVAL 0 -#elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000 -# define FMT_USE_CONSTEVAL 0 -#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L -# define FMT_USE_CONSTEVAL 0 // consteval is broken in Apple clang < 14. -#elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929 -# define FMT_USE_CONSTEVAL 0 // consteval is broken in MSVC VS2019 < 16.10. -#elif defined(__cpp_consteval) -# define FMT_USE_CONSTEVAL 1 -#elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101 -# define FMT_USE_CONSTEVAL 1 -#else -# define FMT_USE_CONSTEVAL 0 -#endif -#if FMT_USE_CONSTEVAL -# define FMT_CONSTEVAL consteval -# define FMT_CONSTEXPR20 constexpr -#else -# define FMT_CONSTEVAL -# define FMT_CONSTEXPR20 -#endif - -// Check if exceptions are disabled. -#ifdef FMT_USE_EXCEPTIONS -// Use the provided definition. -#elif defined(__GNUC__) && !defined(__EXCEPTIONS) -# define FMT_USE_EXCEPTIONS 0 -#elif defined(__clang__) && !defined(__cpp_exceptions) -# define FMT_USE_EXCEPTIONS 0 -#elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS -# define FMT_USE_EXCEPTIONS 0 -#else -# define FMT_USE_EXCEPTIONS 1 -#endif -#if FMT_USE_EXCEPTIONS -# define FMT_TRY try -# define FMT_CATCH(x) catch (x) -#else -# define FMT_TRY if (true) -# define FMT_CATCH(x) if (false) -#endif - -#ifdef FMT_NO_UNIQUE_ADDRESS -// Use the provided definition. -#elif FMT_CPLUSPLUS < 202002L -// Not supported. -#elif FMT_HAS_CPP_ATTRIBUTE(no_unique_address) -# define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] -// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485). -#elif FMT_MSC_VERSION >= 1929 && !FMT_CLANG_VERSION -# define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] -#endif -#ifndef FMT_NO_UNIQUE_ADDRESS -# define FMT_NO_UNIQUE_ADDRESS -#endif - -#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) -# define FMT_FALLTHROUGH [[fallthrough]] -#elif defined(__clang__) -# define FMT_FALLTHROUGH [[clang::fallthrough]] -#elif FMT_GCC_VERSION >= 700 && \ - (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) -# define FMT_FALLTHROUGH [[gnu::fallthrough]] -#else -# define FMT_FALLTHROUGH -#endif - -// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. -#if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__) -# define FMT_NORETURN [[noreturn]] -#else -# define FMT_NORETURN -#endif - -#ifdef FMT_NODISCARD -// Use the provided definition. -#elif FMT_HAS_CPP17_ATTRIBUTE(nodiscard) -# define FMT_NODISCARD [[nodiscard]] -#else -# define FMT_NODISCARD -#endif - -#ifdef FMT_DEPRECATED -// Use the provided definition. -#elif FMT_HAS_CPP14_ATTRIBUTE(deprecated) -# define FMT_DEPRECATED [[deprecated]] -#else -# define FMT_DEPRECATED /* deprecated */ -#endif - -#ifdef FMT_ALWAYS_INLINE -// Use the provided definition. -#elif FMT_GCC_VERSION || FMT_CLANG_VERSION -# define FMT_ALWAYS_INLINE inline __attribute__((always_inline)) -#else -# define FMT_ALWAYS_INLINE inline -#endif -// A version of FMT_ALWAYS_INLINE to prevent code bloat in debug mode. -#ifdef NDEBUG -# define FMT_INLINE FMT_ALWAYS_INLINE -#else -# define FMT_INLINE inline -#endif - -#if FMT_GCC_VERSION || FMT_CLANG_VERSION -# define FMT_VISIBILITY(value) __attribute__((visibility(value))) -#else -# define FMT_VISIBILITY(value) -#endif - -// Detect pragmas. -#define FMT_PRAGMA_IMPL(x) _Pragma(#x) -#if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER) -// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884 -// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582. -# define FMT_PRAGMA_GCC(x) FMT_PRAGMA_IMPL(GCC x) -#else -# define FMT_PRAGMA_GCC(x) -#endif -#if FMT_CLANG_VERSION -# define FMT_PRAGMA_CLANG(x) FMT_PRAGMA_IMPL(clang x) -#else -# define FMT_PRAGMA_CLANG(x) -#endif -#if FMT_MSC_VERSION -# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) -#else -# define FMT_MSC_WARNING(...) -#endif - -// LAMMPS customization -// use 'v11_lmp' namespace instead of 'v11' so that our -// bundled copy does not collide with linking other code -// using system wide installations which may be using -// a different version. - -#ifndef FMT_BEGIN_NAMESPACE -# define FMT_BEGIN_NAMESPACE \ - namespace fmt { \ - inline namespace v11_lmp { -# define FMT_END_NAMESPACE \ - } \ - } -#endif - -#ifndef FMT_EXPORT -# define FMT_EXPORT -# define FMT_BEGIN_EXPORT -# define FMT_END_EXPORT -#endif - -#ifdef _WIN32 -# define FMT_WIN32 1 -#else -# define FMT_WIN32 0 -#endif - -#if !defined(FMT_HEADER_ONLY) && FMT_WIN32 -# if defined(FMT_LIB_EXPORT) -# define FMT_API __declspec(dllexport) -# elif defined(FMT_SHARED) -# define FMT_API __declspec(dllimport) -# endif -#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) -# define FMT_API FMT_VISIBILITY("default") -#endif -#ifndef FMT_API -# define FMT_API -#endif - -#ifndef FMT_OPTIMIZE_SIZE -# define FMT_OPTIMIZE_SIZE 0 -#endif - -// FMT_BUILTIN_TYPE=0 may result in smaller library size at the cost of higher -// per-call binary size by passing built-in types through the extension API. -#ifndef FMT_BUILTIN_TYPES -# define FMT_BUILTIN_TYPES 1 -#endif - -#define FMT_APPLY_VARIADIC(expr) \ - using ignore = int[]; \ - (void)ignore { 0, (expr, 0)... } - -// Enable minimal optimizations for more compact code in debug mode. -FMT_PRAGMA_GCC(push_options) -#if !defined(__OPTIMIZE__) && !defined(__CUDACC__) -FMT_PRAGMA_GCC(optimize("Og")) -#endif -FMT_PRAGMA_CLANG(diagnostic push) - -FMT_BEGIN_NAMESPACE - -// Implementations of enable_if_t and other metafunctions for older systems. -template -using enable_if_t = typename std::enable_if::type; -template -using conditional_t = typename std::conditional::type; -template using bool_constant = std::integral_constant; -template -using remove_reference_t = typename std::remove_reference::type; -template -using remove_const_t = typename std::remove_const::type; -template -using remove_cvref_t = typename std::remove_cv>::type; -template -using make_unsigned_t = typename std::make_unsigned::type; -template -using underlying_t = typename std::underlying_type::type; -template using decay_t = typename std::decay::type; -using nullptr_t = decltype(nullptr); - -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 -// A workaround for gcc 4.9 to make void_t work in a SFINAE context. -template struct void_t_impl { - using type = void; -}; -template using void_t = typename void_t_impl::type; -#else -template using void_t = void; -#endif - -struct monostate { - constexpr monostate() {} -}; - -// An enable_if helper to be used in template parameters which results in much -// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed -// to workaround a bug in MSVC 2019 (see #1140 and #1186). -#ifdef FMT_DOC -# define FMT_ENABLE_IF(...) -#else -# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 -#endif - -template constexpr auto min_of(T a, T b) -> T { - return a < b ? a : b; -} -template constexpr auto max_of(T a, T b) -> T { - return a > b ? a : b; -} - -namespace detail { -// Suppresses "unused variable" warnings with the method described in -// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. -// (void)var does not work on many Intel compilers. -template FMT_CONSTEXPR void ignore_unused(const T&...) {} - -constexpr auto is_constant_evaluated(bool default_value = false) noexcept - -> bool { -// Workaround for incompatibility between clang 14 and libstdc++ consteval-based -// std::is_constant_evaluated: https://github.com/fmtlib/fmt/issues/3247. -#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \ - (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) - ignore_unused(default_value); - return __builtin_is_constant_evaluated(); -#elif defined(__cpp_lib_is_constant_evaluated) - ignore_unused(default_value); - return std::is_constant_evaluated(); -#else - return default_value; -#endif -} - -// Suppresses "conditional expression is constant" warnings. -template FMT_ALWAYS_INLINE constexpr auto const_check(T val) -> T { - return val; -} - -FMT_NORETURN FMT_API void assert_fail(const char* file, int line, - const char* message); - -#if defined(FMT_ASSERT) -// Use the provided definition. -#elif defined(NDEBUG) -// FMT_ASSERT is not empty to avoid -Wempty-body. -# define FMT_ASSERT(condition, message) \ - fmt::detail::ignore_unused((condition), (message)) -#else -# define FMT_ASSERT(condition, message) \ - ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ - ? (void)0 \ - : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) -#endif - -#ifdef FMT_USE_INT128 -// Use the provided definition. -#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ - !(FMT_CLANG_VERSION && FMT_MSC_VERSION) -# define FMT_USE_INT128 1 -using int128_opt = __int128_t; // An optional native 128-bit integer. -using uint128_opt = __uint128_t; -inline auto map(int128_opt x) -> int128_opt { return x; } -inline auto map(uint128_opt x) -> uint128_opt { return x; } -#else -# define FMT_USE_INT128 0 -#endif -#if !FMT_USE_INT128 -enum class int128_opt {}; -enum class uint128_opt {}; -// Reduce template instantiations. -inline auto map(int128_opt) -> monostate { return {}; } -inline auto map(uint128_opt) -> monostate { return {}; } -#endif - -#ifndef FMT_USE_BITINT -# define FMT_USE_BITINT (FMT_CLANG_VERSION >= 1500) -#endif - -#if FMT_USE_BITINT -FMT_PRAGMA_CLANG(diagnostic ignored "-Wbit-int-extension") -template using bitint = _BitInt(N); -template using ubitint = unsigned _BitInt(N); -#else -template struct bitint {}; -template struct ubitint {}; -#endif // FMT_USE_BITINT - -// Casts a nonnegative integer to unsigned. -template -FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t { -#if 0 - // LAMMPS customization: disable assertion to avoid bogus warnings - FMT_ASSERT(std::is_unsigned::value || value >= 0, "negative value"); -#endif - return static_cast>(value); -} - -template -using unsigned_char = conditional_t; - -// A heuristic to detect std::string and std::[experimental::]string_view. -// It is mainly used to avoid dependency on <[experimental/]string_view>. -template -struct is_std_string_like : std::false_type {}; -template -struct is_std_string_like().find_first_of( - typename T::value_type(), 0))>> - : std::is_convertible().data()), - const typename T::value_type*> {}; - -// Check if the literal encoding is UTF-8. -enum { is_utf8_enabled = "\u00A7"[1] == '\xA7' }; -enum { use_utf8 = !FMT_WIN32 || is_utf8_enabled }; - -#ifndef FMT_UNICODE -# define FMT_UNICODE 1 -#endif - -static_assert(!FMT_UNICODE || use_utf8, - "Unicode support requires compiling with /utf-8"); - -template constexpr const char* narrow(const T*) { return nullptr; } -constexpr FMT_ALWAYS_INLINE const char* narrow(const char* s) { return s; } - -template -FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n) - -> int { - if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n); - for (; n != 0; ++s1, ++s2, --n) { - if (*s1 < *s2) return -1; - if (*s1 > *s2) return 1; - } - return 0; -} - -namespace adl { -using namespace std; - -template -auto invoke_back_inserter() - -> decltype(back_inserter(std::declval())); -} // namespace adl - -template -struct is_back_insert_iterator : std::false_type {}; - -template -struct is_back_insert_iterator< - It, bool_constant()), - It>::value>> : std::true_type {}; - -// Extracts a reference to the container from *insert_iterator. -template -inline FMT_CONSTEXPR20 auto get_container(OutputIt it) -> - typename OutputIt::container_type& { - struct accessor : OutputIt { - FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {} - using OutputIt::container; - }; - return *accessor(it).container; -} -} // namespace detail - -// Parsing-related public API and forward declarations. -FMT_BEGIN_EXPORT - -/** - * An implementation of `std::basic_string_view` for pre-C++17. It provides a - * subset of the API. `fmt::basic_string_view` is used for format strings even - * if `std::basic_string_view` is available to prevent issues when a library is - * compiled with a different `-std` option than the client code (which is not - * recommended). - */ -template class basic_string_view { - private: - const Char* data_; - size_t size_; - - public: - using value_type = Char; - using iterator = const Char*; - - constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} - - /// Constructs a string reference object from a C string and a size. - constexpr basic_string_view(const Char* s, size_t count) noexcept - : data_(s), size_(count) {} - - constexpr basic_string_view(nullptr_t) = delete; - - /// Constructs a string reference object from a C string. -#if FMT_GCC_VERSION - FMT_ALWAYS_INLINE -#endif - FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) { -#if FMT_HAS_BUILTIN(__buitin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION - if (std::is_same::value) { - size_ = __builtin_strlen(detail::narrow(s)); - return; - } -#endif - size_t len = 0; - while (*s++) ++len; - size_ = len; - } - - /// Constructs a string reference from a `std::basic_string` or a - /// `std::basic_string_view` object. - template ::value&& std::is_same< - typename S::value_type, Char>::value)> - FMT_CONSTEXPR basic_string_view(const S& s) noexcept - : data_(s.data()), size_(s.size()) {} - - /// Returns a pointer to the string data. - constexpr auto data() const noexcept -> const Char* { return data_; } - - /// Returns the string size. - constexpr auto size() const noexcept -> size_t { return size_; } - - constexpr auto begin() const noexcept -> iterator { return data_; } - constexpr auto end() const noexcept -> iterator { return data_ + size_; } - - constexpr auto operator[](size_t pos) const noexcept -> const Char& { - return data_[pos]; - } - - FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { - data_ += n; - size_ -= n; - } - - FMT_CONSTEXPR auto starts_with(basic_string_view sv) const noexcept - -> bool { - return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0; - } - FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool { - return size_ >= 1 && *data_ == c; - } - FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool { - return starts_with(basic_string_view(s)); - } - - // Lexicographically compare this string reference to other. - FMT_CONSTEXPR auto compare(basic_string_view other) const -> int { - int result = - detail::compare(data_, other.data_, min_of(size_, other.size_)); - if (result != 0) return result; - return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); - } - - FMT_CONSTEXPR friend auto operator==(basic_string_view lhs, - basic_string_view rhs) -> bool { - return lhs.compare(rhs) == 0; - } - friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) != 0; - } - friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) < 0; - } - friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) <= 0; - } - friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) > 0; - } - friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) >= 0; - } -}; - -using string_view = basic_string_view; - -/// Specifies if `T` is an extended character type. Can be specialized by users. -template struct is_xchar : std::false_type {}; -template <> struct is_xchar : std::true_type {}; -template <> struct is_xchar : std::true_type {}; -template <> struct is_xchar : std::true_type {}; -#ifdef __cpp_char8_t -template <> struct is_xchar : std::true_type {}; -#endif - -// DEPRECATED! Will be replaced with an alias to prevent specializations. -template struct is_char : is_xchar {}; -template <> struct is_char : std::true_type {}; - -template class basic_appender; -using appender = basic_appender; - -// Checks whether T is a container with contiguous storage. -template struct is_contiguous : std::false_type {}; - -class context; -template class generic_context; -template class parse_context; - -// Longer aliases for C++20 compatibility. -template using basic_format_parse_context = parse_context; -using format_parse_context = parse_context; -template -using basic_format_context = - conditional_t::value, context, - generic_context>; -using format_context = context; - -template -using buffered_context = - conditional_t::value, context, - generic_context, Char>>; - -template class basic_format_arg; -template class basic_format_args; - -// A separate type would result in shorter symbols but break ABI compatibility -// between clang and gcc on ARM (#1919). -using format_args = basic_format_args; - -// A formatter for objects of type T. -template -struct formatter { - // A deleted default constructor indicates a disabled formatter. - formatter() = delete; -}; - -/// Reports a format error at compile time or, via a `format_error` exception, -/// at runtime. -// This function is intentionally not constexpr to give a compile-time error. -FMT_NORETURN FMT_API void report_error(const char* message); - -enum class presentation_type : unsigned char { - // Common specifiers: - none = 0, - debug = 1, // '?' - string = 2, // 's' (string, bool) - - // Integral, bool and character specifiers: - dec = 3, // 'd' - hex, // 'x' or 'X' - oct, // 'o' - bin, // 'b' or 'B' - chr, // 'c' - - // String and pointer specifiers: - pointer = 3, // 'p' - - // Floating-point specifiers: - exp = 1, // 'e' or 'E' (1 since there is no FP debug presentation) - fixed, // 'f' or 'F' - general, // 'g' or 'G' - hexfloat // 'a' or 'A' -}; - -enum class align { none, left, right, center, numeric }; -enum class sign { none, minus, plus, space }; -enum class arg_id_kind { none, index, name }; - -// Basic format specifiers for built-in and string types. -class basic_specs { - private: - // Data is arranged as follows: - // - // 0 1 2 3 - // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 - // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - // |type |align| w | p | s |u|#|L| f | unused | - // +-----+-----+---+---+---+-+-+-+-----+---------------------------+ - // - // w - dynamic width info - // p - dynamic precision info - // s - sign - // u - uppercase (e.g. 'X' for 'x') - // # - alternate form ('#') - // L - localized - // f - fill size - // - // Bitfields are not used because of compiler bugs such as gcc bug 61414. - enum : unsigned { - type_mask = 0x00007, - align_mask = 0x00038, - width_mask = 0x000C0, - precision_mask = 0x00300, - sign_mask = 0x00C00, - uppercase_mask = 0x01000, - alternate_mask = 0x02000, - localized_mask = 0x04000, - fill_size_mask = 0x38000, - - align_shift = 3, - width_shift = 6, - precision_shift = 8, - sign_shift = 10, - fill_size_shift = 15, - - max_fill_size = 4 - }; - - size_t data_ = 1 << fill_size_shift; - - // Character (code unit) type is erased to prevent template bloat. - char fill_data_[max_fill_size] = {' '}; - - FMT_CONSTEXPR void set_fill_size(size_t size) { - data_ = (data_ & ~fill_size_mask) | (size << fill_size_shift); - } - - public: - constexpr auto type() const -> presentation_type { - return static_cast(data_ & type_mask); - } - FMT_CONSTEXPR void set_type(presentation_type t) { - data_ = (data_ & ~type_mask) | static_cast(t); - } - - constexpr auto align() const -> align { - return static_cast((data_ & align_mask) >> align_shift); - } - FMT_CONSTEXPR void set_align(fmt::align a) { - data_ = (data_ & ~align_mask) | (static_cast(a) << align_shift); - } - - constexpr auto dynamic_width() const -> arg_id_kind { - return static_cast((data_ & width_mask) >> width_shift); - } - FMT_CONSTEXPR void set_dynamic_width(arg_id_kind w) { - data_ = (data_ & ~width_mask) | (static_cast(w) << width_shift); - } - - FMT_CONSTEXPR auto dynamic_precision() const -> arg_id_kind { - return static_cast((data_ & precision_mask) >> - precision_shift); - } - FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) { - data_ = (data_ & ~precision_mask) | - (static_cast(p) << precision_shift); - } - - constexpr bool dynamic() const { - return (data_ & (width_mask | precision_mask)) != 0; - } - - constexpr auto sign() const -> sign { - return static_cast((data_ & sign_mask) >> sign_shift); - } - FMT_CONSTEXPR void set_sign(fmt::sign s) { - data_ = (data_ & ~sign_mask) | (static_cast(s) << sign_shift); - } - - constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; } - FMT_CONSTEXPR void set_upper() { data_ |= uppercase_mask; } - - constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; } - FMT_CONSTEXPR void set_alt() { data_ |= alternate_mask; } - FMT_CONSTEXPR void clear_alt() { data_ &= ~alternate_mask; } - - constexpr auto localized() const -> bool { - return (data_ & localized_mask) != 0; - } - FMT_CONSTEXPR void set_localized() { data_ |= localized_mask; } - - constexpr auto fill_size() const -> size_t { - return (data_ & fill_size_mask) >> fill_size_shift; - } - - template ::value)> - constexpr auto fill() const -> const Char* { - return fill_data_; - } - template ::value)> - constexpr auto fill() const -> const Char* { - return nullptr; - } - - template constexpr auto fill_unit() const -> Char { - using uchar = unsigned char; - return static_cast(static_cast(fill_data_[0]) | - (static_cast(fill_data_[1]) << 8) | - (static_cast(fill_data_[2]) << 16)); - } - - FMT_CONSTEXPR void set_fill(char c) { - fill_data_[0] = c; - set_fill_size(1); - } - - template - FMT_CONSTEXPR void set_fill(basic_string_view s) { - auto size = s.size(); - set_fill_size(size); - if (size == 1) { - unsigned uchar = static_cast>(s[0]); - fill_data_[0] = static_cast(uchar); - fill_data_[1] = static_cast(uchar >> 8); - fill_data_[2] = static_cast(uchar >> 16); - return; - } - FMT_ASSERT(size <= max_fill_size, "invalid fill"); - for (size_t i = 0; i < size; ++i) - fill_data_[i & 3] = static_cast(s[i]); - } - - FMT_CONSTEXPR void copy_fill_from(const basic_specs& specs) { - set_fill_size(specs.fill_size()); - for (size_t i = 0; i < max_fill_size; ++i) - fill_data_[i] = specs.fill_data_[i]; - } -}; - -// Format specifiers for built-in and string types. -struct format_specs : basic_specs { - int width; - int precision; - - constexpr format_specs() : width(0), precision(-1) {} -}; - -/** - * Parsing context consisting of a format string range being parsed and an - * argument counter for automatic indexing. - */ -template class parse_context { - private: - basic_string_view fmt_; - int next_arg_id_; - - enum { use_constexpr_cast = !FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200 }; - - FMT_CONSTEXPR void do_check_arg_id(int arg_id); - - public: - using char_type = Char; - using iterator = const Char*; - - constexpr explicit parse_context(basic_string_view fmt, - int next_arg_id = 0) - : fmt_(fmt), next_arg_id_(next_arg_id) {} - - /// Returns an iterator to the beginning of the format string range being - /// parsed. - constexpr auto begin() const noexcept -> iterator { return fmt_.begin(); } - - /// Returns an iterator past the end of the format string range being parsed. - constexpr auto end() const noexcept -> iterator { return fmt_.end(); } - - /// Advances the begin iterator to `it`. - FMT_CONSTEXPR void advance_to(iterator it) { - fmt_.remove_prefix(detail::to_unsigned(it - begin())); - } - - /// Reports an error if using the manual argument indexing; otherwise returns - /// the next argument index and switches to the automatic indexing. - FMT_CONSTEXPR auto next_arg_id() -> int { - if (next_arg_id_ < 0) { - report_error("cannot switch from manual to automatic argument indexing"); - return 0; - } - int id = next_arg_id_++; - do_check_arg_id(id); - return id; - } - - /// Reports an error if using the automatic argument indexing; otherwise - /// switches to the manual indexing. - FMT_CONSTEXPR void check_arg_id(int id) { - if (next_arg_id_ > 0) { - report_error("cannot switch from automatic to manual argument indexing"); - return; - } - next_arg_id_ = -1; - do_check_arg_id(id); - } - FMT_CONSTEXPR void check_arg_id(basic_string_view) { - next_arg_id_ = -1; - } - FMT_CONSTEXPR void check_dynamic_spec(int arg_id); -}; - -FMT_END_EXPORT - -namespace detail { - -// Constructs fmt::basic_string_view from types implicitly convertible -// to it, deducing Char. Explicitly convertible types such as the ones returned -// from FMT_STRING are intentionally excluded. -template ::value)> -constexpr auto to_string_view(const Char* s) -> basic_string_view { - return s; -} -template ::value)> -constexpr auto to_string_view(const T& s) - -> basic_string_view { - return s; -} -template -constexpr auto to_string_view(basic_string_view s) - -> basic_string_view { - return s; -} - -template -struct has_to_string_view : std::false_type {}; -// detail:: is intentional since to_string_view is not an extension point. -template -struct has_to_string_view< - T, void_t()))>> - : std::true_type {}; - -/// String's character (code unit) type. detail:: is intentional to prevent ADL. -template ()))> -using char_t = typename V::value_type; - -enum class type { - none_type, - // Integer types should go first, - int_type, - uint_type, - long_long_type, - ulong_long_type, - int128_type, - uint128_type, - bool_type, - char_type, - last_integer_type = char_type, - // followed by floating-point types. - float_type, - double_type, - long_double_type, - last_numeric_type = long_double_type, - cstring_type, - string_type, - pointer_type, - custom_type -}; - -// Maps core type T to the corresponding type enum constant. -template -struct type_constant : std::integral_constant {}; - -#define FMT_TYPE_CONSTANT(Type, constant) \ - template \ - struct type_constant \ - : std::integral_constant {} - -FMT_TYPE_CONSTANT(int, int_type); -FMT_TYPE_CONSTANT(unsigned, uint_type); -FMT_TYPE_CONSTANT(long long, long_long_type); -FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); -FMT_TYPE_CONSTANT(int128_opt, int128_type); -FMT_TYPE_CONSTANT(uint128_opt, uint128_type); -FMT_TYPE_CONSTANT(bool, bool_type); -FMT_TYPE_CONSTANT(Char, char_type); -FMT_TYPE_CONSTANT(float, float_type); -FMT_TYPE_CONSTANT(double, double_type); -FMT_TYPE_CONSTANT(long double, long_double_type); -FMT_TYPE_CONSTANT(const Char*, cstring_type); -FMT_TYPE_CONSTANT(basic_string_view, string_type); -FMT_TYPE_CONSTANT(const void*, pointer_type); - -constexpr auto is_integral_type(type t) -> bool { - return t > type::none_type && t <= type::last_integer_type; -} -constexpr auto is_arithmetic_type(type t) -> bool { - return t > type::none_type && t <= type::last_numeric_type; -} - -constexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); } -constexpr auto in(type t, int set) -> bool { - return ((set >> static_cast(t)) & 1) != 0; -} - -// Bitsets of types. -enum { - sint_set = - set(type::int_type) | set(type::long_long_type) | set(type::int128_type), - uint_set = set(type::uint_type) | set(type::ulong_long_type) | - set(type::uint128_type), - bool_set = set(type::bool_type), - char_set = set(type::char_type), - float_set = set(type::float_type) | set(type::double_type) | - set(type::long_double_type), - string_set = set(type::string_type), - cstring_set = set(type::cstring_type), - pointer_set = set(type::pointer_type) -}; - -struct view {}; - -template struct named_arg; -template struct is_named_arg : std::false_type {}; -template struct is_static_named_arg : std::false_type {}; - -template -struct is_named_arg> : std::true_type {}; - -template struct named_arg : view { - const Char* name; - const T& value; - - named_arg(const Char* n, const T& v) : name(n), value(v) {} - static_assert(!is_named_arg::value, "nested named arguments"); -}; - -template constexpr auto count() -> int { return B ? 1 : 0; } -template constexpr auto count() -> int { - return (B1 ? 1 : 0) + count(); -} - -template constexpr auto count_named_args() -> int { - return count::value...>(); -} -template constexpr auto count_static_named_args() -> int { - return count::value...>(); -} - -template struct named_arg_info { - const Char* name; - int id; -}; - -template ::value)> -void init_named_arg(named_arg_info*, int& arg_index, int&, const T&) { - ++arg_index; -} -template ::value)> -void init_named_arg(named_arg_info* named_args, int& arg_index, - int& named_arg_index, const T& arg) { - named_args[named_arg_index++] = {arg.name, arg_index++}; -} - -template ::value)> -FMT_CONSTEXPR void init_static_named_arg(named_arg_info*, int& arg_index, - int&) { - ++arg_index; -} -template ::value)> -FMT_CONSTEXPR void init_static_named_arg(named_arg_info* named_args, - int& arg_index, int& named_arg_index) { - named_args[named_arg_index++] = {T::name, arg_index++}; -} - -// To minimize the number of types we need to deal with, long is translated -// either to int or to long long depending on its size. -enum { long_short = sizeof(long) == sizeof(int) }; -using long_type = conditional_t; -using ulong_type = conditional_t; - -template -using format_as_result = - remove_cvref_t()))>; -template -using format_as_member_result = - remove_cvref_t::format_as(std::declval()))>; - -template -struct use_format_as : std::false_type {}; -// format_as member is only used to avoid injection into the std namespace. -template -struct use_format_as_member : std::false_type {}; - -// Only map owning types because mapping views can be unsafe. -template -struct use_format_as< - T, bool_constant>::value>> - : std::true_type {}; -template -struct use_format_as_member< - T, bool_constant>::value>> - : std::true_type {}; - -template > -using use_formatter = - bool_constant<(std::is_class::value || std::is_enum::value || - std::is_union::value || std::is_array::value) && - !has_to_string_view::value && !is_named_arg::value && - !use_format_as::value && !use_format_as_member::value>; - -template > -auto has_formatter_impl(T* p, buffered_context* ctx = nullptr) - -> decltype(formatter().format(*p, *ctx), std::true_type()); -template auto has_formatter_impl(...) -> std::false_type; - -// T can be const-qualified to check if it is const-formattable. -template constexpr auto has_formatter() -> bool { - return decltype(has_formatter_impl(static_cast(nullptr)))::value; -} - -// Maps formatting argument types to natively supported types or user-defined -// types with formatters. Returns void on errors to be SFINAE-friendly. -template struct type_mapper { - static auto map(signed char) -> int; - static auto map(unsigned char) -> unsigned; - static auto map(short) -> int; - static auto map(unsigned short) -> unsigned; - static auto map(int) -> int; - static auto map(unsigned) -> unsigned; - static auto map(long) -> long_type; - static auto map(unsigned long) -> ulong_type; - static auto map(long long) -> long long; - static auto map(unsigned long long) -> unsigned long long; - static auto map(int128_opt) -> int128_opt; - static auto map(uint128_opt) -> uint128_opt; - static auto map(bool) -> bool; - - template - static auto map(bitint) -> conditional_t; - template - static auto map(ubitint) - -> conditional_t; - - template ::value)> - static auto map(T) -> conditional_t< - std::is_same::value || std::is_same::value, Char, void>; - - static auto map(float) -> float; - static auto map(double) -> double; - static auto map(long double) -> long double; - - static auto map(Char*) -> const Char*; - static auto map(const Char*) -> const Char*; - template , - FMT_ENABLE_IF(!std::is_pointer::value)> - static auto map(const T&) -> conditional_t::value, - basic_string_view, void>; - - static auto map(void*) -> const void*; - static auto map(const void*) -> const void*; - static auto map(volatile void*) -> const void*; - static auto map(const volatile void*) -> const void*; - static auto map(nullptr_t) -> const void*; - template ::value || - std::is_member_pointer::value)> - static auto map(const T&) -> void; - - template ::value)> - static auto map(const T& x) -> decltype(map(format_as(x))); - template ::value)> - static auto map(const T& x) -> decltype(map(formatter::format_as(x))); - - template ::value)> - static auto map(T&) -> conditional_t(), T&, void>; - - template ::value)> - static auto map(const T& named_arg) -> decltype(map(named_arg.value)); -}; - -// detail:: is used to workaround a bug in MSVC 2017. -template -using mapped_t = decltype(detail::type_mapper::map(std::declval())); - -// A type constant after applying type_mapper. -template -using mapped_type_constant = type_constant, Char>; - -template ::value> -using stored_type_constant = std::integral_constant< - type, Context::builtin_types || TYPE == type::int_type ? TYPE - : type::custom_type>; -// A parse context with extra data used only in compile-time checks. -template -class compile_parse_context : public parse_context { - private: - int num_args_; - const type* types_; - using base = parse_context; - - public: - FMT_CONSTEXPR explicit compile_parse_context(basic_string_view fmt, - int num_args, const type* types, - int next_arg_id = 0) - : base(fmt, next_arg_id), num_args_(num_args), types_(types) {} - - constexpr auto num_args() const -> int { return num_args_; } - constexpr auto arg_type(int id) const -> type { return types_[id]; } - - FMT_CONSTEXPR auto next_arg_id() -> int { - int id = base::next_arg_id(); - if (id >= num_args_) report_error("argument not found"); - return id; - } - - FMT_CONSTEXPR void check_arg_id(int id) { - base::check_arg_id(id); - if (id >= num_args_) report_error("argument not found"); - } - using base::check_arg_id; - - FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { - ignore_unused(arg_id); - if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) - report_error("width/precision is not integer"); - } -}; - -// An argument reference. -template union arg_ref { - FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {} - FMT_CONSTEXPR arg_ref(basic_string_view n) : name(n) {} - - int index; - basic_string_view name; -}; - -// Format specifiers with width and precision resolved at formatting rather -// than parsing time to allow reusing the same parsed specifiers with -// different sets of arguments (precompilation of format strings). -template struct dynamic_format_specs : format_specs { - arg_ref width_ref; - arg_ref precision_ref; -}; - -// Converts a character to ASCII. Returns '\0' on conversion failure. -template ::value)> -constexpr auto to_ascii(Char c) -> char { - return c <= 0xff ? static_cast(c) : '\0'; -} - -// Returns the number of code units in a code point or 1 on error. -template -FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { - if (const_check(sizeof(Char) != 1)) return 1; - auto c = static_cast(*begin); - return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 3) + 1; -} - -// Parses the range [begin, end) as an unsigned integer. This function assumes -// that the range is non-empty and the first character is a digit. -template -FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, - int error_value) noexcept -> int { - FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); - unsigned value = 0, prev = 0; - auto p = begin; - do { - prev = value; - value = value * 10 + unsigned(*p - '0'); - ++p; - } while (p != end && '0' <= *p && *p <= '9'); - auto num_digits = p - begin; - begin = p; - int digits10 = static_cast(sizeof(int) * CHAR_BIT * 3 / 10); - if (num_digits <= digits10) return static_cast(value); - // Check for overflow. - unsigned max = INT_MAX; - return num_digits == digits10 + 1 && - prev * 10ull + unsigned(p[-1] - '0') <= max - ? static_cast(value) - : error_value; -} - -FMT_CONSTEXPR inline auto parse_align(char c) -> align { - switch (c) { - case '<': return align::left; - case '>': return align::right; - case '^': return align::center; - } - return align::none; -} - -template constexpr auto is_name_start(Char c) -> bool { - return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; -} - -template -FMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end, - Handler&& handler) -> const Char* { - Char c = *begin; - if (c >= '0' && c <= '9') { - int index = 0; - if (c != '0') - index = parse_nonnegative_int(begin, end, INT_MAX); - else - ++begin; - if (begin == end || (*begin != '}' && *begin != ':')) - report_error("invalid format string"); - else - handler.on_index(index); - return begin; - } - if (FMT_OPTIMIZE_SIZE > 1 || !is_name_start(c)) { - report_error("invalid format string"); - return begin; - } - auto it = begin; - do { - ++it; - } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); - handler.on_name({begin, to_unsigned(it - begin)}); - return it; -} - -template struct dynamic_spec_handler { - parse_context& ctx; - arg_ref& ref; - arg_id_kind& kind; - - FMT_CONSTEXPR void on_index(int id) { - ref = id; - kind = arg_id_kind::index; - ctx.check_arg_id(id); - ctx.check_dynamic_spec(id); - } - FMT_CONSTEXPR void on_name(basic_string_view id) { - ref = id; - kind = arg_id_kind::name; - ctx.check_arg_id(id); - } -}; - -template struct parse_dynamic_spec_result { - const Char* end; - arg_id_kind kind; -}; - -// Parses integer | "{" [arg_id] "}". -template -FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, - int& value, arg_ref& ref, - parse_context& ctx) - -> parse_dynamic_spec_result { - FMT_ASSERT(begin != end, ""); - auto kind = arg_id_kind::none; - if ('0' <= *begin && *begin <= '9') { - int val = parse_nonnegative_int(begin, end, -1); - if (val == -1) report_error("number is too big"); - value = val; - } else { - if (*begin == '{') { - ++begin; - if (begin != end) { - Char c = *begin; - if (c == '}' || c == ':') { - int id = ctx.next_arg_id(); - ref = id; - kind = arg_id_kind::index; - ctx.check_dynamic_spec(id); - } else { - begin = parse_arg_id(begin, end, - dynamic_spec_handler{ctx, ref, kind}); - } - } - if (begin != end && *begin == '}') return {++begin, kind}; - } - report_error("invalid format string"); - } - return {begin, kind}; -} - -template -FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end, - format_specs& specs, arg_ref& width_ref, - parse_context& ctx) -> const Char* { - auto result = parse_dynamic_spec(begin, end, specs.width, width_ref, ctx); - specs.set_dynamic_width(result.kind); - return result.end; -} - -template -FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, - format_specs& specs, - arg_ref& precision_ref, - parse_context& ctx) -> const Char* { - ++begin; - if (begin == end) { - report_error("invalid precision"); - return begin; - } - auto result = - parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx); - specs.set_dynamic_precision(result.kind); - return result.end; -} - -enum class state { start, align, sign, hash, zero, width, precision, locale }; - -// Parses standard format specifiers. -template -FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end, - dynamic_format_specs& specs, - parse_context& ctx, type arg_type) - -> const Char* { - auto c = '\0'; - if (end - begin > 1) { - auto next = to_ascii(begin[1]); - c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; - } else { - if (begin == end) return begin; - c = to_ascii(*begin); - } - - struct { - state current_state = state::start; - FMT_CONSTEXPR void operator()(state s, bool valid = true) { - if (current_state >= s || !valid) - report_error("invalid format specifier"); - current_state = s; - } - } enter_state; - - using pres = presentation_type; - constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; - struct { - const Char*& begin; - format_specs& specs; - type arg_type; - - FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* { - if (!in(arg_type, set)) report_error("invalid format specifier"); - specs.set_type(pres_type); - return begin + 1; - } - } parse_presentation_type{begin, specs, arg_type}; - - for (;;) { - switch (c) { - case '<': - case '>': - case '^': - enter_state(state::align); - specs.set_align(parse_align(c)); - ++begin; - break; - case '+': - case ' ': - specs.set_sign(c == ' ' ? sign::space : sign::plus); - FMT_FALLTHROUGH; - case '-': - enter_state(state::sign, in(arg_type, sint_set | float_set)); - ++begin; - break; - case '#': - enter_state(state::hash, is_arithmetic_type(arg_type)); - specs.set_alt(); - ++begin; - break; - case '0': - enter_state(state::zero); - if (!is_arithmetic_type(arg_type)) - report_error("format specifier requires numeric argument"); - if (specs.align() == align::none) { - // Ignore 0 if align is specified for compatibility with std::format. - specs.set_align(align::numeric); - specs.set_fill('0'); - } - ++begin; - break; - // clang-format off - case '1': case '2': case '3': case '4': case '5': - case '6': case '7': case '8': case '9': case '{': - // clang-format on - enter_state(state::width); - begin = parse_width(begin, end, specs, specs.width_ref, ctx); - break; - case '.': - enter_state(state::precision, - in(arg_type, float_set | string_set | cstring_set)); - begin = parse_precision(begin, end, specs, specs.precision_ref, ctx); - break; - case 'L': - enter_state(state::locale, is_arithmetic_type(arg_type)); - specs.set_localized(); - ++begin; - break; - case 'd': return parse_presentation_type(pres::dec, integral_set); - case 'X': specs.set_upper(); FMT_FALLTHROUGH; - case 'x': return parse_presentation_type(pres::hex, integral_set); - case 'o': return parse_presentation_type(pres::oct, integral_set); - case 'B': specs.set_upper(); FMT_FALLTHROUGH; - case 'b': return parse_presentation_type(pres::bin, integral_set); - case 'E': specs.set_upper(); FMT_FALLTHROUGH; - case 'e': return parse_presentation_type(pres::exp, float_set); - case 'F': specs.set_upper(); FMT_FALLTHROUGH; - case 'f': return parse_presentation_type(pres::fixed, float_set); - case 'G': specs.set_upper(); FMT_FALLTHROUGH; - case 'g': return parse_presentation_type(pres::general, float_set); - case 'A': specs.set_upper(); FMT_FALLTHROUGH; - case 'a': return parse_presentation_type(pres::hexfloat, float_set); - case 'c': - if (arg_type == type::bool_type) report_error("invalid format specifier"); - return parse_presentation_type(pres::chr, integral_set); - case 's': - return parse_presentation_type(pres::string, - bool_set | string_set | cstring_set); - case 'p': - return parse_presentation_type(pres::pointer, pointer_set | cstring_set); - case '?': - return parse_presentation_type(pres::debug, - char_set | string_set | cstring_set); - case '}': return begin; - default: { - if (*begin == '}') return begin; - // Parse fill and alignment. - auto fill_end = begin + code_point_length(begin); - if (end - fill_end <= 0) { - report_error("invalid format specifier"); - return begin; - } - if (*begin == '{') { - report_error("invalid fill character '{'"); - return begin; - } - auto alignment = parse_align(to_ascii(*fill_end)); - enter_state(state::align, alignment != align::none); - specs.set_fill( - basic_string_view(begin, to_unsigned(fill_end - begin))); - specs.set_align(alignment); - begin = fill_end + 1; - } - } - if (begin == end) return begin; - c = to_ascii(*begin); - } -} - -template -FMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(const Char* begin, - const Char* end, - Handler&& handler) - -> const Char* { - ++begin; - if (begin == end) { - handler.on_error("invalid format string"); - return end; - } - int arg_id = 0; - switch (*begin) { - case '}': - handler.on_replacement_field(handler.on_arg_id(), begin); - return begin + 1; - case '{': handler.on_text(begin, begin + 1); return begin + 1; - case ':': arg_id = handler.on_arg_id(); break; - default: { - struct id_adapter { - Handler& handler; - int arg_id; - - FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } - FMT_CONSTEXPR void on_name(basic_string_view id) { - arg_id = handler.on_arg_id(id); - } - } adapter = {handler, 0}; - begin = parse_arg_id(begin, end, adapter); - arg_id = adapter.arg_id; - Char c = begin != end ? *begin : Char(); - if (c == '}') { - handler.on_replacement_field(arg_id, begin); - return begin + 1; - } - if (c != ':') { - handler.on_error("missing '}' in format string"); - return end; - } - break; - } - } - begin = handler.on_format_specs(arg_id, begin + 1, end); - if (begin == end || *begin != '}') - return handler.on_error("unknown format specifier"), end; - return begin + 1; -} - -template -FMT_CONSTEXPR void parse_format_string(basic_string_view fmt, - Handler&& handler) { - auto begin = fmt.data(), end = begin + fmt.size(); - auto p = begin; - while (p != end) { - auto c = *p++; - if (c == '{') { - handler.on_text(begin, p - 1); - begin = p = parse_replacement_field(p - 1, end, handler); - } else if (c == '}') { - if (p == end || *p != '}') - return handler.on_error("unmatched '}' in format string"); - handler.on_text(begin, p); - begin = ++p; - } - } - handler.on_text(begin, end); -} - -// Checks char specs and returns true iff the presentation type is char-like. -FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool { - auto type = specs.type(); - if (type != presentation_type::none && type != presentation_type::chr && - type != presentation_type::debug) { - return false; - } - if (specs.align() == align::numeric || specs.sign() != sign::none || - specs.alt()) { - report_error("invalid format specifier for char"); - } - return true; -} - -// A base class for compile-time strings. -struct compile_string {}; - -template -FMT_VISIBILITY("hidden") // Suppress an ld warning on macOS (#3769). -FMT_CONSTEXPR auto invoke_parse(parse_context& ctx) -> const Char* { - using mapped_type = remove_cvref_t>; - constexpr bool formattable = - std::is_constructible>::value; - if (!formattable) return ctx.begin(); // Error is reported in the value ctor. - using formatted_type = conditional_t; - return formatter().parse(ctx); -} - -template struct arg_pack {}; - -template -class format_string_checker { - private: - type types_[max_of(1, NUM_ARGS)]; - named_arg_info named_args_[max_of(1, NUM_NAMED_ARGS)]; - compile_parse_context context_; - - using parse_func = auto (*)(parse_context&) -> const Char*; - parse_func parse_funcs_[max_of(1, NUM_ARGS)]; - - public: - template - FMT_CONSTEXPR explicit format_string_checker(basic_string_view fmt, - arg_pack) - : types_{mapped_type_constant::value...}, - named_args_{}, - context_(fmt, NUM_ARGS, types_), - parse_funcs_{&invoke_parse...} { - int arg_index = 0, named_arg_index = 0; - FMT_APPLY_VARIADIC( - init_static_named_arg(named_args_, arg_index, named_arg_index)); - ignore_unused(arg_index, named_arg_index); - } - - FMT_CONSTEXPR void on_text(const Char*, const Char*) {} - - FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } - FMT_CONSTEXPR auto on_arg_id(int id) -> int { - context_.check_arg_id(id); - return id; - } - FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { - for (int i = 0; i < NUM_NAMED_ARGS; ++i) { - if (named_args_[i].name == id) return named_args_[i].id; - } - if (!DYNAMIC_NAMES) on_error("argument not found"); - return -1; - } - - FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) { - on_format_specs(id, begin, begin); // Call parse() on empty specs. - } - - FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char* end) - -> const Char* { - context_.advance_to(begin); - if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_); - while (begin != end && *begin != '}') ++begin; - return begin; - } - - FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) { - report_error(message); - } -}; - -/// A contiguous memory buffer with an optional growing ability. It is an -/// internal class and shouldn't be used directly, only via `memory_buffer`. -template class buffer { - private: - T* ptr_; - size_t size_; - size_t capacity_; - - using grow_fun = void (*)(buffer& buf, size_t capacity); - grow_fun grow_; - - protected: - // Don't initialize ptr_ since it is not accessed to save a few cycles. - FMT_MSC_WARNING(suppress : 26495) - FMT_CONSTEXPR buffer(grow_fun grow, size_t sz) noexcept - : size_(sz), capacity_(sz), grow_(grow) {} - - constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0, - size_t cap = 0) noexcept - : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {} - - FMT_CONSTEXPR20 ~buffer() = default; - buffer(buffer&&) = default; - - /// Sets the buffer data and capacity. - FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { - ptr_ = buf_data; - capacity_ = buf_capacity; - } - - public: - using value_type = T; - using const_reference = const T&; - - buffer(const buffer&) = delete; - void operator=(const buffer&) = delete; - - auto begin() noexcept -> T* { return ptr_; } - auto end() noexcept -> T* { return ptr_ + size_; } - - auto begin() const noexcept -> const T* { return ptr_; } - auto end() const noexcept -> const T* { return ptr_ + size_; } - - /// Returns the size of this buffer. - constexpr auto size() const noexcept -> size_t { return size_; } - - /// Returns the capacity of this buffer. - constexpr auto capacity() const noexcept -> size_t { return capacity_; } - - /// Returns a pointer to the buffer data (not null-terminated). - FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } - FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } - - /// Clears this buffer. - FMT_CONSTEXPR void clear() { size_ = 0; } - - // Tries resizing the buffer to contain `count` elements. If T is a POD type - // the new elements may not be initialized. - FMT_CONSTEXPR void try_resize(size_t count) { - try_reserve(count); - size_ = min_of(count, capacity_); - } - - // Tries increasing the buffer capacity to `new_capacity`. It can increase the - // capacity by a smaller amount than requested but guarantees there is space - // for at least one additional element either by increasing the capacity or by - // flushing the buffer if it is full. - FMT_CONSTEXPR void try_reserve(size_t new_capacity) { - if (new_capacity > capacity_) grow_(*this, new_capacity); - } - - FMT_CONSTEXPR void push_back(const T& value) { - try_reserve(size_ + 1); - ptr_[size_++] = value; - } - - /// Appends data to the end of the buffer. - template -// Workaround for MSVC2019 to fix error C2893: Failed to specialize function -// template 'void fmt::v11::detail::buffer::append(const U *,const U *)'. -#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940 - FMT_CONSTEXPR20 -#endif - void - append(const U* begin, const U* end) { - while (begin != end) { - auto count = to_unsigned(end - begin); - try_reserve(size_ + count); - auto free_cap = capacity_ - size_; - if (free_cap < count) count = free_cap; - // A loop is faster than memcpy on small sizes. - T* out = ptr_ + size_; - for (size_t i = 0; i < count; ++i) out[i] = begin[i]; - size_ += count; - begin += count; - } - } - - template FMT_CONSTEXPR auto operator[](Idx index) -> T& { - return ptr_[index]; - } - template - FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { - return ptr_[index]; - } -}; - -struct buffer_traits { - constexpr explicit buffer_traits(size_t) {} - constexpr auto count() const -> size_t { return 0; } - constexpr auto limit(size_t size) const -> size_t { return size; } -}; - -class fixed_buffer_traits { - private: - size_t count_ = 0; - size_t limit_; - - public: - constexpr explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} - constexpr auto count() const -> size_t { return count_; } - FMT_CONSTEXPR auto limit(size_t size) -> size_t { - size_t n = limit_ > count_ ? limit_ - count_ : 0; - count_ += size; - return min_of(size, n); - } -}; - -// A buffer that writes to an output iterator when flushed. -template -class iterator_buffer : public Traits, public buffer { - private: - OutputIt out_; - enum { buffer_size = 256 }; - T data_[buffer_size]; - - static FMT_CONSTEXPR void grow(buffer& buf, size_t) { - if (buf.size() == buffer_size) static_cast(buf).flush(); - } - - void flush() { - auto size = this->size(); - this->clear(); - const T* begin = data_; - const T* end = begin + this->limit(size); - while (begin != end) *out_++ = *begin++; - } - - public: - explicit iterator_buffer(OutputIt out, size_t n = buffer_size) - : Traits(n), buffer(grow, data_, 0, buffer_size), out_(out) {} - iterator_buffer(iterator_buffer&& other) noexcept - : Traits(other), - buffer(grow, data_, 0, buffer_size), - out_(other.out_) {} - ~iterator_buffer() { - // Don't crash if flush fails during unwinding. - FMT_TRY { flush(); } - FMT_CATCH(...) {} - } - - auto out() -> OutputIt { - flush(); - return out_; - } - auto count() const -> size_t { return Traits::count() + this->size(); } -}; - -template -class iterator_buffer : public fixed_buffer_traits, - public buffer { - private: - T* out_; - enum { buffer_size = 256 }; - T data_[buffer_size]; - - static FMT_CONSTEXPR void grow(buffer& buf, size_t) { - if (buf.size() == buf.capacity()) - static_cast(buf).flush(); - } - - void flush() { - size_t n = this->limit(this->size()); - if (this->data() == out_) { - out_ += n; - this->set(data_, buffer_size); - } - this->clear(); - } - - public: - explicit iterator_buffer(T* out, size_t n = buffer_size) - : fixed_buffer_traits(n), buffer(grow, out, 0, n), out_(out) {} - iterator_buffer(iterator_buffer&& other) noexcept - : fixed_buffer_traits(other), - buffer(static_cast(other)), - out_(other.out_) { - if (this->data() != out_) { - this->set(data_, buffer_size); - this->clear(); - } - } - ~iterator_buffer() { flush(); } - - auto out() -> T* { - flush(); - return out_; - } - auto count() const -> size_t { - return fixed_buffer_traits::count() + this->size(); - } -}; - -template class iterator_buffer : public buffer { - public: - explicit iterator_buffer(T* out, size_t = 0) - : buffer([](buffer&, size_t) {}, out, 0, ~size_t()) {} - - auto out() -> T* { return &*this->end(); } -}; - -template -class container_buffer : public buffer { - private: - using value_type = typename Container::value_type; - - static FMT_CONSTEXPR void grow(buffer& buf, size_t capacity) { - auto& self = static_cast(buf); - self.container.resize(capacity); - self.set(&self.container[0], capacity); - } - - public: - Container& container; - - explicit container_buffer(Container& c) - : buffer(grow, c.size()), container(c) {} -}; - -// A buffer that writes to a container with the contiguous storage. -template -class iterator_buffer< - OutputIt, - enable_if_t::value && - is_contiguous::value, - typename OutputIt::container_type::value_type>> - : public container_buffer { - private: - using base = container_buffer; - - public: - explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {} - explicit iterator_buffer(OutputIt out, size_t = 0) - : base(get_container(out)) {} - - auto out() -> OutputIt { return OutputIt(this->container); } -}; - -// A buffer that counts the number of code units written discarding the output. -template class counting_buffer : public buffer { - private: - enum { buffer_size = 256 }; - T data_[buffer_size]; - size_t count_ = 0; - - static FMT_CONSTEXPR void grow(buffer& buf, size_t) { - if (buf.size() != buffer_size) return; - static_cast(buf).count_ += buf.size(); - buf.clear(); - } - - public: - FMT_CONSTEXPR counting_buffer() : buffer(grow, data_, 0, buffer_size) {} - - constexpr auto count() const noexcept -> size_t { - return count_ + this->size(); - } -}; - -template -struct is_back_insert_iterator> : std::true_type {}; - -template -struct has_back_insert_iterator_container_append : std::false_type {}; -template -struct has_back_insert_iterator_container_append< - OutputIt, InputIt, - void_t()) - .append(std::declval(), - std::declval()))>> : std::true_type {}; - -// An optimized version of std::copy with the output value type (T). -template ::value&& - has_back_insert_iterator_container_append< - OutputIt, InputIt>::value)> -FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out) - -> OutputIt { - get_container(out).append(begin, end); - return out; -} - -template ::value && - !has_back_insert_iterator_container_append< - OutputIt, InputIt>::value)> -FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out) - -> OutputIt { - auto& c = get_container(out); - c.insert(c.end(), begin, end); - return out; -} - -template ::value)> -FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { - while (begin != end) *out++ = static_cast(*begin++); - return out; -} - -template -FMT_CONSTEXPR auto copy(basic_string_view s, OutputIt out) -> OutputIt { - return copy(s.begin(), s.end(), out); -} - -template -struct is_buffer_appender : std::false_type {}; -template -struct is_buffer_appender< - It, bool_constant< - is_back_insert_iterator::value && - std::is_base_of, - typename It::container_type>::value>> - : std::true_type {}; - -// Maps an output iterator to a buffer. -template ::value)> -auto get_buffer(OutputIt out) -> iterator_buffer { - return iterator_buffer(out); -} -template ::value)> -auto get_buffer(OutputIt out) -> buffer& { - return get_container(out); -} - -template -auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { - return buf.out(); -} -template -auto get_iterator(buffer&, OutputIt out) -> OutputIt { - return out; -} - -// This type is intentionally undefined, only used for errors. -template struct type_is_unformattable_for; - -template struct string_value { - const Char* data; - size_t size; - auto str() const -> basic_string_view { return {data, size}; } -}; - -template struct custom_value { - using char_type = typename Context::char_type; - void* value; - void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); -}; - -template struct named_arg_value { - const named_arg_info* data; - size_t size; -}; - -struct custom_tag {}; - -#if !FMT_BUILTIN_TYPES -# define FMT_BUILTIN , monostate -#else -# define FMT_BUILTIN -#endif - -// A formatting argument value. -template class value { - public: - using char_type = typename Context::char_type; - - union { - monostate no_value; - int int_value; - unsigned uint_value; - long long long_long_value; - unsigned long long ulong_long_value; - int128_opt int128_value; - uint128_opt uint128_value; - bool bool_value; - char_type char_value; - float float_value; - double double_value; - long double long_double_value; - const void* pointer; - string_value string; - custom_value custom; - named_arg_value named_args; - }; - - constexpr FMT_INLINE value() : no_value() {} - constexpr FMT_INLINE value(signed char x) : int_value(x) {} - constexpr FMT_INLINE value(unsigned char x FMT_BUILTIN) : uint_value(x) {} - constexpr FMT_INLINE value(signed short x) : int_value(x) {} - constexpr FMT_INLINE value(unsigned short x FMT_BUILTIN) : uint_value(x) {} - constexpr FMT_INLINE value(int x) : int_value(x) {} - constexpr FMT_INLINE value(unsigned x FMT_BUILTIN) : uint_value(x) {} - FMT_CONSTEXPR FMT_INLINE value(long x FMT_BUILTIN) : value(long_type(x)) {} - FMT_CONSTEXPR FMT_INLINE value(unsigned long x FMT_BUILTIN) - : value(ulong_type(x)) {} - constexpr FMT_INLINE value(long long x FMT_BUILTIN) : long_long_value(x) {} - constexpr FMT_INLINE value(unsigned long long x FMT_BUILTIN) - : ulong_long_value(x) {} - FMT_INLINE value(int128_opt x FMT_BUILTIN) : int128_value(x) {} - FMT_INLINE value(uint128_opt x FMT_BUILTIN) : uint128_value(x) {} - constexpr FMT_INLINE value(bool x FMT_BUILTIN) : bool_value(x) {} - - template - constexpr FMT_INLINE value(bitint x FMT_BUILTIN) : long_long_value(x) { - static_assert(N <= 64, "unsupported _BitInt"); - } - template - constexpr FMT_INLINE value(ubitint x FMT_BUILTIN) : ulong_long_value(x) { - static_assert(N <= 64, "unsupported _BitInt"); - } - - template ::value)> - constexpr FMT_INLINE value(T x FMT_BUILTIN) : char_value(x) { - static_assert( - std::is_same::value || std::is_same::value, - "mixing character types is disallowed"); - } - - constexpr FMT_INLINE value(float x FMT_BUILTIN) : float_value(x) {} - constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {} - FMT_INLINE value(long double x FMT_BUILTIN) : long_double_value(x) {} - - FMT_CONSTEXPR FMT_INLINE value(char_type* x FMT_BUILTIN) { - string.data = x; - if (is_constant_evaluated()) string.size = 0; - } - FMT_CONSTEXPR FMT_INLINE value(const char_type* x FMT_BUILTIN) { - string.data = x; - if (is_constant_evaluated()) string.size = 0; - } - template , - FMT_ENABLE_IF(!std::is_pointer::value)> - FMT_CONSTEXPR value(const T& x FMT_BUILTIN) { - static_assert(std::is_same::value, - "mixing character types is disallowed"); - auto sv = to_string_view(x); - string.data = sv.data(); - string.size = sv.size(); - } - FMT_INLINE value(void* x FMT_BUILTIN) : pointer(x) {} - FMT_INLINE value(const void* x FMT_BUILTIN) : pointer(x) {} - FMT_INLINE value(volatile void* x FMT_BUILTIN) - : pointer(const_cast(x)) {} - FMT_INLINE value(const volatile void* x FMT_BUILTIN) - : pointer(const_cast(x)) {} - FMT_INLINE value(nullptr_t) : pointer(nullptr) {} - - template ::value || - std::is_member_pointer::value)> - value(const T&) { - // Formatting of arbitrary pointers is disallowed. If you want to format a - // pointer cast it to `void*` or `const void*`. In particular, this forbids - // formatting of `[const] volatile char*` printed as bool by iostreams. - static_assert(sizeof(T) == 0, - "formatting of non-void pointers is disallowed"); - } - - template ::value)> - value(const T& x) : value(format_as(x)) {} - template ::value)> - value(const T& x) : value(formatter::format_as(x)) {} - - template ::value)> - value(const T& named_arg) : value(named_arg.value) {} - - template ::value || !FMT_BUILTIN_TYPES)> - FMT_CONSTEXPR20 FMT_INLINE value(T& x) : value(x, custom_tag()) {} - - FMT_ALWAYS_INLINE value(const named_arg_info* args, size_t size) - : named_args{args, size} {} - - private: - template ())> - FMT_CONSTEXPR value(T& x, custom_tag) { - using value_type = remove_const_t; - // T may overload operator& e.g. std::vector::reference in libc++. - if (!is_constant_evaluated()) { - custom.value = - const_cast(&reinterpret_cast(x)); - } else { - custom.value = nullptr; -#if defined(__cpp_if_constexpr) - if constexpr (std::is_same*>::value) - custom.value = const_cast(&x); -#endif - } - custom.format = format_custom>; - } - - template ())> - FMT_CONSTEXPR value(const T&, custom_tag) { - // Cannot format an argument; to make type T formattable provide a - // formatter specialization: https://fmt.dev/latest/api.html#udt. - type_is_unformattable_for _; - } - - // Formats an argument of a custom type, such as a user-defined class. - template - static void format_custom(void* arg, parse_context& parse_ctx, - Context& ctx) { - auto f = Formatter(); - parse_ctx.advance_to(f.parse(parse_ctx)); - using qualified_type = - conditional_t(), const T, T>; - // format must be const for compatibility with std::format and compilation. - const auto& cf = f; - ctx.advance_to(cf.format(*static_cast(arg), ctx)); - } -}; - -enum { packed_arg_bits = 4 }; -// Maximum number of arguments with packed types. -enum { max_packed_args = 62 / packed_arg_bits }; -enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; -enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; - -template -struct is_output_iterator : std::false_type {}; - -template <> struct is_output_iterator : std::true_type {}; - -template -struct is_output_iterator< - It, T, - void_t&>()++ = std::declval())>> - : std::true_type {}; - -#ifndef FMT_USE_LOCALE -# define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1) -#endif - -// A type-erased reference to an std::locale to avoid a heavy include. -struct locale_ref { -#if FMT_USE_LOCALE - private: - const void* locale_; // A type-erased pointer to std::locale. - - public: - constexpr locale_ref() : locale_(nullptr) {} - template locale_ref(const Locale& loc); - - inline explicit operator bool() const noexcept { return locale_ != nullptr; } -#endif // FMT_USE_LOCALE - - template auto get() const -> Locale; -}; - -template constexpr auto encode_types() -> unsigned long long { - return 0; -} - -template -constexpr auto encode_types() -> unsigned long long { - return static_cast(stored_type_constant::value) | - (encode_types() << packed_arg_bits); -} - -template -constexpr auto make_descriptor() -> unsigned long long { - return NUM_ARGS <= max_packed_args ? encode_types() - : is_unpacked_bit | NUM_ARGS; -} - -template -using arg_t = conditional_t, - basic_format_arg>; - -template -struct named_arg_store { - // args_[0].named_args points to named_args to avoid bloating format_args. - arg_t args[1 + NUM_ARGS]; - named_arg_info named_args[NUM_NAMED_ARGS]; - - template - FMT_CONSTEXPR FMT_ALWAYS_INLINE named_arg_store(T&... values) - : args{{named_args, NUM_NAMED_ARGS}, values...} { - int arg_index = 0, named_arg_index = 0; - FMT_APPLY_VARIADIC( - init_named_arg(named_args, arg_index, named_arg_index, values)); - } - - named_arg_store(named_arg_store&& rhs) { - args[0] = {named_args, NUM_NAMED_ARGS}; - for (size_t i = 1; i < sizeof(args) / sizeof(*args); ++i) - args[i] = rhs.args[i]; - for (size_t i = 0; i < NUM_NAMED_ARGS; ++i) - named_args[i] = rhs.named_args[i]; - } - - named_arg_store(const named_arg_store& rhs) = delete; - named_arg_store& operator=(const named_arg_store& rhs) = delete; - named_arg_store& operator=(named_arg_store&& rhs) = delete; - operator const arg_t*() const { return args + 1; } -}; - -// An array of references to arguments. It can be implicitly converted to -// `basic_format_args` for passing into type-erased formatting functions -// such as `vformat`. It is a plain struct to reduce binary size in debug mode. -template -struct format_arg_store { - // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. - using type = - conditional_t[max_of(1, NUM_ARGS)], - named_arg_store>; - type args; -}; - -// TYPE can be different from type_constant, e.g. for __float128. -template struct native_formatter { - private: - dynamic_format_specs specs_; - - public: - using nonlocking = void; - - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin(); - auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE); - if (const_check(TYPE == type::char_type)) check_char_specs(specs_); - return end; - } - - template - FMT_CONSTEXPR void set_debug_format(bool set = true) { - specs_.set_type(set ? presentation_type::debug : presentation_type::none); - } - - FMT_PRAGMA_CLANG(diagnostic ignored "-Wundefined-inline") - template - FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const - -> decltype(ctx.out()); -}; - -template -struct locking - : bool_constant::value == type::custom_type> {}; -template -struct locking>::nonlocking>> - : std::false_type {}; - -template FMT_CONSTEXPR inline auto is_locking() -> bool { - return locking::value; -} -template -FMT_CONSTEXPR inline auto is_locking() -> bool { - return locking::value || is_locking(); -} - -FMT_API void vformat_to(buffer& buf, string_view fmt, format_args args, - locale_ref loc = {}); - -#if FMT_WIN32 -FMT_API void vprint_mojibake(FILE*, string_view, format_args, bool); -#else // format_args is passed by reference since it is defined later. -inline void vprint_mojibake(FILE*, string_view, const format_args&, bool) {} -#endif -} // namespace detail - -// The main public API. - -template -FMT_CONSTEXPR void parse_context::do_check_arg_id(int arg_id) { - // Argument id is only checked at compile time during parsing because - // formatting has its own validation. - if (detail::is_constant_evaluated() && use_constexpr_cast) { - auto ctx = static_cast*>(this); - if (arg_id >= ctx->num_args()) report_error("argument not found"); - } -} - -template -FMT_CONSTEXPR void parse_context::check_dynamic_spec(int arg_id) { - using detail::compile_parse_context; - if (detail::is_constant_evaluated() && use_constexpr_cast) - static_cast*>(this)->check_dynamic_spec(arg_id); -} - -FMT_BEGIN_EXPORT - -// An output iterator that appends to a buffer. It is used instead of -// back_insert_iterator to reduce symbol sizes and avoid dependency. -template class basic_appender { - protected: - detail::buffer* container; - - public: - using container_type = detail::buffer; - - FMT_CONSTEXPR basic_appender(detail::buffer& buf) : container(&buf) {} - - FMT_CONSTEXPR20 auto operator=(T c) -> basic_appender& { - container->push_back(c); - return *this; - } - FMT_CONSTEXPR20 auto operator*() -> basic_appender& { return *this; } - FMT_CONSTEXPR20 auto operator++() -> basic_appender& { return *this; } - FMT_CONSTEXPR20 auto operator++(int) -> basic_appender { return *this; } -}; - -// A formatting argument. Context is a template parameter for the compiled API -// where output can be unbuffered. -template class basic_format_arg { - private: - detail::value value_; - detail::type type_; - - friend class basic_format_args; - - using char_type = typename Context::char_type; - - public: - class handle { - private: - detail::custom_value custom_; - - public: - explicit handle(detail::custom_value custom) : custom_(custom) {} - - void format(parse_context& parse_ctx, Context& ctx) const { - custom_.format(custom_.value, parse_ctx, ctx); - } - }; - - constexpr basic_format_arg() : type_(detail::type::none_type) {} - basic_format_arg(const detail::named_arg_info* args, size_t size) - : value_(args, size) {} - template - basic_format_arg(T&& val) - : value_(val), type_(detail::stored_type_constant::value) {} - - constexpr explicit operator bool() const noexcept { - return type_ != detail::type::none_type; - } - auto type() const -> detail::type { return type_; } - - /** - * Visits an argument dispatching to the appropriate visit method based on - * the argument type. For example, if the argument type is `double` then - * `vis(value)` will be called with the value of type `double`. - */ - template - FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) { - using detail::map; - switch (type_) { - case detail::type::none_type: break; - case detail::type::int_type: return vis(value_.int_value); - case detail::type::uint_type: return vis(value_.uint_value); - case detail::type::long_long_type: return vis(value_.long_long_value); - case detail::type::ulong_long_type: return vis(value_.ulong_long_value); - case detail::type::int128_type: return vis(map(value_.int128_value)); - case detail::type::uint128_type: return vis(map(value_.uint128_value)); - case detail::type::bool_type: return vis(value_.bool_value); - case detail::type::char_type: return vis(value_.char_value); - case detail::type::float_type: return vis(value_.float_value); - case detail::type::double_type: return vis(value_.double_value); - case detail::type::long_double_type: return vis(value_.long_double_value); - case detail::type::cstring_type: return vis(value_.string.data); - case detail::type::string_type: return vis(value_.string.str()); - case detail::type::pointer_type: return vis(value_.pointer); - case detail::type::custom_type: return vis(handle(value_.custom)); - } - return vis(monostate()); - } - - auto format_custom(const char_type* parse_begin, - parse_context& parse_ctx, Context& ctx) - -> bool { - if (type_ != detail::type::custom_type) return false; - parse_ctx.advance_to(parse_begin); - value_.custom.format(value_.custom.value, parse_ctx, ctx); - return true; - } -}; - -/** - * A view of a collection of formatting arguments. To avoid lifetime issues it - * should only be used as a parameter type in type-erased functions such as - * `vformat`: - * - * void vlog(fmt::string_view fmt, fmt::format_args args); // OK - * fmt::format_args args = fmt::make_format_args(); // Dangling reference - */ -template class basic_format_args { - private: - // A descriptor that contains information about formatting arguments. - // If the number of arguments is less or equal to max_packed_args then - // argument types are passed in the descriptor. This reduces binary code size - // per formatting function call. - unsigned long long desc_; - union { - // If is_packed() returns true then argument values are stored in values_; - // otherwise they are stored in args_. This is done to improve cache - // locality and reduce compiled code size since storing larger objects - // may require more code (at least on x86-64) even if the same amount of - // data is actually copied to stack. It saves ~10% on the bloat test. - const detail::value* values_; - const basic_format_arg* args_; - }; - - constexpr auto is_packed() const -> bool { - return (desc_ & detail::is_unpacked_bit) == 0; - } - constexpr auto has_named_args() const -> bool { - return (desc_ & detail::has_named_args_bit) != 0; - } - - FMT_CONSTEXPR auto type(int index) const -> detail::type { - int shift = index * detail::packed_arg_bits; - unsigned mask = (1 << detail::packed_arg_bits) - 1; - return static_cast((desc_ >> shift) & mask); - } - - template - using store = - detail::format_arg_store; - - public: - using format_arg = basic_format_arg; - - constexpr basic_format_args() : desc_(0), args_(nullptr) {} - - /// Constructs a `basic_format_args` object from `format_arg_store`. - template - constexpr FMT_ALWAYS_INLINE basic_format_args( - const store& s) - : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)), - values_(s.args) {} - - template detail::max_packed_args)> - constexpr basic_format_args(const store& s) - : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)), - args_(s.args) {} - - /// Constructs a `basic_format_args` object from a dynamic list of arguments. - constexpr basic_format_args(const format_arg* args, int count, - bool has_named = false) - : desc_(detail::is_unpacked_bit | detail::to_unsigned(count) | - (has_named ? +detail::has_named_args_bit : 0)), - args_(args) {} - - /// Returns the argument with the specified id. - FMT_CONSTEXPR auto get(int id) const -> format_arg { - auto arg = format_arg(); - if (!is_packed()) { - if (id < max_size()) arg = args_[id]; - return arg; - } - if (static_cast(id) >= detail::max_packed_args) return arg; - arg.type_ = type(id); - if (arg.type_ != detail::type::none_type) arg.value_ = values_[id]; - return arg; - } - - template - auto get(basic_string_view name) const -> format_arg { - int id = get_id(name); - return id >= 0 ? get(id) : format_arg(); - } - - template - FMT_CONSTEXPR auto get_id(basic_string_view name) const -> int { - if (!has_named_args()) return -1; - const auto& named_args = - (is_packed() ? values_[-1] : args_[-1].value_).named_args; - for (size_t i = 0; i < named_args.size; ++i) { - if (named_args.data[i].name == name) return named_args.data[i].id; - } - return -1; - } - - auto max_size() const -> int { - unsigned long long max_packed = detail::max_packed_args; - return static_cast(is_packed() ? max_packed - : desc_ & ~detail::is_unpacked_bit); - } -}; - -// A formatting context. -class context { - private: - appender out_; - format_args args_; - FMT_NO_UNIQUE_ADDRESS detail::locale_ref loc_; - - public: - /// The character type for the output. - using char_type = char; - - using iterator = appender; - using format_arg = basic_format_arg; - using parse_context_type FMT_DEPRECATED = parse_context<>; - template using formatter_type FMT_DEPRECATED = formatter; - enum { builtin_types = FMT_BUILTIN_TYPES }; - - /// Constructs a `context` object. References to the arguments are stored - /// in the object so make sure they have appropriate lifetimes. - FMT_CONSTEXPR context(iterator out, format_args args, - detail::locale_ref loc = {}) - : out_(out), args_(args), loc_(loc) {} - context(context&&) = default; - context(const context&) = delete; - void operator=(const context&) = delete; - - FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); } - inline auto arg(string_view name) const -> format_arg { - return args_.get(name); - } - FMT_CONSTEXPR auto arg_id(string_view name) const -> int { - return args_.get_id(name); - } - - // Returns an iterator to the beginning of the output range. - FMT_CONSTEXPR auto out() const -> iterator { return out_; } - - // Advances the begin iterator to `it`. - FMT_CONSTEXPR void advance_to(iterator) {} - - FMT_CONSTEXPR auto locale() const -> detail::locale_ref { return loc_; } -}; - -template struct runtime_format_string { - basic_string_view str; -}; - -/** - * Creates a runtime format string. - * - * **Example**: - * - * // Check format string at runtime instead of compile-time. - * fmt::print(fmt::runtime("{:d}"), "I am not a number"); - */ -inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } - -/// A compile-time format string. Use `format_string` in the public API to -/// prevent type deduction. -template struct fstring { - private: - static constexpr int num_static_named_args = - detail::count_static_named_args(); - - using checker = detail::format_string_checker< - char, static_cast(sizeof...(T)), num_static_named_args, - num_static_named_args != detail::count_named_args()>; - - using arg_pack = detail::arg_pack; - - public: - string_view str; - using t = fstring; - - // Reports a compile-time error if S is not a valid format string for T. - template - FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char (&s)[N]) : str(s, N - 1) { - using namespace detail; - static_assert(count<(std::is_base_of>::value && - std::is_reference::value)...>() == 0, - "passing views as lvalues is disallowed"); - if (FMT_USE_CONSTEVAL) parse_format_string(s, checker(s, arg_pack())); -#ifdef FMT_ENFORCE_COMPILE_STRING - static_assert( - FMT_USE_CONSTEVAL && sizeof(s) != 0, - "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING"); -#endif - } - template ::value)> - FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) { - auto sv = string_view(str); - if (FMT_USE_CONSTEVAL) - detail::parse_format_string(sv, checker(sv, arg_pack())); -#ifdef FMT_ENFORCE_COMPILE_STRING - static_assert( - FMT_USE_CONSTEVAL && sizeof(s) != 0, - "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING"); -#endif - } - template ::value&& - std::is_same::value)> - FMT_ALWAYS_INLINE fstring(const S&) : str(S()) { - FMT_CONSTEXPR auto sv = string_view(S()); - FMT_CONSTEXPR int ignore = - (parse_format_string(sv, checker(sv, arg_pack())), 0); - detail::ignore_unused(ignore); - } - fstring(runtime_format_string<> fmt) : str(fmt.str) {} - - // Returning by reference generates better code in debug mode. - FMT_ALWAYS_INLINE operator const string_view&() const { return str; } - auto get() const -> string_view { return str; } -}; - -template using format_string = typename fstring::t; - -template -using is_formattable = bool_constant::value, int*, T>, Char>, - void>::value>; -#ifdef __cpp_concepts -template -concept formattable = is_formattable, Char>::value; -#endif - -template -using has_formatter FMT_DEPRECATED = std::is_constructible>; - -// A formatter specialization for natively supported types. -template -struct formatter::value != - detail::type::custom_type>> - : detail::native_formatter::value> { -}; - -/** - * Constructs an object that stores references to arguments and can be - * implicitly converted to `format_args`. `Context` can be omitted in which case - * it defaults to `context`. See `arg` for lifetime considerations. - */ -// Take arguments by lvalue references to avoid some lifetime issues, e.g. -// auto args = make_format_args(std::string()); -template (), - unsigned long long DESC = detail::make_descriptor()> -constexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args) - -> detail::format_arg_store { - // Suppress warnings for pathological types convertible to detail::value. - FMT_PRAGMA_GCC(diagnostic ignored "-Wconversion") - return {{args...}}; -} - -template -using vargs = - detail::format_arg_store(), - detail::make_descriptor()>; - -/** - * Returns a named argument to be used in a formatting function. - * It should only be used in a call to a formatting function. - * - * **Example**: - * - * fmt::print("The answer is {answer}.", fmt::arg("answer", 42)); - */ -template -inline auto arg(const Char* name, const T& arg) -> detail::named_arg { - return {name, arg}; -} - -/// Formats a string and writes the output to `out`. -template , - char>::value)> -auto vformat_to(OutputIt&& out, string_view fmt, format_args args) - -> remove_cvref_t { - auto&& buf = detail::get_buffer(out); - detail::vformat_to(buf, fmt, args, {}); - return detail::get_iterator(buf, out); -} - -/** - * Formats `args` according to specifications in `fmt`, writes the result to - * the output iterator `out` and returns the iterator past the end of the output - * range. `format_to` does not append a terminating null character. - * - * **Example**: - * - * auto out = std::vector(); - * fmt::format_to(std::back_inserter(out), "{}", 42); - */ -template , - char>::value)> -FMT_INLINE auto format_to(OutputIt&& out, format_string fmt, T&&... args) - -> remove_cvref_t { - return vformat_to(out, fmt.str, vargs{{args...}}); -} - -template struct format_to_n_result { - /// Iterator past the end of the output range. - OutputIt out; - /// Total (not truncated) output size. - size_t size; -}; - -template ::value)> -auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) - -> format_to_n_result { - using traits = detail::fixed_buffer_traits; - auto buf = detail::iterator_buffer(out, n); - detail::vformat_to(buf, fmt, args, {}); - return {buf.out(), buf.count()}; -} - -/** - * Formats `args` according to specifications in `fmt`, writes up to `n` - * characters of the result to the output iterator `out` and returns the total - * (not truncated) output size and the iterator past the end of the output - * range. `format_to_n` does not append a terminating null character. - */ -template ::value)> -FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt, - T&&... args) -> format_to_n_result { - return vformat_to_n(out, n, fmt.str, vargs{{args...}}); -} - -struct format_to_result { - /// Pointer to just after the last successful write in the array. - char* out; - /// Specifies if the output was truncated. - bool truncated; - - FMT_CONSTEXPR operator char*() const { - // Report truncation to prevent silent data loss. - if (truncated) report_error("output is truncated"); - return out; - } -}; - -template -auto vformat_to(char (&out)[N], string_view fmt, format_args args) - -> format_to_result { - auto result = vformat_to_n(out, N, fmt, args); - return {result.out, result.size > N}; -} - -template -FMT_INLINE auto format_to(char (&out)[N], format_string fmt, T&&... args) - -> format_to_result { - auto result = vformat_to_n(out, N, fmt.str, vargs{{args...}}); - return {result.out, result.size > N}; -} - -/// Returns the number of chars in the output of `format(fmt, args...)`. -template -FMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt, - T&&... args) -> size_t { - auto buf = detail::counting_buffer<>(); - detail::vformat_to(buf, fmt.str, vargs{{args...}}, {}); - return buf.count(); -} - -FMT_API void vprint(string_view fmt, format_args args); -FMT_API void vprint(FILE* f, string_view fmt, format_args args); -FMT_API void vprintln(FILE* f, string_view fmt, format_args args); -FMT_API void vprint_buffered(FILE* f, string_view fmt, format_args args); - -/** - * Formats `args` according to specifications in `fmt` and writes the output - * to `stdout`. - * - * **Example**: - * - * fmt::print("The answer is {}.", 42); - */ -template -FMT_INLINE void print(format_string fmt, T&&... args) { - vargs va = {{args...}}; - if (detail::const_check(!detail::use_utf8)) - return detail::vprint_mojibake(stdout, fmt.str, va, false); - return detail::is_locking() ? vprint_buffered(stdout, fmt.str, va) - : vprint(fmt.str, va); -} - -/** - * Formats `args` according to specifications in `fmt` and writes the - * output to the file `f`. - * - * **Example**: - * - * fmt::print(stderr, "Don't {}!", "panic"); - */ -template -FMT_INLINE void print(FILE* f, format_string fmt, T&&... args) { - vargs va = {{args...}}; - if (detail::const_check(!detail::use_utf8)) - return detail::vprint_mojibake(f, fmt.str, va, false); - return detail::is_locking() ? vprint_buffered(f, fmt.str, va) - : vprint(f, fmt.str, va); -} - -/// Formats `args` according to specifications in `fmt` and writes the output -/// to the file `f` followed by a newline. -template -FMT_INLINE void println(FILE* f, format_string fmt, T&&... args) { - vargs va = {{args...}}; - return detail::const_check(detail::use_utf8) - ? vprintln(f, fmt.str, va) - : detail::vprint_mojibake(f, fmt.str, va, true); -} - -/// Formats `args` according to specifications in `fmt` and writes the output -/// to `stdout` followed by a newline. -template -FMT_INLINE void println(format_string fmt, T&&... args) { - return fmt::println(stdout, fmt, static_cast(args)...); -} - -FMT_END_EXPORT -FMT_PRAGMA_CLANG(diagnostic pop) -FMT_PRAGMA_GCC(pop_options) -FMT_END_NAMESPACE - -#ifdef FMT_HEADER_ONLY -# include "format.h" -#endif -#endif // FMT_BASE_H_ diff --git a/src/fmt/chrono.h b/src/fmt/chrono.h index 50c777c841..9d54574e16 100644 --- a/src/fmt/chrono.h +++ b/src/fmt/chrono.h @@ -8,37 +8,52 @@ #ifndef FMT_CHRONO_H_ #define FMT_CHRONO_H_ -#ifndef FMT_MODULE -# include -# include -# include // std::isfinite -# include // std::memcpy -# include -# include -# include -# include -# include -#endif +#include +#include +#include // std::isfinite +#include // std::memcpy +#include +#include +#include +#include +#include -#include "format.h" - -namespace fmt_detail { -struct time_zone { - template - auto to_sys(T) - -> std::chrono::time_point { - return {}; - } -}; -template inline auto current_zone(T...) -> time_zone* { - return nullptr; -} - -template inline void _tzset(T...) {} -} // namespace fmt_detail +#include "ostream.h" // formatbuf FMT_BEGIN_NAMESPACE +// Check if std::chrono::local_t is available. +#ifndef FMT_USE_LOCAL_TIME +# ifdef __cpp_lib_chrono +# define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) +# else +# define FMT_USE_LOCAL_TIME 0 +# endif +#endif + +// Check if std::chrono::utc_timestamp is available. +#ifndef FMT_USE_UTC_TIME +# ifdef __cpp_lib_chrono +# define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) +# else +# define FMT_USE_UTC_TIME 0 +# endif +#endif + +// Enable tzset. +#ifndef FMT_USE_TZSET +// UWP doesn't provide _tzset. +# if FMT_HAS_INCLUDE("winapifamily.h") +# include +# endif +# if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \ + (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) +# define FMT_USE_TZSET 1 +# else +# define FMT_USE_TZSET 0 +# endif +#endif + // Enable safe chrono durations, unless explicitly disabled. #ifndef FMT_SAFE_DURATION_CAST # define FMT_SAFE_DURATION_CAST 1 @@ -79,8 +94,10 @@ FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) return static_cast(from); } -/// Converts From to To, without loss. If the dynamic value of from -/// can't be converted to To without loss, ec is set. +/** + * converts From to To, without loss. If the dynamic value of from + * can't be converted to To without loss, ec is set. + */ template ::value && std::numeric_limits::is_signed != @@ -168,7 +185,61 @@ FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { return from; } -/// Safe duration_cast between floating point durations +/** + * safe duration cast between integral durations + */ +template ::value), + FMT_ENABLE_IF(std::is_integral::value)> +auto safe_duration_cast(std::chrono::duration from, + int& ec) -> To { + using From = std::chrono::duration; + ec = 0; + // the basic idea is that we need to convert from count() in the from type + // to count() in the To type, by multiplying it with this: + struct Factor + : std::ratio_divide {}; + + static_assert(Factor::num > 0, "num must be positive"); + static_assert(Factor::den > 0, "den must be positive"); + + // the conversion is like this: multiply from.count() with Factor::num + // /Factor::den and convert it to To::rep, all this without + // overflow/underflow. let's start by finding a suitable type that can hold + // both To, From and Factor::num + using IntermediateRep = + typename std::common_type::type; + + // safe conversion to IntermediateRep + IntermediateRep count = + lossless_integral_conversion(from.count(), ec); + if (ec) return {}; + // multiply with Factor::num without overflow or underflow + if (detail::const_check(Factor::num != 1)) { + const auto max1 = detail::max_value() / Factor::num; + if (count > max1) { + ec = 1; + return {}; + } + const auto min1 = + (std::numeric_limits::min)() / Factor::num; + if (detail::const_check(!std::is_unsigned::value) && + count < min1) { + ec = 1; + return {}; + } + count *= Factor::num; + } + + if (detail::const_check(Factor::den != 1)) count /= Factor::den; + auto tocount = lossless_integral_conversion(count, ec); + return ec ? To() : To(tocount); +} + +/** + * safe duration_cast between floating point durations + */ template ::value), FMT_ENABLE_IF(std::is_floating_point::value)> @@ -247,94 +318,17 @@ auto safe_duration_cast(std::chrono::duration from, } // namespace safe_duration_cast #endif -namespace detail { - -// Check if std::chrono::utc_time is available. -#ifdef FMT_USE_UTC_TIME -// Use the provided definition. -#elif defined(__cpp_lib_chrono) -# define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) -#else -# define FMT_USE_UTC_TIME 0 -#endif -#if FMT_USE_UTC_TIME -using utc_clock = std::chrono::utc_clock; -#else -struct utc_clock { - template void to_sys(T); -}; -#endif - -// Check if std::chrono::local_time is available. -#ifdef FMT_USE_LOCAL_TIME -// Use the provided definition. -#elif defined(__cpp_lib_chrono) -# define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) -#else -# define FMT_USE_LOCAL_TIME 0 -#endif -#if FMT_USE_LOCAL_TIME -using local_t = std::chrono::local_t; -#else -struct local_t {}; -#endif - -} // namespace detail - -template -using sys_time = std::chrono::time_point; - -template -using utc_time = std::chrono::time_point; - -template -using local_time = std::chrono::time_point; - -namespace detail { - // Prevents expansion of a preceding token as a function-style macro. // Usage: f FMT_NOMACRO() #define FMT_NOMACRO +namespace detail { template struct null {}; inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); } inline auto localtime_s(...) -> null<> { return null<>(); } inline auto gmtime_r(...) -> null<> { return null<>(); } inline auto gmtime_s(...) -> null<> { return null<>(); } -// It is defined here and not in ostream.h because the latter has expensive -// includes. -template class formatbuf : public StreamBuf { - private: - using char_type = typename StreamBuf::char_type; - using streamsize = decltype(std::declval().sputn(nullptr, 0)); - using int_type = typename StreamBuf::int_type; - using traits_type = typename StreamBuf::traits_type; - - buffer& buffer_; - - public: - explicit formatbuf(buffer& buf) : buffer_(buf) {} - - protected: - // The put area is always empty. This makes the implementation simpler and has - // the advantage that the streambuf and the buffer are always in sync and - // sputc never writes into uninitialized memory. A disadvantage is that each - // call to sputc always results in a (virtual) call to overflow. There is no - // disadvantage here for sputn since this always results in a call to xsputn. - - auto overflow(int_type ch) -> int_type override { - if (!traits_type::eq_int_type(ch, traits_type::eof())) - buffer_.push_back(static_cast(ch)); - return ch; - } - - auto xsputn(const char_type* s, streamsize count) -> streamsize override { - buffer_.append(s, s + count); - return count; - } -}; - inline auto get_classic_locale() -> const std::locale& { static const auto& locale = std::locale::classic(); return locale; @@ -347,16 +341,20 @@ template struct codecvt_result { }; template -void write_codecvt(codecvt_result& out, string_view in, +void write_codecvt(codecvt_result& out, string_view in_buf, const std::locale& loc) { - FMT_PRAGMA_CLANG(diagnostic push) - FMT_PRAGMA_CLANG(diagnostic ignored "-Wdeprecated") +#if FMT_CLANG_VERSION +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated" auto& f = std::use_facet>(loc); - FMT_PRAGMA_CLANG(diagnostic pop) +# pragma clang diagnostic pop +#else + auto& f = std::use_facet>(loc); +#endif auto mb = std::mbstate_t(); const char* from_next = nullptr; - auto result = f.in(mb, in.begin(), in.end(), from_next, std::begin(out.buf), - std::end(out.buf), out.end); + auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next, + std::begin(out.buf), std::end(out.buf), out.end); if (result != std::codecvt_base::ok) FMT_THROW(format_error("failed to format time")); } @@ -364,12 +362,11 @@ void write_codecvt(codecvt_result& out, string_view in, template auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) -> OutputIt { - if (const_check(detail::use_utf8) && loc != get_classic_locale()) { + if (detail::is_utf8() && loc != get_classic_locale()) { // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and // gcc-4. -#if FMT_MSC_VERSION != 0 || \ - (defined(__GLIBCXX__) && \ - (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0)) +#if FMT_MSC_VERSION != 0 || \ + (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)) // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 // and newer. using code_unit = wchar_t; @@ -385,9 +382,9 @@ auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) to_utf8>(); if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) FMT_THROW(format_error("failed to format time")); - return copy(u.c_str(), u.c_str() + u.size(), out); + return copy_str(u.c_str(), u.c_str() + u.size(), out); } - return copy(in.data(), in.data() + in.size(), out); + return copy_str(in.data(), in.data() + in.size(), out); } template OutputIt { codecvt_result unit; write_codecvt(unit, sv, loc); - return copy(unit.buf, unit.end, out); + return copy_str(unit.buf, unit.end, out); } template ::value)> { }; -FMT_NORETURN inline void throw_duration_error() { - FMT_THROW(format_error("cannot format duration")); -} - -// Cast one integral duration to another with an overflow check. -template ::value&& - std::is_integral::value)> -auto duration_cast(std::chrono::duration from) -> To { -#if !FMT_SAFE_DURATION_CAST - return std::chrono::duration_cast(from); -#else - // The conversion factor: to.count() == factor * from.count(). - using factor = std::ratio_divide; - - using common_rep = typename std::common_type::type; - - int ec = 0; - auto count = safe_duration_cast::lossless_integral_conversion( - from.count(), ec); - if (ec) throw_duration_error(); - - // Multiply from.count() by factor and check for overflow. - if (const_check(factor::num != 1)) { - if (count > max_value() / factor::num) throw_duration_error(); - const auto min = (std::numeric_limits::min)() / factor::num; - if (const_check(!std::is_unsigned::value) && count < min) - throw_duration_error(); - count *= factor::num; - } - if (const_check(factor::den != 1)) count /= factor::den; - auto to = - To(safe_duration_cast::lossless_integral_conversion( - count, ec)); - if (ec) throw_duration_error(); - return to; -#endif -} - -template ::value&& - std::is_floating_point::value)> -auto duration_cast(std::chrono::duration from) -> To { +template < + typename To, typename FromRep, typename FromPeriod, + FMT_ENABLE_IF(is_same_arithmetic_type::value)> +auto fmt_duration_cast(std::chrono::duration from) -> To { #if FMT_SAFE_DURATION_CAST // Throwing version of safe_duration_cast is only available for // integer to integer or float to float casts. int ec; To to = safe_duration_cast::safe_duration_cast(from, ec); - if (ec) throw_duration_error(); + if (ec) FMT_THROW(format_error("cannot format duration")); return to; #else // Standard duration cast, may overflow. @@ -504,60 +461,54 @@ auto duration_cast(std::chrono::duration from) -> To { template < typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(!is_same_arithmetic_type::value)> -auto duration_cast(std::chrono::duration from) -> To { +auto fmt_duration_cast(std::chrono::duration from) -> To { // Mixed integer <-> float cast is not supported by safe_duration_cast. return std::chrono::duration_cast(from); } template -auto to_time_t(sys_time time_point) -> std::time_t { +auto to_time_t( + std::chrono::time_point time_point) + -> std::time_t { // Cannot use std::chrono::system_clock::to_time_t since this would first // require a cast to std::chrono::system_clock::time_point, which could // overflow. - return detail::duration_cast>( + return fmt_duration_cast>( time_point.time_since_epoch()) .count(); } - -// Workaround a bug in libstdc++ which sets __cpp_lib_chrono to 201907 without -// providing current_zone(): https://github.com/fmtlib/fmt/issues/4160. -template FMT_CONSTEXPR auto has_current_zone() -> bool { - using namespace std::chrono; - using namespace fmt_detail; - return !std::is_same::value; -} } // namespace detail FMT_BEGIN_EXPORT /** - * Converts given time since epoch as `std::time_t` value into calendar time, - * expressed in local time. Unlike `std::localtime`, this function is - * thread-safe on most platforms. + Converts given time since epoch as ``std::time_t`` value into calendar time, + expressed in local time. Unlike ``std::localtime``, this function is + thread-safe on most platforms. */ inline auto localtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; - inline dispatcher(std::time_t t) : time_(t) {} + dispatcher(std::time_t t) : time_(t) {} - inline auto run() -> bool { + auto run() -> bool { using namespace fmt::detail; return handle(localtime_r(&time_, &tm_)); } - inline auto handle(std::tm* tm) -> bool { return tm != nullptr; } + auto handle(std::tm* tm) -> bool { return tm != nullptr; } - inline auto handle(detail::null<>) -> bool { + auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(localtime_s(&tm_, &time_)); } - inline auto fallback(int res) -> bool { return res == 0; } + auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION - inline auto fallback(detail::null<>) -> bool { + auto fallback(detail::null<>) -> bool { using namespace fmt::detail; std::tm* tm = std::localtime(&time_); if (tm) tm_ = *tm; @@ -572,43 +523,41 @@ inline auto localtime(std::time_t time) -> std::tm { } #if FMT_USE_LOCAL_TIME -template ())> +template inline auto localtime(std::chrono::local_time time) -> std::tm { - using namespace std::chrono; - using namespace fmt_detail; - return localtime(detail::to_time_t(current_zone()->to_sys(time))); + return localtime( + detail::to_time_t(std::chrono::current_zone()->to_sys(time))); } #endif /** - * Converts given time since epoch as `std::time_t` value into calendar time, - * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this - * function is thread-safe on most platforms. + Converts given time since epoch as ``std::time_t`` value into calendar time, + expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this + function is thread-safe on most platforms. */ inline auto gmtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; - inline dispatcher(std::time_t t) : time_(t) {} + dispatcher(std::time_t t) : time_(t) {} - inline auto run() -> bool { + auto run() -> bool { using namespace fmt::detail; return handle(gmtime_r(&time_, &tm_)); } - inline auto handle(std::tm* tm) -> bool { return tm != nullptr; } + auto handle(std::tm* tm) -> bool { return tm != nullptr; } - inline auto handle(detail::null<>) -> bool { + auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(gmtime_s(&tm_, &time_)); } - inline auto fallback(int res) -> bool { return res == 0; } + auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION - inline auto fallback(detail::null<>) -> bool { + auto fallback(detail::null<>) -> bool { std::tm* tm = std::gmtime(&time_); if (tm) tm_ = *tm; return tm != nullptr; @@ -622,7 +571,9 @@ inline auto gmtime(std::time_t time) -> std::tm { } template -inline auto gmtime(sys_time time_point) -> std::tm { +inline auto gmtime( + std::chrono::time_point time_point) + -> std::tm { return gmtime(detail::to_time_t(time_point)); } @@ -668,8 +619,7 @@ FMT_CONSTEXPR inline auto get_units() -> const char* { if (std::is_same::value) return "fs"; if (std::is_same::value) return "ps"; if (std::is_same::value) return "ns"; - if (std::is_same::value) - return detail::use_utf8 ? "µs" : "us"; + if (std::is_same::value) return "µs"; if (std::is_same::value) return "ms"; if (std::is_same::value) return "cs"; if (std::is_same::value) return "ds"; @@ -696,10 +646,12 @@ enum class numeric_system { // Glibc extensions for formatting numeric values. enum class pad_type { - // Pad a numeric result string with zeros (the default). - zero, + unspecified, // Do not pad a numeric result string. none, + // Pad a numeric result string with zeros even if the conversion specifier + // character uses space-padding by default. + zero, // Pad a numeric result string with spaces. space, }; @@ -707,7 +659,7 @@ enum class pad_type { template auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt { if (pad == pad_type::none) return out; - return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); + return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); } template @@ -723,8 +675,8 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, if (begin == end || *begin == '}') return begin; if (*begin != '%') FMT_THROW(format_error("invalid format")); auto ptr = begin; + pad_type pad = pad_type::unspecified; while (ptr != end) { - pad_type pad = pad_type::zero; auto c = *ptr; if (c == '}') break; if (c != '%') { @@ -744,11 +696,17 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, pad = pad_type::none; ++ptr; break; + case '0': + pad = pad_type::zero; + ++ptr; + break; } if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { - case '%': handler.on_text(ptr - 1, ptr); break; + case '%': + handler.on_text(ptr - 1, ptr); + break; case 'n': { const Char newline[] = {'\n'}; handler.on_text(newline, newline + 1); @@ -760,66 +718,145 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, break; } // Year: - case 'Y': handler.on_year(numeric_system::standard, pad); break; - case 'y': handler.on_short_year(numeric_system::standard); break; - case 'C': handler.on_century(numeric_system::standard); break; - case 'G': handler.on_iso_week_based_year(); break; - case 'g': handler.on_iso_week_based_short_year(); break; + case 'Y': + handler.on_year(numeric_system::standard); + break; + case 'y': + handler.on_short_year(numeric_system::standard); + break; + case 'C': + handler.on_century(numeric_system::standard); + break; + case 'G': + handler.on_iso_week_based_year(); + break; + case 'g': + handler.on_iso_week_based_short_year(); + break; // Day of the week: - case 'a': handler.on_abbr_weekday(); break; - case 'A': handler.on_full_weekday(); break; - case 'w': handler.on_dec0_weekday(numeric_system::standard); break; - case 'u': handler.on_dec1_weekday(numeric_system::standard); break; + case 'a': + handler.on_abbr_weekday(); + break; + case 'A': + handler.on_full_weekday(); + break; + case 'w': + handler.on_dec0_weekday(numeric_system::standard); + break; + case 'u': + handler.on_dec1_weekday(numeric_system::standard); + break; // Month: case 'b': - case 'h': handler.on_abbr_month(); break; - case 'B': handler.on_full_month(); break; - case 'm': handler.on_dec_month(numeric_system::standard, pad); break; + case 'h': + handler.on_abbr_month(); + break; + case 'B': + handler.on_full_month(); + break; + case 'm': + handler.on_dec_month(numeric_system::standard); + break; // Day of the year/month: case 'U': - handler.on_dec0_week_of_year(numeric_system::standard, pad); + handler.on_dec0_week_of_year(numeric_system::standard); break; case 'W': - handler.on_dec1_week_of_year(numeric_system::standard, pad); + handler.on_dec1_week_of_year(numeric_system::standard); + break; + case 'V': + handler.on_iso_week_of_year(numeric_system::standard); + break; + case 'j': + handler.on_day_of_year(); + break; + case 'd': + handler.on_day_of_month(numeric_system::standard); break; - case 'V': handler.on_iso_week_of_year(numeric_system::standard, pad); break; - case 'j': handler.on_day_of_year(pad); break; - case 'd': handler.on_day_of_month(numeric_system::standard, pad); break; case 'e': - handler.on_day_of_month(numeric_system::standard, pad_type::space); + handler.on_day_of_month_space(numeric_system::standard); break; // Hour, minute, second: - case 'H': handler.on_24_hour(numeric_system::standard, pad); break; - case 'I': handler.on_12_hour(numeric_system::standard, pad); break; - case 'M': handler.on_minute(numeric_system::standard, pad); break; - case 'S': handler.on_second(numeric_system::standard, pad); break; + case 'H': + handler.on_24_hour(numeric_system::standard, pad); + break; + case 'I': + handler.on_12_hour(numeric_system::standard, pad); + break; + case 'M': + handler.on_minute(numeric_system::standard, pad); + break; + case 'S': + handler.on_second(numeric_system::standard, pad); + break; // Other: - case 'c': handler.on_datetime(numeric_system::standard); break; - case 'x': handler.on_loc_date(numeric_system::standard); break; - case 'X': handler.on_loc_time(numeric_system::standard); break; - case 'D': handler.on_us_date(); break; - case 'F': handler.on_iso_date(); break; - case 'r': handler.on_12_hour_time(); break; - case 'R': handler.on_24_hour_time(); break; - case 'T': handler.on_iso_time(); break; - case 'p': handler.on_am_pm(); break; - case 'Q': handler.on_duration_value(); break; - case 'q': handler.on_duration_unit(); break; - case 'z': handler.on_utc_offset(numeric_system::standard); break; - case 'Z': handler.on_tz_name(); break; + case 'c': + handler.on_datetime(numeric_system::standard); + break; + case 'x': + handler.on_loc_date(numeric_system::standard); + break; + case 'X': + handler.on_loc_time(numeric_system::standard); + break; + case 'D': + handler.on_us_date(); + break; + case 'F': + handler.on_iso_date(); + break; + case 'r': + handler.on_12_hour_time(); + break; + case 'R': + handler.on_24_hour_time(); + break; + case 'T': + handler.on_iso_time(); + break; + case 'p': + handler.on_am_pm(); + break; + case 'Q': + handler.on_duration_value(); + break; + case 'q': + handler.on_duration_unit(); + break; + case 'z': + handler.on_utc_offset(numeric_system::standard); + break; + case 'Z': + handler.on_tz_name(); + break; // Alternative representation: case 'E': { if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { - case 'Y': handler.on_year(numeric_system::alternative, pad); break; - case 'y': handler.on_offset_year(); break; - case 'C': handler.on_century(numeric_system::alternative); break; - case 'c': handler.on_datetime(numeric_system::alternative); break; - case 'x': handler.on_loc_date(numeric_system::alternative); break; - case 'X': handler.on_loc_time(numeric_system::alternative); break; - case 'z': handler.on_utc_offset(numeric_system::alternative); break; - default: FMT_THROW(format_error("invalid format")); + case 'Y': + handler.on_year(numeric_system::alternative); + break; + case 'y': + handler.on_offset_year(); + break; + case 'C': + handler.on_century(numeric_system::alternative); + break; + case 'c': + handler.on_datetime(numeric_system::alternative); + break; + case 'x': + handler.on_loc_date(numeric_system::alternative); + break; + case 'X': + handler.on_loc_time(numeric_system::alternative); + break; + case 'z': + handler.on_utc_offset(numeric_system::alternative); + break; + default: + FMT_THROW(format_error("invalid format")); } break; } @@ -827,34 +864,54 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { - case 'y': handler.on_short_year(numeric_system::alternative); break; - case 'm': handler.on_dec_month(numeric_system::alternative, pad); break; + case 'y': + handler.on_short_year(numeric_system::alternative); + break; + case 'm': + handler.on_dec_month(numeric_system::alternative); + break; case 'U': - handler.on_dec0_week_of_year(numeric_system::alternative, pad); + handler.on_dec0_week_of_year(numeric_system::alternative); break; case 'W': - handler.on_dec1_week_of_year(numeric_system::alternative, pad); + handler.on_dec1_week_of_year(numeric_system::alternative); break; case 'V': - handler.on_iso_week_of_year(numeric_system::alternative, pad); + handler.on_iso_week_of_year(numeric_system::alternative); break; case 'd': - handler.on_day_of_month(numeric_system::alternative, pad); + handler.on_day_of_month(numeric_system::alternative); break; case 'e': - handler.on_day_of_month(numeric_system::alternative, pad_type::space); + handler.on_day_of_month_space(numeric_system::alternative); break; - case 'w': handler.on_dec0_weekday(numeric_system::alternative); break; - case 'u': handler.on_dec1_weekday(numeric_system::alternative); break; - case 'H': handler.on_24_hour(numeric_system::alternative, pad); break; - case 'I': handler.on_12_hour(numeric_system::alternative, pad); break; - case 'M': handler.on_minute(numeric_system::alternative, pad); break; - case 'S': handler.on_second(numeric_system::alternative, pad); break; - case 'z': handler.on_utc_offset(numeric_system::alternative); break; - default: FMT_THROW(format_error("invalid format")); + case 'w': + handler.on_dec0_weekday(numeric_system::alternative); + break; + case 'u': + handler.on_dec1_weekday(numeric_system::alternative); + break; + case 'H': + handler.on_24_hour(numeric_system::alternative, pad); + break; + case 'I': + handler.on_12_hour(numeric_system::alternative, pad); + break; + case 'M': + handler.on_minute(numeric_system::alternative, pad); + break; + case 'S': + handler.on_second(numeric_system::alternative, pad); + break; + case 'z': + handler.on_utc_offset(numeric_system::alternative); + break; + default: + FMT_THROW(format_error("invalid format")); } break; - default: FMT_THROW(format_error("invalid format")); + default: + FMT_THROW(format_error("invalid format")); } begin = ptr; } @@ -866,7 +923,7 @@ template struct null_chrono_spec_handler { FMT_CONSTEXPR void unsupported() { static_cast(this)->unsupported(); } - FMT_CONSTEXPR void on_year(numeric_system, pad_type) { unsupported(); } + FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_offset_year() { unsupported(); } FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); } @@ -878,20 +935,13 @@ template struct null_chrono_spec_handler { FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_abbr_month() { unsupported(); } FMT_CONSTEXPR void on_full_month() { unsupported(); } - FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) { unsupported(); } - FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) { - unsupported(); - } - FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) { - unsupported(); - } - FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) { - unsupported(); - } - FMT_CONSTEXPR void on_day_of_year(pad_type) { unsupported(); } - FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) { - unsupported(); - } + FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_day_of_year() { unsupported(); } + FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } @@ -912,13 +962,11 @@ template struct null_chrono_spec_handler { }; struct tm_format_checker : null_chrono_spec_handler { - FMT_NORETURN inline void unsupported() { - FMT_THROW(format_error("no format")); - } + FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); } template FMT_CONSTEXPR void on_text(const Char*, const Char*) {} - FMT_CONSTEXPR void on_year(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_year(numeric_system) {} FMT_CONSTEXPR void on_short_year(numeric_system) {} FMT_CONSTEXPR void on_offset_year() {} FMT_CONSTEXPR void on_century(numeric_system) {} @@ -930,12 +978,13 @@ struct tm_format_checker : null_chrono_spec_handler { FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {} FMT_CONSTEXPR void on_abbr_month() {} FMT_CONSTEXPR void on_full_month() {} - FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_day_of_year(pad_type) {} - FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_dec_month(numeric_system) {} + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_day_of_year() {} + FMT_CONSTEXPR void on_day_of_month(numeric_system) {} + FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} @@ -991,14 +1040,15 @@ template struct has_member_data_tm_zone> : std::true_type {}; +#if FMT_USE_TZSET inline void tzset_once() { - static bool init = []() { - using namespace fmt_detail; + static bool init = []() -> bool { _tzset(); - return false; + return true; }(); ignore_unused(init); } +#endif // Converts value to Int and checks that it's in the range [0, upper). template ::value)> @@ -1011,10 +1061,9 @@ inline auto to_nonnegative_int(T value, Int upper) -> Int { } template ::value)> inline auto to_nonnegative_int(T value, Int upper) -> Int { - auto int_value = static_cast(value); - if (int_value < 0 || value > static_cast(upper)) + if (value < 0 || value > static_cast(upper)) FMT_THROW(format_error("invalid value")); - return int_value; + return static_cast(value); } constexpr auto pow10(std::uint32_t n) -> long long { @@ -1049,16 +1098,16 @@ void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { using subsecond_precision = std::chrono::duration< typename std::common_type::type, - std::ratio<1, pow10(num_fractional_digits)>>; + std::ratio<1, detail::pow10(num_fractional_digits)>>; - const auto fractional = d - detail::duration_cast(d); + const auto fractional = d - fmt_duration_cast(d); const auto subseconds = std::chrono::treat_as_floating_point< typename subsecond_precision::rep>::value ? fractional.count() - : detail::duration_cast(fractional).count(); + : fmt_duration_cast(fractional).count(); auto n = static_cast>(subseconds); - const int num_digits = count_digits(n); + const int num_digits = detail::count_digits(n); int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits); if (precision < 0) { @@ -1066,25 +1115,22 @@ void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { if (std::ratio_less::value) { *out++ = '.'; - out = detail::fill_n(out, leading_zeroes, '0'); - out = format_decimal(out, n, num_digits); + out = std::fill_n(out, leading_zeroes, '0'); + out = format_decimal(out, n, num_digits).end; } - } else if (precision > 0) { + } else { *out++ = '.'; - leading_zeroes = min_of(leading_zeroes, precision); + leading_zeroes = (std::min)(leading_zeroes, precision); + out = std::fill_n(out, leading_zeroes, '0'); int remaining = precision - leading_zeroes; - out = detail::fill_n(out, leading_zeroes, '0'); - if (remaining < num_digits) { - int num_truncated_digits = num_digits - remaining; - n /= to_unsigned(pow10(to_unsigned(num_truncated_digits))); - if (n != 0) out = format_decimal(out, n, remaining); + if (remaining != 0 && remaining < num_digits) { + n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining))); + out = format_decimal(out, n, remaining).end; return; } - if (n != 0) { - out = format_decimal(out, n, num_digits); - remaining -= num_digits; - } - out = detail::fill_n(out, remaining, '0'); + out = format_decimal(out, n, num_digits).end; + remaining -= num_digits; + out = std::fill_n(out, remaining, '0'); } } @@ -1225,28 +1271,29 @@ class tm_writer { } } - void write_year_extended(long long year, pad_type pad) { + void write_year_extended(long long year) { // At least 4 characters. int width = 4; - bool negative = year < 0; - if (negative) { + if (year < 0) { + *out_++ = '-'; year = 0 - year; --width; } uint32_or_64_or_128_t n = to_unsigned(year); const int num_digits = count_digits(n); - if (negative && pad == pad_type::zero) *out_++ = '-'; - if (width > num_digits) { - out_ = detail::write_padding(out_, pad, width - num_digits); - } - if (negative && pad != pad_type::zero) *out_++ = '-'; - out_ = format_decimal(out_, n, num_digits); + if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0'); + out_ = format_decimal(out_, n, num_digits).end; } - void write_year(long long year, pad_type pad) { - write_year_extended(year, pad); + void write_year(long long year) { + if (year >= 0 && year < 10000) { + write2(static_cast(year / 100)); + write2(static_cast(year % 100)); + } else { + write_year_extended(year); + } } - void write_utc_offset(long long offset, numeric_system ns) { + void write_utc_offset(long offset, numeric_system ns) { if (offset < 0) { *out_++ = '-'; offset = -offset; @@ -1258,7 +1305,6 @@ class tm_writer { if (ns != numeric_system::standard) *out_++ = ':'; write2(static_cast(offset % 60)); } - template ::value)> void format_utc_offset_impl(const T& tm, numeric_system ns) { write_utc_offset(tm.tm_gmtoff, ns); @@ -1266,7 +1312,9 @@ class tm_writer { template ::value)> void format_utc_offset_impl(const T& tm, numeric_system ns) { #if defined(_WIN32) && defined(_UCRT) +# if FMT_USE_TZSET tzset_once(); +# endif long offset = 0; _get_timezone(&offset); if (tm.tm_isdst) { @@ -1283,7 +1331,7 @@ class tm_writer { std::time_t gt = std::mktime(>m); std::tm ltm = gmtime(gt); std::time_t lt = std::mktime(<m); - long long offset = gt - lt; + long offset = gt - lt; write_utc_offset(offset, ns); #endif } @@ -1316,7 +1364,7 @@ class tm_writer { auto out() const -> OutputIt { return out_; } FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { - out_ = copy(begin, end, out_); + out_ = copy_str(begin, end, out_); } void on_abbr_weekday() { @@ -1363,11 +1411,11 @@ class tm_writer { *out_++ = ' '; on_abbr_month(); *out_++ = ' '; - on_day_of_month(numeric_system::standard, pad_type::space); + on_day_of_month_space(numeric_system::standard); *out_++ = ' '; on_iso_time(); *out_++ = ' '; - on_year(numeric_system::standard, pad_type::space); + on_year(numeric_system::standard); } else { format_localized('c', ns == numeric_system::standard ? '\0' : 'E'); } @@ -1389,31 +1437,31 @@ class tm_writer { write_digit2_separated(buf, to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), to_unsigned(split_year_lower(tm_year())), '/'); - out_ = copy(std::begin(buf), std::end(buf), out_); + out_ = copy_str(std::begin(buf), std::end(buf), out_); } void on_iso_date() { auto year = tm_year(); char buf[10]; size_t offset = 0; if (year >= 0 && year < 10000) { - write2digits(buf, static_cast(year / 100)); + copy2(buf, digits2(static_cast(year / 100))); } else { offset = 4; - write_year_extended(year, pad_type::zero); + write_year_extended(year); year = 0; } write_digit2_separated(buf + 2, static_cast(year % 100), to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), '-'); - out_ = copy(std::begin(buf) + offset, std::end(buf), out_); + out_ = copy_str(std::begin(buf) + offset, std::end(buf), out_); } void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); } void on_tz_name() { format_tz_name_impl(tm_); } - void on_year(numeric_system ns, pad_type pad) { + void on_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) - return write_year(tm_year(), pad); + return write_year(tm_year()); format_localized('Y', 'E'); } void on_short_year(numeric_system ns) { @@ -1444,58 +1492,57 @@ class tm_writer { } } - void on_dec_month(numeric_system ns, pad_type pad) { + void on_dec_month(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) - return write2(tm_mon() + 1, pad); + return write2(tm_mon() + 1); format_localized('m', 'O'); } - void on_dec0_week_of_year(numeric_system ns, pad_type pad) { + void on_dec0_week_of_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) - return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week, - pad); + return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week); format_localized('U', 'O'); } - void on_dec1_week_of_year(numeric_system ns, pad_type pad) { + void on_dec1_week_of_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write2((tm_yday() + days_per_week - (wday == 0 ? (days_per_week - 1) : (wday - 1))) / - days_per_week, - pad); + days_per_week); } else { format_localized('W', 'O'); } } - void on_iso_week_of_year(numeric_system ns, pad_type pad) { + void on_iso_week_of_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) - return write2(tm_iso_week_of_year(), pad); + return write2(tm_iso_week_of_year()); format_localized('V', 'O'); } - void on_iso_week_based_year() { - write_year(tm_iso_week_year(), pad_type::zero); - } + void on_iso_week_based_year() { write_year(tm_iso_week_year()); } void on_iso_week_based_short_year() { write2(split_year_lower(tm_iso_week_year())); } - void on_day_of_year(pad_type pad) { + void on_day_of_year() { auto yday = tm_yday() + 1; - auto digit1 = yday / 100; - if (digit1 != 0) { - write1(digit1); - } else { - out_ = detail::write_padding(out_, pad); - } - write2(yday % 100, pad); + write1(yday / 100); + write2(yday % 100); } - - void on_day_of_month(numeric_system ns, pad_type pad) { - if (is_classic_ || ns == numeric_system::standard) - return write2(tm_mday(), pad); + void on_day_of_month(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday()); format_localized('d', 'O'); } + void on_day_of_month_space(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto mday = to_unsigned(tm_mday()) % 100; + const char* d2 = digits2(mday); + *out_++ = mday < 10 ? ' ' : d2[0]; + *out_++ = d2[1]; + } else { + format_localized('e', 'O'); + } + } void on_24_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) @@ -1522,7 +1569,7 @@ class tm_writer { write_floating_seconds(buf, *subsecs_); if (buf.size() > 1) { // Remove the leading "0", write something like ".123". - out_ = copy(buf.begin() + 1, buf.end(), out_); + out_ = std::copy(buf.begin() + 1, buf.end(), out_); } } else { write_fractional_seconds(out_, *subsecs_); @@ -1539,7 +1586,7 @@ class tm_writer { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_hour12()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); - out_ = copy(std::begin(buf), std::end(buf), out_); + out_ = copy_str(std::begin(buf), std::end(buf), out_); *out_++ = ' '; on_am_pm(); } else { @@ -1554,7 +1601,7 @@ class tm_writer { void on_iso_time() { on_24_hour_time(); *out_++ = ':'; - on_second(numeric_system::standard, pad_type::zero); + on_second(numeric_system::standard, pad_type::unspecified); } void on_am_pm() { @@ -1574,11 +1621,11 @@ class tm_writer { struct chrono_format_checker : null_chrono_spec_handler { bool has_precision_integral = false; - FMT_NORETURN inline void unsupported() { FMT_THROW(format_error("no date")); } + FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); } template FMT_CONSTEXPR void on_text(const Char*, const Char*) {} - FMT_CONSTEXPR void on_day_of_year(pad_type) {} + FMT_CONSTEXPR void on_day_of_year() {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} @@ -1588,8 +1635,9 @@ struct chrono_format_checker : null_chrono_spec_handler { FMT_CONSTEXPR void on_iso_time() {} FMT_CONSTEXPR void on_am_pm() {} FMT_CONSTEXPR void on_duration_value() const { - if (has_precision_integral) + if (has_precision_integral) { FMT_THROW(format_error("precision not allowed for this argument type")); + } } FMT_CONSTEXPR void on_duration_unit() {} }; @@ -1629,17 +1677,17 @@ inline auto get_milliseconds(std::chrono::duration d) #if FMT_SAFE_DURATION_CAST using CommonSecondsType = typename std::common_type::type; - const auto d_as_common = detail::duration_cast(d); + const auto d_as_common = fmt_duration_cast(d); const auto d_as_whole_seconds = - detail::duration_cast(d_as_common); + fmt_duration_cast(d_as_common); // this conversion should be nonproblematic const auto diff = d_as_common - d_as_whole_seconds; const auto ms = - detail::duration_cast>(diff); + fmt_duration_cast>(diff); return ms; #else - auto s = detail::duration_cast(d); - return detail::duration_cast(d - s); + auto s = fmt_duration_cast(d); + return fmt_duration_cast(d - s); #endif } @@ -1652,16 +1700,16 @@ auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt { template ::value)> auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt { - auto specs = format_specs(); + auto specs = format_specs(); specs.precision = precision; - specs.set_type(precision >= 0 ? presentation_type::fixed - : presentation_type::general); + specs.type = precision >= 0 ? presentation_type::fixed_lower + : presentation_type::general_lower; return write(out, val, specs); } template auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt { - return copy(unit.begin(), unit.end(), out); + return std::copy(unit.begin(), unit.end(), out); } template @@ -1669,7 +1717,7 @@ auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt { // This works when wchar_t is UTF-32 because units only contain characters // that have the same representation in UTF-16 and UTF-32. utf8_to_utf16 u(unit); - return copy(u.c_str(), u.c_str() + u.size(), out); + return std::copy(u.c_str(), u.c_str() + u.size(), out); } template @@ -1695,14 +1743,14 @@ class get_locale { bool has_locale_ = false; public: - inline get_locale(bool localized, locale_ref loc) : has_locale_(localized) { + get_locale(bool localized, locale_ref loc) : has_locale_(localized) { if (localized) ::new (&locale_) std::locale(loc.template get()); } - inline ~get_locale() { + ~get_locale() { if (has_locale_) locale_.~locale(); } - inline operator const std::locale&() const { + operator const std::locale&() const { return has_locale_ ? locale_ : get_classic_locale(); } }; @@ -1741,7 +1789,7 @@ struct chrono_formatter { // this may overflow and/or the result may not fit in the // target type. // might need checked conversion (rep!=Rep) - s = detail::duration_cast(std::chrono::duration(val)); + s = fmt_duration_cast(std::chrono::duration(val)); } // returns true if nan or inf, writes to out. @@ -1792,7 +1840,7 @@ struct chrono_formatter { } } - void write(Rep value, int width, pad_type pad = pad_type::zero) { + void write(Rep value, int width, pad_type pad = pad_type::unspecified) { write_sign(); if (isnan(value)) return write_nan(); uint32_or_64_or_128_t n = @@ -1801,7 +1849,7 @@ struct chrono_formatter { if (width > num_digits) { out = detail::write_padding(out, pad, width - num_digits); } - out = format_decimal(out, n, num_digits); + out = format_decimal(out, n, num_digits).end; } void write_nan() { std::copy_n("nan", 3, out); } @@ -1818,7 +1866,7 @@ struct chrono_formatter { } void on_text(const char_type* begin, const char_type* end) { - copy(begin, end, out); + std::copy(begin, end, out); } // These are not implemented because durations don't have date information. @@ -1835,19 +1883,20 @@ struct chrono_formatter { void on_iso_date() {} void on_utc_offset(numeric_system) {} void on_tz_name() {} - void on_year(numeric_system, pad_type) {} + void on_year(numeric_system) {} void on_short_year(numeric_system) {} void on_offset_year() {} void on_century(numeric_system) {} void on_iso_week_based_year() {} void on_iso_week_based_short_year() {} - void on_dec_month(numeric_system, pad_type) {} - void on_dec0_week_of_year(numeric_system, pad_type) {} - void on_dec1_week_of_year(numeric_system, pad_type) {} - void on_iso_week_of_year(numeric_system, pad_type) {} - void on_day_of_month(numeric_system, pad_type) {} + void on_dec_month(numeric_system) {} + void on_dec0_week_of_year(numeric_system) {} + void on_dec1_week_of_year(numeric_system) {} + void on_iso_week_of_year(numeric_system) {} + void on_day_of_month(numeric_system) {} + void on_day_of_month_space(numeric_system) {} - void on_day_of_year(pad_type) { + void on_day_of_year() { if (handle_nan_inf()) return; write(days(), 0); } @@ -1891,7 +1940,7 @@ struct chrono_formatter { if (buf.size() < 2 || buf[1] == '.') { out = detail::write_padding(out, pad); } - out = copy(buf.begin(), buf.end(), out); + out = std::copy(buf.begin(), buf.end(), out); } else { write(second(), 2, pad); write_fractional_seconds( @@ -1925,7 +1974,7 @@ struct chrono_formatter { on_24_hour_time(); *out++ = ':'; if (handle_nan_inf()) return; - on_second(numeric_system::standard, pad_type::zero); + on_second(numeric_system::standard, pad_type::unspecified); } void on_am_pm() { @@ -1948,240 +1997,82 @@ struct chrono_formatter { #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907 using weekday = std::chrono::weekday; -using day = std::chrono::day; -using month = std::chrono::month; -using year = std::chrono::year; -using year_month_day = std::chrono::year_month_day; #else // A fallback version of weekday. class weekday { private: - unsigned char value_; + unsigned char value; public: weekday() = default; - constexpr explicit weekday(unsigned wd) noexcept - : value_(static_cast(wd != 7 ? wd : 0)) {} - constexpr auto c_encoding() const noexcept -> unsigned { return value_; } + explicit constexpr weekday(unsigned wd) noexcept + : value(static_cast(wd != 7 ? wd : 0)) {} + constexpr auto c_encoding() const noexcept -> unsigned { return value; } }; -class day { - private: - unsigned char value_; - - public: - day() = default; - constexpr explicit day(unsigned d) noexcept - : value_(static_cast(d)) {} - constexpr explicit operator unsigned() const noexcept { return value_; } -}; - -class month { - private: - unsigned char value_; - - public: - month() = default; - constexpr explicit month(unsigned m) noexcept - : value_(static_cast(m)) {} - constexpr explicit operator unsigned() const noexcept { return value_; } -}; - -class year { - private: - int value_; - - public: - year() = default; - constexpr explicit year(int y) noexcept : value_(y) {} - constexpr explicit operator int() const noexcept { return value_; } -}; - -class year_month_day { - private: - fmt::year year_; - fmt::month month_; - fmt::day day_; - - public: - year_month_day() = default; - constexpr year_month_day(const year& y, const month& m, const day& d) noexcept - : year_(y), month_(m), day_(d) {} - constexpr auto year() const noexcept -> fmt::year { return year_; } - constexpr auto month() const noexcept -> fmt::month { return month_; } - constexpr auto day() const noexcept -> fmt::day { return day_; } -}; +class year_month_day {}; #endif -template -struct formatter : private formatter { +// A rudimentary weekday formatter. +template struct formatter { private: - bool localized_ = false; - bool use_tm_formatter_ = false; + bool localized = false; public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - auto it = ctx.begin(), end = ctx.end(); - if (it != end && *it == 'L') { - ++it; - localized_ = true; - return it; + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto begin = ctx.begin(), end = ctx.end(); + if (begin != end && *begin == 'L') { + ++begin; + localized = true; } - use_tm_formatter_ = it != end && *it != '}'; - return use_tm_formatter_ ? formatter::parse(ctx) : it; + return begin; } template auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_wday = static_cast(wd.c_encoding()); - if (use_tm_formatter_) return formatter::format(time, ctx); - detail::get_locale loc(localized_, ctx.locale()); + detail::get_locale loc(localized, ctx.locale()); auto w = detail::tm_writer(loc, ctx.out(), time); w.on_abbr_weekday(); return w.out(); } }; -template -struct formatter : private formatter { - private: - bool use_tm_formatter_ = false; - - public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - auto it = ctx.begin(), end = ctx.end(); - use_tm_formatter_ = it != end && *it != '}'; - return use_tm_formatter_ ? formatter::parse(ctx) : it; - } - - template - auto format(day d, FormatContext& ctx) const -> decltype(ctx.out()) { - auto time = std::tm(); - time.tm_mday = static_cast(static_cast(d)); - if (use_tm_formatter_) return formatter::format(time, ctx); - detail::get_locale loc(false, ctx.locale()); - auto w = detail::tm_writer(loc, ctx.out(), time); - w.on_day_of_month(detail::numeric_system::standard, detail::pad_type::zero); - return w.out(); - } -}; - -template -struct formatter : private formatter { - private: - bool localized_ = false; - bool use_tm_formatter_ = false; - - public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - auto it = ctx.begin(), end = ctx.end(); - if (it != end && *it == 'L') { - ++it; - localized_ = true; - return it; - } - use_tm_formatter_ = it != end && *it != '}'; - return use_tm_formatter_ ? formatter::parse(ctx) : it; - } - - template - auto format(month m, FormatContext& ctx) const -> decltype(ctx.out()) { - auto time = std::tm(); - time.tm_mon = static_cast(static_cast(m)) - 1; - if (use_tm_formatter_) return formatter::format(time, ctx); - detail::get_locale loc(localized_, ctx.locale()); - auto w = detail::tm_writer(loc, ctx.out(), time); - w.on_abbr_month(); - return w.out(); - } -}; - -template -struct formatter : private formatter { - private: - bool use_tm_formatter_ = false; - - public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - auto it = ctx.begin(), end = ctx.end(); - use_tm_formatter_ = it != end && *it != '}'; - return use_tm_formatter_ ? formatter::parse(ctx) : it; - } - - template - auto format(year y, FormatContext& ctx) const -> decltype(ctx.out()) { - auto time = std::tm(); - time.tm_year = static_cast(y) - 1900; - if (use_tm_formatter_) return formatter::format(time, ctx); - detail::get_locale loc(false, ctx.locale()); - auto w = detail::tm_writer(loc, ctx.out(), time); - w.on_year(detail::numeric_system::standard, detail::pad_type::zero); - return w.out(); - } -}; - -template -struct formatter : private formatter { - private: - bool use_tm_formatter_ = false; - - public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - auto it = ctx.begin(), end = ctx.end(); - use_tm_formatter_ = it != end && *it != '}'; - return use_tm_formatter_ ? formatter::parse(ctx) : it; - } - - template - auto format(year_month_day val, FormatContext& ctx) const - -> decltype(ctx.out()) { - auto time = std::tm(); - time.tm_year = static_cast(val.year()) - 1900; - time.tm_mon = static_cast(static_cast(val.month())) - 1; - time.tm_mday = static_cast(static_cast(val.day())); - if (use_tm_formatter_) return formatter::format(time, ctx); - detail::get_locale loc(true, ctx.locale()); - auto w = detail::tm_writer(loc, ctx.out(), time); - w.on_iso_date(); - return w.out(); - } -}; - template struct formatter, Char> { private: - format_specs specs_; + format_specs specs_; detail::arg_ref width_ref_; detail::arg_ref precision_ref_; bool localized_ = false; - basic_string_view fmt_; + basic_string_view format_str_; public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; - Char c = *it; - if ((c >= '0' && c <= '9') || c == '{') { - it = detail::parse_width(it, end, specs_, width_ref_, ctx); - if (it == end) return it; - } + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it == end) return it; auto checker = detail::chrono_format_checker(); if (*it == '.') { checker.has_precision_integral = !std::is_floating_point::value; - it = detail::parse_precision(it, end, specs_, precision_ref_, ctx); + it = detail::parse_precision(it, end, specs_.precision, precision_ref_, + ctx); } if (it != end && *it == 'L') { localized_ = true; ++it; } end = detail::parse_chrono_format(it, end, checker); - fmt_ = {it, detail::to_unsigned(end - it)}; + format_str_ = {it, detail::to_unsigned(end - it)}; return end; } @@ -2191,15 +2082,15 @@ struct formatter, Char> { auto specs = specs_; auto precision = specs.precision; specs.precision = -1; - auto begin = fmt_.begin(), end = fmt_.end(); + auto begin = format_str_.begin(), end = format_str_.end(); // As a possible future optimization, we could avoid extra copying if width // is not specified. auto buf = basic_memory_buffer(); - auto out = basic_appender(buf); - detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, - ctx); - detail::handle_dynamic_spec(specs.dynamic_precision(), precision, - precision_ref_, ctx); + auto out = std::back_inserter(buf); + detail::handle_dynamic_spec(specs.width, width_ref_, + ctx); + detail::handle_dynamic_spec(precision, + precision_ref_, ctx); if (begin == end || *begin == '}') { out = detail::format_duration_value(out, d.count(), precision); detail::format_duration_unit(out); @@ -2216,119 +2107,130 @@ struct formatter, Char> { } }; +template +struct formatter, + Char> : formatter { + FMT_CONSTEXPR formatter() { + this->format_str_ = detail::string_literal{}; + } + + template + auto format(std::chrono::time_point val, + FormatContext& ctx) const -> decltype(ctx.out()) { + using period = typename Duration::period; + if (detail::const_check( + period::num != 1 || period::den != 1 || + std::is_floating_point::value)) { + const auto epoch = val.time_since_epoch(); + auto subsecs = detail::fmt_duration_cast( + epoch - detail::fmt_duration_cast(epoch)); + + if (subsecs.count() < 0) { + auto second = + detail::fmt_duration_cast(std::chrono::seconds(1)); + if (epoch.count() < ((Duration::min)() + second).count()) + FMT_THROW(format_error("duration is too small")); + subsecs += second; + val -= second; + } + + return formatter::do_format(gmtime(val), ctx, &subsecs); + } + + return formatter::format(gmtime(val), ctx); + } +}; + +#if FMT_USE_LOCAL_TIME +template +struct formatter, Char> + : formatter { + FMT_CONSTEXPR formatter() { + this->format_str_ = detail::string_literal{}; + } + + template + auto format(std::chrono::local_time val, FormatContext& ctx) const + -> decltype(ctx.out()) { + using period = typename Duration::period; + if (period::num != 1 || period::den != 1 || + std::is_floating_point::value) { + const auto epoch = val.time_since_epoch(); + const auto subsecs = detail::fmt_duration_cast( + epoch - detail::fmt_duration_cast(epoch)); + + return formatter::do_format(localtime(val), ctx, &subsecs); + } + + return formatter::format(localtime(val), ctx); + } +}; +#endif + +#if FMT_USE_UTC_TIME +template +struct formatter, + Char> + : formatter, + Char> { + template + auto format(std::chrono::time_point val, + FormatContext& ctx) const -> decltype(ctx.out()) { + return formatter< + std::chrono::time_point, + Char>::format(std::chrono::utc_clock::to_sys(val), ctx); + } +}; +#endif + template struct formatter { private: - format_specs specs_; + format_specs specs_; detail::arg_ref width_ref_; protected: - basic_string_view fmt_; + basic_string_view format_str_; - template + template auto do_format(const std::tm& tm, FormatContext& ctx, const Duration* subsecs) const -> decltype(ctx.out()) { auto specs = specs_; auto buf = basic_memory_buffer(); - auto out = basic_appender(buf); - detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, - ctx); + auto out = std::back_inserter(buf); + detail::handle_dynamic_spec(specs.width, width_ref_, + ctx); auto loc_ref = ctx.locale(); detail::get_locale loc(static_cast(loc_ref), loc_ref); auto w = detail::tm_writer(loc, out, tm, subsecs); - detail::parse_chrono_format(fmt_.begin(), fmt_.end(), w); + detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w); return detail::write( ctx.out(), basic_string_view(buf.data(), buf.size()), specs); } public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; - Char c = *it; - if ((c >= '0' && c <= '9') || c == '{') { - it = detail::parse_width(it, end, specs_, width_ref_, ctx); - if (it == end) return it; - } + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it == end) return it; end = detail::parse_chrono_format(it, end, detail::tm_format_checker()); - // Replace the default format string only if the new spec is not empty. - if (end != it) fmt_ = {it, detail::to_unsigned(end - it)}; + // Replace the default format_str only if the new spec is not empty. + if (end != it) format_str_ = {it, detail::to_unsigned(end - it)}; return end; } template auto format(const std::tm& tm, FormatContext& ctx) const -> decltype(ctx.out()) { - return do_format(tm, ctx, nullptr); - } -}; - -template -struct formatter, Char> : formatter { - FMT_CONSTEXPR formatter() { - this->fmt_ = detail::string_literal(); - } - - template - auto format(sys_time val, FormatContext& ctx) const - -> decltype(ctx.out()) { - std::tm tm = gmtime(val); - using period = typename Duration::period; - if (detail::const_check( - period::num == 1 && period::den == 1 && - !std::is_floating_point::value)) { - return formatter::format(tm, ctx); - } - Duration epoch = val.time_since_epoch(); - Duration subsecs = detail::duration_cast( - epoch - detail::duration_cast(epoch)); - if (subsecs.count() < 0) { - auto second = detail::duration_cast(std::chrono::seconds(1)); - if (tm.tm_sec != 0) - --tm.tm_sec; - else - tm = gmtime(val - second); - subsecs += detail::duration_cast(std::chrono::seconds(1)); - } - return formatter::do_format(tm, ctx, &subsecs); - } -}; - -template -struct formatter, Char> - : formatter, Char> { - template - auto format(utc_time val, FormatContext& ctx) const - -> decltype(ctx.out()) { - return formatter, Char>::format( - detail::utc_clock::to_sys(val), ctx); - } -}; - -template -struct formatter, Char> : formatter { - FMT_CONSTEXPR formatter() { - this->fmt_ = detail::string_literal(); - } - - template - auto format(local_time val, FormatContext& ctx) const - -> decltype(ctx.out()) { - using period = typename Duration::period; - if (period::num == 1 && period::den == 1 && - !std::is_floating_point::value) { - return formatter::format(localtime(val), ctx); - } - auto epoch = val.time_since_epoch(); - auto subsecs = detail::duration_cast( - epoch - detail::duration_cast(epoch)); - return formatter::do_format(localtime(val), ctx, &subsecs); + return do_format(tm, ctx, nullptr); } }; diff --git a/src/fmt/color.h b/src/fmt/color.h index 2faaf3a067..464519e582 100644 --- a/src/fmt/color.h +++ b/src/fmt/color.h @@ -227,7 +227,7 @@ struct color_type { }; } // namespace detail -/// A text style consisting of foreground and background colors and emphasis. +/** A text style consisting of foreground and background colors and emphasis. */ class text_style { public: FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept @@ -239,7 +239,7 @@ class text_style { foreground_color = rhs.foreground_color; } else if (rhs.set_foreground_color) { if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) - report_error("can't OR a terminal color"); + FMT_THROW(format_error("can't OR a terminal color")); foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; } @@ -248,7 +248,7 @@ class text_style { background_color = rhs.background_color; } else if (rhs.set_background_color) { if (!background_color.is_rgb || !rhs.background_color.is_rgb) - report_error("can't OR a terminal color"); + FMT_THROW(format_error("can't OR a terminal color")); background_color.value.rgb_color |= rhs.background_color.value.rgb_color; } @@ -310,13 +310,13 @@ class text_style { emphasis ems; }; -/// Creates a text style from the foreground (text) color. +/** Creates a text style from the foreground (text) color. */ FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept -> text_style { return text_style(true, foreground); } -/// Creates a text style from the background color. +/** Creates a text style from the background color. */ FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept -> text_style { return text_style(false, background); @@ -330,7 +330,7 @@ FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept namespace detail { template struct ansi_color_escape { - FMT_CONSTEXPR ansi_color_escape(color_type text_color, + FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, const char* esc) noexcept { // If we have a terminal color, we need to output another escape code // sequence. @@ -391,7 +391,7 @@ template struct ansi_color_escape { FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } FMT_CONSTEXPR20 auto end() const noexcept -> const Char* { - return buffer + basic_string_view(buffer).size(); + return buffer + std::char_traits::length(buffer); } private: @@ -412,13 +412,13 @@ template struct ansi_color_escape { }; template -FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept +FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept -> ansi_color_escape { return ansi_color_escape(foreground, "\x1b[38;2;"); } template -FMT_CONSTEXPR auto make_background_color(color_type background) noexcept +FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept -> ansi_color_escape { return ansi_color_escape(background, "\x1b[48;2;"); } @@ -434,7 +434,7 @@ template inline void reset_color(buffer& buffer) { buffer.append(reset_color.begin(), reset_color.end()); } -template struct styled_arg : view { +template struct styled_arg : detail::view { const T& value; text_style style; styled_arg(const T& v, text_style s) : value(v), style(s) {} @@ -442,115 +442,145 @@ template struct styled_arg : view { template void vformat_to(buffer& buf, const text_style& ts, - basic_string_view fmt, - basic_format_args> args) { + basic_string_view format_str, + basic_format_args>> args) { bool has_style = false; if (ts.has_emphasis()) { has_style = true; - auto emphasis = make_emphasis(ts.get_emphasis()); + auto emphasis = detail::make_emphasis(ts.get_emphasis()); buf.append(emphasis.begin(), emphasis.end()); } if (ts.has_foreground()) { has_style = true; - auto foreground = make_foreground_color(ts.get_foreground()); + auto foreground = detail::make_foreground_color(ts.get_foreground()); buf.append(foreground.begin(), foreground.end()); } if (ts.has_background()) { has_style = true; - auto background = make_background_color(ts.get_background()); + auto background = detail::make_background_color(ts.get_background()); buf.append(background.begin(), background.end()); } - vformat_to(buf, fmt, args); - if (has_style) reset_color(buf); + detail::vformat_to(buf, format_str, args, {}); + if (has_style) detail::reset_color(buf); } + } // namespace detail -inline void vprint(FILE* f, const text_style& ts, string_view fmt, +inline void vprint(std::FILE* f, const text_style& ts, string_view fmt, format_args args) { + // Legacy wide streams are not supported. auto buf = memory_buffer(); detail::vformat_to(buf, ts, fmt, args); - print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size())); + if (detail::is_utf8()) { + detail::print(f, string_view(buf.begin(), buf.size())); + return; + } + buf.push_back('\0'); + int result = std::fputs(buf.data(), f); + if (result < 0) + FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } /** - * Formats a string and prints it to the specified file stream using ANSI - * escape sequences to specify text formatting. - * - * **Example**: - * - * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), - * "Elapsed time: {0:.2f} seconds", 1.23); + \rst + Formats a string and prints it to the specified file stream using ANSI + escape sequences to specify text formatting. + + **Example**:: + + fmt::print(fmt::emphasis::bold | fg(fmt::color::red), + "Elapsed time: {0:.2f} seconds", 1.23); + \endrst */ -template -void print(FILE* f, const text_style& ts, format_string fmt, - T&&... args) { - vprint(f, ts, fmt.str, vargs{{args...}}); +template ::value)> +void print(std::FILE* f, const text_style& ts, const S& format_str, + const Args&... args) { + vprint(f, ts, format_str, + fmt::make_format_args>>(args...)); } /** - * Formats a string and prints it to stdout using ANSI escape sequences to - * specify text formatting. - * - * **Example**: - * - * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), - * "Elapsed time: {0:.2f} seconds", 1.23); + \rst + Formats a string and prints it to stdout using ANSI escape sequences to + specify text formatting. + + **Example**:: + + fmt::print(fmt::emphasis::bold | fg(fmt::color::red), + "Elapsed time: {0:.2f} seconds", 1.23); + \endrst */ -template -void print(const text_style& ts, format_string fmt, T&&... args) { - return print(stdout, ts, fmt, std::forward(args)...); +template ::value)> +void print(const text_style& ts, const S& format_str, const Args&... args) { + return print(stdout, ts, format_str, args...); } -inline auto vformat(const text_style& ts, string_view fmt, format_args args) - -> std::string { - auto buf = memory_buffer(); - detail::vformat_to(buf, ts, fmt, args); +template > +inline auto vformat( + const text_style& ts, const S& format_str, + basic_format_args>> args) + -> std::basic_string { + basic_memory_buffer buf; + detail::vformat_to(buf, ts, detail::to_string_view(format_str), args); return fmt::to_string(buf); } /** - * Formats arguments and returns the result as a string using ANSI escape - * sequences to specify text formatting. - * - * **Example**: - * - * ``` - * #include - * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), - * "The answer is {}", 42); - * ``` - */ -template -inline auto format(const text_style& ts, format_string fmt, T&&... args) - -> std::string { - return fmt::vformat(ts, fmt.str, vargs{{args...}}); + \rst + Formats arguments and returns the result as a string using ANSI + escape sequences to specify text formatting. + + **Example**:: + + #include + std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), + "The answer is {}", 42); + \endrst +*/ +template > +inline auto format(const text_style& ts, const S& format_str, + const Args&... args) -> std::basic_string { + return fmt::vformat(ts, detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } -/// Formats a string with the given text_style and writes the output to `out`. -template ::value)> -auto vformat_to(OutputIt out, const text_style& ts, string_view fmt, - format_args args) -> OutputIt { - auto&& buf = detail::get_buffer(out); - detail::vformat_to(buf, ts, fmt, args); +/** + Formats a string with the given text_style and writes the output to ``out``. + */ +template ::value)> +auto vformat_to(OutputIt out, const text_style& ts, + basic_string_view format_str, + basic_format_args>> args) + -> OutputIt { + auto&& buf = detail::get_buffer(out); + detail::vformat_to(buf, ts, format_str, args); return detail::get_iterator(buf, out); } /** - * Formats arguments with the given text style, writes the result to the output - * iterator `out` and returns the iterator past the end of the output range. - * - * **Example**: - * - * std::vector out; - * fmt::format_to(std::back_inserter(out), - * fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); - */ -template ::value)> -inline auto format_to(OutputIt out, const text_style& ts, - format_string fmt, T&&... args) -> OutputIt { - return vformat_to(out, ts, fmt.str, vargs{{args...}}); + \rst + Formats arguments with the given text_style, writes the result to the output + iterator ``out`` and returns the iterator past the end of the output range. + + **Example**:: + + std::vector out; + fmt::format_to(std::back_inserter(out), + fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); + \endrst +*/ +template < + typename OutputIt, typename S, typename... Args, + bool enable = detail::is_output_iterator>::value && + detail::is_string::value> +inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, + Args&&... args) -> + typename std::enable_if::type { + return vformat_to(out, ts, detail::to_string_view(format_str), + fmt::make_format_args>>(args...)); } template @@ -559,44 +589,47 @@ struct formatter, Char> : formatter { auto format(const detail::styled_arg& arg, FormatContext& ctx) const -> decltype(ctx.out()) { const auto& ts = arg.style; + const auto& value = arg.value; auto out = ctx.out(); bool has_style = false; if (ts.has_emphasis()) { has_style = true; auto emphasis = detail::make_emphasis(ts.get_emphasis()); - out = detail::copy(emphasis.begin(), emphasis.end(), out); + out = std::copy(emphasis.begin(), emphasis.end(), out); } if (ts.has_foreground()) { has_style = true; auto foreground = detail::make_foreground_color(ts.get_foreground()); - out = detail::copy(foreground.begin(), foreground.end(), out); + out = std::copy(foreground.begin(), foreground.end(), out); } if (ts.has_background()) { has_style = true; auto background = detail::make_background_color(ts.get_background()); - out = detail::copy(background.begin(), background.end(), out); + out = std::copy(background.begin(), background.end(), out); } - out = formatter::format(arg.value, ctx); + out = formatter::format(value, ctx); if (has_style) { auto reset_color = string_view("\x1b[0m"); - out = detail::copy(reset_color.begin(), reset_color.end(), out); + out = std::copy(reset_color.begin(), reset_color.end(), out); } return out; } }; /** - * Returns an argument that will be formatted using ANSI escape sequences, - * to be used in a formatting function. - * - * **Example**: - * - * fmt::print("Elapsed time: {0:.2f} seconds", - * fmt::styled(1.23, fmt::fg(fmt::color::green) | - * fmt::bg(fmt::color::blue))); + \rst + Returns an argument that will be formatted using ANSI escape sequences, + to be used in a formatting function. + + **Example**:: + + fmt::print("Elapsed time: {0:.2f} seconds", + fmt::styled(1.23, fmt::fg(fmt::color::green) | + fmt::bg(fmt::color::blue))); + \endrst */ template FMT_CONSTEXPR auto styled(const T& value, text_style ts) diff --git a/src/fmt/compile.h b/src/fmt/compile.h index 68b451c71d..71fa69c67e 100644 --- a/src/fmt/compile.h +++ b/src/fmt/compile.h @@ -8,44 +8,49 @@ #ifndef FMT_COMPILE_H_ #define FMT_COMPILE_H_ -#ifndef FMT_MODULE -# include // std::back_inserter -#endif - #include "format.h" FMT_BEGIN_NAMESPACE +namespace detail { + +template +FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end, + counting_iterator it) -> counting_iterator { + return it + (end - begin); +} // A compile-time string which is compiled into fast formatting code. -FMT_EXPORT class compiled_string {}; - -namespace detail { +class compiled_string {}; template struct is_compiled_string : std::is_base_of {}; /** - * Converts a string literal `s` into a format string that will be parsed at - * compile time and converted into efficient formatting code. Requires C++17 - * `constexpr if` compiler support. - * - * **Example**: - * - * // Converts 42 into std::string using the most efficient method and no - * // runtime format string processing. - * std::string s = fmt::format(FMT_COMPILE("{}"), 42); + \rst + Converts a string literal *s* into a format string that will be parsed at + compile time and converted into efficient formatting code. Requires C++17 + ``constexpr if`` compiler support. + + **Example**:: + + // Converts 42 into std::string using the most efficient method and no + // runtime format string processing. + std::string s = fmt::format(FMT_COMPILE("{}"), 42); + \endrst */ #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) -# define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string) +# define FMT_COMPILE(s) \ + FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit) #else # define FMT_COMPILE(s) FMT_STRING(s) #endif #if FMT_USE_NONTYPE_TEMPLATE_ARGS -template Str> +template Str> struct udl_compiled_string : compiled_string { using char_type = Char; - constexpr explicit operator basic_string_view() const { + explicit constexpr operator basic_string_view() const { return {Str.data, N - 1}; } }; @@ -56,7 +61,8 @@ auto first(const T& value, const Tail&...) -> const T& { return value; } -#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) +// LAMMPS customization: only use 'if constexpr' with C++17 +#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) && (FMT_CPLUSPLUS >= 201703L) template struct type_list {}; // Returns a reference to the argument at index N from [first, rest...]. @@ -70,29 +76,6 @@ constexpr const auto& get([[maybe_unused]] const T& first, return detail::get(rest...); } -# if FMT_USE_NONTYPE_TEMPLATE_ARGS -template -constexpr auto get_arg_index_by_name(basic_string_view name) -> int { - if constexpr (is_static_named_arg()) { - if (name == T::name) return N; - } - if constexpr (sizeof...(Args) > 0) - return get_arg_index_by_name(name); - (void)name; // Workaround an MSVC bug about "unused" parameter. - return -1; -} -# endif - -template -FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int { -# if FMT_USE_NONTYPE_TEMPLATE_ARGS - if constexpr (sizeof...(Args) > 0) - return get_arg_index_by_name<0, Args...>(name); -# endif - (void)name; - return -1; -} - template constexpr int get_arg_index_by_name(basic_string_view name, type_list) { @@ -162,12 +145,11 @@ template struct field { template constexpr OutputIt format(OutputIt out, const Args&... args) const { const T& arg = get_arg_checked(args...); - if constexpr (std::is_convertible>::value) { + if constexpr (std::is_convertible_v>) { auto s = basic_string_view(arg); - return copy(s.begin(), s.end(), out); - } else { - return write(out, arg); + return copy_str(s.begin(), s.end(), out); } + return write(out, arg); } }; @@ -255,12 +237,13 @@ constexpr size_t parse_text(basic_string_view str, size_t pos) { } template -constexpr auto compile_format_string(S fmt); +constexpr auto compile_format_string(S format_str); template -constexpr auto parse_tail(T head, S fmt) { - if constexpr (POS != basic_string_view(fmt).size()) { - constexpr auto tail = compile_format_string(fmt); +constexpr auto parse_tail(T head, S format_str) { + if constexpr (POS != + basic_string_view(format_str).size()) { + constexpr auto tail = compile_format_string(format_str); if constexpr (std::is_same, unknown_format>()) return tail; @@ -292,7 +275,6 @@ constexpr parse_specs_result parse_specs(basic_string_view str, } template struct arg_id_handler { - arg_id_kind kind; arg_ref arg_id; constexpr int on_auto() { @@ -300,28 +282,25 @@ template struct arg_id_handler { return 0; } constexpr int on_index(int id) { - kind = arg_id_kind::index; arg_id = arg_ref(id); return 0; } constexpr int on_name(basic_string_view id) { - kind = arg_id_kind::name; arg_id = arg_ref(id); return 0; } }; template struct parse_arg_id_result { - arg_id_kind kind; arg_ref arg_id; const Char* arg_id_end; }; template constexpr auto parse_arg_id(const Char* begin, const Char* end) { - auto handler = arg_id_handler{arg_id_kind::none, arg_ref{}}; + auto handler = arg_id_handler{arg_ref{}}; auto arg_id_end = parse_arg_id(begin, end, handler); - return parse_arg_id_result{handler.kind, handler.arg_id, arg_id_end}; + return parse_arg_id_result{handler.arg_id, arg_id_end}; } template struct field_type { @@ -335,13 +314,14 @@ struct field_type::value>> { template -constexpr auto parse_replacement_field_then_tail(S fmt) { +constexpr auto parse_replacement_field_then_tail(S format_str) { using char_type = typename S::char_type; - constexpr auto str = basic_string_view(fmt); + constexpr auto str = basic_string_view(format_str); constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); if constexpr (c == '}') { return parse_tail( - field::type, ARG_INDEX>(), fmt); + field::type, ARG_INDEX>(), + format_str); } else if constexpr (c != ':') { FMT_THROW(format_error("expected ':'")); } else { @@ -354,7 +334,7 @@ constexpr auto parse_replacement_field_then_tail(S fmt) { return parse_tail( spec_field::type, ARG_INDEX>{ result.fmt}, - fmt); + format_str); } } } @@ -362,21 +342,22 @@ constexpr auto parse_replacement_field_then_tail(S fmt) { // Compiles a non-empty format string and returns the compiled representation // or unknown_format() on unrecognized input. template -constexpr auto compile_format_string(S fmt) { +constexpr auto compile_format_string(S format_str) { using char_type = typename S::char_type; - constexpr auto str = basic_string_view(fmt); + constexpr auto str = basic_string_view(format_str); if constexpr (str[POS] == '{') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '{' in format string")); if constexpr (str[POS + 1] == '{') { - return parse_tail(make_text(str, POS, 1), fmt); + return parse_tail(make_text(str, POS, 1), format_str); } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { static_assert(ID != manual_indexing_id, "cannot switch from manual to automatic argument indexing"); constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail, Args, - POS + 1, ID, next_id>(fmt); + POS + 1, ID, next_id>( + format_str); } else { constexpr auto arg_id_result = parse_arg_id(str.data() + POS + 1, str.data() + str.size()); @@ -384,27 +365,28 @@ constexpr auto compile_format_string(S fmt) { constexpr char_type c = arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type(); static_assert(c == '}' || c == ':', "missing '}' in format string"); - if constexpr (arg_id_result.kind == arg_id_kind::index) { + if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) { static_assert( ID == manual_indexing_id || ID == 0, "cannot switch from automatic to manual argument indexing"); - constexpr auto arg_index = arg_id_result.arg_id.index; + constexpr auto arg_index = arg_id_result.arg_id.val.index; return parse_replacement_field_then_tail, Args, arg_id_end_pos, arg_index, manual_indexing_id>( - fmt); - } else if constexpr (arg_id_result.kind == arg_id_kind::name) { + format_str); + } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) { constexpr auto arg_index = - get_arg_index_by_name(arg_id_result.arg_id.name, Args{}); + get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{}); if constexpr (arg_index >= 0) { constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail< decltype(get_type::value), Args, arg_id_end_pos, - arg_index, next_id>(fmt); + arg_index, next_id>(format_str); } else if constexpr (c == '}') { return parse_tail( - runtime_named_field{arg_id_result.arg_id.name}, fmt); + runtime_named_field{arg_id_result.arg_id.val.name}, + format_str); } else if constexpr (c == ':') { return unknown_format(); // no type info for specs parsing } @@ -413,26 +395,29 @@ constexpr auto compile_format_string(S fmt) { } else if constexpr (str[POS] == '}') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '}' in format string")); - return parse_tail(make_text(str, POS, 1), fmt); + return parse_tail(make_text(str, POS, 1), format_str); } else { constexpr auto end = parse_text(str, POS + 1); if constexpr (end - POS > 1) { - return parse_tail(make_text(str, POS, end - POS), fmt); + return parse_tail(make_text(str, POS, end - POS), + format_str); } else { - return parse_tail(code_unit{str[POS]}, fmt); + return parse_tail(code_unit{str[POS]}, + format_str); } } } template ::value)> -constexpr auto compile(S fmt) { - constexpr auto str = basic_string_view(fmt); +constexpr auto compile(S format_str) { + constexpr auto str = basic_string_view(format_str); if constexpr (str.size() == 0) { return detail::make_text(str, 0, 0); } else { constexpr auto result = - detail::compile_format_string, 0, 0>(fmt); + detail::compile_format_string, 0, 0>( + format_str); return result; } } @@ -504,40 +489,40 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { template ::value)> -auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args) +auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); - fmt::format_to(std::back_inserter(buf), fmt, std::forward(args)...); + fmt::format_to(std::back_inserter(buf), format_str, + std::forward(args)...); return {buf.out(), buf.count()}; } template ::value)> -FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args) +FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args) -> size_t { - auto buf = detail::counting_buffer<>(); - fmt::format_to(appender(buf), fmt, args...); - return buf.count(); + return fmt::format_to(detail::counting_iterator(), format_str, args...) + .count(); } template ::value)> -void print(std::FILE* f, const S& fmt, const Args&... args) { - auto buf = memory_buffer(); - fmt::format_to(appender(buf), fmt, args...); - detail::print(f, {buf.data(), buf.size()}); +void print(std::FILE* f, const S& format_str, const Args&... args) { + memory_buffer buffer; + fmt::format_to(std::back_inserter(buffer), format_str, args...); + detail::print(f, {buffer.data(), buffer.size()}); } template ::value)> -void print(const S& fmt, const Args&... args) { - print(stdout, fmt, args...); +void print(const S& format_str, const Args&... args) { + print(stdout, format_str, args...); } #if FMT_USE_NONTYPE_TEMPLATE_ARGS inline namespace literals { -template constexpr auto operator""_cf() { +template constexpr auto operator""_cf() { using char_t = remove_cvref_t; return detail::udl_compiled_string(); diff --git a/src/fmt/core.h b/src/fmt/core.h index 8ca735f0c0..6a53b8c52c 100644 --- a/src/fmt/core.h +++ b/src/fmt/core.h @@ -1,5 +1,2963 @@ -// This file is only provided for compatibility and may be removed in future -// versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h -// otherwise. +// Formatting library for C++ - the core API for char/UTF-8 +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. -#include "format.h" +#ifndef FMT_CORE_H_ +#define FMT_CORE_H_ + +#include // std::byte +#include // std::FILE +#include // std::strlen +#include // CHAR_BIT +#include // std::string +#include // std::enable_if + +// The fmt library version in the form major * 10000 + minor * 100 + patch. +#define FMT_VERSION 100200 + +#if defined(__clang__) && !defined(__ibmxl__) +# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#else +# define FMT_CLANG_VERSION 0 +#endif + +#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \ + !defined(__NVCOMPILER) +# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#else +# define FMT_GCC_VERSION 0 +#endif + +#ifndef FMT_GCC_PRAGMA +// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884. +# if FMT_GCC_VERSION >= 504 +# define FMT_GCC_PRAGMA(arg) _Pragma(arg) +# else +# define FMT_GCC_PRAGMA(arg) +# endif +#endif + +#ifdef __ICL +# define FMT_ICC_VERSION __ICL +#elif defined(__INTEL_COMPILER) +# define FMT_ICC_VERSION __INTEL_COMPILER +#else +# define FMT_ICC_VERSION 0 +#endif + +#ifdef _MSC_VER +# define FMT_MSC_VERSION _MSC_VER +# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) +#else +# define FMT_MSC_VERSION 0 +# define FMT_MSC_WARNING(...) +#endif + +#ifdef _GLIBCXX_RELEASE +# define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE +#else +# define FMT_GLIBCXX_RELEASE 0 +#endif + +#ifdef _MSVC_LANG +# define FMT_CPLUSPLUS _MSVC_LANG +#else +# define FMT_CPLUSPLUS __cplusplus +#endif + +#ifdef __has_feature +# define FMT_HAS_FEATURE(x) __has_feature(x) +#else +# define FMT_HAS_FEATURE(x) 0 +#endif + +#if defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900 +# define FMT_HAS_INCLUDE(x) __has_include(x) +#else +# define FMT_HAS_INCLUDE(x) 0 +#endif + +#ifdef __has_cpp_attribute +# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define FMT_HAS_CPP_ATTRIBUTE(x) 0 +#endif + +#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) + +#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) + +#ifndef FMT_DEPRECATED +# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900 +# define FMT_DEPRECATED [[deprecated]] +# else +# if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__) +# define FMT_DEPRECATED __attribute__((deprecated)) +# elif FMT_MSC_VERSION +# define FMT_DEPRECATED __declspec(deprecated) +# else +# define FMT_DEPRECATED /* deprecated */ +# endif +# endif +#endif + +// Check if relaxed C++14 constexpr is supported. +// GCC doesn't allow throw in constexpr until version 6 (bug 67371). +#ifndef FMT_USE_CONSTEXPR +# if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \ + (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) && \ + !FMT_ICC_VERSION && (!defined(__NVCC__) || FMT_CPLUSPLUS >= 202002L) +# define FMT_USE_CONSTEXPR 1 +# else +# define FMT_USE_CONSTEXPR 0 +# endif +#endif +#if FMT_USE_CONSTEXPR +# define FMT_CONSTEXPR constexpr +#else +# define FMT_CONSTEXPR +#endif + +#if (FMT_CPLUSPLUS >= 202002L || \ + (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) && \ + ((!FMT_GLIBCXX_RELEASE || FMT_GLIBCXX_RELEASE >= 10) && \ + (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \ + (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) && \ + defined(__cpp_lib_is_constant_evaluated) +# define FMT_CONSTEXPR20 constexpr +#else +# define FMT_CONSTEXPR20 +#endif + +// Check if exceptions are disabled. +#ifndef FMT_EXCEPTIONS +# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ + (FMT_MSC_VERSION && !_HAS_EXCEPTIONS) +# define FMT_EXCEPTIONS 0 +# else +# define FMT_EXCEPTIONS 1 +# endif +#endif + +// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. +#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \ + !defined(__NVCC__) +# define FMT_NORETURN [[noreturn]] +#else +# define FMT_NORETURN +#endif + +#ifndef FMT_NODISCARD +# if FMT_HAS_CPP17_ATTRIBUTE(nodiscard) +# define FMT_NODISCARD [[nodiscard]] +# else +# define FMT_NODISCARD +# endif +#endif + +#ifndef FMT_INLINE +# if FMT_GCC_VERSION || FMT_CLANG_VERSION +# define FMT_INLINE inline __attribute__((always_inline)) +# else +# define FMT_INLINE inline +# endif +#endif + +#ifdef _MSC_VER +# define FMT_UNCHECKED_ITERATOR(It) \ + using _Unchecked_type = It // Mark iterator as checked. +#else +# define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It +#endif + +// LAMMPS customization +// use 'v10_lmp' namespace instead of 'v10' so that our +// bundled copy does not collide with linking other code +// using system wide installations which may be using +// a different version. + +#ifndef FMT_BEGIN_NAMESPACE +# define FMT_BEGIN_NAMESPACE \ + namespace fmt { \ + inline namespace v10_lmp { +# define FMT_END_NAMESPACE \ + } \ + } +#endif + +#ifndef FMT_EXPORT +# define FMT_EXPORT +# define FMT_BEGIN_EXPORT +# define FMT_END_EXPORT +#endif + +#if FMT_GCC_VERSION || FMT_CLANG_VERSION +# define FMT_VISIBILITY(value) __attribute__((visibility(value))) +#else +# define FMT_VISIBILITY(value) +#endif + +#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +# if defined(FMT_LIB_EXPORT) +# define FMT_API __declspec(dllexport) +# elif defined(FMT_SHARED) +# define FMT_API __declspec(dllimport) +# endif +#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) +# define FMT_API FMT_VISIBILITY("default") +#endif +#ifndef FMT_API +# define FMT_API +#endif + +#ifndef FMT_UNICODE +# define FMT_UNICODE !FMT_MSC_VERSION +#endif + +#ifndef FMT_CONSTEVAL +# if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \ + (!defined(__apple_build_version__) || \ + __apple_build_version__ >= 14000029L) && \ + FMT_CPLUSPLUS >= 202002L) || \ + (defined(__cpp_consteval) && \ + (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929)) +// consteval is broken in MSVC before VS2019 version 16.10 and Apple clang +// before 14. +# define FMT_CONSTEVAL consteval +# define FMT_HAS_CONSTEVAL +# else +# define FMT_CONSTEVAL +# endif +#endif + +#ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS +# if defined(__cpp_nontype_template_args) && \ + ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || \ + __cpp_nontype_template_args >= 201911L) && \ + !defined(__NVCOMPILER) && !defined(__LCC__) +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 +# else +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 +# endif +#endif + +// GCC < 5 requires this-> in decltype. +#ifndef FMT_DECLTYPE_THIS +# if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 +# define FMT_DECLTYPE_THIS this-> +# else +# define FMT_DECLTYPE_THIS +# endif +#endif + +// Enable minimal optimizations for more compact code in debug mode. +FMT_GCC_PRAGMA("GCC push_options") +#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \ + !defined(__CUDACC__) +FMT_GCC_PRAGMA("GCC optimize(\"Og\")") +#endif + +FMT_BEGIN_NAMESPACE + +// Implementations of enable_if_t and other metafunctions for older systems. +template +using enable_if_t = typename std::enable_if::type; +template +using conditional_t = typename std::conditional::type; +template using bool_constant = std::integral_constant; +template +using remove_reference_t = typename std::remove_reference::type; +template +using remove_const_t = typename std::remove_const::type; +template +using remove_cvref_t = typename std::remove_cv>::type; +template struct type_identity { + using type = T; +}; +template using type_identity_t = typename type_identity::type; +template +using underlying_t = typename std::underlying_type::type; + +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 +// A workaround for gcc 4.8 to make void_t work in a SFINAE context. +template struct void_t_impl { + using type = void; +}; +template using void_t = typename void_t_impl::type; +#else +template using void_t = void; +#endif + +struct monostate { + constexpr monostate() {} +}; + +// An implementation of back_insert_iterator to avoid dependency on . +template class back_insert_iterator { + private: + Container* container_; + + friend auto get_container(back_insert_iterator it) -> Container& { + return *it.container_; + } + + public: + using difference_type = ptrdiff_t; + FMT_UNCHECKED_ITERATOR(back_insert_iterator); + + explicit back_insert_iterator(Container& c) : container_(&c) {} + + auto operator=(const typename Container::value_type& value) + -> back_insert_iterator& { + container_->push_back(value); + return *this; + } + auto operator*() -> back_insert_iterator& { return *this; } + auto operator++() -> back_insert_iterator& { return *this; } + auto operator++(int) -> back_insert_iterator { return *this; } +}; + +template +auto back_inserter(Container& c) -> back_insert_iterator { + return {c}; +} + +// An enable_if helper to be used in template parameters which results in much +// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed +// to workaround a bug in MSVC 2019 (see #1140 and #1186). +#ifdef FMT_DOC +# define FMT_ENABLE_IF(...) +#else +# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 +#endif + +// This is defined in core.h instead of format.h to avoid injecting in std. +// It is a template to avoid undesirable implicit conversions to std::byte. +#ifdef __cpp_lib_byte +template ::value)> +inline auto format_as(T b) -> unsigned char { + return static_cast(b); +} +#endif + +namespace detail { +// Suppresses "unused variable" warnings with the method described in +// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. +// (void)var does not work on many Intel compilers. +template FMT_CONSTEXPR void ignore_unused(const T&...) {} + +constexpr FMT_INLINE auto is_constant_evaluated( + bool default_value = false) noexcept -> bool { +// Workaround for incompatibility between libstdc++ consteval-based +// std::is_constant_evaluated() implementation and clang-14: +// https://github.com/fmtlib/fmt/issues/3247. +#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \ + (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) + ignore_unused(default_value); + return __builtin_is_constant_evaluated(); +#elif defined(__cpp_lib_is_constant_evaluated) + ignore_unused(default_value); + return std::is_constant_evaluated(); +#else + return default_value; +#endif +} + +// Suppresses "conditional expression is constant" warnings. +template constexpr FMT_INLINE auto const_check(T value) -> T { + return value; +} + +FMT_NORETURN FMT_API void assert_fail(const char* file, int line, + const char* message); + +#ifndef FMT_ASSERT +# ifdef NDEBUG +// FMT_ASSERT is not empty to avoid -Wempty-body. +# define FMT_ASSERT(condition, message) \ + fmt::detail::ignore_unused((condition), (message)) +# else +# define FMT_ASSERT(condition, message) \ + ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ + ? (void)0 \ + : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) +# endif +#endif + +#ifdef FMT_USE_INT128 +// Do nothing. +#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ + !(FMT_CLANG_VERSION && FMT_MSC_VERSION) +# define FMT_USE_INT128 1 +using int128_opt = __int128_t; // An optional native 128-bit integer. +using uint128_opt = __uint128_t; +template inline auto convert_for_visit(T value) -> T { + return value; +} +#else +# define FMT_USE_INT128 0 +#endif +#if !FMT_USE_INT128 +enum class int128_opt {}; +enum class uint128_opt {}; +// Reduce template instantiations. +template auto convert_for_visit(T) -> monostate { return {}; } +#endif + +// Casts a nonnegative integer to unsigned. +template +FMT_CONSTEXPR auto to_unsigned(Int value) -> + typename std::make_unsigned::type { +#if 0 + // LAMMPS customization: disable assertion to avoid bogus warnings + FMT_ASSERT(std::is_unsigned::value || value >= 0, "negative value"); +#endif + return static_cast::type>(value); +} + +template +struct is_string_like : std::false_type {}; + +// A heuristic to detect std::string and std::string_view. +template +struct is_string_like().find_first_of( + typename T::value_type(), 0))>> : std::true_type { +}; + +FMT_CONSTEXPR inline auto is_utf8() -> bool { + FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7"; + + // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297). + using uchar = unsigned char; + return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 && + uchar(section[1]) == 0xA7); +} + +template FMT_CONSTEXPR auto length(const Char* s) -> size_t { + size_t len = 0; + while (*s++) ++len; + return len; +} + +template +FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n) + -> int { + for (; n != 0; ++s1, ++s2, --n) { + if (*s1 < *s2) return -1; + if (*s1 > *s2) return 1; + } + return 0; +} +} // namespace detail + +template +using basic_string = + std::basic_string, std::allocator>; + +// Checks whether T is a container with contiguous storage. +template struct is_contiguous : std::false_type {}; +template +struct is_contiguous> : std::true_type {}; + +/** + An implementation of ``std::basic_string_view`` for pre-C++17. It provides a + subset of the API. ``fmt::basic_string_view`` is used for format strings even + if ``std::string_view`` is available to prevent issues when a library is + compiled with a different ``-std`` option than the client code (which is not + recommended). + */ +FMT_EXPORT +template class basic_string_view { + private: + const Char* data_; + size_t size_; + + public: + using value_type = Char; + using iterator = const Char*; + + constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} + + /** Constructs a string reference object from a C string and a size. */ + constexpr basic_string_view(const Char* s, size_t count) noexcept + : data_(s), size_(count) {} + + /** + Constructs a string reference object from a C string. + */ + FMT_CONSTEXPR20 + FMT_INLINE + basic_string_view(const Char* s) + : data_(s), + size_(detail::const_check(std::is_same::value && + !detail::is_constant_evaluated(false)) + ? std::strlen(reinterpret_cast(s)) + : detail::length(s)) {} + + /** + Constructs a string reference from a ``std::basic_string`` or a + ``std::basic_string_view`` object. + */ + template ::value&& std::is_same< + typename S::value_type, Char>::value)> + FMT_CONSTEXPR basic_string_view(const S& s) noexcept + : data_(s.data()), size_(s.size()) {} + + /** Returns a pointer to the string data. */ + constexpr auto data() const noexcept -> const Char* { return data_; } + + /** Returns the string size. */ + constexpr auto size() const noexcept -> size_t { return size_; } + + constexpr auto begin() const noexcept -> iterator { return data_; } + constexpr auto end() const noexcept -> iterator { return data_ + size_; } + + constexpr auto operator[](size_t pos) const noexcept -> const Char& { + return data_[pos]; + } + + FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { + data_ += n; + size_ -= n; + } + + FMT_CONSTEXPR auto starts_with(basic_string_view sv) const noexcept + -> bool { + return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0; + } + FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool { + return size_ >= 1 && *data_ == c; + } + FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool { + return starts_with(basic_string_view(s)); + } + + // Lexicographically compare this string reference to other. + FMT_CONSTEXPR auto compare(basic_string_view other) const -> int { + size_t str_size = size_ < other.size_ ? size_ : other.size_; + int result = detail::compare(data_, other.data_, str_size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + FMT_CONSTEXPR friend auto operator==(basic_string_view lhs, + basic_string_view rhs) -> bool { + return lhs.compare(rhs) == 0; + } + friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) != 0; + } + friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) < 0; + } + friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) <= 0; + } + friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) > 0; + } + friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) >= 0; + } +}; + +FMT_EXPORT +using string_view = basic_string_view; + +/** Specifies if ``T`` is a character type. Can be specialized by users. */ +FMT_EXPORT +template struct is_char : std::false_type {}; +template <> struct is_char : std::true_type {}; + +namespace detail { + +// A base class for compile-time strings. +struct compile_string {}; + +template +struct is_compile_string : std::is_base_of {}; + +template ::value)> +FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view { + return s; +} +template ::value)> +inline auto to_string_view(const S& s) + -> basic_string_view { + return s; // std::basic_string[_view] +} +template +constexpr auto to_string_view(basic_string_view s) + -> basic_string_view { + return s; +} +template ::value)> +constexpr auto to_string_view(const S& s) + -> basic_string_view { + return basic_string_view(s); +} +void to_string_view(...); + +// Specifies whether S is a string type convertible to fmt::basic_string_view. +// It should be a constexpr function but MSVC 2017 fails to compile it in +// enable_if and MSVC 2015 fails to compile it as an alias template. +// ADL is intentionally disabled as to_string_view is not an extension point. +template +struct is_string + : std::is_class()))> {}; + +template struct char_t_impl {}; +template struct char_t_impl::value>> { + using result = decltype(to_string_view(std::declval())); + using type = typename result::value_type; +}; + +enum class type { + none_type, + // Integer types should go first, + int_type, + uint_type, + long_long_type, + ulong_long_type, + int128_type, + uint128_type, + bool_type, + char_type, + last_integer_type = char_type, + // followed by floating-point types. + float_type, + double_type, + long_double_type, + last_numeric_type = long_double_type, + cstring_type, + string_type, + pointer_type, + custom_type +}; + +// Maps core type T to the corresponding type enum constant. +template +struct type_constant : std::integral_constant {}; + +#define FMT_TYPE_CONSTANT(Type, constant) \ + template \ + struct type_constant \ + : std::integral_constant {} + +FMT_TYPE_CONSTANT(int, int_type); +FMT_TYPE_CONSTANT(unsigned, uint_type); +FMT_TYPE_CONSTANT(long long, long_long_type); +FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); +FMT_TYPE_CONSTANT(int128_opt, int128_type); +FMT_TYPE_CONSTANT(uint128_opt, uint128_type); +FMT_TYPE_CONSTANT(bool, bool_type); +FMT_TYPE_CONSTANT(Char, char_type); +FMT_TYPE_CONSTANT(float, float_type); +FMT_TYPE_CONSTANT(double, double_type); +FMT_TYPE_CONSTANT(long double, long_double_type); +FMT_TYPE_CONSTANT(const Char*, cstring_type); +FMT_TYPE_CONSTANT(basic_string_view, string_type); +FMT_TYPE_CONSTANT(const void*, pointer_type); + +constexpr auto is_integral_type(type t) -> bool { + return t > type::none_type && t <= type::last_integer_type; +} +constexpr auto is_arithmetic_type(type t) -> bool { + return t > type::none_type && t <= type::last_numeric_type; +} + +constexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); } +constexpr auto in(type t, int set) -> bool { + return ((set >> static_cast(t)) & 1) != 0; +} + +// Bitsets of types. +enum { + sint_set = + set(type::int_type) | set(type::long_long_type) | set(type::int128_type), + uint_set = set(type::uint_type) | set(type::ulong_long_type) | + set(type::uint128_type), + bool_set = set(type::bool_type), + char_set = set(type::char_type), + float_set = set(type::float_type) | set(type::double_type) | + set(type::long_double_type), + string_set = set(type::string_type), + cstring_set = set(type::cstring_type), + pointer_set = set(type::pointer_type) +}; +} // namespace detail + +/** Throws ``format_error`` with a given message. */ +FMT_NORETURN FMT_API void throw_format_error(const char* message); + +/** String's character type. */ +template using char_t = typename detail::char_t_impl::type; + +/** + \rst + Parsing context consisting of a format string range being parsed and an + argument counter for automatic indexing. + You can use the ``format_parse_context`` type alias for ``char`` instead. + \endrst + */ +FMT_EXPORT +template class basic_format_parse_context { + private: + basic_string_view format_str_; + int next_arg_id_; + + FMT_CONSTEXPR void do_check_arg_id(int id); + + public: + using char_type = Char; + using iterator = const Char*; + + explicit constexpr basic_format_parse_context( + basic_string_view format_str, int next_arg_id = 0) + : format_str_(format_str), next_arg_id_(next_arg_id) {} + + /** + Returns an iterator to the beginning of the format string range being + parsed. + */ + constexpr auto begin() const noexcept -> iterator { + return format_str_.begin(); + } + + /** + Returns an iterator past the end of the format string range being parsed. + */ + constexpr auto end() const noexcept -> iterator { return format_str_.end(); } + + /** Advances the begin iterator to ``it``. */ + FMT_CONSTEXPR void advance_to(iterator it) { + format_str_.remove_prefix(detail::to_unsigned(it - begin())); + } + + /** + Reports an error if using the manual argument indexing; otherwise returns + the next argument index and switches to the automatic indexing. + */ + FMT_CONSTEXPR auto next_arg_id() -> int { + if (next_arg_id_ < 0) { + throw_format_error( + "cannot switch from manual to automatic argument indexing"); + return 0; + } + int id = next_arg_id_++; + do_check_arg_id(id); + return id; + } + + /** + Reports an error if using the automatic argument indexing; otherwise + switches to the manual indexing. + */ + FMT_CONSTEXPR void check_arg_id(int id) { + if (next_arg_id_ > 0) { + throw_format_error( + "cannot switch from automatic to manual argument indexing"); + return; + } + next_arg_id_ = -1; + do_check_arg_id(id); + } + FMT_CONSTEXPR void check_arg_id(basic_string_view) {} + FMT_CONSTEXPR void check_dynamic_spec(int arg_id); +}; + +FMT_EXPORT +using format_parse_context = basic_format_parse_context; + +namespace detail { +// A parse context with extra data used only in compile-time checks. +template +class compile_parse_context : public basic_format_parse_context { + private: + int num_args_; + const type* types_; + using base = basic_format_parse_context; + + public: + explicit FMT_CONSTEXPR compile_parse_context( + basic_string_view format_str, int num_args, const type* types, + int next_arg_id = 0) + : base(format_str, next_arg_id), num_args_(num_args), types_(types) {} + + constexpr auto num_args() const -> int { return num_args_; } + constexpr auto arg_type(int id) const -> type { return types_[id]; } + + FMT_CONSTEXPR auto next_arg_id() -> int { + int id = base::next_arg_id(); + if (id >= num_args_) throw_format_error("argument not found"); + return id; + } + + FMT_CONSTEXPR void check_arg_id(int id) { + base::check_arg_id(id); + if (id >= num_args_) throw_format_error("argument not found"); + } + using base::check_arg_id; + + FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { + detail::ignore_unused(arg_id); +#if !defined(__LCC__) + if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) + throw_format_error("width/precision is not integer"); +#endif + } +}; + +/** + \rst + A contiguous memory buffer with an optional growing ability. It is an internal + class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`. + \endrst + */ +template class buffer { + private: + T* ptr_; + size_t size_; + size_t capacity_; + + using grow_fun = void (*)(buffer& buf, size_t capacity); + grow_fun grow_; + + protected: + // Don't initialize ptr_ since it is not accessed to save a few cycles. + FMT_MSC_WARNING(suppress : 26495) + FMT_CONSTEXPR buffer(grow_fun grow, size_t sz) noexcept + : size_(sz), capacity_(sz), grow_(grow) {} + + FMT_CONSTEXPR20 buffer(grow_fun grow, T* p = nullptr, size_t sz = 0, + size_t cap = 0) noexcept + : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {} + + FMT_CONSTEXPR20 ~buffer() = default; + buffer(buffer&&) = default; + + /** Sets the buffer data and capacity. */ + FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { + ptr_ = buf_data; + capacity_ = buf_capacity; + } + + public: + using value_type = T; + using const_reference = const T&; + + buffer(const buffer&) = delete; + void operator=(const buffer&) = delete; + + FMT_INLINE auto begin() noexcept -> T* { return ptr_; } + FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; } + + FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; } + FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; } + + /** Returns the size of this buffer. */ + constexpr auto size() const noexcept -> size_t { return size_; } + + /** Returns the capacity of this buffer. */ + constexpr auto capacity() const noexcept -> size_t { return capacity_; } + + /** Returns a pointer to the buffer data (not null-terminated). */ + FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } + FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } + + /** Clears this buffer. */ + void clear() { size_ = 0; } + + // Tries resizing the buffer to contain *count* elements. If T is a POD type + // the new elements may not be initialized. + FMT_CONSTEXPR20 void try_resize(size_t count) { + try_reserve(count); + size_ = count <= capacity_ ? count : capacity_; + } + + // Tries increasing the buffer capacity to *new_capacity*. It can increase the + // capacity by a smaller amount than requested but guarantees there is space + // for at least one additional element either by increasing the capacity or by + // flushing the buffer if it is full. + FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) { + if (new_capacity > capacity_) grow_(*this, new_capacity); + } + + FMT_CONSTEXPR20 void push_back(const T& value) { + try_reserve(size_ + 1); + ptr_[size_++] = value; + } + + /** Appends data to the end of the buffer. */ + template void append(const U* begin, const U* end); + + template FMT_CONSTEXPR auto operator[](Idx index) -> T& { + return ptr_[index]; + } + template + FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { + return ptr_[index]; + } +}; + +struct buffer_traits { + explicit buffer_traits(size_t) {} + auto count() const -> size_t { return 0; } + auto limit(size_t size) -> size_t { return size; } +}; + +class fixed_buffer_traits { + private: + size_t count_ = 0; + size_t limit_; + + public: + explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} + auto count() const -> size_t { return count_; } + auto limit(size_t size) -> size_t { + size_t n = limit_ > count_ ? limit_ - count_ : 0; + count_ += size; + return size < n ? size : n; + } +}; + +// A buffer that writes to an output iterator when flushed. +template +class iterator_buffer final : public Traits, public buffer { + private: + OutputIt out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + static FMT_CONSTEXPR20 void grow(buffer& buf, size_t) { + if (buf.size() == buffer_size) static_cast(buf).flush(); + } + + void flush() { + auto size = this->size(); + this->clear(); + const T* begin = data_; + const T* end = begin + this->limit(size); + while (begin != end) *out_++ = *begin++; + } + + public: + explicit iterator_buffer(OutputIt out, size_t n = buffer_size) + : Traits(n), buffer(grow, data_, 0, buffer_size), out_(out) {} + iterator_buffer(iterator_buffer&& other) + : Traits(other), + buffer(grow, data_, 0, buffer_size), + out_(other.out_) {} + ~iterator_buffer() { flush(); } + + auto out() -> OutputIt { + flush(); + return out_; + } + auto count() const -> size_t { return Traits::count() + this->size(); } +}; + +template +class iterator_buffer final + : public fixed_buffer_traits, + public buffer { + private: + T* out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + static FMT_CONSTEXPR20 void grow(buffer& buf, size_t) { + if (buf.size() == buf.capacity()) + static_cast(buf).flush(); + } + + void flush() { + size_t n = this->limit(this->size()); + if (this->data() == out_) { + out_ += n; + this->set(data_, buffer_size); + } + this->clear(); + } + + public: + explicit iterator_buffer(T* out, size_t n = buffer_size) + : fixed_buffer_traits(n), buffer(grow, out, 0, n), out_(out) {} + iterator_buffer(iterator_buffer&& other) + : fixed_buffer_traits(other), + buffer(static_cast(other)), + out_(other.out_) { + if (this->data() != out_) { + this->set(data_, buffer_size); + this->clear(); + } + } + ~iterator_buffer() { flush(); } + + auto out() -> T* { + flush(); + return out_; + } + auto count() const -> size_t { + return fixed_buffer_traits::count() + this->size(); + } +}; + +template class iterator_buffer final : public buffer { + public: + explicit iterator_buffer(T* out, size_t = 0) + : buffer([](buffer&, size_t) {}, out, 0, ~size_t()) {} + + auto out() -> T* { return &*this->end(); } +}; + +// A buffer that writes to a container with the contiguous storage. +template +class iterator_buffer, + enable_if_t::value, + typename Container::value_type>> + final : public buffer { + private: + using value_type = typename Container::value_type; + Container& container_; + + static FMT_CONSTEXPR20 void grow(buffer& buf, size_t capacity) { + auto& self = static_cast(buf); + self.container_.resize(capacity); + self.set(&self.container_[0], capacity); + } + + public: + explicit iterator_buffer(Container& c) + : buffer(grow, c.size()), container_(c) {} + explicit iterator_buffer(back_insert_iterator out, size_t = 0) + : iterator_buffer(get_container(out)) {} + + auto out() -> back_insert_iterator { + return fmt::back_inserter(container_); + } +}; + +// A buffer that counts the number of code units written discarding the output. +template class counting_buffer final : public buffer { + private: + enum { buffer_size = 256 }; + T data_[buffer_size]; + size_t count_ = 0; + + static FMT_CONSTEXPR20 void grow(buffer& buf, size_t) { + if (buf.size() != buffer_size) return; + static_cast(buf).count_ += buf.size(); + buf.clear(); + } + + public: + counting_buffer() : buffer(grow, data_, 0, buffer_size) {} + + auto count() -> size_t { return count_ + this->size(); } +}; +} // namespace detail + +template +FMT_CONSTEXPR void basic_format_parse_context::do_check_arg_id(int id) { + // Argument id is only checked at compile-time during parsing because + // formatting has its own validation. + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context; + if (id >= static_cast(this)->num_args()) + throw_format_error("argument not found"); + } +} + +template +FMT_CONSTEXPR void basic_format_parse_context::check_dynamic_spec( + int arg_id) { + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context; + static_cast(this)->check_dynamic_spec(arg_id); + } +} + +FMT_EXPORT template class basic_format_arg; +FMT_EXPORT template class basic_format_args; +FMT_EXPORT template class dynamic_format_arg_store; + +// A formatter for objects of type T. +FMT_EXPORT +template +struct formatter { + // A deleted default constructor indicates a disabled formatter. + formatter() = delete; +}; + +// Specifies if T has an enabled formatter specialization. A type can be +// formattable even if it doesn't have a formatter e.g. via a conversion. +template +using has_formatter = + std::is_constructible>; + +// An output iterator that appends to a buffer. It is used instead of +// back_insert_iterator to reduce symbol sizes for the common case. +class appender { + private: + detail::buffer* buffer_; + + friend auto get_container(appender app) -> detail::buffer& { + return *app.buffer_; + } + + public: + using difference_type = ptrdiff_t; + FMT_UNCHECKED_ITERATOR(appender); + + appender(detail::buffer& buf) : buffer_(&buf) {} + + auto operator=(char c) -> appender& { + buffer_->push_back(c); + return *this; + } + auto operator*() -> appender& { return *this; } + auto operator++() -> appender& { return *this; } + auto operator++(int) -> appender { return *this; } +}; + +namespace detail { + +template +constexpr auto has_const_formatter_impl(T*) + -> decltype(typename Context::template formatter_type().format( + std::declval(), std::declval()), + true) { + return true; +} +template +constexpr auto has_const_formatter_impl(...) -> bool { + return false; +} +template +constexpr auto has_const_formatter() -> bool { + return has_const_formatter_impl(static_cast(nullptr)); +} + +template +using buffer_appender = conditional_t::value, appender, + back_insert_iterator>>; + +// Maps an output iterator to a buffer. +template +auto get_buffer(OutputIt out) -> iterator_buffer { + return iterator_buffer(out); +} +template , Buf>::value)> +auto get_buffer(back_insert_iterator out) -> buffer& { + return get_container(out); +} + +template +FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { + return buf.out(); +} +template +auto get_iterator(buffer&, OutputIt out) -> OutputIt { + return out; +} + +struct view {}; + +template struct named_arg : view { + const Char* name; + const T& value; + named_arg(const Char* n, const T& v) : name(n), value(v) {} +}; + +template struct named_arg_info { + const Char* name; + int id; +}; + +template +struct arg_data { + // args_[0].named_args points to named_args_ to avoid bloating format_args. + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)]; + named_arg_info named_args_[NUM_NAMED_ARGS]; + + template + arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {} + arg_data(const arg_data& other) = delete; + auto args() const -> const T* { return args_ + 1; } + auto named_args() -> named_arg_info* { return named_args_; } +}; + +template +struct arg_data { + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + T args_[NUM_ARGS != 0 ? NUM_ARGS : +1]; + + template + FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {} + FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; } + FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t { + return nullptr; + } +}; + +template +inline void init_named_args(named_arg_info*, int, int) {} + +template struct is_named_arg : std::false_type {}; +template struct is_statically_named_arg : std::false_type {}; + +template +struct is_named_arg> : std::true_type {}; + +template ::value)> +void init_named_args(named_arg_info* named_args, int arg_count, + int named_arg_count, const T&, const Tail&... args) { + init_named_args(named_args, arg_count + 1, named_arg_count, args...); +} + +template ::value)> +void init_named_args(named_arg_info* named_args, int arg_count, + int named_arg_count, const T& arg, const Tail&... args) { + named_args[named_arg_count++] = {arg.name, arg_count}; + init_named_args(named_args, arg_count + 1, named_arg_count, args...); +} + +template +FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, + const Args&...) {} + +template constexpr auto count() -> size_t { return B ? 1 : 0; } +template constexpr auto count() -> size_t { + return (B1 ? 1 : 0) + count(); +} + +template constexpr auto count_named_args() -> size_t { + return count::value...>(); +} + +template +constexpr auto count_statically_named_args() -> size_t { + return count::value...>(); +} + +struct unformattable {}; +struct unformattable_char : unformattable {}; +struct unformattable_pointer : unformattable {}; + +template struct string_value { + const Char* data; + size_t size; +}; + +template struct named_arg_value { + const named_arg_info* data; + size_t size; +}; + +template struct custom_value { + using parse_context = typename Context::parse_context_type; + void* value; + void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); +}; + +// A formatting argument value. +template class value { + public: + using char_type = typename Context::char_type; + + union { + monostate no_value; + int int_value; + unsigned uint_value; + long long long_long_value; + unsigned long long ulong_long_value; + int128_opt int128_value; + uint128_opt uint128_value; + bool bool_value; + char_type char_value; + float float_value; + double double_value; + long double long_double_value; + const void* pointer; + string_value string; + custom_value custom; + named_arg_value named_args; + }; + + constexpr FMT_INLINE value() : no_value() {} + constexpr FMT_INLINE value(int val) : int_value(val) {} + constexpr FMT_INLINE value(unsigned val) : uint_value(val) {} + constexpr FMT_INLINE value(long long val) : long_long_value(val) {} + constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} + FMT_INLINE value(int128_opt val) : int128_value(val) {} + FMT_INLINE value(uint128_opt val) : uint128_value(val) {} + constexpr FMT_INLINE value(float val) : float_value(val) {} + constexpr FMT_INLINE value(double val) : double_value(val) {} + FMT_INLINE value(long double val) : long_double_value(val) {} + constexpr FMT_INLINE value(bool val) : bool_value(val) {} + constexpr FMT_INLINE value(char_type val) : char_value(val) {} + FMT_CONSTEXPR FMT_INLINE value(const char_type* val) { + string.data = val; + if (is_constant_evaluated()) string.size = {}; + } + FMT_CONSTEXPR FMT_INLINE value(basic_string_view val) { + string.data = val.data(); + string.size = val.size(); + } + FMT_INLINE value(const void* val) : pointer(val) {} + FMT_INLINE value(const named_arg_info* args, size_t size) + : named_args{args, size} {} + + template FMT_CONSTEXPR20 FMT_INLINE value(T& val) { + using value_type = remove_const_t; + // T may overload operator& e.g. std::vector::reference in libc++. +#ifdef __cpp_if_constexpr + if constexpr (std::is_same::value) + custom.value = const_cast(&val); +#endif + if (!is_constant_evaluated()) + custom.value = const_cast(&reinterpret_cast(val)); + // Get the formatter type through the context to allow different contexts + // have different extension points, e.g. `formatter` for `format` and + // `printf_formatter` for `printf`. + custom.format = format_custom_arg< + value_type, typename Context::template formatter_type>; + } + value(unformattable); + value(unformattable_char); + value(unformattable_pointer); + + private: + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg(void* arg, + typename Context::parse_context_type& parse_ctx, + Context& ctx) { + auto f = Formatter(); + parse_ctx.advance_to(f.parse(parse_ctx)); + using qualified_type = + conditional_t(), const T, T>; + // Calling format through a mutable reference is deprecated. + ctx.advance_to(f.format(*static_cast(arg), ctx)); + } +}; + +// To minimize the number of types we need to deal with, long is translated +// either to int or to long long depending on its size. +enum { long_short = sizeof(long) == sizeof(int) }; +using long_type = conditional_t; +using ulong_type = conditional_t; + +template struct format_as_result { + template ::value || std::is_class::value)> + static auto map(U*) -> remove_cvref_t()))>; + static auto map(...) -> void; + + using type = decltype(map(static_cast(nullptr))); +}; +template using format_as_t = typename format_as_result::type; + +template +struct has_format_as + : bool_constant, void>::value> {}; + +// Maps formatting arguments to core types. +// arg_mapper reports errors by returning unformattable instead of using +// static_assert because it's used in the is_formattable trait. +template struct arg_mapper { + using char_type = typename Context::char_type; + + FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val) + -> unsigned long long { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; } + + template ::value || + std::is_same::value)> + FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type { + return val; + } + template ::value || +#ifdef __cpp_char8_t + std::is_same::value || +#endif + std::is_same::value || + std::is_same::value) && + !std::is_same::value, + int> = 0> + FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char { + return {}; + } + + FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double { + return val; + } + + FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* { + return val; + } + template ::value && !std::is_pointer::value && + std::is_same>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& val) + -> basic_string_view { + return to_string_view(val); + } + template ::value && !std::is_pointer::value && + !std::is_same>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char { + return {}; + } + + FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* { + return val; + } + + // Use SFINAE instead of a const T* parameter to avoid a conflict with the + // array overload. + template < + typename T, + FMT_ENABLE_IF( + std::is_pointer::value || std::is_member_pointer::value || + std::is_function::type>::value || + (std::is_array::value && + !std::is_convertible::value))> + FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer { + return {}; + } + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] { + return values; + } + + // Only map owning types because mapping views can be unsafe. + template , + FMT_ENABLE_IF(std::is_arithmetic::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& val) + -> decltype(FMT_DECLTYPE_THIS map(U())) { + return map(format_as(val)); + } + + template > + struct formattable : bool_constant() || + (has_formatter::value && + !std::is_const::value)> {}; + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& { + return val; + } + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable { + return {}; + } + + template , + FMT_ENABLE_IF((std::is_class::value || std::is_enum::value || + std::is_union::value) && + !is_string::value && !is_char::value && + !is_named_arg::value && + !std::is_arithmetic>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(T& val) + -> decltype(FMT_DECLTYPE_THIS do_map(val)) { + return do_map(val); + } + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg) + -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) { + return map(named_arg.value); + } + + auto map(...) -> unformattable { return {}; } +}; + +// A type constant after applying arg_mapper. +template +using mapped_type_constant = + type_constant().map(std::declval())), + typename Context::char_type>; + +enum { packed_arg_bits = 4 }; +// Maximum number of arguments with packed types. +enum { max_packed_args = 62 / packed_arg_bits }; +enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; +enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; + +template +struct is_output_iterator : std::false_type {}; + +template <> struct is_output_iterator : std::true_type {}; + +template +struct is_output_iterator< + It, T, void_t()++ = std::declval())>> + : std::true_type {}; + +template struct is_back_insert_iterator : std::false_type {}; +template +struct is_back_insert_iterator> + : std::true_type {}; + +// A type-erased reference to an std::locale to avoid a heavy include. +class locale_ref { + private: + const void* locale_; // A type-erased pointer to std::locale. + + public: + constexpr FMT_INLINE locale_ref() : locale_(nullptr) {} + template explicit locale_ref(const Locale& loc); + + explicit operator bool() const noexcept { return locale_ != nullptr; } + + template auto get() const -> Locale; +}; + +template constexpr auto encode_types() -> unsigned long long { + return 0; +} + +template +constexpr auto encode_types() -> unsigned long long { + return static_cast(mapped_type_constant::value) | + (encode_types() << packed_arg_bits); +} + +#if defined(__cpp_if_constexpr) +// This type is intentionally undefined, only used for errors +template struct type_is_unformattable_for; +#endif + +template +FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value { + using arg_type = remove_cvref_t().map(val))>; + + constexpr bool formattable_char = + !std::is_same::value; + static_assert(formattable_char, "Mixing character types is disallowed."); + + // Formatting of arbitrary pointers is disallowed. If you want to format a + // pointer cast it to `void*` or `const void*`. In particular, this forbids + // formatting of `[const] volatile char*` printed as bool by iostreams. + constexpr bool formattable_pointer = + !std::is_same::value; + static_assert(formattable_pointer, + "Formatting of non-void pointers is disallowed."); + + constexpr bool formattable = !std::is_same::value; +#if defined(__cpp_if_constexpr) + if constexpr (!formattable) { + type_is_unformattable_for _; + } +#endif + static_assert( + formattable, + "Cannot format an argument. To make type T formattable provide a " + "formatter specialization: https://fmt.dev/latest/api.html#udt"); + return {arg_mapper().map(val)}; +} + +template +FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg { + auto arg = basic_format_arg(); + arg.type_ = mapped_type_constant::value; + arg.value_ = make_arg(val); + return arg; +} + +template +FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg { + return make_arg(val); +} +} // namespace detail +FMT_BEGIN_EXPORT + +// A formatting argument. Context is a template parameter for the compiled API +// where output can be unbuffered. +template class basic_format_arg { + private: + detail::value value_; + detail::type type_; + + template + friend FMT_CONSTEXPR auto detail::make_arg(T& value) + -> basic_format_arg; + + friend class basic_format_args; + friend class dynamic_format_arg_store; + + using char_type = typename Context::char_type; + + template + friend struct detail::arg_data; + + basic_format_arg(const detail::named_arg_info* args, size_t size) + : value_(args, size) {} + + public: + class handle { + public: + explicit handle(detail::custom_value custom) : custom_(custom) {} + + void format(typename Context::parse_context_type& parse_ctx, + Context& ctx) const { + custom_.format(custom_.value, parse_ctx, ctx); + } + + private: + detail::custom_value custom_; + }; + + constexpr basic_format_arg() : type_(detail::type::none_type) {} + + constexpr explicit operator bool() const noexcept { + return type_ != detail::type::none_type; + } + + auto type() const -> detail::type { return type_; } + + auto is_integral() const -> bool { return detail::is_integral_type(type_); } + auto is_arithmetic() const -> bool { + return detail::is_arithmetic_type(type_); + } + + /** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + ``vis(value)`` will be called with the value of type ``double``. + \endrst + */ + template + FMT_CONSTEXPR auto visit(Visitor&& vis) -> decltype(vis(0)) { + switch (type_) { + case detail::type::none_type: + break; + case detail::type::int_type: + return vis(value_.int_value); + case detail::type::uint_type: + return vis(value_.uint_value); + case detail::type::long_long_type: + return vis(value_.long_long_value); + case detail::type::ulong_long_type: + return vis(value_.ulong_long_value); + case detail::type::int128_type: + return vis(detail::convert_for_visit(value_.int128_value)); + case detail::type::uint128_type: + return vis(detail::convert_for_visit(value_.uint128_value)); + case detail::type::bool_type: + return vis(value_.bool_value); + case detail::type::char_type: + return vis(value_.char_value); + case detail::type::float_type: + return vis(value_.float_value); + case detail::type::double_type: + return vis(value_.double_value); + case detail::type::long_double_type: + return vis(value_.long_double_value); + case detail::type::cstring_type: + return vis(value_.string.data); + case detail::type::string_type: + using sv = basic_string_view; + return vis(sv(value_.string.data, value_.string.size)); + case detail::type::pointer_type: + return vis(value_.pointer); + case detail::type::custom_type: + return vis(typename basic_format_arg::handle(value_.custom)); + } + return vis(monostate()); + } + + FMT_INLINE auto format_custom(const char_type* parse_begin, + typename Context::parse_context_type& parse_ctx, + Context& ctx) -> bool { + if (type_ != detail::type::custom_type) return false; + parse_ctx.advance_to(parse_begin); + value_.custom.format(value_.custom.value, parse_ctx, ctx); + return true; + } +}; + +template +FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto visit_format_arg( + Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)) { + return arg.visit(std::forward(vis)); +} + +// Formatting context. +template class basic_format_context { + private: + OutputIt out_; + basic_format_args args_; + detail::locale_ref loc_; + + public: + using iterator = OutputIt; + using format_arg = basic_format_arg; + using format_args = basic_format_args; + using parse_context_type = basic_format_parse_context; + template using formatter_type = formatter; + + /** The character type for the output. */ + using char_type = Char; + + basic_format_context(basic_format_context&&) = default; + basic_format_context(const basic_format_context&) = delete; + void operator=(const basic_format_context&) = delete; + /** + Constructs a ``basic_format_context`` object. References to the arguments + are stored in the object so make sure they have appropriate lifetimes. + */ + constexpr basic_format_context(OutputIt out, format_args ctx_args, + detail::locale_ref loc = {}) + : out_(out), args_(ctx_args), loc_(loc) {} + + constexpr auto arg(int id) const -> format_arg { return args_.get(id); } + FMT_CONSTEXPR auto arg(basic_string_view name) -> format_arg { + return args_.get(name); + } + FMT_CONSTEXPR auto arg_id(basic_string_view name) -> int { + return args_.get_id(name); + } + auto args() const -> const format_args& { return args_; } + + // This function is intentionally not constexpr to give a compile-time error. + void on_error(const char* message) { throw_format_error(message); } + + // Returns an iterator to the beginning of the output range. + FMT_CONSTEXPR auto out() -> iterator { return out_; } + + // Advances the begin iterator to ``it``. + void advance_to(iterator it) { + if (!detail::is_back_insert_iterator()) out_ = it; + } + + FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } +}; + +template +using buffer_context = + basic_format_context, Char>; +using format_context = buffer_context; + +template +using is_formattable = bool_constant>() + .map(std::declval()))>::value>; + +/** + \rst + An array of references to arguments. It can be implicitly converted into + `~fmt::basic_format_args` for passing into type-erased formatting functions + such as `~fmt::vformat`. + \endrst + */ +template +class format_arg_store +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 + // Workaround a GCC template argument substitution bug. + : public basic_format_args +#endif +{ + private: + static const size_t num_args = sizeof...(Args); + static constexpr size_t num_named_args = detail::count_named_args(); + static const bool is_packed = num_args <= detail::max_packed_args; + + using value_type = conditional_t, + basic_format_arg>; + + detail::arg_data + data_; + + friend class basic_format_args; + + static constexpr unsigned long long desc = + (is_packed ? detail::encode_types() + : detail::is_unpacked_bit | num_args) | + (num_named_args != 0 + ? static_cast(detail::has_named_args_bit) + : 0); + + public: + template + FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args) + : +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 + basic_format_args(*this), +#endif + data_{detail::make_arg(args)...} { + if (detail::const_check(num_named_args != 0)) + detail::init_named_args(data_.named_args(), 0, 0, args...); + } +}; + +/** + \rst + Constructs a `~fmt::format_arg_store` object that contains references to + arguments and can be implicitly converted to `~fmt::format_args`. `Context` + can be omitted in which case it defaults to `~fmt::format_context`. + See `~fmt::arg` for lifetime considerations. + \endrst + */ +// Arguments are taken by lvalue references to avoid some lifetime issues. +template +constexpr auto make_format_args(T&... args) + -> format_arg_store...> { + return {args...}; +} + +/** + \rst + Returns a named argument to be used in a formatting function. + It should only be used in a call to a formatting function or + `dynamic_format_arg_store::push_back`. + + **Example**:: + + fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); + \endrst + */ +template +inline auto arg(const Char* name, const T& arg) -> detail::named_arg { + static_assert(!detail::is_named_arg(), "nested named arguments"); + return {name, arg}; +} +FMT_END_EXPORT + +/** + \rst + A view of a collection of formatting arguments. To avoid lifetime issues it + should only be used as a parameter type in type-erased functions such as + ``vformat``:: + + void vlog(string_view format_str, format_args args); // OK + format_args args = make_format_args(); // Error: dangling reference + \endrst + */ +template class basic_format_args { + public: + using size_type = int; + using format_arg = basic_format_arg; + + private: + // A descriptor that contains information about formatting arguments. + // If the number of arguments is less or equal to max_packed_args then + // argument types are passed in the descriptor. This reduces binary code size + // per formatting function call. + unsigned long long desc_; + union { + // If is_packed() returns true then argument values are stored in values_; + // otherwise they are stored in args_. This is done to improve cache + // locality and reduce compiled code size since storing larger objects + // may require more code (at least on x86-64) even if the same amount of + // data is actually copied to stack. It saves ~10% on the bloat test. + const detail::value* values_; + const format_arg* args_; + }; + + constexpr auto is_packed() const -> bool { + return (desc_ & detail::is_unpacked_bit) == 0; + } + auto has_named_args() const -> bool { + return (desc_ & detail::has_named_args_bit) != 0; + } + + FMT_CONSTEXPR auto type(int index) const -> detail::type { + int shift = index * detail::packed_arg_bits; + unsigned int mask = (1 << detail::packed_arg_bits) - 1; + return static_cast((desc_ >> shift) & mask); + } + + constexpr FMT_INLINE basic_format_args(unsigned long long desc, + const detail::value* values) + : desc_(desc), values_(values) {} + constexpr basic_format_args(unsigned long long desc, const format_arg* args) + : desc_(desc), args_(args) {} + + public: + constexpr basic_format_args() : desc_(0), args_(nullptr) {} + + /** + \rst + Constructs a `basic_format_args` object from `~fmt::format_arg_store`. + \endrst + */ + template + constexpr FMT_INLINE basic_format_args( + const format_arg_store& store) + : basic_format_args(format_arg_store::desc, + store.data_.args()) {} + + /** + \rst + Constructs a `basic_format_args` object from + `~fmt::dynamic_format_arg_store`. + \endrst + */ + constexpr FMT_INLINE basic_format_args( + const dynamic_format_arg_store& store) + : basic_format_args(store.get_types(), store.data()) {} + + /** + \rst + Constructs a `basic_format_args` object from a dynamic set of arguments. + \endrst + */ + constexpr basic_format_args(const format_arg* args, int count) + : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count), + args) {} + + /** Returns the argument with the specified id. */ + FMT_CONSTEXPR auto get(int id) const -> format_arg { + format_arg arg; + if (!is_packed()) { + if (id < max_size()) arg = args_[id]; + return arg; + } + if (id >= detail::max_packed_args) return arg; + arg.type_ = type(id); + if (arg.type_ == detail::type::none_type) return arg; + arg.value_ = values_[id]; + return arg; + } + + template + auto get(basic_string_view name) const -> format_arg { + int id = get_id(name); + return id >= 0 ? get(id) : format_arg(); + } + + template + auto get_id(basic_string_view name) const -> int { + if (!has_named_args()) return -1; + const auto& named_args = + (is_packed() ? values_[-1] : args_[-1].value_).named_args; + for (size_t i = 0; i < named_args.size; ++i) { + if (named_args.data[i].name == name) return named_args.data[i].id; + } + return -1; + } + + auto max_size() const -> int { + unsigned long long max_packed = detail::max_packed_args; + return static_cast(is_packed() ? max_packed + : desc_ & ~detail::is_unpacked_bit); + } +}; + +/** An alias to ``basic_format_args``. */ +// A separate type would result in shorter symbols but break ABI compatibility +// between clang and gcc on ARM (#1919). +FMT_EXPORT using format_args = basic_format_args; + +// We cannot use enum classes as bit fields because of a gcc bug, so we put them +// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414). +// Additionally, if an underlying type is specified, older gcc incorrectly warns +// that the type is too small. Both bugs are fixed in gcc 9.3. +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903 +# define FMT_ENUM_UNDERLYING_TYPE(type) +#else +# define FMT_ENUM_UNDERLYING_TYPE(type) : type +#endif +namespace align { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center, + numeric}; +} +using align_t = align::type; +namespace sign { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space}; +} +using sign_t = sign::type; + +namespace detail { + +// Workaround an array initialization issue in gcc 4.8. +template struct fill_t { + private: + enum { max_size = 4 }; + Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)}; + unsigned char size_ = 1; + + public: + FMT_CONSTEXPR void operator=(basic_string_view s) { + auto size = s.size(); + FMT_ASSERT(size <= max_size, "invalid fill"); + for (size_t i = 0; i < size; ++i) data_[i] = s[i]; + size_ = static_cast(size); + } + + constexpr auto size() const -> size_t { return size_; } + constexpr auto data() const -> const Char* { return data_; } + + FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; } + FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& { + return data_[index]; + } +}; +} // namespace detail + +enum class presentation_type : unsigned char { + none, + dec, // 'd' + oct, // 'o' + hex_lower, // 'x' + hex_upper, // 'X' + bin_lower, // 'b' + bin_upper, // 'B' + hexfloat_lower, // 'a' + hexfloat_upper, // 'A' + exp_lower, // 'e' + exp_upper, // 'E' + fixed_lower, // 'f' + fixed_upper, // 'F' + general_lower, // 'g' + general_upper, // 'G' + chr, // 'c' + string, // 's' + pointer, // 'p' + debug // '?' +}; + +// Format specifiers for built-in and string types. +template struct format_specs { + int width; + int precision; + presentation_type type; + align_t align : 4; + sign_t sign : 3; + bool alt : 1; // Alternate form ('#'). + bool localized : 1; + detail::fill_t fill; + + constexpr format_specs() + : width(0), + precision(-1), + type(presentation_type::none), + align(align::none), + sign(sign::none), + alt(false), + localized(false) {} +}; + +namespace detail { + +enum class arg_id_kind { none, index, name }; + +// An argument reference. +template struct arg_ref { + FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {} + + FMT_CONSTEXPR explicit arg_ref(int index) + : kind(arg_id_kind::index), val(index) {} + FMT_CONSTEXPR explicit arg_ref(basic_string_view name) + : kind(arg_id_kind::name), val(name) {} + + FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& { + kind = arg_id_kind::index; + val.index = idx; + return *this; + } + + arg_id_kind kind; + union value { + FMT_CONSTEXPR value(int idx = 0) : index(idx) {} + FMT_CONSTEXPR value(basic_string_view n) : name(n) {} + + int index; + basic_string_view name; + } val; +}; + +// Format specifiers with width and precision resolved at formatting rather +// than parsing time to allow reusing the same parsed specifiers with +// different sets of arguments (precompilation of format strings). +template +struct dynamic_format_specs : format_specs { + arg_ref width_ref; + arg_ref precision_ref; +}; + +// Converts a character to ASCII. Returns '\0' on conversion failure. +template ::value || + std::is_enum::value)> +constexpr auto to_ascii(Char c) -> char { + return c <= 0xff ? static_cast(c) : '\0'; +} + +// Returns the number of code units in a code point or 1 on error. +template +FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { + if (const_check(sizeof(Char) != 1)) return 1; + auto c = static_cast(*begin); + return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1; +} + +// Return the result via the out param to workaround gcc bug 77539. +template +FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { + for (out = first; out != last; ++out) { + if (*out == value) return true; + } + return false; +} + +template <> +inline auto find(const char* first, const char* last, char value, + const char*& out) -> bool { + out = static_cast( + std::memchr(first, value, to_unsigned(last - first))); + return out != nullptr; +} + +// Parses the range [begin, end) as an unsigned integer. This function assumes +// that the range is non-empty and the first character is a digit. +template +FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, + int error_value) noexcept -> int { + FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); + unsigned value = 0, prev = 0; + auto p = begin; + do { + prev = value; + value = value * 10 + unsigned(*p - '0'); + ++p; + } while (p != end && '0' <= *p && *p <= '9'); + auto num_digits = p - begin; + begin = p; + int digits10 = static_cast(sizeof(int) * CHAR_BIT * 3 / 10); + if (num_digits <= digits10) return static_cast(value); + // Check for overflow. + unsigned max = INT_MAX; + return num_digits == digits10 + 1 && + prev * 10ull + unsigned(p[-1] - '0') <= max + ? static_cast(value) + : error_value; +} + +FMT_CONSTEXPR inline auto parse_align(char c) -> align_t { + switch (c) { + case '<': + return align::left; + case '>': + return align::right; + case '^': + return align::center; + } + return align::none; +} + +template constexpr auto is_name_start(Char c) -> bool { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; +} + +template +FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + Char c = *begin; + if (c >= '0' && c <= '9') { + int index = 0; + if (c != '0') + index = parse_nonnegative_int(begin, end, INT_MAX); + else + ++begin; + if (begin == end || (*begin != '}' && *begin != ':')) + throw_format_error("invalid format string"); + else + handler.on_index(index); + return begin; + } + if (!is_name_start(c)) { + throw_format_error("invalid format string"); + return begin; + } + auto it = begin; + do { + ++it; + } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); + handler.on_name({begin, to_unsigned(it - begin)}); + return it; +} + +template +FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + FMT_ASSERT(begin != end, ""); + Char c = *begin; + if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler); + handler.on_auto(); + return begin; +} + +template struct dynamic_spec_id_handler { + basic_format_parse_context& ctx; + arg_ref& ref; + + FMT_CONSTEXPR void on_auto() { + int id = ctx.next_arg_id(); + ref = arg_ref(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_index(int id) { + ref = arg_ref(id); + ctx.check_arg_id(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_name(basic_string_view id) { + ref = arg_ref(id); + ctx.check_arg_id(id); + } +}; + +// Parses [integer | "{" [arg_id] "}"]. +template +FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, + int& value, arg_ref& ref, + basic_format_parse_context& ctx) + -> const Char* { + FMT_ASSERT(begin != end, ""); + if ('0' <= *begin && *begin <= '9') { + int val = parse_nonnegative_int(begin, end, -1); + if (val != -1) + value = val; + else + throw_format_error("number is too big"); + } else if (*begin == '{') { + ++begin; + auto handler = dynamic_spec_id_handler{ctx, ref}; + if (begin != end) begin = parse_arg_id(begin, end, handler); + if (begin != end && *begin == '}') return ++begin; + throw_format_error("invalid format string"); + } + return begin; +} + +template +FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, + int& value, arg_ref& ref, + basic_format_parse_context& ctx) + -> const Char* { + ++begin; + if (begin == end || *begin == '}') { + throw_format_error("invalid precision"); + return begin; + } + return parse_dynamic_spec(begin, end, value, ref, ctx); +} + +enum class state { start, align, sign, hash, zero, width, precision, locale }; + +// Parses standard format specifiers. +template +FMT_CONSTEXPR FMT_INLINE auto parse_format_specs( + const Char* begin, const Char* end, dynamic_format_specs& specs, + basic_format_parse_context& ctx, type arg_type) -> const Char* { + auto c = '\0'; + if (end - begin > 1) { + auto next = to_ascii(begin[1]); + c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; + } else { + if (begin == end) return begin; + c = to_ascii(*begin); + } + + struct { + state current_state = state::start; + FMT_CONSTEXPR void operator()(state s, bool valid = true) { + if (current_state >= s || !valid) + throw_format_error("invalid format specifier"); + current_state = s; + } + } enter_state; + + using pres = presentation_type; + constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; + struct { + const Char*& begin; + dynamic_format_specs& specs; + type arg_type; + + FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* { + if (!in(arg_type, set)) { + if (arg_type == type::none_type) return begin; + throw_format_error("invalid format specifier"); + } + specs.type = pres_type; + return begin + 1; + } + } parse_presentation_type{begin, specs, arg_type}; + + for (;;) { + switch (c) { + case '<': + case '>': + case '^': + enter_state(state::align); + specs.align = parse_align(c); + ++begin; + break; + case '+': + case '-': + case ' ': + if (arg_type == type::none_type) return begin; + enter_state(state::sign, in(arg_type, sint_set | float_set)); + switch (c) { + case '+': + specs.sign = sign::plus; + break; + case '-': + specs.sign = sign::minus; + break; + case ' ': + specs.sign = sign::space; + break; + } + ++begin; + break; + case '#': + if (arg_type == type::none_type) return begin; + enter_state(state::hash, is_arithmetic_type(arg_type)); + specs.alt = true; + ++begin; + break; + case '0': + enter_state(state::zero); + if (!is_arithmetic_type(arg_type)) { + if (arg_type == type::none_type) return begin; + throw_format_error("format specifier requires numeric argument"); + } + if (specs.align == align::none) { + // Ignore 0 if align is specified for compatibility with std::format. + specs.align = align::numeric; + specs.fill[0] = Char('0'); + } + ++begin; + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '{': + enter_state(state::width); + begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx); + break; + case '.': + if (arg_type == type::none_type) return begin; + enter_state(state::precision, + in(arg_type, float_set | string_set | cstring_set)); + begin = parse_precision(begin, end, specs.precision, specs.precision_ref, + ctx); + break; + case 'L': + if (arg_type == type::none_type) return begin; + enter_state(state::locale, is_arithmetic_type(arg_type)); + specs.localized = true; + ++begin; + break; + case 'd': + return parse_presentation_type(pres::dec, integral_set); + case 'o': + return parse_presentation_type(pres::oct, integral_set); + case 'x': + return parse_presentation_type(pres::hex_lower, integral_set); + case 'X': + return parse_presentation_type(pres::hex_upper, integral_set); + case 'b': + return parse_presentation_type(pres::bin_lower, integral_set); + case 'B': + return parse_presentation_type(pres::bin_upper, integral_set); + case 'a': + return parse_presentation_type(pres::hexfloat_lower, float_set); + case 'A': + return parse_presentation_type(pres::hexfloat_upper, float_set); + case 'e': + return parse_presentation_type(pres::exp_lower, float_set); + case 'E': + return parse_presentation_type(pres::exp_upper, float_set); + case 'f': + return parse_presentation_type(pres::fixed_lower, float_set); + case 'F': + return parse_presentation_type(pres::fixed_upper, float_set); + case 'g': + return parse_presentation_type(pres::general_lower, float_set); + case 'G': + return parse_presentation_type(pres::general_upper, float_set); + case 'c': + if (arg_type == type::bool_type) + throw_format_error("invalid format specifier"); + return parse_presentation_type(pres::chr, integral_set); + case 's': + return parse_presentation_type(pres::string, + bool_set | string_set | cstring_set); + case 'p': + return parse_presentation_type(pres::pointer, pointer_set | cstring_set); + case '?': + return parse_presentation_type(pres::debug, + char_set | string_set | cstring_set); + case '}': + return begin; + default: { + if (*begin == '}') return begin; + // Parse fill and alignment. + auto fill_end = begin + code_point_length(begin); + if (end - fill_end <= 0) { + throw_format_error("invalid format specifier"); + return begin; + } + if (*begin == '{') { + throw_format_error("invalid fill character '{'"); + return begin; + } + auto align = parse_align(to_ascii(*fill_end)); + enter_state(state::align, align != align::none); + specs.fill = {begin, to_unsigned(fill_end - begin)}; + specs.align = align; + begin = fill_end + 1; + } + } + if (begin == end) return begin; + c = to_ascii(*begin); + } +} + +template +FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + struct id_adapter { + Handler& handler; + int arg_id; + + FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); } + FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } + FMT_CONSTEXPR void on_name(basic_string_view id) { + arg_id = handler.on_arg_id(id); + } + }; + + ++begin; + if (begin == end) return handler.on_error("invalid format string"), end; + if (*begin == '}') { + handler.on_replacement_field(handler.on_arg_id(), begin); + } else if (*begin == '{') { + handler.on_text(begin, begin + 1); + } else { + auto adapter = id_adapter{handler, 0}; + begin = parse_arg_id(begin, end, adapter); + Char c = begin != end ? *begin : Char(); + if (c == '}') { + handler.on_replacement_field(adapter.arg_id, begin); + } else if (c == ':') { + begin = handler.on_format_specs(adapter.arg_id, begin + 1, end); + if (begin == end || *begin != '}') + return handler.on_error("unknown format specifier"), end; + } else { + return handler.on_error("missing '}' in format string"), end; + } + } + return begin + 1; +} + +template +FMT_CONSTEXPR FMT_INLINE void parse_format_string( + basic_string_view format_str, Handler&& handler) { + auto begin = format_str.data(); + auto end = begin + format_str.size(); + if (end - begin < 32) { + // Use a simple loop instead of memchr for small strings. + const Char* p = begin; + while (p != end) { + auto c = *p++; + if (c == '{') { + handler.on_text(begin, p - 1); + begin = p = parse_replacement_field(p - 1, end, handler); + } else if (c == '}') { + if (p == end || *p != '}') + return handler.on_error("unmatched '}' in format string"); + handler.on_text(begin, p); + begin = ++p; + } + } + handler.on_text(begin, end); + return; + } + struct writer { + FMT_CONSTEXPR void operator()(const Char* from, const Char* to) { + if (from == to) return; + for (;;) { + const Char* p = nullptr; + if (!find(from, to, Char('}'), p)) + return handler_.on_text(from, to); + ++p; + if (p == to || *p != '}') + return handler_.on_error("unmatched '}' in format string"); + handler_.on_text(from, p); + from = p + 1; + } + } + Handler& handler_; + } write = {handler}; + while (begin != end) { + // Doing two passes with memchr (one for '{' and another for '}') is up to + // 2.5x faster than the naive one-pass implementation on big format strings. + const Char* p = begin; + if (*begin != '{' && !find(begin + 1, end, Char('{'), p)) + return write(begin, end); + write(begin, p); + begin = parse_replacement_field(p, end, handler); + } +} + +template ::value> struct strip_named_arg { + using type = T; +}; +template struct strip_named_arg { + using type = remove_cvref_t; +}; + +template +FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx) + -> decltype(ctx.begin()) { + using char_type = typename ParseContext::char_type; + using context = buffer_context; + using mapped_type = conditional_t< + mapped_type_constant::value != type::custom_type, + decltype(arg_mapper().map(std::declval())), + typename strip_named_arg::type>; +// LAMMPS customization. Fails to compile with (some) Intel compilers +#if defined(__cpp_if_constexpr) && 1 + if constexpr (std::is_default_constructible< + formatter>::value) { + return formatter().parse(ctx); + } else { + type_is_unformattable_for _; + return ctx.begin(); + } +#else + return formatter().parse(ctx); +#endif +} + +// Checks char specs and returns true iff the presentation type is char-like. +template +FMT_CONSTEXPR auto check_char_specs(const format_specs& specs) -> bool { + if (specs.type != presentation_type::none && + specs.type != presentation_type::chr && + specs.type != presentation_type::debug) { + return false; + } + if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) + throw_format_error("invalid format specifier for char"); + return true; +} + +#if FMT_USE_NONTYPE_TEMPLATE_ARGS +template +constexpr auto get_arg_index_by_name(basic_string_view name) -> int { + if constexpr (is_statically_named_arg()) { + if (name == T::name) return N; + } + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name(name); + (void)name; // Workaround an MSVC bug about "unused" parameter. + return -1; +} +#endif + +template +FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name<0, Args...>(name); +#endif + (void)name; + return -1; +} + +template class format_string_checker { + private: + using parse_context_type = compile_parse_context; + static constexpr int num_args = sizeof...(Args); + + // Format specifier parsing function. + // In the future basic_format_parse_context will replace compile_parse_context + // here and will use is_constant_evaluated and downcasting to access the data + // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1. + using parse_func = const Char* (*)(parse_context_type&); + + type types_[num_args > 0 ? static_cast(num_args) : 1]; + parse_context_type context_; + parse_func parse_funcs_[num_args > 0 ? static_cast(num_args) : 1]; + + public: + explicit FMT_CONSTEXPR format_string_checker(basic_string_view fmt) + : types_{mapped_type_constant>::value...}, + context_(fmt, num_args, types_), + parse_funcs_{&parse_format_specs...} {} + + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + + FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } + FMT_CONSTEXPR auto on_arg_id(int id) -> int { + return context_.check_arg_id(id), id; + } + FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS + auto index = get_arg_index_by_name(id); + if (index < 0) on_error("named argument is not found"); + return index; +#else + (void)id; + on_error("compile-time checks for named arguments require C++20 support"); + return 0; +#endif + } + + FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) { + on_format_specs(id, begin, begin); // Call parse() on empty specs. + } + + FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*) + -> const Char* { + context_.advance_to(begin); + // id >= 0 check is a workaround for gcc 10 bug (#2065). + return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin; + } + + FMT_CONSTEXPR void on_error(const char* message) { + throw_format_error(message); + } +}; + +// Reports a compile-time error if S is not a valid format string. +template ::value)> +FMT_INLINE void check_format_string(const S&) { +#ifdef FMT_ENFORCE_COMPILE_STRING + static_assert(is_compile_string::value, + "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " + "FMT_STRING."); +#endif +} +template ::value)> +void check_format_string(S format_str) { + using char_t = typename S::char_type; + FMT_CONSTEXPR auto s = basic_string_view(format_str); + using checker = format_string_checker...>; + FMT_CONSTEXPR bool error = (parse_format_string(s, checker(s)), true); + ignore_unused(error); +} + +template struct vformat_args { + using type = basic_format_args< + basic_format_context>, Char>>; +}; +template <> struct vformat_args { + using type = format_args; +}; + +// Use vformat_args and avoid type_identity to keep symbols short. +template +void vformat_to(buffer& buf, basic_string_view fmt, + typename vformat_args::type args, locale_ref loc = {}); + +FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); +#ifndef _WIN32 +inline void vprint_mojibake(std::FILE*, string_view, format_args) {} +#endif +} // namespace detail + +FMT_BEGIN_EXPORT + +// A formatter specialization for natively supported types. +template +struct formatter::value != + detail::type::custom_type>> { + private: + detail::dynamic_format_specs specs_; + + public: + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { + auto type = detail::type_constant::value; + auto end = + detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type); + if (type == detail::type::char_type) detail::check_char_specs(specs_); + return end; + } + + template ::value, + FMT_ENABLE_IF(U == detail::type::string_type || + U == detail::type::cstring_type || + U == detail::type::char_type)> + FMT_CONSTEXPR void set_debug_format(bool set = true) { + specs_.type = set ? presentation_type::debug : presentation_type::none; + } + + template + FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const + -> decltype(ctx.out()); +}; + +template struct runtime_format_string { + basic_string_view str; +}; + +/** A compile-time format string. */ +template class basic_format_string { + private: + basic_string_view str_; + + public: + template >::value)> + FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) { + static_assert( + detail::count< + (std::is_base_of>::value && + std::is_reference::value)...>() == 0, + "passing views as lvalues is disallowed"); +#ifdef FMT_HAS_CONSTEVAL + if constexpr (detail::count_named_args() == + detail::count_statically_named_args()) { + using checker = + detail::format_string_checker...>; + detail::parse_format_string(str_, checker(s)); + } +#else + detail::check_format_string(s); +#endif + } + basic_format_string(runtime_format_string fmt) : str_(fmt.str) {} + + FMT_INLINE operator basic_string_view() const { return str_; } + FMT_INLINE auto get() const -> basic_string_view { return str_; } +}; + +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 +// Workaround broken conversion on older gcc. +template using format_string = string_view; +inline auto runtime(string_view s) -> string_view { return s; } +#else +template +using format_string = basic_format_string...>; +/** + \rst + Creates a runtime format string. + + **Example**:: + + // Check format string at runtime instead of compile-time. + fmt::print(fmt::runtime("{:d}"), "I am not a number"); + \endrst + */ +inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } +#endif + +FMT_API auto vformat(string_view fmt, format_args args) -> basic_string; + +/** + \rst + Formats ``args`` according to specifications in ``fmt`` and returns the result + as a string. + + **Example**:: + + #include + std::string message = fmt::format("The answer is {}.", 42); + \endrst +*/ +template +FMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args) + -> basic_string { + return vformat(fmt, fmt::make_format_args(args...)); +} + +/** Formats a string and writes the output to ``out``. */ +template ::value)> +auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt { + auto&& buf = detail::get_buffer(out); + detail::vformat_to(buf, fmt, args, {}); + return detail::get_iterator(buf, out); +} + +/** + \rst + Formats ``args`` according to specifications in ``fmt``, writes the result to + the output iterator ``out`` and returns the iterator past the end of the output + range. `format_to` does not append a terminating null character. + + **Example**:: + + auto out = std::vector(); + fmt::format_to(fmt::back_inserter(out), "{}", 42); + \endrst + */ +template ::value)> +FMT_INLINE auto format_to(OutputIt out, format_string fmt, T&&... args) + -> OutputIt { + return vformat_to(out, fmt, fmt::make_format_args(args...)); +} + +template struct format_to_n_result { + /** Iterator past the end of the output range. */ + OutputIt out; + /** Total (not truncated) output size. */ + size_t size; +}; + +template ::value)> +auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) + -> format_to_n_result { + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer(out, n); + detail::vformat_to(buf, fmt, args, {}); + return {buf.out(), buf.count()}; +} + +/** + \rst + Formats ``args`` according to specifications in ``fmt``, writes up to ``n`` + characters of the result to the output iterator ``out`` and returns the total + (not truncated) output size and the iterator past the end of the output range. + `format_to_n` does not append a terminating null character. + \endrst + */ +template ::value)> +FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt, + T&&... args) -> format_to_n_result { + return vformat_to_n(out, n, fmt, fmt::make_format_args(args...)); +} + +/** Returns the number of chars in the output of ``format(fmt, args...)``. */ +template +FMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt, + T&&... args) -> size_t { + auto buf = detail::counting_buffer<>(); + detail::vformat_to(buf, fmt, fmt::make_format_args(args...), {}); + return buf.count(); +} + +FMT_API void vprint(string_view fmt, format_args args); +FMT_API void vprint(std::FILE* f, string_view fmt, format_args args); + +/** + \rst + Formats ``args`` according to specifications in ``fmt`` and writes the output + to ``stdout``. + + **Example**:: + + fmt::print("Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +template +FMT_INLINE void print(format_string fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + return detail::is_utf8() ? vprint(fmt, vargs) + : detail::vprint_mojibake(stdout, fmt, vargs); +} + +/** + \rst + Formats ``args`` according to specifications in ``fmt`` and writes the + output to the file ``f``. + + **Example**:: + + fmt::print(stderr, "Don't {}!", "panic"); + \endrst + */ +template +FMT_INLINE void print(std::FILE* f, format_string fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + return detail::is_utf8() ? vprint(f, fmt, vargs) + : detail::vprint_mojibake(f, fmt, vargs); +} + +/** + Formats ``args`` according to specifications in ``fmt`` and writes the + output to the file ``f`` followed by a newline. + */ +template +FMT_INLINE void println(std::FILE* f, format_string fmt, T&&... args) { + return fmt::print(f, "{}\n", fmt::format(fmt, std::forward(args)...)); +} + +/** + Formats ``args`` according to specifications in ``fmt`` and writes the output + to ``stdout`` followed by a newline. + */ +template +FMT_INLINE void println(format_string fmt, T&&... args) { + return fmt::println(stdout, fmt, std::forward(args)...); +} + +FMT_END_EXPORT +FMT_GCC_PRAGMA("GCC pop_options") +FMT_END_NAMESPACE + +#ifdef FMT_HEADER_ONLY +# include "format.h" +#endif +#endif // FMT_CORE_H_ diff --git a/src/fmt/format-inl.h b/src/fmt/format-inl.h index a5b79dbe49..8da1c17f36 100644 --- a/src/fmt/format-inl.h +++ b/src/fmt/format-inl.h @@ -8,36 +8,32 @@ #ifndef FMT_FORMAT_INL_H_ #define FMT_FORMAT_INL_H_ -#ifndef FMT_MODULE -# include -# include // errno -# include -# include -# include +#include +#include // errno +#include +#include +#include + +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR +# include #endif -#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) +#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR) # include // _isatty #endif #include "format.h" -#if FMT_USE_LOCALE -# include -#endif - -#ifndef FMT_FUNC -# define FMT_FUNC -#endif - FMT_BEGIN_NAMESPACE namespace detail { FMT_FUNC void assert_fail(const char* file, int line, const char* message) { // Use unchecked std::fprintf to avoid triggering another assertion when - // writing to stderr fails. - fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); - abort(); + // writing to stderr fails + std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); + // Chosen instead of std::abort to satisfy Clang in CUDA mode during device + // code pass. + std::terminate(); } FMT_FUNC void format_error_code(detail::buffer& out, int error_code, @@ -56,105 +52,93 @@ FMT_FUNC void format_error_code(detail::buffer& out, int error_code, ++error_code_size; } error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); - auto it = appender(out); + auto it = buffer_appender(out); if (message.size() <= inline_buffer_size - error_code_size) fmt::format_to(it, FMT_STRING("{}{}"), message, SEP); fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); FMT_ASSERT(out.size() <= inline_buffer_size, ""); } -FMT_FUNC void do_report_error(format_func func, int error_code, - const char* message) noexcept { +FMT_FUNC void report_error(format_func func, int error_code, + const char* message) noexcept { memory_buffer full_message; func(full_message, error_code, message); - // Don't use fwrite_all because the latter may throw. + // Don't use fwrite_fully because the latter may throw. if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0) std::fputc('\n', stderr); } // A wrapper around fwrite that throws on error. -inline void fwrite_all(const void* ptr, size_t count, FILE* stream) { +inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) { size_t written = std::fwrite(ptr, 1, count, stream); if (written < count) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } -#if FMT_USE_LOCALE -using std::locale; -using std::numpunct; -using std::use_facet; - +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR template locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { - static_assert(std::is_same::value, ""); + static_assert(std::is_same::value, ""); } -#else -struct locale {}; -template struct numpunct { - auto grouping() const -> std::string { return "\03"; } - auto thousands_sep() const -> Char { return ','; } - auto decimal_point() const -> Char { return '.'; } -}; -template Facet use_facet(locale) { return {}; } -#endif // FMT_USE_LOCALE template auto locale_ref::get() const -> Locale { - static_assert(std::is_same::value, ""); -#if FMT_USE_LOCALE - if (locale_) return *static_cast(locale_); -#endif - return locale(); + static_assert(std::is_same::value, ""); + return locale_ ? *static_cast(locale_) : std::locale(); } template FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result { - auto&& facet = use_facet>(loc.get()); + auto& facet = std::use_facet>(loc.get()); auto grouping = facet.grouping(); auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); return {std::move(grouping), thousands_sep}; } template FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char { - return use_facet>(loc.get()).decimal_point(); + return std::use_facet>(loc.get()) + .decimal_point(); } +#else +template +FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result { + return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR}; +} +template FMT_FUNC Char decimal_point_impl(locale_ref) { + return '.'; +} +#endif -#if FMT_USE_LOCALE FMT_FUNC auto write_loc(appender out, loc_value value, - const format_specs& specs, locale_ref loc) -> bool { + const format_specs<>& specs, locale_ref loc) -> bool { +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR auto locale = loc.get(); // We cannot use the num_put facet because it may produce output in // a wrong encoding. using facet = format_facet; if (std::has_facet(locale)) - return use_facet(locale).put(out, value, specs); + return std::use_facet(locale).put(out, value, specs); return facet(locale).put(out, value, specs); -} #endif + return false; +} } // namespace detail -FMT_FUNC void report_error(const char* message) { -#if FMT_USE_EXCEPTIONS - // Use FMT_THROW instead of throw to avoid bogus unreachable code warnings - // from MSVC. +FMT_FUNC void throw_format_error(const char* message) { FMT_THROW(format_error(message)); -#else - fputs(message, stderr); - abort(); -#endif } template typename Locale::id format_facet::id; +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR template format_facet::format_facet(Locale& loc) { - auto& np = detail::use_facet>(loc); - grouping_ = np.grouping(); - if (!grouping_.empty()) separator_ = std::string(1, np.thousands_sep()); + auto& numpunct = std::use_facet>(loc); + grouping_ = numpunct.grouping(); + if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep()); } -#if FMT_USE_LOCALE template <> FMT_API FMT_FUNC auto format_facet::do_put( - appender out, loc_value val, const format_specs& specs) const -> bool { + appender out, loc_value val, const format_specs<>& specs) const -> bool { return val.visit( detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); } @@ -1427,7 +1411,7 @@ FMT_FUNC void format_system_error(detail::buffer& out, int error_code, const char* message) noexcept { FMT_TRY { auto ec = std::error_code(error_code, std::generic_category()); - detail::write(appender(out), std::system_error(ec, message).what()); + write(std::back_inserter(out), std::system_error(ec, message).what()); return; } FMT_CATCH(...) {} @@ -1436,7 +1420,7 @@ FMT_FUNC void format_system_error(detail::buffer& out, int error_code, FMT_FUNC void report_system_error(int error_code, const char* message) noexcept { - do_report_error(format_system_error, error_code, message); + report_error(format_system_error, error_code, message); } FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string { @@ -1448,251 +1432,7 @@ FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string { } namespace detail { - -FMT_FUNC void vformat_to(buffer& buf, string_view fmt, format_args args, - locale_ref loc) { - auto out = appender(buf); - if (fmt.size() == 2 && equal2(fmt.data(), "{}")) - return args.get(0).visit(default_arg_formatter{out}); - parse_format_string( - fmt, format_handler{parse_context(fmt), {out, args, loc}}); -} - -template struct span { - T* data; - size_t size; -}; - -template auto flockfile(F* f) -> decltype(_lock_file(f)) { - _lock_file(f); -} -template auto funlockfile(F* f) -> decltype(_unlock_file(f)) { - _unlock_file(f); -} - -#ifndef getc_unlocked -template auto getc_unlocked(F* f) -> decltype(_fgetc_nolock(f)) { - return _fgetc_nolock(f); -} -#endif - -template -struct has_flockfile : std::false_type {}; - -template -struct has_flockfile()))>> - : std::true_type {}; - -// A FILE wrapper. F is FILE defined as a template parameter to make system API -// detection work. -template class file_base { - public: - F* file_; - - public: - file_base(F* file) : file_(file) {} - operator F*() const { return file_; } - - // Reads a code unit from the stream. - auto get() -> int { - int result = getc_unlocked(file_); - if (result == EOF && ferror(file_) != 0) - FMT_THROW(system_error(errno, FMT_STRING("getc failed"))); - return result; - } - - // Puts the code unit back into the stream buffer. - void unget(char c) { - if (ungetc(c, file_) == EOF) - FMT_THROW(system_error(errno, FMT_STRING("ungetc failed"))); - } - - void flush() { fflush(this->file_); } -}; - -// A FILE wrapper for glibc. -template class glibc_file : public file_base { - private: - enum { - line_buffered = 0x200, // _IO_LINE_BUF - unbuffered = 2 // _IO_UNBUFFERED - }; - - public: - using file_base::file_base; - - auto is_buffered() const -> bool { - return (this->file_->_flags & unbuffered) == 0; - } - - void init_buffer() { - if (this->file_->_IO_write_ptr) return; - // Force buffer initialization by placing and removing a char in a buffer. - assume(this->file_->_IO_write_ptr >= this->file_->_IO_write_end); - putc_unlocked(0, this->file_); - --this->file_->_IO_write_ptr; - } - - // Returns the file's read buffer. - auto get_read_buffer() const -> span { - auto ptr = this->file_->_IO_read_ptr; - return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)}; - } - - // Returns the file's write buffer. - auto get_write_buffer() const -> span { - auto ptr = this->file_->_IO_write_ptr; - return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)}; - } - - void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; } - - bool needs_flush() const { - if ((this->file_->_flags & line_buffered) == 0) return false; - char* end = this->file_->_IO_write_end; - return memchr(end, '\n', to_unsigned(this->file_->_IO_write_ptr - end)); - } - - void flush() { fflush_unlocked(this->file_); } -}; - -// A FILE wrapper for Apple's libc. -template class apple_file : public file_base { - private: - enum { - line_buffered = 1, // __SNBF - unbuffered = 2 // __SLBF - }; - - public: - using file_base::file_base; - - auto is_buffered() const -> bool { - return (this->file_->_flags & unbuffered) == 0; - } - - void init_buffer() { - if (this->file_->_p) return; - // Force buffer initialization by placing and removing a char in a buffer. - putc_unlocked(0, this->file_); - --this->file_->_p; - ++this->file_->_w; - } - - auto get_read_buffer() const -> span { - return {reinterpret_cast(this->file_->_p), - to_unsigned(this->file_->_r)}; - } - - auto get_write_buffer() const -> span { - return {reinterpret_cast(this->file_->_p), - to_unsigned(this->file_->_bf._base + this->file_->_bf._size - - this->file_->_p)}; - } - - void advance_write_buffer(size_t size) { - this->file_->_p += size; - this->file_->_w -= size; - } - - bool needs_flush() const { - if ((this->file_->_flags & line_buffered) == 0) return false; - return memchr(this->file_->_p + this->file_->_w, '\n', - to_unsigned(-this->file_->_w)); - } -}; - -// A fallback FILE wrapper. -template class fallback_file : public file_base { - private: - char next_; // The next unconsumed character in the buffer. - bool has_next_ = false; - - public: - using file_base::file_base; - - auto is_buffered() const -> bool { return false; } - auto needs_flush() const -> bool { return false; } - void init_buffer() {} - - auto get_read_buffer() const -> span { - return {&next_, has_next_ ? 1u : 0u}; - } - - auto get_write_buffer() const -> span { return {nullptr, 0}; } - - void advance_write_buffer(size_t) {} - - auto get() -> int { - has_next_ = false; - return file_base::get(); - } - - void unget(char c) { - file_base::unget(c); - next_ = c; - has_next_ = true; - } -}; - -#ifndef FMT_USE_FALLBACK_FILE -# define FMT_USE_FALLBACK_FILE 0 -#endif - -template -auto get_file(F* f, int) -> apple_file { - return f; -} -template -inline auto get_file(F* f, int) -> glibc_file { - return f; -} - -inline auto get_file(FILE* f, ...) -> fallback_file { return f; } - -using file_ref = decltype(get_file(static_cast(nullptr), 0)); - -template -class file_print_buffer : public buffer { - public: - explicit file_print_buffer(F*) : buffer(nullptr, size_t()) {} -}; - -template -class file_print_buffer::value>> - : public buffer { - private: - file_ref file_; - - static void grow(buffer& base, size_t) { - auto& self = static_cast(base); - self.file_.advance_write_buffer(self.size()); - if (self.file_.get_write_buffer().size == 0) self.file_.flush(); - auto buf = self.file_.get_write_buffer(); - FMT_ASSERT(buf.size > 0, ""); - self.set(buf.data, buf.size); - self.clear(); - } - - public: - explicit file_print_buffer(F* f) : buffer(grow, size_t()), file_(f) { - flockfile(f); - file_.init_buffer(); - auto buf = file_.get_write_buffer(); - set(buf.data, buf.size); - } - ~file_print_buffer() { - file_.advance_write_buffer(size()); - bool flush = file_.needs_flush(); - F* f = file_; // Make funlockfile depend on the template parameter F - funlockfile(f); // for the system API detection to work. - if (flush) fflush(file_); - } -}; - -#if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE) +#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR) FMT_FUNC auto write_console(int, string_view) -> bool { return false; } #else using dword = conditional_t; @@ -1708,44 +1448,28 @@ FMT_FUNC bool write_console(int fd, string_view text) { #ifdef _WIN32 // Print assuming legacy (non-Unicode) encoding. -FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args, - bool newline) { +FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); - if (newline) buffer.push_back('\n'); - fwrite_all(buffer.data(), buffer.size(), f); + fwrite_fully(buffer.data(), buffer.size(), f); } #endif FMT_FUNC void print(std::FILE* f, string_view text) { -#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) +#ifdef _WIN32 int fd = _fileno(f); if (_isatty(fd)) { std::fflush(f); if (write_console(fd, text)) return; } #endif - fwrite_all(text.data(), text.size(), f); + fwrite_fully(text.data(), text.size(), f); } } // namespace detail -FMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) { - auto buffer = memory_buffer(); - detail::vformat_to(buffer, fmt, args); - detail::print(f, {buffer.data(), buffer.size()}); -} - FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) { - if (!detail::file_ref(f).is_buffered() || !detail::has_flockfile<>()) - return vprint_buffered(f, fmt, args); - auto&& buffer = detail::file_print_buffer<>(f); - return detail::vformat_to(buffer, fmt, args); -} - -FMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); - buffer.push_back('\n'); detail::print(f, {buffer.data(), buffer.size()}); } diff --git a/src/fmt/format.h b/src/fmt/format.h index 92a1d5b7a0..8cdf95b7bd 100644 --- a/src/fmt/format.h +++ b/src/fmt/format.h @@ -33,58 +33,30 @@ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ -#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES -# define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES -# define FMT_REMOVE_TRANSITIVE_INCLUDES +#include // std::signbit +#include // uint32_t +#include // std::memcpy +#include // std::initializer_list +#include +#include // std::numeric_limits +#include // std::uninitialized_copy +#include // std::runtime_error +#include // std::system_error + +#ifdef __cpp_lib_bit_cast +# include // std::bit_cast #endif -#include "base.h" - -#ifndef FMT_MODULE -# include // std::signbit -# include // std::byte -# include // uint32_t -# include // std::memcpy -# include // std::numeric_limits -# include // std::bad_alloc -# if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI) -// Workaround for pre gcc 5 libstdc++. -# include // std::allocator_traits -# endif -# include // std::runtime_error -# include // std::string -# include // std::system_error - -// Check FMT_CPLUSPLUS to avoid a warning in MSVC. -# if FMT_HAS_INCLUDE() && FMT_CPLUSPLUS > 201703L -# include // std::bit_cast -# endif +#include "core.h" // libc++ supports string_view in pre-c++17. -# if FMT_HAS_INCLUDE() && \ - (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) -# include -# define FMT_USE_STRING_VIEW -# endif - -# if FMT_MSC_VERSION -# include // _BitScanReverse[64], _umul128 -# endif -#endif // FMT_MODULE - -#if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS) -// Use the provided definition. -#elif defined(__NVCOMPILER) -# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 -#elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L -# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 -#elif defined(__cpp_nontype_template_args) && \ - __cpp_nontype_template_args >= 201911L -# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 -#elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L -# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 -#else -# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 +#if FMT_HAS_INCLUDE() && \ + (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) +# include +# define FMT_USE_STRING_VIEW +#elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L +# include +# define FMT_USE_EXPERIMENTAL_STRING_VIEW #endif #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L @@ -93,15 +65,29 @@ # define FMT_INLINE_VARIABLE #endif -// Check if RTTI is disabled. -#ifdef FMT_USE_RTTI -// Use the provided definition. -#elif defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \ - defined(__INTEL_RTTI__) || defined(__RTTI) -// __RTTI is for EDG compilers. _CPPRTTI is for MSVC. -# define FMT_USE_RTTI 1 +#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) +# define FMT_FALLTHROUGH [[fallthrough]] +#elif defined(__clang__) +# define FMT_FALLTHROUGH [[clang::fallthrough]] +#elif FMT_GCC_VERSION >= 700 && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) +# define FMT_FALLTHROUGH [[gnu::fallthrough]] #else -# define FMT_USE_RTTI 0 +# define FMT_FALLTHROUGH +#endif + +#ifndef FMT_NO_UNIQUE_ADDRESS +# if FMT_CPLUSPLUS >= 202002L +# if FMT_HAS_CPP_ATTRIBUTE(no_unique_address) +# define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] +// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485). +# elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION +# define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] +# endif +# endif +#endif +#ifndef FMT_NO_UNIQUE_ADDRESS +# define FMT_NO_UNIQUE_ADDRESS #endif // Visibility when compiled as a shared library/object. @@ -111,25 +97,20 @@ # define FMT_SO_VISIBILITY(value) #endif +#ifdef __has_builtin +# define FMT_HAS_BUILTIN(x) __has_builtin(x) +#else +# define FMT_HAS_BUILTIN(x) 0 +#endif + #if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_NOINLINE __attribute__((noinline)) #else # define FMT_NOINLINE #endif -namespace std { -template struct iterator_traits> { - using iterator_category = output_iterator_tag; - using value_type = T; - using difference_type = - decltype(static_cast(nullptr) - static_cast(nullptr)); - using pointer = void; - using reference = void; -}; -} // namespace std - #ifndef FMT_THROW -# if FMT_USE_EXCEPTIONS +# if FMT_EXCEPTIONS # if FMT_MSC_VERSION || defined(__NVCC__) FMT_BEGIN_NAMESPACE namespace detail { @@ -148,8 +129,38 @@ FMT_END_NAMESPACE # else # define FMT_THROW(x) \ ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what()) -# endif // FMT_USE_EXCEPTIONS -#endif // FMT_THROW +# endif +#endif + +#if FMT_EXCEPTIONS +# define FMT_TRY try +# define FMT_CATCH(x) catch (x) +#else +# define FMT_TRY if (true) +# define FMT_CATCH(x) if (false) +#endif + +#ifndef FMT_MAYBE_UNUSED +# if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) +# define FMT_MAYBE_UNUSED [[maybe_unused]] +# else +# define FMT_MAYBE_UNUSED +# endif +#endif + +#ifndef FMT_USE_USER_DEFINED_LITERALS +// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs. +// +// GCC before 4.9 requires a space in `operator"" _a` which is invalid in later +// compiler versions. +# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \ + FMT_MSC_VERSION >= 1900) && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480) +# define FMT_USE_USER_DEFINED_LITERALS 1 +# else +# define FMT_USE_USER_DEFINED_LITERALS 0 +# endif +#endif // Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of // integer formatter template instantiations to just one by only using the @@ -159,15 +170,7 @@ FMT_END_NAMESPACE # define FMT_REDUCE_INT_INSTANTIATIONS 0 #endif -FMT_BEGIN_NAMESPACE - -template -struct is_contiguous> - : std::true_type {}; - -namespace detail { - -// __builtin_clz is broken in clang with Microsoft codegen: +// __builtin_clz is broken in clang with Microsoft CodeGen: // https://github.com/fmtlib/fmt/issues/519. #if !FMT_MSC_VERSION # if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION @@ -178,30 +181,53 @@ namespace detail { # endif #endif -// Some compilers masquerade as both MSVC and GCC but otherwise support +// __builtin_ctz is broken in Intel Compiler Classic on Windows: +// https://github.com/fmtlib/fmt/issues/2510. +#ifndef __ICL +# if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || \ + defined(__NVCOMPILER) +# define FMT_BUILTIN_CTZ(n) __builtin_ctz(n) +# endif +# if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || \ + FMT_ICC_VERSION || defined(__NVCOMPILER) +# define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n) +# endif +#endif + +#if FMT_MSC_VERSION +# include // _BitScanReverse[64], _BitScanForward[64], _umul128 +#endif + +// Some compilers masquerade as both MSVC and GCC-likes or otherwise support // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the // MSVC intrinsics if the clz and clzll builtins are not available. -#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) +#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && \ + !defined(FMT_BUILTIN_CTZLL) +FMT_BEGIN_NAMESPACE +namespace detail { // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. -# ifndef __clang__ +# if !defined(__clang__) +# pragma intrinsic(_BitScanForward) # pragma intrinsic(_BitScanReverse) -# ifdef _WIN64 +# if defined(_WIN64) +# pragma intrinsic(_BitScanForward64) # pragma intrinsic(_BitScanReverse64) # endif # endif inline auto clz(uint32_t x) -> int { - FMT_ASSERT(x != 0, ""); - FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. unsigned long r = 0; _BitScanReverse(&r, x); + FMT_ASSERT(x != 0, ""); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. + FMT_MSC_WARNING(suppress : 6102) return 31 ^ static_cast(r); } # define FMT_BUILTIN_CLZ(n) detail::clz(n) inline auto clzll(uint64_t x) -> int { - FMT_ASSERT(x != 0, ""); - FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. unsigned long r = 0; # ifdef _WIN64 _BitScanReverse64(&r, x); @@ -212,10 +238,55 @@ inline auto clzll(uint64_t x) -> int { // Scan the low 32 bits. _BitScanReverse(&r, static_cast(x)); # endif + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. return 63 ^ static_cast(r); } # define FMT_BUILTIN_CLZLL(n) detail::clzll(n) -#endif // FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) + +inline auto ctz(uint32_t x) -> int { + unsigned long r = 0; + _BitScanForward(&r, x); + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + return static_cast(r); +} +# define FMT_BUILTIN_CTZ(n) detail::ctz(n) + +inline auto ctzll(uint64_t x) -> int { + unsigned long r = 0; + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. +# ifdef _WIN64 + _BitScanForward64(&r, x); +# else + // Scan the low 32 bits. + if (_BitScanForward(&r, static_cast(x))) return static_cast(r); + // Scan the high 32 bits. + _BitScanForward(&r, static_cast(x >> 32)); + r += 32; +# endif + return static_cast(r); +} +# define FMT_BUILTIN_CTZLL(n) detail::ctzll(n) +} // namespace detail +FMT_END_NAMESPACE +#endif + +namespace std { +template <> struct iterator_traits { + using value_type = void; + using iterator_category = std::output_iterator_tag; +}; +template +struct iterator_traits> { + using value_type = void; + using iterator_category = std::output_iterator_tag; +}; +} // namespace std + +FMT_BEGIN_NAMESPACE +namespace detail { FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { ignore_unused(condition); @@ -226,19 +297,23 @@ FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { #if defined(FMT_USE_STRING_VIEW) template using std_string_view = std::basic_string_view; +#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) +template +using std_string_view = std::experimental::basic_string_view; #else template struct std_string_view {}; #endif -template struct string_literal { - static constexpr Char value[sizeof...(C)] = {C...}; - constexpr operator basic_string_view() const { +template struct string_literal { + static constexpr CharT value[sizeof...(C)] = {C...}; + constexpr operator basic_string_view() const { return {value, sizeof...(C)}; } }; + #if FMT_CPLUSPLUS < 201703L -template -constexpr Char string_literal::value[sizeof...(C)]; +template +constexpr CharT string_literal::value[sizeof...(C)]; #endif // Implementation of std::bit_cast for pre-C++20. @@ -310,14 +385,13 @@ class uint128_fallback { -> uint128_fallback { return {~n.hi_, ~n.lo_}; } - friend FMT_CONSTEXPR auto operator+(const uint128_fallback& lhs, - const uint128_fallback& rhs) - -> uint128_fallback { + friend auto operator+(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> uint128_fallback { auto result = uint128_fallback(lhs); result += rhs; return result; } - friend FMT_CONSTEXPR auto operator*(const uint128_fallback& lhs, uint32_t rhs) + friend auto operator*(const uint128_fallback& lhs, uint32_t rhs) -> uint128_fallback { FMT_ASSERT(lhs.hi_ == 0, ""); uint64_t hi = (lhs.lo_ >> 32) * rhs; @@ -325,7 +399,7 @@ class uint128_fallback { uint64_t new_lo = (hi << 32) + lo; return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo}; } - friend constexpr auto operator-(const uint128_fallback& lhs, uint64_t rhs) + friend auto operator-(const uint128_fallback& lhs, uint64_t rhs) -> uint128_fallback { return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs}; } @@ -398,24 +472,23 @@ template constexpr auto num_bits() -> int { } // std::numeric_limits::digits may return 0 for 128-bit ints. template <> constexpr auto num_bits() -> int { return 128; } -template <> constexpr auto num_bits() -> int { return 128; } -template <> constexpr auto num_bits() -> int { return 128; } +template <> constexpr auto num_bits() -> int { return 128; } // A heterogeneous bit_cast used for converting 96-bit long double to uint128_t // and 128-bit pointers to uint128_fallback. template sizeof(From))> inline auto bit_cast(const From& from) -> To { - constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned short)); + constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned)); struct data_t { - unsigned short value[static_cast(size)]; + unsigned value[static_cast(size)]; } data = bit_cast(from); auto result = To(); if (const_check(is_big_endian())) { for (int i = 0; i < size; ++i) - result = (result << num_bits()) | data.value[i]; + result = (result << num_bits()) | data.value[i]; } else { for (int i = size - 1; i >= 0; --i) - result = (result << num_bits()) | data.value[i]; + result = (result << num_bits()) | data.value[i]; } return result; } @@ -451,25 +524,84 @@ FMT_INLINE void assume(bool condition) { #endif } +// Extracts a reference to the container from back_insert_iterator. +template +inline auto get_container(std::back_insert_iterator it) + -> Container& { + using base = std::back_insert_iterator; + struct accessor : base { + accessor(base b) : base(b) {} + using base::container; + }; + return *accessor(it).container; +} + +template +FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out) + -> OutputIt { + while (begin != end) *out++ = static_cast(*begin++); + return out; +} + +template , U>::value&& is_char::value)> +FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* { + if (is_constant_evaluated()) return copy_str(begin, end, out); + auto size = to_unsigned(end - begin); + if (size > 0) memcpy(out, begin, size * sizeof(U)); + return out + size; +} + +template +auto copy_str(InputIt begin, InputIt end, appender out) -> appender { + get_container(out).append(begin, end); + return out; +} +template +auto copy_str(InputIt begin, InputIt end, back_insert_iterator out) + -> back_insert_iterator { + get_container(out).append(begin, end); + return out; +} + +template +FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt { + return detail::copy_str(rng.begin(), rng.end(), out); +} + +// An approximation of iterator_t for pre-C++20 systems. +template +using iterator_t = decltype(std::begin(std::declval())); +template using sentinel_t = decltype(std::end(std::declval())); + +// A workaround for std::string not having mutable data() until C++17. +template +inline auto get_data(std::basic_string& s) -> Char* { + return &s[0]; +} +template +inline auto get_data(Container& c) -> typename Container::value_type* { + return c.data(); +} + // Attempts to reserve space for n extra characters in the output range. // Returns a pointer to the reserved range or a reference to it. -template ::value&& - is_contiguous::value)> +template ::value)> #if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION __attribute__((no_sanitize("undefined"))) #endif -FMT_CONSTEXPR20 inline auto -reserve(OutputIt it, size_t n) -> typename OutputIt::value_type* { - auto& c = get_container(it); +inline auto +reserve(std::back_insert_iterator it, size_t n) -> + typename Container::value_type* { + Container& c = get_container(it); size_t size = c.size(); c.resize(size + n); - return &c[size]; + return get_data(c) + size; } template -FMT_CONSTEXPR20 inline auto reserve(basic_appender it, size_t n) - -> basic_appender { +inline auto reserve(buffer_appender it, size_t n) -> buffer_appender { buffer& buf = get_container(it); buf.try_reserve(buf.size() + n); return it; @@ -488,22 +620,18 @@ template constexpr auto to_pointer(OutputIt, size_t) -> T* { return nullptr; } -template -FMT_CONSTEXPR20 auto to_pointer(basic_appender it, size_t n) -> T* { +template auto to_pointer(buffer_appender it, size_t n) -> T* { buffer& buf = get_container(it); - buf.try_reserve(buf.size() + n); auto size = buf.size(); if (buf.capacity() < size + n) return nullptr; buf.try_resize(size + n); return buf.data() + size; } -template ::value&& - is_contiguous::value)> -inline auto base_iterator(OutputIt it, - typename OutputIt::container_type::value_type*) - -> OutputIt { +template ::value)> +inline auto base_iterator(std::back_insert_iterator it, + typename Container::value_type*) + -> std::back_insert_iterator { return it; } @@ -522,15 +650,23 @@ FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value) } template FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* { - if (is_constant_evaluated()) return fill_n(out, count, value); + if (is_constant_evaluated()) { + return fill_n(out, count, value); + } std::memset(out, value, to_unsigned(count)); return out + count; } +#ifdef __cpp_char8_t +using char8_type = char8_t; +#else +enum char8_type : unsigned char {}; +#endif + template -FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end, - OutputIt out) -> OutputIt { - return copy(begin, end, out); +FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end, + OutputIt out) -> OutputIt { + return copy_str(begin, end, out); } // A public domain branchless UTF-8 decoder by Christopher Wellons: @@ -601,7 +737,6 @@ FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr))); return result ? (error ? buf_ptr + 1 : end) : nullptr; }; - auto p = s.data(); const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars. if (s.size() >= block_size) { @@ -610,20 +745,17 @@ FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { if (!p) return; } } - auto num_chars_left = to_unsigned(s.data() + s.size() - p); - if (num_chars_left == 0) return; - - // Suppress bogus -Wstringop-overflow. - if (FMT_GCC_VERSION) num_chars_left &= 3; - char buf[2 * block_size - 1] = {}; - copy(p, p + num_chars_left, buf); - const char* buf_ptr = buf; - do { - auto end = decode(buf_ptr, p); - if (!end) return; - p += end - buf_ptr; - buf_ptr = end; - } while (buf_ptr < buf + num_chars_left); + if (auto num_chars_left = s.data() + s.size() - p) { + char buf[2 * block_size - 1] = {}; + copy_str(p, p + num_chars_left, buf); + const char* buf_ptr = buf; + do { + auto end = decode(buf_ptr, p); + if (!end) return; + p += end - buf_ptr; + buf_ptr = end; + } while (buf_ptr - buf < num_chars_left); + } } template @@ -638,7 +770,7 @@ FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t { struct count_code_points { size_t* count; FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool { - *count += to_unsigned( + *count += detail::to_unsigned( 1 + (cp >= 0x1100 && (cp <= 0x115f || // Hangul Jamo init. consonants @@ -666,9 +798,15 @@ FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t { return num_code_points; } +inline auto compute_width(basic_string_view s) -> size_t { + return compute_width( + string_view(reinterpret_cast(s.data()), s.size())); +} + template inline auto code_point_index(basic_string_view s, size_t n) -> size_t { - return min_of(n, s.size()); + size_t size = s.size(); + return n < size ? n : size; } // Calculates the index of the nth code point in a UTF-8 string. @@ -686,6 +824,12 @@ inline auto code_point_index(string_view s, size_t n) -> size_t { return result; } +inline auto code_point_index(basic_string_view s, size_t n) + -> size_t { + return code_point_index( + string_view(reinterpret_cast(s.data()), s.size()), n); +} + template struct is_integral : std::is_integral {}; template <> struct is_integral : std::true_type {}; template <> struct is_integral : std::true_type {}; @@ -701,22 +845,38 @@ using is_integer = !std::is_same::value && !std::is_same::value>; -#if defined(FMT_USE_FLOAT128) -// Use the provided definition. -#elif FMT_CLANG_VERSION && FMT_HAS_INCLUDE() -# define FMT_USE_FLOAT128 1 -#elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \ - !defined(__STRICT_ANSI__) -# define FMT_USE_FLOAT128 1 -#else -# define FMT_USE_FLOAT128 0 +#ifndef FMT_USE_FLOAT +# define FMT_USE_FLOAT 1 #endif +#ifndef FMT_USE_DOUBLE +# define FMT_USE_DOUBLE 1 +#endif +#ifndef FMT_USE_LONG_DOUBLE +# define FMT_USE_LONG_DOUBLE 1 +#endif + +#ifndef FMT_USE_FLOAT128 +# ifdef __clang__ +// Clang emulates GCC, so it has to appear early. +# if FMT_HAS_INCLUDE() +# define FMT_USE_FLOAT128 1 +# endif +# elif defined(__GNUC__) +// GNU C++: +# if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) +# define FMT_USE_FLOAT128 1 +# endif +# endif +# ifndef FMT_USE_FLOAT128 +# define FMT_USE_FLOAT128 0 +# endif +#endif + #if FMT_USE_FLOAT128 using float128 = __float128; #else -struct float128 {}; +using float128 = void; #endif - template using is_float128 = std::is_same; template @@ -735,21 +895,24 @@ using is_double_double = bool_constant::digits == 106>; # define FMT_USE_FULL_CACHE_DRAGONBOX 0 #endif -// An allocator that uses malloc/free to allow removing dependency on the C++ -// standard libary runtime. -template struct allocator { - using value_type = T; - - T* allocate(size_t n) { - FMT_ASSERT(n <= max_value() / sizeof(T), ""); - T* p = static_cast(malloc(n * sizeof(T))); - if (!p) FMT_THROW(std::bad_alloc()); - return p; +template +template +void buffer::append(const U* begin, const U* end) { + while (begin != end) { + auto count = to_unsigned(end - begin); + try_reserve(size_ + count); + auto free_cap = capacity_ - size_; + if (free_cap < count) count = free_cap; + std::uninitialized_copy_n(begin, count, ptr_ + size_); + size_ += count; + begin += count; } +} - void deallocate(T* p, size_t) { free(p); } -}; - +template +struct is_locale : std::false_type {}; +template +struct is_locale> : std::true_type {}; } // namespace detail FMT_BEGIN_EXPORT @@ -759,21 +922,29 @@ FMT_BEGIN_EXPORT enum { inline_buffer_size = 500 }; /** - * A dynamically growing memory buffer for trivially copyable/constructible - * types with the first `SIZE` elements stored in the object itself. Most - * commonly used via the `memory_buffer` alias for `char`. - * - * **Example**: - * - * auto out = fmt::memory_buffer(); - * fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); - * - * This will append "The answer is 42." to `out`. The buffer content can be - * converted to `std::string` with `to_string(out)`. + \rst + A dynamically growing memory buffer for trivially copyable/constructible types + with the first ``SIZE`` elements stored in the object itself. + + You can use the ``memory_buffer`` type alias for ``char`` instead. + + **Example**:: + + auto out = fmt::memory_buffer(); + fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); + + This will append the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42. + + The output can be converted to an ``std::string`` with ``to_string(out)``. + \endrst */ template > -class basic_memory_buffer : public detail::buffer { + typename Allocator = std::allocator> +class basic_memory_buffer final : public detail::buffer { private: T store_[SIZE]; @@ -786,6 +957,7 @@ class basic_memory_buffer : public detail::buffer { if (data != store_) alloc_.deallocate(data, this->capacity()); } + protected: static FMT_CONSTEXPR20 void grow(detail::buffer& buf, size_t size) { detail::abort_fuzzing_if(size > 5000); auto& self = static_cast(buf); @@ -796,13 +968,14 @@ class basic_memory_buffer : public detail::buffer { if (size > new_capacity) new_capacity = size; else if (new_capacity > max_size) - new_capacity = max_of(size, max_size); + new_capacity = size > max_size ? size : max_size; T* old_data = buf.data(); - T* new_data = self.alloc_.allocate(new_capacity); + T* new_data = + std::allocator_traits::allocate(self.alloc_, new_capacity); // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481). detail::assume(buf.size() <= new_capacity); // The following code doesn't throw, so the raw pointer above doesn't leak. - memcpy(new_data, old_data, buf.size() * sizeof(T)); + std::uninitialized_copy_n(old_data, buf.size(), new_data); self.set(new_data, new_capacity); // deallocate must not throw according to the standard, but even if it does, // the buffer already uses the new storage and will deallocate it in @@ -814,7 +987,7 @@ class basic_memory_buffer : public detail::buffer { using value_type = T; using const_reference = const T&; - FMT_CONSTEXPR explicit basic_memory_buffer( + FMT_CONSTEXPR20 explicit basic_memory_buffer( const Allocator& alloc = Allocator()) : detail::buffer(grow), alloc_(alloc) { this->set(store_, SIZE); @@ -830,7 +1003,7 @@ class basic_memory_buffer : public detail::buffer { size_t size = other.size(), capacity = other.capacity(); if (data == other.store_) { this->set(store_, capacity); - detail::copy(other.store_, other.store_ + size, store_); + detail::copy_str(other.store_, other.store_ + size, store_); } else { this->set(data, capacity); // Set pointer to the inline array so that delete is not called @@ -842,14 +1015,22 @@ class basic_memory_buffer : public detail::buffer { } public: - /// Constructs a `basic_memory_buffer` object moving the content of the other - /// object to it. + /** + \rst + Constructs a :class:`fmt::basic_memory_buffer` object moving the content + of the other object to it. + \endrst + */ FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept : detail::buffer(grow) { move(other); } - /// Moves the content of the other `basic_memory_buffer` object to this one. + /** + \rst + Moves the content of the other ``basic_memory_buffer`` object to this one. + \endrst + */ auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& { FMT_ASSERT(this != &other, ""); deallocate(); @@ -860,108 +1041,119 @@ class basic_memory_buffer : public detail::buffer { // Returns a copy of the allocator associated with this buffer. auto get_allocator() const -> Allocator { return alloc_; } - /// Resizes the buffer to contain `count` elements. If T is a POD type new - /// elements may not be initialized. - FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); } + /** + Resizes the buffer to contain *count* elements. If T is a POD type new + elements may not be initialized. + */ + FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); } - /// Increases the buffer capacity to `new_capacity`. + /** Increases the buffer capacity to *new_capacity*. */ void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } using detail::buffer::append; template - FMT_CONSTEXPR20 void append(const ContiguousRange& range) { + void append(const ContiguousRange& range) { append(range.data(), range.data() + range.size()); } }; using memory_buffer = basic_memory_buffer; -template -FMT_NODISCARD auto to_string(const basic_memory_buffer& buf) - -> std::string { - auto size = buf.size(); - detail::assume(size < std::string().max_size()); - return {buf.data(), size}; -} - -// A writer to a buffered stream. It doesn't own the underlying stream. -class writer { - private: - detail::buffer* buf_; - - // We cannot create a file buffer in advance because any write to a FILE may - // invalidate it. - FILE* file_; - - public: - inline writer(FILE* f) : buf_(nullptr), file_(f) {} - inline writer(detail::buffer& buf) : buf_(&buf) {} - - /// Formats `args` according to specifications in `fmt` and writes the - /// output to the file. - template void print(format_string fmt, T&&... args) { - if (buf_) - fmt::format_to(appender(*buf_), fmt, std::forward(args)...); - else - fmt::print(file_, fmt, std::forward(args)...); - } -}; - -class string_buffer { - private: - std::string str_; - detail::container_buffer buf_; - - public: - inline string_buffer() : buf_(str_) {} - - inline operator writer() { return buf_; } - inline std::string& str() { return str_; } -}; - template struct is_contiguous> : std::true_type { }; -// Suppress a misleading warning in older versions of clang. -FMT_PRAGMA_CLANG(diagnostic ignored "-Wweak-vtables") +FMT_END_EXPORT +namespace detail { +FMT_API auto write_console(int fd, string_view text) -> bool; +FMT_API void print(std::FILE*, string_view); +} // namespace detail -/// An error reported from a formatting function. +FMT_BEGIN_EXPORT + +// Suppress a misleading warning in older versions of clang. +#if FMT_CLANG_VERSION +# pragma clang diagnostic ignored "-Wweak-vtables" +#endif + +/** An error reported from a formatting function. */ class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error { public: using std::runtime_error::runtime_error; }; -class loc_value; - -FMT_END_EXPORT -namespace detail { -FMT_API auto write_console(int fd, string_view text) -> bool; -FMT_API void print(FILE*, string_view); -} // namespace detail - -namespace detail { +namespace detail_exported { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS template struct fixed_string { - FMT_CONSTEXPR20 fixed_string(const Char (&s)[N]) { - detail::copy(static_cast(s), s + N, - data); + constexpr fixed_string(const Char (&str)[N]) { + detail::copy_str(static_cast(str), + str + N, data); } Char data[N] = {}; }; +#endif // Converts a compile-time string to basic_string_view. -FMT_EXPORT template +template constexpr auto compile_string_to_view(const Char (&s)[N]) -> basic_string_view { // Remove trailing NUL character if needed. Won't be present if this is used // with a raw character array (i.e. not defined as a string). return {s, N - (std::char_traits::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; } -FMT_EXPORT template -constexpr auto compile_string_to_view(basic_string_view s) +template +constexpr auto compile_string_to_view(detail::std_string_view s) -> basic_string_view { - return s; + return {s.data(), s.size()}; } +} // namespace detail_exported + +class loc_value { + private: + basic_format_arg value_; + + public: + template ::value)> + loc_value(T value) : value_(detail::make_arg(value)) {} + + template ::value)> + loc_value(T) {} + + template auto visit(Visitor&& vis) -> decltype(vis(0)) { + return value_.visit(vis); + } +}; + +// A locale facet that formats values in UTF-8. +// It is parameterized on the locale to avoid the heavy include. +template class format_facet : public Locale::facet { + private: + std::string separator_; + std::string grouping_; + std::string decimal_point_; + + protected: + virtual auto do_put(appender out, loc_value val, + const format_specs<>& specs) const -> bool; + + public: + static FMT_API typename Locale::id id; + + explicit format_facet(Locale& loc); + explicit format_facet(string_view sep = "", + std::initializer_list g = {3}, + std::string decimal_point = ".") + : separator_(sep.data(), sep.size()), + grouping_(g.begin(), g.end()), + decimal_point_(decimal_point) {} + + auto put(appender out, loc_value val, const format_specs<>& specs) const + -> bool { + return do_put(out, val, specs); + } +}; + +namespace detail { // Returns true if value is negative, false otherwise. // Same as `value < 0` but doesn't produce warnings if T is an unsigned type. @@ -974,6 +1166,14 @@ constexpr auto is_negative(T) -> bool { return false; } +template +FMT_CONSTEXPR auto is_supported_floating_point(T) -> bool { + if (std::is_same()) return FMT_USE_FLOAT; + if (std::is_same()) return FMT_USE_DOUBLE; + if (std::is_same()) return FMT_USE_LONG_DOUBLE; + return true; +} + // Smallest of uint32_t, uint64_t, uint128_t that is large enough to // represent all values of an integral type T. template @@ -990,22 +1190,21 @@ using uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>; (factor) * 100000000, (factor) * 1000000000 // Converts value in the range [0, 100) to a string. -// GCC generates slightly better code when value is pointer-size. -inline auto digits2(size_t value) -> const char* { - // Align data since unaligned access may be slower when crossing a - // hardware-specific boundary. - alignas(2) static const char data[] = - "0001020304050607080910111213141516171819" - "2021222324252627282930313233343536373839" - "4041424344454647484950515253545556575859" - "6061626364656667686970717273747576777879" - "8081828384858687888990919293949596979899"; - return &data[value * 2]; +constexpr auto digits2(size_t value) -> const char* { + // GCC generates slightly better code when value is pointer-size. + return &"0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"[value * 2]; } -template constexpr auto getsign(sign s) -> Char { - return static_cast(((' ' << 24) | ('+' << 16) | ('-' << 8)) >> - (static_cast(s) * 8)); +// Sign is a template parameter to workaround a bug in gcc 4.8. +template constexpr auto sign(Sign s) -> Char { +#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604 + static_assert(std::is_same::value, ""); +#endif + return static_cast("\0-+ "[s]); } template FMT_CONSTEXPR auto count_digits_fallback(T n) -> int { @@ -1053,7 +1252,9 @@ inline auto do_count_digits(uint64_t n) -> int { // except for n == 0 in which case count_digits returns 1. FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL - if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n); + if (!is_constant_evaluated()) { + return do_count_digits(n); + } #endif return count_digits_fallback(n); } @@ -1103,7 +1304,9 @@ FMT_INLINE auto do_count_digits(uint32_t n) -> int { // Optional version of count_digits for better performance on 32-bit platforms. FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ - if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n); + if (!is_constant_evaluated()) { + return do_count_digits(n); + } #endif return count_digits_fallback(n); } @@ -1140,17 +1343,6 @@ template <> inline auto decimal_point(locale_ref loc) -> wchar_t { return decimal_point_impl(loc); } -#ifndef FMT_HEADER_ONLY -FMT_BEGIN_EXPORT -extern template FMT_API auto thousands_sep_impl(locale_ref) - -> thousands_sep_result; -extern template FMT_API auto thousands_sep_impl(locale_ref) - -> thousands_sep_result; -extern template FMT_API auto decimal_point_impl(locale_ref) -> char; -extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; -FMT_END_EXPORT -#endif // FMT_HEADER_ONLY - // Compares two characters for equality. template auto equal2(const Char* lhs, const char* rhs) -> bool { return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]); @@ -1159,99 +1351,83 @@ inline auto equal2(const char* lhs, const char* rhs) -> bool { return memcmp(lhs, rhs, 2) == 0; } -// Writes a two-digit value to out. +// Copies two characters from src to dst. template -FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) { - if (!is_constant_evaluated() && std::is_same::value && - !FMT_OPTIMIZE_SIZE) { - memcpy(out, digits2(value), 2); +FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) { + if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) { + memcpy(dst, src, 2); return; } - *out++ = static_cast('0' + value / 10); - *out = static_cast('0' + value % 10); + *dst++ = static_cast(*src++); + *dst = static_cast(*src); } -// Formats a decimal unsigned integer value writing to out pointing to a buffer -// of specified size. The caller must ensure that the buffer is large enough. +template struct format_decimal_result { + Iterator begin; + Iterator end; +}; + +// Formats a decimal unsigned integer value writing into out pointing to a +// buffer of specified size. The caller must ensure that the buffer is large +// enough. template -FMT_CONSTEXPR20 auto do_format_decimal(Char* out, UInt value, int size) - -> Char* { +FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size) + -> format_decimal_result { FMT_ASSERT(size >= count_digits(value), "invalid digit count"); - unsigned n = to_unsigned(size); + out += size; + Char* end = out; while (value >= 100) { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. - n -= 2; - write2digits(out + n, static_cast(value % 100)); + out -= 2; + copy2(out, digits2(static_cast(value % 100))); value /= 100; } - if (value >= 10) { - n -= 2; - write2digits(out + n, static_cast(value)); - } else { - out[--n] = static_cast('0' + value); + if (value < 10) { + *--out = static_cast('0' + value); + return {out, end}; } - return out + n; + out -= 2; + copy2(out, digits2(static_cast(value))); + return {out, end}; } -template -FMT_CONSTEXPR FMT_INLINE auto format_decimal(Char* out, UInt value, - int num_digits) -> Char* { - do_format_decimal(out, value, num_digits); - return out + num_digits; -} - -template ::value)> -FMT_CONSTEXPR auto format_decimal(OutputIt out, UInt value, int num_digits) - -> OutputIt { - if (auto ptr = to_pointer(out, to_unsigned(num_digits))) { - do_format_decimal(ptr, value, num_digits); - return out; - } +template >::value)> +FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size) + -> format_decimal_result { // Buffer is large enough to hold all digits (digits10 + 1). - char buffer[digits10() + 1]; - if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0'); - do_format_decimal(buffer, value, num_digits); - return copy_noinline(buffer, buffer + num_digits, out); + Char buffer[digits10() + 1] = {}; + auto end = format_decimal(buffer, value, size).end; + return {out, detail::copy_str_noinline(buffer, end, out)}; } -template -FMT_CONSTEXPR auto do_format_base2e(int base_bits, Char* out, UInt value, - int size, bool upper = false) -> Char* { - out += size; +template +FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits, + bool upper = false) -> Char* { + buffer += num_digits; + Char* end = buffer; do { const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; - unsigned digit = static_cast(value & ((1 << base_bits) - 1)); - *--out = static_cast(base_bits < 4 ? static_cast('0' + digit) - : digits[digit]); - } while ((value >>= base_bits) != 0); - return out; + unsigned digit = static_cast(value & ((1 << BASE_BITS) - 1)); + *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit) + : digits[digit]); + } while ((value >>= BASE_BITS) != 0); + return end; } -// Formats an unsigned integer in the power of two base (binary, octal, hex). -template -FMT_CONSTEXPR auto format_base2e(int base_bits, Char* out, UInt value, - int num_digits, bool upper = false) -> Char* { - do_format_base2e(base_bits, out, value, num_digits, upper); - return out + num_digits; -} - -template ::value)> -FMT_CONSTEXPR inline auto format_base2e(int base_bits, OutputIt out, UInt value, - int num_digits, bool upper = false) - -> OutputIt { +template +FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits, + bool upper = false) -> It { if (auto ptr = to_pointer(out, to_unsigned(num_digits))) { - format_base2e(base_bits, ptr, value, num_digits, upper); + format_uint(ptr, value, num_digits, upper); return out; } - // Make buffer large enough for any base. - char buffer[num_bits()]; - if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0'); - format_base2e(base_bits, buffer, value, num_digits, upper); - return detail::copy_noinline(buffer, buffer + num_digits, out); + // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). + char buffer[num_bits() / BASE_BITS + 1] = {}; + format_uint(buffer, value, num_digits, upper); + return detail::copy_str_noinline(buffer, buffer + num_digits, out); } // A converter from UTF-8 to UTF-16. @@ -1261,12 +1437,10 @@ class utf8_to_utf16 { public: FMT_API explicit utf8_to_utf16(string_view s); - inline operator basic_string_view() const { - return {&buffer_[0], size()}; - } - inline auto size() const -> size_t { return buffer_.size() - 1; } - inline auto c_str() const -> const wchar_t* { return &buffer_[0]; } - inline auto str() const -> std::wstring { return {&buffer_[0], size()}; } + operator basic_string_view() const { return {&buffer_[0], size()}; } + auto size() const -> size_t { return buffer_.size() - 1; } + auto c_str() const -> const wchar_t* { return &buffer_[0]; } + auto str() const -> std::wstring { return {&buffer_[0], size()}; } }; enum class to_utf8_error_policy { abort, replace }; @@ -1313,12 +1487,10 @@ template class to_utf8 { if (policy == to_utf8_error_policy::abort) return false; buf.append(string_view("\xEF\xBF\xBD")); --p; - continue; } else { c = (c << 10) + static_cast(*p) - 0x35fdc00; } - } - if (c < 0x80) { + } else if (c < 0x80) { buf.push_back(static_cast(c)); } else if (c < 0x800) { buf.push_back(static_cast(0xc0 | (c >> 6))); @@ -1486,30 +1658,25 @@ template constexpr auto exponent_bias() -> int { } // Writes the exponent exp in the form "[+-]d{2,3}" to buffer. -template -FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt { +template +FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It { FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); if (exp < 0) { - *out++ = static_cast('-'); + *it++ = static_cast('-'); exp = -exp; } else { - *out++ = static_cast('+'); + *it++ = static_cast('+'); } - auto uexp = static_cast(exp); - if (is_constant_evaluated()) { - if (uexp < 10) *out++ = '0'; - return format_decimal(out, uexp, count_digits(uexp)); + if (exp >= 100) { + const char* top = digits2(to_unsigned(exp / 100)); + if (exp >= 1000) *it++ = static_cast(top[0]); + *it++ = static_cast(top[1]); + exp %= 100; } - if (uexp >= 100u) { - const char* top = digits2(uexp / 100); - if (uexp >= 1000u) *out++ = static_cast(top[0]); - *out++ = static_cast(top[1]); - uexp %= 100; - } - const char* d = digits2(uexp); - *out++ = static_cast(d[0]); - *out++ = static_cast(d[1]); - return out; + const char* d = digits2(to_unsigned(exp)); + *it++ = static_cast(d[0]); + *it++ = static_cast(d[1]); + return it; } // A floating-point number f * pow(2, e) where F is an unsigned type. @@ -1610,69 +1777,67 @@ constexpr auto convert_float(T value) -> convert_float_result { return static_cast>(value); } -template +template FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, - const basic_specs& specs) -> OutputIt { - auto fill_size = specs.fill_size(); - if (fill_size == 1) return detail::fill_n(it, n, specs.fill_unit()); - if (const Char* data = specs.fill()) { - for (size_t i = 0; i < n; ++i) it = copy(data, data + fill_size, it); - } + const fill_t& fill) -> OutputIt { + auto fill_size = fill.size(); + if (fill_size == 1) return detail::fill_n(it, n, fill[0]); + auto data = fill.data(); + for (size_t i = 0; i < n; ++i) + it = copy_str(data, data + fill_size, it); return it; } // Writes the output of f, padded according to format specifications in specs. // size: output size in code units. // width: output display width in (terminal) column positions. -template -FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, +FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, size_t size, size_t width, F&& f) -> OutputIt { - static_assert(default_align == align::left || default_align == align::right, - ""); + static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. - auto* shifts = - default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; - size_t left_padding = padding >> shifts[static_cast(specs.align())]; + auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; + size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; - auto it = reserve(out, size + padding * specs.fill_size()); - if (left_padding != 0) it = fill(it, left_padding, specs); + auto it = reserve(out, size + padding * specs.fill.size()); + if (left_padding != 0) it = fill(it, left_padding, specs.fill); it = f(it); - if (right_padding != 0) it = fill(it, right_padding, specs); + if (right_padding != 0) it = fill(it, right_padding, specs.fill); return base_iterator(out, it); } -template -constexpr auto write_padded(OutputIt out, const format_specs& specs, +constexpr auto write_padded(OutputIt out, const format_specs& specs, size_t size, F&& f) -> OutputIt { - return write_padded(out, specs, size, size, f); + return write_padded(out, specs, size, size, f); } -template +template FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, - const format_specs& specs = {}) -> OutputIt { - return write_padded( + const format_specs& specs) -> OutputIt { + return write_padded( out, specs, bytes.size(), [bytes](reserve_iterator it) { const char* data = bytes.data(); - return copy(data, data + bytes.size(), it); + return copy_str(data, data + bytes.size(), it); }); } template -auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) +auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) -> OutputIt { int num_digits = count_digits<4>(value); auto size = to_unsigned(num_digits) + size_t(2); auto write = [=](reserve_iterator it) { *it++ = static_cast('0'); *it++ = static_cast('x'); - return format_base2e(4, it, value, num_digits); + return format_uint<4, Char>(it, value, num_digits); }; - return specs ? write_padded(out, *specs, size, write) + return specs ? write_padded(out, *specs, size, write) : base_iterator(out, write(reserve(out, size))); } @@ -1680,9 +1845,8 @@ auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) FMT_API auto is_printable(uint32_t cp) -> bool; inline auto needs_escape(uint32_t cp) -> bool { - if (cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\') return true; - if (const_check(FMT_OPTIMIZE_SIZE > 1)) return false; - return !is_printable(cp); + return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' || + !is_printable(cp); } template struct find_escape_result { @@ -1691,11 +1855,17 @@ template struct find_escape_result { uint32_t cp; }; +template +using make_unsigned_char = + typename conditional_t::value, + std::make_unsigned, + type_identity>::type; + template auto find_escape(const Char* begin, const Char* end) -> find_escape_result { for (; begin != end; ++begin) { - uint32_t cp = static_cast>(*begin); + uint32_t cp = static_cast>(*begin); if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue; if (needs_escape(cp)) return {begin, begin + 1, cp}; } @@ -1704,7 +1874,7 @@ auto find_escape(const Char* begin, const Char* end) inline auto find_escape(const char* begin, const char* end) -> find_escape_result { - if (const_check(!use_utf8)) return find_escape(begin, end); + if (!is_utf8()) return find_escape(begin, end); auto result = find_escape_result{end, nullptr, 0}; for_each_codepoint(string_view(begin, to_unsigned(end - begin)), [&](uint32_t cp, string_view sv) { @@ -1717,14 +1887,40 @@ inline auto find_escape(const char* begin, const char* end) return result; } +#define FMT_STRING_IMPL(s, base, explicit) \ + [] { \ + /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ + /* Use a macro-like name to avoid shadowing warnings. */ \ + struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ + using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t; \ + FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit \ + operator fmt::basic_string_view() const { \ + return fmt::detail_exported::compile_string_to_view(s); \ + } \ + }; \ + return FMT_COMPILE_STRING(); \ + }() + +/** + \rst + Constructs a compile-time format string from a string literal *s*. + + **Example**:: + + // A compile-time error because 'd' is an invalid specifier for strings. + std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); + \endrst + */ +#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, ) + template auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { *out++ = static_cast('\\'); *out++ = static_cast(prefix); Char buf[width]; fill_n(buf, width, static_cast('0')); - format_base2e(4, buf, cp, width); - return copy(buf, buf + width, out); + format_uint<4>(buf, cp, width); + return copy_str(buf, buf + width, out); } template @@ -1744,9 +1940,13 @@ auto write_escaped_cp(OutputIt out, const find_escape_result& escape) *out++ = static_cast('\\'); c = static_cast('t'); break; - case '"': FMT_FALLTHROUGH; - case '\'': FMT_FALLTHROUGH; - case '\\': *out++ = static_cast('\\'); break; + case '"': + FMT_FALLTHROUGH; + case '\'': + FMT_FALLTHROUGH; + case '\\': + *out++ = static_cast('\\'); + break; default: if (escape.cp < 0x100) return write_codepoint<2, Char>(out, 'x', escape.cp); if (escape.cp < 0x10000) @@ -1771,7 +1971,7 @@ auto write_escaped_string(OutputIt out, basic_string_view str) auto begin = str.begin(), end = str.end(); do { auto escape = find_escape(begin, end); - out = copy(begin, escape.begin, out); + out = copy_str(begin, escape.begin, out); begin = escape.end; if (!begin) break; out = write_escaped_cp(out, escape); @@ -1798,23 +1998,74 @@ auto write_escaped_char(OutputIt out, Char v) -> OutputIt { template FMT_CONSTEXPR auto write_char(OutputIt out, Char value, - const format_specs& specs) -> OutputIt { - bool is_debug = specs.type() == presentation_type::debug; - return write_padded(out, specs, 1, [=](reserve_iterator it) { + const format_specs& specs) -> OutputIt { + bool is_debug = specs.type == presentation_type::debug; + return write_padded(out, specs, 1, [=](reserve_iterator it) { if (is_debug) return write_escaped_char(it, value); *it++ = value; return it; }); } template -FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs, - locale_ref loc = {}) -> OutputIt { +FMT_CONSTEXPR auto write(OutputIt out, Char value, + const format_specs& specs, locale_ref loc = {}) + -> OutputIt { // char is formatted as unsigned char for consistency across platforms. using unsigned_type = conditional_t::value, unsigned char, unsigned>; return check_char_specs(specs) - ? write_char(out, value, specs) - : write(out, static_cast(value), specs, loc); + ? write_char(out, value, specs) + : write(out, static_cast(value), specs, loc); +} + +// Data for write_int that doesn't depend on output iterator type. It is used to +// avoid template code bloat. +template struct write_int_data { + size_t size; + size_t padding; + + FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, + const format_specs& specs) + : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { + if (specs.align == align::numeric) { + auto width = to_unsigned(specs.width); + if (width > size) { + padding = width - size; + size = width; + } + } else if (specs.precision > num_digits) { + size = (prefix >> 24) + to_unsigned(specs.precision); + padding = to_unsigned(specs.precision - num_digits); + } + } +}; + +// Writes an integer in the format +// +// where are written by write_digits(it). +// prefix contains chars in three lower bytes and the size in the fourth byte. +template +FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits, + unsigned prefix, + const format_specs& specs, + W write_digits) -> OutputIt { + // Slightly faster check for specs.width == 0 && specs.precision == -1. + if ((specs.width | (specs.precision + 1)) == 0) { + auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); + if (prefix != 0) { + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast(p & 0xff); + } + return base_iterator(out, write_digits(it)); + } + auto data = write_int_data(num_digits, prefix, specs); + return write_padded( + out, specs, data.size, [=](reserve_iterator it) { + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast(p & 0xff); + it = detail::fill_n(it, data.padding, static_cast('0')); + return write_digits(it); + }); } template class digit_grouping { @@ -1839,9 +2090,7 @@ template class digit_grouping { } public: - template ::value)> - explicit digit_grouping(Locale loc, bool localized = true) { + explicit digit_grouping(locale_ref loc, bool localized = true) { if (!localized) return; auto sep = thousands_sep(loc); grouping_ = sep.grouping; @@ -1873,8 +2122,9 @@ template class digit_grouping { for (int i = 0, sep_index = static_cast(separators.size() - 1); i < num_digits; ++i) { if (num_digits - i == separators[sep_index]) { - out = copy(thousands_sep_.data(), - thousands_sep_.data() + thousands_sep_.size(), out); + out = + copy_str(thousands_sep_.data(), + thousands_sep_.data() + thousands_sep_.size(), out); --sep_index; } *out++ = static_cast(digits[to_unsigned(i)]); @@ -1891,45 +2141,54 @@ FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { // Writes a decimal integer with digit grouping. template auto write_int(OutputIt out, UInt value, unsigned prefix, - const format_specs& specs, const digit_grouping& grouping) - -> OutputIt { + const format_specs& specs, + const digit_grouping& grouping) -> OutputIt { static_assert(std::is_same, UInt>::value, ""); int num_digits = 0; auto buffer = memory_buffer(); - switch (specs.type()) { - default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH; + switch (specs.type) { case presentation_type::none: - case presentation_type::dec: + case presentation_type::dec: { num_digits = count_digits(value); format_decimal(appender(buffer), value, num_digits); break; - case presentation_type::hex: - if (specs.alt()) - prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0'); + } + case presentation_type::hex_lower: + case presentation_type::hex_upper: { + bool upper = specs.type == presentation_type::hex_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); num_digits = count_digits<4>(value); - format_base2e(4, appender(buffer), value, num_digits, specs.upper()); + format_uint<4, char>(appender(buffer), value, num_digits, upper); break; - case presentation_type::oct: + } + case presentation_type::bin_lower: + case presentation_type::bin_upper: { + bool upper = specs.type == presentation_type::bin_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); + num_digits = count_digits<1>(value); + format_uint<1, char>(appender(buffer), value, num_digits); + break; + } + case presentation_type::oct: { num_digits = count_digits<3>(value); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. - if (specs.alt() && specs.precision <= num_digits && value != 0) + if (specs.alt && specs.precision <= num_digits && value != 0) prefix_append(prefix, '0'); - format_base2e(3, appender(buffer), value, num_digits); - break; - case presentation_type::bin: - if (specs.alt()) - prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0'); - num_digits = count_digits<1>(value); - format_base2e(1, appender(buffer), value, num_digits); + format_uint<3, char>(appender(buffer), value, num_digits); break; + } case presentation_type::chr: - return write_char(out, static_cast(value), specs); + return write_char(out, static_cast(value), specs); + default: + throw_format_error("invalid format specifier"); } unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) + to_unsigned(grouping.count_separators(num_digits)); - return write_padded( + return write_padded( out, specs, size, size, [&](reserve_iterator it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast(p & 0xff); @@ -1937,13 +2196,11 @@ auto write_int(OutputIt out, UInt value, unsigned prefix, }); } -#if FMT_USE_LOCALE // Writes a localized value. -FMT_API auto write_loc(appender out, loc_value value, const format_specs& specs, - locale_ref loc) -> bool; -#endif -template -inline auto write_loc(OutputIt, const loc_value&, const format_specs&, +FMT_API auto write_loc(appender out, loc_value value, + const format_specs<>& specs, locale_ref loc) -> bool; +template +inline auto write_loc(OutputIt, loc_value, const format_specs&, locale_ref) -> bool { return false; } @@ -1954,7 +2211,7 @@ template struct write_int_arg { }; template -FMT_CONSTEXPR auto make_write_int_arg(T value, sign s) +FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign) -> write_int_arg> { auto prefix = 0u; auto abs_value = static_cast>(value); @@ -1964,21 +2221,21 @@ FMT_CONSTEXPR auto make_write_int_arg(T value, sign s) } else { constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '}; - prefix = prefixes[static_cast(s)]; + prefix = prefixes[sign]; } return {abs_value, prefix}; } template struct loc_writer { - basic_appender out; - const format_specs& specs; + buffer_appender out; + const format_specs& specs; std::basic_string sep; std::string grouping; std::basic_string decimal_point; template ::value)> auto operator()(T value) -> bool { - auto arg = make_write_int_arg(value, specs.sign()); + auto arg = make_write_int_arg(value, specs.sign); write_int(out, static_cast>(arg.abs_value), arg.prefix, specs, digit_grouping(grouping, sep)); return true; @@ -1990,162 +2247,167 @@ template struct loc_writer { } }; -// Size and padding computation separate from write_int to avoid template bloat. -struct size_padding { - unsigned size; - unsigned padding; - - FMT_CONSTEXPR size_padding(int num_digits, unsigned prefix, - const format_specs& specs) - : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { - if (specs.align() == align::numeric) { - auto width = to_unsigned(specs.width); - if (width > size) { - padding = width - size; - size = width; - } - } else if (specs.precision > num_digits) { - size = (prefix >> 24) + to_unsigned(specs.precision); - padding = to_unsigned(specs.precision - num_digits); - } - } -}; - template FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg arg, - const format_specs& specs) -> OutputIt { + const format_specs& specs, + locale_ref) -> OutputIt { static_assert(std::is_same>::value, ""); - - constexpr int buffer_size = num_bits(); - char buffer[buffer_size]; - if (is_constant_evaluated()) fill_n(buffer, buffer_size, '\0'); - const char* begin = nullptr; - const char* end = buffer + buffer_size; - auto abs_value = arg.abs_value; auto prefix = arg.prefix; - switch (specs.type()) { - default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH; + switch (specs.type) { case presentation_type::none: - case presentation_type::dec: - begin = do_format_decimal(buffer, abs_value, buffer_size); - break; - case presentation_type::hex: - begin = do_format_base2e(4, buffer, abs_value, buffer_size, specs.upper()); - if (specs.alt()) - prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0'); - break; + case presentation_type::dec: { + auto num_digits = count_digits(abs_value); + return write_int( + out, num_digits, prefix, specs, [=](reserve_iterator it) { + return format_decimal(it, abs_value, num_digits).end; + }); + } + case presentation_type::hex_lower: + case presentation_type::hex_upper: { + bool upper = specs.type == presentation_type::hex_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); + int num_digits = count_digits<4>(abs_value); + return write_int( + out, num_digits, prefix, specs, [=](reserve_iterator it) { + return format_uint<4, Char>(it, abs_value, num_digits, upper); + }); + } + case presentation_type::bin_lower: + case presentation_type::bin_upper: { + bool upper = specs.type == presentation_type::bin_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); + int num_digits = count_digits<1>(abs_value); + return write_int(out, num_digits, prefix, specs, + [=](reserve_iterator it) { + return format_uint<1, Char>(it, abs_value, num_digits); + }); + } case presentation_type::oct: { - begin = do_format_base2e(3, buffer, abs_value, buffer_size); + int num_digits = count_digits<3>(abs_value); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. - auto num_digits = end - begin; - if (specs.alt() && specs.precision <= num_digits && abs_value != 0) + if (specs.alt && specs.precision <= num_digits && abs_value != 0) prefix_append(prefix, '0'); - break; + return write_int(out, num_digits, prefix, specs, + [=](reserve_iterator it) { + return format_uint<3, Char>(it, abs_value, num_digits); + }); } - case presentation_type::bin: - begin = do_format_base2e(1, buffer, abs_value, buffer_size); - if (specs.alt()) - prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0'); - break; case presentation_type::chr: - return write_char(out, static_cast(abs_value), specs); + return write_char(out, static_cast(abs_value), specs); + default: + throw_format_error("invalid format specifier"); } - - // Write an integer in the format - // - // prefix contains chars in three lower bytes and the size in the fourth byte. - int num_digits = static_cast(end - begin); - // Slightly faster check for specs.width == 0 && specs.precision == -1. - if ((specs.width | (specs.precision + 1)) == 0) { - auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); - for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) - *it++ = static_cast(p & 0xff); - return base_iterator(out, copy(begin, end, it)); - } - auto sp = size_padding(num_digits, prefix, specs); - unsigned padding = sp.padding; - return write_padded( - out, specs, sp.size, [=](reserve_iterator it) { - for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) - *it++ = static_cast(p & 0xff); - it = detail::fill_n(it, padding, static_cast('0')); - return copy(begin, end, it); - }); + return out; } - template -FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out, - write_int_arg arg, - const format_specs& specs) - -> OutputIt { - return write_int(out, arg, specs); +FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline( + OutputIt out, write_int_arg arg, const format_specs& specs, + locale_ref loc) -> OutputIt { + return write_int(out, arg, specs, loc); } - -template ::value && !std::is_same::value && - !std::is_same::value)> -FMT_CONSTEXPR FMT_INLINE auto write(basic_appender out, T value, - const format_specs& specs, locale_ref loc) - -> basic_appender { - if (specs.localized() && write_loc(out, value, specs, loc)) return out; - return write_int_noinline(out, make_write_int_arg(value, specs.sign()), - specs); + std::is_same>::value)> +FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, + const format_specs& specs, + locale_ref loc) -> OutputIt { + if (specs.localized && write_loc(out, value, specs, loc)) return out; + return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs, + loc); } - // An inlined version of write used in format string compilation. template ::value && !std::is_same::value && - !std::is_same::value && - !std::is_same>::value)> + !std::is_same>::value)> FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, - const format_specs& specs, locale_ref loc) - -> OutputIt { - if (specs.localized() && write_loc(out, value, specs, loc)) return out; - return write_int(out, make_write_int_arg(value, specs.sign()), specs); + const format_specs& specs, + locale_ref loc) -> OutputIt { + if (specs.localized && write_loc(out, value, specs, loc)) return out; + return write_int(out, make_write_int_arg(value, specs.sign), specs, loc); } +// An output iterator that counts the number of objects written to it and +// discards them. +class counting_iterator { + private: + size_t count_; + + public: + using iterator_category = std::output_iterator_tag; + using difference_type = std::ptrdiff_t; + using pointer = void; + using reference = void; + FMT_UNCHECKED_ITERATOR(counting_iterator); + + struct value_type { + template FMT_CONSTEXPR void operator=(const T&) {} + }; + + FMT_CONSTEXPR counting_iterator() : count_(0) {} + + FMT_CONSTEXPR auto count() const -> size_t { return count_; } + + FMT_CONSTEXPR auto operator++() -> counting_iterator& { + ++count_; + return *this; + } + FMT_CONSTEXPR auto operator++(int) -> counting_iterator { + auto it = *this; + ++*this; + return it; + } + + FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n) + -> counting_iterator { + it.count_ += static_cast(n); + return it; + } + + FMT_CONSTEXPR auto operator*() const -> value_type { return {}; } +}; + template FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, - const format_specs& specs) -> OutputIt { + const format_specs& specs) -> OutputIt { auto data = s.data(); auto size = s.size(); if (specs.precision >= 0 && to_unsigned(specs.precision) < size) size = code_point_index(s, to_unsigned(specs.precision)); - - bool is_debug = specs.type() == presentation_type::debug; - if (is_debug) { - auto buf = counting_buffer(); - write_escaped_string(basic_appender(buf), s); - size = buf.count(); - } - + bool is_debug = specs.type == presentation_type::debug; size_t width = 0; if (specs.width != 0) { - width = - is_debug ? size : compute_width(basic_string_view(data, size)); + if (is_debug) + width = write_escaped_string(counting_iterator{}, s).count(); + else + width = compute_width(basic_string_view(data, size)); } - return write_padded( - out, specs, size, width, [=](reserve_iterator it) { - return is_debug ? write_escaped_string(it, s) - : copy(data, data + size, it); - }); + return write_padded(out, specs, size, width, + [=](reserve_iterator it) { + if (is_debug) return write_escaped_string(it, s); + return copy_str(data, data + size, it); + }); } template -FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, - const format_specs& specs, locale_ref) -> OutputIt { - return write(out, s, specs); +FMT_CONSTEXPR auto write(OutputIt out, + basic_string_view> s, + const format_specs& specs, locale_ref) + -> OutputIt { + return write(out, s, specs); } template -FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs, - locale_ref) -> OutputIt { - if (specs.type() == presentation_type::pointer) +FMT_CONSTEXPR auto write(OutputIt out, const Char* s, + const format_specs& specs, locale_ref) + -> OutputIt { + if (specs.type == presentation_type::pointer) return write_ptr(out, bit_cast(s), &specs); - if (!s) report_error("string pointer is null"); - return write(out, basic_string_view(s), specs, {}); + if (!s) throw_format_error("string pointer is null"); + return write(out, basic_string_view(s), specs, {}); } template OutputIt { if (negative) abs_value = ~abs_value + 1; int num_digits = count_digits(abs_value); auto size = (negative ? 1 : 0) + static_cast(num_digits); - if (auto ptr = to_pointer(out, size)) { + auto it = reserve(out, size); + if (auto ptr = to_pointer(it, size)) { if (negative) *ptr++ = static_cast('-'); format_decimal(ptr, abs_value, num_digits); return out; } - if (negative) *out++ = static_cast('-'); - return format_decimal(out, abs_value, num_digits); + if (negative) *it++ = static_cast('-'); + it = format_decimal(it, abs_value, num_digits).end; + return base_iterator(out, it); } +// DEPRECATED! template FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, - format_specs& specs) -> const Char* { + format_specs& specs) -> const Char* { FMT_ASSERT(begin != end, ""); - auto alignment = align::none; + auto align = align::none; auto p = begin + code_point_length(begin); if (end - p <= 0) p = begin; for (;;) { switch (to_ascii(*p)) { - case '<': alignment = align::left; break; - case '>': alignment = align::right; break; - case '^': alignment = align::center; break; + case '<': + align = align::left; + break; + case '>': + align = align::right; + break; + case '^': + align = align::center; + break; } - if (alignment != align::none) { + if (align != align::none) { if (p != begin) { auto c = *begin; if (c == '}') return begin; if (c == '{') { - report_error("invalid fill character '{'"); + throw_format_error("invalid fill character '{'"); return begin; } - specs.set_fill(basic_string_view(begin, to_unsigned(p - begin))); + specs.fill = {begin, to_unsigned(p - begin)}; begin = p + 1; } else { ++begin; @@ -2200,27 +2471,88 @@ FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, } p = begin; } - specs.set_align(alignment); + specs.align = align; return begin; } +// A floating-point presentation format. +enum class float_format : unsigned char { + general, // General: exponent notation or fixed point based on magnitude. + exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3. + fixed, // Fixed point with the default precision of 6, e.g. 0.0012. + hex +}; + +struct float_specs { + int precision; + float_format format : 8; + sign_t sign : 8; + bool upper : 1; + bool locale : 1; + bool binary32 : 1; + bool showpoint : 1; +}; + +template +FMT_CONSTEXPR auto parse_float_type_spec(const format_specs& specs) + -> float_specs { + auto result = float_specs(); + result.showpoint = specs.alt; + result.locale = specs.localized; + switch (specs.type) { + case presentation_type::none: + result.format = float_format::general; + break; + case presentation_type::general_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::general_lower: + result.format = float_format::general; + break; + case presentation_type::exp_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::exp_lower: + result.format = float_format::exp; + result.showpoint |= specs.precision != 0; + break; + case presentation_type::fixed_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::fixed_lower: + result.format = float_format::fixed; + result.showpoint |= specs.precision != 0; + break; + case presentation_type::hexfloat_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::hexfloat_lower: + result.format = float_format::hex; + break; + default: + throw_format_error("invalid format specifier"); + break; + } + return result; +} + template FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, - format_specs specs, sign s) -> OutputIt { + format_specs specs, + const float_specs& fspecs) -> OutputIt { auto str = - isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf"); + isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf"); constexpr size_t str_size = 3; - auto size = str_size + (s != sign::none ? 1 : 0); + auto sign = fspecs.sign; + auto size = str_size + (sign ? 1 : 0); // Replace '0'-padding with space for non-finite values. const bool is_zero_fill = - specs.fill_size() == 1 && specs.fill_unit() == '0'; - if (is_zero_fill) specs.set_fill(' '); - return write_padded(out, specs, size, - [=](reserve_iterator it) { - if (s != sign::none) - *it++ = detail::getsign(s); - return copy(str, str + str_size, it); - }); + specs.fill.size() == 1 && *specs.fill.data() == static_cast('0'); + if (is_zero_fill) specs.fill[0] = static_cast(' '); + return write_padded(out, specs, size, [=](reserve_iterator it) { + if (sign) *it++ = detail::sign(sign); + return copy_str(str, str + str_size, it); + }); } // A decimal floating-point number significand * pow(10, exp). @@ -2241,12 +2573,12 @@ inline auto get_significand_size(const dragonbox::decimal_fp& f) -> int { template constexpr auto write_significand(OutputIt out, const char* significand, int significand_size) -> OutputIt { - return copy(significand, significand + significand_size, out); + return copy_str(significand, significand + significand_size, out); } template inline auto write_significand(OutputIt out, UInt significand, int significand_size) -> OutputIt { - return format_decimal(out, significand, significand_size); + return format_decimal(out, significand, significand_size).end; } template FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, @@ -2266,13 +2598,14 @@ template ::value)> inline auto write_significand(Char* out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char* { - if (!decimal_point) return format_decimal(out, significand, significand_size); + if (!decimal_point) + return format_decimal(out, significand, significand_size).end; out += significand_size + 1; Char* end = out; int floating_size = significand_size - integral_size; for (int i = floating_size / 2; i > 0; --i) { out -= 2; - write2digits(out, static_cast(significand % 100)); + copy2(out, digits2(static_cast(significand % 100))); significand /= 100; } if (floating_size % 2 != 0) { @@ -2293,19 +2626,19 @@ inline auto write_significand(OutputIt out, UInt significand, Char buffer[digits10() + 2]; auto end = write_significand(buffer, significand, significand_size, integral_size, decimal_point); - return detail::copy_noinline(buffer, end, out); + return detail::copy_str_noinline(buffer, end, out); } template FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { - out = detail::copy_noinline(significand, significand + integral_size, - out); + out = detail::copy_str_noinline(significand, + significand + integral_size, out); if (!decimal_point) return out; *out++ = decimal_point; - return detail::copy_noinline(significand + integral_size, - significand + significand_size, out); + return detail::copy_str_noinline(significand + integral_size, + significand + significand_size, out); } template @@ -2318,42 +2651,44 @@ FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, decimal_point); } auto buffer = basic_memory_buffer(); - write_significand(basic_appender(buffer), significand, significand_size, - integral_size, decimal_point); + write_significand(buffer_appender(buffer), significand, + significand_size, integral_size, decimal_point); grouping.apply( out, basic_string_view(buffer.data(), to_unsigned(integral_size))); - return detail::copy_noinline(buffer.data() + integral_size, - buffer.end(), out); + return detail::copy_str_noinline(buffer.data() + integral_size, + buffer.end(), out); } -template > FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, - const format_specs& specs, sign s, - locale_ref loc) -> OutputIt { + const format_specs& specs, + float_specs fspecs, locale_ref loc) + -> OutputIt { auto significand = f.significand; int significand_size = get_significand_size(f); const Char zero = static_cast('0'); - size_t size = to_unsigned(significand_size) + (s != sign::none ? 1 : 0); + auto sign = fspecs.sign; + size_t size = to_unsigned(significand_size) + (sign ? 1 : 0); using iterator = reserve_iterator; - Char decimal_point = specs.localized() ? detail::decimal_point(loc) - : static_cast('.'); + Char decimal_point = + fspecs.locale ? detail::decimal_point(loc) : static_cast('.'); int output_exp = f.exponent + significand_size - 1; auto use_exp_format = [=]() { - if (specs.type() == presentation_type::exp) return true; - if (specs.type() == presentation_type::fixed) return false; + if (fspecs.format == float_format::exp) return true; + if (fspecs.format != float_format::general) return false; // Use the fixed notation if the exponent is in [exp_lower, exp_upper), // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. const int exp_lower = -4, exp_upper = 16; return output_exp < exp_lower || - output_exp >= (specs.precision > 0 ? specs.precision : exp_upper); + output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper); }; if (use_exp_format()) { int num_zeros = 0; - if (specs.alt()) { - num_zeros = specs.precision - significand_size; + if (fspecs.showpoint) { + num_zeros = fspecs.precision - significand_size; if (num_zeros < 0) num_zeros = 0; size += to_unsigned(num_zeros); } else if (significand_size == 1) { @@ -2364,9 +2699,9 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3; size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits); - char exp_char = specs.upper() ? 'E' : 'e'; + char exp_char = fspecs.upper ? 'E' : 'e'; auto write = [=](iterator it) { - if (s != sign::none) *it++ = detail::getsign(s); + if (sign) *it++ = detail::sign(sign); // Insert a decimal point after the first digit and add an exponent. it = write_significand(it, significand, significand_size, 1, decimal_point); @@ -2374,41 +2709,39 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, *it++ = static_cast(exp_char); return write_exponent(output_exp, it); }; - return specs.width > 0 - ? write_padded(out, specs, size, write) - : base_iterator(out, write(reserve(out, size))); + return specs.width > 0 ? write_padded(out, specs, size, write) + : base_iterator(out, write(reserve(out, size))); } int exp = f.exponent + significand_size; if (f.exponent >= 0) { // 1234e5 -> 123400000[.0+] size += to_unsigned(f.exponent); - int num_zeros = specs.precision - exp; + int num_zeros = fspecs.precision - exp; abort_fuzzing_if(num_zeros > 5000); - if (specs.alt()) { + if (fspecs.showpoint) { ++size; - if (num_zeros <= 0 && specs.type() != presentation_type::fixed) - num_zeros = 0; + if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0; if (num_zeros > 0) size += to_unsigned(num_zeros); } - auto grouping = Grouping(loc, specs.localized()); + auto grouping = Grouping(loc, fspecs.locale); size += to_unsigned(grouping.count_separators(exp)); - return write_padded(out, specs, size, [&](iterator it) { - if (s != sign::none) *it++ = detail::getsign(s); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); it = write_significand(it, significand, significand_size, f.exponent, grouping); - if (!specs.alt()) return it; + if (!fspecs.showpoint) return it; *it++ = decimal_point; return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; }); } else if (exp > 0) { // 1234e-2 -> 12.34[0+] - int num_zeros = specs.alt() ? specs.precision - significand_size : 0; - size += 1 + static_cast(max_of(num_zeros, 0)); - auto grouping = Grouping(loc, specs.localized()); + int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0; + size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0); + auto grouping = Grouping(loc, fspecs.locale); size += to_unsigned(grouping.count_separators(exp)); - return write_padded(out, specs, size, [&](iterator it) { - if (s != sign::none) *it++ = detail::getsign(s); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); it = write_significand(it, significand, significand_size, exp, decimal_point, grouping); return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; @@ -2416,14 +2749,14 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, } // 1234e-6 -> 0.001234 int num_zeros = -exp; - if (significand_size == 0 && specs.precision >= 0 && - specs.precision < num_zeros) { - num_zeros = specs.precision; + if (significand_size == 0 && fspecs.precision >= 0 && + fspecs.precision < num_zeros) { + num_zeros = fspecs.precision; } - bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt(); + bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint; size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros); - return write_padded(out, specs, size, [&](iterator it) { - if (s != sign::none) *it++ = detail::getsign(s); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); *it++ = zero; if (!pointy) return it; *it++ = decimal_point; @@ -2446,20 +2779,22 @@ template class fallback_digit_grouping { } }; -template +template FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, - const format_specs& specs, sign s, - locale_ref loc) -> OutputIt { + const format_specs& specs, + float_specs fspecs, locale_ref loc) + -> OutputIt { if (is_constant_evaluated()) { - return do_write_float>(out, f, specs, s, loc); + return do_write_float>(out, f, specs, fspecs, + loc); } else { - return do_write_float(out, f, specs, s, loc); + return do_write_float(out, f, specs, fspecs, loc); } } template constexpr auto isnan(T value) -> bool { - return value != value; // std::isnan doesn't support __float128. + return !(value >= value); // std::isnan doesn't support __float128. } template @@ -2507,48 +2842,52 @@ inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { class bigint { private: - // A bigint is a number in the form bigit_[N - 1] ... bigit_[0] * 32^exp_. - using bigit = uint32_t; // A big digit. + // A bigint is stored as an array of bigits (big digits), with bigit at index + // 0 being the least significant one. + using bigit = uint32_t; using double_bigit = uint64_t; - enum { bigit_bits = num_bits() }; enum { bigits_capacity = 32 }; basic_memory_buffer bigits_; int exp_; - friend struct formatter; - - FMT_CONSTEXPR auto get_bigit(int i) const -> bigit { - return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0; + FMT_CONSTEXPR20 auto operator[](int index) const -> bigit { + return bigits_[to_unsigned(index)]; + } + FMT_CONSTEXPR20 auto operator[](int index) -> bigit& { + return bigits_[to_unsigned(index)]; } - FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) { - auto result = double_bigit(bigits_[index]) - other - borrow; - bigits_[index] = static_cast(result); + static constexpr const int bigit_bits = num_bits(); + + friend struct formatter; + + FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) { + auto result = static_cast((*this)[index]) - other - borrow; + (*this)[index] = static_cast(result); borrow = static_cast(result >> (bigit_bits * 2 - 1)); } - FMT_CONSTEXPR void remove_leading_zeros() { + FMT_CONSTEXPR20 void remove_leading_zeros() { int num_bigits = static_cast(bigits_.size()) - 1; - while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits; + while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits; bigits_.resize(to_unsigned(num_bigits + 1)); } // Computes *this -= other assuming aligned bigints and *this >= other. - FMT_CONSTEXPR void subtract_aligned(const bigint& other) { + FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) { FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); FMT_ASSERT(compare(*this, other) >= 0, ""); bigit borrow = 0; int i = other.exp_ - exp_; for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) subtract_bigits(i, other.bigits_[j], borrow); - if (borrow != 0) subtract_bigits(i, 0, borrow); - FMT_ASSERT(borrow == 0, ""); + while (borrow > 0) subtract_bigits(i, 0, borrow); remove_leading_zeros(); } - FMT_CONSTEXPR void multiply(uint32_t value) { - bigit carry = 0; + FMT_CONSTEXPR20 void multiply(uint32_t value) { const double_bigit wide_value = value; + bigit carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { double_bigit result = bigits_[i] * wide_value + carry; bigits_[i] = static_cast(result); @@ -2559,7 +2898,7 @@ class bigint { template ::value || std::is_same::value)> - FMT_CONSTEXPR void multiply(UInt value) { + FMT_CONSTEXPR20 void multiply(UInt value) { using half_uint = conditional_t::value, uint64_t, uint32_t>; const int shift = num_bits() - bigit_bits; @@ -2580,7 +2919,7 @@ class bigint { template ::value || std::is_same::value)> - FMT_CONSTEXPR void assign(UInt n) { + FMT_CONSTEXPR20 void assign(UInt n) { size_t num_bigits = 0; do { bigits_[num_bigits++] = static_cast(n); @@ -2591,30 +2930,30 @@ class bigint { } public: - FMT_CONSTEXPR bigint() : exp_(0) {} + FMT_CONSTEXPR20 bigint() : exp_(0) {} explicit bigint(uint64_t n) { assign(n); } bigint(const bigint&) = delete; void operator=(const bigint&) = delete; - FMT_CONSTEXPR void assign(const bigint& other) { + FMT_CONSTEXPR20 void assign(const bigint& other) { auto size = other.bigits_.size(); bigits_.resize(size); auto data = other.bigits_.data(); - copy(data, data + size, bigits_.data()); + copy_str(data, data + size, bigits_.data()); exp_ = other.exp_; } - template FMT_CONSTEXPR void operator=(Int n) { + template FMT_CONSTEXPR20 void operator=(Int n) { FMT_ASSERT(n > 0, ""); assign(uint64_or_128_t(n)); } - FMT_CONSTEXPR auto num_bigits() const -> int { + FMT_CONSTEXPR20 auto num_bigits() const -> int { return static_cast(bigits_.size()) + exp_; } - FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& { + FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& { FMT_ASSERT(shift >= 0, ""); exp_ += shift / bigit_bits; shift %= bigit_bits; @@ -2629,39 +2968,49 @@ class bigint { return *this; } - template FMT_CONSTEXPR auto operator*=(Int value) -> bigint& { + template + FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& { FMT_ASSERT(value > 0, ""); multiply(uint32_or_64_or_128_t(value)); return *this; } - friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int { - int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits(); - if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1; - int i = static_cast(b1.bigits_.size()) - 1; - int j = static_cast(b2.bigits_.size()) - 1; + friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs) + -> int { + int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits(); + if (num_lhs_bigits != num_rhs_bigits) + return num_lhs_bigits > num_rhs_bigits ? 1 : -1; + int i = static_cast(lhs.bigits_.size()) - 1; + int j = static_cast(rhs.bigits_.size()) - 1; int end = i - j; if (end < 0) end = 0; for (; i >= end; --i, --j) { - bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j]; - if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1; + bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j]; + if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1; } if (i != j) return i > j ? 1 : -1; return 0; } // Returns compare(lhs1 + lhs2, rhs). - friend FMT_CONSTEXPR auto add_compare(const bigint& lhs1, const bigint& lhs2, - const bigint& rhs) -> int { - int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits()); + friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1, + const bigint& lhs2, const bigint& rhs) + -> int { + auto minimum = [](int a, int b) { return a < b ? a : b; }; + auto maximum = [](int a, int b) { return a > b ? a : b; }; + int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits()); int num_rhs_bigits = rhs.num_bigits(); if (max_lhs_bigits + 1 < num_rhs_bigits) return -1; if (max_lhs_bigits > num_rhs_bigits) return 1; + auto get_bigit = [](const bigint& n, int i) -> bigit { + return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0; + }; double_bigit borrow = 0; - int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_); + int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_); for (int i = num_rhs_bigits - 1; i >= min_exp; --i) { - double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i); - bigit rhs_bigit = rhs.get_bigit(i); + double_bigit sum = + static_cast(get_bigit(lhs1, i)) + get_bigit(lhs2, i); + bigit rhs_bigit = get_bigit(rhs, i); if (sum > rhs_bigit + borrow) return 1; borrow = rhs_bigit + borrow - sum; if (borrow > 1) return -1; @@ -2674,8 +3023,10 @@ class bigint { FMT_CONSTEXPR20 void assign_pow10(int exp) { FMT_ASSERT(exp >= 0, ""); if (exp == 0) return *this = 1; - int bitmask = 1 << (num_bits() - - countl_zero(static_cast(exp)) - 1); + // Find the top bit. + int bitmask = 1; + while (exp >= bitmask) bitmask <<= 1; + bitmask >>= 1; // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by // repeated squaring and multiplication. *this = 5; @@ -2699,17 +3050,17 @@ class bigint { // cross-product terms n[i] * n[j] such that i + j == bigit_index. for (int i = 0, j = bigit_index; j >= 0; ++i, --j) { // Most terms are multiplied twice which can be optimized in the future. - sum += double_bigit(n[i]) * n[j]; + sum += static_cast(n[i]) * n[j]; } - bigits_[bigit_index] = static_cast(sum); + (*this)[bigit_index] = static_cast(sum); sum >>= num_bits(); // Compute the carry. } // Do the same for the top half. for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index) { for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;) - sum += double_bigit(n[i++]) * n[j--]; - bigits_[bigit_index] = static_cast(sum); + sum += static_cast(n[i++]) * n[j--]; + (*this)[bigit_index] = static_cast(sum); sum >>= num_bits(); } remove_leading_zeros(); @@ -2718,20 +3069,20 @@ class bigint { // If this bigint has a bigger exponent than other, adds trailing zero to make // exponents equal. This simplifies some operations such as subtraction. - FMT_CONSTEXPR void align(const bigint& other) { + FMT_CONSTEXPR20 void align(const bigint& other) { int exp_difference = exp_ - other.exp_; if (exp_difference <= 0) return; int num_bigits = static_cast(bigits_.size()); bigits_.resize(to_unsigned(num_bigits + exp_difference)); for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) bigits_[j] = bigits_[i]; - memset(bigits_.data(), 0, to_unsigned(exp_difference) * sizeof(bigit)); + std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u); exp_ -= exp_difference; } // Divides this bignum by divisor, assigning the remainder to this and // returning the quotient. - FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int { + FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int { FMT_ASSERT(this != &divisor, ""); if (compare(*this, divisor) < 0) return 0; FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); @@ -2850,11 +3201,8 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp value, // Generate the given number of digits. exp10 -= num_digits - 1; if (num_digits <= 0) { - auto digit = '0'; - if (num_digits == 0) { - denominator *= 10; - digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; - } + denominator *= 10; + auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; buf.push_back(digit); return; } @@ -2891,8 +3239,8 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp value, // Formats a floating-point number using the hexfloat format. template ::value)> -FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, - buffer& buf) { +FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, + float_specs specs, buffer& buf) { // float is passed as double to reduce the number of instantiations and to // simplify implementation. static_assert(!std::is_same::value, ""); @@ -2902,25 +3250,26 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, // Assume Float is in the format [sign][exponent][significand]. using carrier_uint = typename info::carrier_uint; - const auto num_float_significand_bits = detail::num_significand_bits(); + constexpr auto num_float_significand_bits = + detail::num_significand_bits(); basic_fp f(value); f.e += num_float_significand_bits; if (!has_implicit_bit()) --f.e; - const auto num_fraction_bits = + constexpr auto num_fraction_bits = num_float_significand_bits + (has_implicit_bit() ? 1 : 0); - const auto num_xdigits = (num_fraction_bits + 3) / 4; + constexpr auto num_xdigits = (num_fraction_bits + 3) / 4; - const auto leading_shift = ((num_xdigits - 1) * 4); + constexpr auto leading_shift = ((num_xdigits - 1) * 4); const auto leading_mask = carrier_uint(0xF) << leading_shift; const auto leading_xdigit = static_cast((f.f & leading_mask) >> leading_shift); if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1); int print_xdigits = num_xdigits - 1; - if (specs.precision >= 0 && print_xdigits > specs.precision) { - const int shift = ((print_xdigits - specs.precision - 1) * 4); + if (precision >= 0 && print_xdigits > precision) { + const int shift = ((print_xdigits - precision - 1) * 4); const auto mask = carrier_uint(0xF) << shift; const auto v = static_cast((f.f & mask) >> shift); @@ -2939,25 +3288,25 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, } } - print_xdigits = specs.precision; + print_xdigits = precision; } char xdigits[num_bits() / 4]; detail::fill_n(xdigits, sizeof(xdigits), '0'); - format_base2e(4, xdigits, f.f, num_xdigits, specs.upper()); + format_uint<4>(xdigits, f.f, num_xdigits, specs.upper); // Remove zero tail while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits; buf.push_back('0'); - buf.push_back(specs.upper() ? 'X' : 'x'); + buf.push_back(specs.upper ? 'X' : 'x'); buf.push_back(xdigits[0]); - if (specs.alt() || print_xdigits > 0 || print_xdigits < specs.precision) + if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision) buf.push_back('.'); buf.append(xdigits + 1, xdigits + 1 + print_xdigits); - for (; print_xdigits < specs.precision; ++print_xdigits) buf.push_back('0'); + for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0'); - buf.push_back(specs.upper() ? 'P' : 'p'); + buf.push_back(specs.upper ? 'P' : 'p'); uint32_t abs_e; if (f.e < 0) { @@ -2971,9 +3320,9 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, } template ::value)> -FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, - buffer& buf) { - format_hexfloat(static_cast(value), specs, buf); +FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, + float_specs specs, buffer& buf) { + format_hexfloat(static_cast(value), precision, specs, buf); } constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t { @@ -2988,15 +3337,15 @@ constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t { } template -FMT_CONSTEXPR20 auto format_float(Float value, int precision, - const format_specs& specs, bool binary32, +FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, buffer& buf) -> int { // float is passed as double to reduce the number of instantiations. static_assert(!std::is_same::value, ""); + FMT_ASSERT(value >= 0, "value is negative"); auto converted_value = convert_float(value); - const bool fixed = specs.type() == presentation_type::fixed; - if (value == 0) { + const bool fixed = specs.format == float_format::fixed; + if (value <= 0) { // <= instead of == to silence a warning. if (precision <= 0 || !fixed) { buf.push_back('0'); return 0; @@ -3021,6 +3370,16 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, exp = static_cast(e); if (e > exp) ++exp; // Compute ceil. dragon_flags = dragon::fixup; + } else if (precision < 0) { + // Use Dragonbox for the shortest format. + if (specs.binary32) { + auto dec = dragonbox::to_decimal(static_cast(value)); + write(buffer_appender(buf), dec.significand); + return dec.exponent; + } + auto dec = dragonbox::to_decimal(static_cast(value)); + write(buffer_appender(buf), dec.significand); + return dec.exponent; } else { // Extract significand bits and exponent bits. using info = dragonbox::float_info; @@ -3119,7 +3478,7 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, uint64_t prod; uint32_t digits; bool should_round_up; - int number_of_digits_to_print = min_of(precision, 9); + int number_of_digits_to_print = precision > 9 ? 9 : precision; // Print a 9-digits subsegment, either the first or the second. auto print_subsegment = [&](uint32_t subsegment, char* buffer) { @@ -3147,7 +3506,7 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, // for details. prod = ((subsegment * static_cast(450359963)) >> 20) + 1; digits = static_cast(prod >> 32); - write2digits(buffer, digits); + copy2(buffer, digits2(digits)); number_of_digits_printed += 2; } @@ -3155,7 +3514,7 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, while (number_of_digits_printed < number_of_digits_to_print) { prod = static_cast(prod) * static_cast(100); digits = static_cast(prod >> 32); - write2digits(buffer + number_of_digits_printed, digits); + copy2(buffer + number_of_digits_printed, digits2(digits)); number_of_digits_printed += 2; } }; @@ -3264,8 +3623,9 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, } if (use_dragon) { auto f = basic_fp(); - bool is_predecessor_closer = binary32 ? f.assign(static_cast(value)) - : f.assign(converted_value); + bool is_predecessor_closer = specs.binary32 + ? f.assign(static_cast(value)) + : f.assign(converted_value); if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer; if (fixed) dragon_flags |= dragon::fixed; // Limit precision to the maximum possible number of significant digits in @@ -3274,7 +3634,7 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, if (precision > max_double_digits) precision = max_double_digits; format_dragon(f, dragon_flags, precision, buf, exp); } - if (!fixed && !specs.alt()) { + if (!fixed && !specs.showpoint) { // Remove trailing zeros. auto num_digits = buf.size(); while (num_digits > 0 && buf[num_digits - 1] == '0') { @@ -3285,97 +3645,97 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, } return exp; } - template -FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs, - locale_ref loc) -> OutputIt { - // Use signbit because value < 0 is false for NaN. - sign s = detail::signbit(value) ? sign::minus : specs.sign(); +FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, + format_specs specs, locale_ref loc) + -> OutputIt { + float_specs fspecs = parse_float_type_spec(specs); + fspecs.sign = specs.sign; + if (detail::signbit(value)) { // value < 0 is false for NaN so use signbit. + fspecs.sign = sign::minus; + value = -value; + } else if (fspecs.sign == sign::minus) { + fspecs.sign = sign::none; + } if (!detail::isfinite(value)) - return write_nonfinite(out, detail::isnan(value), specs, s); + return write_nonfinite(out, detail::isnan(value), specs, fspecs); - if (specs.align() == align::numeric && s != sign::none) { - *out++ = detail::getsign(s); - s = sign::none; + if (specs.align == align::numeric && fspecs.sign) { + auto it = reserve(out, 1); + *it++ = detail::sign(fspecs.sign); + out = base_iterator(out, it); + fspecs.sign = sign::none; if (specs.width != 0) --specs.width; } - int precision = specs.precision; - if (precision < 0) { - if (specs.type() != presentation_type::none) { - precision = 6; - } else if (is_fast_float::value && !is_constant_evaluated()) { - // Use Dragonbox for the shortest format. - using floaty = conditional_t= sizeof(double), double, float>; - auto dec = dragonbox::to_decimal(static_cast(value)); - return write_float(out, dec, specs, s, loc); - } - } - memory_buffer buffer; - if (specs.type() == presentation_type::hexfloat) { - if (s != sign::none) buffer.push_back(detail::getsign(s)); - format_hexfloat(convert_float(value), specs, buffer); - return write_bytes(out, {buffer.data(), buffer.size()}, - specs); + if (fspecs.format == float_format::hex) { + if (fspecs.sign) buffer.push_back(detail::sign(fspecs.sign)); + format_hexfloat(convert_float(value), specs.precision, fspecs, buffer); + return write_bytes(out, {buffer.data(), buffer.size()}, + specs); } - - if (specs.type() == presentation_type::exp) { + int precision = specs.precision >= 0 || specs.type == presentation_type::none + ? specs.precision + : 6; + if (fspecs.format == float_format::exp) { if (precision == max_value()) - report_error("number is too big"); + throw_format_error("number is too big"); else ++precision; - if (specs.precision != 0) specs.set_alt(); - } else if (specs.type() == presentation_type::fixed) { - if (specs.precision != 0) specs.set_alt(); - } else if (precision == 0) { + } else if (fspecs.format != float_format::fixed && precision == 0) { precision = 1; } - int exp = format_float(convert_float(value), precision, specs, - std::is_same(), buffer); - - specs.precision = precision; + if (const_check(std::is_same())) fspecs.binary32 = true; + int exp = format_float(convert_float(value), precision, fspecs, buffer); + fspecs.precision = precision; auto f = big_decimal_fp{buffer.data(), static_cast(buffer.size()), exp}; - return write_float(out, f, specs, s, loc); + return write_float(out, f, specs, fspecs, loc); } template ::value)> -FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, +FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, locale_ref loc = {}) -> OutputIt { - return specs.localized() && write_loc(out, value, specs, loc) + if (const_check(!is_supported_floating_point(value))) return out; + return specs.localized && write_loc(out, value, specs, loc) ? out - : write_float(out, value, specs, loc); + : write_float(out, value, specs, loc); } template ::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { - if (is_constant_evaluated()) return write(out, value, format_specs()); + if (is_constant_evaluated()) return write(out, value, format_specs()); + if (const_check(!is_supported_floating_point(value))) return out; - auto s = detail::signbit(value) ? sign::minus : sign::none; + auto fspecs = float_specs(); + if (detail::signbit(value)) { + fspecs.sign = sign::minus; + value = -value; + } - constexpr auto specs = format_specs(); - using floaty = conditional_t= sizeof(double), double, float>; + constexpr auto specs = format_specs(); + using floaty = conditional_t::value, double, T>; using floaty_uint = typename dragonbox::float_info::carrier_uint; floaty_uint mask = exponent_mask(); if ((bit_cast(value) & mask) == mask) - return write_nonfinite(out, std::isnan(value), specs, s); + return write_nonfinite(out, std::isnan(value), specs, fspecs); auto dec = dragonbox::to_decimal(static_cast(value)); - return write_float(out, dec, specs, s, {}); + return write_float(out, dec, specs, fspecs, {}); } template ::value && !is_fast_float::value)> inline auto write(OutputIt out, T value) -> OutputIt { - return write(out, value, format_specs()); + return write(out, value, format_specs()); } template -auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) +auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) -> OutputIt { FMT_ASSERT(false, ""); return out; @@ -3384,11 +3744,13 @@ auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) template FMT_CONSTEXPR auto write(OutputIt out, basic_string_view value) -> OutputIt { - return copy_noinline(value.begin(), value.end(), out); + auto it = reserve(out, value.size()); + it = copy_str_noinline(value.begin(), value.end(), it); + return base_iterator(out, it); } template ::value)> + FMT_ENABLE_IF(is_string::value)> constexpr auto write(OutputIt out, const T& value) -> OutputIt { return write(out, to_string_view(value)); } @@ -3396,8 +3758,10 @@ constexpr auto write(OutputIt out, const T& value) -> OutputIt { // FMT_ENABLE_IF() condition separated to workaround an MSVC bug. template < typename Char, typename OutputIt, typename T, - bool check = std::is_enum::value && !std::is_same::value && - mapped_type_constant::value != type::custom_type, + bool check = + std::is_enum::value && !std::is_same::value && + mapped_type_constant>::value != + type::custom_type, FMT_ENABLE_IF(check)> FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { return write(out, static_cast>(value)); @@ -3405,12 +3769,13 @@ FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { template ::value)> -FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {}, - locale_ref = {}) -> OutputIt { - return specs.type() != presentation_type::none && - specs.type() != presentation_type::string - ? write(out, value ? 1 : 0, specs, {}) - : write_bytes(out, value ? "true" : "false", specs); +FMT_CONSTEXPR auto write(OutputIt out, T value, + const format_specs& specs = {}, locale_ref = {}) + -> OutputIt { + return specs.type != presentation_type::none && + specs.type != presentation_type::string + ? write(out, value ? 1 : 0, specs, {}) + : write_bytes(out, value ? "true" : "false", specs); } template @@ -3423,148 +3788,168 @@ FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt { template FMT_CONSTEXPR20 auto write(OutputIt out, const Char* value) -> OutputIt { if (value) return write(out, basic_string_view(value)); - report_error("string pointer is null"); + throw_format_error("string pointer is null"); return out; } template ::value)> -auto write(OutputIt out, const T* value, const format_specs& specs = {}, +auto write(OutputIt out, const T* value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return write_ptr(out, bit_cast(value), &specs); } +// A write overload that handles implicit conversions. template ::value == - type::custom_type && - !std::is_fundamental::value)> -FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> OutputIt { - auto f = formatter(); - auto parse_ctx = parse_context({}); - f.parse(parse_ctx); - auto ctx = basic_format_context(out, {}, {}); - return f.format(value, ctx); + typename Context = basic_format_context> +FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t< + std::is_class::value && !is_string::value && + !is_floating_point::value && !std::is_same::value && + !std::is_same().map( + value))>>::value, + OutputIt> { + return write(out, arg_mapper().map(value)); } -template -using is_builtin = - bool_constant::value || FMT_BUILTIN_TYPES>; +template > +FMT_CONSTEXPR auto write(OutputIt out, const T& value) + -> enable_if_t::value == type::custom_type, + OutputIt> { + auto formatter = typename Context::template formatter_type(); + auto parse_ctx = typename Context::parse_context_type({}); + formatter.parse(parse_ctx); + auto ctx = Context(out, {}, {}); + return formatter.format(value, ctx); +} // An argument visitor that formats the argument and writes it via the output // iterator. It's a class and not a generic lambda for compatibility with C++11. template struct default_arg_formatter { - using context = buffered_context; + using iterator = buffer_appender; + using context = buffer_context; - basic_appender out; + iterator out; + basic_format_args args; + locale_ref loc; - void operator()(monostate) { report_error("argument not found"); } - - template ::value)> - void operator()(T value) { - write(out, value); + template auto operator()(T value) -> iterator { + return write(out, value); } - - template ::value)> - void operator()(T) { - FMT_ASSERT(false, ""); - } - - void operator()(typename basic_format_arg::handle h) { - // Use a null locale since the default format must be unlocalized. - auto parse_ctx = parse_context({}); - auto format_ctx = context(out, {}, {}); + auto operator()(typename basic_format_arg::handle h) -> iterator { + basic_format_parse_context parse_ctx({}); + context format_ctx(out, args, loc); h.format(parse_ctx, format_ctx); + return format_ctx.out(); } }; template struct arg_formatter { - basic_appender out; - const format_specs& specs; - FMT_NO_UNIQUE_ADDRESS locale_ref locale; + using iterator = buffer_appender; + using context = buffer_context; - template ::value)> - FMT_CONSTEXPR FMT_INLINE void operator()(T value) { - detail::write(out, value, specs, locale); + iterator out; + const format_specs& specs; + locale_ref locale; + + template + FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator { + return detail::write(out, value, specs, locale); } - - template ::value)> - void operator()(T) { - FMT_ASSERT(false, ""); - } - - void operator()(typename basic_format_arg>::handle) { + auto operator()(typename basic_format_arg::handle) -> iterator { // User-defined types are handled separately because they require access // to the parse context. + return out; } }; -struct dynamic_spec_getter { +struct width_checker { template ::value)> FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { - return is_negative(value) ? ~0ull : static_cast(value); + if (is_negative(value)) throw_format_error("negative width"); + return static_cast(value); } template ::value)> FMT_CONSTEXPR auto operator()(T) -> unsigned long long { - report_error("width/precision is not integer"); + throw_format_error("width is not integer"); return 0; } }; -template -FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> basic_format_arg { - auto arg = ctx.arg(id); - if (!arg) report_error("argument not found"); - return arg; -} +struct precision_checker { + template ::value)> + FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { + if (is_negative(value)) throw_format_error("negative precision"); + return static_cast(value); + } -template -FMT_CONSTEXPR int get_dynamic_spec( - arg_id_kind kind, const arg_ref& ref, - Context& ctx) { - FMT_ASSERT(kind != arg_id_kind::none, ""); - auto arg = - kind == arg_id_kind::index ? ctx.arg(ref.index) : ctx.arg(ref.name); - if (!arg) report_error("argument not found"); - unsigned long long value = arg.visit(dynamic_spec_getter()); + template ::value)> + FMT_CONSTEXPR auto operator()(T) -> unsigned long long { + throw_format_error("precision is not integer"); + return 0; + } +}; + +template +FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int { + unsigned long long value = arg.visit(Handler()); if (value > to_unsigned(max_value())) - report_error("width/precision is out of range"); + throw_format_error("number is too big"); return static_cast(value); } -template -FMT_CONSTEXPR void handle_dynamic_spec( - arg_id_kind kind, int& value, - const arg_ref& ref, Context& ctx) { - if (kind != arg_id_kind::none) value = get_dynamic_spec(kind, ref, ctx); +template +FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) { + auto arg = ctx.arg(id); + if (!arg) ctx.on_error("argument not found"); + return arg; } -#if FMT_USE_NONTYPE_TEMPLATE_ARGS +template +FMT_CONSTEXPR void handle_dynamic_spec(int& value, + arg_ref ref, + Context& ctx) { + switch (ref.kind) { + case arg_id_kind::none: + break; + case arg_id_kind::index: + value = detail::get_dynamic_spec(get_arg(ctx, ref.val.index)); + break; + case arg_id_kind::name: + value = detail::get_dynamic_spec(get_arg(ctx, ref.val.name)); + break; + } +} + +#if FMT_USE_USER_DEFINED_LITERALS +# if FMT_USE_NONTYPE_TEMPLATE_ARGS template Str> -struct static_named_arg : view { + fmt::detail_exported::fixed_string Str> +struct statically_named_arg : view { static constexpr auto name = Str.data; const T& value; - static_named_arg(const T& v) : value(v) {} + statically_named_arg(const T& v) : value(v) {} }; template Str> -struct is_named_arg> : std::true_type {}; + fmt::detail_exported::fixed_string Str> +struct is_named_arg> : std::true_type {}; template Str> -struct is_static_named_arg> : std::true_type { -}; + fmt::detail_exported::fixed_string Str> +struct is_statically_named_arg> + : std::true_type {}; -template Str> +template Str> struct udl_arg { template auto operator=(T&& value) const { - return static_named_arg(std::forward(value)); + return statically_named_arg(std::forward(value)); } }; -#else +# else template struct udl_arg { const Char* str; @@ -3572,198 +3957,149 @@ template struct udl_arg { return {str, std::forward(value)}; } }; -#endif // FMT_USE_NONTYPE_TEMPLATE_ARGS +# endif +#endif // FMT_USE_USER_DEFINED_LITERALS -template struct format_handler { - parse_context parse_ctx; - buffered_context ctx; - - void on_text(const Char* begin, const Char* end) { - copy_noinline(begin, end, ctx.out()); - } - - FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); } - FMT_CONSTEXPR auto on_arg_id(int id) -> int { - parse_ctx.check_arg_id(id); - return id; - } - FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { - parse_ctx.check_arg_id(id); - int arg_id = ctx.arg_id(id); - if (arg_id < 0) report_error("argument not found"); - return arg_id; - } - - FMT_INLINE void on_replacement_field(int id, const Char*) { - ctx.arg(id).visit(default_arg_formatter{ctx.out()}); - } - - auto on_format_specs(int id, const Char* begin, const Char* end) - -> const Char* { - auto arg = get_arg(ctx, id); - // Not using a visitor for custom types gives better codegen. - if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin(); - - auto specs = dynamic_format_specs(); - begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type()); - if (specs.dynamic()) { - handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, - ctx); - handle_dynamic_spec(specs.dynamic_precision(), specs.precision, - specs.precision_ref, ctx); - } - - arg.visit(arg_formatter{ctx.out(), specs, ctx.locale()}); - return begin; - } - - FMT_NORETURN void on_error(const char* message) { report_error(message); } -}; +template +auto vformat(const Locale& loc, basic_string_view fmt, + basic_format_args>> args) + -> std::basic_string { + auto buf = basic_memory_buffer(); + detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); + return {buf.data(), buf.size()}; +} using format_func = void (*)(detail::buffer&, int, const char*); -FMT_API void do_report_error(format_func func, int error_code, - const char* message) noexcept; FMT_API void format_error_code(buffer& out, int error_code, string_view message) noexcept; -template -template -FMT_CONSTEXPR auto native_formatter::format( - const T& val, FormatContext& ctx) const -> decltype(ctx.out()) { - if (!specs_.dynamic()) - return write(ctx.out(), val, specs_, ctx.locale()); - auto specs = format_specs(specs_); - handle_dynamic_spec(specs.dynamic_width(), specs.width, specs_.width_ref, - ctx); - handle_dynamic_spec(specs.dynamic_precision(), specs.precision, - specs_.precision_ref, ctx); - return write(ctx.out(), val, specs, ctx.locale()); -} - -// DEPRECATED! https://github.com/fmtlib/fmt/issues/4292. -template -struct is_locale : std::false_type {}; -template -struct is_locale> : std::true_type {}; - -// DEPRECATED! -template struct vformat_args { - using type = basic_format_args>; -}; -template <> struct vformat_args { - using type = format_args; -}; - -template -void vformat_to(buffer& buf, basic_string_view fmt, - typename vformat_args::type args, locale_ref loc = {}) { - auto out = basic_appender(buf); - parse_format_string( - fmt, format_handler{parse_context(fmt), {out, args, loc}}); -} +FMT_API void report_error(format_func func, int error_code, + const char* message) noexcept; } // namespace detail -FMT_BEGIN_EXPORT +FMT_API auto vsystem_error(int error_code, string_view format_str, + format_args args) -> std::system_error; -// A generic formatting context with custom output iterator and character -// (code unit) support. Char is the format string code unit type which can be -// different from OutputIt::value_type. -template class generic_context { +/** + \rst + Constructs :class:`std::system_error` with a message formatted with + ``fmt::format(fmt, args...)``. + *error_code* is a system error code as given by ``errno``. + + **Example**:: + + // This throws std::system_error with the description + // cannot open file 'madeup': No such file or directory + // or similar (system message may vary). + const char* filename = "madeup"; + std::FILE* file = std::fopen(filename, "r"); + if (!file) + throw fmt::system_error(errno, "cannot open file '{}'", filename); + \endrst + */ +template +auto system_error(int error_code, format_string fmt, T&&... args) + -> std::system_error { + return vsystem_error(error_code, fmt, fmt::make_format_args(args...)); +} + +/** + \rst + Formats an error message for an error returned by an operating system or a + language runtime, for example a file opening error, and writes it to *out*. + The format is the same as the one used by ``std::system_error(ec, message)`` + where ``ec`` is ``std::error_code(error_code, std::generic_category()})``. + It is implementation-defined but normally looks like: + + .. parsed-literal:: + **: ** + + where ** is the passed message and ** is the system + message corresponding to the error code. + *error_code* is a system error code as given by ``errno``. + \endrst + */ +FMT_API void format_system_error(detail::buffer& out, int error_code, + const char* message) noexcept; + +// Reports a system error without throwing an exception. +// Can be used to report errors from destructors. +FMT_API void report_system_error(int error_code, const char* message) noexcept; + +/** Fast integer formatter. */ +class format_int { private: - OutputIt out_; - basic_format_args args_; - detail::locale_ref loc_; + // Buffer should be large enough to hold all digits (digits10 + 1), + // a sign and a null character. + enum { buffer_size = std::numeric_limits::digits10 + 3 }; + mutable char buffer_[buffer_size]; + char* str_; + + template auto format_unsigned(UInt value) -> char* { + auto n = static_cast>(value); + return detail::format_decimal(buffer_, n, buffer_size - 1).begin; + } + + template auto format_signed(Int value) -> char* { + auto abs_value = static_cast>(value); + bool negative = value < 0; + if (negative) abs_value = 0 - abs_value; + auto begin = format_unsigned(abs_value); + if (negative) *--begin = '-'; + return begin; + } public: - using char_type = Char; - using iterator = OutputIt; - using parse_context_type FMT_DEPRECATED = parse_context; - template - using formatter_type FMT_DEPRECATED = formatter; - enum { builtin_types = FMT_BUILTIN_TYPES }; + explicit format_int(int value) : str_(format_signed(value)) {} + explicit format_int(long value) : str_(format_signed(value)) {} + explicit format_int(long long value) : str_(format_signed(value)) {} + explicit format_int(unsigned value) : str_(format_unsigned(value)) {} + explicit format_int(unsigned long value) : str_(format_unsigned(value)) {} + explicit format_int(unsigned long long value) + : str_(format_unsigned(value)) {} - constexpr generic_context(OutputIt out, - basic_format_args args, - detail::locale_ref loc = {}) - : out_(out), args_(args), loc_(loc) {} - generic_context(generic_context&&) = default; - generic_context(const generic_context&) = delete; - void operator=(const generic_context&) = delete; - - constexpr auto arg(int id) const -> basic_format_arg { - return args_.get(id); - } - auto arg(basic_string_view name) const - -> basic_format_arg { - return args_.get(name); - } - constexpr auto arg_id(basic_string_view name) const -> int { - return args_.get_id(name); + /** Returns the number of characters written to the output buffer. */ + auto size() const -> size_t { + return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); } - constexpr auto out() const -> iterator { return out_; } + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + auto data() const -> const char* { return str_; } - void advance_to(iterator it) { - if (!detail::is_back_insert_iterator()) out_ = it; + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + auto c_str() const -> const char* { + buffer_[buffer_size - 1] = '\0'; + return str_; } - constexpr auto locale() const -> detail::locale_ref { return loc_; } + /** + \rst + Returns the content of the output buffer as an ``std::string``. + \endrst + */ + auto str() const -> std::string { return std::string(str_, size()); } }; -class loc_value { - private: - basic_format_arg value_; - - public: - template ::value)> - loc_value(T value) : value_(value) {} - - template ::value)> - loc_value(T) {} - - template auto visit(Visitor&& vis) -> decltype(vis(0)) { - return value_.visit(vis); +template +struct formatter::value>> + : formatter, Char> { + template + auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { + using base = formatter, Char>; + return base::format(format_as(value), ctx); } }; -// A locale facet that formats values in UTF-8. -// It is parameterized on the locale to avoid the heavy include. -template class format_facet : public Locale::facet { - private: - std::string separator_; - std::string grouping_; - std::string decimal_point_; - - protected: - virtual auto do_put(appender out, loc_value val, - const format_specs& specs) const -> bool; - - public: - static FMT_API typename Locale::id id; - - explicit format_facet(Locale& loc); - explicit format_facet(string_view sep = "", std::string grouping = "\3", - std::string decimal_point = ".") - : separator_(sep.data(), sep.size()), - grouping_(grouping), - decimal_point_(decimal_point) {} - - auto put(appender out, loc_value val, const format_specs& specs) const - -> bool { - return do_put(out, val, specs); - } -}; - -#define FMT_FORMAT_AS(Type, Base) \ - template \ - struct formatter : formatter { \ - template \ - FMT_CONSTEXPR auto format(Type value, FormatContext& ctx) const \ - -> decltype(ctx.out()) { \ - return formatter::format(value, ctx); \ - } \ - } +#define FMT_FORMAT_AS(Type, Base) \ + template \ + struct formatter : formatter {} FMT_FORMAT_AS(signed char, int); FMT_FORMAT_AS(unsigned char, unsigned); @@ -3772,58 +4108,44 @@ FMT_FORMAT_AS(unsigned short, unsigned); FMT_FORMAT_AS(long, detail::long_type); FMT_FORMAT_AS(unsigned long, detail::ulong_type); FMT_FORMAT_AS(Char*, const Char*); -FMT_FORMAT_AS(detail::std_string_view, basic_string_view); +FMT_FORMAT_AS(std::basic_string, basic_string_view); FMT_FORMAT_AS(std::nullptr_t, const void*); +FMT_FORMAT_AS(detail::std_string_view, basic_string_view); FMT_FORMAT_AS(void*, const void*); template struct formatter : formatter, Char> {}; -template -class formatter, Char> - : public formatter, Char> {}; - -template -struct formatter, Char> : formatter {}; -template -struct formatter, Char> - : formatter {}; - -template -struct formatter - : detail::native_formatter {}; - -template -struct formatter>> - : formatter, Char> { - template - FMT_CONSTEXPR auto format(const T& value, FormatContext& ctx) const - -> decltype(ctx.out()) { - auto&& val = format_as(value); // Make an lvalue reference for format. - return formatter, Char>::format(val, ctx); - } -}; - /** - * Converts `p` to `const void*` for pointer formatting. - * - * **Example**: - * - * auto s = fmt::format("{}", fmt::ptr(p)); + \rst + Converts ``p`` to ``const void*`` for pointer formatting. + + **Example**:: + + auto s = fmt::format("{}", fmt::ptr(p)); + \endrst */ template auto ptr(T p) -> const void* { static_assert(std::is_pointer::value, ""); return detail::bit_cast(p); } +template +auto ptr(const std::unique_ptr& p) -> const void* { + return p.get(); +} +template auto ptr(const std::shared_ptr& p) -> const void* { + return p.get(); +} /** - * Converts `e` to the underlying type. - * - * **Example**: - * - * enum class color { red, green, blue }; - * auto s = fmt::format("{}", fmt::underlying(color::red)); // s == "0" + \rst + Converts ``e`` to the underlying type. + + **Example**:: + + enum class color { red, green, blue }; + auto s = fmt::format("{}", fmt::underlying(color::red)); + \endrst */ template constexpr auto underlying(Enum e) noexcept -> underlying_t { @@ -3837,22 +4159,13 @@ constexpr auto format_as(Enum e) noexcept -> underlying_t { } } // namespace enums -#ifdef __cpp_lib_byte -template <> struct formatter : formatter { - static auto format_as(std::byte b) -> unsigned char { - return static_cast(b); - } - template - auto format(std::byte b, Context& ctx) const -> decltype(ctx.out()) { - return formatter::format(format_as(b), ctx); - } -}; -#endif +class bytes { + private: + string_view data_; + friend struct formatter; -struct bytes { - string_view data; - - inline explicit bytes(string_view s) : data(s) {} + public: + explicit bytes(string_view data) : data_(data) {} }; template <> struct formatter { @@ -3860,19 +4173,19 @@ template <> struct formatter { detail::dynamic_format_specs<> specs_; public: - FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::string_type); } template - auto format(bytes b, FormatContext& ctx) const -> decltype(ctx.out()) { - auto specs = specs_; - detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, - specs.width_ref, ctx); - detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, - specs.precision_ref, ctx); - return detail::write_bytes(ctx.out(), b.data, specs); + auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) { + detail::handle_dynamic_spec(specs_.width, + specs_.width_ref, ctx); + detail::handle_dynamic_spec( + specs_.precision, specs_.precision_ref, ctx); + return detail::write_bytes(ctx.out(), b.data_, specs_); } }; @@ -3882,13 +4195,15 @@ template struct group_digits_view { }; /** - * Returns a view that formats an integer value using ',' as a - * locale-independent thousands separator. - * - * **Example**: - * - * fmt::print("{}", fmt::group_digits(12345)); - * // Output: "12,345" + \rst + Returns a view that formats an integer value using ',' as a locale-independent + thousands separator. + + **Example**:: + + fmt::print("{}", fmt::group_digits(12345)); + // Output: "12,345" + \endrst */ template auto group_digits(T value) -> group_digits_view { return {value}; @@ -3899,255 +4214,253 @@ template struct formatter> : formatter { detail::dynamic_format_specs<> specs_; public: - FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::int_type); } template - auto format(group_digits_view view, FormatContext& ctx) const + auto format(group_digits_view t, FormatContext& ctx) -> decltype(ctx.out()) { - auto specs = specs_; - detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, - specs.width_ref, ctx); - detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, - specs.precision_ref, ctx); - auto arg = detail::make_write_int_arg(view.value, specs.sign()); + detail::handle_dynamic_spec(specs_.width, + specs_.width_ref, ctx); + detail::handle_dynamic_spec( + specs_.precision, specs_.precision_ref, ctx); return detail::write_int( - ctx.out(), static_cast>(arg.abs_value), - arg.prefix, specs, detail::digit_grouping("\3", ",")); + ctx.out(), static_cast>(t.value), 0, specs_, + detail::digit_grouping("\3", ",")); } }; -template struct nested_view { - const formatter* fmt; +template struct nested_view { + const formatter* fmt; const T* value; }; -template -struct formatter, Char> { - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { +template struct formatter> { + FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* { return ctx.begin(); } - template - auto format(nested_view view, FormatContext& ctx) const + auto format(nested_view view, format_context& ctx) const -> decltype(ctx.out()) { return view.fmt->format(*view.value, ctx); } }; -template struct nested_formatter { +template struct nested_formatter { private: - basic_specs specs_; int width_; - formatter formatter_; + detail::fill_t fill_; + align_t align_ : 4; + formatter formatter_; public: - constexpr nested_formatter() : width_(0) {} + constexpr nested_formatter() : width_(0), align_(align_t::none) {} - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - auto it = ctx.begin(), end = ctx.end(); - if (it == end) return it; - auto specs = format_specs(); - it = detail::parse_align(it, end, specs); - specs_ = specs; - Char c = *it; - auto width_ref = detail::arg_ref(); - if ((c >= '0' && c <= '9') || c == '{') { - it = detail::parse_width(it, end, specs, width_ref, ctx); - width_ = specs.width; - } + FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* { + auto specs = detail::dynamic_format_specs(); + auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx, + detail::type::none_type); + width_ = specs.width; + fill_ = specs.fill; + align_ = specs.align; ctx.advance_to(it); return formatter_.parse(ctx); } - template - auto write_padded(FormatContext& ctx, F write) const -> decltype(ctx.out()) { + template + auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) { if (width_ == 0) return write(ctx.out()); - auto buf = basic_memory_buffer(); - write(basic_appender(buf)); - auto specs = format_specs(); + auto buf = memory_buffer(); + write(std::back_inserter(buf)); + auto specs = format_specs<>(); specs.width = width_; - specs.copy_fill_from(specs_); - specs.set_align(specs_.align()); - return detail::write( - ctx.out(), basic_string_view(buf.data(), buf.size()), specs); + specs.fill = fill_; + specs.align = align_; + return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs); } - auto nested(const T& value) const -> nested_view { - return nested_view{&formatter_, &value}; + auto nested(const T& value) const -> nested_view { + return nested_view{&formatter_, &value}; } }; -inline namespace literals { -#if FMT_USE_NONTYPE_TEMPLATE_ARGS -template constexpr auto operator""_a() { - using char_t = remove_cvref_t; - return detail::udl_arg(); -} -#else /** - * User-defined literal equivalent of `fmt::arg`. - * - * **Example**: - * - * using namespace fmt::literals; - * fmt::print("The answer is {answer}.", "answer"_a=42); + \rst + Converts *value* to ``std::string`` using the default format for type *T*. + + **Example**:: + + #include + + std::string answer = fmt::to_string(42); + \endrst */ +template ::value && + !detail::has_format_as::value)> +inline auto to_string(const T& value) -> std::string { + auto buffer = memory_buffer(); + detail::write(appender(buffer), value); + return {buffer.data(), buffer.size()}; +} + +template ::value)> +FMT_NODISCARD inline auto to_string(T value) -> std::string { + // The buffer should be large enough to store the number including the sign + // or "false" for bool. + constexpr int max_size = detail::digits10() + 2; + char buffer[max_size > 5 ? static_cast(max_size) : 5]; + char* begin = buffer; + return std::string(begin, detail::write(begin, value)); +} + +template +FMT_NODISCARD auto to_string(const basic_memory_buffer& buf) + -> std::basic_string { + auto size = buf.size(); + detail::assume(size < std::basic_string().max_size()); + return std::basic_string(buf.data(), size); +} + +template ::value && + detail::has_format_as::value)> +inline auto to_string(const T& value) -> std::string { + return to_string(format_as(value)); +} + +FMT_END_EXPORT + +namespace detail { + +template +void vformat_to(buffer& buf, basic_string_view fmt, + typename vformat_args::type args, locale_ref loc) { + auto out = buffer_appender(buf); + if (fmt.size() == 2 && equal2(fmt.data(), "{}")) { + auto arg = args.get(0); + if (!arg) throw_format_error("argument not found"); + arg.visit(default_arg_formatter{out, args, loc}); + return; + } + + struct format_handler { + basic_format_parse_context parse_context; + buffer_context context; + + format_handler(buffer_appender p_out, basic_string_view str, + basic_format_args> p_args, + locale_ref p_loc) + : parse_context(str), context(p_out, p_args, p_loc) {} + + void on_text(const Char* begin, const Char* end) { + auto text = basic_string_view(begin, to_unsigned(end - begin)); + context.advance_to(write(context.out(), text)); + } + + FMT_CONSTEXPR auto on_arg_id() -> int { + return parse_context.next_arg_id(); + } + FMT_CONSTEXPR auto on_arg_id(int id) -> int { + return parse_context.check_arg_id(id), id; + } + FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { + int arg_id = context.arg_id(id); + if (arg_id < 0) throw_format_error("argument not found"); + return arg_id; + } + + FMT_INLINE void on_replacement_field(int id, const Char*) { + auto arg = get_arg(context, id); + context.advance_to(arg.visit(default_arg_formatter{ + context.out(), context.args(), context.locale()})); + } + + auto on_format_specs(int id, const Char* begin, const Char* end) + -> const Char* { + auto arg = get_arg(context, id); + // Not using a visitor for custom types gives better codegen. + if (arg.format_custom(begin, parse_context, context)) + return parse_context.begin(); + auto specs = detail::dynamic_format_specs(); + begin = parse_format_specs(begin, end, specs, parse_context, arg.type()); + detail::handle_dynamic_spec( + specs.width, specs.width_ref, context); + detail::handle_dynamic_spec( + specs.precision, specs.precision_ref, context); + if (begin == end || *begin != '}') + throw_format_error("missing '}' in format string"); + context.advance_to(arg.visit( + arg_formatter{context.out(), specs, context.locale()})); + return begin; + } + + void on_error(const char* message) { throw_format_error(message); } + }; + detail::parse_format_string(fmt, format_handler(out, fmt, args, loc)); +} + +FMT_BEGIN_EXPORT + +#ifndef FMT_HEADER_ONLY +extern template FMT_API void vformat_to(buffer&, string_view, + typename vformat_args<>::type, + locale_ref); +extern template FMT_API auto thousands_sep_impl(locale_ref) + -> thousands_sep_result; +extern template FMT_API auto thousands_sep_impl(locale_ref) + -> thousands_sep_result; +extern template FMT_API auto decimal_point_impl(locale_ref) -> char; +extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; +#endif // FMT_HEADER_ONLY + +} // namespace detail + +#if FMT_USE_USER_DEFINED_LITERALS +inline namespace literals { +/** + \rst + User-defined literal equivalent of :func:`fmt::arg`. + + **Example**:: + + using namespace fmt::literals; + fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); + \endrst + */ +# if FMT_USE_NONTYPE_TEMPLATE_ARGS +template constexpr auto operator""_a() { + using char_t = remove_cvref_t; + return detail::udl_arg(); +} +# else constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg { return {s}; } -#endif // FMT_USE_NONTYPE_TEMPLATE_ARGS +# endif } // namespace literals - -/// A fast integer formatter. -class format_int { - private: - // Buffer should be large enough to hold all digits (digits10 + 1), - // a sign and a null character. - enum { buffer_size = std::numeric_limits::digits10 + 3 }; - mutable char buffer_[buffer_size]; - char* str_; - - template - FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* { - auto n = static_cast>(value); - return detail::do_format_decimal(buffer_, n, buffer_size - 1); - } - - template - FMT_CONSTEXPR20 auto format_signed(Int value) -> char* { - auto abs_value = static_cast>(value); - bool negative = value < 0; - if (negative) abs_value = 0 - abs_value; - auto begin = format_unsigned(abs_value); - if (negative) *--begin = '-'; - return begin; - } - - public: - FMT_CONSTEXPR20 explicit format_int(int value) : str_(format_signed(value)) {} - FMT_CONSTEXPR20 explicit format_int(long value) - : str_(format_signed(value)) {} - FMT_CONSTEXPR20 explicit format_int(long long value) - : str_(format_signed(value)) {} - FMT_CONSTEXPR20 explicit format_int(unsigned value) - : str_(format_unsigned(value)) {} - FMT_CONSTEXPR20 explicit format_int(unsigned long value) - : str_(format_unsigned(value)) {} - FMT_CONSTEXPR20 explicit format_int(unsigned long long value) - : str_(format_unsigned(value)) {} - - /// Returns the number of characters written to the output buffer. - FMT_CONSTEXPR20 auto size() const -> size_t { - return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); - } - - /// Returns a pointer to the output buffer content. No terminating null - /// character is appended. - FMT_CONSTEXPR20 auto data() const -> const char* { return str_; } - - /// Returns a pointer to the output buffer content with terminating null - /// character appended. - FMT_CONSTEXPR20 auto c_str() const -> const char* { - buffer_[buffer_size - 1] = '\0'; - return str_; - } - - /// Returns the content of the output buffer as an `std::string`. - inline auto str() const -> std::string { return {str_, size()}; } -}; - -#define FMT_STRING_IMPL(s, base) \ - [] { \ - /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ - /* Use a macro-like name to avoid shadowing warnings. */ \ - struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ - using char_type = fmt::remove_cvref_t; \ - constexpr explicit operator fmt::basic_string_view() const { \ - return fmt::detail::compile_string_to_view(s); \ - } \ - }; \ - using FMT_STRING_VIEW = \ - fmt::basic_string_view; \ - fmt::detail::ignore_unused(FMT_STRING_VIEW(FMT_COMPILE_STRING())); \ - return FMT_COMPILE_STRING(); \ - }() - -/** - * Constructs a legacy compile-time format string from a string literal `s`. - * - * **Example**: - * - * // A compile-time error because 'd' is an invalid specifier for strings. - * std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); - */ -#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string) - -FMT_API auto vsystem_error(int error_code, string_view fmt, format_args args) - -> std::system_error; - -/** - * Constructs `std::system_error` with a message formatted with - * `fmt::format(fmt, args...)`. - * `error_code` is a system error code as given by `errno`. - * - * **Example**: - * - * // This throws std::system_error with the description - * // cannot open file 'madeup': No such file or directory - * // or similar (system message may vary). - * const char* filename = "madeup"; - * FILE* file = fopen(filename, "r"); - * if (!file) - * throw fmt::system_error(errno, "cannot open file '{}'", filename); - */ -template -auto system_error(int error_code, format_string fmt, T&&... args) - -> std::system_error { - return vsystem_error(error_code, fmt.str, vargs{{args...}}); -} - -/** - * Formats an error message for an error returned by an operating system or a - * language runtime, for example a file opening error, and writes it to `out`. - * The format is the same as the one used by `std::system_error(ec, message)` - * where `ec` is `std::error_code(error_code, std::generic_category())`. - * It is implementation-defined but normally looks like: - * - * : - * - * where `` is the passed message and `` is the system - * message corresponding to the error code. - * `error_code` is a system error code as given by `errno`. - */ -FMT_API void format_system_error(detail::buffer& out, int error_code, - const char* message) noexcept; - -// Reports a system error without throwing an exception. -// Can be used to report errors from destructors. -FMT_API void report_system_error(int error_code, const char* message) noexcept; +#endif // FMT_USE_USER_DEFINED_LITERALS template ::value)> inline auto vformat(const Locale& loc, string_view fmt, format_args args) -> std::string { - auto buf = memory_buffer(); - detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); - return {buf.data(), buf.size()}; + return detail::vformat(loc, fmt, args); } template ::value)> -FMT_INLINE auto format(const Locale& loc, format_string fmt, T&&... args) +inline auto format(const Locale& loc, format_string fmt, T&&... args) -> std::string { - return vformat(loc, fmt.str, vargs{{args...}}); + return fmt::vformat(loc, string_view(fmt), fmt::make_format_args(args...)); } template ::value)> + FMT_ENABLE_IF(detail::is_output_iterator::value&& + detail::is_locale::value)> auto vformat_to(OutputIt out, const Locale& loc, string_view fmt, format_args args) -> OutputIt { - auto&& buf = detail::get_buffer(out); + using detail::get_buffer; + auto&& buf = get_buffer(out); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); return detail::get_iterator(buf, out); } @@ -4157,7 +4470,7 @@ template ::value)> FMT_INLINE auto format_to(OutputIt out, const Locale& loc, format_string fmt, T&&... args) -> OutputIt { - return fmt::vformat_to(out, loc, fmt.str, vargs{{args...}}); + return vformat_to(out, loc, fmt, fmt::make_format_args(args...)); } template fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); - detail::vformat_to(buf, fmt.str, vargs{{args...}}, - detail::locale_ref(loc)); + detail::vformat_to(buf, fmt, fmt::make_format_args(args...), + detail::locale_ref(loc)); return buf.count(); } -FMT_API auto vformat(string_view fmt, format_args args) -> std::string; - -/** - * Formats `args` according to specifications in `fmt` and returns the result - * as a string. - * - * **Example**: - * - * #include - * std::string message = fmt::format("The answer is {}.", 42); - */ -template -FMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args) - -> std::string { - return vformat(fmt.str, vargs{{args...}}); -} - -/** - * Converts `value` to `std::string` using the default format for type `T`. - * - * **Example**: - * - * std::string answer = fmt::to_string(42); - */ -template ::value)> -FMT_NODISCARD auto to_string(T value) -> std::string { - // The buffer should be large enough to store the number including the sign - // or "false" for bool. - char buffer[max_of(detail::digits10() + 2, 5)]; - return {buffer, detail::write(buffer, value)}; -} - -template ::value)> -FMT_NODISCARD auto to_string(const T& value) -> std::string { - return to_string(format_as(value)); -} - -template ::value && - !detail::use_format_as::value)> -FMT_NODISCARD auto to_string(const T& value) -> std::string { - auto buffer = memory_buffer(); - detail::write(appender(buffer), value); - return {buffer.data(), buffer.size()}; -} - FMT_END_EXPORT + +template +template +FMT_CONSTEXPR FMT_INLINE auto +formatter::value != + detail::type::custom_type>>::format(const T& val, + FormatContext& ctx) + const -> decltype(ctx.out()) { + if (specs_.width_ref.kind == detail::arg_id_kind::none && + specs_.precision_ref.kind == detail::arg_id_kind::none) { + return detail::write(ctx.out(), val, specs_, ctx.locale()); + } + auto specs = specs_; + detail::handle_dynamic_spec(specs.width, + specs.width_ref, ctx); + detail::handle_dynamic_spec( + specs.precision, specs.precision_ref, ctx); + return detail::write(ctx.out(), val, specs, ctx.locale()); +} + FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY # define FMT_FUNC inline # include "format-inl.h" -#endif - -// Restore _LIBCPP_REMOVE_TRANSITIVE_INCLUDES. -#ifdef FMT_REMOVE_TRANSITIVE_INCLUDES -# undef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES +#else +# define FMT_FUNC #endif #endif // FMT_FORMAT_H_ diff --git a/src/fmt/os.h b/src/fmt/os.h index b2cc5e4b85..6009ccc112 100644 --- a/src/fmt/os.h +++ b/src/fmt/os.h @@ -8,18 +8,18 @@ #ifndef FMT_OS_H_ #define FMT_OS_H_ +#include +#include +#include +#include // std::system_error + #include "format.h" -#ifndef FMT_MODULE -# include -# include -# include -# include // std::system_error - +#if defined __APPLE__ || defined(__FreeBSD__) # if FMT_HAS_INCLUDE() -# include // LC_NUMERIC_MASK on macOS +# include // for LC_NUMERIC_MASK on OS X # endif -#endif // FMT_MODULE +#endif #ifndef FMT_USE_FCNTL // UWP doesn't provide _pipe. @@ -77,33 +77,46 @@ FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT /** - * A reference to a null-terminated string. It can be constructed from a C - * string or `std::string`. - * - * You can use one of the following type aliases for common character types: - * - * +---------------+-----------------------------+ - * | Type | Definition | - * +===============+=============================+ - * | cstring_view | basic_cstring_view | - * +---------------+-----------------------------+ - * | wcstring_view | basic_cstring_view | - * +---------------+-----------------------------+ - * - * This class is most useful as a parameter type for functions that wrap C APIs. + \rst + A reference to a null-terminated string. It can be constructed from a C + string or ``std::string``. + + You can use one of the following type aliases for common character types: + + +---------------+-----------------------------+ + | Type | Definition | + +===============+=============================+ + | cstring_view | basic_cstring_view | + +---------------+-----------------------------+ + | wcstring_view | basic_cstring_view | + +---------------+-----------------------------+ + + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: + + template + std::string format(cstring_view format_str, const Args & ... args); + + format("{}", 42); + format(std::string("{}"), 42); + \endrst */ template class basic_cstring_view { private: const Char* data_; public: - /// Constructs a string reference object from a C string. + /** Constructs a string reference object from a C string. */ basic_cstring_view(const Char* s) : data_(s) {} - /// Constructs a string reference from an `std::string` object. + /** + \rst + Constructs a string reference from an ``std::string`` object. + \endrst + */ basic_cstring_view(const std::basic_string& s) : data_(s.c_str()) {} - /// Returns the pointer to a C string. + /** Returns the pointer to a C string. */ auto c_str() const -> const Char* { return data_; } }; @@ -118,38 +131,41 @@ FMT_API void format_windows_error(buffer& out, int error_code, const char* message) noexcept; } -FMT_API std::system_error vwindows_error(int error_code, string_view fmt, +FMT_API std::system_error vwindows_error(int error_code, string_view format_str, format_args args); /** - * Constructs a `std::system_error` object with the description of the form - * - * : - * - * where `` is the formatted message and `` is the - * system message corresponding to the error code. - * `error_code` is a Windows error code as given by `GetLastError`. - * If `error_code` is not a valid error code such as -1, the system message - * will look like "error -1". - * - * **Example**: - * - * // This throws a system_error with the description - * // cannot open file 'madeup': The system cannot find the file - * specified. - * // or similar (system message may vary). - * const char *filename = "madeup"; - * LPOFSTRUCT of = LPOFSTRUCT(); - * HFILE file = OpenFile(filename, &of, OF_READ); - * if (file == HFILE_ERROR) { - * throw fmt::windows_error(GetLastError(), - * "cannot open file '{}'", filename); - * } - */ -template -auto windows_error(int error_code, string_view message, const T&... args) - -> std::system_error { - return vwindows_error(error_code, message, vargs{{args...}}); + \rst + Constructs a :class:`std::system_error` object with the description + of the form + + .. parsed-literal:: + **: ** + + where ** is the formatted message and ** is the + system message corresponding to the error code. + *error_code* is a Windows error code as given by ``GetLastError``. + If *error_code* is not a valid error code such as -1, the system message + will look like "error -1". + + **Example**:: + + // This throws a system_error with the description + // cannot open file 'madeup': The system cannot find the file specified. + // or similar (system message may vary). + const char *filename = "madeup"; + LPOFSTRUCT of = LPOFSTRUCT(); + HFILE file = OpenFile(filename, &of, OF_READ); + if (file == HFILE_ERROR) { + throw fmt::windows_error(GetLastError(), + "cannot open file '{}'", filename); + } + \endrst +*/ +template +std::system_error windows_error(int error_code, string_view message, + const Args&... args) { + return vwindows_error(error_code, message, fmt::make_format_args(args...)); } // Reports a Windows error without throwing an exception. @@ -164,8 +180,8 @@ inline auto system_category() noexcept -> const std::error_category& { // std::system is not available on some platforms such as iOS (#2248). #ifdef __OSX__ template > -void say(const S& fmt, Args&&... args) { - std::system(format("say \"{}\"", format(fmt, args...)).c_str()); +void say(const S& format_str, Args&&... args) { + std::system(format("say \"{}\"", format(format_str, args...)).c_str()); } #endif @@ -176,24 +192,24 @@ class buffered_file { friend class file; - inline explicit buffered_file(FILE* f) : file_(f) {} + explicit buffered_file(FILE* f) : file_(f) {} public: buffered_file(const buffered_file&) = delete; void operator=(const buffered_file&) = delete; // Constructs a buffered_file object which doesn't represent any file. - inline buffered_file() noexcept : file_(nullptr) {} + buffered_file() noexcept : file_(nullptr) {} // Destroys the object closing the file it represents if any. FMT_API ~buffered_file() noexcept; public: - inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) { + buffered_file(buffered_file&& other) noexcept : file_(other.file_) { other.file_ = nullptr; } - inline auto operator=(buffered_file&& other) -> buffered_file& { + auto operator=(buffered_file&& other) -> buffered_file& { close(); file_ = other.file_; other.file_ = nullptr; @@ -207,15 +223,17 @@ class buffered_file { FMT_API void close(); // Returns the pointer to a FILE object representing this file. - inline auto get() const noexcept -> FILE* { return file_; } + auto get() const noexcept -> FILE* { return file_; } FMT_API auto descriptor() const -> int; - template - inline void print(string_view fmt, const T&... args) { - fmt::vargs vargs = {{args...}}; - detail::is_locking() ? fmt::vprint_buffered(file_, fmt, vargs) - : fmt::vprint(file_, fmt, vargs); + void vprint(string_view format_str, format_args args) { + fmt::vprint(file_, format_str, args); + } + + template + inline void print(string_view format_str, const Args&... args) { + vprint(format_str, fmt::make_format_args(args...)); } }; @@ -248,7 +266,7 @@ class FMT_API file { }; // Constructs a file object which doesn't represent any file. - inline file() noexcept : fd_(-1) {} + file() noexcept : fd_(-1) {} // Opens a file and constructs a file object representing this file. file(cstring_view path, int oflag); @@ -257,10 +275,10 @@ class FMT_API file { file(const file&) = delete; void operator=(const file&) = delete; - inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } + file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } // Move assignment is not noexcept because close may throw. - inline auto operator=(file&& other) -> file& { + auto operator=(file&& other) -> file& { close(); fd_ = other.fd_; other.fd_ = -1; @@ -271,7 +289,7 @@ class FMT_API file { ~file() noexcept; // Returns the file descriptor. - inline auto descriptor() const noexcept -> int { return fd_; } + auto descriptor() const noexcept -> int { return fd_; } // Closes the file. void close(); @@ -324,9 +342,9 @@ auto getpagesize() -> long; namespace detail { struct buffer_size { - constexpr buffer_size() = default; + buffer_size() = default; size_t value = 0; - FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size { + auto operator=(size_t val) const -> buffer_size { auto bs = buffer_size(); bs.value = val; return bs; @@ -337,7 +355,7 @@ struct ostream_params { int oflag = file::WRONLY | file::CREATE | file::TRUNC; size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768; - constexpr ostream_params() {} + ostream_params() {} template ostream_params(T... params, int new_oflag) : ostream_params(params...) { @@ -358,62 +376,80 @@ struct ostream_params { # endif }; -} // namespace detail - -FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size(); - -/// A fast buffered output stream for writing from a single thread. Writing from -/// multiple threads without external synchronization may result in a data race. -class FMT_API ostream : private detail::buffer { +class file_buffer final : public buffer { private: file file_; - ostream(cstring_view path, const detail::ostream_params& params); - - static void grow(buffer& buf, size_t); + FMT_API static void grow(buffer& buf, size_t); public: - ostream(ostream&& other) noexcept; - ~ostream(); + FMT_API file_buffer(cstring_view path, const ostream_params& params); + FMT_API file_buffer(file_buffer&& other); + FMT_API ~file_buffer(); - operator writer() { - detail::buffer& buf = *this; - return buf; - } - - inline void flush() { + void flush() { if (size() == 0) return; file_.write(data(), size() * sizeof(data()[0])); clear(); } - template - friend auto output_file(cstring_view path, T... params) -> ostream; - - inline void close() { + void close() { flush(); file_.close(); } +}; - /// Formats `args` according to specifications in `fmt` and writes the - /// output to the file. +} // namespace detail + +// Added {} below to work around default constructor error known to +// occur in Xcode versions 7.2.1 and 8.2.1. +constexpr detail::buffer_size buffer_size{}; + +/** A fast output stream which is not thread-safe. */ +class FMT_API ostream { + private: + FMT_MSC_WARNING(suppress : 4251) + detail::file_buffer buffer_; + + ostream(cstring_view path, const detail::ostream_params& params) + : buffer_(path, params) {} + + public: + ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {} + + ~ostream(); + + void flush() { buffer_.flush(); } + + template + friend auto output_file(cstring_view path, T... params) -> ostream; + + void close() { buffer_.close(); } + + /** + Formats ``args`` according to specifications in ``fmt`` and writes the + output to the file. + */ template void print(format_string fmt, T&&... args) { - vformat_to(appender(*this), fmt.str, vargs{{args...}}); + vformat_to(std::back_inserter(buffer_), fmt, + fmt::make_format_args(args...)); } }; /** - * Opens a file for writing. Supported parameters passed in `params`: - * - * - ``: Flags passed to [open]( - * https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html) - * (`file::WRONLY | file::CREATE | file::TRUNC` by default) - * - `buffer_size=`: Output buffer size - * - * **Example**: - * - * auto out = fmt::output_file("guide.txt"); - * out.print("Don't {}", "Panic"); + \rst + Opens a file for writing. Supported parameters passed in *params*: + + * ````: Flags passed to `open + `_ + (``file::WRONLY | file::CREATE | file::TRUNC`` by default) + * ``buffer_size=``: Output buffer size + + **Example**:: + + auto out = fmt::output_file("guide.txt"); + out.print("Don't {}", "Panic"); + \endrst */ template inline auto output_file(cstring_view path, T... params) -> ostream { diff --git a/src/fmt/ostream.h b/src/fmt/ostream.h index 5d893c9216..26fb3b5ac0 100644 --- a/src/fmt/ostream.h +++ b/src/fmt/ostream.h @@ -8,9 +8,7 @@ #ifndef FMT_OSTREAM_H_ #define FMT_OSTREAM_H_ -#ifndef FMT_MODULE -# include // std::filebuf -#endif +#include // std::filebuf #ifdef _WIN32 # ifdef __GLIBCXX__ @@ -20,19 +18,42 @@ # include #endif -#include "chrono.h" // formatbuf - -#ifdef _MSVC_STL_UPDATE -# define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE -#elif defined(_MSC_VER) && _MSC_VER < 1912 // VS 15.5 -# define FMT_MSVC_STL_UPDATE _MSVC_LANG -#else -# define FMT_MSVC_STL_UPDATE 0 -#endif +#include "format.h" FMT_BEGIN_NAMESPACE namespace detail { +template class formatbuf : public Streambuf { + private: + using char_type = typename Streambuf::char_type; + using streamsize = decltype(std::declval().sputn(nullptr, 0)); + using int_type = typename Streambuf::int_type; + using traits_type = typename Streambuf::traits_type; + + buffer& buffer_; + + public: + explicit formatbuf(buffer& buf) : buffer_(buf) {} + + protected: + // The put area is always empty. This makes the implementation simpler and has + // the advantage that the streambuf and the buffer are always in sync and + // sputc never writes into uninitialized memory. A disadvantage is that each + // call to sputc always results in a (virtual) call to overflow. There is no + // disadvantage here for sputn since this always results in a call to xsputn. + + auto overflow(int_type ch) -> int_type override { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } + + auto xsputn(const char_type* s, streamsize count) -> streamsize override { + buffer_.append(s, s + count); + return count; + } +}; + // Generate a unique explicit instantion in every translation unit using a tag // type in an anonymous namespace. namespace { @@ -43,18 +64,53 @@ class file_access { friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; } }; -#if FMT_MSVC_STL_UPDATE +#if FMT_MSC_VERSION template class file_access; auto get_file(std::filebuf&) -> FILE*; #endif +inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data) + -> bool { + FILE* f = nullptr; +#if FMT_MSC_VERSION + if (auto* buf = dynamic_cast(os.rdbuf())) + f = get_file(*buf); + else + return false; +#elif defined(_WIN32) && defined(__GLIBCXX__) + auto* rdbuf = os.rdbuf(); + if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf*>(rdbuf)) + f = sfbuf->file(); + else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf*>(rdbuf)) + f = fbuf->file(); + else + return false; +#else + ignore_unused(os, data, f); +#endif +#ifdef _WIN32 + if (f) { + int fd = _fileno(f); + if (_isatty(fd)) { + os.flush(); + return write_console(fd, data); + } + } +#endif + return false; +} +inline auto write_ostream_unicode(std::wostream&, + fmt::basic_string_view) -> bool { + return false; +} + // Write the content of buf to os. // It is a separate function rather than a part of vprint to simplify testing. template void write_buffer(std::basic_ostream& os, buffer& buf) { const Char* buf_data = buf.data(); - using unsigned_streamsize = make_unsigned_t; + using unsigned_streamsize = std::make_unsigned::type; unsigned_streamsize size = buf.size(); unsigned_streamsize max_size = to_unsigned(max_value()); do { @@ -65,9 +121,21 @@ void write_buffer(std::basic_ostream& os, buffer& buf) { } while (size != 0); } +template +void format_value(buffer& buf, const T& value) { + auto&& format_buf = formatbuf>(buf); + auto&& output = std::basic_ostream(&format_buf); +#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) + output.imbue(std::locale::classic()); // The default is always unlocalized. +#endif + output << value; + output.exceptions(std::ios_base::failbit | std::ios_base::badbit); +} + template struct streamed_view { const T& value; }; + } // namespace detail // Formats an object of type T that has an overloaded ostream operator<<. @@ -75,14 +143,11 @@ template struct basic_ostream_formatter : formatter, Char> { void set_debug_format() = delete; - template - auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) { + template + auto format(const T& value, basic_format_context& ctx) const + -> OutputIt { auto buffer = basic_memory_buffer(); - auto&& formatbuf = detail::formatbuf>(buffer); - auto&& output = std::basic_ostream(&formatbuf); - output.imbue(std::locale::classic()); // The default is always unlocalized. - output << value; - output.exceptions(std::ios_base::failbit | std::ios_base::badbit); + detail::format_value(buffer, value); return formatter, Char>::format( {buffer.data(), buffer.size()}, ctx); } @@ -93,67 +158,73 @@ using ostream_formatter = basic_ostream_formatter; template struct formatter, Char> : basic_ostream_formatter { - template - auto format(detail::streamed_view view, Context& ctx) const - -> decltype(ctx.out()) { + template + auto format(detail::streamed_view view, + basic_format_context& ctx) const -> OutputIt { return basic_ostream_formatter::format(view.value, ctx); } }; /** - * Returns a view that formats `value` via an ostream `operator<<`. - * - * **Example**: - * - * fmt::print("Current thread id: {}\n", - * fmt::streamed(std::this_thread::get_id())); + \rst + Returns a view that formats `value` via an ostream ``operator<<``. + + **Example**:: + + fmt::print("Current thread id: {}\n", + fmt::streamed(std::this_thread::get_id())); + \endrst */ template constexpr auto streamed(const T& value) -> detail::streamed_view { return {value}; } -inline void vprint(std::ostream& os, string_view fmt, format_args args) { +namespace detail { + +inline void vprint_directly(std::ostream& os, string_view format_str, + format_args args) { auto buffer = memory_buffer(); - detail::vformat_to(buffer, fmt, args); - FILE* f = nullptr; -#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI - if (auto* buf = dynamic_cast(os.rdbuf())) - f = detail::get_file(*buf); -#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI - auto* rdbuf = os.rdbuf(); - if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf*>(rdbuf)) - f = sfbuf->file(); - else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf*>(rdbuf)) - f = fbuf->file(); -#endif -#ifdef _WIN32 - if (f) { - int fd = _fileno(f); - if (_isatty(fd)) { - os.flush(); - if (detail::write_console(fd, {buffer.data(), buffer.size()})) return; - } - } -#endif - detail::ignore_unused(f); + detail::vformat_to(buffer, format_str, args); + detail::write_buffer(os, buffer); +} + +} // namespace detail + +FMT_EXPORT template +void vprint(std::basic_ostream& os, + basic_string_view> format_str, + basic_format_args>> args) { + auto buffer = basic_memory_buffer(); + detail::vformat_to(buffer, format_str, args); + if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return; detail::write_buffer(os, buffer); } /** - * Prints formatted data to the stream `os`. - * - * **Example**: - * - * fmt::print(cerr, "Don't {}!", "panic"); + \rst + Prints formatted data to the stream *os*. + + **Example**:: + + fmt::print(cerr, "Don't {}!", "panic"); + \endrst */ FMT_EXPORT template void print(std::ostream& os, format_string fmt, T&&... args) { - fmt::vargs vargs = {{args...}}; - if (detail::use_utf8) return vprint(os, fmt.str, vargs); - auto buffer = memory_buffer(); - detail::vformat_to(buffer, fmt.str, vargs); - detail::write_buffer(os, buffer); + const auto& vargs = fmt::make_format_args(args...); + if (detail::is_utf8()) + vprint(os, fmt, vargs); + else + detail::vprint_directly(os, fmt, vargs); +} + +FMT_EXPORT +template +void print(std::wostream& os, + basic_format_string...> fmt, + Args&&... args) { + vprint(os, fmt, fmt::make_format_args>(args...)); } FMT_EXPORT template @@ -161,6 +232,14 @@ void println(std::ostream& os, format_string fmt, T&&... args) { fmt::print(os, "{}\n", fmt::format(fmt, std::forward(args)...)); } +FMT_EXPORT +template +void println(std::wostream& os, + basic_format_string...> fmt, + Args&&... args) { + print(os, L"{}\n", fmt::format(fmt, std::forward(args)...)); +} + FMT_END_NAMESPACE #endif // FMT_OSTREAM_H_ diff --git a/src/fmt/printf.h b/src/fmt/printf.h index e726840185..35445abce2 100644 --- a/src/fmt/printf.h +++ b/src/fmt/printf.h @@ -8,10 +8,8 @@ #ifndef FMT_PRINTF_H_ #define FMT_PRINTF_H_ -#ifndef FMT_MODULE -# include // std::max -# include // std::numeric_limits -#endif +#include // std::max +#include // std::numeric_limits #include "format.h" @@ -24,7 +22,7 @@ template struct printf_formatter { template class basic_printf_context { private: - basic_appender out_; + detail::buffer_appender out_; basic_format_args args_; static_assert(std::is_same::value || @@ -33,53 +31,41 @@ template class basic_printf_context { public: using char_type = Char; - using parse_context_type = parse_context; + using parse_context_type = basic_format_parse_context; template using formatter_type = printf_formatter; - enum { builtin_types = 1 }; - /// Constructs a `printf_context` object. References to the arguments are - /// stored in the context object so make sure they have appropriate lifetimes. - basic_printf_context(basic_appender out, + /** + \rst + Constructs a ``printf_context`` object. References to the arguments are + stored in the context object so make sure they have appropriate lifetimes. + \endrst + */ + basic_printf_context(detail::buffer_appender out, basic_format_args args) : out_(out), args_(args) {} - auto out() -> basic_appender { return out_; } - void advance_to(basic_appender) {} + auto out() -> detail::buffer_appender { return out_; } + void advance_to(detail::buffer_appender) {} auto locale() -> detail::locale_ref { return {}; } auto arg(int id) const -> basic_format_arg { return args_.get(id); } + + void on_error(const char* message) { throw_format_error(message); } }; namespace detail { -// Return the result via the out param to workaround gcc bug 77539. -template -FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { - for (out = first; out != last; ++out) { - if (*out == value) return true; - } - return false; -} - -template <> -inline auto find(const char* first, const char* last, char value, - const char*& out) -> bool { - out = - static_cast(memchr(first, value, to_unsigned(last - first))); - return out != nullptr; -} - // Checks if a value fits in int - used to avoid warnings about comparing // signed and unsigned integers. template struct int_checker { template static auto fits_in_int(T value) -> bool { - unsigned max = to_unsigned(max_value()); + unsigned max = max_value(); return value <= max; } - inline static auto fits_in_int(bool) -> bool { return true; } + static auto fits_in_int(bool) -> bool { return true; } }; template <> struct int_checker { @@ -87,20 +73,20 @@ template <> struct int_checker { return value >= (std::numeric_limits::min)() && value <= max_value(); } - inline static auto fits_in_int(int) -> bool { return true; } + static auto fits_in_int(int) -> bool { return true; } }; struct printf_precision_handler { template ::value)> auto operator()(T value) -> int { if (!int_checker::is_signed>::fits_in_int(value)) - report_error("number is too big"); + throw_format_error("number is too big"); return (std::max)(static_cast(value), 0); } template ::value)> auto operator()(T) -> int { - report_error("precision is not integer"); + throw_format_error("precision is not integer"); return 0; } }; @@ -145,19 +131,25 @@ template class arg_converter { using target_type = conditional_t::value, U, T>; if (const_check(sizeof(target_type) <= sizeof(int))) { // Extra casts are used to silence warnings. - using unsigned_type = typename make_unsigned_or_bool::type; - if (is_signed) - arg_ = static_cast(static_cast(value)); - else - arg_ = static_cast(static_cast(value)); + if (is_signed) { + auto n = static_cast(static_cast(value)); + arg_ = detail::make_arg(n); + } else { + using unsigned_type = typename make_unsigned_or_bool::type; + auto n = static_cast(static_cast(value)); + arg_ = detail::make_arg(n); + } } else { - // glibc's printf doesn't sign extend arguments of smaller types: - // std::printf("%lld", -42); // prints "4294967254" - // but we don't have to do the same because it's a UB. - if (is_signed) - arg_ = static_cast(value); - else - arg_ = static_cast::type>(value); + if (is_signed) { + // glibc's printf doesn't sign extend arguments of smaller types: + // std::printf("%lld", -42); // prints "4294967254" + // but we don't have to do the same because it's a UB. + auto n = static_cast(value); + arg_ = detail::make_arg(n); + } else { + auto n = static_cast::type>(value); + arg_ = detail::make_arg(n); + } } } @@ -184,7 +176,8 @@ template class char_converter { template ::value)> void operator()(T value) { - arg_ = static_cast(value); + auto c = static_cast(value); + arg_ = detail::make_arg(c); } template ::value)> @@ -200,28 +193,28 @@ template struct get_cstring { // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. -class printf_width_handler { +template class printf_width_handler { private: - format_specs& specs_; + format_specs& specs_; public: - inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {} + explicit printf_width_handler(format_specs& specs) : specs_(specs) {} template ::value)> auto operator()(T value) -> unsigned { auto width = static_cast>(value); if (detail::is_negative(value)) { - specs_.set_align(align::left); + specs_.align = align::left; width = 0 - width; } - unsigned int_max = to_unsigned(max_value()); - if (width > int_max) report_error("number is too big"); + unsigned int_max = max_value(); + if (width > int_max) throw_format_error("number is too big"); return static_cast(width); } template ::value)> auto operator()(T) -> unsigned { - report_error("width is not integer"); + throw_format_error("width is not integer"); return 0; } }; @@ -229,12 +222,12 @@ class printf_width_handler { // Workaround for a bug with the XL compiler when initializing // printf_arg_formatter's base class. template -auto make_arg_formatter(basic_appender iter, format_specs& s) +auto make_arg_formatter(buffer_appender iter, format_specs& s) -> arg_formatter { return {iter, s, locale_ref()}; } -// The `printf` argument formatter. +// The ``printf`` argument formatter. template class printf_arg_formatter : public arg_formatter { private: @@ -245,96 +238,105 @@ class printf_arg_formatter : public arg_formatter { void write_null_pointer(bool is_string = false) { auto s = this->specs; - s.set_type(presentation_type::none); - write_bytes(this->out, is_string ? "(null)" : "(nil)", s); - } - - template void write(T value) { - detail::write(this->out, value, this->specs, this->locale); + s.type = presentation_type::none; + write_bytes(this->out, is_string ? "(null)" : "(nil)", s); } public: - printf_arg_formatter(basic_appender iter, format_specs& s, + printf_arg_formatter(buffer_appender iter, format_specs& s, context_type& ctx) : base(make_arg_formatter(iter, s)), context_(ctx) {} - void operator()(monostate value) { write(value); } + void operator()(monostate value) { base::operator()(value); } template ::value)> void operator()(T value) { // MSVC2013 fails to compile separate overloads for bool and Char so use // std::is_same instead. if (!std::is_same::value) { - write(value); + base::operator()(value); return; } - format_specs s = this->specs; - if (s.type() != presentation_type::none && - s.type() != presentation_type::chr) { + format_specs fmt_specs = this->specs; + if (fmt_specs.type != presentation_type::none && + fmt_specs.type != presentation_type::chr) { return (*this)(static_cast(value)); } - s.set_sign(sign::none); - s.clear_alt(); - s.set_fill(' '); // Ignore '0' flag for char types. + fmt_specs.sign = sign::none; + fmt_specs.alt = false; + fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types. // align::numeric needs to be overwritten here since the '0' flag is // ignored for non-numeric types - if (s.align() == align::none || s.align() == align::numeric) - s.set_align(align::right); - detail::write(this->out, static_cast(value), s); + if (fmt_specs.align == align::none || fmt_specs.align == align::numeric) + fmt_specs.align = align::right; + write(this->out, static_cast(value), fmt_specs); } template ::value)> void operator()(T value) { - write(value); + base::operator()(value); } + /** Formats a null-terminated C string. */ void operator()(const char* value) { if (value) - write(value); + base::operator()(value); else - write_null_pointer(this->specs.type() != presentation_type::pointer); + write_null_pointer(this->specs.type != presentation_type::pointer); } + /** Formats a null-terminated wide C string. */ void operator()(const wchar_t* value) { if (value) - write(value); + base::operator()(value); else - write_null_pointer(this->specs.type() != presentation_type::pointer); + write_null_pointer(this->specs.type != presentation_type::pointer); } - void operator()(basic_string_view value) { write(value); } + void operator()(basic_string_view value) { base::operator()(value); } + /** Formats a pointer. */ void operator()(const void* value) { if (value) - write(value); + base::operator()(value); else write_null_pointer(); } + /** Formats an argument of a custom (user-defined) type. */ void operator()(typename basic_format_arg::handle handle) { - auto parse_ctx = parse_context({}); + auto parse_ctx = basic_format_parse_context({}); handle.format(parse_ctx, context_); } }; template -void parse_flags(format_specs& specs, const Char*& it, const Char* end) { +void parse_flags(format_specs& specs, const Char*& it, const Char* end) { for (; it != end; ++it) { switch (*it) { - case '-': specs.set_align(align::left); break; - case '+': specs.set_sign(sign::plus); break; - case '0': specs.set_fill('0'); break; - case ' ': - if (specs.sign() != sign::plus) specs.set_sign(sign::space); + case '-': + specs.align = align::left; break; - case '#': specs.set_alt(); break; - default: return; + case '+': + specs.sign = sign::plus; + break; + case '0': + specs.fill[0] = '0'; + break; + case ' ': + if (specs.sign != sign::plus) specs.sign = sign::space; + break; + case '#': + specs.alt = true; + break; + default: + return; } } } template -auto parse_header(const Char*& it, const Char* end, format_specs& specs, +auto parse_header(const Char*& it, const Char* end, format_specs& specs, GetArg get_arg) -> int { int arg_index = -1; Char c = *it; @@ -346,11 +348,11 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs, ++it; arg_index = value != -1 ? value : max_value(); } else { - if (c == '0') specs.set_fill('0'); + if (c == '0') specs.fill[0] = '0'; if (value != 0) { // Nonzero value means that we parsed width and don't need to // parse it or flags again, so return now. - if (value == -1) report_error("number is too big"); + if (value == -1) throw_format_error("number is too big"); specs.width = value; return arg_index; } @@ -361,47 +363,63 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs, if (it != end) { if (*it >= '0' && *it <= '9') { specs.width = parse_nonnegative_int(it, end, -1); - if (specs.width == -1) report_error("number is too big"); + if (specs.width == -1) throw_format_error("number is too big"); } else if (*it == '*') { ++it; specs.width = static_cast( - get_arg(-1).visit(detail::printf_width_handler(specs))); + get_arg(-1).visit(detail::printf_width_handler(specs))); } } return arg_index; } -inline auto parse_printf_presentation_type(char c, type t, bool& upper) +inline auto parse_printf_presentation_type(char c, type t) -> presentation_type { using pt = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; switch (c) { - case 'd': return in(t, integral_set) ? pt::dec : pt::none; - case 'o': return in(t, integral_set) ? pt::oct : pt::none; - case 'X': upper = true; FMT_FALLTHROUGH; - case 'x': return in(t, integral_set) ? pt::hex : pt::none; - case 'E': upper = true; FMT_FALLTHROUGH; - case 'e': return in(t, float_set) ? pt::exp : pt::none; - case 'F': upper = true; FMT_FALLTHROUGH; - case 'f': return in(t, float_set) ? pt::fixed : pt::none; - case 'G': upper = true; FMT_FALLTHROUGH; - case 'g': return in(t, float_set) ? pt::general : pt::none; - case 'A': upper = true; FMT_FALLTHROUGH; - case 'a': return in(t, float_set) ? pt::hexfloat : pt::none; - case 'c': return in(t, integral_set) ? pt::chr : pt::none; - case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none; - case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none; - default: return pt::none; + case 'd': + return in(t, integral_set) ? pt::dec : pt::none; + case 'o': + return in(t, integral_set) ? pt::oct : pt::none; + case 'x': + return in(t, integral_set) ? pt::hex_lower : pt::none; + case 'X': + return in(t, integral_set) ? pt::hex_upper : pt::none; + case 'a': + return in(t, float_set) ? pt::hexfloat_lower : pt::none; + case 'A': + return in(t, float_set) ? pt::hexfloat_upper : pt::none; + case 'e': + return in(t, float_set) ? pt::exp_lower : pt::none; + case 'E': + return in(t, float_set) ? pt::exp_upper : pt::none; + case 'f': + return in(t, float_set) ? pt::fixed_lower : pt::none; + case 'F': + return in(t, float_set) ? pt::fixed_upper : pt::none; + case 'g': + return in(t, float_set) ? pt::general_lower : pt::none; + case 'G': + return in(t, float_set) ? pt::general_upper : pt::none; + case 'c': + return in(t, integral_set) ? pt::chr : pt::none; + case 's': + return in(t, string_set | cstring_set) ? pt::string : pt::none; + case 'p': + return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none; + default: + return pt::none; } } template void vprintf(buffer& buf, basic_string_view format, basic_format_args args) { - using iterator = basic_appender; + using iterator = buffer_appender; auto out = iterator(buf); auto context = basic_printf_context(out, args); - auto parse_ctx = parse_context(format); + auto parse_ctx = basic_format_parse_context(format); // Returns the argument with specified index or, if arg_index is -1, the next // argument. @@ -429,12 +447,12 @@ void vprintf(buffer& buf, basic_string_view format, } write(out, basic_string_view(start, to_unsigned(it - 1 - start))); - auto specs = format_specs(); - specs.set_align(align::right); + auto specs = format_specs(); + specs.align = align::right; // Parse argument index, flags and width. int arg_index = parse_header(it, end, specs, get_arg); - if (arg_index == 0) report_error("argument not found"); + if (arg_index == 0) throw_format_error("argument not found"); // Parse precision. if (it != end && *it == '.') { @@ -454,9 +472,9 @@ void vprintf(buffer& buf, basic_string_view format, auto arg = get_arg(arg_index); // For d, i, o, u, x, and X conversion specifiers, if a precision is // specified, the '0' flag is ignored - if (specs.precision >= 0 && is_integral_type(arg.type())) { + if (specs.precision >= 0 && arg.is_integral()) { // Ignore '0' for non-numeric types or if '-' present. - specs.set_fill(' '); + specs.fill[0] = ' '; } if (specs.precision >= 0 && arg.type() == type::cstring_type) { auto str = arg.visit(get_cstring()); @@ -464,16 +482,15 @@ void vprintf(buffer& buf, basic_string_view format, auto nul = std::find(str, str_end, Char()); auto sv = basic_string_view( str, to_unsigned(nul != str_end ? nul - str : specs.precision)); - arg = sv; + arg = make_arg>(sv); } - if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt(); - if (specs.fill_unit() == '0') { - if (is_arithmetic_type(arg.type()) && specs.align() != align::left) { - specs.set_align(align::numeric); - } else { - // Ignore '0' flag for non-numeric types or if '-' flag is also present. - specs.set_fill(' '); - } + if (specs.alt && arg.visit(is_zero_int())) specs.alt = false; + if (specs.fill[0] == '0') { + if (arg.is_arithmetic() && specs.align != align::left) + specs.align = align::numeric; + else + specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-' + // flag is also present. } // Parse length and convert the argument to the required type. @@ -498,34 +515,42 @@ void vprintf(buffer& buf, basic_string_view format, convert_arg(arg, t); } break; - case 'j': convert_arg(arg, t); break; - case 'z': convert_arg(arg, t); break; - case 't': convert_arg(arg, t); break; + case 'j': + convert_arg(arg, t); + break; + case 'z': + convert_arg(arg, t); + break; + case 't': + convert_arg(arg, t); + break; case 'L': // printf produces garbage when 'L' is omitted for long double, no // need to do the same. break; - default: --it; convert_arg(arg, c); + default: + --it; + convert_arg(arg, c); } // Parse type. - if (it == end) report_error("invalid format string"); + if (it == end) throw_format_error("invalid format string"); char type = static_cast(*it++); - if (is_integral_type(arg.type())) { + if (arg.is_integral()) { // Normalize type. switch (type) { case 'i': - case 'u': type = 'd'; break; + case 'u': + type = 'd'; + break; case 'c': arg.visit(char_converter>(arg)); break; } } - bool upper = false; - specs.set_type(parse_printf_presentation_type(type, arg.type(), upper)); - if (specs.type() == presentation_type::none) - report_error("invalid format specifier"); - if (upper) specs.set_upper(); + specs.type = parse_printf_presentation_type(type, arg.type()); + if (specs.type == presentation_type::none) + throw_format_error("invalid format specifier"); start = it; @@ -542,44 +567,56 @@ using wprintf_context = basic_printf_context; using printf_args = basic_format_args; using wprintf_args = basic_format_args; -/// Constructs an `format_arg_store` object that contains references to -/// arguments and can be implicitly converted to `printf_args`. -template -inline auto make_printf_args(T&... args) - -> decltype(fmt::make_format_args>(args...)) { - return fmt::make_format_args>(args...); +/** + \rst + Constructs an `~fmt::format_arg_store` object that contains references to + arguments and can be implicitly converted to `~fmt::printf_args`. + \endrst + */ +template +inline auto make_printf_args(const T&... args) + -> format_arg_store { + return {args...}; } -template struct vprintf_args { - using type = basic_format_args>; -}; +// DEPRECATED! +template +inline auto make_wprintf_args(const T&... args) + -> format_arg_store { + return {args...}; +} template -inline auto vsprintf(basic_string_view fmt, - typename vprintf_args::type args) +inline auto vsprintf( + basic_string_view fmt, + basic_format_args>> args) -> std::basic_string { auto buf = basic_memory_buffer(); detail::vprintf(buf, fmt, args); - return {buf.data(), buf.size()}; + return to_string(buf); } /** - * Formats `args` according to specifications in `fmt` and returns the result - * as as string. - * - * **Example**: - * - * std::string message = fmt::sprintf("The answer is %d", 42); - */ -template > + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + std::string message = fmt::sprintf("The answer is %d", 42); + \endrst +*/ +template ::value, char_t>> inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string { return vsprintf(detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template -inline auto vfprintf(std::FILE* f, basic_string_view fmt, - typename vprintf_args::type args) -> int { +inline auto vfprintf( + std::FILE* f, basic_string_view fmt, + basic_format_args>> args) + -> int { auto buf = basic_memory_buffer(); detail::vprintf(buf, fmt, args); size_t size = buf.size(); @@ -589,33 +626,36 @@ inline auto vfprintf(std::FILE* f, basic_string_view fmt, } /** - * Formats `args` according to specifications in `fmt` and writes the output - * to `f`. - * - * **Example**: - * - * fmt::fprintf(stderr, "Don't %s!", "panic"); + \rst + Prints formatted data to the file *f*. + + **Example**:: + + fmt::fprintf(stderr, "Don't %s!", "panic"); + \endrst */ -template > +template > inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int { return vfprintf(f, detail::to_string_view(fmt), - make_printf_args(args...)); + fmt::make_format_args>(args...)); } template -FMT_DEPRECATED inline auto vprintf(basic_string_view fmt, - typename vprintf_args::type args) +FMT_DEPRECATED inline auto vprintf( + basic_string_view fmt, + basic_format_args>> args) -> int { return vfprintf(stdout, fmt, args); } /** - * Formats `args` according to specifications in `fmt` and writes the output - * to `stdout`. - * - * **Example**: - * - * fmt::printf("Elapsed time: %.2f seconds", 1.23); + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + fmt::printf("Elapsed time: %.2f seconds", 1.23); + \endrst */ template inline auto printf(string_view fmt, const T&... args) -> int { @@ -624,7 +664,7 @@ inline auto printf(string_view fmt, const T&... args) -> int { template FMT_DEPRECATED inline auto printf(basic_string_view fmt, const T&... args) -> int { - return vfprintf(stdout, fmt, make_printf_args(args...)); + return vfprintf(stdout, fmt, make_wprintf_args(args...)); } FMT_END_EXPORT diff --git a/src/fmt/ranges.h b/src/fmt/ranges.h index 118d24fe81..a9cd60e594 100644 --- a/src/fmt/ranges.h +++ b/src/fmt/ranges.h @@ -8,31 +8,67 @@ #ifndef FMT_RANGES_H_ #define FMT_RANGES_H_ -#ifndef FMT_MODULE -# include -# include -# include -# include -# include -# include -#endif +#include +#include +#include #include "format.h" FMT_BEGIN_NAMESPACE -FMT_EXPORT -enum class range_format { disabled, map, set, sequence, string, debug_string }; - namespace detail { +template +auto copy(const Range& range, OutputIt out) -> OutputIt { + for (auto it = range.begin(), end = range.end(); it != end; ++it) + *out++ = *it; + return out; +} + +template +auto copy(const char* str, OutputIt out) -> OutputIt { + while (*str) *out++ = *str++; + return out; +} + +template auto copy(char ch, OutputIt out) -> OutputIt { + *out++ = ch; + return out; +} + +template auto copy(wchar_t ch, OutputIt out) -> OutputIt { + *out++ = ch; + return out; +} + +// Returns true if T has a std::string-like interface, like std::string_view. +template class is_std_string_like { + template + static auto check(U* p) + -> decltype((void)p->find('a'), p->length(), (void)p->data(), int()); + template static void check(...); + + public: + static constexpr const bool value = + is_string::value || + std::is_convertible>::value || + !std::is_void(nullptr))>::value; +}; + +template +struct is_std_string_like> : std::true_type {}; + template class is_map { template static auto check(U*) -> typename U::mapped_type; template static void check(...); public: +#ifdef FMT_FORMAT_MAP_AS_LIST // DEPRECATED! + static constexpr const bool value = false; +#else static constexpr const bool value = !std::is_void(nullptr))>::value; +#endif }; template class is_set { @@ -40,10 +76,26 @@ template class is_set { template static void check(...); public: +#ifdef FMT_FORMAT_SET_AS_LIST // DEPRECATED! + static constexpr const bool value = false; +#else static constexpr const bool value = !std::is_void(nullptr))>::value && !is_map::value; +#endif }; +template struct conditional_helper {}; + +template struct is_range_ : std::false_type {}; + +#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800 + +# define FMT_DECLTYPE_RETURN(val) \ + ->decltype(val) { return val; } \ + static_assert( \ + true, "") // This makes it so that a semicolon is required after the + // macro, which helps clang-format handle the formatting. + // C array overload template auto range_begin(const T (&arr)[N]) -> const T* { @@ -58,21 +110,17 @@ template struct has_member_fn_begin_end_t : std::false_type {}; template -struct has_member_fn_begin_end_t().begin()), +struct has_member_fn_begin_end_t().begin()), decltype(std::declval().end())>> : std::true_type {}; -// Member function overloads. +// Member function overload template -auto range_begin(T&& rng) -> decltype(static_cast(rng).begin()) { - return static_cast(rng).begin(); -} +auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).begin()); template -auto range_end(T&& rng) -> decltype(static_cast(rng).end()) { - return static_cast(rng).end(); -} +auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).end()); -// ADL overloads. Only participate in overload resolution if member functions +// ADL overload. Only participates in overload resolution if member functions // are not found. template auto range_begin(T&& rng) @@ -93,30 +141,31 @@ struct has_mutable_begin_end : std::false_type {}; template struct has_const_begin_end< - T, void_t&>())), - decltype(detail::range_end( - std::declval&>()))>> + T, + void_t< + decltype(detail::range_begin(std::declval&>())), + decltype(detail::range_end(std::declval&>()))>> : std::true_type {}; template struct has_mutable_begin_end< - T, void_t())), - decltype(detail::range_end(std::declval())), + T, void_t())), + decltype(detail::range_end(std::declval())), // the extra int here is because older versions of MSVC don't // SFINAE properly unless there are distinct types int>> : std::true_type {}; -template struct is_range_ : std::false_type {}; template struct is_range_ : std::integral_constant::value || has_mutable_begin_end::value)> {}; +# undef FMT_DECLTYPE_RETURN +#endif // tuple_size and tuple_element check. template class is_tuple_like_ { - template ::type> - static auto check(U* p) -> decltype(std::tuple_size::value, 0); + template + static auto check(U* p) -> decltype(std::tuple_size::value, int()); template static void check(...); public: @@ -157,13 +206,12 @@ class is_tuple_formattable_ { static constexpr const bool value = false; }; template class is_tuple_formattable_ { - template - static auto all_true(index_sequence, - integer_sequence= 0)...>) -> std::true_type; - static auto all_true(...) -> std::false_type; - - template - static auto check(index_sequence) -> decltype(all_true( + template + static auto check2(index_sequence, + integer_sequence) -> std::true_type; + static auto check2(...) -> std::false_type; + template + static auto check(index_sequence) -> decltype(check2( index_sequence{}, integer_sequence::type, @@ -244,32 +292,21 @@ FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) template FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} -template -struct range_format_kind_ - : std::integral_constant, T>::value - ? range_format::disabled - : is_map::value ? range_format::map - : is_set::value ? range_format::set - : range_format::sequence> {}; - -template -using range_format_constant = std::integral_constant; - // These are not generic lambdas for compatibility with C++11. -template struct parse_empty_specs { +template struct parse_empty_specs { template FMT_CONSTEXPR void operator()(Formatter& f) { f.parse(ctx); detail::maybe_set_debug_format(f, true); } - parse_context& ctx; + ParseContext& ctx; }; template struct format_tuple_element { using char_type = typename FormatContext::char_type; template void operator()(const formatter& f, const T& v) { - if (i > 0) ctx.advance_to(detail::copy(separator, ctx.out())); + if (i > 0) + ctx.advance_to(detail::copy_str(separator, ctx.out())); ctx.advance_to(f.format(v, ctx)); ++i; } @@ -318,48 +355,66 @@ struct formatter& ctx) -> const Char* { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); - auto end = ctx.end(); - if (it != end && detail::to_ascii(*it) == 'n') { - ++it; - set_brackets({}, {}); - set_separator({}); - } - if (it != end && *it != '}') report_error("invalid format specifier"); - ctx.advance_to(it); - detail::for_each(formatters_, detail::parse_empty_specs{ctx}); + if (it != ctx.end() && *it != '}') + FMT_THROW(format_error("invalid format specifier")); + detail::for_each(formatters_, detail::parse_empty_specs{ctx}); return it; } template auto format(const Tuple& value, FormatContext& ctx) const -> decltype(ctx.out()) { - ctx.advance_to(detail::copy(opening_bracket_, ctx.out())); + ctx.advance_to(detail::copy_str(opening_bracket_, ctx.out())); detail::for_each2( formatters_, value, detail::format_tuple_element{0, ctx, separator_}); - return detail::copy(closing_bracket_, ctx.out()); + return detail::copy_str(closing_bracket_, ctx.out()); } }; template struct is_range { static constexpr const bool value = - detail::is_range_::value && !detail::has_to_string_view::value; + detail::is_range_::value && !detail::is_std_string_like::value && + !std::is_convertible>::value && + !std::is_convertible>::value; }; namespace detail { +template struct range_mapper { + using mapper = arg_mapper; + + template , Context>::value)> + static auto map(T&& value) -> T&& { + return static_cast(value); + } + template , Context>::value)> + static auto map(T&& value) + -> decltype(mapper().map(static_cast(value))) { + return mapper().map(static_cast(value)); + } +}; template -using range_formatter_type = formatter, Char>; +using range_formatter_type = + formatter>{}.map( + std::declval()))>, + Char>; template using maybe_const_range = conditional_t::value, const R, R>; +// Workaround a bug in MSVC 2015 and earlier. +#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 template struct is_formattable_delayed : is_formattable>, Char> {}; +#endif } // namespace detail template struct conjunction : std::true_type {}; @@ -383,24 +438,6 @@ struct range_formatter< detail::string_literal{}; basic_string_view closing_bracket_ = detail::string_literal{}; - bool is_debug = false; - - template ::value)> - auto write_debug_string(Output& out, It it, Sentinel end) const -> Output { - auto buf = basic_memory_buffer(); - for (; it != end; ++it) buf.push_back(*it); - auto specs = format_specs(); - specs.set_type(presentation_type::debug); - return detail::write( - out, basic_string_view(buf.data(), buf.size()), specs); - } - - template ::value)> - auto write_debug_string(Output& out, It, Sentinel) const -> Output { - return out; - } public: FMT_CONSTEXPR range_formatter() {} @@ -419,40 +456,21 @@ struct range_formatter< closing_bracket_ = close; } - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); auto end = ctx.end(); - detail::maybe_set_debug_format(underlying_, true); - if (it == end) return underlying_.parse(ctx); - switch (detail::to_ascii(*it)) { - case 'n': + if (it != end && *it == 'n') { set_brackets({}, {}); ++it; - break; - case '?': - is_debug = true; - set_brackets({}, {}); - ++it; - if (it == end || *it != 's') report_error("invalid format specifier"); - FMT_FALLTHROUGH; - case 's': - if (!std::is_same::value) - report_error("invalid format specifier"); - if (!is_debug) { - set_brackets(detail::string_literal{}, - detail::string_literal{}); - set_separator({}); - detail::maybe_set_debug_format(underlying_, false); - } - ++it; - return it; } if (it != end && *it != '}') { - if (*it != ':') report_error("invalid format specifier"); - detail::maybe_set_debug_format(underlying_, false); + if (*it != ':') FMT_THROW(format_error("invalid format specifier")); ++it; + } else { + detail::maybe_set_debug_format(underlying_, true); } ctx.advance_to(it); @@ -461,26 +479,80 @@ struct range_formatter< template auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) { + detail::range_mapper> mapper; auto out = ctx.out(); + out = detail::copy_str(opening_bracket_, out); + int i = 0; auto it = detail::range_begin(range); auto end = detail::range_end(range); - if (is_debug) return write_debug_string(out, std::move(it), end); - - out = detail::copy(opening_bracket_, out); - int i = 0; for (; it != end; ++it) { - if (i > 0) out = detail::copy(separator_, out); + if (i > 0) out = detail::copy_str(separator_, out); ctx.advance_to(out); - auto&& item = *it; // Need an lvalue - out = underlying_.format(item, ctx); + auto&& item = *it; + out = underlying_.format(mapper.map(item), ctx); ++i; } - out = detail::copy(closing_bracket_, out); + out = detail::copy_str(closing_bracket_, out); return out; } }; -FMT_EXPORT +enum class range_format { disabled, map, set, sequence, string, debug_string }; + +namespace detail { +template +struct range_format_kind_ + : std::integral_constant, T>::value + ? range_format::disabled + : is_map::value ? range_format::map + : is_set::value ? range_format::set + : range_format::sequence> {}; + +template +struct range_default_formatter; + +template +using range_format_constant = std::integral_constant; + +template +struct range_default_formatter< + K, R, Char, + enable_if_t<(K == range_format::sequence || K == range_format::map || + K == range_format::set)>> { + using range_type = detail::maybe_const_range; + range_formatter, Char> underlying_; + + FMT_CONSTEXPR range_default_formatter() { init(range_format_constant()); } + + FMT_CONSTEXPR void init(range_format_constant) { + underlying_.set_brackets(detail::string_literal{}, + detail::string_literal{}); + } + + FMT_CONSTEXPR void init(range_format_constant) { + underlying_.set_brackets(detail::string_literal{}, + detail::string_literal{}); + underlying_.underlying().set_brackets({}, {}); + underlying_.underlying().set_separator( + detail::string_literal{}); + } + + FMT_CONSTEXPR void init(range_format_constant) {} + + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return underlying_.parse(ctx); + } + + template + auto format(range_type& range, FormatContext& ctx) const + -> decltype(ctx.out()) { + return underlying_.format(range, ctx); + } +}; +} // namespace detail + template struct range_format_kind : conditional_t< @@ -490,131 +562,16 @@ struct range_format_kind template struct formatter< R, Char, - enable_if_t::value != range_format::disabled && - range_format_kind::value != range_format::map && - range_format_kind::value != range_format::string && - range_format_kind::value != range_format::debug_string>, - detail::is_formattable_delayed>::value>> { - private: - using range_type = detail::maybe_const_range; - range_formatter, Char> range_formatter_; - - public: - using nonlocking = void; - - FMT_CONSTEXPR formatter() { - if (detail::const_check(range_format_kind::value != - range_format::set)) - return; - range_formatter_.set_brackets(detail::string_literal{}, - detail::string_literal{}); - } - - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - return range_formatter_.parse(ctx); - } - - template - auto format(range_type& range, FormatContext& ctx) const - -> decltype(ctx.out()) { - return range_formatter_.format(range, ctx); - } -}; - -// A map formatter. -template -struct formatter< - R, Char, - enable_if_t::value == range_format::map>> { - private: - using map_type = detail::maybe_const_range; - using element_type = detail::uncvref_type; - - decltype(detail::tuple::get_formatters( - detail::tuple_index_sequence())) formatters_; - bool no_delimiters_ = false; - - public: - FMT_CONSTEXPR formatter() {} - - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - auto it = ctx.begin(); - auto end = ctx.end(); - if (it != end) { - if (detail::to_ascii(*it) == 'n') { - no_delimiters_ = true; - ++it; - } - if (it != end && *it != '}') { - if (*it != ':') report_error("invalid format specifier"); - ++it; - } - ctx.advance_to(it); - } - detail::for_each(formatters_, detail::parse_empty_specs{ctx}); - return it; - } - - template - auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) { - auto out = ctx.out(); - basic_string_view open = detail::string_literal{}; - if (!no_delimiters_) out = detail::copy(open, out); - int i = 0; - basic_string_view sep = detail::string_literal{}; - for (auto&& value : map) { - if (i > 0) out = detail::copy(sep, out); - ctx.advance_to(out); - detail::for_each2(formatters_, value, - detail::format_tuple_element{ - 0, ctx, detail::string_literal{}}); - ++i; - } - basic_string_view close = detail::string_literal{}; - if (!no_delimiters_) out = detail::copy(close, out); - return out; - } -}; - -// A (debug_)string formatter. -template -struct formatter< - R, Char, - enable_if_t::value == range_format::string || - range_format_kind::value == - range_format::debug_string>> { - private: - using range_type = detail::maybe_const_range; - using string_type = - conditional_t, - decltype(detail::range_begin(std::declval())), - decltype(detail::range_end(std::declval()))>::value, - detail::std_string_view, std::basic_string>; - - formatter underlying_; - - public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - return underlying_.parse(ctx); - } - - template - auto format(range_type& range, FormatContext& ctx) const - -> decltype(ctx.out()) { - auto out = ctx.out(); - if (detail::const_check(range_format_kind::value == - range_format::debug_string)) - *out++ = '"'; - out = underlying_.format( - string_type{detail::range_begin(range), detail::range_end(range)}, ctx); - if (detail::const_check(range_format_kind::value == - range_format::debug_string)) - *out++ = '"'; - return out; - } + enable_if_t::value != + range_format::disabled> +// Workaround a bug in MSVC 2015 and earlier. +#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 + , + detail::is_formattable_delayed +#endif + >::value>> + : detail::range_default_formatter::value, R, + Char> { }; template @@ -624,7 +581,7 @@ struct join_view : detail::view { basic_string_view sep; join_view(It b, Sentinel e, basic_string_view s) - : begin(std::move(b)), end(e), sep(s) {} + : begin(b), end(e), sep(s) {} }; template @@ -638,41 +595,67 @@ struct formatter, Char> { #endif formatter, Char> value_formatter_; - using view = conditional_t::value, - const join_view, - join_view>; - public: - using nonlocking = void; - - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { return value_formatter_.parse(ctx); } template - auto format(view& value, FormatContext& ctx) const -> decltype(ctx.out()) { - using iter = - conditional_t::value, It, It&>; - iter it = value.begin; + auto format(const join_view& value, + FormatContext& ctx) const -> decltype(ctx.out()) { + auto it = value.begin; auto out = ctx.out(); - if (it == value.end) return out; - out = value_formatter_.format(*it, ctx); - ++it; - while (it != value.end) { - out = detail::copy(value.sep.begin(), value.sep.end(), out); - ctx.advance_to(out); + if (it != value.end) { out = value_formatter_.format(*it, ctx); ++it; + while (it != value.end) { + out = detail::copy_str(value.sep.begin(), value.sep.end(), out); + ctx.advance_to(out); + out = value_formatter_.format(*it, ctx); + ++it; + } } return out; } }; -template struct tuple_join_view : detail::view { - const Tuple& tuple; +/** + Returns a view that formats the iterator range `[begin, end)` with elements + separated by `sep`. + */ +template +auto join(It begin, Sentinel end, string_view sep) -> join_view { + return {begin, end, sep}; +} + +/** + \rst + Returns a view that formats `range` with elements separated by `sep`. + + **Example**:: + + std::vector v = {1, 2, 3}; + fmt::print("{}", fmt::join(v, ", ")); + // Output: "1, 2, 3" + + ``fmt::join`` applies passed format specifiers to the range elements:: + + fmt::print("{:02}", fmt::join(v, ", ")); + // Output: "01, 02, 03" + \endrst + */ +template +auto join(Range&& range, string_view sep) + -> join_view, detail::sentinel_t> { + return join(std::begin(range), std::end(range), sep); +} + +template struct tuple_join_view : detail::view { + const std::tuple& tuple; basic_string_view sep; - tuple_join_view(const Tuple& t, basic_string_view s) + tuple_join_view(const std::tuple& t, basic_string_view s) : tuple(t), sep{s} {} }; @@ -683,64 +666,65 @@ template struct tuple_join_view : detail::view { # define FMT_TUPLE_JOIN_SPECIFIERS 0 #endif -template -struct formatter, Char, - enable_if_t::value>> { - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - return do_parse(ctx, std::tuple_size()); +template +struct formatter, Char> { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return do_parse(ctx, std::integral_constant()); } template - auto format(const tuple_join_view& value, + auto format(const tuple_join_view& value, FormatContext& ctx) const -> typename FormatContext::iterator { - return do_format(value, ctx, std::tuple_size()); + return do_format(value, ctx, + std::integral_constant()); } private: - decltype(detail::tuple::get_formatters( - detail::tuple_index_sequence())) formatters_; + std::tuple::type, Char>...> formatters_; - FMT_CONSTEXPR auto do_parse(parse_context& ctx, + template + FMT_CONSTEXPR auto do_parse(ParseContext& ctx, std::integral_constant) - -> const Char* { + -> decltype(ctx.begin()) { return ctx.begin(); } - template - FMT_CONSTEXPR auto do_parse(parse_context& ctx, + template + FMT_CONSTEXPR auto do_parse(ParseContext& ctx, std::integral_constant) - -> const Char* { + -> decltype(ctx.begin()) { auto end = ctx.begin(); #if FMT_TUPLE_JOIN_SPECIFIERS - end = std::get::value - N>(formatters_).parse(ctx); + end = std::get(formatters_).parse(ctx); if (N > 1) { auto end1 = do_parse(ctx, std::integral_constant()); if (end != end1) - report_error("incompatible format specs for tuple elements"); + FMT_THROW(format_error("incompatible format specs for tuple elements")); } #endif return end; } template - auto do_format(const tuple_join_view&, FormatContext& ctx, + auto do_format(const tuple_join_view&, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator { return ctx.out(); } template - auto do_format(const tuple_join_view& value, FormatContext& ctx, + auto do_format(const tuple_join_view& value, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator { - using std::get; - auto out = - std::get::value - N>(formatters_) - .format(get::value - N>(value.tuple), ctx); - if (N <= 1) return out; - out = detail::copy(value.sep, out); - ctx.advance_to(out); - return do_format(value, ctx, std::integral_constant()); + auto out = std::get(formatters_) + .format(std::get(value.tuple), ctx); + if (N > 1) { + out = std::copy(value.sep.begin(), value.sep.end(), out); + ctx.advance_to(out); + return do_format(value, ctx, std::integral_constant()); + } + return out; } }; @@ -784,57 +768,33 @@ struct formatter< FMT_BEGIN_EXPORT -/// Returns a view that formats the iterator range `[begin, end)` with elements -/// separated by `sep`. -template -auto join(It begin, Sentinel end, string_view sep) -> join_view { - return {std::move(begin), end, sep}; -} - /** - * Returns a view that formats `range` with elements separated by `sep`. - * - * **Example**: - * - * auto v = std::vector{1, 2, 3}; - * fmt::print("{}", fmt::join(v, ", ")); - * // Output: 1, 2, 3 - * - * `fmt::join` applies passed format specifiers to the range elements: - * - * fmt::print("{:02}", fmt::join(v, ", ")); - * // Output: 01, 02, 03 - */ -template ::value)> -auto join(Range&& r, string_view sep) - -> join_view { - return {detail::range_begin(r), detail::range_end(r), sep}; -} + \rst + Returns an object that formats `tuple` with elements separated by `sep`. -/** - * Returns an object that formats `std::tuple` with elements separated by `sep`. - * - * **Example**: - * - * auto t = std::tuple{1, 'a'}; - * fmt::print("{}", fmt::join(t, ", ")); - * // Output: 1, a + **Example**:: + + std::tuple t = {1, 'a'}; + fmt::print("{}", fmt::join(t, ", ")); + // Output: "1, a" + \endrst */ -template ::value)> -FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep) - -> tuple_join_view { +template +FMT_CONSTEXPR auto join(const std::tuple& tuple, string_view sep) + -> tuple_join_view { return {tuple, sep}; } /** - * Returns an object that formats `std::initializer_list` with elements - * separated by `sep`. - * - * **Example**: - * - * fmt::print("{}", fmt::join({1, 2, 3}, ", ")); - * // Output: "1, 2, 3" + \rst + Returns an object that formats `initializer_list` with elements separated by + `sep`. + + **Example**:: + + fmt::print("{}", fmt::join({1, 2, 3}, ", ")); + // Output: "1, 2, 3" + \endrst */ template auto join(std::initializer_list list, string_view sep) diff --git a/src/fmt/std.h b/src/fmt/std.h index 54eb2c2a73..7cff115920 100644 --- a/src/fmt/std.h +++ b/src/fmt/std.h @@ -8,49 +8,39 @@ #ifndef FMT_STD_H_ #define FMT_STD_H_ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + #include "format.h" #include "ostream.h" -#ifndef FMT_MODULE -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include - -// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC. -# if FMT_CPLUSPLUS >= 201703L -# if FMT_HAS_INCLUDE() && \ - (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0) -# include -# endif -# if FMT_HAS_INCLUDE() -# include -# endif -# if FMT_HAS_INCLUDE() -# include -# endif -# endif -// Use > instead of >= in the version check because may be -// available after C++17 but before C++20 is marked as implemented. -# if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE() -# include -# endif -# if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE() -# include -# endif -#endif // FMT_MODULE - #if FMT_HAS_INCLUDE() # include #endif +// Checking FMT_CPLUSPLUS for warning suppression in MSVC. +#if FMT_CPLUSPLUS >= 201703L +# if FMT_HAS_INCLUDE() +# include +# endif +# if FMT_HAS_INCLUDE() +# include +# endif +# if FMT_HAS_INCLUDE() +# include +# endif +#endif + +#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE() +# include +#endif // GCC 4 does not support FMT_HAS_INCLUDE. #if FMT_HAS_INCLUDE() || defined(__GLIBCXX__) @@ -62,6 +52,17 @@ # endif #endif +// Check if typeid is available. +#ifndef FMT_USE_TYPEID +// __RTTI is for EDG compilers. In MSVC typeid is available without RTTI. +# if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \ + defined(__INTEL_RTTI__) || defined(__RTTI) +# define FMT_USE_TYPEID 1 +# else +# define FMT_USE_TYPEID 0 +# endif +#endif + // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined. #ifndef FMT_CPP_LIB_FILESYSTEM # ifdef __cpp_lib_filesystem @@ -116,7 +117,7 @@ void write_escaped_path(basic_memory_buffer& quoted, FMT_EXPORT template struct formatter { private: - format_specs specs_; + format_specs specs_; detail::arg_ref width_ref_; bool debug_ = false; char path_type_ = 0; @@ -124,33 +125,33 @@ template struct formatter { public: FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } - FMT_CONSTEXPR auto parse(parse_context& ctx) { + template FMT_CONSTEXPR auto parse(ParseContext& ctx) { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; - Char c = *it; - if ((c >= '0' && c <= '9') || c == '{') - it = detail::parse_width(it, end, specs_, width_ref_, ctx); + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); if (it != end && *it == '?') { debug_ = true; ++it; } - if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++); + if (it != end && (*it == 'g')) path_type_ = *it++; return it; } template auto format(const std::filesystem::path& p, FormatContext& ctx) const { auto specs = specs_; - auto path_string = - !path_type_ ? p.native() - : p.generic_string(); +# ifdef _WIN32 + auto path_string = !path_type_ ? p.native() : p.generic_wstring(); +# else + auto path_string = !path_type_ ? p.native() : p.generic_string(); +# endif - detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, - ctx); + detail::handle_dynamic_spec(specs.width, width_ref_, + ctx); if (!debug_) { auto s = detail::get_path_string(p, path_string); return detail::write(ctx.out(), basic_string_view(s), specs); @@ -162,30 +163,13 @@ template struct formatter { specs); } }; - -class path : public std::filesystem::path { - public: - auto display_string() const -> std::string { - const std::filesystem::path& base = *this; - return fmt::format(FMT_STRING("{}"), base); - } - auto system_string() const -> std::string { return string(); } - - auto generic_display_string() const -> std::string { - const std::filesystem::path& base = *this; - return fmt::format(FMT_STRING("{:g}"), base); - } - auto generic_system_string() const -> std::string { return generic_string(); } -}; - FMT_END_NAMESPACE #endif // FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE FMT_EXPORT template -struct formatter, Char> - : nested_formatter, Char> { +struct formatter, Char> : nested_formatter { private: // Functor because C++11 doesn't support generic lambdas. struct writer { @@ -205,7 +189,7 @@ struct formatter, Char> template auto format(const std::bitset& bs, FormatContext& ctx) const -> decltype(ctx.out()) { - return this->write_padded(ctx, writer{bs}); + return write_padded(ctx, writer{bs}); } }; @@ -238,7 +222,7 @@ struct formatter, Char, FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {} public: - FMT_CONSTEXPR auto parse(parse_context& ctx) { + template FMT_CONSTEXPR auto parse(ParseContext& ctx) { maybe_set_debug_format(underlying_, true); return underlying_.parse(ctx); } @@ -258,62 +242,13 @@ struct formatter, Char, FMT_END_NAMESPACE #endif // __cpp_lib_optional -#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT - -FMT_BEGIN_NAMESPACE -namespace detail { - -template -auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt { - if constexpr (has_to_string_view::value) - return write_escaped_string(out, detail::to_string_view(v)); - if constexpr (std::is_same_v) return write_escaped_char(out, v); - return write(out, v); -} - -} // namespace detail - -FMT_END_NAMESPACE -#endif - -#ifdef __cpp_lib_expected -FMT_BEGIN_NAMESPACE - -FMT_EXPORT -template -struct formatter, Char, - std::enable_if_t<(std::is_void::value || - is_formattable::value) && - is_formattable::value>> { - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - return ctx.begin(); - } - - template - auto format(const std::expected& value, FormatContext& ctx) const - -> decltype(ctx.out()) { - auto out = ctx.out(); - - if (value.has_value()) { - out = detail::write(out, "expected("); - if constexpr (!std::is_void::value) - out = detail::write_escaped_alternative(out, *value); - } else { - out = detail::write(out, "unexpected("); - out = detail::write_escaped_alternative(out, value.error()); - } - *out++ = ')'; - return out; - } -}; -FMT_END_NAMESPACE -#endif // __cpp_lib_expected - #ifdef __cpp_lib_source_location FMT_BEGIN_NAMESPACE FMT_EXPORT template <> struct formatter { - FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); } + template FMT_CONSTEXPR auto parse(ParseContext& ctx) { + return ctx.begin(); + } template auto format(const std::source_location& loc, FormatContext& ctx) const @@ -356,6 +291,16 @@ template class is_variant_formattable_ { decltype(check(variant_index_sequence{}))::value; }; +template +auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt { + if constexpr (is_string::value) + return write_escaped_string(out, detail::to_string_view(v)); + else if constexpr (std::is_same_v) + return write_escaped_char(out, v); + else + return write(out, v); +} + } // namespace detail template struct is_variant_like { @@ -369,7 +314,8 @@ template struct is_variant_formattable { FMT_EXPORT template struct formatter { - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return ctx.begin(); } @@ -386,7 +332,8 @@ struct formatter< Variant, Char, std::enable_if_t, is_variant_formattable>>> { - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return ctx.begin(); } @@ -399,7 +346,7 @@ struct formatter< FMT_TRY { std::visit( [&](const auto& v) { - out = detail::write_escaped_alternative(out, v); + out = detail::write_variant_alternative(out, v); }, value); } @@ -415,127 +362,22 @@ FMT_END_NAMESPACE FMT_BEGIN_NAMESPACE FMT_EXPORT -template <> struct formatter { - private: - format_specs specs_; - detail::arg_ref width_ref_; - - public: - FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { - auto it = ctx.begin(), end = ctx.end(); - if (it == end) return it; - - it = detail::parse_align(it, end, specs_); - if (it == end) return it; - - char c = *it; - if ((c >= '0' && c <= '9') || c == '{') - it = detail::parse_width(it, end, specs_, width_ref_, ctx); - return it; - } - - template - FMT_CONSTEXPR20 auto format(const std::error_code& ec, - FormatContext& ctx) const -> decltype(ctx.out()) { - auto specs = specs_; - detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, - ctx); - memory_buffer buf; - buf.append(string_view(ec.category().name())); - buf.push_back(':'); - detail::write(appender(buf), ec.value()); - return detail::write(ctx.out(), string_view(buf.data(), buf.size()), - specs); - } -}; - -#if FMT_USE_RTTI -namespace detail { - -template -auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt { -# ifdef FMT_HAS_ABI_CXA_DEMANGLE - int status = 0; - std::size_t size = 0; - std::unique_ptr demangled_name_ptr( - abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); - - string_view demangled_name_view; - if (demangled_name_ptr) { - demangled_name_view = demangled_name_ptr.get(); - - // Normalization of stdlib inline namespace names. - // libc++ inline namespaces. - // std::__1::* -> std::* - // std::__1::__fs::* -> std::* - // libstdc++ inline namespaces. - // std::__cxx11::* -> std::* - // std::filesystem::__cxx11::* -> std::filesystem::* - if (demangled_name_view.starts_with("std::")) { - char* begin = demangled_name_ptr.get(); - char* to = begin + 5; // std:: - for (char *from = to, *end = begin + demangled_name_view.size(); - from < end;) { - // This is safe, because demangled_name is NUL-terminated. - if (from[0] == '_' && from[1] == '_') { - char* next = from + 1; - while (next < end && *next != ':') next++; - if (next[0] == ':' && next[1] == ':') { - from = next + 2; - continue; - } - } - *to++ = *from++; - } - demangled_name_view = {begin, detail::to_unsigned(to - begin)}; - } - } else { - demangled_name_view = string_view(ti.name()); - } - return detail::write_bytes(out, demangled_name_view); -# elif FMT_MSC_VERSION - const string_view demangled_name(ti.name()); - for (std::size_t i = 0; i < demangled_name.size(); ++i) { - auto sub = demangled_name; - sub.remove_prefix(i); - if (sub.starts_with("enum ")) { - i += 4; - continue; - } - if (sub.starts_with("class ") || sub.starts_with("union ")) { - i += 5; - continue; - } - if (sub.starts_with("struct ")) { - i += 6; - continue; - } - if (*sub.begin() != ' ') *out++ = *sub.begin(); - } - return out; -# else - return detail::write_bytes(out, string_view(ti.name())); -# endif -} - -} // namespace detail - -FMT_EXPORT -template -struct formatter { - public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { +template struct formatter { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return ctx.begin(); } - template - auto format(const std::type_info& ti, Context& ctx) const + template + FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const -> decltype(ctx.out()) { - return detail::write_demangled_name(ctx.out(), ti); + auto out = ctx.out(); + out = detail::write_bytes(out, ec.category().name(), format_specs()); + out = detail::write(out, Char(':')); + out = detail::write(out, ec.value()); + return out; } }; -#endif FMT_EXPORT template @@ -546,29 +388,81 @@ struct formatter< bool with_typename_ = false; public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { auto it = ctx.begin(); auto end = ctx.end(); if (it == end || *it == '}') return it; if (*it == 't') { ++it; - with_typename_ = FMT_USE_RTTI != 0; + with_typename_ = FMT_USE_TYPEID != 0; } return it; } - template - auto format(const std::exception& ex, Context& ctx) const - -> decltype(ctx.out()) { + template + auto format(const std::exception& ex, + basic_format_context& ctx) const -> OutputIt { + format_specs spec; auto out = ctx.out(); -#if FMT_USE_RTTI - if (with_typename_) { - out = detail::write_demangled_name(out, typeid(ex)); - *out++ = ':'; - *out++ = ' '; + if (!with_typename_) + return detail::write_bytes(out, string_view(ex.what()), spec); + +#if FMT_USE_TYPEID + const std::type_info& ti = typeid(ex); +# ifdef FMT_HAS_ABI_CXA_DEMANGLE + int status = 0; + std::size_t size = 0; + std::unique_ptr demangled_name_ptr( + abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); + + string_view demangled_name_view; + if (demangled_name_ptr) { + demangled_name_view = demangled_name_ptr.get(); + + // Normalization of stdlib inline namespace names. + // libc++ inline namespaces. + // std::__1::* -> std::* + // std::__1::__fs::* -> std::* + // libstdc++ inline namespaces. + // std::__cxx11::* -> std::* + // std::filesystem::__cxx11::* -> std::filesystem::* + if (demangled_name_view.starts_with("std::")) { + char* begin = demangled_name_ptr.get(); + char* to = begin + 5; // std:: + for (char *from = to, *end = begin + demangled_name_view.size(); + from < end;) { + // This is safe, because demangled_name is NUL-terminated. + if (from[0] == '_' && from[1] == '_') { + char* next = from + 1; + while (next < end && *next != ':') next++; + if (next[0] == ':' && next[1] == ':') { + from = next + 2; + continue; + } + } + *to++ = *from++; + } + demangled_name_view = {begin, detail::to_unsigned(to - begin)}; + } + } else { + demangled_name_view = string_view(ti.name()); } + out = detail::write_bytes(out, demangled_name_view, spec); +# elif FMT_MSC_VERSION + string_view demangled_name_view(ti.name()); + if (demangled_name_view.starts_with("class ")) + demangled_name_view.remove_prefix(6); + else if (demangled_name_view.starts_with("struct ")) + demangled_name_view.remove_prefix(7); + out = detail::write_bytes(out, demangled_name_view, spec); +# else + out = detail::write_bytes(out, string_view(ti.name()), spec); +# endif + *out++ = ':'; + *out++ = ' '; + return detail::write_bytes(out, string_view(ex.what()), spec); #endif - return detail::write_bytes(out, string_view(ex.what())); } }; @@ -615,14 +509,6 @@ struct formatter -auto ptr(const std::unique_ptr& p) -> const void* { - return p.get(); -} -template auto ptr(const std::shared_ptr& p) -> const void* { - return p.get(); -} - FMT_EXPORT template struct formatter, Char, @@ -647,80 +533,5 @@ struct formatter : formatter { }; #endif // __cpp_lib_atomic_flag_test -FMT_EXPORT -template struct formatter, Char> { - private: - detail::dynamic_format_specs specs_; - - template - FMT_CONSTEXPR auto do_format(const std::complex& c, - detail::dynamic_format_specs& specs, - FormatContext& ctx, OutputIt out) const - -> OutputIt { - if (c.real() != 0) { - *out++ = Char('('); - out = detail::write(out, c.real(), specs, ctx.locale()); - specs.set_sign(sign::plus); - out = detail::write(out, c.imag(), specs, ctx.locale()); - if (!detail::isfinite(c.imag())) *out++ = Char(' '); - *out++ = Char('i'); - *out++ = Char(')'); - return out; - } - out = detail::write(out, c.imag(), specs, ctx.locale()); - if (!detail::isfinite(c.imag())) *out++ = Char(' '); - *out++ = Char('i'); - return out; - } - - public: - FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { - if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin(); - return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, - detail::type_constant::value); - } - - template - auto format(const std::complex& c, FormatContext& ctx) const - -> decltype(ctx.out()) { - auto specs = specs_; - if (specs.dynamic()) { - detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, - specs.width_ref, ctx); - detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, - specs.precision_ref, ctx); - } - - if (specs.width == 0) return do_format(c, specs, ctx, ctx.out()); - auto buf = basic_memory_buffer(); - - auto outer_specs = format_specs(); - outer_specs.width = specs.width; - outer_specs.copy_fill_from(specs); - outer_specs.set_align(specs.align()); - - specs.width = 0; - specs.set_fill({}); - specs.set_align(align::none); - - do_format(c, specs, ctx, basic_appender(buf)); - return detail::write(ctx.out(), - basic_string_view(buf.data(), buf.size()), - outer_specs); - } -}; - -FMT_EXPORT -template -struct formatter, Char, - enable_if_t, Char>::value>> - : formatter, Char> { - template - auto format(std::reference_wrapper ref, FormatContext& ctx) const - -> decltype(ctx.out()) { - return formatter, Char>::format(ref.get(), ctx); - } -}; - FMT_END_NAMESPACE #endif // FMT_STD_H_ diff --git a/src/fmt/xchar.h b/src/fmt/xchar.h index 9f7f889d64..1e791bb07b 100644 --- a/src/fmt/xchar.h +++ b/src/fmt/xchar.h @@ -8,16 +8,13 @@ #ifndef FMT_XCHAR_H_ #define FMT_XCHAR_H_ -#include "color.h" +#include + #include "format.h" -#include "ostream.h" #include "ranges.h" -#ifndef FMT_MODULE -# include -# if FMT_USE_LOCALE -# include -# endif +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR +# include #endif FMT_BEGIN_NAMESPACE @@ -26,26 +23,10 @@ namespace detail { template using is_exotic_char = bool_constant::value>; -template struct format_string_char {}; - -template -struct format_string_char< - S, void_t())))>> { - using type = char_t; -}; - -template -struct format_string_char< - S, enable_if_t::value>> { - using type = typename S::char_type; -}; - -template -using format_string_char_t = typename format_string_char::type; - -inline auto write_loc(basic_appender out, loc_value value, - const format_specs& specs, locale_ref loc) -> bool { -#if FMT_USE_LOCALE +inline auto write_loc(back_insert_iterator> out, + loc_value value, const format_specs& specs, + locale_ref loc) -> bool { +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR auto& numpunct = std::use_facet>(loc.get()); auto separator = std::wstring(); @@ -60,79 +41,42 @@ inline auto write_loc(basic_appender out, loc_value value, FMT_BEGIN_EXPORT using wstring_view = basic_string_view; -using wformat_parse_context = parse_context; -using wformat_context = buffered_context; +using wformat_parse_context = basic_format_parse_context; +using wformat_context = buffer_context; using wformat_args = basic_format_args; using wmemory_buffer = basic_memory_buffer; -template struct basic_fstring { - private: - basic_string_view str_; - - static constexpr int num_static_named_args = - detail::count_static_named_args(); - - using checker = detail::format_string_checker< - Char, static_cast(sizeof...(T)), num_static_named_args, - num_static_named_args != detail::count_named_args()>; - - using arg_pack = detail::arg_pack; - - public: - using t = basic_fstring; - - template >::value)> - FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) { - if (FMT_USE_CONSTEVAL) - detail::parse_format_string(s, checker(s, arg_pack())); - } - template ::value&& - std::is_same::value)> - FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) { - FMT_CONSTEXPR auto sv = basic_string_view(S()); - FMT_CONSTEXPR int ignore = - (parse_format_string(sv, checker(sv, arg_pack())), 0); - detail::ignore_unused(ignore); - } - basic_fstring(runtime_format_string fmt) : str_(fmt.str) {} - - operator basic_string_view() const { return str_; } - auto get() const -> basic_string_view { return str_; } -}; - -template -using basic_format_string = basic_fstring; - -template -using wformat_string = typename basic_format_string::t; +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 +// Workaround broken conversion on older gcc. +template using wformat_string = wstring_view; +inline auto runtime(wstring_view s) -> wstring_view { return s; } +#else +template +using wformat_string = basic_format_string...>; inline auto runtime(wstring_view s) -> runtime_format_string { return {{s}}; } +#endif template <> struct is_char : std::true_type {}; +template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; -#ifdef __cpp_char8_t -template <> struct is_char : bool_constant {}; -#endif - template -constexpr auto make_wformat_args(T&... args) - -> decltype(fmt::make_format_args(args...)) { - return fmt::make_format_args(args...); +constexpr auto make_wformat_args(const T&... args) + -> format_arg_store { + return {args...}; } -#if !FMT_USE_NONTYPE_TEMPLATE_ARGS inline namespace literals { -inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg { +#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS +constexpr auto operator""_a(const wchar_t* s, size_t) + -> detail::udl_arg { return {s}; } -} // namespace literals #endif +} // namespace literals template auto join(It begin, Sentinel end, wstring_view sep) @@ -140,9 +84,9 @@ auto join(It begin, Sentinel end, wstring_view sep) return {begin, end, sep}; } -template ::value)> +template auto join(Range&& range, wstring_view sep) - -> join_view join_view, detail::sentinel_t, wchar_t> { return join(std::begin(range), std::end(range), sep); } @@ -153,19 +97,19 @@ auto join(std::initializer_list list, wstring_view sep) return join(std::begin(list), std::end(list), sep); } -template ::value)> -auto join(const Tuple& tuple, basic_string_view sep) - -> tuple_join_view { +template +auto join(const std::tuple& tuple, basic_string_view sep) + -> tuple_join_view { return {tuple, sep}; } template ::value)> -auto vformat(basic_string_view fmt, - typename detail::vformat_args::type args) +auto vformat(basic_string_view format_str, + basic_format_args>> args) -> std::basic_string { auto buf = basic_memory_buffer(); - detail::vformat_to(buf, fmt, args); - return {buf.data(), buf.size()}; + detail::vformat_to(buf, format_str, args); + return to_string(buf); } template @@ -173,122 +117,110 @@ auto format(wformat_string fmt, T&&... args) -> std::wstring { return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } -template -auto format_to(OutputIt out, wformat_string fmt, T&&... args) - -> OutputIt { - return vformat_to(out, fmt::wstring_view(fmt), - fmt::make_wformat_args(args...)); -} - // Pass char_t as a default template parameter instead of using // std::basic_string> to reduce the symbol size. -template , +template , FMT_ENABLE_IF(!std::is_same::value && !std::is_same::value)> -auto format(const S& fmt, T&&... args) -> std::basic_string { - return vformat(detail::to_string_view(fmt), - fmt::make_format_args>(args...)); +auto format(const S& format_str, T&&... args) -> std::basic_string { + return vformat(detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } -template , +template , FMT_ENABLE_IF(detail::is_locale::value&& detail::is_exotic_char::value)> -inline auto vformat(const Locale& loc, const S& fmt, - typename detail::vformat_args::type args) +inline auto vformat( + const Locale& loc, const S& format_str, + basic_format_args>> args) -> std::basic_string { - auto buf = basic_memory_buffer(); - detail::vformat_to(buf, detail::to_string_view(fmt), args, - detail::locale_ref(loc)); - return {buf.data(), buf.size()}; + return detail::vformat(loc, detail::to_string_view(format_str), args); } -template , +template , FMT_ENABLE_IF(detail::is_locale::value&& detail::is_exotic_char::value)> -inline auto format(const Locale& loc, const S& fmt, T&&... args) +inline auto format(const Locale& loc, const S& format_str, T&&... args) -> std::basic_string { - return vformat(loc, detail::to_string_view(fmt), - fmt::make_format_args>(args...)); + return detail::vformat(loc, detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } -template , +template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> -auto vformat_to(OutputIt out, const S& fmt, - typename detail::vformat_args::type args) -> OutputIt { +auto vformat_to(OutputIt out, const S& format_str, + basic_format_args>> args) + -> OutputIt { auto&& buf = detail::get_buffer(out); - detail::vformat_to(buf, detail::to_string_view(fmt), args); + detail::vformat_to(buf, detail::to_string_view(format_str), args); return detail::get_iterator(buf, out); } template , - FMT_ENABLE_IF(detail::is_output_iterator::value && - !std::is_same::value && - !std::is_same::value)> + typename Char = char_t, + FMT_ENABLE_IF(detail::is_output_iterator::value&& + detail::is_exotic_char::value)> inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt { return vformat_to(out, detail::to_string_view(fmt), - fmt::make_format_args>(args...)); + fmt::make_format_args>(args...)); } template , + typename Char = char_t, FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_locale::value&& detail::is_exotic_char::value)> -inline auto vformat_to(OutputIt out, const Locale& loc, const S& fmt, - typename detail::vformat_args::type args) - -> OutputIt { +inline auto vformat_to( + OutputIt out, const Locale& loc, const S& format_str, + basic_format_args>> args) -> OutputIt { auto&& buf = detail::get_buffer(out); - vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc)); + vformat_to(buf, detail::to_string_view(format_str), args, + detail::locale_ref(loc)); return detail::get_iterator(buf, out); } -template , +template , bool enable = detail::is_output_iterator::value && detail::is_locale::value && detail::is_exotic_char::value> -inline auto format_to(OutputIt out, const Locale& loc, const S& fmt, +inline auto format_to(OutputIt out, const Locale& loc, const S& format_str, T&&... args) -> typename std::enable_if::type { - return vformat_to(out, loc, detail::to_string_view(fmt), - fmt::make_format_args>(args...)); + return vformat_to(out, loc, detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } template ::value&& detail::is_exotic_char::value)> -inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view fmt, - typename detail::vformat_args::type args) +inline auto vformat_to_n( + OutputIt out, size_t n, basic_string_view format_str, + basic_format_args>> args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); - detail::vformat_to(buf, fmt, args); + detail::vformat_to(buf, format_str, args); return {buf.out(), buf.count()}; } template , + typename Char = char_t, FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) -> format_to_n_result { - return vformat_to_n(out, n, fmt::basic_string_view(fmt), - fmt::make_format_args>(args...)); + return vformat_to_n(out, n, detail::to_string_view(fmt), + fmt::make_format_args>(args...)); } -template , +template , FMT_ENABLE_IF(detail::is_exotic_char::value)> inline auto formatted_size(const S& fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer(); detail::vformat_to(buf, detail::to_string_view(fmt), - fmt::make_format_args>(args...)); + fmt::make_format_args>(args...)); return buf.count(); } @@ -322,48 +254,9 @@ template void println(wformat_string fmt, T&&... args) { return print(L"{}\n", fmt::format(fmt, std::forward(args)...)); } -inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args) - -> std::wstring { - auto buf = wmemory_buffer(); - detail::vformat_to(buf, ts, fmt, args); - return {buf.data(), buf.size()}; -} - -template -inline auto format(const text_style& ts, wformat_string fmt, T&&... args) - -> std::wstring { - return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...)); -} - -template -FMT_DEPRECATED void print(std::FILE* f, const text_style& ts, - wformat_string fmt, const T&... args) { - vprint(f, ts, fmt, fmt::make_wformat_args(args...)); -} - -template -FMT_DEPRECATED void print(const text_style& ts, wformat_string fmt, - const T&... args) { - return print(stdout, ts, fmt, args...); -} - -inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) { - auto buffer = basic_memory_buffer(); - detail::vformat_to(buffer, fmt, args); - detail::write_buffer(os, buffer); -} - -template -void print(std::wostream& os, wformat_string fmt, T&&... args) { - vprint(os, fmt, fmt::make_format_args>(args...)); -} - -template -void println(std::wostream& os, wformat_string fmt, T&&... args) { - print(os, L"{}\n", fmt::format(fmt, std::forward(args)...)); -} - -/// Converts `value` to `std::wstring` using the default format for type `T`. +/** + Converts *value* to ``std::wstring`` using the default format for type *T*. + */ template inline auto to_wstring(const T& value) -> std::wstring { return format(FMT_STRING(L"{}"), value); } diff --git a/src/fmtlib_format.cpp b/src/fmtlib_format.cpp index 966b6dce84..fd51cb6468 100644 --- a/src/fmtlib_format.cpp +++ b/src/fmtlib_format.cpp @@ -16,8 +16,7 @@ template FMT_API auto dragonbox::to_decimal(float x) noexcept template FMT_API auto dragonbox::to_decimal(double x) noexcept -> dragonbox::decimal_fp; -#if FMT_USE_LOCALE -// DEPRECATED! locale_ref in the detail namespace +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR template FMT_API locale_ref::locale_ref(const std::locale& loc); template FMT_API auto locale_ref::get() const -> std::locale; #endif @@ -28,10 +27,8 @@ template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; template FMT_API auto decimal_point_impl(locale_ref) -> char; -// DEPRECATED! template FMT_API void buffer::append(const char*, const char*); -// DEPRECATED! template FMT_API void vformat_to(buffer&, string_view, typename vformat_args<>::type, locale_ref); diff --git a/src/fmtlib_os.cpp b/src/fmtlib_os.cpp index 2bb9e94551..3338d13cae 100644 --- a/src/fmtlib_os.cpp +++ b/src/fmtlib_os.cpp @@ -13,51 +13,47 @@ #include "fmt/os.h" -#ifndef FMT_MODULE -# include +#include -# if FMT_USE_FCNTL -# include -# include +#if FMT_USE_FCNTL +# include +# include -# ifdef _WRS_KERNEL // VxWorks7 kernel -# include // getpagesize -# endif - -# ifndef _WIN32 -# include -# else -# ifndef WIN32_LEAN_AND_MEAN -# define WIN32_LEAN_AND_MEAN -# endif -# include -# endif // _WIN32 -# endif // FMT_USE_FCNTL - -# ifdef _WIN32 -# include +# ifdef _WRS_KERNEL // VxWorks7 kernel +# include // getpagesize # endif -#endif + +# ifndef _WIN32 +# include +# else +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include + +# ifndef S_IRUSR +# define S_IRUSR _S_IREAD +# endif +# ifndef S_IWUSR +# define S_IWUSR _S_IWRITE +# endif +# ifndef S_IRGRP +# define S_IRGRP 0 +# endif +# ifndef S_IWGRP +# define S_IWGRP 0 +# endif +# ifndef S_IROTH +# define S_IROTH 0 +# endif +# ifndef S_IWOTH +# define S_IWOTH 0 +# endif +# endif // _WIN32 +#endif // FMT_USE_FCNTL #ifdef _WIN32 -# ifndef S_IRUSR -# define S_IRUSR _S_IREAD -# endif -# ifndef S_IWUSR -# define S_IWUSR _S_IWRITE -# endif -# ifndef S_IRGRP -# define S_IRGRP 0 -# endif -# ifndef S_IWGRP -# define S_IWGRP 0 -# endif -# ifndef S_IROTH -# define S_IROTH 0 -# endif -# ifndef S_IWOTH -# define S_IWOTH 0 -# endif +# include #endif namespace { @@ -161,7 +157,7 @@ void detail::format_windows_error(detail::buffer& out, int error_code, } void report_windows_error(int error_code, const char* message) noexcept { - do_report_error(detail::format_windows_error, error_code, message); + report_error(detail::format_windows_error, error_code, message); } #endif // _WIN32 @@ -187,14 +183,12 @@ void buffered_file::close() { } int buffered_file::descriptor() const { -#ifdef FMT_HAS_SYSTEM - // fileno is a macro on OpenBSD. -# ifdef fileno -# undef fileno -# endif +#if !defined(fileno) int fd = FMT_POSIX_CALL(fileno(file_)); -#elif defined(_WIN32) - int fd = _fileno(file_); +#elif defined(FMT_HAS_SYSTEM) + // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL. +# define FMT_DISABLE_MACRO + int fd = FMT_SYSTEM(fileno FMT_DISABLE_MACRO(file_)); #else int fd = fileno(file_); #endif @@ -375,25 +369,30 @@ long getpagesize() { } # endif -void ostream::grow(buffer& buf, size_t) { - if (buf.size() == buf.capacity()) static_cast(buf).flush(); +namespace detail { + +void file_buffer::grow(buffer& buf, size_t) { + if (buf.size() == buf.capacity()) static_cast(buf).flush(); } -ostream::ostream(cstring_view path, const detail::ostream_params& params) +file_buffer::file_buffer(cstring_view path, const ostream_params& params) : buffer(grow), file_(path, params.oflag) { set(new char[params.buffer_size], params.buffer_size); } -ostream::ostream(ostream&& other) noexcept +file_buffer::file_buffer(file_buffer&& other) : buffer(grow, other.data(), other.size(), other.capacity()), file_(std::move(other.file_)) { other.clear(); other.set(nullptr, 0); } -ostream::~ostream() { +file_buffer::~file_buffer() { flush(); delete[] data(); } +} // namespace detail + +ostream::~ostream() = default; #endif // FMT_USE_FCNTL FMT_END_NAMESPACE diff --git a/src/info.cpp b/src/info.cpp index bf98f77b58..17b1f417ea 100644 --- a/src/info.cpp +++ b/src/info.cpp @@ -270,25 +270,25 @@ void Info::command(int narg, char **arg) fputs("\nInfo-Info-Info-Info-Info-Info-Info-Info-Info-Info-Info\n",out); std::tm now = fmt::localtime(std::time(nullptr)); - fmt::print(out,"Printed on {}", std::asctime(&now)); + utils::print(out,"Printed on {}", std::asctime(&now)); if (flags & CONFIG) { - fmt::print(out,"\nLAMMPS version: {} / {}\n", lmp->version, lmp->num_ver); + utils::print(out,"\nLAMMPS version: {} / {}\n", lmp->version, lmp->num_ver); if (LAMMPS::has_git_info()) - fmt::print(out,"Git info: {} / {} / {}\n", + utils::print(out,"Git info: {} / {} / {}\n", LAMMPS::git_branch(), LAMMPS::git_descriptor(),LAMMPS::git_commit()); - fmt::print(out,"\nOS information: {}\n\n",platform::os_info()); + utils::print(out,"\nOS information: {}\n\n",platform::os_info()); - fmt::print(out,"sizeof(smallint): {}-bit\n" + utils::print(out,"sizeof(smallint): {}-bit\n" "sizeof(imageint): {}-bit\n" "sizeof(tagint): {}-bit\n" "sizeof(bigint): {}-bit\n", sizeof(smallint)*8, sizeof(imageint)*8, sizeof(tagint)*8, sizeof(bigint)*8); - fmt::print(out,"\nCompiler: {} with {}\nC++ standard: {}\n", + utils::print(out,"\nCompiler: {} with {}\nC++ standard: {}\n", platform::compiler_info(),platform::openmp_standard(),platform::cxx_standard()); fputs(get_fmt_info().c_str(), out); @@ -307,7 +307,7 @@ void Info::command(int narg, char **arg) #else // defined(LAMMPS_SMALLSMALL) fputs("-DLAMMPS_SMALLSMALL\n",out); #endif - if (has_gzip_support()) fmt::print(out,"\n{}\n",platform::compress_info()); + if (has_gzip_support()) utils::print(out,"\n{}\n",platform::compress_info()); int ncword, ncline = 0; fputs("\nInstalled packages:\n\n",out); @@ -317,17 +317,17 @@ void Info::command(int narg, char **arg) ncline = 0; fputs("\n",out); } - fmt::print(out,"{} ",*pkg); + utils::print(out,"{} ",*pkg); ncline += ncword + 1; } fputs("\n",out); } if (flags & ACCELERATOR) { - fmt::print(out,"\nAccelerator configuration:\n\n{}", + utils::print(out,"\nAccelerator configuration:\n\n{}", get_accelerator_info()); if (Info::has_gpu_device()) - fmt::print(out,"\nAvailable GPU devices:\n{}\n",get_gpu_device_info()); + utils::print(out,"\nAvailable GPU devices:\n{}\n",get_gpu_device_info()); } if (flags & MEMORY) { @@ -336,18 +336,18 @@ void Info::command(int narg, char **arg) get_memory_info(meminfo); fputs("\nMemory allocation information (MPI rank 0):\n\n",out); - fmt::print(out,"Total dynamically allocated memory: {:.4} Mbyte\n", + utils::print(out,"Total dynamically allocated memory: {:.4} Mbyte\n", meminfo[0]); #if defined(_WIN32) - fmt::print(out,"Non-shared memory use: {:.4} Mbyte\n",meminfo[1]); - fmt::print(out,"Maximum working set size: {:.4} Mbyte\n",meminfo[2]); + utils::print(out,"Non-shared memory use: {:.4} Mbyte\n",meminfo[1]); + utils::print(out,"Maximum working set size: {:.4} Mbyte\n",meminfo[2]); #else #if defined(__linux__) - fmt::print(out,"Current reserved memory pool size: {:.4} Mbyte\n", + utils::print(out,"Current reserved memory pool size: {:.4} Mbyte\n", meminfo[1]); #endif - fmt::print(out,"Maximum resident set size: {:.4} Mbyte\n",meminfo[2]); + utils::print(out,"Maximum resident set size: {:.4} Mbyte\n",meminfo[2]); #endif } @@ -355,18 +355,18 @@ void Info::command(int narg, char **arg) int major,minor; std::string version = platform::mpi_info(major,minor); - fmt::print(out,"\nCommunication information:\n" + utils::print(out,"\nCommunication information:\n" "MPI library level: MPI v{}.{}\n" "MPI version: {}\n",major,minor,version); - fmt::print(out,"Comm style = {}, Comm layout = {}\n" + utils::print(out,"Comm style = {}, Comm layout = {}\n" "Communicate velocities for ghost atoms = {}\n", commstyles[comm->style], commlayout[comm->layout], comm->ghost_velocity ? "yes" : "no"); if (domain->box_exist) { if (comm->mode == 0) - fmt::print(out,"Communication mode = single\n" + utils::print(out,"Communication mode = single\n" "Communication cutoff = {}\n", comm->get_comm_cutoff()); @@ -381,7 +381,7 @@ void Info::command(int narg, char **arg) } if (comm->cutusermulti) cut = MAX(cut,comm->cutusermulti[i]); - fmt::print(out,"Communication cutoff for collection {} = {:.8}\n", i, cut); + utils::print(out,"Communication cutoff for collection {} = {:.8}\n", i, cut); } } @@ -391,13 +391,13 @@ void Info::command(int narg, char **arg) for (int i=1; i <= atom->ntypes && neighbor->cuttype; ++i) { cut = neighbor->cuttype[i]; if (comm->cutusermultiold) cut = MAX(cut,comm->cutusermultiold[i]); - fmt::print(out,"Communication cutoff for type {} = {:.8}\n", i, cut); + utils::print(out,"Communication cutoff for type {} = {:.8}\n", i, cut); } } } - fmt::print(out,"Nprocs = {}, Nthreads = {}\n",comm->nprocs,comm->nthreads); + utils::print(out,"Nprocs = {}, Nthreads = {}\n",comm->nprocs,comm->nthreads); if (domain->box_exist) - fmt::print(out,"Processor grid = {} x {} x {}\n",comm->procgrid[0], + utils::print(out,"Processor grid = {} x {} x {}\n",comm->procgrid[0], comm->procgrid[1], comm->procgrid[2]); } @@ -408,80 +408,80 @@ void Info::command(int narg, char **arg) if (flags & SYSTEM) { fputs("\nSystem information:\n",out); - fmt::print(out,"Units = {}\n", update->unit_style); - fmt::print(out,"Atom style = {}\n", atom->get_style()); - fmt::print(out,"Atom map = {}\n", mapstyles[atom->map_style]); + utils::print(out,"Units = {}\n", update->unit_style); + utils::print(out,"Atom style = {}\n", atom->get_style()); + utils::print(out,"Atom map = {}\n", mapstyles[atom->map_style]); if (atom->molecular != Atom::ATOMIC) { const char *msg; msg = (atom->molecular == Atom::TEMPLATE) ? "template" : "standard"; - fmt::print(out,"Molecule type = {}\n",msg); + utils::print(out,"Molecule type = {}\n",msg); } - fmt::print(out,"Atoms = {:12}, types = {:8d}, style = {}\n", + utils::print(out,"Atoms = {:12}, types = {:8d}, style = {}\n", atom->natoms, atom->ntypes, force->pair_style); - if (atom->tag_enable) fmt::print(out,"Atoms with atom IDs\n"); - if (atom->molecule) fmt::print(out,"Atoms with molecule IDs\n"); - if (atom->mass) fmt::print(out,"Atoms with per-type masses\n"); - if (atom->rmass) fmt::print(out,"Atoms with per-atom masses\n"); - if (atom->q) fmt::print(out,"Atoms with per-atom charges\n"); + if (atom->tag_enable) utils::print(out,"Atoms with atom IDs\n"); + if (atom->molecule) utils::print(out,"Atoms with molecule IDs\n"); + if (atom->mass) utils::print(out,"Atoms with per-type masses\n"); + if (atom->rmass) utils::print(out,"Atoms with per-atom masses\n"); + if (atom->q) utils::print(out,"Atoms with per-atom charges\n"); if (force->pair && utils::strmatch(force->pair_style,"^hybrid")) { auto hybrid = dynamic_cast(force->pair); - fmt::print(out,"Hybrid sub-styles:"); + utils::print(out,"Hybrid sub-styles:"); for (int i=0; i < hybrid->nstyles; ++i) - fmt::print(out," {}", hybrid->keywords[i]); + utils::print(out," {}", hybrid->keywords[i]); fputc('\n',out); } if (atom->molecular != Atom::ATOMIC) { const char *msg; msg = force->bond_style ? force->bond_style : "none"; - fmt::print(out,"Bonds = {:12}, types = {:8}, style = {}\n", + utils::print(out,"Bonds = {:12}, types = {:8}, style = {}\n", atom->nbonds, atom->nbondtypes, msg); msg = force->angle_style ? force->angle_style : "none"; - fmt::print(out,"Angles = {:12}, types = {:8}, style = {}\n", + utils::print(out,"Angles = {:12}, types = {:8}, style = {}\n", atom->nangles, atom->nangletypes, msg); msg = force->dihedral_style ? force->dihedral_style : "none"; - fmt::print(out,"Dihedrals = {:12}, types = {:8}, style = {}\n", + utils::print(out,"Dihedrals = {:12}, types = {:8}, style = {}\n", atom->ndihedrals, atom->ndihedraltypes, msg); msg = force->improper_style ? force->improper_style : "none"; - fmt::print(out,"Impropers = {:12}, types = {:8}, style = {}\n", + utils::print(out,"Impropers = {:12}, types = {:8}, style = {}\n", atom->nimpropers, atom->nimpropertypes, msg); const double * const special_lj = force->special_lj; const double * const special_coul = force->special_coul; - fmt::print(out,"Special bond factors lj = {:<8} {:<8} {:<8}\n" + utils::print(out,"Special bond factors lj = {:<8} {:<8} {:<8}\n" "Special bond factors coul = {:<8} {:<8} {:<8}\n", special_lj[1],special_lj[2],special_lj[3], special_coul[1],special_coul[2],special_coul[3]); } - fmt::print(out,"Kspace style = {}\n", + utils::print(out,"Kspace style = {}\n", force->kspace ? force->kspace_style : "none"); if (domain->box_exist) { - fmt::print(out,"\nDimensions = {}\n",domain->dimension); - fmt::print(out,"{} box = {:.8} x {:.8} x {:.8}\n", + utils::print(out,"\nDimensions = {}\n",domain->dimension); + utils::print(out,"{} box = {:.8} x {:.8} x {:.8}\n", domain->triclinic ? "Triclinic" : "Orthogonal", domain->xprd, domain->yprd, domain->zprd); - fmt::print(out,"Boundaries = {},{} {},{} {},{}\n", + utils::print(out,"Boundaries = {},{} {},{} {},{}\n", bstyles[domain->boundary[0][0]],bstyles[domain->boundary[0][1]], bstyles[domain->boundary[1][0]],bstyles[domain->boundary[1][1]], bstyles[domain->boundary[2][0]],bstyles[domain->boundary[2][1]]); - fmt::print(out,"xlo, xhi = {:.8}, {:.8}\n", domain->boxlo[0], domain->boxhi[0]); - fmt::print(out,"ylo, yhi = {:.8}, {:.8}\n", domain->boxlo[1], domain->boxhi[1]); - fmt::print(out,"zlo, zhi = {:.8}, {:.8}\n", domain->boxlo[2], domain->boxhi[2]); + utils::print(out,"xlo, xhi = {:.8}, {:.8}\n", domain->boxlo[0], domain->boxhi[0]); + utils::print(out,"ylo, yhi = {:.8}, {:.8}\n", domain->boxlo[1], domain->boxhi[1]); + utils::print(out,"zlo, zhi = {:.8}, {:.8}\n", domain->boxlo[2], domain->boxhi[2]); if (domain->triclinic) - fmt::print(out,"Xy, xz, yz = {:.8}, {:.8}, {:.8}\n", + utils::print(out,"Xy, xz, yz = {:.8}, {:.8}, {:.8}\n", domain->xy, domain->xz, domain->yz); } else { fputs("\nBox has not yet been created\n",out); } - fmt::print(out,"\nCurrent timestep number = {}\n", update->ntimestep); - fmt::print(out,"Current timestep size = {}\n", update->dt); + utils::print(out,"\nCurrent timestep number = {}\n", update->ntimestep); + utils::print(out,"Current timestep size = {}\n", update->dt); } if (domain->box_exist && (flags & COEFFS)) { @@ -492,7 +492,7 @@ void Info::command(int narg, char **arg) fputs("\nPair Coeffs:\n",out); for (int i=1; i <= atom->ntypes; ++i) for (int j=i; j <= atom->ntypes; ++j) { - fmt::print(out,"{:6d} {:6d}:",i,j); + utils::print(out,"{:6d} {:6d}:",i,j); if (pair->allocated && pair->setflag[i][j]) fputs(" is set\n",out); else fputs(" is not set\n",out); } @@ -503,7 +503,7 @@ void Info::command(int narg, char **arg) if (bond) { fputs("\nBond Coeffs:\n",out); for (int i=1; i <= atom->nbondtypes; ++i) { - fmt::print(out,"{:6d}:",i); + utils::print(out,"{:6d}:",i); if (bond->allocated && bond->setflag[i]) fputs(" is set\n",out); else fputs (" is not set\n",out); } @@ -515,7 +515,7 @@ void Info::command(int narg, char **arg) if (angle) { fputs("\nAngle Coeffs:\n",out); for (int i=1; i <= atom->nangletypes; ++i) { - fmt::print(out,"{:6d}:",i); + utils::print(out,"{:6d}:",i); if (angle->allocated && angle->setflag[i]) fputs(" is set\n",out); else fputs (" is not set\n",out); } @@ -527,7 +527,7 @@ void Info::command(int narg, char **arg) if (dihedral) { fputs("\nDihedral Coeffs:\n",out); for (int i=1; i <= atom->ndihedraltypes; ++i) { - fmt::print(out,"{:6d}:",i); + utils::print(out,"{:6d}:",i); if (dihedral->allocated && dihedral->setflag[i]) fputs(" is set\n",out); else fputs (" is not set\n",out); } @@ -539,7 +539,7 @@ void Info::command(int narg, char **arg) if (b) { fputs("\nImproper Coeffs:\n",out); for (int i=1; i <= atom->nimpropertypes; ++i) { - fmt::print(out,"{:6d}:",i); + utils::print(out,"{:6d}:",i); if (b->allocated && b->setflag[i]) fputs(" is set\n",out); else fputs (" is not set\n",out); } @@ -554,7 +554,7 @@ void Info::command(int narg, char **arg) fputs("\nGroup information:\n",out); for (int i=0; i < ngroup; ++i) { if (names[i]) - fmt::print(out,"Group[{:2d}]: {:16} ({})\n", + utils::print(out,"Group[{:2d}]: {:16} ({})\n", i, names[i], dynamic[i] ? "dynamic" : "static"); } } @@ -563,11 +563,11 @@ void Info::command(int narg, char **arg) fputs("\nRegion information:\n",out); int i=0; for (auto ® : domain->get_region_list()) { - fmt::print(out,"Region[{:3d}]: {:16} style = {:16} side = {}\n", + utils::print(out,"Region[{:3d}]: {:16} style = {:16} side = {}\n", i, std::string(reg->id)+',', std::string(reg->style)+',', reg->interior ? "in" : "out"); if (reg->bboxflag) - fmt::print(out," Boundary: lo {:.8} {:.8} {:.8} hi {:.8} {:.8} {:.8}\n", + utils::print(out," Boundary: lo {:.8} {:.8} {:.8} hi {:.8} {:.8} {:.8}\n", reg->extent_xlo, reg->extent_ylo, reg->extent_zlo, reg->extent_xhi, reg->extent_yhi, reg->extent_zhi); @@ -580,7 +580,7 @@ void Info::command(int narg, char **arg) char **names = group->names; fputs("\nCompute information:\n",out); for (const auto &compute : modify->get_compute_list()) - fmt::print(out,"Compute[{:3d}]: {:16} style = {:16} group = {}\n", i++, + utils::print(out,"Compute[{:3d}]: {:16} style = {:16} group = {}\n", i++, std::string(compute->id)+',',std::string(compute->style)+',', names[compute->igroup]); } @@ -593,13 +593,13 @@ void Info::command(int narg, char **arg) char **names = group->names; fputs("\nDump information:\n",out); for (int i=0; i < ndump; ++i) { - fmt::print(out,"Dump[{:3d}]: {:16} file = {:16} style = {:16} group = {:16} ", + utils::print(out,"Dump[{:3d}]: {:16} file = {:16} style = {:16} group = {:16} ", i, std::string(dump[i]->id)+',',std::string(dump[i]->filename)+',', std::string(dump[i]->style)+',',std::string(names[dump[i]->igroup])+','); if (nevery[i]) { - fmt::print(out,"every = {}\n", nevery[i]); + utils::print(out,"every = {}\n", nevery[i]); } else { - fmt::print(out,"every = {}\n", vnames[i]); + utils::print(out,"every = {}\n", vnames[i]); } } } @@ -609,7 +609,7 @@ void Info::command(int narg, char **arg) char **names = group->names; fputs("\nFix information:\n",out); for (const auto &fix : modify->get_fix_list()) - fmt::print(out, "Fix[{:3d}]: {:16} style = {:16} group = {}\n",i++, + utils::print(out, "Fix[{:3d}]: {:16} style = {:16} group = {}\n",i++, std::string(fix->id)+',',std::string(fix->style)+',',names[fix->igroup]); } @@ -618,7 +618,7 @@ void Info::command(int narg, char **arg) fputs("\nVariable information:\n",out); for (int i=0; i < nvar; ++i) { auto vinfo = get_variable_info(i); - fmt::print(out, get_variable_info(i)); + utils::print(out, get_variable_info(i)); } } @@ -635,7 +635,7 @@ void Info::command(int narg, char **arg) wallclock = (wallclock - walls) / 60.0; wallm = fmod(wallclock,60.0); wallh = (wallclock - wallm) / 60.0; - fmt::print(out,"\nTotal time information (MPI rank 0):\n" + utils::print(out,"\nTotal time information (MPI rank 0):\n" " CPU time: {:4d}:{:02d}:{:02d}\n" " Wall time: {:4d}:{:02d}:{:02d}\n", cpuh,cpum,cpus,wallh,wallm,walls); diff --git a/src/label_map.cpp b/src/label_map.cpp index 9934868c49..24cef51062 100644 --- a/src/label_map.cpp +++ b/src/label_map.cpp @@ -335,28 +335,28 @@ bool LabelMap::is_complete(int mode) const void LabelMap::write_data(FILE *fp) { if (is_complete(Atom::ATOM)) { - fmt::print(fp, "\nAtom Type Labels\n\n"); - for (int i = 0; i < natomtypes; i++) fmt::print(fp, "{} {}\n", i + 1, typelabel[i]); + utils::print(fp, "\nAtom Type Labels\n\n"); + for (int i = 0; i < natomtypes; i++) utils::print(fp, "{} {}\n", i + 1, typelabel[i]); } if (force->bond && is_complete(Atom::BOND)) { - fmt::print(fp, "\nBond Type Labels\n\n"); - for (int i = 0; i < nbondtypes; i++) fmt::print(fp, "{} {}\n", i + 1, btypelabel[i]); + utils::print(fp, "\nBond Type Labels\n\n"); + for (int i = 0; i < nbondtypes; i++) utils::print(fp, "{} {}\n", i + 1, btypelabel[i]); } if (force->angle && is_complete(Atom::ANGLE)) { - fmt::print(fp, "\nAngle Type Labels\n\n"); - for (int i = 0; i < nangletypes; i++) fmt::print(fp, "{} {}\n", i + 1, atypelabel[i]); + utils::print(fp, "\nAngle Type Labels\n\n"); + for (int i = 0; i < nangletypes; i++) utils::print(fp, "{} {}\n", i + 1, atypelabel[i]); } if (force->dihedral && is_complete(Atom::DIHEDRAL)) { - fmt::print(fp, "\nDihedral Type Labels\n\n"); - for (int i = 0; i < ndihedraltypes; i++) fmt::print(fp, "{} {}\n", i + 1, dtypelabel[i]); + utils::print(fp, "\nDihedral Type Labels\n\n"); + for (int i = 0; i < ndihedraltypes; i++) utils::print(fp, "{} {}\n", i + 1, dtypelabel[i]); } if (force->improper && is_complete(Atom::IMPROPER)) { - fmt::print(fp, "\nImproper Type Labels\n\n"); - for (int i = 0; i < nimpropertypes; i++) fmt::print(fp, "{} {}\n", i + 1, itypelabel[i]); + utils::print(fp, "\nImproper Type Labels\n\n"); + for (int i = 0; i < nimpropertypes; i++) utils::print(fp, "{} {}\n", i + 1, itypelabel[i]); } } @@ -473,31 +473,31 @@ void LabelMap::write_map(const std::string &filename) if (typelabel_map.size() > 0) { fputs("labelmap atom", fp); for (int i = 0; i < natomtypes; ++i) - if (!typelabel[i].empty()) fmt::print(fp, " {} \"\"\" {} \"\"\"", i + 1, typelabel[i]); + if (!typelabel[i].empty()) utils::print(fp, " {} \"\"\" {} \"\"\"", i + 1, typelabel[i]); fputc('\n', fp); } if (btypelabel_map.size() > 0) { fputs("labelmap bond", fp); for (int i = 0; i < nbondtypes; ++i) - if (!btypelabel[i].empty()) fmt::print(fp, " {} \"\"\" {} \"\"\"", i + 1, btypelabel[i]); + if (!btypelabel[i].empty()) utils::print(fp, " {} \"\"\" {} \"\"\"", i + 1, btypelabel[i]); fputc('\n', fp); } if (atypelabel_map.size() > 0) { fputs("labelmap angle", fp); for (int i = 0; i < nangletypes; ++i) - if (!atypelabel[i].empty()) fmt::print(fp, " {} \"\"\" {} \"\"\"", i + 1, atypelabel[i]); + if (!atypelabel[i].empty()) utils::print(fp, " {} \"\"\" {} \"\"\"", i + 1, atypelabel[i]); fputc('\n', fp); } if (dtypelabel_map.size() > 0) { fputs("labelmap dihedral", fp); for (int i = 0; i < ndihedraltypes; ++i) - if (!dtypelabel[i].empty()) fmt::print(fp, " {} \"\"\" {} \"\"\"", i + 1, dtypelabel[i]); + if (!dtypelabel[i].empty()) utils::print(fp, " {} \"\"\" {} \"\"\"", i + 1, dtypelabel[i]); fputc('\n', fp); } if (itypelabel_map.size() > 0) { fputs("labelmap improper", fp); for (int i = 0; i < nimpropertypes; ++i) - if (!itypelabel[i].empty()) fmt::print(fp, " {} \"\"\" {} \"\"\"", i + 1, itypelabel[i]); + if (!itypelabel[i].empty()) utils::print(fp, " {} \"\"\" {} \"\"\"", i + 1, itypelabel[i]); fputc('\n', fp); } fclose(fp); diff --git a/src/lammps.cpp b/src/lammps.cpp index 1abc34a11b..cecad6e870 100644 --- a/src/lammps.cpp +++ b/src/lammps.cpp @@ -562,14 +562,10 @@ LAMMPS::LAMMPS(int narg, char **arg, MPI_Comm communicator) : else if (strcmp(arg[inflag], "none") == 0) infile = stdin; else infile = fopen(arg[inflag],"r"); if (infile == nullptr) - error->one(FLERR,"Cannot open input script {}: {}", arg[inflag], utils::getsyserror()); + error->all(FLERR,"Cannot open input script {}: {}", arg[inflag], utils::getsyserror()); if (!helpflag) utils::logmesg(this,"LAMMPS ({}{})\n", version, update_string); - // warn against using I/O redirection in parallel runs - if ((inflag == 0) && (universe->nprocs > 1)) - error->warning(FLERR, "Using I/O redirection is unreliable with parallel runs. " - "Better to use the -in switch to read input files."); utils::flush_buffers(this); } @@ -651,12 +647,12 @@ LAMMPS::LAMMPS(int narg, char **arg, MPI_Comm communicator) : // screen and logfile messages for universe and world if ((universe->me == 0) && (!helpflag)) { - const char fmt[] = "LAMMPS ({})\nRunning on {} partitions of processors\n"; + constexpr char fmt[] = "LAMMPS ({})\nRunning on {} partitions of processors\n"; if (universe->uscreen) - fmt::print(universe->uscreen,fmt,version,universe->nworlds); + utils::print(universe->uscreen,fmt,version,universe->nworlds); if (universe->ulogfile) - fmt::print(universe->ulogfile,fmt,version,universe->nworlds); + utils::print(universe->ulogfile,fmt,version,universe->nworlds); } if ((me == 0) && (!helpflag)) @@ -1454,21 +1450,21 @@ void LAMMPS::print_config(FILE *fp) const char *pkg; int ncword, ncline = 0; - fmt::print(fp,"OS: {}\n\n",platform::os_info()); + utils::print(fp,"OS: {}\n\n",platform::os_info()); - fmt::print(fp,"Compiler: {} with {}\nC++ standard: {}\n", + utils::print(fp,"Compiler: {} with {}\nC++ standard: {}\n", platform::compiler_info(),platform::openmp_standard(), platform::cxx_standard()); fputs(Info::get_fmt_info().c_str(),fp); int major,minor; std::string infobuf = platform::mpi_info(major,minor); - fmt::print(fp,"\nMPI v{}.{}: {}\n\n",major,minor,infobuf); + utils::print(fp,"\nMPI v{}.{}: {}\n\n",major,minor,infobuf); - fmt::print(fp,"Accelerator configuration:\n\n{}\n", + utils::print(fp,"Accelerator configuration:\n\n{}\n", Info::get_accelerator_info()); #if defined(LMP_GPU) - fmt::print(fp,"Compatible GPU present: {}\n\n",Info::has_gpu_device() ? "yes" : "no"); + utils::print(fp,"Compatible GPU present: {}\n\n",Info::has_gpu_device() ? "yes" : "no"); #endif fputs("FFT information:\n\n",fp); @@ -1489,14 +1485,14 @@ void LAMMPS::print_config(FILE *fp) fputs("-DLAMMPS_SMALLSMALL\n",fp); #endif - fmt::print(fp,"sizeof(smallint): {}-bit\n" + utils::print(fp,"sizeof(smallint): {}-bit\n" "sizeof(imageint): {}-bit\n" "sizeof(tagint): {}-bit\n" "sizeof(bigint): {}-bit\n", sizeof(smallint)*8, sizeof(imageint)*8, sizeof(tagint)*8, sizeof(bigint)*8); - if (Info::has_gzip_support()) fmt::print(fp,"\n{}\n",platform::compress_info()); + if (Info::has_gzip_support()) utils::print(fp,"\n{}\n",platform::compress_info()); fputs("\nInstalled packages:\n\n",fp); for (int i = 0; nullptr != (pkg = installed_packages[i]); ++i) { diff --git a/src/library.cpp b/src/library.cpp index c5341eec83..07ed9184bc 100644 --- a/src/library.cpp +++ b/src/library.cpp @@ -187,7 +187,7 @@ void *lammps_open(int argc, char **argv, MPI_Comm comm, void **ptr) } catch(LAMMPSException &e) { lammps_last_global_errormessage = e.what(); - fmt::print(stderr, "LAMMPS Exception: {}", e.what()); + utils::print(stderr, "LAMMPS Exception: {}", e.what()); if (ptr) *ptr = nullptr; } return (void *) lmp; @@ -2925,6 +2925,8 @@ int lammps_variable_info(void *handle, int idx, char *buffer, int buf_size) { return 0; } +/* ---------------------------------------------------------------------- */ + /** Evaluate an immediate variable expression * \verbatim embed:rst @@ -2958,6 +2960,86 @@ double lammps_eval(void *handle, const char *expr) return result; } +/* ---------------------------------------------------------------------- */ + +/** Clear whether a compute has been invoked. + * +\verbatim embed:rst + +.. versionadded:: TBD + + This function clears the invoked flag of all computes. + Called everywhere that computes are used, before computes are invoked. + The invoked flag is used to avoid re-invoking same compute multiple times + and to flag computes that store invocation times as having been invoked + +*See also* + :cpp:func:`lammps_addstep_compute_all` + :cpp:func:`lammps_addstep_compute` + +\endverbatim + + * \param handle pointer to a previously created LAMMPS instance cast to ``void *``. + */ +void lammps_clearstep_compute(void *handle) { + auto lmp = (LAMMPS *) handle; + lmp->modify->clearstep_compute(); +} + +/* ---------------------------------------------------------------------- */ + +/** Add next timestep to all computes + * +\verbatim embed:rst + +.. versionadded:: TBD + + loop over all computes + schedule next invocation for those that store invocation times + called when not sure what computes will be needed on newstep + do not loop only over n_timeflag, since may not be set yet + +*See also* + :cpp:func:`lammps_clearstep_compute` + :cpp:func:`lammps_addstep_compute` + +\endverbatim + + * \param handle pointer to a previously created LAMMPS instance cast to ``void *``. + * \param newstep pointer to bigint of next timestep the compute will be invoked + */ +void lammps_addstep_compute_all(void *handle, void *newstep) { + auto lmp = (LAMMPS *) handle; + auto ns = (bigint *) newstep; + if (lmp && lmp->modify && ns) lmp->modify->addstep_compute_all(*ns); +} +/* ---------------------------------------------------------------------- */ + +/** Add next timestep to compute if it has been invoked in the current timestep + * +\verbatim embed:rst + +.. versionadded:: TBD + + loop over computes that store invocation times + if its invoked flag set on this timestep, schedule next invocation + called everywhere that computes are used, after computes are invoked + +*See also* + :cpp:func:`lammps_addstep_compute_all` + :cpp:func:`lammps_clearstep_compute` + +\endverbatim + + * \param handle pointer to a previously created LAMMPS instance cast to ``void *``. + * \param newstep next timestep the compute will be invoked + */ +void lammps_addstep_compute(void *handle, void *newstep) { + auto lmp = (LAMMPS *) handle; + auto ns = (bigint *) newstep; + if (lmp && lmp->modify && ns) lmp->modify->addstep_compute(*ns); +} + // ---------------------------------------------------------------------- // Library functions for scatter/gather operations of data // ---------------------------------------------------------------------- diff --git a/src/library.h b/src/library.h index f64ae9e7c2..99b251ee85 100644 --- a/src/library.h +++ b/src/library.h @@ -191,6 +191,10 @@ int lammps_set_internal_variable(void *handle, const char *name, double value); int lammps_variable_info(void *handle, int idx, char *buf, int bufsize); double lammps_eval(void *handle, const char *expr); +void lammps_clearstep_compute(void *handle); +void lammps_addstep_compute_all(void *handle, void * nextstep); +void lammps_addstep_compute(void *handle, void * nextstep); + /* ---------------------------------------------------------------------- * Library functions for scatter/gather operations of data * ---------------------------------------------------------------------- */ diff --git a/src/min.cpp b/src/min.cpp index 931031e44a..e20e4c191f 100644 --- a/src/min.cpp +++ b/src/min.cpp @@ -197,10 +197,10 @@ void Min::init() void Min::setup(int flag) { if (comm->me == 0 && screen) { - fmt::print(screen,"Setting up {} style minimization ...\n", update->minimize_style); + utils::print(screen,"Setting up {} style minimization ...\n", update->minimize_style); if (flag) { - fmt::print(screen," Unit style : {}\n", update->unit_style); - fmt::print(screen," Current step : {}\n", update->ntimestep); + utils::print(screen," Unit style : {}\n", update->unit_style); + utils::print(screen," Current step : {}\n", update->ntimestep); timer->print_timeout(screen); } } diff --git a/src/pair.cpp b/src/pair.cpp index 8e9a4e44be..8f10d81d99 100644 --- a/src/pair.cpp +++ b/src/pair.cpp @@ -1843,7 +1843,7 @@ void Pair::write_file(int narg, char **arg) utils::logmesg(lmp,"Creating table file {} with DATE: {}\n", table_file, utils::current_date()); fp = fopen(table_file.c_str(),"w"); - if (fp) fmt::print(fp,"# DATE: {} UNITS: {} Created by pair_write\n", + if (fp) utils::print(fp,"# DATE: {} UNITS: {} Created by pair_write\n", utils::current_date(), update->unit_style); } if (fp == nullptr) diff --git a/src/pair_hybrid_scaled.cpp b/src/pair_hybrid_scaled.cpp index 025c468935..3ce6327370 100644 --- a/src/pair_hybrid_scaled.cpp +++ b/src/pair_hybrid_scaled.cpp @@ -436,7 +436,6 @@ double PairHybridScaled::single(int i, int j, int itype, int jtype, double rsq, // update scale values from variables where needed const int nvars = scalevars.size(); - int atomscaleflag = 0; if (nvars > 0) { auto vals = new double[nvars]; auto vars = new int[nvars]; @@ -453,7 +452,6 @@ double PairHybridScaled::single(int i, int j, int itype, int jtype, double rsq, } else if (input->variable->atomstyle(m)) { vals[k] = 0.0; vars[k] = m; - atomscaleflag = 1; } else error->all(FLERR, "Variable '{}' has incompatible style", scalevars[k]); } @@ -517,7 +515,6 @@ void PairHybridScaled::born_matrix(int i, int j, int itype, int jtype, double rs // update scale values from variables where needed const int nvars = scalevars.size(); - int atomscaleflag = 0; if (nvars > 0) { auto vals = new double[nvars]; auto vars = new int[nvars]; @@ -534,7 +531,6 @@ void PairHybridScaled::born_matrix(int i, int j, int itype, int jtype, double rs } else if (input->variable->atomstyle(m)) { vals[k] = 0.0; vars[k] = m; - atomscaleflag = 1; } else error->all(FLERR, "Variable '{}' has incompatible style", scalevars[k]); } @@ -548,8 +544,8 @@ void PairHybridScaled::born_matrix(int i, int j, int itype, int jtype, double rs delete[] vars; } - double du, du2, scale; - dupair = du2pair = scale = 0.0; + double du, du2; + dupair = du2pair = 0.0; for (int m = 0; m < nmap[itype][jtype]; m++) { auto pstyle = styles[map[itype][jtype][m]]; diff --git a/src/thermo.cpp b/src/thermo.cpp index 35b5016118..6d0e18e6d3 100644 --- a/src/thermo.cpp +++ b/src/thermo.cpp @@ -87,7 +87,8 @@ static constexpr char YAML[] = "step temp ke pe ebond eangle edihed eimp evdwl e #define FORMAT_FLOAT_YAML_DEFAULT "%.15g" #define FORMAT_INT_YAML_DEFAULT "%d" -#define FORMAT_MULTI_HEADER "------------ Step {:14} ----- CPU = {:12.7g} (sec) -------------" +static constexpr char FORMAT_MULTI_HEADER[] = + "------------ Step {:14} ----- CPU = {:12.7g} (sec) -------------"; enum { SCALAR, VECTOR, ARRAY }; diff --git a/src/utils.cpp b/src/utils.cpp index 47e1315304..940faa3eed 100644 --- a/src/utils.cpp +++ b/src/utils.cpp @@ -263,6 +263,22 @@ void utils::fmtargs_logmesg(LAMMPS *lmp, fmt::string_view format, fmt::format_ar } } +/* specialization for the case of just a single string argument */ + +void utils::print(FILE *fp, const std::string &mesg) +{ + fputs(mesg.c_str(), fp); +} + +void utils::fmtargs_print(FILE *fp, fmt::string_view format, fmt::format_args args) +{ + try { + print(fp, fmt::vformat(format, args)); + } catch (fmt::format_error &) { + ; // do nothing + } +} + std::string utils::errorurl(int errorcode) { return fmt::format("\nFor more information see https://docs.lammps.org/err{:04d}", errorcode); diff --git a/src/utils.h b/src/utils.h index 38f91cfc66..7e5e1766ad 100644 --- a/src/utils.h +++ b/src/utils.h @@ -43,6 +43,15 @@ namespace utils { /*! Compare two string while ignoring whitespace * +\verbatim embed:rst + +.. versionadded:: TBD + +This function compares two strings while skipping over any kind of whitespace +(blank, tab, newline, carriage return, etc.). + +\endverbatim + * * \param text1 the first text to be compared * \param text2 the second text to be compared * \return true if the non-whitespace part of the two strings matches, false if not */ @@ -51,6 +60,14 @@ namespace utils { /*! Compress whitespace in a string * +\verbatim embed:rst + +.. versionadded:: TBD + +This function compresses whitespace in a string to just a single blank. + +\endverbatim + * * \param text the text to be compressed * \return string with whitespace compressed to single blanks */ @@ -77,11 +94,22 @@ namespace utils { /*! Create string with last command and optionally pointing to arg with error * - * This function is a helper function for error messages. It creates +\verbatim embed:rst + +.. versionadded:: TBD + +This function is a helper function for error messages. It creates extra output +in error messages. It will produce either two or three lines: the original last +input line *before* variable substitutions, the corresponding pre-processed command +(only when different) and one or more '^' characters pointing to the faulty argument +as indicated by the *failed* argument. Any whitespace in the lines with the command +output are compressed to a single blank by calling :cpp:func:`strcompress()` + +\endverbatim * * \param input pointer to the Input class instance (for access to last command args) - * \param faile index of the faulty argument (-1 to point to the command itself) - * \return string with two lines: the pre-processed command and a '^' pointing to the faulty argument */ + * \param failed index of the faulty argument (-1 to point to the command itself) + * \return string with two or three lines to follow error messages */ std::string point_to_error(Input *input, int failed); /*! Internal function handling the argument list for logmesg(). */ @@ -92,8 +120,8 @@ namespace utils { * * This function simplifies the repetitive task of outputting some * message to both the screen and/or the log file. The template - * wrapper with fmtlib format and argument processing allows - * this function to work similar to ``fmt::print()``. + * wrapper with {fmt} formatting and argument processing allows + * this function to work similar to :cpp:func:`utils::print() `. * * \param lmp pointer to LAMMPS class instance * \param format format string of message to be printed @@ -111,6 +139,36 @@ namespace utils { void logmesg(LAMMPS *lmp, const std::string &mesg); + /*! Internal function handling the argument list for print(). */ + + void fmtargs_print(FILE *fp, fmt::string_view format, fmt::format_args args); + + /*! Write formatted message to file + * +\verbatim embed:rst + +.. versionadded:: TBD + +\endverbatim + * + * This function implements a version of fprintf() that uses {fmt} formatting + * + * \param fp stdio FILE pointer + * \param format format string of message to be printed + * \param args arguments to format string */ + + template void print(FILE *fp, const std::string &format, Args &&...args) + { + fmtargs_print(fp, format, fmt::make_format_args(args...)); + } + + /*! \overload + * + * \param fp stdio FILE pointer + * \param mesg string with message to be printed */ + + void print(FILE *fp, const std::string &mesg); + /*! Return text redirecting the user to a specific paragraph in the manual * * The LAMMPS manual contains detailed explanations for errors and diff --git a/src/variable.cpp b/src/variable.cpp index d20a134d0d..e0c0ae35ee 100644 --- a/src/variable.cpp +++ b/src/variable.cpp @@ -77,7 +77,7 @@ enum{DONE,ADD,SUBTRACT,MULTIPLY,DIVIDE,CARAT,MODULO,UNARY, SQRT,EXP,LN,LOG,ABS,SIN,COS,TAN,ASIN,ACOS,ATAN,ATAN2, RANDOM,NORMAL,CEIL,FLOOR,ROUND,TERNARY, RAMP,STAGGER,LOGFREQ,LOGFREQ2,LOGFREQ3,STRIDE,STRIDE2, - VDISPLACE,SWIGGLE,CWIGGLE,GMASK,RMASK, + VDISPLACE,SWIGGLE,CWIGGLE,SIGN,GMASK,RMASK, GRMASK,IS_ACTIVE,IS_DEFINED,IS_AVAILABLE,IS_FILE,EXTRACT_SETTING, VALUE,ATOMARRAY,TYPEARRAY,INTARRAY,BIGINTARRAY,VECTORARRAY}; @@ -835,7 +835,8 @@ int Variable::next(int narg, char **arg) if (fp == nullptr) goto uloop_again; buf[0] = buf[1] = '\0'; - fread(buf,1,64,fp); + auto tmp = fread(buf,1,64,fp); + (void) tmp; // can be safely ignored, suppress compiler warning in a portable way fclose(fp); if (strlen(buf) > 0) { @@ -2593,7 +2594,7 @@ double Variable::evaluate(char *str, Tree **tree, int ivar) atan2(y,x),random(x,y,z),normal(x,y,z),ceil(),floor(),round(),ternary(x,y,z), ramp(x,y),stagger(x,y),logfreq(x,y,z),logfreq2(x,y,z), logfreq3(x,y,z),stride(x,y,z),stride2(x,y,z,a,b,c),vdisplace(x,y),swiggle(x,y,z), - cwiggle(x,y,z),gmask(x),rmask(x),grmask(x,y) + cwiggle(x,y,z),sign(x),gmask(x),rmask(x),grmask(x,y) ---------------------------------------------------------------------- */ double Variable::collapse_tree(Tree *tree) @@ -3143,6 +3144,14 @@ double Variable::collapse_tree(Tree *tree) return tree->value; } + if (tree->type == SIGN) { + arg1 = collapse_tree(tree->first); + if (tree->first->type != VALUE) return 0.0; + tree->type = VALUE; + tree->value = (arg1 >= 0.0) ? 1.0 : -1.0; // sign(arg1); + return tree->value; + } + // mask functions do not become a single collapsed value if (tree->type == GMASK) return 0.0; @@ -3161,7 +3170,7 @@ double Variable::collapse_tree(Tree *tree) atan2(y,x),random(x,y,z),normal(x,y,z),ceil(),floor(),round(),ternary(x,y,z), ramp(x,y),stagger(x,y),logfreq(x,y,z),logfreq2(x,y,z), logfreq3(x,y,z),stride(x,y,z),stride2(x,y,z,a,b,c),vdisplace(x,y), - swiggle(x,y,z),cwiggle(x,y,z),gmask(x),rmask(x),grmask(x,y) + swiggle(x,y,z),cwiggle(x,y,z),sign(x),gmask(x),rmask(x),grmask(x,y) ---------------------------------------------------------------------- */ double Variable::eval_tree(Tree *tree, int i) @@ -3477,6 +3486,9 @@ double Variable::eval_tree(Tree *tree, int i) return arg; } + if (tree->type == SIGN) + return (eval_tree(tree->first,i) >= 0.0) ? 1.0 : -1.0; // sign(eval_tree(tree->first,i)); + if (tree->type == GMASK) { if (atom->mask[i] & tree->ivalue) return 1.0; else return 0.0; @@ -3650,7 +3662,7 @@ tagint Variable::int_between_brackets(char *&ptr, int varallow) atan2(y,x),random(x,y,z),normal(x,y,z),ceil(),floor(),round(),ternary(), ramp(x,y),stagger(x,y),logfreq(x,y,z),logfreq2(x,y,z), logfreq3(x,y,z),stride(x,y,z),stride2(x,y,z,a,b,c),vdisplace(x,y), - swiggle(x,y,z),cwiggle(x,y,z) + swiggle(x,y,z),cwiggle(x,y,z),sign(x) ------------------------------------------------------------------------- */ int Variable::math_function(char *word, char *contents, Tree **tree, Tree **treestack, @@ -3668,7 +3680,7 @@ int Variable::math_function(char *word, char *contents, Tree **tree, Tree **tree strcmp(word,"logfreq") != 0 && strcmp(word,"logfreq2") != 0 && strcmp(word,"logfreq3") != 0 && strcmp(word,"stride") != 0 && strcmp(word,"stride2") != 0 && strcmp(word,"vdisplace") != 0 && - strcmp(word,"swiggle") != 0 && strcmp(word,"cwiggle") != 0) + strcmp(word,"swiggle") != 0 && strcmp(word,"cwiggle") != 0 && strcmp(word,"sign") != 0) return 0; // parse contents for comma-separated args @@ -4063,6 +4075,11 @@ int Variable::math_function(char *word, char *contents, Tree **tree, Tree **tree double value = value1 + value2*(1.0-cos(omega*delta*update->dt)); argstack[nargstack++] = value; } + } else if (strcmp(word,"sign") == 0) { + if (narg != 1) + print_var_error(FLERR,"Invalid math function in variable formula",ivar); + if (tree) newtree->type = SIGN; + else argstack[nargstack++] = (value1 >= 0.0) ? 1.0 : -1.0; // sign(value1); } // delete stored args diff --git a/src/verlet.cpp b/src/verlet.cpp index 0222a0d2a0..f0a307bdd2 100644 --- a/src/verlet.cpp +++ b/src/verlet.cpp @@ -95,7 +95,7 @@ void Verlet::setup(int flag) if (comm->me == 0 && screen) { fputs("Setting up Verlet run ...\n",screen); if (flag) { - fmt::print(screen," Unit style : {}\n" + utils::print(screen," Unit style : {}\n" " Current step : {}\n" " Time step : {}\n", update->unit_style,update->ntimestep,update->dt); diff --git a/src/write_data.cpp b/src/write_data.cpp index 76d1c598ca..85950f3b47 100644 --- a/src/write_data.cpp +++ b/src/write_data.cpp @@ -274,41 +274,41 @@ void WriteData::write(const std::string &file) void WriteData::header() { - fmt::print(fp,"LAMMPS data file via write_data, version {}, timestep = {}, units = {}\n\n", + utils::print(fp,"LAMMPS data file via write_data, version {}, timestep = {}, units = {}\n\n", lmp->version, update->ntimestep, update->unit_style); - fmt::print(fp,"{} atoms\n{} atom types\n",atom->natoms,atom->ntypes); + utils::print(fp,"{} atoms\n{} atom types\n",atom->natoms,atom->ntypes); // only write out number of types for atom style template if (atom->molecular == Atom::MOLECULAR) { if (atom->nbonds || atom->nbondtypes) - fmt::print(fp,"{} bonds\n{} bond types\n", + utils::print(fp,"{} bonds\n{} bond types\n", nbonds,atom->nbondtypes); if (atom->nangles || atom->nangletypes) - fmt::print(fp,"{} angles\n{} angle types\n", + utils::print(fp,"{} angles\n{} angle types\n", nangles,atom->nangletypes); if (atom->ndihedrals || atom->ndihedraltypes) - fmt::print(fp,"{} dihedrals\n{} dihedral types\n", + utils::print(fp,"{} dihedrals\n{} dihedral types\n", ndihedrals,atom->ndihedraltypes); if (atom->nimpropers || atom->nimpropertypes) - fmt::print(fp,"{} impropers\n{} improper types\n", + utils::print(fp,"{} impropers\n{} improper types\n", nimpropers,atom->nimpropertypes); } if (atom->molecular == Atom::TEMPLATE) { - if (atom->nbondtypes) fmt::print(fp,"{} bond types\n",atom->nbondtypes); - if (atom->nangletypes) fmt::print(fp,"{} angle types\n",atom->nangletypes); - if (atom->ndihedraltypes) fmt::print(fp,"{} dihedral types\n",atom->ndihedraltypes); - if (atom->nimpropertypes) fmt::print(fp,"{} improper types\n",atom->nimpropertypes); + if (atom->nbondtypes) utils::print(fp,"{} bond types\n",atom->nbondtypes); + if (atom->nangletypes) utils::print(fp,"{} angle types\n",atom->nangletypes); + if (atom->ndihedraltypes) utils::print(fp,"{} dihedral types\n",atom->ndihedraltypes); + if (atom->nimpropertypes) utils::print(fp,"{} improper types\n",atom->nimpropertypes); } // bonus info - if (atom->ellipsoid_flag) fmt::print(fp,"{} ellipsoids\n",atom->nellipsoids); - if (atom->line_flag) fmt::print(fp,"{} lines\n",atom->nlines); - if (atom->tri_flag) fmt::print(fp,"{} triangles\n",atom->ntris); - if (atom->body_flag) fmt::print(fp,"{} bodies\n",atom->nbodies); + if (atom->ellipsoid_flag) utils::print(fp,"{} ellipsoids\n",atom->nellipsoids); + if (atom->line_flag) utils::print(fp,"{} lines\n",atom->nlines); + if (atom->tri_flag) utils::print(fp,"{} triangles\n",atom->ntris); + if (atom->body_flag) utils::print(fp,"{} bodies\n",atom->nbodies); // fix info @@ -321,19 +321,19 @@ void WriteData::header() // box info: orthogonal, restricted triclinic, or general triclinic (if requested) if (!domain->triclinic_general) { - fmt::print(fp,"\n{} {} xlo xhi\n{} {} ylo yhi\n{} {} zlo zhi\n", + utils::print(fp,"\n{} {} xlo xhi\n{} {} ylo yhi\n{} {} zlo zhi\n", domain->boxlo[0],domain->boxhi[0], domain->boxlo[1],domain->boxhi[1], domain->boxlo[2],domain->boxhi[2]); if (domain->triclinic) - fmt::print(fp,"{} {} {} xy xz yz\n",domain->xy,domain->xz,domain->yz); + utils::print(fp,"{} {} {} xy xz yz\n",domain->xy,domain->xz,domain->yz); } else if (domain->triclinic_general) { - fmt::print(fp,"\n{} {} {} avec\n{} {} {} bvec\n{} {} {} cvec\n", + utils::print(fp,"\n{} {} {} avec\n{} {} {} bvec\n{} {} {} cvec\n", domain->avec[0],domain->avec[1],domain->avec[2], domain->bvec[0],domain->bvec[1],domain->bvec[2], domain->cvec[0],domain->cvec[1],domain->cvec[2]); - fmt::print(fp,"{} {} {} abc origin\n", + utils::print(fp,"{} {} {} abc origin\n", domain->boxlo[0],domain->boxlo[1],domain->boxlo[2]); } } @@ -348,7 +348,7 @@ void WriteData::type_arrays() double *mass = atom->mass; fputs("\nMasses\n\n",fp); for (int i = 1; i <= atom->ntypes; i++) - fmt::print(fp,"{} {:.16g}\n",i,mass[i]); + utils::print(fp,"{} {:.16g}\n",i,mass[i]); } } @@ -363,7 +363,7 @@ void WriteData::force_fields() if ((comm->me == 0) && (force->pair->mixed_flag == 0)) error->warning(FLERR,"Not all mixed pair coeffs generated from mixing. " "Use write_data with 'pair ij' option to store all pair coeffs."); - fmt::print(fp,"\nPair Coeffs # {}\n\n", force->pair_style); + utils::print(fp,"\nPair Coeffs # {}\n\n", force->pair_style); force->pair->write_data(fp); } else if (pairflag == IJ) { // try computing mixed pair coeffs in case we skipped lmp->init() @@ -375,24 +375,24 @@ void WriteData::force_fields() if (!force->pair->setflag[i][j]) force->pair->init_one(i, j); } - fmt::print(fp,"\nPairIJ Coeffs # {}\n\n", force->pair_style); + utils::print(fp,"\nPairIJ Coeffs # {}\n\n", force->pair_style); force->pair->write_data_all(fp); } } if (force->bond && force->bond->writedata && atom->nbondtypes) { - fmt::print(fp,"\nBond Coeffs # {}\n\n", force->bond_style); + utils::print(fp,"\nBond Coeffs # {}\n\n", force->bond_style); force->bond->write_data(fp); } if (force->angle && force->angle->writedata && atom->nangletypes) { - fmt::print(fp,"\nAngle Coeffs # {}\n\n", force->angle_style); + utils::print(fp,"\nAngle Coeffs # {}\n\n", force->angle_style); force->angle->write_data(fp); } if (force->dihedral && force->dihedral->writedata && atom->ndihedraltypes) { - fmt::print(fp,"\nDihedral Coeffs # {}\n\n", force->dihedral_style); + utils::print(fp,"\nDihedral Coeffs # {}\n\n", force->dihedral_style); force->dihedral->write_data(fp); } if (force->improper && force->improper->writedata && atom->nimpropertypes) { - fmt::print(fp,"\nImproper Coeffs # {}\n\n", force->improper_style); + utils::print(fp,"\nImproper Coeffs # {}\n\n", force->improper_style); force->improper->write_data(fp); } } @@ -429,7 +429,7 @@ void WriteData::atoms() MPI_Status status; MPI_Request request; - fmt::print(fp,"\nAtoms # {}\n\n",atom->atom_style); + utils::print(fp,"\nAtoms # {}\n\n",atom->atom_style); for (int iproc = 0; iproc < comm->nprocs; iproc++) { if (iproc) { MPI_Irecv(&buf[0][0],maxrow*ncol,MPI_DOUBLE,iproc,0,world,&request); diff --git a/tools/coding_standard/errordocs.py b/tools/coding_standard/errordocs.py index 07c0064e6c..fad60dbad8 100644 --- a/tools/coding_standard/errordocs.py +++ b/tools/coding_standard/errordocs.py @@ -102,7 +102,7 @@ def check_folder(directory, config, fix=False, verbose=False): return success def main(): - parser = argparse.ArgumentParser(description='Utility for detecting and fixing whitespace issues in LAMMPS') + parser = argparse.ArgumentParser(description='Utility for detecting and removing error message comment in LAMMPS headers') parser.add_argument('-c', '--config', metavar='CONFIG_FILE', help='location of a optional configuration file') parser.add_argument('-f', '--fix', action='store_true', help='automatically fix URLs') parser.add_argument('-v', '--verbose', action='store_true', help='verbose output') diff --git a/tools/coding_standard/fmtlib.py b/tools/coding_standard/fmtlib.py new file mode 100644 index 0000000000..8128a3c747 --- /dev/null +++ b/tools/coding_standard/fmtlib.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +# Utility for detecting fmtlib related issues +# +# Currently it checks for the following issues +# use of fmt::print() instead of utils::print() +# +# Written by Axel Kohlmeyer (Temple University) +from __future__ import print_function +import sys + +if sys.version_info.major < 3: + sys.exit('This script must be run with Python 3.5 or later') + +if sys.version_info.minor < 5: + sys.exit('This script must be run with Python 3.5 or later') + +import os +import glob +import re +import yaml +import argparse +import shutil + +DEFAULT_CONFIG = """ +recursive: true +include: + - src/** +exclude: + - "src/fmt/" + - "src/fmtlib" + - "src/utils" +patterns: + - "*.h" + - "*.cpp" +""" + +def check_fmtprint(f): + pattern = re.compile(r'[ \t\n\r]*fmt::print\(') + lineno = 1 + errors = set() + + for line in f: + if pattern.match(line): + errors.add(lineno) + lineno += 1 + + return errors + +def check_file(path): + if path.find('fmtlib.py') >= 0: return { 'fmtlib_errors' : '' } + encoding = 'UTF-8' + fmtprint_errors = set() + try: + with open(path, 'r') as f: + fmtprint_errors = check_fmtprint(f) + except UnicodeDecodeError: + encoding = 'ISO-8859-1' + try: + with open(path, 'r', encoding=encoding) as f: + fmtprint_errors = check_fmtprint(f) + except Exception: + encoding = 'unknown' + + return { + 'fmtprint_errors': fmtprint_errors, + 'encoding': encoding + } + +def fix_file(path, check_result): + if path.find('fmtlib.py') >= 0: return + newfile = path + ".modified" + pattern = re.compile(r'fmt::print\(', re.DOTALL) + with open(newfile, 'w', encoding='UTF-8') as out: + with open(path, 'r', encoding=check_result['encoding']) as src: + filetxt = re.sub(pattern,'utils::print(', src.read()); + print(filetxt, end='', file=out) + shutil.copymode(path, newfile) + shutil.move(newfile, path) + +def check_folder(directory, config, fix=False, verbose=False): + success = True + files = [] + + # compile list of files to check + for base_path in config['include']: + for pattern in config['patterns']: + path = os.path.join(directory, base_path, pattern) + files += glob.glob(path, recursive=config['recursive']) + + # prune list of files to skip from list + for pattern in config['exclude']: + path = os.path.join(directory, pattern) + remove = [] + for file in files: + if path not in file: continue + remove += [file] + for rm in remove: + files.remove(rm) + + for f in files: + path = os.path.normpath(f) + + if verbose: + print("Checking file:", path) + + result = check_file(path) + + has_resolvable_errors = False + + for lineno in result['fmtprint_errors']: + print("[Error] Found LAMMPS fmt::print @ {}:{}".format(path, lineno)) + has_resolvable_errors = True + + if has_resolvable_errors: + if fix: + print("Applying automatic fixes to file:", path) + fix_file(path, result) + else: + success = False + + return success + +def main(): + parser = argparse.ArgumentParser(description='Utility for detecting and fixing fmtlib issues in LAMMPS') + parser.add_argument('-c', '--config', metavar='CONFIG_FILE', help='location of a optional configuration file') + parser.add_argument('-f', '--fix', action='store_true', help='automatically fix URLs') + parser.add_argument('-v', '--verbose', action='store_true', help='verbose output') + parser.add_argument('DIRECTORY', help='directory (or file) that should be checked') + args = parser.parse_args() + lammpsdir = os.path.abspath(os.path.expanduser(args.DIRECTORY)) + + if args.config: + with open(args.config, 'r') as cfile: + config = yaml.load(cfile, Loader=yaml.FullLoader) + else: + config = yaml.load(DEFAULT_CONFIG, Loader=yaml.FullLoader) + + if os.path.isdir(lammpsdir): + if not check_folder(lammpsdir, config, args.fix, args.verbose): + sys.exit(1) + else: + success = True + path = os.path.normpath(lammpsdir) + + if args.verbose: + print("Checking file:", path) + + result = check_file(path) + + has_resolvable_errors = False + + for lineno in result['fmtprint_errors']: + print("[Error] Found LAMMPS fmt::print @ {}:{}".format(path, lineno)) + has_resolvable_errors = True + + if has_resolvable_errors: + if args.fix: + print("Applying automatic fixes to file:", path) + fix_file(path, result) + else: + success = False + + if not success: + sys.exit(1) + +if __name__ == "__main__": + main() diff --git a/tools/coding_standard/homepage.py b/tools/coding_standard/homepage.py index 8cfc5192b9..2576bb4ed8 100644 --- a/tools/coding_standard/homepage.py +++ b/tools/coding_standard/homepage.py @@ -158,7 +158,7 @@ def check_folder(directory, config, fix=False, verbose=False): return success def main(): - parser = argparse.ArgumentParser(description='Utility for detecting and fixing whitespace issues in LAMMPS') + parser = argparse.ArgumentParser(description='Utility for detecting and correct the LAMMPS homepage URL and developer email in LAMMPS source files') parser.add_argument('-c', '--config', metavar='CONFIG_FILE', help='location of a optional configuration file') parser.add_argument('-f', '--fix', action='store_true', help='automatically fix URLs') parser.add_argument('-v', '--verbose', action='store_true', help='verbose output') diff --git a/tools/lammps-gui/logwindow.cpp b/tools/lammps-gui/logwindow.cpp index ee92e6da8b..82689924dc 100644 --- a/tools/lammps-gui/logwindow.cpp +++ b/tools/lammps-gui/logwindow.cpp @@ -121,7 +121,6 @@ void LogWindow::stop_run() void LogWindow::next_warning() { - auto *doc = document(); #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0) auto regex = QRegExp(QStringLiteral("^(ERROR|WARNING).*$")); #else diff --git a/tools/swig/lammps.i b/tools/swig/lammps.i index bc9f46f407..476e6ad17d 100644 --- a/tools/swig/lammps.i +++ b/tools/swig/lammps.i @@ -143,6 +143,9 @@ extern int lammps_set_string_variable(void *, const char *, const char *); extern int lammps_set_internal_variable(void *, const char *, double); extern int lammps_variable_info(void *handle, int idx, char *buf, int bufsize); extern double lammps_eval(void *handle, const char *expr); +extern void lammps_clearstep_compute(void *handle); +extern void lammps_addstep_compute(void *handle, void *nstep); +extern void lammps_addstep_compute_all(void *handle, void *nstep); extern void lammps_gather_atoms(void *, char *, int, int, void *); extern void lammps_gather_atoms_concat(void *, char *, int, int, void *); @@ -336,6 +339,9 @@ extern int lammps_set_string_variable(void *, const char *, const char *); extern int lammps_set_internal_variable(void *, const char *, double); extern int lammps_variable_info(void *handle, int idx, char *buf, int bufsize); extern double lammps_eval(void *handle, const char *expr); +extern void lammps_clearstep_compute(void *handle); +extern void lammps_addstep_compute(void *handle, void *nstep); +extern void lammps_addstep_compute_all(void *handle, void *nstep); extern void lammps_gather_atoms(void *, char *, int, int, void *); extern void lammps_gather_atoms_concat(void *, char *, int, int, void *); diff --git a/unittest/c-library/test_library_properties.cpp b/unittest/c-library/test_library_properties.cpp index 737015ccdc..1feccf5cb0 100644 --- a/unittest/c-library/test_library_properties.cpp +++ b/unittest/c-library/test_library_properties.cpp @@ -3,9 +3,12 @@ #include "library.h" #include "atom.h" +#include "compute.h" #include "lammps.h" #include "lmptype.h" +#include "modify.h" #include "platform.h" + #include #include @@ -668,6 +671,77 @@ TEST_F(LibraryProperties, neighlist) } }; +static constexpr char lj_setup[] = "lattice fcc 0.8442\n" + "region box block 0 10 0 10 0 10\n" + "create_box 1 box\n" + "create_atoms 1 box\n" + "mass 1 1.0\n" + "pair_style lj/cut 2.5\n" + "pair_coeff 1 1 1.0 1.0\n" + "fix 1 all nve\n"; + +TEST_F(LibraryProperties, step_compute) +{ + ::testing::internal::CaptureStdout(); + lammps_commands_string(lmp, lj_setup); + lammps_command(lmp, "compute pr all pressure thermo_temp"); + lammps_command(lmp, "fix av all ave/time 2 1 2 c_pr mode scalar"); + lammps_command(lmp, "run 2 post no"); + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + if (lammps_has_error(lmp)) { + char buf[2048]; + lammps_get_last_error_message(lmp, buf, 2048); + FAIL() << buf << "\n"; + } + auto lammps = (LAMMPS_NS::LAMMPS *)lmp; + auto icomp = lammps->modify->get_compute_by_id("pr"); + EXPECT_EQ(icomp->ntime, 2); + EXPECT_EQ(icomp->tlist[0], 4); + EXPECT_EQ(icomp->tlist[1], 2); + EXPECT_EQ(icomp->invoked_flag, 0); + EXPECT_EQ(icomp->invoked_scalar, 2); + EXPECT_EQ(icomp->invoked_vector, -1); + lammps_clearstep_compute(lmp); + EXPECT_EQ(icomp->invoked_flag, 0); + EXPECT_EQ(icomp->invoked_scalar, 2); + EXPECT_EQ(icomp->invoked_vector, -1); + bigint nextstep = 6; + lammps_addstep_compute(lmp, (void *)&nextstep); + EXPECT_EQ(icomp->ntime, 3); + EXPECT_EQ(icomp->tlist[0], 6); + EXPECT_EQ(icomp->tlist[1], 4); + EXPECT_EQ(icomp->tlist[2], 2); + EXPECT_EQ(icomp->invoked_flag, 0); + EXPECT_EQ(icomp->invoked_scalar, 2); + EXPECT_EQ(icomp->invoked_vector, -1); + lammps_command(lmp, "run 4 post no"); + EXPECT_EQ(icomp->ntime, 2); + EXPECT_EQ(icomp->tlist[0], 8); + EXPECT_EQ(icomp->tlist[1], 6); + EXPECT_EQ(icomp->invoked_flag, 0); + EXPECT_EQ(icomp->invoked_scalar, 6); + EXPECT_EQ(icomp->invoked_vector, -1); + lammps_command(lmp, "run 2 post no"); + EXPECT_EQ(icomp->ntime, 2); + EXPECT_EQ(icomp->tlist[0], 10); + EXPECT_EQ(icomp->tlist[1], 8); + EXPECT_EQ(icomp->invoked_flag, 0); + EXPECT_EQ(icomp->invoked_scalar, 8); + EXPECT_EQ(icomp->invoked_vector, -1); + nextstep = 9; + lammps_addstep_compute(lmp, (void *)&nextstep); + lammps_command(lmp, "run 1 post no"); + EXPECT_EQ(icomp->ntime, 2); + EXPECT_EQ(icomp->tlist[0], 10); + EXPECT_EQ(icomp->tlist[1], 9); + EXPECT_EQ(icomp->invoked_flag, 0); + EXPECT_EQ(icomp->invoked_scalar, -1); + EXPECT_EQ(icomp->invoked_vector, -1); + icomp->compute_scalar(); + EXPECT_EQ(icomp->invoked_scalar, 9); +} + TEST_F(LibraryProperties, has_error) { EXPECT_EQ(lammps_has_error(lmp), 0); diff --git a/unittest/force-styles/CMakeLists.txt b/unittest/force-styles/CMakeLists.txt index 043b628fd3..fb6cd1a63b 100644 --- a/unittest/force-styles/CMakeLists.txt +++ b/unittest/force-styles/CMakeLists.txt @@ -246,7 +246,7 @@ if(MLIAP_ENABLE_PYTHON AND (NOT WIN32)) add_executable(test_mliappy_unified test_mliappy_unified.cpp) target_link_libraries(test_mliappy_unified PRIVATE lammps GTest::GMockMain) add_test(NAME TestMliapPyUnified COMMAND test_mliappy_unified) - set_tests_properties(${TNAME} PROPERTIES ENVIRONMENT "${FORCE_TEST_ENVIRONMENT}") + set_tests_properties(TestMliapPyUnified PROPERTIES ENVIRONMENT "${FORCE_TEST_ENVIRONMENT}") endif() add_executable(test_pair_list test_pair_list.cpp) diff --git a/unittest/force-styles/test_angle_style.cpp b/unittest/force-styles/test_angle_style.cpp index ebd8170b7c..e24e5401df 100644 --- a/unittest/force-styles/test_angle_style.cpp +++ b/unittest/force-styles/test_angle_style.cpp @@ -53,15 +53,16 @@ using ::testing::StartsWith; using namespace LAMMPS_NS; -void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) +void cleanup_lammps(LAMMPS *&lmp, const TestConfig &cfg) { platform::unlink(cfg.basename + ".restart"); platform::unlink(cfg.basename + ".data"); platform::unlink(cfg.basename + "-coeffs.in"); delete lmp; + lmp = nullptr; } -LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton = true) +LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton) { LAMMPS *lmp; @@ -92,21 +93,7 @@ LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton // utility lambdas to improve readability auto command = [&](const std::string &line) { - try { - lmp->input->one(line); - } catch (LAMMPSAbortException &ae) { - fprintf(stderr, "LAMMPS Error: %s\n", ae.what()); - exit(2); - } catch (LAMMPSException &e) { - fprintf(stderr, "LAMMPS Error: %s\n", e.what()); - exit(3); - } catch (fmt::format_error &fe) { - fprintf(stderr, "fmt::format_error: %s\n", fe.what()); - exit(4); - } catch (std::exception &e) { - fprintf(stderr, "General exception: %s\n", e.what()); - exit(5); - } + lmp->input->one(line); }; auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); @@ -230,7 +217,12 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // initialize system geometry LAMMPS::argv args = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite"}; - LAMMPS *lmp = init_lammps(args, config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, config, true); + } catch (std::exception &e) { + FAIL() << e.what(); + } if (!lmp) { std::cerr << "One or more prerequisite styles are not available " "in this LAMMPS configuration:\n"; @@ -321,8 +313,14 @@ TEST(AngleStyle, plain) LAMMPS::argv args = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -371,7 +369,12 @@ TEST(AngleStyle, plain) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -439,8 +442,14 @@ TEST(AngleStyle, omp) "-pk", "omp", "4", "-sf", "omp"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -493,7 +502,12 @@ TEST(AngleStyle, omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -540,14 +554,21 @@ TEST(AngleStyle, kokkos_omp) // if KOKKOS has GPU support enabled, it *must* be used. We cannot test OpenMP only. if (Info::has_accelerator_feature("KOKKOS", "api", "cuda") || Info::has_accelerator_feature("KOKKOS", "api", "hip") || - Info::has_accelerator_feature("KOKKOS", "api", "sycl")) GTEST_SKIP(); + Info::has_accelerator_feature("KOKKOS", "api", "sycl")) + GTEST_SKIP() << "Cannot test KOKKOS/OpenMP with GPU support enabled"; LAMMPS::argv args = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite", "-k", "on", "t", "4", "-sf", "kk"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -597,7 +618,12 @@ TEST(AngleStyle, kokkos_omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -664,8 +690,14 @@ TEST(AngleStyle, numdiff) LAMMPS::argv args = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -717,7 +749,13 @@ TEST(AngleStyle, single) // create a LAMMPS instance with standard settings to detect the number of atom types if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { @@ -865,7 +903,13 @@ TEST(AngleStyle, extract) LAMMPS::argv args = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite"}; if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { diff --git a/unittest/force-styles/test_bond_style.cpp b/unittest/force-styles/test_bond_style.cpp index 4a3a985ffc..660435cf49 100644 --- a/unittest/force-styles/test_bond_style.cpp +++ b/unittest/force-styles/test_bond_style.cpp @@ -53,15 +53,16 @@ using ::testing::StartsWith; using namespace LAMMPS_NS; -void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) +void cleanup_lammps(LAMMPS *&lmp, const TestConfig &cfg) { platform::unlink(cfg.basename + ".restart"); platform::unlink(cfg.basename + ".data"); platform::unlink(cfg.basename + "-coeffs.in"); delete lmp; + lmp = nullptr; } -LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton = true) +LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton) { LAMMPS *lmp; @@ -92,21 +93,7 @@ LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton // utility lambdas to improve readability auto command = [&](const std::string &line) { - try { - lmp->input->one(line); - } catch (LAMMPSAbortException &ae) { - fprintf(stderr, "LAMMPS Error: %s\n", ae.what()); - exit(2); - } catch (LAMMPSException &e) { - fprintf(stderr, "LAMMPS Error: %s\n", e.what()); - exit(3); - } catch (fmt::format_error &fe) { - fprintf(stderr, "fmt::format_error: %s\n", fe.what()); - exit(4); - } catch (std::exception &e) { - fprintf(stderr, "General exception: %s\n", e.what()); - exit(5); - } + lmp->input->one(line); }; auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); @@ -230,7 +217,13 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // initialize system geometry LAMMPS::argv args = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; - LAMMPS *lmp = init_lammps(args, config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, config, true); + } catch (std::exception &e) { + FAIL() << e.what(); + } + if (!lmp) { std::cerr << "One or more prerequisite styles are not available " "in this LAMMPS configuration:\n"; @@ -321,8 +314,14 @@ TEST(BondStyle, plain) LAMMPS::argv args = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -371,7 +370,12 @@ TEST(BondStyle, plain) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -441,8 +445,14 @@ TEST(BondStyle, omp) "-pk", "omp", "4", "-sf", "omp"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -495,7 +505,12 @@ TEST(BondStyle, omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -542,14 +557,21 @@ TEST(BondStyle, kokkos_omp) // if KOKKOS has GPU support enabled, it *must* be used. We cannot test OpenMP only. if (Info::has_accelerator_feature("KOKKOS", "api", "cuda") || Info::has_accelerator_feature("KOKKOS", "api", "hip") || - Info::has_accelerator_feature("KOKKOS", "api", "sycl")) GTEST_SKIP(); + Info::has_accelerator_feature("KOKKOS", "api", "sycl")) + GTEST_SKIP() << "Cannot test KOKKOS/OpenMP with GPU support enabled"; LAMMPS::argv args = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite", "-k", "on", "t", "4", "-sf", "kk"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -603,7 +625,12 @@ TEST(BondStyle, kokkos_omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -652,8 +679,14 @@ TEST(BondStyle, numdiff) LAMMPS::argv args = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -705,7 +738,13 @@ TEST(BondStyle, single) // create a LAMMPS instance with standard settings to detect the number of atom types if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { @@ -959,7 +998,13 @@ TEST(BondStyle, extract) LAMMPS::argv args = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { diff --git a/unittest/force-styles/test_dihedral_style.cpp b/unittest/force-styles/test_dihedral_style.cpp index b538c45f42..5d0bd86d2b 100644 --- a/unittest/force-styles/test_dihedral_style.cpp +++ b/unittest/force-styles/test_dihedral_style.cpp @@ -53,15 +53,16 @@ using ::testing::StartsWith; using namespace LAMMPS_NS; -void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) +void cleanup_lammps(LAMMPS *&lmp, const TestConfig &cfg) { platform::unlink(cfg.basename + ".restart"); platform::unlink(cfg.basename + ".data"); platform::unlink(cfg.basename + "-coeffs.in"); delete lmp; + lmp = nullptr; } -LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton = true) +LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton) { auto *lmp = new LAMMPS(args, MPI_COMM_WORLD); @@ -237,7 +238,13 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // initialize system geometry LAMMPS::argv args = {"DihedralStyle", "-log", "none", "-echo", "screen", "-nocite"}; - LAMMPS *lmp = init_lammps(args, config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, config, true); + } catch (std::exception &e) { + FAIL() << e.what(); + } + if (!lmp) { std::cerr << "One or more prerequisite styles are not available " "in this LAMMPS configuration:\n"; @@ -322,8 +329,14 @@ TEST(DihedralStyle, plain) LAMMPS::argv args = {"DihedralStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -372,7 +385,12 @@ TEST(DihedralStyle, plain) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -442,8 +460,14 @@ TEST(DihedralStyle, omp) "-pk", "omp", "4", "-sf", "omp"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -497,7 +521,12 @@ TEST(DihedralStyle, omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -544,15 +573,22 @@ TEST(DihedralStyle, kokkos_omp) // if KOKKOS has GPU support enabled, it *must* be used. We cannot test OpenMP only. if (Info::has_accelerator_feature("KOKKOS", "api", "cuda") || Info::has_accelerator_feature("KOKKOS", "api", "hip") || - Info::has_accelerator_feature("KOKKOS", "api", "sycl")) GTEST_SKIP(); + Info::has_accelerator_feature("KOKKOS", "api", "sycl")) + GTEST_SKIP() << "Cannot test KOKKOS/OpenMP with GPU support enabled"; LAMMPS::argv args = {"DihedralStyle", "-log", "none", "-echo", "screen", "-nocite", "-k", "on", "t", "4", "-sf", "kk"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -606,7 +642,12 @@ TEST(DihedralStyle, kokkos_omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -655,8 +696,14 @@ TEST(DihedralStyle, numdiff) LAMMPS::argv args = {"DihedralStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; diff --git a/unittest/force-styles/test_fix_timestep.cpp b/unittest/force-styles/test_fix_timestep.cpp index 957226d22b..b952a3c045 100644 --- a/unittest/force-styles/test_fix_timestep.cpp +++ b/unittest/force-styles/test_fix_timestep.cpp @@ -56,13 +56,14 @@ using ::testing::StartsWith; using namespace LAMMPS_NS; -void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) +void cleanup_lammps(LAMMPS *&lmp, const TestConfig &cfg) { platform::unlink(cfg.basename + ".restart"); delete lmp; + lmp = nullptr; } -LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool use_respa = false) +LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool use_respa) { LAMMPS *lmp; @@ -178,7 +179,12 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) { // initialize system geometry LAMMPS::argv args = {"FixIntegrate", "-log", "none", "-echo", "screen", "-nocite"}; - LAMMPS *lmp = init_lammps(args, config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, config, false); + } catch (std::exception &e) { + FAIL() << e.what(); + } if (!lmp) { std::cerr << "One or more prerequisite styles are not available " "in this LAMMPS configuration:\n"; @@ -272,7 +278,14 @@ TEST(FixTimestep, plain) LAMMPS::argv args = {"FixTimestep", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -430,14 +443,20 @@ TEST(FixTimestep, plain) // fix nve/limit cannot work with r-RESPA ifix = lmp->modify->get_fix_by_id("test"); if (ifix && !utils::strmatch(ifix->style, "^rigid") && - !utils::strmatch(ifix->style, "^nve/limit") && - !utils::strmatch(ifix->style, "^recenter")) { + !utils::strmatch(ifix->style, "^nve/limit") && !utils::strmatch(ifix->style, "^recenter")) { if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); ::testing::internal::CaptureStdout(); - lmp = init_lammps(args, test_config, true); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -572,15 +591,26 @@ TEST(FixTimestep, omp) "-pk", "omp", "4", "-sf", "omp"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { - std::cerr << "One or more prerequisite styles are not available " + std::cerr << "One or more prerequisite styles with /omp suffix are not available " "in this LAMMPS configuration:\n"; for (auto &prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; + if (prerequisite.first == "atom") { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; + } else { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "/omp\n"; + } } GTEST_SKIP(); } @@ -731,7 +761,13 @@ TEST(FixTimestep, omp) if (!verbose) ::testing::internal::GetCapturedStdout(); ::testing::internal::CaptureStdout(); - lmp = init_lammps(args, test_config, true); + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -861,13 +897,21 @@ TEST(FixTimestep, kokkos_omp) // if KOKKOS has GPU support enabled, it *must* be used. We cannot test OpenMP only. if (Info::has_accelerator_feature("KOKKOS", "api", "cuda") || Info::has_accelerator_feature("KOKKOS", "api", "hip") || - Info::has_accelerator_feature("KOKKOS", "api", "sycl")) GTEST_SKIP(); - + Info::has_accelerator_feature("KOKKOS", "api", "sycl")) { + GTEST_SKIP() << "Cannot test KOKKOS/OpenMP with GPU support enabled"; + } LAMMPS::argv args = {"FixTimestep", "-log", "none", "-echo", "screen", "-nocite", "-k", "on", "t", "4", "-sf", "kk"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -875,7 +919,7 @@ TEST(FixTimestep, kokkos_omp) std::cerr << "One or more prerequisite styles with /kk suffix\n" "are not available in this LAMMPS configuration:\n"; for (auto &prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "/kk\n"; } GTEST_SKIP(); } diff --git a/unittest/force-styles/test_improper_style.cpp b/unittest/force-styles/test_improper_style.cpp index cddb27a2f7..e272033e85 100644 --- a/unittest/force-styles/test_improper_style.cpp +++ b/unittest/force-styles/test_improper_style.cpp @@ -53,15 +53,16 @@ using ::testing::StartsWith; using namespace LAMMPS_NS; -void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) +void cleanup_lammps(LAMMPS *&lmp, const TestConfig &cfg) { platform::unlink(cfg.basename + ".restart"); platform::unlink(cfg.basename + ".data"); platform::unlink(cfg.basename + "-coeffs.in"); delete lmp; + lmp = nullptr; } -LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton = true) +LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton) { LAMMPS *lmp; @@ -92,21 +93,7 @@ LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton // utility lambdas to improve readability auto command = [&](const std::string &line) { - try { - lmp->input->one(line); - } catch (LAMMPSAbortException &ae) { - fprintf(stderr, "LAMMPS Error: %s\n", ae.what()); - exit(2); - } catch (LAMMPSException &e) { - fprintf(stderr, "LAMMPS Error: %s\n", e.what()); - exit(3); - } catch (fmt::format_error &fe) { - fprintf(stderr, "fmt::format_error: %s\n", fe.what()); - exit(4); - } catch (std::exception &e) { - fprintf(stderr, "General exception: %s\n", e.what()); - exit(5); - } + lmp->input->one(line); }; auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); @@ -230,7 +217,12 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // initialize system geometry LAMMPS::argv args = {"ImproperStyle", "-log", "none", "-echo", "screen", "-nocite"}; - LAMMPS *lmp = init_lammps(args, config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, config, true); + } catch (std::exception &e) { + FAIL() << e.what(); + } if (!lmp) { std::cerr << "One or more prerequisite styles are not available " "in this LAMMPS configuration:\n"; @@ -315,8 +307,14 @@ TEST(ImproperStyle, plain) LAMMPS::argv args = {"ImproperStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -365,7 +363,12 @@ TEST(ImproperStyle, plain) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -435,8 +438,14 @@ TEST(ImproperStyle, omp) "-pk", "omp", "4", "-sf", "omp"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -490,7 +499,12 @@ TEST(ImproperStyle, omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -536,15 +550,22 @@ TEST(ImproperStyle, kokkos_omp) // if KOKKOS has GPU support enabled, it *must* be used. We cannot test OpenMP only. if (Info::has_accelerator_feature("KOKKOS", "api", "cuda") || Info::has_accelerator_feature("KOKKOS", "api", "hip") || - Info::has_accelerator_feature("KOKKOS", "api", "sycl")) GTEST_SKIP(); + Info::has_accelerator_feature("KOKKOS", "api", "sycl")) + GTEST_SKIP() << "Cannot test KOKKOS/OpenMP with GPU support enabled"; LAMMPS::argv args = {"ImproperStyle", "-log", "none", "-echo", "screen", "-nocite", "-k", "on", "t", "4", "-sf", "kk"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -597,7 +618,12 @@ TEST(ImproperStyle, kokkos_omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on @@ -644,8 +670,14 @@ TEST(ImproperStyle, numdiff) LAMMPS::argv args = {"ImproperStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; diff --git a/unittest/force-styles/test_pair_style.cpp b/unittest/force-styles/test_pair_style.cpp index bb1346fe70..6dabeab7a4 100644 --- a/unittest/force-styles/test_pair_style.cpp +++ b/unittest/force-styles/test_pair_style.cpp @@ -54,15 +54,16 @@ using ::testing::StartsWith; using namespace LAMMPS_NS; -void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) +void cleanup_lammps(LAMMPS *&lmp, const TestConfig &cfg) { platform::unlink(cfg.basename + ".restart"); platform::unlink(cfg.basename + ".data"); platform::unlink(cfg.basename + "-coeffs.in"); delete lmp; + lmp = nullptr; } -LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton = true) +LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton) { LAMMPS *lmp; @@ -93,21 +94,7 @@ LAMMPS *init_lammps(LAMMPS::argv &args, const TestConfig &cfg, const bool newton // utility lambdas to improve readability auto command = [&](const std::string &line) { - try { - lmp->input->one(line); - } catch (LAMMPSAbortException &ae) { - fprintf(stderr, "LAMMPS Error: %s\n", ae.what()); - exit(2); - } catch (LAMMPSException &e) { - fprintf(stderr, "LAMMPS Error: %s\n", e.what()); - exit(3); - } catch (fmt::format_error &fe) { - fprintf(stderr, "fmt::format_error: %s\n", fe.what()); - exit(4); - } catch (std::exception &e) { - fprintf(stderr, "General exception: %s\n", e.what()); - exit(5); - } + lmp->input->one(line); }; auto parse_input_script = [&](const std::string &filename) { @@ -242,8 +229,12 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) { // initialize system geometry LAMMPS::argv args = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite"}; - - LAMMPS *lmp = init_lammps(args, config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, config, true); + } catch (std::exception &e) { + FAIL() << e.what(); + } if (!lmp) { std::cerr << "One or more prerequisite styles are not available " "in this LAMMPS configuration:\n"; @@ -340,8 +331,14 @@ TEST(PairStyle, plain) LAMMPS::argv args = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -399,7 +396,12 @@ TEST(PairStyle, plain) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton pair is forced to be on @@ -480,9 +482,14 @@ TEST(PairStyle, plain) if (pair->respa_enable) { if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); - lmp->input->one("run_style respa 2 1 inner 1 4.8 5.5 outer 2"); - run_lammps(lmp); + try { + lmp = init_lammps(args, test_config, false); + lmp->input->one("run_style respa 2 1 inner 1 4.8 5.5 outer 2"); + run_lammps(lmp); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); // need to relax error by a large amount with tabulation, since @@ -519,8 +526,14 @@ TEST(PairStyle, omp) if (utils::strmatch(test_config.pair_style, "^dpd")) args[8] = "1"; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -578,7 +591,12 @@ TEST(PairStyle, omp) if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); pair = lmp->force->pair; @@ -636,7 +654,9 @@ TEST(PairStyle, kokkos_omp) // if KOKKOS has GPU support enabled, it *must* be used. We cannot test OpenMP only. if (Info::has_accelerator_feature("KOKKOS", "api", "cuda") || Info::has_accelerator_feature("KOKKOS", "api", "hip") || - Info::has_accelerator_feature("KOKKOS", "api", "sycl")) GTEST_SKIP(); + Info::has_accelerator_feature("KOKKOS", "api", "sycl")) { + GTEST_SKIP() << "Cannot test KOKKOS/OpenMP with GPU support enabled"; + } LAMMPS::argv args = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite", "-k", "on", "t", "4", "-sf", "kk"}; @@ -655,8 +675,14 @@ TEST(PairStyle, kokkos_omp) args[9] = "1"; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -713,7 +739,12 @@ TEST(PairStyle, kokkos_omp) if (lmp->force->newton_pair == 0) { if (!verbose) ::testing::internal::CaptureStdout(); cleanup_lammps(lmp, test_config); - lmp = init_lammps(args, test_config, false); + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); pair = lmp->force->pair; @@ -788,8 +819,14 @@ TEST(PairStyle, gpu) } ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, false); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, false); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -868,8 +905,14 @@ TEST(PairStyle, intel) if (utils::strmatch(test_config.pair_style, "^dpd")) args[12] = "1"; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -948,8 +991,14 @@ TEST(PairStyle, opt) LAMMPS::argv args = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite", "-sf", "opt"}; ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config); - + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + std::string output = ::testing::internal::GetCapturedStdout(); + if (verbose) std::cout << output; + FAIL() << e.what(); + } std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; @@ -1032,7 +1081,13 @@ TEST(PairStyle, single) // create a LAMMPS instance with standard settings to detect the number of atom types if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { @@ -1276,7 +1331,13 @@ TEST(PairStyle, extract) LAMMPS::argv args = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite"}; if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(args, test_config, true); + LAMMPS *lmp = nullptr; + try { + lmp = init_lammps(args, test_config, true); + } catch (std::exception &e) { + if (!verbose) ::testing::internal::GetCapturedStdout(); + FAIL() << e.what(); + } if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { diff --git a/unittest/force-styles/tests/fix-timestep-efield_lepton.yaml b/unittest/force-styles/tests/fix-timestep-efield_lepton.yaml index c6f80af274..7928c81c45 100644 --- a/unittest/force-styles/tests/fix-timestep-efield_lepton.yaml +++ b/unittest/force-styles/tests/fix-timestep-efield_lepton.yaml @@ -6,7 +6,7 @@ epsilon: 2e-13 skip_tests: prerequisites: ! | atom full - fix efield + fix efield/lepton pre_commands: ! "" post_commands: ! | region half block 0 EDGE EDGE EDGE EDGE EDGE diff --git a/unittest/force-styles/tests/fix-timestep-efield_lepton_region.yaml b/unittest/force-styles/tests/fix-timestep-efield_lepton_region.yaml index b2275f047b..f0a6b121a4 100644 --- a/unittest/force-styles/tests/fix-timestep-efield_lepton_region.yaml +++ b/unittest/force-styles/tests/fix-timestep-efield_lepton_region.yaml @@ -6,7 +6,7 @@ epsilon: 2e-13 skip_tests: prerequisites: ! | atom full - fix efield + fix efield/lepton pre_commands: ! "" post_commands: ! | region half block 0 EDGE EDGE EDGE EDGE EDGE diff --git a/unittest/formats/test_text_file_reader.cpp b/unittest/formats/test_text_file_reader.cpp index 3fae7ef231..a8fb0b4f7a 100644 --- a/unittest/formats/test_text_file_reader.cpp +++ b/unittest/formats/test_text_file_reader.cpp @@ -92,7 +92,7 @@ TEST_F(TextFileReaderTest, buffer) test_files(); auto *reader = new TextFileReader("text_reader_two.file", "test"); reader->set_bufsize(4096); - auto *line = reader->next_line(); + reader->next_line(); ASSERT_THROW({ reader->set_bufsize(20); }, FileReaderException); delete reader; }