# Install and Run¶

## Prerequisites¶

In this guide, it is assumed that readers have a basic knowledge of Linux and its command line operations. For the installation of SALMON, following packages are required.

• Fortran90/C compiler. SALMON assumes users have one of the following compilers:

• GCC (Gnu Compiler Collection)

• Intel Compiler

• Fujitsu Compiler (at FX100 and A64FX)

• Nvidia HPC SDK Compiler

• One of the following library packages for linear algebra:

• Netlib BLAS/LAPACK/ScaLAPACK

• Intel Math Kernel Library (MKL)

• Fujitsu Scientific Subroutine Library 2 (SSL-II)

• Build tools:

• CMake

If you use other compilers, you may need to change build scripts (CMake). See Additional options in configure.py script. If no numerical library is installed on your computer system, you may need to install BLAS/LAPACK by yourself. See Troubleshooting of the Installation Process.

For the installation of SALMON, we adopt the CMake tools as the first option. If there were any problems to use CMake tools in your environment, you may use the GNU make tools. See Troubleshooting of the Installation Process.

To extract files from the downloaded file SALMON-<VERSION>.tar.gz, type the following command in the command-line:

$tar -zxvf ./SALMON-<VERSION>.tar.gz  After the extraction, the following directories will be created: SALMON |- src Source codes |- example Samples |- cmakefiles CMake related files |- gnumakefiles GNU Makefiles for building  ## Build and Install¶ To compile SALMON to create executable the binary files, we adopt to use CMake tools as the first option. In case you fail to build SALMON using CMake in your environment, we may use Gnu Make. See Build using GNU Makefile. ### Checking CMake availability¶ First, examine whether CMake is usable in your environment or not. Type the following in Linux command-line: $ cmake --version


If CMake is not installed in your system, an error message such as cmake: command not found will appear. If CMake is installed on your system, the version number will be shown. To build SALMON, CMake of version 3.14.0 or later is required. If you confirm that CMake of version 3.14.0 or later is installed in your system, proceed to Build using CMake. However, we realize that old versions of CMake are installed in many systems. If CMake is not installed or CMake of older versions is installed in your system, you need to install the new version by yourself. It is a simple procedure and explained below.

### Installation of CMake (pre-compiled binary of Linux)¶

CMake is a cross-platform build tool. The simplest way to make CMake usable in your environment is to get the binary distribution of CMake from the download page. (The file name of the binary distribution will be cmake-<VERSION>-<PLATFORM>.tar.gz). In standard Linux environment, a file for the platform of Linux x86_64 will be appropriate.

To download the file, proceed as follows: We assume that you are in the directory that you extracted files from the downloaded file of SALMON, and that you will use the version 3.16.8. First get the URL of the download link from your browser, and use wget command in your Linux command-line:

$wget https://cmake.org/files/v3.16/cmake-3.16.8-Linux-x86_64.tar.gz  Next, unpack the archive by: $ tar -zxvf cmake-3.16.8-Linux-x86_64.tar.gz


and you will have the binary make-3.16.8-Linux-x86_64/bin/cmake in your directory.

To make the cmake command usable in your command-line, you need to modify the environment variable $PATH so that the executable of CMake are settled inside the directory specified in your $PATH. If you use the bash shell, you need to modify the file ~/.bashrc that specifies the $PATH variable. It can be done by typing the following command in your login directory: $ export PATH=<SALMON_INSTALLATION_DIRECTORY>/cmake-3.16.8-Linux-x86_64/bin:$PATH  and then reload the configuration by typing: $ source ~/.bashrc


See Installation of CMake describes Other way of the installation.

### Build using CMake¶

Confirming that CMake of version 3.14.0 or later can be usable in your environment, proceed the following steps. We assume that you are in the directory SALMON.

1. Create a new temporary directory build and move to the directory:

$mkdir build$ cd build

2. Execute the python script ''configure.py'' and then make:

