Beispiel #1
0
                       pseudos=my_qmc_pps,
                       jastrows=[('J1', 'bspline', 8, 4.0),
                                 ('J2', 'bspline', 8)],
                       calculations=[
                           vmc(walkers=1,
                               warmupsteps=20,
                               blocks=200,
                               steps=10,
                               substeps=2,
                               timestep=.4)
                       ],
                       dependencies=(p2q, 'orbitals'))
sims.append(qmc)

# write input files and submit jobs
run_project(sims)

## additional runs for optimization and DMC
##
##   to use, comment out "run_project" above and uncomment below
#linopt1 = linear(
#    energy               = 0.0,
#    unreweightedvariance = 1.0,
#    reweightedvariance   = 0.0,
#    timestep             = 0.4,
#    samples              = 5120,
#    warmupsteps          = 50,
#    blocks               = 200,
#    substeps             = 1,
#    nonlocalpp           = True,
#    usebuffer            = True,
Beispiel #2
0
            steps=10,
            substeps=2,
            timestep=.4)
    ],
    dependencies=(conv, 'orbitals'),
)

qmc_optical = generate_qmcpack(
    det_format='old',
    identifier='vmc',
    path='diamond/vmc_optical',
    job=job(cores=16, threads=16, app='qmcpack', hours=1),
    input_type='basic',
    spin_polarized=True,
    system=dia2,
    excitation=['up', '0 3 4 4'],  #
    pseudos=['C.BFD.xml'],
    jastrows=[],
    calculations=[
        vmc(walkers=16,
            warmupsteps=20,
            blocks=1000,
            steps=10,
            substeps=2,
            timestep=.4)
    ],
    dependencies=(conv, 'orbitals'),
)

run_project()
Beispiel #3
0
conv = generate_pw2qmcpack(
    identifier   = 'conv',
    path         = 'diamond/scf',
    job          = Job(cores=1,app='pw2qmcpack.x'),
    write_psir   = False,
    dependencies = (scf,'orbitals')
    )

qmc = generate_qmcpack(
    identifier   = 'vmc',
    path         = 'diamond/vmc',
    job          = Job(cores=16,threads=4,app='qmcapp'),
    input_type   = 'basic',
    system       = dia16,
    pseudos      = ['C.BFD.xml'],
    jastrows     = [],
    calculations = [
        vmc(
            walkers     =   1,
            warmupsteps =  20,
            blocks      = 200,
            steps       =  10,
            substeps    =   2,
            timestep    =  .4
            )
        ],
    dependencies = (conv,'orbitals')
    )

run_project(scf,conv,qmc)
Beispiel #4
0
              [ x/2+d/2    ,  x/2    ,  x/2    ]],
    net_spin  = 0,
    tiling    = (1,1,1),
    kgrid     = (1,1,1), # scf kgrid given below to enable symmetries
    kshift    = (0,0,0),
    O         = 6,
)

scf = generate_pwscf(
    identifier   = 'scf',
    path         = 'scf'+str(ind),
    job          = jobs['scf'],
    input_type   = 'generic',
    calculation  = 'scf',
    input_dft    = 'lda', 
    for kgtid in [(1,1,1), (2,2,2), (3,3,3)]:
        ecutwfc      = 200,   
        conv_thr     = 1e-8, 
        nosym        = True,
        wf_collect   = True,
        system       = O2,
#        kgrid        = (1,1,1),
        pseudos      = ['O.BFD.upf'],
        ind += 1
    )
scfs.append(scf)

    
run_project(scfs)

Beispiel #5
0
    corrections=[],
    jastrows=[],
    calculations=[
        vmc(
            timestep=0.3,
            warmupsteps=10,
            blocks=80,
            steps=5,
            substeps=3,
            #samplesperthread = 10,
            samples=2048,
        ),
        dmc(
            timestep=0.01,
            warmupsteps=10,
            blocks=80,
            steps=5,
            nonlocalmoves=True,
        ),
        dmc(
            timestep=0.005,
            warmupsteps=50,
            blocks=80,
            steps=5,
            nonlocalmoves=True,
        ),
    ],
    dependencies=[(conv, 'orbitals'), (optJ2, 'jastrow')])

