from aiida.orm import Dict
from aiida.orm.nodes.data.array import ArrayData
from aiida.orm import Int, Float, Str, Bool, List
from aiida.orm import SinglefileData
from aiida.orm import RemoteData
from aiida.orm import Code
from aiida.engine import WorkChain, ToContext, while_
from aiida.engine import submit
from aiida_cp2k.calculations import Cp2kCalculation
from apps.scanning_probe import common
from aiida.plugins import CalculationFactory
OverlapCalculation = CalculationFactory('spm.overlap')
import os
import tempfile
import shutil
import numpy as np
import copy
class PdosWorkChain(WorkChain):
@classmethod
def define(cls, spec):
super(PdosWorkChain, cls).define(spec)
spec.input("cp2k_code", valid_type=Code)
spec.input("slabsys_structure", valid_type=StructureData)
from __future__ import print_function
from __future__ import absolute_import
import ase.io
import numpy as np
import sys
import click
import matplotlib.pyplot as plt
from aiida.engine import run, run_get_node
from aiida.orm import Code, Dict, Int, Float, Bool, StructureData, List
from aiida.common import NotExistent
from aiida.plugins import CalculationFactory, WorkflowFactory
GaussianCalculation = CalculationFactory('gaussian')
GaussianCubesWorkChain = WorkflowFactory('gaussian.cubes')
def example(gaussian_code, formchk_code, cubegen_code):
# geometry
ase_geom = ase.io.read("./p-quinodimethane.xyz")
ase_geom.cell = np.diag([10.0, 10.0, 10.0])
struct_node = StructureData(ase=ase_geom)
# Run Gaussian calculation
num_cores = 2
memory_mb = 500
builder = GaussianCalculation.get_builder()
# -*- coding: utf-8 -*-
"""Workchain to run a Quantum ESPRESSO pw.x calculation with automated error handling and restarts."""
from aiida import orm
from aiida.common import AttributeDict, exceptions
from aiida.engine import ToContext, if_, while_, BaseRestartWorkChain, process_handler, ProcessHandlerReport, ExitCode
from aiida.plugins import CalculationFactory
from aiida_quantumespresso.calculations.functions.create_kpoints_from_distance import create_kpoints_from_distance
from aiida_quantumespresso.utils.defaults.calculation import pw as qe_defaults
from aiida_quantumespresso.utils.mapping import update_mapping, prepare_process_inputs
from aiida_quantumespresso.utils.pseudopotential import validate_and_prepare_pseudos_inputs
from aiida_quantumespresso.utils.resources import get_default_options, get_pw_parallelization_parameters
from aiida_quantumespresso.utils.resources import cmdline_remove_npools, create_scheduler_resources
PwCalculation = CalculationFactory('quantumespresso.pw')
class PwBaseWorkChain(BaseRestartWorkChain):
"""Workchain to run a Quantum ESPRESSO pw.x calculation with automated error handling and restarts."""
# pylint: disable=too-many-public-methods
_process_class = PwCalculation
defaults = AttributeDict({
'qe': qe_defaults,
'delta_threshold_degauss': 30,
'delta_factor_degauss': 0.1,
'delta_factor_mixing_beta': 0.8,
'delta_factor_max_seconds': 0.95,
'delta_factor_nbnd': 0.05,
# -*- coding: utf-8 -*-
"""Base work chain to run a CP2K calculation."""
from aiida.common import AttributeDict
from aiida.engine import BaseRestartWorkChain, ExitCode, ProcessHandlerReport, process_handler, while_
from aiida.orm import Dict
from aiida.plugins import CalculationFactory
from ..utils import add_restart_sections
Cp2kCalculation = CalculationFactory('cp2k') # pylint: disable=invalid-name
class Cp2kBaseWorkChain(BaseRestartWorkChain):
"""Workchain to run a CP2K calculation with automated error handling and restarts."""
_process_class = Cp2kCalculation
@classmethod
def define(cls, spec):
# yapf: disable
super(Cp2kBaseWorkChain, cls).define(spec)
spec.expose_inputs(Cp2kCalculation, namespace='cp2k')
spec.outline(
cls.setup,
while_(cls.should_run_process)(
cls.run_process,
cls.inspect_process,
cls.overwrite_input_structure,
),
def create_builder_from_file(input_folder,
input_file_name,
code,
metadata,
pseudo_folder_path=None):
"""Create a populated process builder for a `PwCalculation` from a standard QE input file and pseudo (upf) files.
:param input_folder: the folder containing the input file
:type input_folder: aiida.common.folders.Folder or str
:param input_file_name: the name of the input file
:type input_file_name: str
:param code: the code associated with the calculation
:type code: aiida.orm.Code or str
:param metadata: metadata values for the calculation (e.g. resources)
:type metadata: dict
:param pseudo_folder_path: the folder containing the upf files (if None, then input_folder is used)
:type pseudo_folder_path: aiida.common.folders.Folder or str or None
:raises NotImplementedError: if the structure is not ibrav=0
:return: a builder instance for PwCalculation
"""
PwCalculation = CalculationFactory('quantumespresso.pw')
builder = PwCalculation.get_builder()
builder.metadata = metadata
if isinstance(code, str):
code = Code.get_from_string(code)
builder.code = code
# read input_file
if isinstance(input_folder, str):
input_folder = Folder(input_folder)
with input_folder.open(input_file_name) as input_file:
parsed_file = PwInputFile(input_file.read())
builder.structure = parsed_file.get_structuredata()
builder.kpoints = parsed_file.get_kpointsdata()
# Then, strip the namelist items that the plugin doesn't allow or sets later.
# NOTE: If any of the position or cell units are in alat or crystal
# units, that will be taken care of by the input parsing tools, and
# we are safe to fake that they were never there in the first place.
parameters_dict = copy.deepcopy(parsed_file.namelists)
for namelist, blocked_key in PwCalculation._blocked_keywords: # pylint: disable=protected-access
for key in list(parameters_dict[namelist].keys()):
# take into account that celldm and celldm(*) must be blocked
if re.sub('[(0-9)]', '', key) == blocked_key:
parameters_dict[namelist].pop(key, None)
builder.parameters = Dict(dict=parameters_dict)
# Get or create a UpfData node for the pseudopotentials used for the calculation.
pseudos_map = {}
if pseudo_folder_path is None:
pseudo_folder_path = input_folder
if isinstance(pseudo_folder_path, str):
pseudo_folder_path = Folder(pseudo_folder_path)
names = parsed_file.atomic_species['names']
pseudo_file_names = parsed_file.atomic_species['pseudo_file_names']
pseudo_file_map = {}
for name, fname in zip(names, pseudo_file_names):
if fname not in pseudo_file_map:
local_path = pseudo_folder_path.get_abs_path(fname)
with open(local_path, 'rb') as handle:
upf = UpfData(handle)
pseudo_file_map[fname] = upf
pseudos_map[name] = pseudo_file_map[fname]
builder.pseudos = pseudos_map
settings_dict = {}
if parsed_file.k_points['type'] == 'gamma':
settings_dict['gamma_only'] = True
# If there are any fixed coordinates (i.e. force modification) present in the input file, specify in settings
fixed_coords = parsed_file.atomic_positions['fixed_coords']
# Function ``any()`` only works for 1-dimensional lists so we have to call it twice manually.
if any((any(fc_xyz) for fc_xyz in fixed_coords)):
settings_dict['FIXED_COORDS'] = fixed_coords
if settings_dict:
builder.settings = settings_dict
return builder
# -*- coding: utf-8 -*-
"""AiiDA DDEC plugin parser"""
from __future__ import absolute_import
import os
from aiida.parsers.parser import Parser
from aiida.common import NotExistent, OutputParsingError
from aiida.engine import ExitCode
from aiida.plugins import CalculationFactory
from aiida_ddec.utils import xyz2cif
DdecCalculation = CalculationFactory('ddec') # pylint: disable=invalid-name
class DdecParser(Parser):
"""
Parser class for parsing output of multiplication.
"""
# pylint: disable=protected-access
def parse(self, **kwargs):
"""Parse output structur, store it in database in CifData format."""
# Check that the retrieved folder is there
try:
out_folder = self.retrieved
except NotExistent:
self.logger.error('No retrieved folder found')
return self.exit_codes.ERROR_NO_RETRIEVED_FOLDER
# Check what is inside the folder
list_of_files = out_folder._repository.list_object_names() # pylint: disable=protected-access
def launch_calculation(code, structures, num_images, num_steps, pseudo_family,
kpoints_mesh, ecutwfc, ecutrho, smearing,
max_num_machines, max_wallclock_seconds, with_mpi,
daemon, parent_folder, dry_run):
"""Run a NebCalculation.
Note that some parameters are hardcoded.
"""
from aiida.orm import Dict
from aiida.plugins import CalculationFactory
from aiida_quantumespresso.utils.resources import get_default_options
cutoff_wfc, cutoff_rho = pseudo_family.get_recommended_cutoffs(
structure=structures[0], unit='Ry')
pw_parameters = {
'CONTROL': {
'calculation': 'relax',
},
'SYSTEM': {
'ecutwfc': ecutwfc or cutoff_wfc,
'ecutrho': ecutrho or cutoff_rho
}
}
neb_parameters = {
'PATH': {
'restart_mode': ('restart' if parent_folder else 'from_scratch'),
'opt_scheme': 'broyden',
'num_of_images': num_images,
'nstep_path': num_steps,
},
}
try:
validate.validate_smearing(pw_parameters, smearing)
except ValueError as exception:
raise click.BadParameter(str(exception))
inputs = {
'code': code,
'first_structure': structures[0],
'last_structure': structures[1],
'pw': {
'pseudos': pseudo_family.get_pseudos(structure=structures[0]),
'kpoints': kpoints_mesh,
'parameters': Dict(dict=pw_parameters),
},
'parameters': Dict(dict=neb_parameters),
'metadata': {
'options':
get_default_options(max_num_machines, max_wallclock_seconds,
with_mpi),
}
}
if parent_folder:
inputs['parent_folder'] = parent_folder
if dry_run:
if daemon:
# .submit() would forward to .run(), but it's better to stop here,
# since it's a bit unexpected and the log messages output to screen
# would be confusing ("Submitted NebCalculation<None> to the daemon")
raise click.BadParameter(
'cannot send to the daemon if in dry_run mode',
param_hint='--daemon')
inputs['metadata']['store_provenance'] = False
inputs['metadata']['dry_run'] = True
launch.launch_process(CalculationFactory('quantumespresso.neb'), daemon,
**inputs)
# -*- coding: utf-8 -*-
"""Workchain to compute the DOS for a given structure using Quantum ESPRESSO pw.x."""
from aiida import orm
from aiida.common import AttributeDict
from aiida.plugins import WorkflowFactory, CalculationFactory
from aiida.engine import WorkChain, ToContext, if_
from aiida_quantumespresso.utils.mapping import prepare_process_inputs
from aiida_quantumespresso.calculations.functions.create_kpoints_from_distance import create_kpoints_from_distance
from .kpoint_grids import kpt_crop, mergeXyData
PwBaseWorkChain = WorkflowFactory('quantumespresso.pw.base')
DosCalc = CalculationFactory('quantumespresso.dos')
class DosWorkChain(WorkChain):
"""Workchain to compute a DOS for a given structure using Quantum ESPRESSO pw.x. """
@classmethod
def define(cls, spec):
"""Define the process specification."""
# yapf: disable
super().define(spec)
# spec.expose_inputs(PwRelaxWorkChain, namespace='relax', exclude=('clean_workdir', 'structure'),
# namespace_options={'required': False, 'populate_defaults': False,
# 'help': 'Inputs for the `PwRelaxWorkChain`, if not specified at all, the relaxation step is skipped.'})
spec.expose_inputs(PwBaseWorkChain, namespace='scf',
exclude=('clean_workdir', 'pw.structure'),
namespace_options={'help': 'Inputs for the `PwBaseWorkChain` for the SCF calculation.'})
spec.expose_inputs(PwBaseWorkChain, namespace='nscf',
exclude=('clean_workdir', 'pw.structure'),