def define(cls, spec): super(PwBandsWorkChain, cls).define(spec) spec.input('code', valid_type=Code) spec.input('structure', valid_type=StructureData) spec.input('pseudo_family', valid_type=Str) spec.input('kpoints_distance', valid_type=Float, default=Float(0.2)) spec.input('kpoints_distance_bands', valid_type=Float, default=Float(0.2)) spec.input('kpoints', valid_type=KpointsData, required=False) spec.input('vdw_table', valid_type=SinglefileData, required=False) spec.input('parameters', valid_type=ParameterData) spec.input('settings', valid_type=ParameterData, required=False) spec.input('options', valid_type=ParameterData, required=False) spec.input('automatic_parallelization', valid_type=ParameterData, required=False) spec.input('group', valid_type=Str, required=False) spec.input_group('relax', required=False) spec.outline( cls.setup, cls.validate_inputs, if_(cls.should_do_relax)(cls.run_relax, ), cls.run_seekpath, cls.run_scf, cls.run_bands, cls.results, ) spec.output('primitive_structure', valid_type=StructureData) spec.output('seekpath_parameters', valid_type=ParameterData) spec.output('scf_parameters', valid_type=ParameterData) spec.output('band_parameters', valid_type=ParameterData) spec.output('band_structure', valid_type=BandsData)
def test_add(self): a = Float(4) b = Float(5) # Check adding two db Floats res = a + b self.assertIsInstance(res, NumericType) self.assertEqual(res, 9.0) # Check adding db Float and native (both ways) res = a + 5.0 self.assertIsInstance(res, NumericType) self.assertEqual(res, 9.0) res = 5.0 + a self.assertIsInstance(res, NumericType) self.assertEqual(res, 9.0) # Inplace a = Float(4) a += b self.assertEqual(a, 9.0) a = Float(4) a += 5 self.assertEqual(a, 9.0)
def define(cls, spec): super(OptimizeStructure, cls).define(spec) spec.input("structure", valid_type=StructureData) spec.input("es_settings", valid_type=ParameterData) # Optional spec.input("pressure", valid_type=Float, required=False, default=Float(0.0)) spec.input("tolerance_forces", valid_type=Float, required=False, default=Float(1e-5)) spec.input("tolerance_stress", valid_type=Float, required=False, default=Float(1e-2)) spec.input("max_iterations", valid_type=Int, required=False, default=Int(10)) spec.input("standarize_cell", valid_type=Bool, required=False, default=Bool(True)) spec.outline(cls.optimize_cycle, _While(cls.not_converged)(cls.optimize_cycle), cls.get_data)
def test_create(self): a = Float() # Check that initial value is zero self.assertEqual(a.value, 0.0) f = Float(6.0) self.assertEqual(f.value, 6.) self.assertEqual(f, Float(6.0)) i = Int() self.assertEqual(i.value, 0) i = Int(6) self.assertEqual(i.value, 6) self.assertEqual(f, i) b = Bool() self.assertEqual(b.value, False) b = Bool(False) self.assertEqual(b.value, False) self.assertEqual(b.value, get_false_node()) b = Bool(True) self.assertEqual(b.value, True) self.assertEqual(b.value, get_true_node()) s = Str() self.assertEqual(s.value, "") s = Str('Hello') self.assertEqual(s.value, 'Hello')
def test_mul(self): a = Float(4) b = Float(5) # Check adding two db Floats res = a * b self.assertIsInstance(res, NumericType) self.assertEqual(res, 20.0) # Check adding db Float and native (both ways) res = a * 5.0 self.assertIsInstance(res, NumericType) self.assertEqual(res, 20) res = 5.0 * a self.assertIsInstance(res, NumericType) self.assertEqual(res, 20.0) # Inplace a = Float(4) a *= b self.assertEqual(a, 20) a = Float(4) a *= 5 self.assertEqual(a, 20)
def run_bands(self): """ Run the PwBandsWorkChain to compute the band structure """ inputs = dict(self.ctx.inputs) options = inputs['options'] settings = inputs['settings'] parameters = inputs['parameters'] # Final input preparation, wrapping dictionaries in ParameterData nodes inputs['kpoints_mesh'] = self.ctx.kpoints_mesh inputs['parameters'] = ParameterData(dict=parameters) inputs['settings'] = ParameterData(dict=settings) inputs['options'] = ParameterData(dict=options) inputs['relax'] = { 'kpoints_distance': Float(self.ctx.protocol['kpoints_mesh_density']), 'parameters': ParameterData(dict=parameters), 'settings': ParameterData(dict=settings), 'options': ParameterData(dict=options), 'meta_convergence': Bool(False), 'relaxation_scheme': Str('vc-relax'), 'volume_convergence': Float(0.01) } running = self.submit(PwBandsWorkChain, **inputs) self.report('launching PwBandsWorkChain<{}>'.format(running.pk)) return ToContext(workchain_bands=running)
def define(cls, spec): super(GCMCMD2, cls).define(spec) # structure, adsorbant, pressures spec.input('structure', valid_type=CifData) spec.input("pressure", valid_type=Float, required=True) spec.input("number_runs", valid_type=Float, default=Float(1)) spec.input("number_cycles_lower", valid_type=Float, default=Float(1)) spec.input("number_cycles_upper", valid_type=Float, default=Float(100000)) # zeopp spec.input('zeopp_code', valid_type=Code) spec.input("_zeopp_options", valid_type=dict, default=None, required=False) spec.input("zeopp_probe_radius", valid_type=Float) spec.input("zeopp_atomic_radii", valid_type=SinglefileData, default=None, required=False) # raspa spec.input("raspa_code", valid_type=Code) spec.input("raspa_parameters_gcmc", valid_type=ParameterData) spec.input("raspa_parameters_md", valid_type=ParameterData) spec.input("raspa_parameters_gcmc_0", valid_type=ParameterData) spec.input("_raspa_options", valid_type=dict, default=None, required=False) # settings spec.input("_usecharges", valid_type=bool, default=True, required=False) # workflow spec.outline( cls.init, cls.run_zeopp, # computes volpo and block pockets cls.init_raspa_calc, # assign HeliumVoidFraction=POAV cls.run_first_gcmc, # first GCMC is longer and with intialization cls. parse_loading_raspa, # then move to loop in which one cycles between MD and MC while_(cls.should_run_loading_raspa)( cls.run_md, cls.parse_loading_raspa, cls. run_loading_raspa, # for each run, recover the last snapshot of the previous and run GCMC cls.parse_loading_raspa, ), cls.return_results, ) spec.dynamic_output()
def define(cls, spec): spec.input("structure", valid_type=StructureData) spec.input("start", valid_type=NumericType, default=Float(0.96)) spec.input("delta", valid_type=NumericType, default=Float(0.02)) spec.input("end", valid_type=NumericType, default=Float(1.04)) spec.input("code", valid_type=Str) spec.input("pseudo_family", valid_type=Str) spec.outline(cls.run_pw, cls.print_eos)
def define(cls, spec): super(GruneisenPhonopy, cls).define(spec) spec.input("structure", valid_type=StructureData) spec.input("ph_settings", valid_type=ParameterData) spec.input("es_settings", valid_type=ParameterData) # Optional arguments spec.input("pressure", valid_type=Float, required=False, default=Float(0.0)) # in kB spec.input("stress_displacement", valid_type=Float, required=False, default=Float(2.0)) # in kB spec.input("use_nac", valid_type=Bool, required=False, default=Bool(False)) spec.outline(cls.create_unit_cell_expansions, cls.calculate_gruneisen)
def submit_jobs(self): print("structure PK: %i" % self.inputs.structure.pk) grp, created = Group.get_or_create(name=self.inputs.group) grp.add_nodes([self.calc]) print("stress tensor PK: %i" % self.calc.pk) # get calculation class C = CalculationFactory(self.inputs.code.get_input_plugin_name()) Proc = C.process() num_points = 5 # volume scales from 0.94 to 1.06, alat scales as pow(1/3) scales = numpy.linspace(0.94**(1 / 3.0), 1.06**(1 / 3.0), num_points).tolist() calcs = {} for scale in scales: print("scale = %f" % scale) # scaled structure new_structure = scaled_structure(self.inputs.structure, Float(scale)) # basic parameters of the calculation params = calculation_helpers.create_calculation_parameters( self.inputs.code, str(self.inputs.partition), int(self.inputs.ranks_per_node), int(self.inputs.ranks_kp), int(self.inputs.ranks_diag)) inputs = Proc.get_inputs_template() inputs.code = self.inputs.code inputs._options.resources = params['calculation_resources'] inputs._options.max_wallclock_seconds = 20 * 60 inputs._options.custom_scheduler_commands = params[ 'custom_scheduler_commands'] inputs._options.environment_variables = params[ 'environment_variables'] inputs._options.mpirun_extra_params = params['mpirun_extra_params'] inputs.structure = new_structure inputs.kpoints = KpointsData() inputs.kpoints.set_kpoints_mesh(self.inputs.kmesh, offset=(0.0, 0.0, 0.0)) inputs.parameters = params['calculation_parameters'] inputs.settings = params['calculation_settings'] if self.inputs.code.get_input_plugin_name( ) == 'quantumespresso.pw': inputs.pseudo = get_pseudos(new_structure, self.inputs.atomic_files) if self.inputs.code.get_input_plugin_name() == 'exciting.exciting': inputs.lapwbasis = get_lapwbasis(new_structure, self.inputs.atomic_files) future = submit(Proc, **inputs)
def test_identifier_sub_classes(self): """ The sub_classes keyword argument should allow to narrow the scope of the query based on the orm class """ node_bool = Bool(True).store() node_float = Float(0.0).store() node_int = Int(1).store() param_type_normal = NodeParamType() param_type_scoped = NodeParamType(sub_classes=('aiida.data:bool', 'aiida.data:float')) # For the base NodeParamType all node types should be matched self.assertEquals( param_type_normal.convert(str(node_bool.pk), None, None).uuid, node_bool.uuid) self.assertEquals( param_type_normal.convert(str(node_float.pk), None, None).uuid, node_float.uuid) self.assertEquals( param_type_normal.convert(str(node_int.pk), None, None).uuid, node_int.uuid) # The scoped NodeParamType should only match Bool and Float self.assertEquals( param_type_scoped.convert(str(node_bool.pk), None, None).uuid, node_bool.uuid) self.assertEquals( param_type_scoped.convert(str(node_float.pk), None, None).uuid, node_float.uuid) # The Int should not be found and raise with self.assertRaises(click.BadParameter): param_type_scoped.convert(str(node_int.pk), None, None).uuid, node_int.uuid
def define(cls, spec): super(SelfConsistentHubbardWorkChain, cls).define(spec) spec.input('structure', valid_type=StructureData) spec.input('hubbard_u', valid_type=ParameterData) spec.input('tolerance', valid_type=Float, default=Float(0.1)) spec.input('max_iterations', valid_type=Int, default=Int(5)) spec.input('is_insulator', valid_type=Bool, required=False) spec.input('meta_convergence', valid_type=Bool, default=Bool(False)) spec.expose_inputs(PwBaseWorkChain, namespace='scf', exclude=('structure')) spec.expose_inputs(HpWorkChain, namespace='hp', exclude=('parent_calculation')) spec.outline( cls.setup, cls.validate_inputs, if_(cls.should_run_recon)( cls.run_recon, cls.inspect_recon, ), while_(cls.should_run_iteration)( if_(cls.should_run_relax)( cls.run_relax, cls.inspect_relax, ), if_(cls.is_metal)(cls.run_scf_smearing).elif_(cls.is_magnetic)( cls.run_scf_smearing, cls.run_scf_fixed_magnetic).else_(cls.run_scf_fixed), cls.run_hp, cls.inspect_hp, ), cls.run_results, )
def run_eos_wf(codename, pseudo_family, element): print "Workfunction node identifiers: {}".format(Process.current().calc) s0 = create_diamond_fcc(Str(element)) calcs = {} for label, factor in zip(labels, scale_facs): s = rescale(s0, Float(factor)) inputs = generate_scf_input_params(s, str(codename), Str(pseudo_family)) print "Running a scf for {} with scale factor {}".format( element, factor) result = run(PwCalculation, **inputs) print "RESULT: {}".format(result) calcs[label] = get_info(result) eos = [] for label in labels: eos.append(calcs[label]) # Return information to plot the EOS ParameterData = DataFactory('parameter') retdict = { 'initial_structure': s0, 'result': ParameterData(dict={'eos_data': eos}) } return retdict
def calc_energies(codename, pseudo_family): print("Calculating energies, my pk is '{}'".format( ProcessStack.get_active_process_id())) futures = {} for element, scale in [("Si", 5.41)]: structure = create_diamond_fcc(Str(element), Float(1.)) structure = rescale(structure, Float(scale)) print("Running {} scf calculation.".format(element)) futures[element] = async(run_scf, structure, codename, pseudo_family) print("Waiting for calculations to finish.") outs = {element: Float(future.result()['output_parameters'].dict.energy) for element, future in futures.iteritems()} print("Calculations finished.") return outs
def _run_loading_raspa(self): """Perform raspa calculation at given pressure. Most of the runtime will be spent in this function. """ # Create the input dictionary inputs = { 'code': self.inputs.raspa_code, 'structure': self.inputs.structure, 'parameters': update_raspa_parameters(self.inputs.raspa_parameters, Float(self.ctx.current_pressure)), 'block_component_0': self.ctx.zeopp['block'], '_options': self.ctx.options, } # Create the calculation process and launch it process = RaspaCalculation.process() future = submit(process, **inputs) self.report("pk: {} | Running raspa for the pressure {} [bar]".format( future.pid, self.ctx.current_pressure / 1e5)) return ToContext(raspa=Outputs(future))
def create_unit_cell_expansions(self): print('start Gruneisen (pk={})'.format(self.pid)) print('start create cell expansions') # For testing testing = False if testing: self.ctx._content['plus'] = load_node(13603) self.ctx._content['origin'] = load_node(13600) self.ctx._content['minus'] = load_node(13606) return calcs = {} for expansions in {'plus': float(self.inputs.pressure) + float(self.inputs.stress_displacement), 'origin': float(self.inputs.pressure), 'minus': float(self.inputs.pressure) - float(self.inputs.stress_displacement)}.items(): future = submit(PhononPhonopy, structure=self.inputs.structure, ph_settings=self.inputs.ph_settings, es_settings=self.inputs.es_settings, pressure=Float(expansions[1]), optimize=Bool(True), use_nac=self.inputs.use_nac ) calcs[expansions[0]] = future print ('phonon workchain: {} {}'.format(expansions[0], future.pid)) return ToContext(**calcs)
def define(cls, spec): super(Cp2kGeoOptDdecWorkChain, cls).define(spec) # structure, adsorbant, pressures spec.input('structure', valid_type=StructureData) spec.input("min_cell_size", valid_type=Float, default=Float(10)) # cp2k spec.input('cp2k_code', valid_type=Code) spec.input('cp2k_parameters', valid_type=ParameterData, default=ParameterData(dict={})) spec.input("_cp2k_options", valid_type=dict, default=None, required=False) spec.input('cp2k_parent_folder', valid_type=RemoteData, default=None, required=False) # ddec spec.input('ddec_code', valid_type=Code) spec.input("_ddec_options", valid_type=dict, default=None, required=False) # settings spec.input('_guess_multiplicity', valid_type=bool, default=False) # workflow spec.outline( cls.run_geo_opt, #robust 5 stesps cellopt, first expands the uc according to min_cell_size cls.parse_geo_opt, cls.run_point_charges, # wfn > (E_DENSITY & core_el) > DDEC charges cls.parse_point_charges, cls.return_results, ) # specify the outputs of the workchain spec.output('output_structure', valid_type=CifData, required=False)
def get_structure(original_structure, new_volume): """ Given a structure and a new volume, rescale the structure to the new volume """ initial_volume = original_structure.get_cell_volume() scale_factor = (new_volume / initial_volume)**(1. / 3.) scaled_structure = rescale(original_structure, Float(scale_factor)) return scaled_structure
def run_eos(structure, element="Si", code='qe-pw-6.2.1@localhost', pseudo_family='GBRV_lda'): return run(PressureConvergence, structure=structure, code=Str(code), pseudo_family=Str(pseudo_family), volume_tolerance=Float(0.1))
def define(cls, spec): super(ThermalPhono3py, cls).define(spec) spec.input("structure", valid_type=StructureData) spec.input("ph_settings", valid_type=ParameterData) spec.input("es_settings", valid_type=ParameterData) # Optional arguments spec.input("optimize", valid_type=Bool, required=False, default=Bool(True)) spec.input("pressure", valid_type=Float, required=False, default=Float(0.0)) spec.input("use_nac", valid_type=Bool, required=False, default=Bool(False)) spec.input("chunks", valid_type=Int, required=False, default=Int(100)) spec.input("step", valid_type=Float, required=False, default=Float(1.0)) spec.input("initial_cutoff", valid_type=Float, required=False, default=Float(2.0)) spec.input("gp_chunks", valid_type=Int, required=False, default=Int(1)) # Convergence criteria spec.input("rtol", valid_type=Float, required=False, default=Float(0.3)) spec.input("atol", valid_type=Float, required=False, default=Float(0.1)) spec.outline( cls.harmonic_calculation, _While(cls.not_converged)(cls.get_data_sets, cls.get_thermal_conductivity), cls.collect_data)
def define(cls, spec): super(PhononPhono3py, cls).define(spec) spec.input("structure", valid_type=StructureData) spec.input("ph_settings", valid_type=ParameterData) spec.input("es_settings", valid_type=ParameterData) # Optional arguments spec.input("optimize", valid_type=Bool, required=False, default=Bool(True)) spec.input("pressure", valid_type=Float, required=False, default=Float(0.0)) spec.input("use_nac", valid_type=Bool, required=False, default=Bool(False)) # false by default spec.input("calculate_fc", valid_type=Bool, required=False, default=Bool(False)) # false by default spec.input("chunks", valid_type=Int, required=False, default=Int(100)) spec.input("cutoff", valid_type=Float, required=False, default=Float(0)) spec.input("recover", required=False, default=Bool(False)) # temporal patch spec.input("data_sets", required=False, default=Bool(False)) spec.outline(_If(cls.use_optimize)(cls.optimize), # cls.create_displacement_calculations, _While(cls.continue_submitting)(cls.create_displacement_calculations_chunk), cls.collect_data, _If(cls.calculate_fc)(cls.calculate_force_constants))
def eos(structure, codename, pseudo_family): Proc = PwCalculation.process() results = {} for s in (0.98, 0.99, 1.0, 1.02, 1.04): rescaled = rescale(structure, Float(s)) inputs = generate_scf_input_params(rescaled, codename, pseudo_family) outputs = run(Proc, **inputs) res = outputs['output_parameters'].dict results[str(s)] = res return results
def main(): inputs = {'a': Float(3.14), 'b': Int(4), 'c': Int(6)} results = run(SumWorkChain, **inputs) print 'Result of SumWorkChain: {}'.format(results) results = run(ProductWorkChain, **inputs) print 'Result of ProductWorkChain: {}'.format(results) results = run(SumProductWorkChain, **inputs) print 'Result of SumProductWorkChain: {}'.format(results)
def run_wf(): print "Workfunction node identifiers: {}".format(ProcessRegistry().current_calc_node) #Instantiate a JobCalc process and create basic structure JobCalc = SiestaCalculation.process() s0 = create_structure() calcs = {} for label, factor in zip(labels, scale_facs): s = rescale(s0,Float(factor)) inputs = geninputs(s) print "Running a scf for Si with scale factor {}".format(factor) # result = run(JobCalc,**inputs) result = async(JobCalc,**inputs)
def launch(code, structure, pseudo_family, kpoints, max_num_machines, max_wallclock_seconds, daemon, automatic_parallelization): """ Run the PwBandsWorkChain for a given input structure """ from aiida.orm.data.base import Bool, Float, Str from aiida.orm.data.parameter import ParameterData from aiida.orm.utils import WorkflowFactory from aiida.work.run import run, submit from aiida_quantumespresso.utils.resources import get_default_options PwBandsWorkChain = WorkflowFactory('quantumespresso.pw.bands') parameters = { 'SYSTEM': { 'ecutwfc': 30., 'ecutrho': 240., }, } relax_inputs = { 'kpoints_distance': Float(0.2), 'parameters': ParameterData(dict=parameters), } inputs = { 'code': code, 'structure': structure, 'pseudo_family': Str(pseudo_family), 'kpoints': kpoints, 'parameters': ParameterData(dict=parameters), 'relax': relax_inputs, } if automatic_parallelization: parallelization = { 'max_num_machines': max_num_machines, 'target_time_seconds': 0.5 * max_wallclock_seconds, 'max_wallclock_seconds': max_wallclock_seconds } inputs['automatic_parallelization'] = ParameterData( dict=parallelization) else: options = get_default_options(max_num_machines, max_wallclock_seconds) inputs['options'] = ParameterData(dict=options) if daemon: workchain = submit(PwBandsWorkChain, **inputs) click.echo('Submitted {}<{}> to the daemon'.format( PwBandsWorkChain.__name__, workchain.pid)) else: run(PwBandsWorkChain, **inputs)
def main(): a = Float(3.14) b = Int(4) c = Int(6) results = sum(a, b) print 'Result of sum: {}'.format(results) results = product(a, b) print 'Result of product: {}'.format(results) results = sumproduct(a, b, c) print 'Result of sumproduct: {}'.format(results)
def to_db_type(value): if isinstance(value, Data): return value elif isinstance(value, bool): return Bool(value) elif isinstance(value, (int, long)): return Int(value) elif isinstance(value, float): return Float(value) elif isinstance(value, basestring): return Str(value) else: raise ValueError("Cannot convert value to database type")
def test_operator(self): a = Float(2.2) b = Int(3) for op in [ operator.add, operator.mul, operator.pow, operator.lt, operator.le, operator.gt, operator.ge, operator.iadd, operator.imul ]: for x, y in [(a, b), (b, a)]: c = op(x, y) c_val = op(x.value, y.value) self.assertEqual(c._type, type(c_val)) self.assertEqual(c, op(x.value, y.value))
def define(cls, spec): super(DFTGeoOptWorkChain, cls).define(spec) spec.input("cp2k_code", valid_type=Code) spec.input("structure", valid_type=StructureData) spec.input("max_force", valid_type=Float, default=Float(0.001)) spec.input("vdw_switch", valid_type=Bool, default=Bool(False)) spec.input("mgrid_cutoff", valid_type=Int, default=Int(600)) spec.input("fixed_atoms", valid_type=Str, default=Str('')) spec.outline( cls.run_geopt, while_(cls.not_converged)(cls.run_geopt_again), ) spec.dynamic_output()
def get_gruneisen_prediction(self): print('start qha (pk={})'.format(self.pid)) if __testing__: self.ctx._content['gruneisen'] = load_node(19945) return future = submit(GruneisenPhonopy, structure=self.inputs.structure, ph_settings=self.inputs.ph_settings, es_settings=self.inputs.es_settings, pressure=Float(0.0), use_nac=self.inputs.use_nac) print('gruneisen workchain: {}'.format(future.pid)) return ToContext(gruneisen=future)