Difference between revisions of "Documents"

From salmon
Jump to: navigation, search
 
(40 intermediate revisions by 3 users not shown)
Line 1: Line 1:
 +
== Documents of past events ==
  
== Installation ==
+
=== Manual for SALMON ===
 +
{| class="wikitable"
 +
| Contents || PDF file
 +
|-
 +
| Manual for SALMON-v.1.0.0 (simple version) || [[media:Manual_SALMON-v1_0_0.pdf|Manual_SALMON-v1_0_0.pdf]]
 +
|}
  
=== Prerequisites ===
 
  
In this guide, it is assumed that readers have a basic knowledge on Unix. In the following, most works will be done in the command-line interface of Unix. For the installation of SALMON, following packages are required.
+
=== A tutorial seminar with hands-on session, Nov. 24, 2017 at Univ. of Tsukuba ===
  
* Fortran90/C compiler with MPI support. Our package assumes users have one of the following compilers:
+
{| class="wikitable"
** GCC (Gnu Compiler Collection)
+
| Contents || PDF file
** Intel Fortran/C Compiler
+
|-
** Fujitsu Compiler (at FX100 / K-Computer)
+
| Installation || [[media:Installation_of_SALMON.pdf|Installation_of_SALMON.pdf]]
 
+
|-
* One of the following library packages for linear algebra:
+
| Basic of SALMON || [[media:Basics_of_SALMON.pdf|Basics_of_SALMON.pdf]]
** BLAS/LAPACK
+
|-
** Intel Math Kernel Library (MKL)
+
| Isolated Systems - Overview || [[media:HowtoUseSALMON-1_Overview.pdf|HowtoUseSALMON-1_Overview.pdf]]
** Fujitsu Scientific Subroutine Library 2 (SSL-II)
+
|-
 
+
| Isolated Systems - Exercise ||  [[media:HowToUseSALMON-1_Exercise.pdf|HowToUseSALMON-1_Exercise.pdf]]
* One of the following build tools.
+
|-
** CMake
+
| Periodic Systems - Overview ||  [[media:HowtoUseSALMON-2_Overview.pdf|HowtoUseSALMON-2_Overview.pdf]]
** Gnu Make
+
|-
 
+
| Periodic Systems - Exercise ||  [[media:HowToUseSALMON-2_Exercise.pdf|HowToUseSALMON-2_Exercise.pdf]]
If you use other compilers, you may need to change build scripts (CMake, Makefile).
+
|}
If no numerical library is installed in your computer system, you may need to install BLAS/LAPACK by yourself. 
 
See Installation of BLAS/LAPACK.
 
 
 
 
 
=== Download ===
 
 
 
Newest version of the SALMON can be downloaded from http://salmon-tddft.jp.
 
Extract files from the downloaded file `salmon-xx.xx.xx.tar.gz` in the command-line,
 
 
 
`tar –zxvf ./salmon-xx.xx.xx.tar.gz`
 
 
 
After the extraction, the following directories will be created.
 
 
 
SALMON
 
  |- ARTED      Source codes of ARTED related modules
 
  |- GCEED      Source codes of GCEED related modules
 
  |- src        Source codes of core module
 
  |- main      Source codes of the main routines
 
  |- example   
 
  |- Makefile 
 
 
 
 
 
=== Build ===
 
To compile SALMON codes to create executable binary file, two options are prepared, CMake and Gnu Make. If CMake works in your environment, we recommend to use it. If CMake fails in your environment, consider to use Gnu Make.
 
 
 
==== Build using CMake ====
 
If CMake is installed in your system, you can check the version of the CMake typing in the command-line as
 
 
 
$ cmake --version
 
 
 
