Git Product home page Git Product logo

sparc's Introduction

SPARC installation and usage

(1) Brief:

SPARC is an open-source software package for the accurate, effcient, and scalable solution of the Kohn-Sham density functional theory (DFT) problem. The main features of SPARC currently include

  • Applicable to isolated systems such as molecules as well as extended systems such as crystals, surfaces, and wires.
  • Local, semilocal, and nonlocal (including hybrid) exchange-correlation functionals.
  • Standard ONCV pseudopotentials, including nonlinear core corrections (NLCCs).
  • Calculation of ground state energy, atomic forces, and stress tensor.
  • Structural relaxation and ab initio molecular dynamics (NVE, NVT, and NPT).
  • Spin polarized and unpolarized calculations.
  • Spin-orbit coupling (SOC).
  • Noncollinear spin.
  • Dispersion interactions through DFT-D3, vdW-DF1, and vdW-DF2.
  • Symmetry-adaption for cyclic and/or helical symmetries (Cyclix-DFT).
  • O(N) Spectral Quadrature (SQ) method.
  • On-the-fly machine-learned force field (MLFF) molecular dynamics (MD) simulations.

SPARC is straightforward to install, use, and modify, with minimal external library dependencies. It has shown to be an order of magnitude faster than state-of-the-art planewave codes, with a range of exchange-correlation functionals, and with increasing advantages as the number of processors is increased. In particular, SPARC efficiently scales to thousands of processors in regular operation, bringing solution times down to about a minute for systems with O(500-1000) atoms, and a few seconds for O(100-500) atoms. Using the O(N) SQ method, SPARC has been scaled to system sizes of over a million atoms (https://doi.org/10.1088/1361-651X/acdf06).

(2) Installation:

Prerequisite: C compiler, MPI.

There are several options to compile SPARC, depending on the available external libraries.

  • Option 1: Compile with BLAS and LAPACK.

    • Step 1: Install/Load OpenBLAS/BLAS and LAPACK.

    • Step 2: Change directory to src/ directory, there is an available makefile.

    • Step 3 (optional): Edit makefile. If the BLAS library path and LAPACK library path are not in the search path, edit the BLASROOT and LAPACKROOT variables, and add them to LDFLAGS. If you are using BLAS instead of OpenBLAS, replace all -lopenblas flags with -lblas.

    • Step 4 (optional): To turn on DEBUG mode, set DEBUG_MODE to 1 in the makefile.

    • Step 5: Within the src/ directory, compile the code by

      $ make clean; make

Remark: make sure in the makefile USE_MKL = 0, USE_SCALAPACK = 0, and USE_DP_SUBEIG = 1 for option 1.

  • Option 2 (default): Compile with MKL.
    • Step 1: Install/Load MKL.

    • Step 2: Change directory to src/ directory, there is an available makefile.

    • Step 3: Edit makefile . Set USE_MKL to 1 to enable compilation with MKL. If the MKL library path is not in the search path, edit the MKLROOT variable to manually set the MKL path.

    • Step 4 (optional): For the projection/subspace rotation step, to use SPARC routines for matrix data distribution rather than ScaLAPACK (through MKL), set USE_DP_SUBEIG to 1. We found on some machines this option is faster.

    • Step 5 (optional): To turn on DEBUG mode, set DEBUG_MODE to 1 in the makefile .

    • Step 6: Within the src/ directory, compile the code by

      $ make clean; make

Remark: make sure in the makefile USE_MKL = 1 and USE_SCALAPACK = 0 for option 2.

  • Option 3: Compile with BLAS, LAPACK, and ScaLAPACK.

    • Step 1: Install/Load OpenBLAS/BLAS, LAPACK, and ScaLAPACK.

    • Step 2: Change directory to src/ directory, there is an available makefile.

    • Step 3 (optional): Edit makefile. If the BLAS library path, LAPACK library path, and/or ScaLAPACK library path are not in the search path, edit the BLASROOT, LAPACKROOT , and/or SCALAPACKROOT variables accordingly, and add them to LDFLAGS. If you are using BLAS instead of OpenBLAS, replace all -lopenblas flags with -lblas.

    • Step 4 (optional): For the projection/subspace rotation step, to use SPARC routines for matrix data distribution rather than ScaLAPACK, set USE_DP_SUBEIG to 1. We found on some machines this option is faster.

    • Step 5 (optional): To turn on DEBUG mode, set DEBUG_MODE to 1 in the makefile.

    • Step 6: Within the src/ directory, compile the code by

      $ make clean; make

Remark: make sure in the makefile USE_MKL = 0 and USE_SCALAPACK = 1 for option 3.

Once compilation is done, a binary named sparc will be created in the lib/ directory.

  • Option 4: Install pre-compiled sparc binaries distributed by conda-forge

Pre-compiled sparc package can be installed on x86_64 or aarch64 Linux platforms using anaconda or miniconda. The binary is compiled with OpenBLAS and OpenMPI and flags USE_MKL=0 USE_SCALAPACK=1 USE_FFTW=1.

  • Step 1 (optional): create a conda environment (e.g. sparc-env)
    conda create -n sparc-env
    conda activate sparc-env
  • Step 2: install conda package sparc-x
    conda install -c conda-forge sparc-x
    echo sparc binary is located at: $(which sparc)
    echo .psp files installed at: $SPARC_PSP_PATH
    echo SPARC doc files installed at: $SPARC_DOC_PATH

(3) Input files:

The required input files to run a simulation with SPARC are (with shared names)

(a) ".inpt" -- User options and parameters.

(b) ".ion" -- Atomic information.

It is required that the ".inpt" and ".ion" files are located in the same directory and share the same name. A detailed description of the input options is provided in the documentation located in doc/. Examples of input files can be found in the SPARC/tests directory .

In addition, SPARC requires pseudopotential files of psp8 format which can be generated by D. R. Hamann's open-source pseudopotential code ONCVPSP. The SPMS table of soft and transferable pseudopotentials is provided within the package. For access to more pseudopotentials, the user is referred to pseudoDOJO ONCV potentials and the SG15 ONCV potentials. Note that using the ONCVPSP input files included in the SG15 ONCV potentials, one can easily convert the SG15 ONCV potentials from upf format to psp8 format. Paths to the pseudopotential files are specified in the ".ion" file.

(4) Execution:

SPARC can be executed in parallel using the mpirun command. Sample PBS script files are available in "SPARC/tests" folder. It is required that the ".inpt" and ".ion" files are located in the same directory and share the same name. For example, to run a simulation with 8 processes with input files as "filename.inpt" and "filename.ion" in the root directory (SPARC/), use the following command:

$ mpirun -np 24 ./lib/sparc -name filename

As an example, one can run one of the tests located in SPARC/tests/. First go to SPARC/tests/Example_tests/ directory:

$ cd tests/Example_tests/

The input file is available inside the folder. Run a DC silicon system by

$ mpirun -np 24 ../../lib/sparc -name Si8_kpt

The result is printed to output file "Si8_kpt.out", located in the same directory as the input files. If the file "Si8_kpt.out" is already present, the result will be printed to "Si8_kpt.out_1" instead. The max number of ".out" files allowed with the same name is 100. Once this number is reached, the result will instead overwrite the "Si8_kpt.out" file. One can compare the result with the reference out file named "Si8_kpt.refout".

In the tests/ directory, we also provide a suite of tests which are arranged in a hierarchy of folders. Each test system has its own directory. A python script is also provided which launches the suite of test systems. To run a set of four quick tests locally on the CPU, simply run:

$ python SPARC_testing_script.py quick_run

The result is stored in the corresponding directory of the tests. A message is also printed in the terminal showing if the tests passed or failed. The tests can also be launched in parallel on a cluster by using the Python script. Detailed information on using the python script can be found in the 'ReadMe' file in the tests/ directory.

(5) Output

Upon successful execution of the sparc code, depending on the calculations performed, some output files will be created in the same location as the input files.

Single point calculations

  • ".out" file

    General information about the test, including input parameters, SCF convergence progress, ground state properties and timing information.

  • ".static" file

    Atomic positions and atomic forces if the user chooses to print these information.

Structural relaxation calculations

  • ".out" file

    See above.

  • ".geopt" file

    Atomic positions and atomic forces for atomic relaxation, cell lengths and stress tensor for volume relaxation, and atomic positions, atomic forces, cell lengths , and stress tensor for full relaxation.

  • ".restart" file

    Information necessary to perform a restarted structural relaxation calculation. Only created if atomic relaxation is performed.

Ab initio molecular dynamics (AIMD) calculations

  • .out file

    See above.

  • .aimd file

    Atomic positions, atomic velocities, atomic forces, electronic temperature, ionic temperature and total energy for each QMD step.

  • .restart file

    Information necessary to perform a restarted QMD calculation.

(6) Citation:

If you publish work using/regarding SPARC, please cite some of the following articles, particularly those that are most relevant to your work:

(7) Acknowledgement:

  • U.S. Department of Energy (DOE), Office of Science (SC): DE-SC0023445, DE-SC0019410
  • U.S. Department of Energy (DOE), National Nuclear Security Administration (NNSA): Advanced Simulation and Computing (ASC) Program
  • U.S. Department of Energy (DOE), National Nuclear Security Administration (NNSA): DE-NA0004128 (highT feature)
  • U.S. National Science Foundation (NSF): 1553212 (cyclix feature)
  • U.S. National Science Foundation (NSF): 1663244, and 1333500 (preliminary developments)

sparc's People

Contributors

alchem0x2a avatar phanish-suryanarayana avatar shashikant193 avatar stevenzhangcsfm avatar xuqimen avatar yaphets-jx avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

sparc's Issues

Scaling of lattice vectors

When we specify the scaling factor in SPARC, we use it to scale the unit vectors in the direction of the lattice vectors that the user provides, rather than the lattice vectors themselves. This is atypical and could lease to confusion.

Error in running simulations on Brown University Cluster

Hi

I am trying to run single point energy calculation for my system (contains Pt, C, H, O and total of 221 atoms) on my cluster at Brown university. However, I am getting the following error. Please note that Jagriti was able to run the same calculation successfully on PACE cluster at Georgia Tech.

The error is:
1 INTERNAL ERROR: invalid error code 66 (Ring ids do not match) in MPIR_Alltoallv_intra_scattered:124
2 INTERNAL ERROR: invalid error code 66 (Ring ids do not match) in MPIR_Alltoallv_intra_scattered:124
3 INTERNAL ERROR: invalid error code 66 (Ring ids do not match) in MPIR_Alltoallv_intra_scattered:124
4 INTERNAL ERROR: invalid error code 66 (Ring ids do not match) in MPIR_Alltoallv_intra_scattered:124
5 INTERNAL ERROR: invalid error code 66 (Ring ids do not match) in MPIR_Alltoallv_intra_scattered:124
6 INTERNAL ERROR: invalid error code 66 (Ring ids do not match) in MPIR_Alltoallv_intra_scattered:124
7 INTERNAL ERROR: invalid error code 66 (Ring ids do not match) in MPIR_Alltoallv_intra_scattered:124
8 Fatal error in PMPI_Alltoallv: Unknown error class, error stack:
9 PMPI_Alltoallv(361)................: MPI_Alltoallv(sbuf=0x7fe598adc010, scnts=0x1cc0710, sdispls=0x1c c0740, dtype=0x4c001041, rbuf=0x7fe5c8484010, rcnts=0x1cc0770, rdispls=0x1ce2da0, dtype=0x4c001041, c omm=0xc400000f) failed
10 MPIR_Alltoallv(193)................:
11 MPIR_Alltoallv_intra(105)..........: Failure during collective
12 MPIR_Alltoallv_intra(100)..........:
13 MPIR_Alltoallv_intra_scattered(124):
14 MPID_nem_tcp_connpoll(1845)........: Communication error with rank 47: Connection timed out
15 MPIR_Alltoallv_intra_scattered(124):
16 MPIR_Alltoallv_intra_scattered(124):
17 MPIR_Alltoallv_intra_scattered(124):
18 MPIR_Alltoallv_intra_scattered(124):
19 MPIR_Alltoallv_intra_scattered(124):
20 MPIR_Alltoallv_intra_scattered(124):
21 MPIR_Alltoallv_intra_scattered(124)

I will highly appreciate any help to debug this problem. @xuqimen

Thanks,
Mayank

Not able to compile and run SPARC on my cluster

Hi

I am trying to get SPARC running on the cluster of Brown university. I am able to compile it without errors but all the examples run into segmentation fault error. A file is attached for the error I was getting for test-run.
sparc_error.txt

I have tried different modules for compilation. Some of the installations are as follows:

  1. intel/2020.2 gcc/10.2 mpi/mvapich2-2.3.5_intel_2020.2_slurm20
  2. intel/2017.0 gcc/6.2 mpi/mvapich2-2.3.5_intel_2017.0_slurm20
  3. intel/2020.2 gcc/10.2 mpi/openmpi_4.1.1_gcc_10.2_slurm20

I will appreciate any help possible to get it work. Please let me know if there is any other information I can provide to help debug the issue.

simd instructions for complex stencil not working for all versions of compilers

The ENABLE_SIMD_COMPLEX option in the makefile can bring significant speedup for systems with k-points. However, it only brings speedup for relatively new versions of compilers. For some old compilers, it might even give wrong results. Therefore the user would need to test by turning on and off the ENABLE_SIMD_COMPLEX option (and check both the answers and the speed) to confirm whether the compiler is compatible with this option. This option is off by default.

multi-projector PPs

John Pask advertised SPARC-X as being able to use the new multi-projector PP formalism, which I gather is supported by v 4 of Don Hamann's code. Is this true, and if so, is there a database of such PPs anywhere?

density file atomic positions are wrong

The atomic positions in the header of the density files appear to be wrong. For example, running with this for the PREFIX.ion file

# Input File Generated By SPARC ASE Calculator #
#CELL:   11.114353808858745   11.154443843030773   11.163719668017823
#LATVEC
# -1.000000000000000  0.000000000000000  0.000000000000000
# -0.000357999044009 -0.999999935918340  0.000000000000000
#  0.491162915337454  0.490426660327026  0.719889353607687
#PBC: True True True 
# 


ATOM_TYPE: Al
N_TYPE_ATOM: 2
PSEUDO_POT: Al.psp8
ATOMIC_MASS: 26.9815385
COORD_FRAC:
     0.377775998824091     0.621032998786236     0.250017999224589   # index 0
     0.622224001078524     0.378967000926453     0.749982000541744   # index 1
RELAX:
1 1 1
1 1 1
SPIN:
 0.600000000000000
 0.600000000000000


ATOM_TYPE: O
N_TYPE_ATOM: 8
PSEUDO_POT: O.psp8
ATOMIC_MASS: 15.999

     0.747417999633703     0.741904999126334     0.497531998910203   # index 10
     0.744494000604332     0.252539000420551     0.998849999656910   # index 11
     0.256920999578256     0.253459999671266     0.003540999022197   # index 12
     0.251977000401936     0.742732000468213     0.498768001015243   # index 13
RELAX:
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
SPIN:
 0.600000000000000
 0.600000000000000
 0.600000000000000
 0.600000000000000
 0.600000000000000
 0.600000000000000
 0.600000000000000
 0.600000000000000


ATOM_TYPE: V
N_TYPE_ATOM: 4
PSEUDO_POT: V.psp8
ATOMIC_MASS: 50.9415
COORD_FRAC:
    -0.000000000000000    -0.000000000000000     0.000000000000000   # index 2
     0.000000000419092     0.000000001279868     0.500000001058860   # index 3
     0.499999999507650    -0.000000000000000     0.000000000000000   # index 4
     0.000000001023168     0.500000001280489     0.500000001058860   # index 5
RELAX:
1 1 1
1 1 1
1 1 1
1 1 1
SPIN:
 5.000000000000000
 5.000000000000000
-5.000000000000000
-5.000000000000000


Gives the following density file header

Spin-up electron density in Cube format printed by SPARC-X (Print time: Fri Oct 21 13:05:21 2022)
OUTER LOOP: X, MIDDLE LOOP: Y, INNER LOOP: Z.
   14    0.000000     0.000000     0.000000
   45   -0.246986     0.000000     0.000000
   45   -0.000089    -0.247877     0.000000
   45    0.121849     0.121666     0.178592
   13    3.000000    4.198736     6.927278     2.791131
   13    3.000000    6.915618     4.227166     8.372589
    8    6.000000    2.839784     8.337512     0.012838
    8    6.000000    2.807286     2.878906     5.609412
    8    6.000000    8.258843     8.327239    11.124189
    8    6.000000    8.313792     2.869681     5.595614
    8    6.000000    8.307068     8.275538     5.554308
    8    6.000000    8.274570     2.816932    11.150881
    8    6.000000    2.855511     2.827205     0.039531
    8    6.000000    2.800562     8.284762     5.568106
   23   13.000000   -0.000000    -0.000000     0.000000
   23   13.000000    0.000000     0.000000     5.581860
   23   13.000000    5.557177    -0.000000     0.000000
   23   13.000000    0.000000     5.577222     5.581860
.
.
.

I'm not sure where these values are coming from, but from what I can tell they are just wrong. When I visualize them they look completely different. Is there some way to interpret these that makes sense, and I'm just not understanding it, or is there a bug saving positions to the density file?

SIMD not used for k-points

  • #pragma omp simd instructions are used in the gamma-point part of the matrix-vector routines, however, such instructions are not used in their k-point counterparts. This might be a reason why the k-point code is not as fast as expected.

The energy of crystal structure from RELAX_FLAG: 2/1 is lower than that from RELAX_FLAG: 3

Hi,

I obtained a relaxed BaTiS3 structure with RELAX_FLAG: 2 first, and then with RELAX_FLAG: 1. This relaxed BaTiS3 structure with RELAX_FLAG: 2 and RELAX_FLAG: 1 has lower energy than the relaxed BaTiS3 structure with RELAX_FLAG: 3. In both cases, I used the same convergence setting. It seems like the "RELAX_FLAG: 3" setting missed a local minimum structure. Does anyone know what is a reliable way to get a fully optimized structure?

compiling with MKL fails to find lapacke.h

I set USE_MKL=1, USE_SCALAPACK=0, and USE_DP_SUBEIG=1. When I compile, I get the following error

mpicc -std=gnu99 -O3 -fopenmp -Iinclude/ -DUSE_DP_SUBEIG  -c -o orbitalElecDensInit.o orbitalElecDensInit.c
orbitalElecDensInit.c:20:14: fatal error: lapacke.h: No such file or directory
     #include <lapacke.h>
              ^~~~~~~~~~~
compilation terminated.
make: *** [<builtin>: orbitalElecDensInit.o] Error 1

Is there a dependence on something other than plain LAPACK? My MKL installation (2020.2.254) doesn't seem to have this file, and even if it did there's no attempt to add its include/ path to the compile line.

support for restarts from old wavefunctions

It would be nice if SPARC supported some way to start a calculation from the results of the previous, for example when using an ASE dynamics algorithm (MD, relaxation, NEB, whatever). The simplest approach would be to save and reload wavefunctions, but another (arguably better) way would be to have the sparc executable work in a sort of client-server mode, where it waited for new input positions/cell passed from the ASE calculator somehow. I've done things like that with file based I/O for VASP, so if that seems useful, I'd be happy to help if I can.

cyclic DFT

Just wanted to if the cylic DFT implementation used for calculations of flexo electric properties (https://arxiv.org/abs/2010.01747
) is already available with the public release? If nit are there any plans for making it open in near future?

Thanks
Alex

Eggbox effect

Like all real-space codes, SPARC is susceptible to the eggbox effect. However, the eggbox effect in SPARC is sufficiently small such that most applications should not be impacted. In order to further minimize the eggbox effect, Fourier filtering and other such techniques will be incorporated into future releases of SPARC.

more control over hybrid functionals

It might be useful to add more hybrid functionals, or maybe just direct control over things like fraction of exact exchange, fraction of PBE correlation, etc, which can define at least some of the existing hybrid functionals.

Help with extracting band gap and band structure

Good morning,

I want to extract the band gap information from the results of sparc static calculation. I assume the density of state(DOS) is from the .eigen file. What is the unit in the "eigval" column? Is it Hartree? In addition, if I want to plot band structure, which file should I look for?

Thanks,
Jiang

support for charged systems

Are there any plans for SPARC to support charged systems (with a uniform background charge compensation)?

Lattice symmetry: Brillouin zone integration

Other than time-reversal symmetry, symmetry-adaption in the Brillouin zone has currently not been implemented. This is because SPARC is targeted for large systems, where lattice symmetry is less likely to be present. Consequently, for systems with spatial symmetry, the number of k-points that SPARC will employ for Brillouin zone integration is larger than the minimal set required.

Fe2_spin_scan_gamma error

using 1 processor: stuck at MGGAstress.c line 160
using 2 processors: it can finish normally
using 3 processors: segment fault in computing mGGA psi term

printing out wavefunctions

We're trying to understand why we're getting states in the gap, and it would be helpful to get some sort of spatially and energy resolved information. One option, probably the simplest to code, would be if SPARC could save the wavefunctions (perhaps only in a specified energy or state # range). Another, which would require more parameters inside SPARC but perhaps less I/O, would be to save an atom-projected density of states.

Segmentation fault after running the compiled sparc-x on anvil and rockfish cluster

Hi,

I compiled the sparc-x on anvil and rockfish cluster without showing any error message. But the segmentation fault error, as shown below, come out when I was running the compiled sparc-x. Does anyone have any clue about this error? I know the segmentation error means that the program accessed an unassigned memory location. It might be related to the misbehaving in the code. So, I attached my job file here.

Caught signal 11 (Segmentation fault: address not mapped to object at address 0x440000e8)

Below is my job file:
#!/bin/bash
#SBATCH -A dmr160007 # Allocation name
#SBATCH --nodes=1 # Total # of nodes
#SBATCH --ntasks=128 # Total # of MPI tasks
#SBATCH --time=00:30:00 # Total run time limit (hh:mm:ss)
#SBATCH -J sparc # Job name
#SBATCH -p wholenode # Queue (partition) name
#module --force purge

cd $SLURM_SUBMIT_DIR
module reset
module load intel-mkl/2019.5.281
echo $PWD
mpirun -np 128 ./sparc -name BTS

Thanks,
Jiang

document units of various output

It would be helpful if units for all input output files were documented. Things in PREFIX.out mostly (always?) are, but I've been assuming that the eigenvalues file is in Ha, but it would be nice if that were written someplace (either in the file or in the docs, or both).

add support for LDA/GGA+U

Many systems of interest involve transition metals that are better described by LDA+U or GGA+U, so it would be nice to support those sorts of functionals (also hybrid functionals, but I gather those are already being planned, right?)

documenting makefile, in particular libraries that will be used

It would be nice if there was a bit more documentation on the libraries that will be used, and a cleaner way of specifying them. In particular, I was getting weird crashes until I noticed that it was using MKL scalapack and MKL blacs for intelmpi. I had to change it to the openmpi version, but it would be better if this was at least documented, especially since the current description of USE_DP_SUBEIG makes one think it won't use scalapack at all if that's set.

Memory management for large scale AIMD

I tried to run NVT AIMD w/ 170 atoms/cell. It is
an amorphous structure. SPARC showed me a result initially, but it crashed after around 100 steps. I checked memory consumption during md step and it continuously increases and thus when it is over the physical memory (380GB in my cluster), the calculation is crashed. I tried it with another cluster of which memory is 760GB, but it crashed as well though it is alive a little longer time.
Are there any specific options to control the memory consumption during md step? Or, if you have any examples with larger system, please share it as well

ASE Calculator Interface

Are there any plans to implement an ASE calculator interface for this code? In particular, an interface allowing for the atomic positions to be streamed in / out of the code would be particularly useful for MD / NEB / Dimer type of calculations.

How does the tag "RELAX_MAXDILAT" work in relaxation calculation?

I have a question about Sparc-X tag “RELAX_MAXDILAT”. I thought it can control the change of cell volume during the full relaxation step (RELAX_FLAG=3, RELAX_METHOD= LBFGS). The default RELAX_MAXDILAT = 1.06. But the volume can change by 40%~80% after each iteration for the full relaxation of Si, TiO2, and BaTiO3 materials that I tested. Does anyone know what is going on with the tag “RELAX_MAXDILAT” and how to control the restriction on the cell change?

Magnetization calculation in cyclix

Hi,

I have a few questions on spin polarized calculations in Cyclix:

  1. I was going through the Cyclix code and could not find a routine for calculating atomic magnetization but the code prints magnetization values. I am wondering whether those values are correct.
  2. The .dens flies generated by the Cyclix code looks like .cube file. I used Vesta to plot isosurfaces but it did not plot anything. I looked at the .dens file and it has 0 as a value in voxels. Usual .cube files are in cartesian coordinates. Is the density printed in this file by the code in cylindrical coordinate system?
  3. Does DCP boundary conditions allow for non-zero twist?
    Many thanks,
    Shivam

What is the preferred K-point grid?

Hi,

I tried to use a similar rule of thumb for the K-point grid in vasp calculation (a*k=30). It greatly increased the cost of the computation resources. Then, I saw K-point grid is 2 * 2 * 2 in the testing example "AlSi_primitive_quick_relax" with a cell size of 7 * 7 * 7. Does anyone know if there is a rule of thumb for the K-point grid in sparc-X calculation?

Thanks,
Jiang

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.