run_project(scf, conv, qmc, optJ2, dmc_run)
Beispiel #6
0
    ],
    dependencies=(conv, 'orbitals'),
)
qmc_minus.input.simulation.qmcsystem.particlesets.e.groups.u.size += 1
qmc_minus.input.simulation.qmcsystem.wavefunction.determinantset.slaterdeterminant.determinants.updet.size += 1

qmc_plus = generate_qmcpack(
    det_format='old',
    identifier='vmc',
    path='diamond/vmc_+e',
    job=job(cores=16, threads=16, app='qmcpack', hours=1),
    input_type='basic',
    spin_polarized=True,
    system=dia2,
    pseudos=['C.BFD.xml'],
    jastrows=[],
    calculations=[
        vmc(walkers=16,
            warmupsteps=20,
            blocks=1000,
            steps=10,
            substeps=2,
            timestep=.4)
    ],
    dependencies=(conv, 'orbitals'),
)
qmc_plus.input.simulation.qmcsystem.particlesets.e.groups.u.size -= 1
qmc_plus.input.simulation.qmcsystem.wavefunction.determinantset.slaterdeterminant.determinants.updet.size -= 1

run_project(scf, nscf, conv, qmc_0, qmc_minus, qmc_plus)
Beispiel #7
0
            timestep      = 0.01,   # dmc timestep (1/Ha)
            warmupsteps   =  50,    # No. of MC steps before data is collected
            blocks        = 400,    # No. of data blocks recorded in scalar.dat
            steps         =   5,    # No. of steps per block
            nonlocalmoves = True    # use Casula's T-moves
            ),                      #  (retains variational principle for NLPP's)
        ],
    # workflow dependencies
    dependencies = [(p2q,'orbitals'),
                    (opt,'jastrow')]
    )



# nexus monitors all runs
run_project(sims)



# print out the total energy
performed_runs = not settings.generate_only and not settings.status_only
if performed_runs:
    # get the qmcpack analyzer object
    # it contains all of the statistically analyzed data from the run
    qa = qmc.load_analyzer_image()
    # get the local energy from dmc.dat
    le = qa.dmc[1].dmc.LocalEnergy  # dmc series 1, dmc.dat, local energy
    #  print the total energy for the 20 atom system
    print 'The DMC ground state energy for C20 is:'
    print '    {0} +/- {1} Ha'.format(le.mean,le.error)
#end if
Beispiel #8
0
    kpoints=dia2_kpath['explicit_kpoints_abs_inv_B'],
    C=4,
)

band = generate_pwscf(
    identifier='nscf',
    path='diamond/band',
    job=job(nodes=1, app='pw.x', hours=1),
    input_type='generic',
    calculation='nscf',
    input_dft='lda',
    ecutwfc=200,
    nspin=2,
    conv_thr=1e-8,
    nosym=True,
    wf_collect=True,
    system=dia2_kpts,
    nbnd=8,  #a sensible nbnd value can be given 
    verbosity='high',  #verbosity must be set to high
    pseudos=['C.BFD.upf'],
    dependencies=(scf, 'charge_density'),
)
run_project(scf, band)
from pwscf_analyzer import PwscfAnalyzer

p = PwscfAnalyzer(band)
p.analyze()
p.plot_bandstructure()
print "VBM: {0}".format(p.bands.vbm)
print "CBM: {0}".format(p.bands.cbm)
Beispiel #9
0
            steps=10,
            substeps=2,
            timestep=.4)
    ],
    dependencies=(conv, 'orbitals'),
)

qmc_optical = generate_qmcpack(
    det_format='old',
    identifier='vmc',
    path='diamond/vmc_optical',
    job=job(cores=16, threads=16, app='qmcpack', hours=1),
    input_type='basic',
    spin_polarized=True,
    system=dia2,
    excitation=['up', '0 3 4 4'],  #
    pseudos=['C.BFD.xml'],
    jastrows=[],
    calculations=[
        vmc(walkers=16,
            warmupsteps=20,
            blocks=1000,
            steps=10,
            substeps=2,
            timestep=.4)
    ],
    dependencies=(conv, 'orbitals'),
)