$python ../configure.py --arch=ARCHITECTURE --prefix=../$ make
$make install  In executing the python script, you need to specify ARCHITECTURE that indicates the architecture of the CPU in your computer system such as intel-avx. The options of the ARCHITECUTRE are as follows: arch Detail Compiler Numerical Library intel-knl Intel Knights Landing Intel Compiler Intel MKL intel-knc Intel Knights Corner Intel Compiler Intel MKL intel-avx Intel Processer (Ivy-, Sandy-Bridge) Intel Compiler Intel MKL intel-avx2 Intel Processer (Haswell, Broadwell ..) Intel Compiler Intel MKL intel-avx512 Intel Processer (Skylake-SP) Intel Compiler Intel MKL fujitsu-fx100 FX100 Supercomputer Fujitsu Compiler SSL-II fujitsu-a64fx-ea A64FX processor (Fugaku, FX1000, FX700) Fujitsu Compiler SSL-II nvhpc-openmp NVHPC OpenMP (CPU) Nvidia HPC Compiler Nvidia HPC SDK nvhpc-openacc NVHPC OpenACC (GPU) Nvidia HPC Compiler Nvidia HPC SDK nvhpc-openacc-cuda NVHPC OpenACC+CUDA (GPU) Nvidia HPC Compiler Nvidia HPC SDK If the build is successful, you will get a file salmon at the top-level build directory. ## Files necessary to run SALMON¶ To run SALMON, at least two kinds of files are required for any calculations. One is an input file with the filename extension *.inp that should be read from the standard input stdin. This file should be prepared in the Fortran90 namelist format. Pseudopotential files of relevant elements are also required. Depending on your purpose, some other files may also be necessary. For example, coordinates of atomic positions of the target material may be either written in the input file or prepared as a separate file. ### Pseudopotentials¶ SALMON utilizes norm-conserving (NC) pseudpotentials. Filenames of pseudopotentials should be written in the input file. You may find pseudopotentials of some elements in the samples prepared in Exercises. In SALMON, several formats of pseudopotentials may be usable (listed below). For example, pseudopotentials with an extension .fhi can be obtained from the ABINIT website (this is a part of previous atomic data files for the ABINIT code). Pseudopotential extension Website Fritz-Haber-Institute (FHI) pseudopotentials .fhi Pseudopotentials for the OpenMX code .vps https://t-ozaki.issp.u-tokyo.ac.jp/vps_pao2019/ Format 8 for ABINIT norm-conserving pseudopotentials .psp8 Unified-pseudopotential-format (NC type only in SALMON) .upf ### input file¶ Input files are composed of several blocks of namelists: &namelist1 variable1 = int_value variable2 = 'char_value' / &namelist2 variable1 = real8_value variable2 = int_value1, int_value2, int_value3 /  A block of namelists starts with &namelist line and ends with / line. The blocks may appear in any order. Between two lines of &namelist and /, descriptions of variables and their values appear. Note that many variables have their default values so that it is not necessary to give values for all variables. Descriptions of the variables may appear at any position if they are between &namelist and /. SALMON describes electron dynamics in systems with both isolated and periodic boundary conditions. The boundary condition is specified by the variable iperiodic in the namelist &system. Calculations are usually achieved in two steps; first, the ground state calculation is carried out and then electron dynamics calculations in real time is carried out. A choice of the calculation mode or theory in the calculation is specified by the variable theory in the namelist &calculation. In the typical way, the ground state calculation based on DFT is first carried out specifying theory = 'dft'. Then the real-time electron dynamics calculation based on TDDFT is carried out specifying theory = 'tddft_pulse'. In Exercises, we prepare six exercises that cover typical calculations feasible by SALMON. We prepare explanations of the input files of the exercises that will help to prepare input files of your own interests. There are more than 20 groups of namelists. A complete list of namelist variables is given in the file SALMON/manual/input_variables.md. Namelist variables that are used in our exercises are explained at Inputs. ## Run SALMON¶ Before running SALMON, the following preparations are required as described above: The executable file of salmon should be built from the source file of SALMON. An input file inputfile.inp and pseudopotential files should also be prepared. The execution of the calculation can be done as follows: In single process environment, type the following command: $ salmon < inputfile.inp > fileout.out


In multiprocess environment in which the command to execute parallel calculations using MPI is mpiexec, type the following command:

export PATH=INSTALLATION_DIRECTORY/bin:$PATH  and reload the configuration: source ~/.bashrc  ## Appendix¶ ### Additional options in configure.py script¶ #### Manual specifications of compiler and environment variables¶ In executing configure.py, you may manually specify compiler and environment variables instead of specifying the architecture, for example: $ python ../configure.py FC=mpiifort CC=mpiicc FFLAGS="-xAVX" CFLAGS="-restrict -xAVX"


The list of options of configure.py can be found by:



#### Build by user-specified compiler¶

If you want that specify the compiler, set the FC and CC flags in executing the python script:

$python ../configure.py FC=gfortran CC=gcc  When --arch option is not used, MPI parallelization is disabled as default. ### Compilation for GPU acceleration¶ GPU acceleration (OpenACC or OpenACC+CUDA) for the basic part (such as DFT & TDDFT for spin-unpolarized systems) is available. Specify --arch=nvhpc-openacc (OpenACC) or --arch=nvhpc-openacc-cuda (OpenACC+CUDA) option when executing configure.py. This option is currently under development and tested only for NVIDIA HPC SDK compiler ver 21.2 and 21.5 with NVIDIA Tesla V100 and A100 GPUs. ### Build using GNU Makefile¶ If CMake build fails in your environment, we recommend you to try to use Gnu Make for the build process. First, enter the directory gnumakefiles: $ cd SALMON/gnumakefiles


In the directory, Makefile files are prepared for several architectures:

• gnu-mpi

• intel-mpi

• gnu-without-mpi

• intel-without-mpi

Makefile files with *-without-mpi indicate that they are for single processor environment. Choose Makefile appropriate for your environment, and execute the make command:

\$ make -f Makefile.PLATFORM


If the make proceeds successful, a binary file is created in the directory SALMON/bin/.