diff --git a/container/openeuler.wannier90.arm.cpu.config.def b/container/openeuler.wannier90.arm.cpu.config.def new file mode 100644 index 0000000000000000000000000000000000000000..4764063ba81caedef2d818d07f01e2c502e0accb --- /dev/null +++ b/container/openeuler.wannier90.arm.cpu.config.def @@ -0,0 +1,35 @@ +BootStrap: docker +From: openeuler/openeuler + +%environment + source /etc/profile || true + cd /hpcrunner + source env.sh + +%post + # Install the necessary development environment + yum install -y environment-modules git dmidecode pciutils wget vim + # Install base gcc + yum install -y gcc gcc-c++ gcc-gfortran glibc-devel make libgfortran unzip cmake python lapack lapack-devel + # install network package + yum install -y tcsh tcl lsof tk bc + source /etc/profile || true + git config --global http.sslVerify false + git clone https://gitee.com/openeuler/hpcrunner + cd hpcrunner + source ./init.sh + # add your personal files here + export LD_LIBRARY_PATH=/usr/local/lib64:$LD_LIBRARY_PATH + sed -i '6c tar -xvf ${JARVIS_DOWNLOAD}/v3.10.1.tar.gz' package/lapack/3.10.1/install.sh + # Switch config + ./jarvis -use templates/wannier90/3.1.0/data.wannier90.arm.cpu.kgcc.config + # download dependency + ./jarvis -d + # install dependency + ./jarvis -dp + # build hpc + ./jarvis -b + # run hpc + ./jarvis -r + # clean tmp directory + rm -rf downloads tmp diff --git a/container/openeuler.wannier90.x86.cpu.config.def b/container/openeuler.wannier90.x86.cpu.config.def new file mode 100644 index 0000000000000000000000000000000000000000..0110ab10a8c07a9a3cd45782398b066a34f4aaa1 --- /dev/null +++ b/container/openeuler.wannier90.x86.cpu.config.def @@ -0,0 +1,36 @@ +BootStrap: docker +From: openeuler/openeuler + +%environment + source /etc/profile || true + cd /hpcrunner + source env.sh + +%post + # Install the necessary development environment + yum install -y environment-modules git dmidecode pciutils wget vim + # Install base gcc + yum install -y gcc gcc-c++ gcc-gfortran glibc-devel make libgfortran python lapack lapack-devel + # install network package + yum install -y tcsh tcl lsof tk bc + source /etc/profile || true + git config --global http.sslVerify false + git clone https://gitee.com/openeuler/hpcrunner + cd hpcrunner + source ./init.sh + # add your personal files here + sed -i '12c make -j2 && make install' package/gcc/10.3.0/install.sh + sed -i '$c make -j2 install' package/openmpi/4.1.2/install.sh + sed -i '6c tar -xvf ${JARVIS_DOWNLOAD}/v3.10.1.tar.gz' package/lapack/3.10.1/install.sh + # Switch config + ./jarvis -use templates/wannier90/3.1.0/data.wannier90.amd.cpu.config + # download dependency + ./jarvis -d + # install dependency + ./jarvis -dp + # build hpc + ./jarvis -b + # run hpc + ./jarvis -r + # clean tmp directory + rm -rf downloads tmp diff --git "a/doc/wannier90/\343\200\212\345\237\272\344\272\216openEuler\347\232\204wannier90\350\275\257\344\273\266\346\265\213\350\257\225\346\212\245\345\221\212\343\200\213.md" "b/doc/wannier90/\343\200\212\345\237\272\344\272\216openEuler\347\232\204wannier90\350\275\257\344\273\266\346\265\213\350\257\225\346\212\245\345\221\212\343\200\213.md" new file mode 100644 index 0000000000000000000000000000000000000000..4ea6e7bda93fd9e6825b3d3398e29f92e5f0a7fa --- /dev/null +++ "b/doc/wannier90/\343\200\212\345\237\272\344\272\216openEuler\347\232\204wannier90\350\275\257\344\273\266\346\265\213\350\257\225\346\212\245\345\221\212\343\200\213.md" @@ -0,0 +1,1119 @@ +# 《基于openEuler的QMCPACK软件测试报告》 + +## 1.规范性自检 + +项目使用了fprettify对文件进行格式化 + +fprettify 是现代化的 Fortran 代码的自动格式化程序，它采用 Python 编写，对Fortran代码进行严格的空格格式化 + +格式化范例如下，设置中限制了一行最大字符数，所以并非所有行进行了代码添加。 + +``` +program demo +integer :: endif,if,elseif +integer,DIMENSION(2) :: function +endif=3;if=2 +if(endif==2)then +endif=5 +elseif=if+4*(endif+& +2**10) +elseif(endif==3)then +function(if)=endif/elseif +print*,endif +endif +end program +------------------fprettify---------------------------- +program demo + integer :: endif, if, elseif + integer, DIMENSION(2) :: function + endif = 3; if = 2 + if (endif == 2) then + endif = 5 + elseif = if + 4*(endif + & + 2**10) + elseif (endif == 3) then + function(if) = endif/elseif + print *, endif + endif +end program +``` + +对于当前项目，检查代码规范性，可以通过使用fprettify对所有源码进行重新格式化，然后使用git查看文件修改。 + +统计代码不规范内容。 + +### 1.1.选择统计文件类型 + +统计项目文件类型及其文件数量 + +使用python编写脚本文件 + +```python +import os + +print(os.getcwd()) + +def getAllFiles(targetDir): + files = [] + listFiles = os.listdir(targetDir) + for i in range(0, len(listFiles)): + path = os.path.join(targetDir, listFiles[i]) + if os.path.isdir(path): + files.extend(getAllFiles(path)) + elif os.path.isfile(path): + files.append(path) + return files + +all_files = getAllFiles(os.curdir) +type_dict = dict() + +for each_file in all_files: + if os.path.isdir(each_file): + type_dict.setdefault("directory", 0) + type_dict["directory"] += 1 + else: + ext = os.path.splitext(each_file)[1] + type_dict.setdefault(ext, 0) + type_dict[ext] += 1 + +for each_type in dict(sorted(type_dict.items(), reverse=True, key=lambda item: item[1])).keys(): + print("当前文件夹下共有[%s]的文件%d个" % (each_type, type_dict[each_type])) +``` + +在qmcpack项目根目录下运行,运行结果如下 + +```bash +python run.py +/root/hpcrunner/downloads/wannier90-3.1.0 +当前文件夹下共有[]的文件74个 +当前文件夹下共有[.sh]的文件8个 +当前文件夹下共有[.f90]的文件19个 +当前文件夹下共有[.in]的文件2个 +当前文件夹下共有[.pl]的文件1个 +当前文件夹下共有[.travisci]的文件1个 +当前文件夹下共有[.kpt]的文件9个 +当前文件夹下共有[.gnu]的文件6个 +当前文件夹下共有[.g95]的文件1个 +当前文件夹下共有[.wpout-NOA]的文件2个 +当前文件夹下共有[.gfort]的文件2个 +当前文件夹下共有[.md]的文件6个 +当前文件夹下共有[.inc_more]的文件1个 +当前文件夹下共有[.py]的文件57个 +当前文件夹下共有[.mod]的文件33个 +当前文件夹下共有[.chk]的文件58个 +当前文件夹下共有[.wpout]的文件29个 +当前文件夹下共有[.macports]的文件1个 +当前文件夹下共有[.proj]的文件1个 +当前文件夹下共有[.sym]的文件2个 +当前文件夹下共有[.win]的文件1108个 +当前文件夹下共有[.mmn]的文件64个 +当前文件夹下共有[.fig]的文件1个 +当前文件夹下共有[.UPF]的文件27个 +当前文件夹下共有[.yaml]的文件1个 +当前文件夹下共有[.yml]的文件2个 +当前文件夹下共有[.ifort_tcm]的文件1个 +当前文件夹下共有[.gfort+openmpi]的文件1个 +当前文件夹下共有[.amn]的文件69个 +当前文件夹下共有[.rst]的文件2个 +当前文件夹下共有[.dat]的文件87个 +当前文件夹下共有[.inc]的文件24个 +当前文件夹下共有[.x]的文件3个 +当前文件夹下共有[.log]的文件31个 +当前文件夹下共有[.pathscale]的文件1个 +当前文件夹下共有[.pw2wan]的文件43个 +当前文件夹下共有[.1]的文件24个 +当前文件夹下共有[.scf]的文件39个 +当前文件夹下共有[.spn]的文件6个 +当前文件夹下共有[.out]的文件4个 +当前文件夹下共有[.ifort]的文件1个 +当前文件夹下共有[.eps]的文件16个 +当前文件夹下共有[.vdw]的文件4个 +当前文件夹下共有[.nag]的文件1个 +当前文件夹下共有[.upf]的文件1个 +当前文件夹下共有[.wout]的文件12个 +当前文件夹下共有[.inp]的文件5个 +当前文件夹下共有[.xlf]的文件1个 +当前文件夹下共有[.eig]的文件67个 +当前文件夹下共有[.wpout-gyrotropic]的文件2个 +当前文件夹下共有[.F90]的文件31个 +当前文件夹下共有[.bib]的文件2个 +当前文件夹下共有[.qe]的文件1个 +当前文件夹下共有[.nscf]的文件41个 +当前文件夹下共有[.pgf90]的文件1个 +当前文件夹下共有[.2]的文件1个 +当前文件夹下共有[.homebrew]的文件1个 +当前文件夹下共有[.dmn]的文件2个 +当前文件夹下共有[.tex]的文件54个 +当前文件夹下共有[.pyc]的文件33个 +当前文件夹下共有[.png]的文件129个 +当前文件夹下共有[.m]的文件1个 +当前文件夹下共有[.header]的文件1个 +当前文件夹下共有[.o]的文件32个 +当前文件夹下共有[.sun]的文件1个 +当前文件夹下共有[.c]的文件1个 +当前文件夹下共有[.alpha]的文件1个 +当前文件夹下共有[.xyz]的文件2个 +当前文件夹下共有[.uHu]的文件16个 +当前文件夹下共有[.bz2]的文件98个 +当前文件夹下共有[.dynlib]的文件1个 +当前文件夹下共有[.gz]的文件2个 +当前文件夹下共有[.txt]的文件10个 +当前文件夹下共有[.pov]的文件1个 +当前文件夹下共有[.install]的文件1个 +当前文件夹下共有[.pdf]的文件83个 +当前文件夹下共有[.args=-pp]的文件68个 + +``` + +查看上述结果可知主要源码文件后缀名为 `F90`,`f90`,`py`,`sh`,`gfort`。 + +### 1.2.统计源码总行数 + +统计所有源码文件的代码行数 + +```bash + find ./ -regex ".*\.F90\|.*\.f90\|.*\.py"\|.*\.sh"\|.*\.gfort"\ + | xargs wc -l +``` + +统计结果 + +```bash + 82082 total +``` + +### 1.3.统计不符合要求的总行数 + +对文件后缀名为 `f90`,`hpp`,`h`,`py`,`sh`,`c`,`csh`,`cc`,`pl`, 的所有文件进行格式 +通过git与clang-format结合的方式进行统计 + +```bash +[root@ecs-4200 wannier90]#fprettify -r ./ +57 files changed, 96082 insertions(+), 96213 deletions(-) + rewrite pwscf/v3.2.3/pw2wannier90.f90 (78%) + rewrite pwscf/v4.0/pw2wannier90.f90 (73%) + rewrite pwscf/v4.1/pw2wannier90.f90 (73%) + rewrite pwscf/v5.0/pw2wannier90.f90 (79%) + rewrite pwscf/v6.0/pw2wannier90.f90 (77%) + rewrite pwscf/v6.2.1/pw2wannier90.f90 (77%) + rewrite pwscf/v6.3/pw2wannier90.f90 (76%) + rewrite pwscf/v6.3/pw2wannier90_legacy.f90 (77%) + rewrite pwscf/v6.4/pw2wannier90.f90 (76%) + rewrite pwscf/v6.5/pw2wannier90.f90 (76%) + rewrite src/comms.F90 (85%) + rewrite src/constants.F90 (60%) + rewrite src/disentangle.F90 (88%) + rewrite src/error.F90 (77%) + rewrite src/hamiltonian.F90 (88%) + rewrite src/io.F90 (80%) + rewrite src/kmesh.F90 (90%) + rewrite src/overlap.F90 (75%) + rewrite src/plot.F90 (91%) + rewrite src/postw90/berry.F90 (92%) + rewrite src/postw90/boltzwann.F90 (87%) + rewrite src/postw90/dos.F90 (65%) + rewrite src/postw90/geninterp.F90 (86%) + rewrite src/postw90/get_oper.F90 (92%) + rewrite src/postw90/gyrotropic.F90 (94%) + rewrite src/postw90/kpath.F90 (93%) + rewrite src/postw90/kslice.F90 (89%) + rewrite src/postw90/postw90.F90 (89%) + rewrite src/postw90/postw90_common.F90 (85%) + rewrite src/postw90/postw90_readwrite.F90 (93%) + rewrite src/postw90/postw90_types.F90 (61%) + rewrite src/postw90/spin.F90 (88%) + rewrite src/postw90/wan_ham.F90 (91%) + rewrite src/readwrite.F90 (88%) + rewrite src/sitesym.F90 (92%) + rewrite src/transport.F90 (90%) + rewrite src/utility.F90 (84%) + rewrite src/w90chk2chk.F90 (91%) + rewrite src/w90spn2spn.F90 (85%) + rewrite src/wannier90_readwrite.F90 (93%) + rewrite src/wannier90_types.F90 (61%) + rewrite src/wannier_lib.F90 (82%) + rewrite src/wannier_prog.F90 (83%) + rewrite src/wannierise.F90 (86%) + rewrite src/ws_distance.F90 (81%) + rewrite test-suite/library-mode-test/test_library.F90 (88%) + rewrite utility/PL_assessment/PL_assess.f90 (81%) + rewrite utility/w90pov/src/driver.f90 (95%) + rewrite utility/w90pov/src/io.f90 (85%) + rewrite utility/w90vdw/w90vdw.f90 (86%) +``` + +### 1.4.统计结果 + +综上信息，项目中代码规范性自检检查结果为 + +通过率 : 0.2% 1-96213/96400*100% + +不通过率 : 99.8% 96213/96400*100% + +## 2.功能性测试 + +### 2.1.所选测试案例 + +qmcpack内置了大量的单元测试，可以使用其进行单元测试文件内容。 + +单元测试文件列表（部分）如下 + +```bash +[root@host- build]# tree tests +test-suite/ +├── checkpoints +│ ├── cu_postw90 +│ │ └── copper.chk.fmt.bz2 +│ ├── example02 +│ │ ├── lead.amn +│ │ ├── lead.chk.fmt.bz2 +│ │ ├── lead.eig +│ │ ├── lead.mmn +│ │ ├── lead.win +│ │ └── Makefile +│ ├── fe_postw90 +│ │ ├── Fe.amn +│ │ ├── Fe.chk.fmt.bz2 +│ │ ├── Fe.eig +│ │ ├── Fe.mmn.bz2 +│ │ ├── Fe.uHu.bz2 +│ │ ├── Fe.win +│ │ └── Makefile +│ ├── gaas_postw90 +│ │ ├── gaas.amn +│ │ ├── gaas.chk.fmt.bz2 +│ │ ├── gaas.eig +│ │ ├── gaas.mmn +│ │ ├── gaas.mmn.bz2 +│ │ ├── gaas.win +│ │ └── Makefile +│ ├── gaas_shc_postw90 +│ │ ├── GaAs.amn.bz2 +│ │ ├── GaAs.chk.fmt.bz2 +│ │ ├── GaAs.eig +│ │ ├── GaAs.mmn.bz2 +│ │ ├── GaAs.win +│ │ └── Makefile +│ ├── pt_shc_postw90 +│ │ ├── Makefile +│ │ ├── Pt.amn.bz2 +│ │ ├── Pt.chk.fmt.bz2 +│ │ ├── Pt.eig +│ │ ├── Pt.mmn.bz2 +│ │ ├── Pt.spn.bz2 +│ │ └── Pt.win +│ ├── README.txt +│ ├── si_geninterp +│ │ ├── Makefile +│ │ ├── silicon.amn +│ │ ├── silicon.chk.fmt.bz2 +│ │ ├── silicon.eig +│ │ ├── silicon.mmn.bz2 +│ │ └── silicon.win +│ ├── si_geninterp_wsdistance +│ │ ├── Makefile +│ │ ├── silicon.amn +│ │ ├── silicon.chk.fmt.bz2 +│ │ ├── silicon.eig +│ │ └── silicon.win +│ └── te_postw90 +│ ├── Te.chk.fmt.bz2 +│ └── Te.uHu.bz2 +├── clean_tests +├── config +│ ├── README.md +│ └── TestFarm +│ ├── farm2_gcc520.inc +│ ├── farm2_intel13.inc +│ ├── farm2_intel15.inc +│ ├── farm2_nag6.inc +│ ├── farm2_pgi15.inc +│ ├── farmer3_gcc493.inc +│ ├── farmer3_intel15.inc +│ ├── farmer4_gcc485_openblas.inc +│ ├── farmer_gcc485.inc +│ ├── farmer_gcc485_serial.inc +│ ├── farmer_gcc640_serial.inc +│ ├── farmer_gcc730_openmpi1107.inc +│ ├── farmer_intel12.inc +│ ├── farmer_intel13.inc +│ ├── farmer_intel15.inc +│ ├── farmer_intel17_impi.inc +│ ├── farmer_intel17_openmpi313.inc +│ ├── farmer_intel18_openmpi313.inc +│ └── farmer_pgi18_mvapich23b.inc +├── library-mode-test +│ ├── CELL +│ ├── compare_results.py +│ ├── EIG +│ ├── gaas.amn +│ ├── gaas.eig +│ ├── gaas.mmn +│ ├── gaas.win +│ ├── KPOINTS +│ ├── Makefile +│ ├── PARAMS +│ ├── POSITIONS +│ ├── README +│ ├── ref +│ │ ├── gaas.amn -> ../gaas.amn +│ │ ├── gaas.eig -> ../gaas.eig +│ │ ├── gaas.mmn -> ../gaas.mmn +│ │ ├── gaas_ref.wout +│ │ ├── gaas.win -> ../gaas.win +│ │ ├── README.txt +│ │ └── results_ref.dat +│ ├── run.sh +│ └── test_library.F90 +├── README.md +├── run_tests +├── testcode +│ ├── bin +│ │ └── testcode.py +│ ├── lib +│ │ └── testcode2 +│ │ ├── ansi.py +│ │ ├── compatibility.py +│ │ ├── config.py +│ │ ├── dir_lock.py +│ │ ├── exceptions.py +│ │ ├── _functools_dummy.py +│ │ ├── __init__.py +│ │ ├── queues.py +│ │ ├── util.py +│ │ ├── validation.py +│ │ └── vcs.py +│ ├── LICENSE +│ └── README.rst +├── testcode-README.txt +├── tests +│ ├── jobconfig +│ ├── partestw90_mpierr +│ │ ├── benchmark.out.default.inp=wannier.win +│ │ ├── wannier.amn +│ │ ├── wannier.mmn +│ │ └── wannier.win +│ ├── testpostw90_boltzwann +│ │ ├── benchmark.out.default.inp=silicon.win +│ │ ├── Makefile +│ │ ├── silicon.amn +│ │ ├── silicon.chk.fmt.bz2 -> ../../checkpoints/si_geninterp_wsdistance/silicon.chk.fmt.bz2 +│ │ ├── silicon.eig +│ │ ├── silicon.mmn.bz2 -> ../../checkpoints/si_geninterp/silicon.mmn.bz2 +│ │ └── silicon.win +│ ├── testpostw90_example04_dos +│ │ ├── benchmark.out.default.inp=copper.win +│ │ ├── copper.chk.fmt.bz2 -> ../../checkpoints/cu_postw90/copper.chk.fmt.bz2 +│ │ ├── copper.eig +│ │ ├── copper.win +│ │ └── Makefile +│ ├── testpostw90_example04_pdos +│ │ ├── benchmark.out.default.inp=copper.win +│ │ ├── copper.chk.fmt.bz2 -> ../../checkpoints/cu_postw90/copper.chk.fmt.bz2 +│ │ ├── copper.eig +│ │ ├── copper.win +│ │ └── Makefile +│ ├── testpostw90_fe_ahc +│ │ ├── benchmark.out.default.inp=Fe.win +│ │ ├── Fe.amn +│ │ ├── Fe.chk.fmt.bz2 -> ../../checkpoints/fe_postw90/Fe.chk.fmt.bz2 +│ │ ├── Fe.eig +│ │ ├── Fe.mmn.bz2 -> ../../checkpoints/fe_postw90/Fe.mmn.bz2 +│ │ ├── Fe.win +│ │ └── Makefile +│ ├── testpostw90_fe_ahc_adaptandfermi +│ │ ├── benchmark.out.default.inp=Fe.win +│ │ ├── Fe.amn -> ../testpostw90_fe_ahc/Fe.amn +│ │ ├── Fe.chk.fmt.bz2 -> ../testpostw90_fe_ahc/Fe.chk.fmt.bz2 +│ │ ├── Fe.eig -> ../testpostw90_fe_ahc/Fe.eig +│ │ ├── Fe.mmn.bz2 -> ../testpostw90_fe_ahc/Fe.mmn.bz2 +│ │ ├── Fe.win +│ │ └── Makefile +│ ├── testpostw90_fe_dos_spin +│ │ ├── benchmark.out.default.inp=Fe.win +│ │ ├── Fe.amn -> ../../checkpoints/fe_postw90/Fe.amn +│ │ ├── Fe.chk.fmt.bz2 -> ../../checkpoints/fe_postw90/Fe.chk.fmt.bz2 +│ │ ├── Fe.eig -> ../../checkpoints/fe_postw90/Fe.eig +│ │ ├── Fe.mmn.bz2 -> ../../checkpoints/fe_postw90/Fe.mmn.bz2 +│ │ ├── Fe.spn +│ │ ├── Fe.win +│ │ └── Makefile +│ ├── testpostw90_fe_kpathcurv +│ │ ├── benchmark.out.default.inp=Fe.win +│ │ ├── Fe.amn +│ │ ├── Fe.chk.fmt.bz2 -> ../../checkpoints/fe_postw90/Fe.chk.fmt.bz2 +│ │ ├── Fe.eig +│ │ ├── Fe.mmn.bz2 -> ../../checkpoints/fe_postw90/Fe.mmn.bz2 +│ │ ├── Fe.uHu.bz2 -> ../../checkpoints/fe_postw90/Fe.uHu.bz2 +│ │ ├── Fe.win +│ │ └── Makefile +│ ├── testpostw90_fe_kpathmorbcurv +│ │ ├── benchmark.out.default.inp=Fe.win +│ │ ├── Fe.amn +│ │ ├── Fe.chk.fmt.bz2 -> ../../checkpoints/fe_postw90/Fe.chk.fmt.bz2 +│ │ ├── Fe.eig +│ │ ├── Fe.mmn.bz2 -> ../../checkpoints/fe_postw90/Fe.mmn.bz2 +│ │ ├── Fe.uHu.bz2 -> ../../checkpoints/fe_postw90/Fe.uHu.bz2 +│ │ ├── Fe.win +│ │ └── Makefile +│ ├── testpostw90_fe_kpathmorbcurv_ws +│ │ ├── benchmark.out.default.inp=Fe.win +│ │ ├── Fe.amn -> ../../checkpoints/fe_postw90/Fe.amn +│ │ ├── Fe.chk.fmt.bz2 -> ../../checkpoints/fe_postw90/Fe.chk.fmt.bz2 +│ │ ├── Fe.eig -> ../../checkpoints/fe_postw90/Fe.eig +│ │ ├── Fe.mmn.bz2 -> ../../checkpoints/fe_postw90/Fe.mmn.bz2 +│ │ ├── Fe.uHu.bz2 -> ../../checkpoints/fe_postw90/Fe.uHu.bz2 +│ │ ├── Fe.win +│ │ └── Makefile +│ ├── testpostw90_fe_kslicecurv +│ │ ├── benchmark.out.default.inp=Fe.win +│ │ ├── Fe.amn +│ │ ├── Fe.chk.fmt.bz2 -> ../../checkpoints/fe_postw90/Fe.chk.fmt.bz2 +│ │ ├── Fe.eig +│ │ ├── Fe.mmn.bz2 -> ../../checkpoints/fe_postw90/Fe.mmn.bz2 +│ │ ├── Fe.uHu.bz2 -> ../../checkpoints/fe_postw90/Fe.uHu.bz2 +│ │ ├── Fe.win +│ │ └── Makefile +... +``` + +在项目根目录下执行命令来运行单元测试和确定性测试 + +```bash +export OMPI_ALLOW_RUN_AS_ROOT=1 +export OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1 +make tests +``` + +### 2.2.运行结果 + +```bash +(cd ./src/obj && make -f ../Makefile.2 w90chk2chk) +make[1]: Entering directory '/root/hpcrunner/software/libs/wannier90/src/obj' +make[1]: Nothing to be done for 'w90chk2chk'. +make[1]: Leaving directory '/root/hpcrunner/software/libs/wannier90/src/obj' +(cd ./src/obj && make -f ../Makefile.2 wannier) +make[1]: Entering directory '/root/hpcrunner/software/libs/wannier90/src/obj' +make[1]: Nothing to be done for 'wannier'. +make[1]: Leaving directory '/root/hpcrunner/software/libs/wannier90/src/obj' +(cd ./src/obj && make -f ../Makefile.2 post) +make[1]: Entering directory '/root/hpcrunner/software/libs/wannier90/src/obj' +make[1]: Nothing to be done for 'post'. +make[1]: Leaving directory '/root/hpcrunner/software/libs/wannier90/src/obj' +(cd ./test-suite && ./run_tests --category=default ) +Using executable: /root/hpcrunner/software/libs/wannier90/test-suite/tests/../../wannier90.x. +Using executable: /root/hpcrunner/software/libs/wannier90/test-suite/tests/../../postw90.x. +Test id: 25092022-2. +Benchmark: default. + +tests/testpostw90_boltzwann - silicon.win: Passed. + +tests/testpostw90_example04_dos - copper.win: Passed. + +tests/testpostw90_example04_pdos - copper.win: Passed. + +tests/testpostw90_fe_ahc - Fe.win: Passed. + +tests/testpostw90_fe_ahc_adaptandfermi - Fe.win: Passed. + +tests/testpostw90_fe_dos_spin - Fe.win: Passed. + +tests/testpostw90_fe_kpathcurv - Fe.win: Passed. + +tests/testpostw90_fe_kpathmorbcurv - Fe.win: Passed. + +tests/testpostw90_fe_kpathmorbcurv_ws - Fe.win: Passed. + +tests/testpostw90_fe_kslicecurv - Fe.win: Passed. + +tests/testpostw90_fe_kslicemorb - Fe.win: Passed. + +tests/testpostw90_fe_kubo_Axy - Fe.win: Passed. + +tests/testpostw90_fe_kubo_Szz - Fe.win: Passed. + +tests/testpostw90_fe_kubo_jdos - Fe.win: Passed. + +tests/testpostw90_fe_morb - Fe.win: Passed. + +tests/testpostw90_fe_morbandahc - Fe.win: Passed. + +tests/testpostw90_fe_spin - Fe.win: Passed. + +tests/testpostw90_gaas_kdotp - gaas.win: Passed. + +tests/testpostw90_gaas_sc_eta_corr - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz_scphase2 - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz_scphase2_ws - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz_ws - gaas.win: Passed. + +tests/testpostw90_gaas_shc - GaAs.win: Passed. + +tests/testpostw90_pt_kpathbandsshc - Pt.win: Passed. + +tests/testpostw90_pt_kpathshc - Pt.win: Passed. + +tests/testpostw90_pt_ksliceshc - Pt.win: Passed. + +tests/testpostw90_pt_shc - Pt.win: Passed. + +tests/testpostw90_pt_shc_ryoo - Pt.win: Passed. + +tests/testpostw90_si_geninterp - silicon.win: Passed. + +tests/testpostw90_si_geninterp_wsdistance - silicon.win: Passed. + +tests/testpostw90_te_gyrotropic - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_C - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_D0 - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_Dw - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_K - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_NOA - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_dos - Te.win: Passed. + +tests/testw90_basic1 - wannier.win: Passed. + +tests/testw90_basic2 - wannier.win: Passed. + +tests/testw90_benzene_gamma_val - benzene.win: Passed. + +tests/testw90_benzene_gamma_val_hexcell - benzene.win: Passed. + +tests/testw90_benzene_gamma_valcond - benzene.win: Passed. + +tests/testw90_bvec - lead.win: Passed. + +tests/testw90_cube_format - gaas.win: Passed. + +tests/testw90_disentanglement_sawfs - H3S.win: Passed. + +tests/testw90_example01 - gaas.win: Passed. + +tests/testw90_example02 - lead.win: Passed. + +tests/testw90_example02_restart - lead.win: Passed. + +tests/testw90_example03 - silicon.win: Passed. + +tests/testw90_example03_labelinfo - silicon.win: Passed. + +tests/testw90_example03_optmem - silicon.win: Passed. + +tests/testw90_example04 - copper.win: Passed. + +tests/testw90_example05 - diamond.win: Passed. + +tests/testw90_example07 - silane.win: Passed. + +tests/testw90_example11_1 - silicon.win: Passed. + +tests/testw90_example11_2 - silicon.win: Passed. + +tests/testw90_example21_As_sp - GaAs.win: Passed. + +tests/testw90_example26 - gaas.win: Passed. + +tests/testw90_gaas_disentanglement_issue192 - gaas.win: Passed. + +tests/testw90_lavo3_dissphere - LaVO3.win: Passed. + +tests/testw90_na_chain_gamma - Na_chain.win: Passed. + +tests/testw90_nnkpt1 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt2 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt3 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt4 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt5 - wannier.win: Passed. + +tests/testw90_precond_1 - gaas1.win: Passed. + +tests/testw90_precond_2 - gaas2.win: Passed. + +tests/testw90_write_u_matrices - gaas.win: Passed. + +All done. 70 out of 70 tests passed. +(cd ./test-suite && ./run_tests --category=par --numprocs=4 ) +Using executable: /root/hpcrunner/software/libs/wannier90/test-suite/tests/../../wannier90.x. +Using executable: /root/hpcrunner/software/libs/wannier90/test-suite/tests/../../postw90.x. +Test id: 25092022-3. +Benchmark: default. + +tests/partestw90_mpierr - wannier.win: Passed. + +tests/testpostw90_boltzwann - silicon.win: Passed. + +tests/testpostw90_example04_dos - copper.win: Passed. + +tests/testpostw90_example04_pdos - copper.win: Passed. + +tests/testpostw90_fe_ahc - Fe.win: Passed. + +tests/testpostw90_fe_ahc_adaptandfermi - Fe.win: Passed. + +tests/testpostw90_fe_dos_spin - Fe.win: Passed. + +tests/testpostw90_fe_kpathcurv - Fe.win: Passed. + +tests/testpostw90_fe_kpathmorbcurv - Fe.win: Passed. + +tests/testpostw90_fe_kpathmorbcurv_ws - Fe.win: Passed. + +tests/testpostw90_fe_kslicecurv - Fe.win: Passed. + +tests/testpostw90_fe_kslicemorb - Fe.win: Passed. + +tests/testpostw90_fe_kubo_Axy - Fe.win: Passed. + +tests/testpostw90_fe_kubo_Szz - Fe.win: Passed. + +tests/testpostw90_fe_kubo_jdos - Fe.win: Passed. + +tests/testpostw90_fe_morb - Fe.win: Passed. + +tests/testpostw90_fe_morbandahc - Fe.win: Passed. + +tests/testpostw90_fe_spin - Fe.win: Passed. + +tests/testpostw90_gaas_kdotp - gaas.win: Passed. + +tests/testpostw90_gaas_sc_eta_corr - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz_scphase2 - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz_scphase2_ws - gaas.win: Passed. + +tests/testpostw90_gaas_sc_xyz_ws - gaas.win: Passed. + +tests/testpostw90_gaas_shc - GaAs.win: Passed. + +tests/testpostw90_pt_kpathbandsshc - Pt.win: Passed. + +tests/testpostw90_pt_kpathshc - Pt.win: Passed. + +tests/testpostw90_pt_ksliceshc - Pt.win: Passed. + +tests/testpostw90_pt_shc - Pt.win: Passed. + +tests/testpostw90_pt_shc_ryoo - Pt.win: Passed. + +tests/testpostw90_si_geninterp - silicon.win: Passed. + +tests/testpostw90_si_geninterp_wsdistance - silicon.win: Passed. + +tests/testpostw90_te_gyrotropic - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_C - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_D0 - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_Dw - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_K - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_NOA - Te.win: Passed. + +tests/testpostw90_te_gyrotropic_dos - Te.win: Passed. + +tests/testw90_basic1 - wannier.win: Passed. + +tests/testw90_basic2 - wannier.win: Passed. + +tests/testw90_benzene_gamma_val - benzene.win: Passed. + +tests/testw90_benzene_gamma_val_hexcell - benzene.win: Passed. + +tests/testw90_benzene_gamma_valcond - benzene.win: Passed. + +tests/testw90_bvec - lead.win: Passed. + +tests/testw90_cube_format - gaas.win: Passed. + +tests/testw90_disentanglement_sawfs - H3S.win: Passed. + +tests/testw90_example01 - gaas.win: Passed. + +tests/testw90_example02 - lead.win: Passed. + +tests/testw90_example02_restart - lead.win: Passed. + +tests/testw90_example03 - silicon.win: Passed. + +tests/testw90_example03_labelinfo - silicon.win: Passed. + +tests/testw90_example03_optmem - silicon.win: Passed. + +tests/testw90_example04 - copper.win: Passed. + +tests/testw90_example05 - diamond.win: Passed. + +tests/testw90_example07 - silane.win: Passed. + +tests/testw90_example11_1 - silicon.win: Passed. + +tests/testw90_example11_2 - silicon.win: Passed. + +tests/testw90_example21_As_sp - GaAs.win: Passed. + +tests/testw90_example26 - gaas.win: Passed. + +tests/testw90_gaas_disentanglement_issue192 - gaas.win: Passed. + +tests/testw90_lavo3_dissphere - LaVO3.win: Passed. + +tests/testw90_na_chain_gamma - Na_chain.win: Passed. + +tests/testw90_nnkpt1 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt2 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt3 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt4 - wannier.win (arg(s): -pp): Passed. + +tests/testw90_nnkpt5 - wannier.win: Passed. + +tests/testw90_precond_1 - gaas1.win: Passed. + +tests/testw90_precond_2 - gaas2.win: Passed. + +tests/testw90_write_u_matrices - gaas.win: Passed. + +All done. 71 out of 71 tests passed. +``` + +测试结果 + +单元测试运行正常，说明各类型函数和功能都响应正常。测试通过。 + +## 3.性能测试 + +### 3.1.测试平台信息对比 + +todo x86 + +| | arm信息 | x86信息 | +| -------- | --------------------------------- | -------------------------------- | +| 操作系统 | openEuler 20.03 (LTS) | openEuler 20.03 (LTS) | +| 内核版本 | 4.19.90-2003.4.0.0036.oe1.aarch64 | 4.19.90-2112.8.0.0131.oe1.x86_64 | + +### 3.2.测试软件环境信息对比 + +| | arm信息 | x86信息 | +| -------- | ------------- | --------- | +| gcc | kgcc 10.3.1 | gcc 10.3.0 | +| mpi | hmpi1.2.0 | openmpi4.1.2 | +| BLAS | 3.10.0 | 3.10.0 | +| lapack | 3.10.1 | 3.10.1 | + +### 3.3.测试硬件性能信息对比 + +| | arm信息 | x86信息 | +| ------ | ----------- | -------- | +| cpu | Kunpeng 920 | Intel(R) Xeon(R) Gold 6278C CPU @ 2.60GHz | +| 核心数 | 8 | 4 | +| 内存 | 16 GB | 16 GB | +| 磁盘io | 1.3 GB/s | 132.57 MB/s| +| 虚拟化 | KVM | KVM | + +### 3.4.测试选择的案例 + +examples/molecules/H2O 目录下的文件 simple-H2O.xml + +对水分子进行一个简短的扩散蒙特卡罗计算 + +测试文件（部分）如下 + +```xml +! Gallium Arsenide: Tutorial Example 1 + + num_wann = 4 + num_iter = 20 + + +! SYSTEM + +begin unit_cell_cart +bohr +-5.367 0.000 5.367 + 0.000 5.367 5.367 +-5.367 5.367 0.000 +end unit_cell_cart + +begin atoms_frac +Ga 0.00 0.00 0.00 +As 0.25 0.25 0.25 +end atoms_frac + +begin projections +As:sp3 +end projections + +! KPOINTS + +mp_grid : 2 2 2 + +begin kpoints +0.0 0.0 0.0 +0.0 0.0 0.5 +0.0 0.5 0.0 +0.0 0.5 0.5 +0.5 0.0 0.0 +0.5 0.0 0.5 +0.5 0.5 0.0 +0.5 0.5 0.5 +end kpoints + +!We set this flag to read the bloch states from +!a formatted file. This is to ensure the example +!works on all platforms. The default (.false.) state +!should be used on production runs +wvfn_formatted=.true. + +``` + +### 3.6.单线程 + +单线程运行测试时间对比（五次运行取平均值） + +| | arm | x86 | +| ----------- | ---------- | -------- | +| 实际CPU时间 | 4.142s | 2.707s | +| 用户时间 | 4.065s | 2.628s | + +### 3.7.多线程 + +多线程运行测试时间对比（五次运行取平均值） + +| | arm | x86 | +| ----------- | ---------- | --------- | +| 线程数 | 4 | 4 | +| 实际CPU时间 | 0.154s | 0.118s | +| 用户时间 | 0.0289s | 0.202s | + +arm多线程时间耗费数据表： + +| 线程 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | +| :------------ | -------- | ------- | ------- | -------- | ------- | -------- | ------- | ------- | +| 用户时间(s) | 4.142| 2.205 | 1.599 | 1.255 | 1.067 | 0.935 | 0.876 | 0.811 | +| 用户态时间(s) | 4.065 | 4.241 | 4.529 | 4.674 | 4.889 | 5.102 | 5.491 | 5.680 | +| 内核态时间(s) | 0.028 | 0.044 | 0.068 | 0.071 | 0.069 | 0.116 | 0.144 | 0.557 | + +x86多线程时间耗费数据表： + +| 线程 | 1 | 2 | 3 | 4 | +| --------------- | ------ | ------ | ------- | ------- | +| 用户时间 （s） | 2.707 | 1.492 | 1.107 | 0.892 | +| 用户态时间（s） | 2.628 | 2.801 | 3.041 | 3.158 | +| 内核态时间（s） | 0.031 | 0.055 | 0.079 | 0.130 | + +由上表可知，在线程逐渐增加的情况下，所减少的用户时间并非线性关系，线程数增加后，运算用时并未显著下降，且系统调用的时间有较为明显的上升趋势。 + +### 3.8.测试总结 + +arm平台内核态时间，在相同线程数下比x86平台耗费更少。随着线程数的增加，两个平台的对于同一个应用的所耗费的时间差距逐渐减少。 + +且线程增加并不会无限制减少应用的实际耗费时间，在合理的范围内分配线程数才能更好的利用算力资源。 + +## 4.精度测试 + +### 4.1.所选测试案例 + +test-suite/tests/testpostw90_boltzwann 目录下的文件 silicon.win + + +测试文件（部分）如下 + +``` +num_bands = 12 +num_wann = 8 +use_ws_distance = true +search_shells=12 + +boltzwann = true +boltz_calc_also_dos = true +boltz_dos_energy_step = 0.1 +smr_type = gauss +boltz_dos_adpt_smr = false +boltz_dos_smr_fixed_en_width = 0.03 +kmesh = 20 +boltz_mu_min = 5. +boltz_mu_max = 5. +boltz_mu_step = 0.01 +boltz_temp_min = 300. +boltz_temp_max = 300. +boltz_temp_step = 50 +boltz_relax_time = 10. + +dis_win_max = 17.0d0 +dis_froz_max = 6.4d0 +dis_num_iter = 120 +dis_mix_ratio = 1.d0 +dis_conv_tol = 1.0e-13 + +num_iter = 300 +num_print_cycles = 10 + +Begin Atoms_Frac +Si -0.25 0.75 -0.25 +Si 0.00 0.00 0.00 +End Atoms_Frac + +Begin Projections +Si : sp3 +End Projections + +begin kpoint_path +L 0.50000 0.50000 0.5000 G 0.00000 0.00000 0.0000 +G 0.00000 0.00000 0.0000 X 0.50000 0.00000 0.5000 +X 0.50000 -0.50000 0.0000 K 0.37500 -0.37500 0.0000 +K 0.37500 -0.37500 0.0000 G 0.00000 0.00000 0.0000 +end kpoint_path + + +Begin Unit_Cell_Cart +-2.6988 0.0000 2.6988 + 0.0000 2.6988 2.6988 +-2.6988 2.6988 0.0000 +End Unit_Cell_Cart + + +mp_grid = 4 4 4 + + +begin kpoints +0.0000 0.0000 0.0000 +0.0000 0.2500 0.0000 +0.0000 0.5000 0.0000 +0.0000 0.7500 0.0000 +0.2500 0.0000 0.0000 +0.2500 0.2500 0.0000 +0.2500 0.5000 0.0000 +0.2500 0.7500 0.0000 +0.5000 0.0000 0.0000 +0.5000 0.2500 0.0000 +0.5000 0.5000 0.0000 +0.5000 0.7500 0.0000 +0.7500 0.0000 0.0000 +0.7500 0.2500 0.0000 +0.7500 0.5000 0.0000 +0.7500 0.7500 0.0000 +0.0000 0.0000 0.2500 +0.0000 0.2500 0.2500 +0.0000 0.5000 0.2500 +0.0000 0.7500 0.2500 +0.2500 0.0000 0.2500 +0.2500 0.2500 0.2500 +0.2500 0.5000 0.2500 +0.2500 0.7500 0.2500 +0.5000 0.0000 0.2500 +0.5000 0.2500 0.2500 +0.5000 0.5000 0.2500 +0.5000 0.7500 0.2500 +0.7500 0.0000 0.2500 +0.7500 0.2500 0.2500 +0.7500 0.5000 0.2500 +0.7500 0.7500 0.2500 +0.0000 0.0000 0.5000 +0.0000 0.2500 0.5000 +0.0000 0.5000 0.5000 +0.0000 0.7500 0.5000 +0.2500 0.0000 0.5000 +0.2500 0.2500 0.5000 +0.2500 0.5000 0.5000 +0.2500 0.7500 0.5000 +0.5000 0.0000 0.5000 +0.5000 0.2500 0.5000 +0.5000 0.5000 0.5000 +0.5000 0.7500 0.5000 +0.7500 0.0000 0.5000 +0.7500 0.2500 0.5000 +0.7500 0.5000 0.5000 +0.7500 0.7500 0.5000 +0.0000 0.0000 0.7500 +0.0000 0.2500 0.7500 +0.0000 0.5000 0.7500 +0.0000 0.7500 0.7500 +0.2500 0.0000 0.7500 +0.2500 0.2500 0.7500 +0.2500 0.5000 0.7500 +0.2500 0.7500 0.7500 +0.5000 0.0000 0.7500 +0.5000 0.2500 0.7500 +0.5000 0.5000 0.7500 +0.5000 0.7500 0.7500 +0.7500 0.0000 0.7500 +0.7500 0.2500 0.7500 +0.7500 0.5000 0.7500 +0.7500 0.7500 0.7500 +End Kpoints + +``` + +### 4.2.获得对比数据 + +arm 运行结果(部分) + +```bash +# Written by the BoltzWann module of the Wannier90 code. +# [Electrical conductivity in SI units, i.e. in 1/Ohm/m] +# Mu(eV) Temp(K) ElCond_xx ElCond_xy ElCond_yy ElCond_xz ElCond_yz ElCond_zz + 5.000000000 300.0000000 6504318.581 -207173.9444 6669730.424 200281.2121 209188.4582 6478066.903 + +``` + + +x86运行结果 + +```bash +# Written by the BoltzWann module of the Wannier90 code. +# [Electrical conductivity in SI units, i.e. in 1/Ohm/m] +# Mu(eV) Temp(K) ElCond_xx ElCond_xy ElCond_yy ElCond_xz ElCond_yz ElCond_zz + 5.000000000 300.0000000 6504319.606 -207173.9934 6669730.426 200280.1797 209188.5069 6478067.945 +``` + + + +使用以上数据进行误差计算 + +```python + +x86 = [5.000000000,300.0000000 , 6504319.606,-207173.9934 ,6669730.426 ,200280.1797, 209188.5069, 6478067.945 ] +arm = [5.000000000 ,300.0000000 ,6504318.581,-207173.9444,6669730.424 ,200281.2121, 209188.4582, 6478066.903] + +for i in range(len(arm)): + print(abs((x86[i]-arm[i]) / x86[i]) * 100, '%') +``` + +### 4.3.误差运算结果 + +```bash +0.0 % +0.0 % +1.575875820271318e-05 % +2.3651617268612574e-05 % +2.998622433118328e-08 % +0.000515477867826386 % +2.3280437694984702e-05 % +1.608504278145663e-05 % +``` + +### 4.4.测试总结 + +所有运算结果偏差在1%以内，偏差较小。 diff --git "a/doc/wannier90/\343\200\212\345\237\272\344\272\216openEuler\347\232\204wannier90\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" "b/doc/wannier90/\343\200\212\345\237\272\344\272\216openEuler\347\232\204wannier90\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" new file mode 100644 index 0000000000000000000000000000000000000000..a558ad7cb5f97c59c475f7e7e2a55cb73d72af99 --- /dev/null +++ "b/doc/wannier90/\343\200\212\345\237\272\344\272\216openEuler\347\232\204wannier90\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" @@ -0,0 +1,345 @@ +# 《基于openEuler的wannier90软件移植指南》 + +## 1.介绍 + +- wannier90 Wannier90是一个构建局域轨道基组的有力工具，一般用来计算紧束缚模型中的占位能和跳跃积分，再结合杂化泛函或GW方法，插值得到更为准确的能带结构，或者计算极化、输运、拓扑不变量等物理性质 + +- 官网地址： + +- GITHUB托管地址： + +- 特性： + + - Marzari和Vanderbilt的方法(MV) + - 最大局域化瓦尼尔函数计算 + - 使用Souza，Marzari，Vanderbilt的方法(SMV) + - FLAPW的电子结构代码结合使用 + - 还有很多。。。 + +## 2.环境要求 + +- 操作系统：OpenEuler arm/x86 (本文档以 arm 架构为例) + +## 3.配置编译环境 + +配置环境指导，手动进行配置依赖环境。 + +### 3.1.环境总览 + +- 编译器： gcc for openeuler + +- MPI：openmpi + +- 其他类库：`BLAS``Python3`, `lapack` + + 具体版本和下载地址如下 + +| 名称 | 版本 | 软件下载地址 | +| -------- | ------ | ---------------------------------------------------------------------------------------------- | +| hmpi | 1.2.0 | | +| kgcc | 10.3.1 | | +| BLAS | 3.10.1 | | +| Python3 | 3.7.10 | | +| lapack | 3.10.1 | | + +### 3.2.创建文件夹 + +```bash +mkdir -p $HOME/build +mkdir -p $HOME/install +mkdir -p $HOME/tmp +``` + +### 3.3.安装预设 + +设置环境变量，方便修改自定义安装目录 + +- 编译目录为 $HOME/build , 根据实际情况进行修改 +- 软件安装目录为 $HOME/install , 根据实际情况进行修改 +- 下载目录为 $HOME/tmp , 根据实际情况进行修改 + +```bash +#为了方便自定义软件安装目录 +#环境变量DEP_INSTALL_DIR将在后文中作为软件安装目录的根目录 +export DEP_INSTALL_DIR=$HOME/install +#环境变量DEP_BUILD_DIR将在后文中作为编译的根目录 +export DEP_BUILD_DIR=$HOME/build +#环境变量DEP_DOWNLOAD_DIR将在后文中作为下载文件的保存目录 +export DEP_DOWNLOAD_DIR=$HOME/tmp + +#注： 以上变量只在一次会话中有效。如果中途断开ssh会话，则在后续的安装过程中不会生效，需要重新运行 +``` + +### 3.4.安装环境依赖和kgcc编译器 + +```bash +#环境依赖 +yum -y install wget tar libatomic + +#安装kgcc编译器 +wget -P $DEP_DOWNLOAD_DIR https://mirrors.huaweicloud.com/kunpeng/archive/compiler/kunpeng_gcc/gcc-10.3.1-2021.09-aarch64-linux.tar.gz +tar -xf $DEP_DOWNLOAD_DIR/gcc-10.3.1-2021.09-aarch64-linux.tar.gz -C $DEP_INSTALL_DIR + + + +#设置环境变量 +echo "export PATH=$DEP_INSTALL_DIR/gcc-9.3.0/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=`which clang` +export CXX=`which clang++` +``` + +## 3.5.下载并编译hmpi + +```bash +yum -y install libstdc++ libstdc++-devel +yum -y install unzip make autoconf automake git libtool +#下载解压源码文件 +wget https://github.com/kunpengcompute/hucx/archive/refs/tags/v1.2.0-huawei.zip -O $DEP_DOWNLOAD_DIR/hucx-1.2.0-huawei.zip +wget https://github.com/kunpengcompute/xucg/archive/refs/tags/v1.2.0-huawei.zip -O $DEP_DOWNLOAD_DIR/xucg-1.2.0-huawei.zip +wget https://github.com/kunpengcompute/hmpi/archive/refs/tags/v1.2.0-huawei.zip -O $DEP_DOWNLOAD_DIR/hmpi-1.2.0-huawei.zip + +cd $DEP_BUILD_DIR +unzip -q $DEP_DOWNLOAD_DIR/hucx-1.2.0-huawei.zip +unzip -q $DEP_DOWNLOAD_DIR/xucg-1.2.0-huawei.zip +unzip -q $DEP_DOWNLOAD_DIR/hmpi-1.2.0-huawei.zip +cp -rf xucg-1.2.0-huawei/* hucx-1.2.0-huawei/src/ucg/ + +#编译hucx +cd $DEP_BUILD_DIR/hucx-1.2.0-huawei +./autogen.sh +./contrib/configure-opt --prefix=$DEP_INSTALL_DIR/hmpi/hucx CFLAGS="-DHAVE___CLEAR_CACHE=1" --disable-numa --without-java +for file in `find . -name Makefile`;do sed -i "s/-Werror//g" $file;done +for file in `find . -name Makefile`;do sed -i "s/-implicit-function-declaration//g" $file;done +make -j +make install + +yum -y install flex +#编译hmpi +cd $DEP_BUILD_DIR/hmpi-1.2.0-huawei +./autogen.pl +./configure --prefix=$DEP_INSTALL_DIR/hmpi --with-platform=contrib/platform/mellanox/optimized --enable-mpi1-compatibility --with-ucx=$DEP_INSTALL_DIR/hmpi/hucx +make -j +make install + +echo "export PATH=$DEP_INSTALL_DIR/hmpi/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=mpicc CXX=mpicxx FC=mpifort F77=mpifort +``` + +## 3.6.下载并编译`BLAS`, `lapack`, `python3` + +```bash + + +# 下载并编译BLAS +wget -u http://www.netlib.org/blas/blas-3.10.0.tgz $DEP_DOWNLOAD_DIR/blas-3.10.0.tgz +cd $DEP_DOWNLOAD_DIR +tar -xzvf $DEP_DOWNLOAD_DIR/blas-3.10.0.tgz +cd BLAS-3.10.0 +gfortran -c -O3 ./*.f +ar rv libblas.a ./*.o +cp libblas.a /usr/local/lib + +# 下载并编译Python3 +yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make libffi-devel +wget https://repo.huaweicloud.com/python/3.7.10/Python-3.7.10.tgz -O $DEP_DOWNLOAD_DIR/Python-3.7.10.tgz +tar -zxvf $DEP_DOWNLOAD_DIR/Python-3.7.10.tgz -C $DEP_BUILD_DIR +cd $DEP_BUILD_DIR/Python-3.7.10 +./configure --prefix=$DEP_INSTALL_DIR/python3 +make -j +make install +echo "export PATH=$DEP_INSTALL_DIR/python3/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +echo "export LD_LIBRARY_PATH=$DEP_INSTALL_DIR/python3/lib:$LD_LIBRARY_PATH" >> ~/.bashrc && source ~/.bashrc + +# 下载并编译lapack +wget -u https://github.com/Reference-LAPACK/lapack/archive/refs/tags/v3.10.1.tar.gz -O $DEP_DOWNLOAD_DIR/lapack=3.10.1.tar.gz +cd $DEP_DOWNLOAD_DIR +tar -xvf $DEP_DOWNLOAD_DIR/lapack-3.10.1.tar.gz +cd lapack-3.10.1 +cp make.inc.example make.inc +make -j +cd LAPACKE +make -j +cd .. +cp *.a /usr/local/lib + +``` + +## 4.编译wannier90 + +### 4.1.下载并编译wannier90 + +获取QMCPACK软件源码并解压文件 + +```bash + +# 下载源码文件 +cd $DEP_DOWNLOAD_DIR +git clone https://github.com/wannier-developers/wannier90.git +# 解压源码文件 +cd $DEP_BUILD_DIR/wannier90 +#编译源码 +cp config/make.inc.gfortran ./make.inc +sed -i '4c F90 = gfortran' make.inc +sed -i '8c MPIF90 = mpif90' make.inc +sed -i '7c COMMS= mpi' make.inc +sed -i '14c FCOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -fcheck=bounds,do,recursion,pointer -ffree-form -Wall -Waliasing -Wsurprising -Wline-truncation -Wno-tabs -Wno-uninitialized -Wno-unused-dummy-argument -Wno-unused -Wno-character-truncation -O1 -g -fbacktrace' make.inc +sed -i '15c LDOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -fcheck=bounds,do,recursion,pointer -ffree-form -Wall -Waliasing -Wsurprising -Wline-truncation -Wno-tabs -Wno-uninitialized -Wno-unused-dummy-argument -Wno-unused -Wno-character-truncation -O1 -g -fbacktrace' make.inc + +make +make install +``` + +### 4.2. 运行测试文件 + +运行wannier90项目测试文件 + +```bash +export OMPI_ALLOW_RUN_AS_ROOT=1; +export OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1; +make tests +make test-serial +make test-parallel +``` + +## 附A：使用hpcrunner进行一键安装wannier90 + +推荐使用hpcrunner进行安装wannier90 + +### 1.克隆仓库 + +```bash +git clone https://gitee.com/openeuler/hpcrunner.git +``` + +## 2.初始化hpcrunner 和 安装必要软件包 + +初始化项目助手 + +```bash +cd hpcrunner +source init.sh +``` + +安装必要软件包 + +**arm / x86 需要的软件包不同，根据实际环境进行选择** + +```bash +# arm +yum install -y environment-odules git wget unzip make flex tar +# x86 +yum install -y environment-modules git wget unzip make flex tar +yum install -y gcc gcc-c++ gcc-gfortran glibc-devel libgfortran +yum install -y tcsh tcl lsof tk bc +``` + +### 3.选择平台对应配置文件 + +- arm平台的配置文件为 `templates/wannier90/3.1.0/data.wannier90.arm.cpu.config` + + ```bash + ./jarvis -use templates/wannier90/3.1.0/data.wannier90.arm.cpu.config + ``` + +- x86 平台的配置文件为 `templates/wannier90/3.1.0/data.wannier90.amd.cpu.config` + + ```bash + ./jarvis -use templates/wannier90/3.1.0/data.wannier90.amd.cpu.config + ``` + +### 4.下载QMCPACK源码 + +```bash +./jarvis -d +``` + +### 5.一键配置依赖环境 + +```bash +./jarvis -dp +``` + +### 6.一键进行编译 + +```bash +./jarvis -b +``` + +### 7.一键进行运行测试 + +```bash +./jarvis -r +``` + +## 附B：使用singularity运行容器 + +### 使用教程 + +### 下载容器镜像 + +通过链接下载： + +[百度云盘](https://pan.baidu.com/s/1iwjfsZAJKYxu1WBDqYv7LA?pwd=rbab) + +或者扫码下载： + +![百度云](data:image/png;base64,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) + +#### 1.安装singularity + +安装singularity， + +具体步骤如下 + +```bash +mkdir -p ~/install +mkdir -p ~/build + +#安装编译所需依赖 +yum -y install libatomic libstdc++ libstdc++-devel libseccomp-devel glib2-devel gcc squashfs-tools tar + +#安装bisheng编译器 +cd ~/build +wget https://mirrors.huaweicloud.com/kunpeng/archive/compiler/bisheng_compiler/bisheng-compiler-2.1.0-aarch64-linux.tar.gz +tar -C ~/install -xf bisheng-compiler-2.1.0-aarch64-linux.tar.gz +echo "export PATH=$HOME/install/bisheng-compiler-2.1.0-aarch64-linux/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=`which clang` +export CXX=`which clang++` + +#安装go编译器 +cd ~/build +wget https://go.dev/dl/go1.19.linux-arm64.tar.gz +tar -C ~/install -xf go1.19.linux-arm64.tar.gz +echo "export PATH=$HOME/install/go/bin:$PATH" >> ~/.bashrc && source ~/.bashrc + +#安装singularity +cd ~/build +wget https://github.com/sylabs/singularity/releases/download/v3.10.2/singularity-ce-3.10.2.tar.gz +tar -xf singularity-ce-3.10.2.tar.gz +cd singularity-ce-3.10.2 +./mconfig --prefix=$HOME/install/singularity +make -C ./builddir +make -C ./builddir install +echo "export PATH=$HOME/install/singularity/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +``` + +#### 2.构建镜像 + +```shell +# x86 +singularity build ./name-of-image.sif openeuler-gcc-9.3.0-hmpi1-qmcpack-3.13.0.def +# arm +singularity build ./name-of-image.sif openeuler-bisheng2-hmpi1-qmcpack-3.13.0.def +# 转换为沙盒 +singularity build --sandbox image-sandbox name-of-image.sif +``` + +#### 3.在沙盒中运行 + +```shell +#进入沙盒 +singularity shell -w image-sandbox +#在沙盒中运行内置的测试案例 +cd /hpcrunner +./jarvis -r +``` diff --git a/templates/wannier90/3.1.0/data.wannier90.amd.cpu.config b/templates/wannier90/3.1.0/data.wannier90.amd.cpu.config new file mode 100644 index 0000000000000000000000000000000000000000..f7a91a303d4696a545082665380da0f7a3d53181 --- /dev/null +++ b/templates/wannier90/3.1.0/data.wannier90.amd.cpu.config @@ -0,0 +1,50 @@ +[SERVER] +11.11.11.11 + +[DOWNLOAD] +wannier90/3.1.0 https://github.com/wannier-developers/wannier90/archive/v3.1.0.tar.gz + +[DEPENDENCY] +set -e +set -x +module purge +git clone https://github.com/wannier-developers/wannier90.git tmp/wannier90 +./jarvis -install gcc/10.3.0 com +module use ./software/modulefiles +module load gcc10/10.3.0 +./jarvis -install blas/3.10.0 gcc +sed -i '10,12d ' package/lapack/3.8.0/install.sh +sed -i '$a mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=RELEASE -DBUILD_SHARED_LIBS=ON && make && make install && export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib64 ' package/lapack/3.8.0/install.sh +./jarvis -install lapack/3.8.0 gcc +./jarvis -install openmpi/4.1.2 gcc +module load openmpi4 +git clone https://github.com/wannier-developers/wannier90.git tmp/wannier90 + +[ENV] +module purge +module use ./software/modulefiles +module load gcc10/10.3.0 +module load openmpi4 + + +[APP] +app_name = wannier90 +build_dir = ${JARVIS_TMP}/wannier90 +binary_dir = ${JARVIS_LIBS}/gcc10/wannier90 +case_dir = ${JARVIS_LIBS}/gcc10/wannier90 + +[BUILD] + +cp config/make.inc.gfort make.inc +sed -i '8c MPIF90 = mpif90' make.inc +sed -i '7c COMMS= mpi' make.inc +sed -i '14c FCOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -fcheck=bounds,do,recursion,pointer -ffree-form -Wall -Waliasing -Wsurprising -Wline-truncation -Wno-tabs -Wno-uninitialized -Wno-unused-dummy-argument -Wno-unused -Wno-character-truncation -O1 -g -fbacktrace' make.inc +sed -i '15c LDOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -fcheck=bounds,do,recursion,pointer -ffree-form -Wall -Waliasing -Wsurprising -Wline-truncation -Wno-tabs -Wno-uninitialized -Wno-unused-dummy-argument -Wno-unused -Wno-character-truncation -O1 -g -fbacktrace' make.inc +sed -i '16c FCOPTS += -fallow-argument-mismatch' make.inc +make +make install +cp -r ${JARVIS_TMP}/wannier90 ${JARVIS_LIBS}/gcc10/ +[RUN] +run = export OMPI_ALLOW_RUN_AS_ROOT=1 && export OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1 && make tests +binary = +nodes = 1 diff --git a/templates/wannier90/3.1.0/data.wannier90.arm.cpu.bisheng.config b/templates/wannier90/3.1.0/data.wannier90.arm.cpu.bisheng.config new file mode 100644 index 0000000000000000000000000000000000000000..a2fd6d405e642c676d497254cb19da72b7e3a625 --- /dev/null +++ b/templates/wannier90/3.1.0/data.wannier90.arm.cpu.bisheng.config @@ -0,0 +1,62 @@ +[SERVER] +11.11.11.11 + +[DOWNLOAD] + + +[DEPENDENCY] +set -e +set -x +module purge +git clone https://github.com/wannier-developers/wannier90.git tmp/wannier90 +./jarvis -install bisheng/2.1.0 com +module use ./software/modulefiles +module load bisheng2/2.1.0 +export CC=`which clang` +export CXX=`which clang++` +export FC=`which flang` +#./jarvis -install blas/3.10.0/clang bisheng +./jarvis -install openblas/0.3.18 bisheng +module load openblas +sed -i '$a mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=RELEASE -DBUILD_SHARED_LIBS=ON && make && cp lib/* /usr/local/lib' package/lapack/3.8.0/bisheng/install.sh +./jarvis -install lapack/3.8.0/bisheng bisheng +module load blas-clang +module load lapack-bisheng +./jarvis -install hmpi/1.2.0 bisheng +module load hmpi1 + + +[ENV] +module purge +module use ./software/modulefiles +module load bisheng2/2.1.0 +#module load blas-clang + +module load lapack-bisheng +module load hmpi1 +export CC=`which clang` +export CXX=`which clang++` +export FC=`which flang` + +[APP] +app_name = wannier90 +build_dir = ${JARVIS_TMP}/wannier90 +binary_dir = ${JARVIS_LIBS}/bisheng2/wannier90 +case_dir = ${JARVIS_LIBS}/bisheng2/wannier90 + +[BUILD] + +cp config/make.inc.gfort make.inc +sed -i '4c F90 = flang' make.inc +sed -i '8c MPIF90 = mpif90' make.inc +sed -i '7c COMMS= mpi' make.inc +sed -i '14c FCOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -ffree-form -Wall -Wno-uninitialized -Wno-unused -O1 -g' make.inc +sed -i '15c LDOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -ffree-form -Wall -Wno-uninitialized -Wno-unused -O1 -g' make.inc +#sed -i '16c FCOPTS += -fallow-argument-mismatch' make.inc +make +make install +cp -r ${JARVIS_TMP}/wannier90 ${JARVIS_LIBS}/bisheng2/ +[RUN] +run = export OMPI_ALLOW_RUN_AS_ROOT=1 && export OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1 && make test-serial && make test-parallel +binary = +nodes = 1 diff --git a/templates/wannier90/3.1.0/data.wannier90.arm.cpu.kgcc.config b/templates/wannier90/3.1.0/data.wannier90.arm.cpu.kgcc.config new file mode 100644 index 0000000000000000000000000000000000000000..5b4b90eec5eaf4f0908f2db500b46658b40ec8ab --- /dev/null +++ b/templates/wannier90/3.1.0/data.wannier90.arm.cpu.kgcc.config @@ -0,0 +1,51 @@ +[SERVER] +11.11.11.11 + +[DOWNLOAD] + + +[DEPENDENCY] +set -e +set -x +module purge +git clone https://github.com/wannier-developers/wannier90.git tmp/wannier90 +./jarvis -install kgcc/10.3.1 com +module use ./software/modulefiles +module load kgcc10 +./jarvis -install blas/3.10.0 gcc +sed -i '10,12d ' package/lapack/3.8.0/install.sh +sed -i '$a mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=RELEASE -DBUILD_SHARED_LIBS=ON && make && make install && export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib64' package/lapack/3.8.0/install.sh +./jarvis -install lapack/3.8.0 gcc +./jarvis -install hmpi/1.2.0 gcc +module load hmpi1 + + +[ENV] +module purge +module use ./software/modulefiles +module load kgcc10 +module load hmpi1 + + +[APP] +app_name = wannier90 +build_dir = ${JARVIS_TMP}/wannier90 +binary_dir = ${JARVIS_LIBS}/kgcc10/wannier90 +case_dir = ${JARVIS_LIBS}/kgcc10/wannier90 + +[BUILD] + +cp config/make.inc.gfort make.inc +sed -i '4c F90 = gfortran' make.inc +sed -i '8c MPIF90 = mpif90' make.inc +sed -i '7c COMMS= mpi' make.inc +sed -i '14c FCOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -fcheck=bounds,do,recursion,pointer -ffree-form -Wall -Waliasing -Wsurprising -Wline-truncation -Wno-tabs -Wno-uninitialized -Wno-unused-dummy-argument -Wno-unused -Wno-character-truncation -O1 -g -fbacktrace' make.inc +sed -i '15c LDOPTS = -fstrict-aliasing -fno-omit-frame-pointer -fno-realloc-lhs -fcheck=bounds,do,recursion,pointer -ffree-form -Wall -Waliasing -Wsurprising -Wline-truncation -Wno-tabs -Wno-uninitialized -Wno-unused-dummy-argument -Wno-unused -Wno-character-truncation -O1 -g -fbacktrace' make.inc +#sed -i '16c FCOPTS += -fallow-argument-mismatch' make.inc +make +make install +cp -r ${JARVIS_TMP}/wannier90 ${JARVIS_LIBS}/kgcc10/ +[RUN] +run = export OMPI_ALLOW_RUN_AS_ROOT=1 && export OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1 && make tests +binary = +nodes = 1