Example #1
0
def test():
  """ Tests functional prints and reads itself """
  from pylada.dftcrystal.functional import Functional
  from pylada.dftcrystal import Crystal
  from pylada.dftcrystal.parse import parse
  parsed = parse(string)
  structure = Crystal()
  structure.read_input(parsed['rutile']['CRYSTAL'])
  a = Functional()
  a.read_input(parsed)
  assert a.scfdir 
  assert a.maxcycle == 300
  assert a.exchsize == 6937578
  # need structure otherwise parse can't find beginning of input.
  otherstring = a.print_input(structure=structure)
  otherparsed = parse(otherstring)
  b = Functional()
  b.read_input(otherparsed)
  assert otherstring == b.print_input(structure=structure)
Example #2
0
def test():
  from numpy import abs, all
  from pylada.dftcrystal.parse import parse
  from pylada.dftcrystal import Molecule
  string = '\nMOLECULE\n1\n2\n1 0.0 -2.91352558499E-15 12.3754696347\n'        \
           '1 0.0 -2.91352558499E-15 13.1454696347\nEND MOLECULE'
  tree = parse(string)['']
  molecule = Molecule()
  molecule.read_input(tree['MOLECULE'])
  assert molecule.symmgroup == 1
  assert len(molecule) == 0
  assert len(molecule.atoms) == 2
  assert molecule.atoms[0].type == 'H'
  assert molecule.atoms[1].type == 'H'
  assert all(abs(molecule.atoms[0].pos - [0, 0, 12.3754696347]) < 1e-6)
  assert all(abs(molecule.atoms[1].pos - [0, 0, 13.1454696347]) < 1e-6)
Example #3
0
def test_read_input():
  from numpy import array, all
  from pylada.dftcrystal import Functional
  from pylada.dftcrystal.parse import parse
  a = Functional()
  parsed = parse(input)['']['BASISSET']
  a.basis.read_input(parsed)
  assert len(a.basis.ghosts) == 2
  assert a.basis.ghosts[0] == 1
  assert a.basis.ghosts[1] == 2
  assert a.basis.ghosts.breaksym is True
  assert len(a.basis) == 3
  assert set(a.basis) == set(['H', 'O', 'Ti'])
  assert len(a.basis['H']) == 3
  assert abs(a.basis['H'][0].charge - 1) < 1e-8
  assert len(a.basis['H'][0].functions) == 3
  assert a.basis['H'][0].type == 's'
  assert all(abs(array(a.basis['H'][0].functions[0]) - [18.7311370, 0.03349460]) < 1e-8)
  assert all(abs(array(a.basis['H'][0].functions[1]) - [2.82539370, 0.234726950]) < 1e-8)
  assert all(abs(array(a.basis['H'][0].functions[2]) - [0.640121700, 0.813757330]) < 1e-8)
Example #4
0
def test_output_map():
  from pylada.dftcrystal import Functional, Crystal
  from pylada.dftcrystal.parse import parse

  a = Functional()
  parsed = parse(input)['']
  a.basis.read_input(parsed['BASISSET'])
  structure = Crystal()
  structure.read_input(parsed['CRYSTAL'])
  o = a.basis.output_map(structure=structure)
  assert len(o) == 1
  assert o[0] == ('ghosts', '2\n1 2')
  a.basis.ghosts.breaksym = False
  o = a.basis.output_map(structure=structure)
  assert len(o) == 2
  assert o[0] == ('keepsymm', True)
  assert o[1] == ('ghosts', '2\n1 2')
  b = Functional()
  b.basis.raw = o.prefix
  assert set(b.basis) == set(['O', 'Ti'])
  assert repr(b.basis['O']) == repr(a.basis['O'])
  assert repr(b.basis['Ti']) == repr(a.basis['Ti'])