To build SALMON, CMake of version 3.0.2 or later is required. If CMake of older version is installed in your system, you need to install the new version by yourself. See [1.4.1 Installation of CMake](#1.4.1 Installation of CMake).
 
 
 
===== Build using CMake specifying archtechture =====
 
 
 
Confirming that CMake of version 3.0.2 or later can be usable in your system, proceed the following steps. We assume that you are in the directory SALMON.
 
* Create a new temporary directory `build` and move to the directory,
 
 
 
$ mkdir build
 
$ cd build
 
 
 
* Execute the python script `configure.py` and then make,
 
 
 
$ python ../configure.py –arch=ARCHTECTURE
 
$ make
 
 
 
Here `ARCHTECTURE` specifies the architecture of the CPU in your computer system such as `intel-avx`. You need to choose `ARCHTECUTRE` from the following options:
 
 
 
 
 
| 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 |
 
| `fujitsu-fx100` | FX100 Su | Fujitsu Compiler | SSL-II |
 
| `fujitsu-k` | Fujitsu FX100 / K-computer | Fujitsu Compiler | SSL-II |
 
 
 
 
 
If the build is successful, you get a file `salmon.cpu` at the directory `./bin`. If you specify many-core archtechtures, `intel-knl` or `intel-knc`, you find a file `salmon.mic` or both files `salmon.cpu` and `salmon.mic`.
 
 
 
#### 1.3.1.2 Build using CMake manually
 
 
 
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"
 
$ make
 
```
 
 
 
A list of the environmental variables is given below:
 
(Table)
 
 
 
### 1.3.2 Build using Gnu Make
 
If CMake build fails in your environment, try Gnu Make for the build process. Gnu Make utilize a file, Makefile, which you can find at the directory `SALMON/Makefile`. First you need to modify Makefile appropriately according to your environment. Edit the Makefile using a text editor. At least you need to change the line that choose the architecture of the system, from line ?? to ??
 
```
 
# This is a makefile for SALMON program.
 
# please select architecture by deleting “#”
 
 
 
#ARCH = gnu
 
ARCH = intel
 
#ARCH = fujitsu
 
#ARCH = intel-knl
 
```
 
Then use make command in the command-line to build the executable file.
 
```
 
$ make
 
```
 
 
 
## 1.4 Tips for installation
 
 
 
### 1.4.1 Installation of CMake
 
Installation of CMake
 
When CMake is not available in your environment or the version of the installed CMake is former than version 3.0.2, you need to install the new version of CMake by yourself. It can be done as follows:
 
 
 
#### 1.4.2 Installation of BLAS/LAPACK
 
 
 
# 2. 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 of *.inp*, to be read through the standard input, `stdin`. It 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 either be written in the input file or prepared as a separate file.
 
 
 
# 2.1 pseudopotentials
 
SALMON utilizes norm-conserving pseudpotentials. You may find pseudopotentials of some elements in [Samples](http://www). SALMON allows to use several formats of pseudpotentials that can be easily obtained from websites listed below.
 
 
 
| pseudopotential | website |
 
|-----------------|---------|
 
| Ab-init FHI http://www.ab-init |
 
 
 
In the input file, you need to write the filename of the pseudopotential. Use exactly the same filename as that downloaded from the website or that in the Samples.
 
 
 
# 2.2 input file
 
Input file should be written using Fortran90 namelist format such as
 
```
 
&system
 
  iperiodic = 0
 
  al = 16d0, 16d0, 16d0
 
  nstate = 5
 
  nelem = 2
 
  natom = 4
 
  file_atom='coo.data'
 
/
 
```
 
where the `system` in `&system` indicates the name of the namelist. In `iperiodic = 0`, `iperiodic` is the variable name and `0` is the value. A group of namelists starts with `&namelist` line and ends with `/` line. Between two lines, descriptions of variables and their values appear. Note that many variables have their default values, so it is not necessary to give values for all variables. The description of the variables may appear at any position if they are between `&namelist` and `/`.
 
Usually several groups of namelists are included in the input file. The order of the groups can be arbitrary.
 
 
 
SALMON describes electron dynamics in systems with both isolated and periodic boundary conditions. The boundary condition is specified by the variable `iperiodic` in `&system`. Calculations are achieved in two steps; first the ground state calculation is carried out and then electron dynamics calculations in real time are achieved. Choice of the calculation mode is specified by the variable `calc_mode` in `&calculation`. For isolated system, the ground state and the electron dynamics calculations should be carried out in two steps. For periodic system, two calculations should be carried out in one step. Therefore, we prepare three options in the `calc_mode`, 'GS', 'RT', and 'GS_RT'.
 
 
 
There are about 20 groups of namelists.
 
 
 
| name of namelist | description |
 
|----------------|-------------|
 
| &units        | specify units of input and output files |
 
| &calculation  | specify the type of calculation, GS (ground state), RT (real-time), and GS-RT (ground state and real time) |
 
| &parallel      | related to parallelization |
 
| &system        | system information |
 
| &pseudo        | specify pseudopotential |
 
| &rgrid        | parameters related to real space grid |
 
| &scf          | parameters related to ground state calculation |
 
| &hartree      | construct Hartree potential |
 
| &group_fundamental |    |
 
| &group_file    |        | |
 
 
 
In [Samples](http://), we prepare six samples that cover typical calculations by SALMON. We prepare explanation for the input files that will help to prepare input files of your own interests.
 
 
 
#3 Run SALMON
 
 
 
#4 Output files
 

Latest revision as of 10:40, 3 July 2018

Documents of past events

Manual for SALMON

Contents PDF file
Manual for SALMON-v.1.0.0 (simple version) Manual_SALMON-v1_0_0.pdf


A tutorial seminar with hands-on session, Nov. 24, 2017 at Univ. of Tsukuba

Contents PDF file
Installation Installation_of_SALMON.pdf
Basic of SALMON Basics_of_SALMON.pdf
Isolated Systems - Overview HowtoUseSALMON-1_Overview.pdf
Isolated Systems - Exercise HowToUseSALMON-1_Exercise.pdf
Periodic Systems - Overview HowtoUseSALMON-2_Overview.pdf
Periodic Systems - Exercise HowToUseSALMON-2_Exercise.pdf