run_project(scf, nscf, conv, qmc_0, qmc_optical)
        kshift     = (1,1,1),               # grid centered at supercell L point
        pseudos    = ['Ge.pbe-kjpaw.UPF'],  # PBE pseudopotential
        system     = T_system               # the interstitial system
        )
                                        # link together the simulation cascade
                                        #   current relax gets structure from previous
    if len(relaxations)>0:              #   if it exists
        relax.depends(relaxations[-1],'structure')
    #end if
    relaxations.append(relax)           # add relax simulation to the list
#end for



# perform the simulations
run_project(relaxations)



# analyze the results
performed_runs = not settings.generate_only and not settings.status_only
if performed_runs:
    print
    print 'Relaxation results:'
    print '-------------------'
    print '    kgrid     starting force   max force    # of cycles'
    for ik in range(len(supercell_kgrids)):
        kgrid = supercell_kgrids[ik]
        relax = relaxations[ik]
        pa = relax.load_analyzer_image()
        start_force = pa.tot_forces[0]
Beispiel #11
0
print b+'net charge:',dia16vac.net_charge
              
scf = generate_pwscf(
    identifier  = 'scf',
    path        = 'diamond/scf',
    job         = scf_job,
    input_type  = 'generic',
    calculation = 'scf',
    input_dft   = 'lda', 
    ecutwfc     = 200,
    mixing_beta = 0.2,
    degauss     = 0.01,
    conv_thr    = 1e-6,
    system      = dia16vac,
    kgrid       = (3,3,3),
    kshift      = (0,0,0),
    pseudos     = ['C.BFD.upf'], 
    )
print b+'scf directory:',scf.locdir

si = scf.input
print b+'scf input data\n',si
print b+'scf input file\n',si.write()

pm = run_project()
print b+'status after execute:'
pm.write_simulation_status()

sa = scf.load_analyzer_image()
print b+'DFT Energy:',sa.E
Beispiel #12
0
jobs = get_taito_configs()

dia16 = generate_physical_system(units='A',
                                 axes=[[1.785, 1.785, 0.], [0., 1.785, 1.785],
                                       [1.785, 0., 1.785]],
                                 elem=['C', 'C'],
                                 pos=[[0., 0., 0.], [0.8925, 0.8925, 0.8925]],
                                 tiling=(2, 2, 2),
                                 kgrid=(1, 1, 1),
                                 kshift=(0, 0, 0),
                                 C=4)

scf = generate_pwscf(
    identifier='scf',
    path='scf',
    job=jobs['scf'],
    input_type='generic',
    calculation='scf',
    input_dft='lda',
    ecutwfc=200,
    conv_thr=1e-8,
    nosym=True,
    wf_collect=True,
    system=dia16,
    kgrid=(1, 1, 1),
    pseudos=['C.BFD.upf'],
)

run_project(scf)
Beispiel #13
0
        conv_thr=1e-6,  # convergence threshold
        kgrid=kgrid,  # supercell k-point grid
        kshift=(1, 1, 1),  # grid centered at supercell L point
        pseudos=['Ge.pbe-kjpaw.UPF'],  # PBE pseudopotential
        system=T_system,  # the interstitial system
    )
    # link together the simulation cascade
    #   current relax gets structure from previous
    if len(relaxations) > 0:  #   if it exists
        relax.depends(relaxations[-1], 'structure')
    #end if
    relaxations.append(relax)  # add relax simulation to the list
#end for

# perform the simulations
run_project(relaxations)

# analyze the results
performed_runs = not settings.generate_only and not settings.status_only
if performed_runs:
    print
    print 'Relaxation results:'
    print '-------------------'
    print '    kgrid     starting force   max force    # of cycles'
    for ik in range(len(supercell_kgrids)):
        kgrid = supercell_kgrids[ik]
        relax = relaxations[ik]
        pa = relax.load_analyzer_image()
        start_force = pa.tot_forces[0]
        max_force = pa.tot_forces.max()
        ncycles = len(pa.tot_forces)