4 # The contents of this file are subject to the terms of the Common Development
5 # and Distribution License Version 1.0 (the "License").
7 # You can obtain a copy of the license at
8 # http://www.opensource.org/licenses/CDDL-1.0. See the License for the
9 # specific language governing permissions and limitations under the License.
11 # When distributing Covered Code, include this CDDL HEADER in each file and
12 # include the License file in a prominent location with the name LICENSE.CDDL.
13 # If applicable, add the following below this CDDL HEADER, with the fields
14 # enclosed by brackets "[]" replaced with your own identifying information:
16 # Portions Copyright (c) [yyyy] [name of copyright owner]. All rights reserved.
22 # Copyright (c) 2013--2020, Regents of the University of Minnesota.
23 # All rights reserved.
31 # Release: This file is part of the kim-api-2.2.1 package.
35 ============================= The KIM API package =============================
37 This file contains instructions for installing the KIM API package.
42 A. System requirements
46 C. Package concepts and operation overview
48 C.2 Collections for Model Drivers (MDs), Portable Models (PMs), and
49 Simulator Models (SMs)
50 C.2.1 The system-collection
51 C.2.2 The user-collection
52 C.2.3 The environment-variable-collection
53 C.2.4 The CWD-collection
56 D. KIM API Installation
57 D.1 Typical build scenario
58 D.2 CMake build options
59 D.2.1 Compiler selection
60 D.2.2 CMAKE_BUILD_TYPE
61 D.2.3 Installation prefix
62 D.2.4 KIM API specific build options
63 D.3 Installing multiple versions
64 D.4 Uninstall the KIM API
66 E. Adding MDs, PMs, and SMs to the collections
67 E.1 Adding MDs, PMs, and SMs to the system-collection
68 E.2 Adding MDs, PMs, and SMs to the user-collection
69 E.3 Adding MDs, PMs, and SMs to the environment-variable-collection
70 E.4 Adding MDs, PMs, and SMs to the CWD-collection
71 E.5 Adding MDs, PMs, and SMs from a local source directory
72 E.6 Manually adding MDs, PMs, and SMs
75 -------------------------------------------------------------------------------
77 A. SYSTEM REQUIREMENTS
80 To install and run the KIM API package you need the following:
82 1. A Unix/Linux/macOS system.
84 2. CMake (3.10 or later).
86 3. GNU compilers (gcc, g++, gfortran) version 4.8.x or higher or the
87 corresponding Intel compilers, version 11.1 or higher. Other compilers may
90 4. (optional) The 'xxd' utility (distributed as part of the vim package).
91 If available, provides faster builds than without.
93 5. wget or curl, sed, grep, tar, uname, etc. (used by the
94 kim-api-collections-management utility).
96 6. Doxygen and Graphviz (for generating the documentation).
98 7. The bash-completion package (for facilitating command-line usage of the
101 8. pkg-config can be used by code needing to link against the kim-api library.
104 -------------------------------------------------------------------------------
106 B. QUICK START: For those who don't like to read and are a bit audacious.
110 $ mkdir build && cd build
111 $ cmake .. -DCMAKE_BUILD_TYPE=Release
116 For more information, see section D.
118 -------------------------------------------------------------------------------
120 C. PACKAGE LAYOUT AND OPERATION OVERVIEW
123 The KIM API package is a system-level library that aims to give computer
124 programmers the ability to write atomistic or molecular simulation programs
125 (Simulators) that can seamlessly interface with implementations of interatomic
126 potentials (Portable Models, PMs), regardless of the programming language in
127 which the codes are written. The KIM API package provides a dedicated Portable
128 Model Interface (PMI) for use by simulators and PMs and referred to as the KIM
129 API/PMI. A PM can include code and parameters all in one. Or, a PM can
130 include just parameters and use a separate Model Driver (MD) library containing
131 the code. There are also Simulator Models (SMs) that only work with a specific
132 simulator. The KIM API package provides a dedicated Simulator Model Interface
133 (SMI) for use by simulators and SMs and referred to as the KIM API/SMI. In
134 addition to the main KIM API library, a small number of associated helper
135 utilities are provided.
139 The KIM API library provides the necessary routines for a Simulator to interact
140 with a PM or SM. It also contains an interface for discovering what MDs, PMs,
141 and SMs are available in the KIM API Collections. MDs, PMs, and SMs are built
142 and linked against the KIM API library, then installed in one of the
143 collections (see below) so that they are available for use with a simulator.
144 Simulators are built and linked against the KIM API library so that they can
145 access and use any of the available PMs and/or SM in the various collections.
147 C.2 COLLECTIONS FOR MODEL DRIVERS (MDs), PORTABLE MODELS (PMs), AND
148 SIMULATOR MODELS (SMs)
150 The KIM API supports four Collections of Items. These are the
151 "system-collection", the "user-collection", the
152 "environment-variable-collection", and the "CWD-collection" as described below.
153 Each collection consists of separate sets of three Item Types: MDs, PMs, and
154 SMs. When the KIM API needs to use a particular MD, PD, or SM, it looks for
155 the item by type and name, first in the CWD-collection, then in the
156 environment-variable-collection, then in the user-collection, and finally in
157 the system-collection. It uses the first match that it finds. Note, it is
158 possible for a PM and its associated MD to be located in different collections.
159 The search for each is a separate and independent procedure.
161 See also the documentation for the Collections Interface (c++:
162 KIM::Collections; c: KIM_Collections; and Fortran: kim_collections_module).
164 C.2.1 THE SYSTEM-COLLECTION
166 The system-collection is a collection of MDs, PMs, and SMs that are available
167 to all simulators that use the KIM API library. By default, this collection is
168 located in the same subdirectory as the KIM API library. (See also the
169 "KIM_API_SYSTEM_*_DIR" build options in section D.2.4, below.)
171 MDs, PMs, and SMs may be built and installed to the system-collection at
172 anytime after the KIM API has been built and installed.
174 C.2.2 THE USER-COLLECTION
176 The user-collection is a collection of MDs, PMs, and SMs that are available
177 only to the user who owns the process for the simulator that uses the KIM API
178 library. This collection is located in subdirectories that are specified by a
179 configuration file. The user-collection may be populated with MDs, PMs, and
180 SMs after the KIM API has been built and installed.
182 The configuration file is named "${HOME}/.kim-api/<kim-api-uid>/config" by
183 default, where <kim-api-uid> is a unique identifier for the particular
184 installation of the kim-api being used (this allows multiple, independent,
185 installations on a single machine). Here "${HOME}" is the user's home
186 directory. (See item D below for build options controlling this default file
187 name.) If the "KIM_API_CONFIGURATION_FILE" environment variable is set, its
188 value (interpreted as an absolute file name) will supersede the default
189 location and name of the configuration file. For example, the following
190 commands will instruct the KIM API library to use a file named "kim-config" in
191 the /my-kim-stuff folder
193 $ export KIM_API_CONFIGURATION_FILE=/my-kim-stuff/kim-config
195 If the configuration file does not exist, the KIM API library will create it
196 with a default configuration specifying that the user-collection files are
197 stored in "${HOME}/.kim-api/<kim-api-uid>/model-drivers/",
198 "${HOME}/.kim-api/<kim-api-uid>/portable-models/", and
199 "${HOME}/.kim-api/<kim-api-uid>/simulator-models/". More generally, the values
200 in the configuration file may contain colon ':' (on Windows: semi-colon ';')
201 separated lists of fully-qualified directory names (starting, strictly, with
202 '/', '~/' or a root drive letter like 'C:/'). (See item D below for build
203 options controlling these defaults.)
205 C.2.3 THE ENVIRONMENT-VARIABLE-COLLECTION
207 The environment-variable-collection is a collection of MDs, PMs, and SMs that
208 are specified by the run-time environment of the process for the simulator that
209 uses the KIM API library. The locations of this collection are specified by
210 the environment variables "KIM_API_MODEL_DRIVERS_DIR",
211 "KIM_API_PORTABLE_MODELS_DIR", and "KIM_API_SIMULATOR_MODELS_DIR". These
212 variables should contain colon ':' (on Windows: semi-colon ';') separated lists
213 of absolute directory names where the collection MDs, PMs, and SMs, respectively,
214 are located. (For example, in bash you could execute the command
216 $ export KIM_API_PORTABLE_MODELS_DIR=/my-kim-stuff/models-i-am-developing:/my-kim-stuff/misc-portable-models
218 to have the KIM API look for PMs in /my-kim-stuff/models-i-am-developing first
219 and then look in /my-kim-stuff/misc-portable-models. (Similarly for MDs and
220 SMs.) The environment-variable-collection may be populated with MDs, PMs, and
221 SMs after the KIM API has been built and installed.
223 C.2.4 THE CWD-COLLECTION
225 The CWD-collection is a collection of MDs, PMs, SMs that are available to a
226 simulator at run-time. The collection is located in the simulator process's
227 current working directory (CWD). The CWD-collection may be populated with MDs,
228 PMs, and SMs after the KIM API has been built and installed.
232 The KIM API package also includes a utility for managing the MDs, PMs, and SMs
233 contained in the various collections and for managing the configuration file.
234 This utility is called "kim-api-collections-management". The KIM API package
235 installs bash completion scripts that are designed to work with the
236 "bash-completion" package (https://github.com/scop/bash-completion). When
237 "bash-completion" is installed and activated on the system, tab-completions for
238 the collections management utility should be automatically loaded and available
241 In addition, when the KIM API package is installed to a "Local (non-global)"
242 (see D below) directory, the package also installs the "kim-api-activate" and
243 "kim-api-deactivate" scripts. The activate script adds the utilities to the
244 executable PATH, adds the KIM API library to the PKG_CONFIG_PATH so that the
245 pkg-config utility can find it, and loads bash tab-completion support for the
246 collections management utility. The deactivate script removes what the
247 activate script added.
250 -------------------------------------------------------------------------------
252 D. KIM API INSTALLATION
254 D.1 Typical Build Scenario
256 Here, the typical KIM API build and install process is detailed and the
257 system-collection is populated with the example MDs, PMs, and SMs, as well as a
258 single PM and its associated MD, both from openkim.org. Additionally, one of
259 the example simulators is copied to the user's home directory and used to test
260 the KIM API. The KIM API package uses the CMake build system. See the CMake
261 documentation (https://cmake.org/cmake/help/v3.10/) for help with CMake
262 settings. For some common CMake settings and KIM API specific settings, see
265 The commands given below are for the bash shell.
267 By default packages are installed to the Global prefix directory "/usr/local".
268 Here we assume that "/usr/local/bin" is included as part of the system's
269 standard PATH setting.
271 First, we will create a working space and obtain the source package
273 $ export WORKSPACE="${HOME}/kim-api-workspace"
274 $ mkdir "${WORKSPACE}"
276 $ wget https://s3.openkim.org/kim-api/kim-api-X.Y.Z.txz # replace X, Y, and Z with the current version numbers
277 $ tar Jxvf kim-api-X.Y.Z.txz
280 We will set an environment variable to point the the KIM API source.
282 $ export KIM_API_SOURCE="${WORKSPACE}/kim-api-X.Y.Z" # replace X, Y, and Z with the current version numbers
284 Next the configuration and build process begins. (Note: lines beginning with
285 "$", without leading whitespace, in this file are extracted and used in the KIM
286 API automated Continuous-Integration (CI) testing framework.)
291 $ cmake ${KIM_API_SOURCE} -DCMAKE_BUILD_TYPE=Release
294 If you want, build the documentation.
298 If you want, before installing the package, you can run the tests.
302 Now, install the package (and docs, if built).
305 $ sudo ldconfig # All linux systems should do this; on Redhat-like systems you may need to first add /usr/local/lib to /etc/ld.so.conf
306 $ cp -r "${KIM_API_SOURCE}/examples/simulators/utility_forces_numer_deriv" "${WORKSPACE}/"
309 If you want, you can now delete the source and build tree. However, you may
310 also want to preserve the "install_manifest.txt" file which would be needed for
311 uninstalling the KIM API package (see D.4 below).
313 $ cp "${WORKSPACE}/build/install_manifest.txt" "${WORKSPACE}/install_manifest.txt"
314 $ rm -r "${WORKSPACE}/build
316 Now, we can build the simulator using the KIM API library that we have just
319 $ cd utility_forces_numer_deriv
325 Try it with one of the example models:
327 $ printf "ex_model_Ar_P_LJ" | ./utility_forces_numer_deriv
329 Next, we can try it with a model installed from https://openkim.org:
331 $ kim-api-collections-management install system --sudo EDIP_JustoBazantKaxiras_1998_Si__MO_958932894036_002
332 $ printf "EDIP_JustoBazantKaxiras_1998_Si__MO_958932894036_002" | ./utility_forces_numer_deriv
334 Congratulations, you have now successfully installed the KIM API. If you would
335 like to learn more about the KIM API, read the documentation in the docs
336 directory (/usr/local/share/doc/kim-api).
338 If you would like to install the latest release of all models from
339 https://openkim.org, you can do:
341 $ kim-api-collections-management install system --sudo OpenKIM
343 D.2 CMAKE BUILD OPTIONS
345 The KIM API defines a number of specific build options which are detailed in
346 this section. But first, some notes about a few important standard CMake
349 D.2.1 COMPILER SELECTION
351 By default CMake will search for appropriate compilers available on your
352 system. Generally, it selects reasonable choices. However, if you wish to
353 force CMake to use specific compilers, you can do so with environment variables
354 set on the command line. For example, suppose you have the latest GNU Compiler
355 Collection (GCC) version X installed with the compilers named 'gcc-X', 'g++-X',
356 and 'gfortran-X', for the C, C++, and Fortran compilers, respectively. Then,
357 to force CMake to use these compilers, replace the command (from above)
359 $ cmake .. -DCMAKE_BUILD_TYPE=Release
363 $ CC=gcc-X CXX=g++-X FC=gfortran-X cmake .. -DCMAKE_BUILD_TYPE=Release
365 D.2.2 CMAKE_BUILD_TYPE
367 CMake defines the option CMAKE_BUILD_TYPE which can be set to "Debug",
368 "Release", "RelWithDebInfo", "MinSizeRel", or it can be empty. (See the CMake
369 documentation for more details.) By default CMAKE_BUILD_TYPE is empty. In
370 short, while developing code or debugging, the value of "Debug" or
371 "RelWithDebInfo" should be used. When building for production runs one of the
372 other values should be used.
374 D.2.3 INSTALLATION PREFIX
376 Here and below, all paths or filepaths must be specified in a format
377 appropriate for the OS (windows or linux). Windows paths are of the form
378 C:\dir1\dir2 (forward slashes may be used instead to avoid escaping issues:
379 C:/dir1/dir2) and linux paths are of the form /dir1/dir2.
381 By default CMake installs the KIM API package under the Global prefix
382 "/usr/local". This is referred to as a "Global" (or system-wide) installation.
383 It is available to all users of the system. (Other "Global" prefix values are
384 "/" and "/usr".) However, such installations require root user permissions (as
385 implied by the use of the "sudo" command above). If you do not have root user
386 permission and/or do not want to install the KIM API to the global location,
387 you can change where CMake installs the KIM API by replacing the command (from
390 $ cmake .. -DCMAKE_BUILD_TYPE=Release
394 $ cmake .. -DCMAKE_INSTALL_PREFIX="/install/prefix/path" -DCMAKE_BUILD_TYPE=Release
396 where "/install/prefix/path" should be replaced with your desired prefix. For
397 example, to install the KIM API in the "local" subdirectory of your home
398 directory, use "${HOME}/local". When installed in such a directory, the user
399 may employ the "kim-api-activate" utility to setup the PATH and bash
400 completions. For example:
402 $ source ${HOME}/local/bin/kim-api-activate
404 D.2.4 KIM API SPECIFIC BUILD OPTIONS
406 The KIM API defines two additional regular build options and additional
409 * KIM_API_LOG_MAXIMUM_LEVEL (="DEBUG" if CMAKE_BUILD_TYPE is "Debug", otherwise
410 ="INFORMATION") This option takes one of the following six values "SILENT",
411 "FATAL", "ERROR", "WARNING", "INFORMATION", "DEBUG". This value controls, at
412 compile-time, which type of log messages can be printed to the "kim.log"
415 * KIM_API_BUILD_EXAMPLES (=ON) When ON CMake will build the example MDs, PMs,
416 SMs and Simulators. NOTE: this option may be removed/changed in future
417 releases when the examples are incorporated into the documentation.
419 Additionally, the KIM API defines the following advanced build options.
421 * KIM_API_PROJECT_NAME (="kim-api") This value controls the naming of many
422 aspects of the package build. Generally this should not be changed. It can
423 be used to build and install, on the same machine, two different copies
424 (typically different versions) of the package.
426 * KIM_API_ENABLE_SANITIZE (=OFF) When ON this enables the AddressSanitizer
427 library for detecting memory corruption bugs.
429 * KIM_API_ENABLE_COVERAGE (=OFF) When ON this enables gcov code coverage.
431 * KIM_API_CONFIGURATION_TIMESTAMP (=<utc-time-of-cmake-configuration>) This is
432 used as part of the <kim-api-uid> universal ID for the kim-api installation.
434 * KIM_API_CMAKE_C_COMPILER (="${CMAKE_C_COMPILER}") This value is recorded and
435 used after installation for compilation of items (MDs, PMs, SMs, etc.) to
436 ensure binary compatibility with the installed KIM API.
438 * KIM_API_CMAKE_CXX_COMPILER (="${CMAKE_CXX_COMPILER}") This value is recorded
439 and used after installation for compilation of items (MDs, PMs, SMs, etc.)
440 to ensure binary compatibility with the installed KIM API.
442 * KIM_API_CMAKE_Fortran_COMPILER (="${CMAKE_Fortran_COMPILER}") This value is
443 recorded and used after installation for compilation of items (MDs, PMs, SMs,
444 etc.) to ensure binary compatibility with the installed KIM API.
446 * KIM_API_USER_CONFIGURATION_FILE (=".${PROJECT_NAME}/config") This value
447 determines the default name of the KIM API user configuration file. If the
448 value corresponds to a relative path (does not start with "/"), then it is
449 interpreted as relative to the user's home directory "${HOME}".
451 * KIM_API_USER_MODEL_DRIVERS_DIR_DEFAULT
452 (="~/.${PROJECT_NAME}/<kim-api-uid>/model-drivers") This value specifies the
453 default colon ':' (semicolon ';' on windows) separated list of the MD
454 directory locations for the user collection.
456 * KIM_API_USER_PORTABLE_MODELS_DIR_DEFAULT
457 (="~/.${PROJECT_NAME}/<kim-api-uid>/portable-drivers") This value specifies
458 the default colon ':' (semicolon ';' on windows) separated list of the PM
459 directory locations for the user collection.
461 * KIM_API_USER_SIMULATOR_MODELS_DIR_DEFAULT
462 (="~/.${PROJECT_NAME}/<kim-api-uid>/simulator-models") This value specifies
463 the default colon ':' (semicolon ';' on windows) separated list of the SM
464 directory locations for the user collection.
466 * KIM_API_SYSTEM_MODEL_DRIVERS_DIR
467 (="${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}/model-drivers") This value
468 specifies a colon ':' (semicolon ';' on windows) separated list of the MD
469 directory locations in the system collection. If the value starts with a
470 colon (semicolon on windows), cmake will update it by prepending the default
473 * KIM_API_SYSTEM_PORTABLE_MODELS_DIR
474 (="${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}/portable-models") This value
475 specifies a colon ':' (semicolon ';' on windows) separated list of the PM
476 directory locations in the system collection. If the value starts with a
477 colon (semicolon on windows), cmake will update it by prepending the default
480 * KIM_API_SYSTEM_SIMULATOR_MODELS_DIR
481 (="${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}/simulator-models") This value
482 specifies a colon ':' (semicolon ';' on windows) separated list of the SM
483 directory locations in the system collection. If the value starts with a
484 colon (semicolon on windows), cmake will update it by prepending the default
487 D.3 Installing multiple versions
489 On linux and macOS systems if you intend to install multiple versions of the
490 KIM API using the same installation prefix
491 ("-DCMAKE_INSTALL_PREFIX=/install/prefix/path" argument to cmake) you must take
492 care that the installations do not overwrite each other. If you intend to
493 install multiple versions using the same prefix you must use the
494 "-DKIM_API_PROJECT_NAME=project-name" argument (See D.2.4 above) to cmake and
495 use a unique value (any string without whitespace or control characters is
496 valid) for each installation.
498 Full support for the "-DKIM_API_PROJECT_NAME" argument, as described here, was
499 first available in v2.0.2. For example, suppose the current version of the KIM
500 API were v3.2.1, and you want to also install KIM API v3.0.0, and v2.1.1.
501 Then, you would configure each version as follows:
505 $ cmake .. [additional args] # use default ("kim-api") for current version.
509 $ cmake .. -DKIM_API_PROJECT_NAME=kim-api3.0 [additional args]
513 $ cmake .. -DKIM_API_PROJECT_NAME=kim-api2.1 [additional args]
515 D.4 Uninstall the KIM API
517 When the KIM API package is installed, CMake creates a file in the build tree
518 named "install_manifest.txt". For the above commands this file would be
519 located at "${HOME}/kim-api-X.Y.Z/build/install_manifest.txt". The manifest
520 file contains the absolute file name of every file installed as part of the KIM
521 API package. The contents of the install_manifest.txt file can be used to
522 remove these files and, thus, uninstall the KIM API package. Thus, the
523 install_manifest.txt file should be saved for later use, if necessary.
525 For example, the following commands could be used to uninstall the KIM API
526 package (assuming the "install_manifest.txt" file is located in your home
530 $ while read line || test -n "${line}"; do sudo rm -f "${line}"; done < install_manifest.txt
532 A more sophisticated set of commands could also remove any empty subdirectories
533 left behind by this process.
535 It may also be desirable to remove the user configuration file and user
536 collection directories.
538 $ rm -rf "${HOME}/.kim-api"
541 -------------------------------------------------------------------------------
543 E. ADDING MDs, PMs, and SMs TO THE COLLECTIONS
546 Here we describe how to add MDs, PMs, and SMs to the system-collection,
547 user-collection, environment-variable-collection, and the CWD-collection.
549 E.1 ADDING MDs, PMs, and SMs TO THE SYSTEM-COLLECTION
551 Once you have the KIM API installed, it is easy to add additional MDs, PMs, and
552 SMs to the system-collection.
556 $ kim-api-collections-management install system --sudo Morse_Shifted_Jelinek_1972_Ar__MO_831902330215_003
557 $ kim-api-collections-management install system --sudo Sim_LAMMPS_ADP_PunDarlingKecskes_2015_CuTa__SM_399364650444_000
559 The kim-api-collections-management utility automatically installs the necessary
560 MD too. You can see the items in the various collections by executing the
563 $ kim-api-collections-management list
565 Now we can test the newly installed PM.
567 $ cd "${WORKSPACE}/utility_forces_numer_deriv/build" # we'll assume this is already built
568 $ printf "Morse_Shifted_Jelinek_1972_Ar__MO_831902330215_003" | ./utility_forces_numer_deriv
570 E.2 ADDING MDs, PMs, and SMs TO THE USER-COLLECTION
572 Adding MDs, PSs, and SMs to the user-collection is similar.
576 $ kim-api-collections-management install user LJ_Shifted_Bernardes_1958HighCutoff_Ar__MO_242741380554_003
577 $ kim-api-collections-management install user Sim_LAMMPS_AGNI_BotuBatraChapman_2017_Al__SM_666183636896_000
578 $ kim-api-collections-management list
579 $ cd "${WORKSPACE}/utility_forces_numer_deriv/build" # we'll assume this is already built
580 $ printf "LJ_Shifted_Bernardes_1958HighCutoff_Ar__MO_242741380554_003" | ./utility_forces_numer_deriv
582 E.3 ADDING MDs, PMs, and SMs TO THE ENVIRONMENT-VARIABLE-COLLECTION
584 Adding MDs, PMs, and SMs to the environment-variable-collection is similar.
588 $ mkdir -p "${WORKSPACE}/my-env-collection/model-drivers"
589 $ export KIM_API_MODEL_DRIVERS_DIR="${WORKSPACE}/my-env-collection/model-drivers"
590 $ mkdir -p "${WORKSPACE}/my-env-collection/portable-models"
591 $ export KIM_API_PORTABLE_MODELS_DIR="${WORKSPACE}/my-env-collection/portable-models"
592 $ mkdir -p "${WORKSPACE}/my-env-collection/simulator-models"
593 $ export KIM_API_SIMULATOR_MODELS_DIR="${WORKSPACE}/my-env-collection/simulator-models"
594 $ kim-api-collections-management install environment Morse_Shifted_GirifalcoWeizer_1959HighCutoff_Cu__MO_151002396060_003
595 $ kim-api-collections-management install environment Sim_LAMMPS_BOP_WardZhouWong_2012_CdZnTe__SM_409035133405_000
596 $ kim-api-collections-management list
597 $ cd "${WORKSPACE}/utility_forces_numer_deriv/build" # we'll assume this is already built
598 $ printf "Morse_Shifted_GirifalcoWeizer_1959HighCutoff_Cu__MO_151002396060_003" | ./utility_forces_numer_deriv
600 E.4 ADDING MDs, PMs, and SMs TO THE CWD-COLLECTION
602 Adding MDs, PMs, and SMs to the CWD-collection is, again, similar.
606 $ kim-api-collections-management install CWD Exp6_KongChakrabarty_1973_ArNe__MO_946046425752_002
607 $ kim-api-collections-management install CWD Sim_LAMMPS_MEAM_EtesamiAsadi_2018_Ni__SM_333792531460_000
608 $ kim-api-collections-management list
609 $ printf "Exp6_KongChakrabarty_1973_ArNe__MO_946046425752_002" | "${WORKSPACE}/utility_forces_numer_deriv/build/utility_forces_numer_deriv" # we'll assume this is already built
611 E.5 Adding MDs, PMs, and SMs from a local source directory
613 The kim-api-collections-management utility allows for the installation of items
614 from a directory on the local file system. This is useful if you are
615 developing an item or do not have network access to openkim.org, but already
616 have the source code downloaded. We'll assume that the item's source code
617 (including the CMakeLists.txt file, parameter files, etc) you want to install
618 are in directory "${WORKSPACE}/item-source". Then you simply provide this
619 directory name instead of the item name.
621 $ kim-api-collections-management install user "${WORKSPACE}/item-source"
623 E.6 Manually adding MDs, PMs, and SMs
625 If necessary a MD, PM, or SM may be manually built and installed. We'll assume
626 the item's source code is in the current directory
630 $ cmake .. -DKIM_API_INSTALL_COLLECTION=SYSTEM
634 The KIM_API_INSTALL_COLLECTION variable can also take values USER and
637 *******************************************************************************
641 Support is always available by posting questions with all relevant information
644 <https://matsci.org/openkim>
646 Members of the OpenKIM development team actively monitor this forum and
647 will do their best to respond to questions in a timely fashion.
649 *******************************************************************************
