def get_structuredata_ncf(self): """ This routine returns an AiiDA Structure Data type produced from the ``inp.xml`` file. not a calcfunction :param self: a FleurinpData instance to be parsed into a StructureData :returns: StructureData node, or None """ from aiida.orm import StructureData from masci_tools.util.xml.xml_getters import get_structure_data xmltree, schema_dict = self.load_inpxml() atoms, cell, pbc = get_structure_data(xmltree, schema_dict, site_namedtuple=True) struc = StructureData(cell=cell, pbc=pbc) for atom in atoms: struc.append_atom(position=atom.position, symbols=atom.symbol, name=atom.kind) # TODO DATA-DATA links are not wanted, you might want to use a cf instead #struc.add_link_from(self, label='self.structure', link_type=LinkType.CREATE) # label='self.structure' # return {label : struc} return struc
def prepare_plotting_structure(return_struc=False, show_empty_atoms=False): # find and plot structure, extract if from parent of bandstructure calc Sb2Te3_6QL_bandstruc = load_node( UUID_HOST_BANDSTRUC) # -0.5eV..+0.3eV, corrected K-path structure0, _ = VoronoiCalculation.find_parent_structure( Sb2Te3_6QL_bandstruc) if structure0.has_vacancies: cell = structure0.cell # correct cell ... cell[2] = [i * 8 for i in cell[2]] stmp = StructureData(cell=cell) for site in structure0.sites: k = structure0.get_kind(site.kind_name) pos = np.array(site.position) pos[2] = -pos[2] if not k.has_vacancies: stmp.append_atom(position=pos, symbols=k.symbol) elif show_empty_atoms: stmp.append_atom(position=pos, symbols='X') #else: # print("removing atom", site) stmp.set_pbc(structure0.pbc) structure = stmp if return_struc: return structure # now construct ase object and use ase's viewer ase_atoms = structure.get_ase() return ase_atoms
def get_supercell( structure: orm.StructureData, supercell_shape: orm.Dict, ) -> orm.StructureData: """Generate a supercell from a given StructureData :param structure: original structure that will be used to generate the supercell :type structure: orm.StructureData :param supercell_shape: dictionary with the supercell information :type supercell_shape: orm.Dict :return: generated supercell :rtype: orm.StructureData """ symbols = np.array([site.kind_name for site in structure.sites]) positions = np.array([site.position for site in structure.sites]) cell = np.array(structure.cell) supercell_shape = np.array(supercell_shape.dict.shape) supercell_array = np.dot(cell, np.diag(supercell_shape)) supercell = StructureData(cell=supercell_array) for k in range(positions.shape[0]): for entry in itertools.product( *[range(i) for i in supercell_shape[::-1]]): position = positions[k, :] + np.dot(np.array(entry[::-1]), cell) symbol = symbols[k] supercell.append_atom(position=position, symbols=symbol) return supercell
def setUpClass(cls, *args, **kwargs): super(TestKpoints, cls).setUpClass(*args, **kwargs) alat = 5.430 # angstrom cell = [[ 0.5 * alat, 0.5 * alat, 0., ], [ 0., 0.5 * alat, 0.5 * alat, ], [0.5 * alat, 0., 0.5 * alat]] cls.alat = alat structure = StructureData(cell=cell) structure.append_atom(position=(0.000 * alat, 0.000 * alat, 0.000 * alat), symbols=['Si']) structure.append_atom(position=(0.250 * alat, 0.250 * alat, 0.250 * alat), symbols=['Si']) cls.structure = structure # Define the expected reciprocal cell val = 2. * np.pi / alat cls.expected_reciprocal_cell = np.array([[val, val, -val], [-val, val, val], [val, -val, val]])
def _generate_structure2(): """Return a `StructureData` representing bulk silicon.""" from aiida.orm import StructureData def rel_to_abs(vector, cell): """ converts interal coordinates to absolut coordinates in Angstroem. """ if len(vector) == 3: postionR = vector row1 = cell[0] row2 = cell[1] row3 = cell[2] new_abs_pos = [ postionR[0] * row1[0] + postionR[1] * row2[0] + postionR[2] * row3[0], postionR[0] * row1[1] + postionR[1] * row2[1] + postionR[2] * row3[1], postionR[0] * row1[2] + postionR[1] * row2[2] + postionR[2] * row3[2] ] return new_abs_pos bohr_a_0 = 0.52917721092 # A a = 5.167355275190 * bohr_a_0 cell = [[0.0, a, a], [a, 0.0, a], [a, a, 0.0]] structure = StructureData(cell=cell) pos1 = rel_to_abs((1. / 8., 1. / 8., 1. / 8.), cell) pos2 = rel_to_abs((-1. / 8., -1. / 8., -1. / 8.), cell) structure.append_atom(position=pos1, symbols='Si') structure.append_atom(position=pos2, symbols='Si') return structure
def _generate_structure(structure_id='silicon'): """Return a `StructureData` representing bulk silicon or a snapshot of a single water molecule dynamics.""" from aiida.orm import StructureData if structure_id == 'silicon': param = 5.43 cell = [[param / 2., param / 2., 0], [param / 2., 0, param / 2.], [0, param / 2., param / 2.]] structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., 0.), symbols='Si', name='Si') structure.append_atom(position=(param / 4., param / 4., param / 4.), symbols='Si', name='Si') elif structure_id == 'water': structure = StructureData( cell=[[5.29177209, 0., 0.], [0., 5.29177209, 0.], [0., 0., 5.29177209]]) structure.append_atom( position=[12.73464656, 16.7741411, 24.35076238], symbols='H', name='H') structure.append_atom( position=[-29.3865565, 9.51707929, -4.02515904], symbols='H', name='H') structure.append_atom( position=[1.04074437, -1.64320127, -1.27035021], symbols='O', name='O') else: raise KeyError('Unknown structure_id=\'{}\''.format(structure_id)) return structure
def create_structure_bands(): """Create bands structure object.""" alat = 4. # angstrom cell = [ [ alat, 0., 0., ], [ 0., alat, 0., ], [ 0., 0., alat, ], ] strct = StructureData(cell=cell) strct.append_atom(position=(0., 0., 0.), symbols='Fe') strct.append_atom(position=(alat / 2., alat / 2., alat / 2.), symbols='O') strct.store() @calcfunction def connect_structure_bands(strct): # pylint: disable=unused-argument alat = 4. cell = np.array([ [alat, 0., 0.], [0., alat, 0.], [0., 0., alat], ]) kpnts = KpointsData() kpnts.set_cell(cell) kpnts.set_kpoints([[0., 0., 0.], [0.1, 0.1, 0.1]]) bands = BandsData() bands.set_kpointsdata(kpnts) bands.set_bands([[1.0, 2.0], [3.0, 4.0]]) return bands bands = connect_structure_bands(strct) # Create 2 groups and add the data to one of them g_ne = Group(label='non_empty_group') g_ne.store() g_ne.add_nodes(bands) g_e = Group(label='empty_group') g_e.store() return { DummyVerdiDataListable.NODE_ID_STR: bands.id, DummyVerdiDataListable.NON_EMPTY_GROUP_ID_STR: g_ne.id, DummyVerdiDataListable.EMPTY_GROUP_ID_STR: g_e.id }
def create_structure_bands(): alat = 4. # angstrom cell = [ [ alat, 0., 0., ], [ 0., alat, 0., ], [ 0., 0., alat, ], ] s = StructureData(cell=cell) s.append_atom(position=(0., 0., 0.), symbols='Fe') s.append_atom(position=(alat / 2., alat / 2., alat / 2.), symbols='O') s.store() @calcfunction def connect_structure_bands(structure): alat = 4. cell = np.array([ [alat, 0., 0.], [0., alat, 0.], [0., 0., alat], ]) k = KpointsData() k.set_cell(cell) k.set_kpoints([[0., 0., 0.], [0.1, 0.1, 0.1]]) b = BandsData() b.set_kpointsdata(k) b.set_bands([[1.0, 2.0], [3.0, 4.0]]) return b b = connect_structure_bands(s) # Create 2 groups and add the data to one of them g_ne = Group(label='non_empty_group') g_ne.store() g_ne.add_nodes(b) g_e = Group(label='empty_group') g_e.store() return { TestVerdiDataListable.NODE_ID_STR: b.id, TestVerdiDataListable.NON_EMPTY_GROUP_ID_STR: g_ne.id, TestVerdiDataListable.EMPTY_GROUP_ID_STR: g_e.id }
def h2_structure(aiida_profile, db_test_app): a = 10 cell = ((a, 0., 0.), (0., a, 0.), (0., 0., a)) s = StructureData(cell=cell) s.append_atom(position=(0., 0., 0.), symbols=["H"]) s.append_atom(position=(a / 2, a / 2, a / 2), symbols=["H"]) s.label = "h2" return s
def get_x2_structure(x): """Return a O2 molecule in a box""" a = 10 cell = ((a, 0., 0.), (0., a, 0.), (0., 0., a)) s = StructureData(cell=cell) s.append_atom(position=(0., 0., 0.), symbols=[x]) s.append_atom(position=(1.4, 0., 0.), symbols=[x]) s.label = "O2" return s
def _generate_structure(): """Return a `StructureData` representing bulk silicon.""" from aiida.orm import StructureData param = 5.43 cell = [[param / 2., param / 2., 0], [param / 2., 0, param / 2.], [0, param / 2., param / 2.]] structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., 0.), symbols='Si', name='Si') structure.append_atom(position=(param / 4., param / 4., param / 4.), symbols='Si', name='Si') return structure
def _generate_structure(element='Si'): """Return a `StructureData` representing bulk silicon.""" from aiida.orm import StructureData a = 5.43 cell = [[a / 2., a / 2., 0], [a / 2., 0, a / 2.], [0, a / 2., a / 2.]] structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., 0.), symbols=element) structure.append_atom(position=(a / 4., a / 4., a / 4.), symbols=element) return structure
def _generate_structure(elements=('Ar',)): """Return a ``StructureData``.""" from aiida.orm import StructureData structure = StructureData(cell=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]) for index, element in enumerate(elements): symbol = re.sub(r'[0-9]+', '', element) structure.append_atom(position=(index * 0.5, index * 0.5, index * 0.5), symbols=symbol, name=element) return structure
def structure_from_input(cell, positions, symbols): """ Receives the dictionary cell parsed from CASTEP Convert it into an AiiDA structure object """ out_structure = StructureData(cell=cell) for symbol, position in zip(symbols, positions): out_structure.append_atom(symbols=symbol, position=position) return out_structure
def newStructure(structure, changeDict): """ :code:`newStructure` will create a new structure by replacing the changeList atom to new type of atoms, very useful if there are different chemical states of the same atom in the structure. :param structure: previous structure with conventional atomic symbols :type structure: aiida.orm.StructureData object :param changeDict: A dictionary where the i-th atom's label will be replaced. e.g. 'Fe' to 'Fe2' :type changeDict: python dictionary :returns: return an object which stores the change of the label :rtype: aiida.orm.StructureData object """ # create the kind_names list kind_names = [] structure_ase = structure.get_ase() for atom in structure_ase: kind_names.append(atom.symbol) for key, value in changeDict.items(): for ind, atomSymbol in enumerate(kind_names): if atomSymbol == key: kind_names[ind] = value # since I recreate kind_names from structure, then they must be the same. # if len(structure.sites) != len(kind_names): # raise ValueError('The number of new kind names must be equal to the number of sites in the structure.') new_structure = StructureData( cell=structure.cell, pbc=structure.pbc, ) for site, kind_name in zip(structure.sites, kind_names): kind = structure.get_kind(site.kind_name) new_structure.append_atom(name=kind_name, symbols=kind.symbols, weights=kind.weights, position=site.position) return new_structure
def get_structure(self): """ Returns the structure used to calculate the NAC parameters :return: StructureData """ structure = StructureData(cell=self.get_attr('cell')) symbols = self.get_attr('symbols') positions = self.get_attr('positions') for symbol, position in zip(symbols, positions): structure.append_atom(position=position, symbols=symbol) return structure
def _generate_structure_W(): """Return a `StructureData` representing bulk tungsten.""" from aiida.orm import StructureData # W bcc structure bohr_a_0 = 0.52917721092 # A a = 3.013812049196 * bohr_a_0 cell = [[-a, a, a], [a, -a, a], [a, a, -a]] structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., 0.), symbols='W', name='W') #param = 3.18968 # 1.58950065353588 * 0.5291772109 #cell = [[-param, param, param], [param, -param, param], [param, param, -param]] #structure = StructureData(cell=cell) #structure.append_atom(position=(0., 0., 0.), symbols='W', name='W') return structure
def get_supercell(structure, supercell_shape): import itertools symbols = np.array([site.kind_name for site in structure.sites]) positions = np.array([site.position for site in structure.sites]) cell = np.array(structure.cell) supercell_shape = np.array(supercell_shape.dict.shape) supercell_array = np.dot(cell, np.diag(supercell_shape)) supercell = StructureData(cell=supercell_array) for k in range(positions.shape[0]): for r in itertools.product(*[range(i) for i in supercell_shape[::-1]]): position = positions[k, :] + np.dot(np.array(r[::-1]), cell) symbol = symbols[k] supercell.append_atom(position=position, symbols=symbol) return supercell
def get_sto_structure(): """Return a STO structure""" a = 3.905 cell = ((a, 0., 0.), (0., a, 0.), (0., 0., a)) s = StructureData(cell=cell) s.append_atom(position=(0., 0., 0.), symbols=["Sr"]) s.append_atom(position=(a / 2, a / 2, a / 2), symbols=["Ti"]) s.append_atom(position=(a / 2, a / 2, 0.), symbols=["O"]) s.append_atom(position=(a / 2, 0., a / 2), symbols=["O"]) s.append_atom(position=(0., a / 2, a / 2), symbols=["O"]) s.label = "STO" return s
def get_STO_structure(): """Return a STO structure""" from aiida.plugins import DataFactory a = 3.905 cell = ((a, 0., 0.), (0., a, 0.), (0., 0., a)) s = StructureData(cell=cell) s.append_atom(position=(0., 0., 0.), symbols=["Sr"]) s.append_atom(position=(a / 2, a / 2, a / 2), symbols=["Ti"]) s.append_atom(position=(a / 2, a / 2, 0.), symbols=["O"]) s.append_atom(position=(a / 2, 0., a / 2), symbols=["O"]) s.append_atom(position=(0., a / 2, a / 2), symbols=["O"]) s.label = "STO" return s
def create_structure( traj_block, symbol_field="element", position_fields=("x", "y", "z"), original_structure=None, ): symbols = traj_block.atom_fields[symbol_field] positions = np.array([traj_block.atom_fields[f] for f in position_fields], dtype=float).T if original_structure is not None: kind_names = original_structure.get_site_kindnames() kind_symbols = [ original_structure.get_kind(n).symbol for n in kind_names ] if symbols != kind_symbols: raise ValueError( "original_structure has different symbols:: {} != {}".format( kind_symbols, symbols)) structure = original_structure.clone() structure.reset_cell(traj_block.cell) structure.reset_sites_positions(positions) return structure pbcs = [] for pbc in traj_block.pbc: if pbc == "pp": pbcs.append(True) elif pbc == "ff": pbcs.append(False) else: raise NotImplementedError("pbc = {}".format(traj_block.pbc)) structure = StructureData(cell=traj_block.cell, pbc=pbcs) for symbol, position in zip(symbols, positions): structure.append_atom(position=position, symbols=symbol) return structure
def _generate_structure(scale=None): """Return a `StructureData` representing bulk silicon.""" from aiida.orm import StructureData param = 5.43 cell = [[param / 2., param / 2., 0], [param / 2., 0, param / 2.], [0, param / 2., param / 2.]] structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., 0.), symbols='Si', name='Si') structure.append_atom(position=(param / 4., param / 4., param / 4.), symbols='Si', name='SiDiff') if scale: the_ase = structure.get_ase() new_ase = the_ase.copy() new_ase.set_cell(the_ase.get_cell() * float(scale), scale_atoms=True) new_structure = StructureData(ase=new_ase) structure = new_structure return structure
def get_mixture_cell(): """Return a STO structure""" a = 3.905 cell = ((a, 0., 0.), (0., a, 0.), (0., 0., a)) s = StructureData(cell=cell) s.append_atom(position=(0., 0., 0.), symbols=["Sr", "Ti"], weights=(0.5, 0.5), name='SrTi') s.append_atom(position=(a / 2, a / 2, a / 2), symbols=["Ti"]) s.append_atom(position=(a / 2, a / 2, 0.), symbols=["O"]) s.append_atom(position=(a / 2, 0., a / 2), symbols=["O"], name='O1') s.append_atom(position=(0., a / 2, a / 2), symbols=["O"], name='O2') s.label = "STO" return s
def create_structure_data(): """Create StructureData object.""" alat = 4. # angstrom cell = [ [ alat, 0., 0., ], [ 0., alat, 0., ], [ 0., 0., alat, ], ] # BaTiO3 cubic structure struc = StructureData(cell=cell) struc.append_atom(position=(0., 0., 0.), symbols='Ba') struc.append_atom(position=(alat / 2., alat / 2., alat / 2.), symbols='Ti') struc.append_atom(position=(alat / 2., alat / 2., 0.), symbols='O') struc.append_atom(position=(alat / 2., 0., alat / 2.), symbols='O') struc.append_atom(position=(0., alat / 2., alat / 2.), symbols='O') struc.store() # Create 2 groups and add the data to one of them g_ne = Group(label='non_empty_group') g_ne.store() g_ne.add_nodes(struc) g_e = Group(label='empty_group') g_e.store() return { DummyVerdiDataListable.NODE_ID_STR: struc.id, DummyVerdiDataListable.NON_EMPTY_GROUP_ID_STR: g_ne.id, DummyVerdiDataListable.EMPTY_GROUP_ID_STR: g_e.id }
def _generate_film_structure(): """Return a `StructureData` representing bulk silicon.""" from aiida.orm import StructureData from aiida_fleur.common.constants import BOHR_A a = 7.497 * BOHR_A cell = [[0.7071068 * a, 0.0, 0.0], [0.0, 1.0 * a, 0.0], [0.0, 0.0, 0.7071068 * a]] structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., -1.99285 * BOHR_A), symbols='Fe') structure.append_atom(position=(0.5 * 0.7071068 * a, 0.5 * a, 0.0), symbols='Pt') structure.append_atom(position=(0., 0., 1.99285 * BOHR_A), symbols='Fe') structure.pbc = (True, True, False) return structure
], [ 0., 0.5 * alat, 0.5 * alat, ], [ 0.5 * alat, 0., 0.5 * alat, ], ] #The atom positions were originally given in the "ScaledCartesian" format #but standard for aiida structures is Cartesian in Angstrom structure = StructureData(cell=cell) structure.append_atom(position=(0.000 * alat, 0.000 * alat, 0.000 * alat), symbols=['Si']) structure.append_atom(position=(0.250 * alat, 0.250 * alat, 0.250 * alat), symbols=['Si']) #The parameters parameters = Dict( dict={ 'xc-functional': 'LDA', 'xc-authors': 'CA', 'max-scfiterations': 4, 'dm-numberpulay': 4, 'dm-mixingweight': 0.3, 'dm-tolerance': 1.e-5, 'Solution-method': 'diagon', 'electronic-temperature': '25 meV', 'write-forces': True,
############################ a = 5.404 cell = [[a, 0, 0], [0, a, 0], [0, 0, a]] symbols = ['Si'] * 8 scaled_positions = [(0.875, 0.875, 0.875), (0.875, 0.375, 0.375), (0.375, 0.875, 0.375), (0.375, 0.375, 0.875), (0.125, 0.125, 0.125), (0.125, 0.625, 0.625), (0.625, 0.125, 0.625), (0.625, 0.625, 0.125)] structure = StructureData(cell=cell) positions = np.dot(scaled_positions, cell) for i, scaled_position in enumerate(scaled_positions): structure.append_atom(position=np.dot(scaled_position, cell).tolist(), symbols=symbols[i]) structure.store() dynaphopy_parameters = { 'supercell': [[2, 0, 0], [0, 2, 0], [0, 0, 2]], 'primitive': [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], 'mesh': [40, 40, 40], 'md_commensurate': True, 'temperature': 300 } # Temperature can be omitted (If ommited calculated from Max.-Boltz.) dynaphopy_machine = { 'num_machines': 1, 'parallel_env': 'mpi*', 'tot_num_mpiprocs': 16
], [ 0., 0.5 * alat, 0.5 * alat, ], [ 0.5 * alat, 0., 0.5 * alat, ], ] #The atom positions were originally given in the "ScaledCartesian" format #but standard for aiida structures is Cartesian in Angstrom structure = StructureData(cell=cell) structure.append_atom(position=(0.000 * alat, 0.000 * alat, 0.000 * alat), symbols=['Si'], name='Si_one') structure.append_atom(position=(0.260 * alat, 0.250 * alat, 0.250 * alat), symbols=['Si'], name='alt_Si') #The parameters parameters = Dict( dict={ 'xc-functional': 'LDA', 'xc-authors': 'CA', 'max-scfiterations': 50, 'dm-numberpulay': 4, 'dm-mixingweight': 0.3, 'dm-tolerance': 1.e-3, 'Solution-method': 'diagon', 'electronic-temperature': '25 meV', 'md-typeofrun': 'cg',
def from_sirius_json(sirius_json): """Create input provenance from sirius_json. Assuming quantities are given in atomic units! Returns structure (unit_cell, sites) and magnetization Keyword Arguments: sirius_json -- sirius_json (as dict) Returns: - StructureData - magnetization dictionary - kpoint """ sirius_unit_cell = sirius_json['unit_cell'] if 'lattice_vectors_scale' in sirius_unit_cell: lattice_vectors_scale = sirius_unit_cell['lattice_vectors_scale'] else: lattice_vectors_scale = 1 cell_angstrom = np.array(sirius_unit_cell['lattice_vectors'] ) * lattice_vectors_scale * bohr_to_ang magnetization = read_magnetization(sirius_unit_cell['atoms']) # get kpoints kpoints = KpointsData() if 'vk' in sirius_json['parameters']: kpoints.set_kpoints(sirius_json['parameters']['vk']) else: ngridk = sirius_json['parameters']['ngridk'] kpoints.set_kpoints_mesh(ngridk) structure = StructureData(cell=to_list(cell_angstrom)) if 'atom_coordinate_units' in sirius_unit_cell: if sirius_unit_cell['atom_coordinate_units'] in ['A', 'a.u.', 'au']: # atom positions are already given in angstrom, nothing to convert for atom_type in sirius_unit_cell['atoms']: for lposmag in sirius_unit_cell['atoms'][atom_type]: lpos = np.array(lposmag[:3]) if sirius_unit_cell['atom_coordinate_units'] in [ 'a.u.', 'au' ]: structure.append_atom(position=tuple(lpos * bohr_to_ang), symbols=atom_type) else: structure.append_atom(position=tuple(lpos), symbols=atom_type) else: raise ValueError('invalid entry for atom_coordinate_units') else: # atom positions are given in relative coordinates for atom_type in sirius_unit_cell['atoms']: for lposmag in sirius_unit_cell['atoms'][atom_type]: lpos = np.array(lposmag[:3]) apos = np.dot(cell_angstrom.T, lpos) structure.append_atom(position=tuple(apos), symbols=atom_type) return structure, magnetization, kpoints
from aiida.plugins import WorkflowFactory from aiida_wannier90.orbitals import generate_projections pw_code = load_code("<CODE LABEL>") # Replace with the QE pw.x code label wannier_code = load_code( "<CODE LABEL>") # Replace with the Wannier90 wannier.x code label pw2wannier90_code = load_code( "<CODE LABEL>") # Replace with the QE pw2wannier90.x code label pseudo_family_name = "<UPF FAMILY NAME>" # Replace with the name of the pseudopotential family for SSSP efficiency # GaAs structure a = 5.68018817933178 # angstrom structure = StructureData( cell=[[-a / 2., 0, a / 2.], [0, a / 2., a / 2.], [-a / 2., a / 2., 0]]) structure.append_atom(symbols=['Ga'], position=(0., 0., 0.)) structure.append_atom(symbols=['As'], position=(-a / 4., a / 4., a / 4.)) # 4x4x4 k-points mesh for the SCF kpoints_scf = KpointsData() kpoints_scf.set_kpoints_mesh([4, 4, 4]) # 10x10x10 k-points mesh for the NSCF/Wannier90 calculations kpoints_nscf = KpointsData() kpoints_nscf.set_kpoints_mesh([10, 10, 10]) # k-points path for the band structure kpoint_path = Dict( dict={ 'point_coords': { 'GAMMA': [0.0, 0.0, 0.0],