Example #5
0
def test():
  from collections import namedtuple
  from pylada.dftcrystal.hamiltonian import Dft
  from pylada.dftcrystal.input import print_input
  from pylada.dftcrystal.parse import parse
  Crystal = namedtuple('Crystal', ['dft'])
  
  a = Dft()
  crystal = Crystal(a)
  assert a.exchange is None
  assert a.correlat is None
  assert a.hybrid is None
  assert a.nonlocal.correlation is None
  assert a.nonlocal.exchange is None
  assert a.spin is None
  assert not a.b3lyp
  assert not a.b3pw
  assert not a.pbe0
  assert not a.soggaxc
  assert a.output_map(crystal=crystal) is None

  try: a.exchange = 'none'
  except: pass
  else: raise Exception()
  try: a.correlat = 'none'
  except: pass
  else: raise Exception()
  try: a.hybrid = 'none'
  except: pass
  else: raise Exception()
  a.spin = 'none'
  assert a.spin == False

  a.exchange = 'lda'
  crystal = Crystal(a)
  assert a.exchange == 'lda'
  assert a.correlat is None
  assert a.hybrid is None
  assert a.nonlocal.correlation is None
  assert a.nonlocal.exchange is None
  assert a.spin is False
  assert not a.b3lyp
  assert not a.b3pw
  assert not a.pbe0
  assert not a.soggaxc
  assert len(a.output_map(crystal=crystal)) == 1
  assert 'DFT' in a.output_map(crystal=crystal)
  assert len(a.output_map(crystal=crystal)['DFT']) == 1
  assert 'EXCHANGE' in a.output_map(crystal=crystal)['DFT']
  assert a.output_map(crystal=crystal)['DFT']['EXCHANGE'] == 'LDA'

  b = parse("DFT\nEXCHANGE\nPBE\nEND DFT\n", needstarters=False)
  a = Dft()
  a.read_input(b['DFT'])
  assert a.exchange == 'pbe'
  assert a.correlat is None
  assert a.hybrid is None
  assert a.nonlocal.correlation is None
  assert a.nonlocal.exchange is None
  assert a.spin is None
  assert not a.b3lyp
  assert not a.b3pw
  assert not a.pbe0
  assert not a.soggaxc

  a.b3lyp = True
  crystal = Crystal(a)
  assert a.exchange == 'becke'
  assert a.correlat == 'lyp'
  assert abs(a.hybrid - 20) < 1e-8
  assert abs(a.nonlocal.exchange - 0.9) < 1e-8
  assert abs(a.nonlocal.correlation - 0.81) < 1e-8
  assert a.spin is None
  assert a.b3lyp
  assert not a.b3pw
  assert not a.pbe0
  assert not a.soggaxc
  assert len(a.output_map(crystal=crystal)) == 1
  assert 'DFT' in a.output_map(crystal=crystal)
  assert len(a.output_map(crystal=crystal)['DFT']) == 1
  assert 'B3LYP' in a.output_map(crystal=crystal)['DFT']
  assert a.output_map(crystal=crystal)['DFT']['B3LYP'] is None

  b = parse("DFT\nB3LYP\nEND DFT\n", needstarters=False)
  a = Dft()
  a.read_input(b['DFT'])
  assert a.b3lyp
  b = parse("DFT\nPBE0\nEND DFT\n", needstarters=False)
  a = Dft()
  a.read_input(b['DFT'])
  crystal = Crystal(a)
  assert a.pbe0
  assert a.exchange == 'pbe'
  assert a.correlat == 'pbe'
  assert a.hybrid is None
  assert a.nonlocal.exchange is None
  assert a.nonlocal.correlation is None
  assert a.spin is None
  assert not a.b3lyp
  assert not a.b3pw
  assert not a.soggaxc
  assert len(a.output_map(crystal=crystal)) == 1
  assert 'DFT' in a.output_map(crystal=crystal)
  assert len(a.output_map(crystal=crystal)['DFT']) == 1
  assert 'PBE0' in a.output_map(crystal=crystal)['DFT']
  assert a.output_map(crystal=crystal)['DFT']['PBE0'] is None

  a.b3pw = True
  a.exchange = 'lda'
  assert a.exchange == 'lda'
  assert a.correlat == 'pwgga'
  assert abs(a.hybrid - 20) < 1e-8
  assert abs(a.nonlocal.exchange - 0.9) < 1e-8
  assert abs(a.nonlocal.correlation - 0.81) < 1e-8
  assert a.spin is None
  assert not a.pbe0
  assert not a.b3lyp
  assert not a.b3pw
  assert not a.soggaxc
  string = "DFT\nCORRELAT\nPWGGA\nEXCHANGE\nLDA\n"\
           "HYBRID\n" + str(float(20)) + "\n"     \
           "NONLOCAL\n" + str(float(0.9)) + " "   \
           + str(float(0.81)) + "\n" + "END DFT\n"
  assert print_input(a.output_map(crystal=Crystal(a))) == string
  assert print_input(a.output_map(crystal=Crystal(a))) == string

  b = parse(string, needstarters=False)
  a = Dft()
  a.read_input(b['DFT'])
  assert a.exchange == 'lda'
  assert a.correlat == 'pwgga'
  assert abs(a.hybrid - 20) < 1e-8
  assert abs(a.nonlocal.exchange - 0.9) < 1e-8
  assert abs(a.nonlocal.correlation - 0.81) < 1e-8
  assert a.spin is None
  assert not a.pbe0
  assert not a.b3lyp
  assert not a.b3pw
  assert not a.soggaxc
  assert print_input(a.output_map(crystal=Crystal(a))) == string

  string = "DFT\nCORRELAT\nPWGGA\nEXCHANGE\nLDA\n"\
           "HYBRID\n" + str(float(20)) + "\n"     \
           "NONLOCAL\n" + str(float(0.9)) + " "   \
           + str(float(0.81)) + "\nHELLO\nWORLD\n1\n" + "END DFT\n"
  b = parse(string, needstarters=False)
  a = Dft()
  a.read_input(b['DFT'])
  assert a.exchange == 'lda'
  assert a.correlat == 'pwgga'
  assert abs(a.hybrid - 20) < 1e-8
  assert abs(a.nonlocal.exchange - 0.9) < 1e-8
  assert abs(a.nonlocal.correlation - 0.81) < 1e-8
  assert a.spin is None
  assert not a.pbe0
  assert not a.b3lyp
  assert not a.b3pw
  assert not a.soggaxc
  assert 'hello' in a._input
  assert type(a._input['hello']) is bool and a._input['hello'] == True
  assert 'world' in a._input
  assert type(a._input['world']) is int and a._input['world'] == 1
  string = print_input(a.output_map(crystal=Crystal(a))).split('\n')
  assert 'HELLO' in string
  assert 'WORLD' in string 
  assert string[string.index('WORLD')+1] == '1'
  a.hello = False
  a.world = 2
  string = print_input(a.output_map(crystal=Crystal(a))).split('\n')
  assert 'HELLO' not in string
  assert 'WORLD' in string 
  assert string[string.index('WORLD')+1] == '2'