From de0982414c1f702990b04502008e131e9b4cf857 Mon Sep 17 00:00:00 2001 From: Ury Date: Fri, 23 Feb 2024 15:46:09 -0800 Subject: [PATCH 01/53] mobility fitting module using espei for parameter generation and mcmc --- kawin/mobility_fitting/__init__.py | 1 + kawin/mobility_fitting/cached_mobility.py | 133 ++++++ kawin/mobility_fitting/fitting_steps.py | 163 +++++++ kawin/mobility_fitting/generate.py | 123 ++++++ .../interdiffusivity_error.py | 197 +++++++++ .../tracer_diffusivity_error.py | 396 ++++++++++++++++++ kawin/mobility_fitting/utils.py | 48 +++ kawin/thermo/Mobility.py | 91 +++- 8 files changed, 1151 insertions(+), 1 deletion(-) create mode 100644 kawin/mobility_fitting/__init__.py create mode 100644 kawin/mobility_fitting/cached_mobility.py create mode 100644 kawin/mobility_fitting/fitting_steps.py create mode 100644 kawin/mobility_fitting/generate.py create mode 100644 kawin/mobility_fitting/interdiffusivity_error.py create mode 100644 kawin/mobility_fitting/tracer_diffusivity_error.py create mode 100644 kawin/mobility_fitting/utils.py diff --git a/kawin/mobility_fitting/__init__.py b/kawin/mobility_fitting/__init__.py new file mode 100644 index 0000000..02f357f --- /dev/null +++ b/kawin/mobility_fitting/__init__.py @@ -0,0 +1 @@ +from .generate import fit_mobility \ No newline at end of file diff --git a/kawin/mobility_fitting/cached_mobility.py b/kawin/mobility_fitting/cached_mobility.py new file mode 100644 index 0000000..8416209 --- /dev/null +++ b/kawin/mobility_fitting/cached_mobility.py @@ -0,0 +1,133 @@ +import numpy as np +from pycalphad.core.utils import extract_parameters +from pycalphad import variables as v + +interstitials = ['C', 'N', 'O', 'H', 'B'] + +# ------------------------------------------------------------------ +# For ESPEI assessments +# Quick compute functions using serializable composition set data +# The CompositionSet object itself doesn't appear serializable +# So this will take in data such as dof or elements, which are serializable +# If assessing only mobility parameters, then the thermodynamic factor will be constant for each data point +# Thus, we can cache all the thermodynamic factors and use them to compute mobility without having to compute equilibrium each time +# ------------------------------------------------------------------ +def mobility_from_composition_set_quick(dof, elements, mobility_callables = None, mobility_correction = None, parameters = {}): + if mobility_callables is None: + raise ValueError('mobility_callables is required') + + #Set mobility correction if not set + if mobility_correction is None: + mobility_correction = {A: 1 for A in elements} + else: + for A in elements: + if A not in mobility_correction: + mobility_correction[A] = 1 + + #return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](composition_set.dof) for A in range(len(elements))]) + param_keys, param_values = extract_parameters(parameters) + if len(param_values) > 0: + callableInput = np.concatenate((dof, param_values[0]), dtype=np.float_) + else: + callableInput = dof + return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](callableInput) for A in range(len(elements))]) + +def compute_symbolic_quick(dof, elements, mobility_model, symbol, parameters = {}): + param_keys, param_values = extract_parameters(parameters) + + symbols = sorted([v.T, v.P, v.N, v.GE]) + mobility_model.site_fractions + var_dict = {s:val for s,val in zip(symbols, np.array(dof))} + if len(param_keys) > 0: + for p,val in zip(param_keys, param_values[0]): + var_dict[p] = val + + return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))]) + +def mobility_from_composition_set_symbolic_quick(dof, elements, mobility_model, parameters = {}): + return compute_symbolic_quick(dof, elements, mobility_model, 'MQ', parameters) + +def activation_energy_from_composition_set_quick(dof, elements, mobility_model, parameters = {}): + return compute_symbolic_quick(dof, elements, mobility_model, 'MQa', parameters) + +def prefactor_from_composition_set_quick(dof, elements, mobility_model, parameters = {}): + return compute_symbolic_quick(dof, elements, mobility_model, 'lnM0', parameters) + +def tracer_diffusivity_quick(T, mob_from_CS): + R = 8.314 + return R * T * mob_from_CS + +def mobility_matrix_quick(dof, composition, elements, mob_from_CS, phase_record): + X = composition + Usum = np.sum([X[A] for A in range(len(elements)) if elements[A] not in interstitials]) + U = X / Usum + + mob = np.array([U[A] * mob_from_CS[A] for A in range(len(elements))]) + + #Find vacancy site fractions for multiplying with interstitials when making the mobility matrix + #If vacancies are not found on the same sublattice, we'll defualt to 1 so there's at least some mobility and not 0 + # A mobility of 0 would be quite unrealistic + # In addition, as we're working with interstitals, the vacancies are going to be close to 1, so this assumption wouldn't hurt + vaTerms = {} #Maps sublattice index to site fraction index for vacancies + interstitialTerms = {} #Maps interstitial to sublattice index + index = len(phase_record.state_variables) + for i in range(len(phase_record.variables)): + if phase_record.variables[i].species.name == 'VA': + vaTerms[phase_record.variables[i].sublattice_index] = dof[index+i] + if phase_record.variables[i].species.name in interstitials: + interstitialTerms[phase_record.variables[i].species.name] = phase_record.variables[i].sublattice_index + + mobMatrix = np.zeros((len(elements), len(elements))) + for a in range(len(elements)): + if elements[a] in interstitials: + mobMatrix[a, a] = vaTerms.get(interstitialTerms[elements[a]], 1) * mob[a] + else: + for b in range(len(elements)): + if elements[b] not in interstitials: + if a == b: + mobMatrix[a, b] = (1 - U[a]) * mob[b] + else: + mobMatrix[a, b] = -U[a] * mob[b] + mobMatrix *= Usum + + #for a in range(len(elements)): + # for b in range(len(elements)): + # if a == b: + # mobMatrix[a, b] = (1 - U[a]) * mob[b] + # else: + # mobMatrix[a, b] = -U[a] * mob[b] + + return mobMatrix + +def chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian = False): + Dkj = np.matmul(mobMatrix, dmudx) + + if returnHessian: + return Dkj, dmudx + else: + return Dkj, None + +def interdiffusivity_quick(dmudx, mobMatrix, elements, refElement, mobility_callables = None, mobility_correction = None, returnHessian = False, parameters = {}): + Dkj, hessian = chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian) + + refIndex = 0 + for a in range(len(elements)): + if elements[a] == refElement: + refIndex = a + break + + Dnkj = np.zeros((len(elements) - 1, len(elements) - 1)) + c = 0 + d = 0 + for a in range(len(elements)): + if a != refIndex: + for b in range(len(elements)): + if b != refIndex: + if elements[b] in interstitials: + Dnkj[c, d] = Dkj[a, b] + else: + Dnkj[c, d] = Dkj[a, b] - Dkj[a, refIndex] + d += 1 + c += 1 + d = 0 + + return Dnkj, hessian \ No newline at end of file diff --git a/kawin/mobility_fitting/fitting_steps.py b/kawin/mobility_fitting/fitting_steps.py new file mode 100644 index 0000000..7011c67 --- /dev/null +++ b/kawin/mobility_fitting/fitting_steps.py @@ -0,0 +1,163 @@ +from espei.parameter_selection.fitting_steps import AbstractLinearPropertyStep, FittingStep +from pycalphad import Model, variables as v +import numpy as np +import symengine +from typing import Optional, Dict, Any +from numpy.typing import ArrayLike +from espei.utils import build_sitefractions +import itertools + +Dataset = Dict[str, Any] + +''' +Fitting steps for Mobility models from tracer diffusivity data + +Tracer diffusivity can be defined as D* = D0*exp(-Q/RT) + Where D0 is a pre-factor term (m/s^2) and Q is the activation energy (J/mol) + +Mobility is related to tracer diffusivity by: + D* = RTM = RT*(1/RT exp(MQ/RT)) = exp(MQ/RT) + Where MQ is a Redlich-Kister polynomial + +Option 1: Fit mobility to activation energy and pre-factor + D* = D0 exp(-Q/RT) = exp(MQ/RT) + ln(D0) + -Q/RT = MQ/RT + RT ln(D0) - Q = MQ + + Then: + R ln(D0) = dMQ/dT + -Q = MQ - T dMQ/dT + + Some pre-processing of tracer diffusivity data is required to have input files for both + activation energy and the pre-factor term, but this gives a better model fit + +Option 2: Fit mobility directly to tracer diffusivity + D* = exp(MQ/RT) + RT ln(D*) = MQ + + Then we could fit MQ as a linear model where each RK term is in the form of A+B*T + NOTE: This method is not recommended since it can lead to overfitting +''' + +class StepD0(FittingStep): + supported_reference_states: [str] = [""] + features: [symengine.Expr] = [v.T] + + @staticmethod + def transform_data(d: ArrayLike, model: Optional[Model] = None) -> ArrayLike: # np.object_ + return np.array([symengine.log(di)*v.R for di in d]) + + @classmethod + def transform_feature(cls, expr: symengine.Expr, model: Optional[Model] = None) -> symengine.Expr: + # Fitting to R ln(D0) = dMQ/dT + return symengine.diff(expr, v.T) + + @classmethod + def shift_reference_state(cls, desired_data: [Dataset], fixed_model: Model, mole_atoms_per_mole_formula_unit: symengine.Expr) -> ArrayLike: # np.object_ + """ + Shift _MIX or _FORM data to a common reference state in per mole-atom units. + + Parameters + ---------- + desired_data : List[Dict[str, Any]] + ESPEI single phase dataset + fixed_model : pycalphad.Model + Model with all lower order (in composition) terms already fit. Pure + element reference state (GHSER functions) should be set to zero. + mole_atoms_per_mole_formula_unit : float + Number of moles of atoms in every mole atom unit. + + Returns + ------- + np.ndarray + Data for this feature in [qty]/mole-formula in a common reference state. + + Raises + ------ + ValueError + + Notes + ----- + pycalphad Model parameters are stored as per mole-formula quantites, but + the calculated properties and our data are all in [qty]/mole-atoms. We + multiply by mole-atoms/mole-formula to convert the units to + [qty]/mole-formula. + + """ + total_response = [] + for dataset in desired_data: + values = np.asarray(dataset['values'], dtype=np.object_)*mole_atoms_per_mole_formula_unit + unique_excluded_contributions = set(dataset.get('excluded_model_contributions', [])) + for config_idx in range(len(dataset['solver']['sublattice_configurations'])): + occupancy = dataset['solver'].get('sublattice_occupancies', None) + if dataset['output'].endswith('_FORM'): + # we don't shift the reference state because we assume our + # models are already in the formation reference state (by us + # setting GHSERXX functions to zero explictly) + pass + elif dataset['output'].endswith('_MIX'): + if occupancy is None: + raise ValueError('Cannot have a _MIX property without sublattice occupancies.') + else: + values[..., config_idx] += cls.transform_feature(fixed_model.models['ref'])*mole_atoms_per_mole_formula_unit + else: + #raise ValueError(f'Unknown property to shift: {dataset["output"]}') + pass + for excluded_contrib in unique_excluded_contributions: + values[..., config_idx] += cls.transform_feature(fixed_model.models[excluded_contrib])*mole_atoms_per_mole_formula_unit + total_response.append(values.flatten()) + return total_response + + @classmethod + def get_response_vector(cls, fixed_model: Model, fixed_portions: [symengine.Basic], data: [Dataset], sample_condition_dicts: [Dict[str, Any]]) -> ArrayLike: # np.float_ + mole_atoms_per_mole_formula_unit = fixed_model._site_ratio_normalization + # Define site fraction symbols that will be reused + phase_name = fixed_model.phase_name + + # Construct flattened list of site fractions corresponding to the ravelled data (from shift_reference_state) + site_fractions = [] + for ds in data: + for _ in ds['conditions']['T']: + sf = build_sitefractions(phase_name, ds['solver']['sublattice_configurations'], ds['solver'].get('sublattice_occupancies', np.ones((len(ds['solver']['sublattice_configurations']), len(ds['solver']['sublattice_configurations'][0])), dtype=np.float_))) + site_fractions.append(sf) + site_fractions = list(itertools.chain(*site_fractions)) + + #data_qtys = np.concatenate(cls.shift_reference_state(data, fixed_model, mole_atoms_per_mole_formula_unit), axis=-1) + data_qtys = np.concatenate(cls.shift_reference_state(data, fixed_model, 1), axis=-1) + data_qtys = cls.transform_data(data_qtys, fixed_model) + # Remove existing partial model contributions from the data, convert to per mole-formula units + data_qtys = data_qtys - cls.transform_feature(getattr(fixed_model, cls.parameter_name))*mole_atoms_per_mole_formula_unit + # Subtract out high-order (in T) parameters we've already fit, already in per mole-formula units + data_qtys = data_qtys - cls.transform_feature(sum(fixed_portions)) + # If any site fractions show up in our rhs that aren't in these + # datasets' site fractions, set them to zero. This can happen if we're + # fitting a multi-component model that has site fractions from + # components that aren't in a particular dataset + for sf, i, cond_dict in zip(site_fractions, data_qtys, sample_condition_dicts): + missing_variables = symengine.S(i).atoms(v.SiteFraction) - set(sf.keys()) + sf.update({x: 0. for x in missing_variables}) + sf.update(cond_dict) + # also replace with database symbols in case we did higher order fitting + data_qtys = [fixed_model.symbol_replace(symengine.S(i).xreplace(sf), fixed_model._symbols).evalf() for i, sf in zip(data_qtys, site_fractions)] + data_qtys = np.asarray(data_qtys, dtype=np.float_) + return data_qtys + +class StepQ(StepD0): + features: [symengine.Expr] = [symengine.S.One] + + @staticmethod + def transform_data(d: ArrayLike, model: Optional[Model] = None) -> ArrayLike: # np.object_ + return np.array([-di for di in d]) + + @classmethod + def transform_feature(cls, expr: symengine.Expr, model: Optional[Model] = None) -> symengine.Expr: + # Fitting to -Q = MQ - T dMQ/dT + return expr - v.T*symengine.diff(expr, v.T) + +class TracerDiffusivityStep(AbstractLinearPropertyStep): + features: [symengine.Expr] = [symengine.S.One, v.T] + + @staticmethod + def transform_data(d: ArrayLike, model: Optional[Model] = None) -> ArrayLike: # np.object_ + # D* = exp(MQ/RT) -> RT D* = MQ + return np.array([symengine.log(di)*v.R*v.T for di in d]) \ No newline at end of file diff --git a/kawin/mobility_fitting/generate.py b/kawin/mobility_fitting/generate.py new file mode 100644 index 0000000..7c73710 --- /dev/null +++ b/kawin/mobility_fitting/generate.py @@ -0,0 +1,123 @@ +from tinydb import where +import json +import pycalphad +from pycalphad import Database +from espei.espei_script import run_espei +from espei.parameter_selection.fitting_descriptions import ModelFittingDescription +from kawin.mobility_fitting.fitting_steps import StepQ, StepD0, TracerDiffusivityStep +from kawin.thermo.Mobility import MobilityModel + +fitting_description = None + +def add_mobility_keywords(elements): + ''' + Adds MQ_el keywords to the pycalphad tdb keyword list + + Custom fitting in espei doesn't support diffusing species yet so as a workaround, + we could fit to terms of MQ_el where el is the diffusing species, then rewrite + the database to replace MQ_el terms with MQ(Phase&el,...) + + In order to do this, pycalphad will need to be able to recognize that MQ_el is a valid + keyword in the tdb file + + Parameters + ---------- + elements : [str] + List of diffusing species to fit mobility models to + + Returns + ------- + aliases : {str: str} + Maps tdb keyword (MQ_el) to element (el) + ''' + aliases = [] + for e in elements: + aliases.append('MQ_{}'.format(e)) + pycalphad.io.tdb_keywords.TDB_PARAM_TYPES.append(aliases[-1]) + return aliases + +def rewrite_mobility_terms(db_name, mob_aliases): + ''' + Rewrites the database to replace MQ_el with MQ(Phase&el,...) + + Parameters + ---------- + db_name : str + Name of thermodynamic database + mob_aliases : {str: str} + Maps tdb keyword (MQ_el) to element (el) + ''' + db = Database(db_name) + for p in db._parameters: + if p['parameter_type'] in mob_aliases: + ptype = p['parameter_type'] + index = ptype.index('_') + diff_species = ptype[index+1:] + cons_array = tuple(tuple(s.name for s in xs) for xs in p['constituent_array']) + db.add_parameter( + 'MQ', p['phase_name'], cons_array, + p['parameter_order'], p['parameter'], + ref=p['reference'], diffusing_species = diff_species) + + for m in mob_aliases: + db._parameters.remove(where('parameter_type') == m) + + db.to_file(db_name, if_exists='overwrite') + +def setup_mobility_fitting_description(elements, fit_to_tracer = False): + ''' + Create custom classes for diffusion prefactor, activation energy and tracer diffusivity + and add to the global mobility_fitting_description + + Parameters + ---------- + elements : [str] + List of elements to fit mobility models to + fit_to_tracer : bool + If False, will fit to datasets of activation energy and pre-factor terms + If True, will fit to tracer diffusivity directly + Not recommended due to overfitting. It is better to convert the + tracer diffusivity to activation energy and pre-factor terms and fit + to those values instead + ''' + steps = [] + for e in elements: + if fit_to_tracer: + Dstar = type(f'Tracer_{e}', (TracerDiffusivityStep,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_DIFF_{e}'}) + steps.append(Dstar) + else: + D0 = type(f'D0_{e}', (StepD0,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_D0_{e}'}) + Q = type(f'Q_{e}', (StepQ,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_Q_{e}'}) + steps += [D0, Q] + + global fitting_description + fitting_description = ModelFittingDescription(steps, model=MobilityModel) + +def fit_mobility(input_settings, fit_to_tracer=False): + ''' + Wrapper around run_espei to do the following: + 1. Find components to fit mobility to + 2. Add 'MQ_el' keywords into pycalphad tdb_keyword list + 3. Set up mobility fitting description + 4. Run espei + 5. Rewrite generated database to replace 'MQ_el' with 'MQ(ph&el)' + + Parameters + ---------- + input_settings : dict + Input dictionary used for an espei assessment + ''' + #Get phase models to get components in system to fit to + phase_model_file = input_settings['system']['phase_models'] + with open(phase_model_file, 'r') as f: + phase_models = json.load(f) + + #Get non-VA components + components = list(set(phase_models['components']) - set(['VA'])) + + aliases = add_mobility_keywords(components) + setup_mobility_fitting_description(components, fit_to_tracer=fit_to_tracer) + + out_db = input_settings['output']['output_db'] + run_espei(input_settings) + rewrite_mobility_terms(out_db, aliases) \ No newline at end of file diff --git a/kawin/mobility_fitting/interdiffusivity_error.py b/kawin/mobility_fitting/interdiffusivity_error.py new file mode 100644 index 0000000..aa1dd29 --- /dev/null +++ b/kawin/mobility_fitting/interdiffusivity_error.py @@ -0,0 +1,197 @@ +from collections import OrderedDict +from typing import Sequence, Dict, Union, List, Optional + +import numpy as np +from pycalphad import Database, variables as v +from pycalphad.core.utils import filter_phases, unpack_components, unpack_condition +from scipy.stats import norm +import tinydb + +from espei.phase_models import PhaseModelSpecification +from espei.typing import SymbolName +from espei.utils import PickleableTinyDB, database_symbols_to_fit +from espei.error_functions.residual_base import ResidualFunction, residual_function_registry + +from kawin.thermo import GeneralThermodynamics +from kawin.thermo.LocalEquilibrium import local_equilibrium +from kawin.thermo.FreeEnergyHessian import partialdMudX +from itertools import product + +import kawin.mobility_fitting.cached_mobility as cmob + +def getCachedData(cache, conds, data): + strConds = {c.__str__(): conds[c] for c in conds} + hashStr = str(strConds) + if hashStr in cache: + return cache[hashStr] + else: + result, cs = local_equilibrium(data.thermo.db, data.thermo.elements, data.thermo.phases, conds, data.thermo.models, data.thermo.phase_records) + cs_el = list(cs[0].phase_record.nonvacant_elements) + cs_T = cs[0].dof[cs[0].phase_record.state_variables.index(v.T)] + cs_dof = np.array(cs[0].dof) + cs_X = np.array(cs[0].X) + cs_dmudx = partialdMudX(result.chemical_potentials, cs[0]) + cache[hashStr] = (cs_el, cs_T, cs_dof, cs_X, cs_dmudx) + return cache[hashStr] + +class InterdiffusivityData: + def __init__(self, dbf, data, parameters = None, data_weight_dict = None): + self.dbf = dbf + self.parameters = parameters if parameters is not None else {} + self.parameter_keys = [p for p in self.parameters] + self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} + self.output = data['output'] + self.property_std_deviation = { + 'D': 0.1 # decade + } + + pot_conds = OrderedDict([(getattr(v, key), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if not key.startswith('X_')]) + comp_conds = OrderedDict([(v.X(key[2:]), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if key.startswith('X_')]) + rav_comp_conds = [OrderedDict(zip(comp_conds.keys(), pt_comps)) for pt_comps in zip(*comp_conds.values())] + + comps = data['components'] + phases = data['phases'] + self.refComp = data.get('ref_el') + self.depComps = data.get('dependent_el', []) + self.thermo = GeneralThermodynamics(dbf, comps, phases, parameters=parameters) + self.conditions = {} + for c in data['conditions']: + condList = unpack_condition(data['conditions'][c]) + if 'X_' not in c: + self.conditions[getattr(v,c)] = condList + self.conditions['composition'] = rav_comp_conds + + self.values = np.array(data['values']) + + total_num_calculations = len(rav_comp_conds)*np.prod([len(vals) for vals in pot_conds.values()]) + dataset_weights = np.array(data.get('weight', 1.0)) * np.ones(total_num_calculations) + self.weights = (self.property_std_deviation.get('D', 1.0)/data_weight_dict.get('D', 1.0)/dataset_weights).flatten() + +def get_diff_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], datasets: PickleableTinyDB, parameters: Dict[str, float], data_weight_dict: Optional[Dict[str, float]] = None): + ''' + Return the ZPF data used in the calculation of ZPF error + + Parameters + ---------- + comps : list + List of active component names + phases : list + List of phases to consider + datasets : espei.utils.PickleableTinyDB + Datasets that contain single phase data + parameters : dict + Dictionary mapping symbols to optimize to their initial values + model : Optional[Dict[str, Type[Model]]] + Dictionary phase names to pycalphad Model classes. + + Returns + ------- + list + List of data dictionaries with keys ``weight``, ``phase_regions`` and ``dataset_references``. + ''' + desired_data = datasets.search((tinydb.where('output').test(lambda x: 'INTER_DIFF' in x)) & + (tinydb.where('components').test(lambda x: set(x).issubset(comps))) & + (tinydb.where('phases').test(lambda x: len(set(phases).intersection(x)) > 0))) + + diff_data = [] + for data in desired_data: + diff_data.append(InterdiffusivityData(dbf, data, parameters, data_weight_dict)) + return diff_data + +def calc_diff_differences(data : InterdiffusivityData, parameters : np.ndarray, thermoCache : Dict): + diffs, wts = [], [] + paramDict = {} + for i in range(len(data.parameter_keys)): + paramDict[data.parameter_keys[i]] = parameters[i] + data.thermo.updateParameters(paramDict) + + nonVaElements = sorted([e for e in data.thermo.elements if e != 'VA']) + + keys, values = zip(*data.conditions.items()) + allConds = [dict(zip(keys,p)) for p in product(*values)] + for i in range(len(allConds)): + inds = np.array([data.conditions[k].index(v) for k,v in allConds[i].items()], dtype=np.int32) + dexp = data.values[tuple(inds)] + + currConds = {v.N: 1, v.GE: 0, v.P: allConds[i][v.P], v.T: allConds[i][v.T]} + for c in allConds[i]['composition']: + currConds[c] = allConds[i]['composition'][c] + + #Grab data from global cache + cs_data = getCachedData(thermoCache, currConds, data) + cs_el, cs_T, cs_dof, cs_X, cs_dmudx = cs_data + mob_from_CS = cmob.mobility_from_composition_set_quick(cs_dof, cs_el, data.thermo.mobCallables[data.thermo.phases[0]], data.thermo.mobility_correction, parameters = data.thermo._parameters) + + #eq_result = local_equilibrium(data.thermo.db, data.thermo.elements, data.thermo.phases, currConds, data.thermo.models, data.thermo.phase_records) + #result, cs = eq_result + + if data.refComp is None: + refComp = data.output.split('_')[-1] + refIndex = nonVaElements.index(refComp) + else: + refIndex = nonVaElements.index(data.refComp[0]) + + if 'INTER_DIFF' in data.output: + #cd, _ = chemical_diffusivity(result.chemical_potentials, cs[0], data.thermo.mobCallables[data.thermo.phases[0]], data.thermo.mobility_correction, parameters = data.thermo._parameters) + + mobMatrix = cmob.mobility_matrix_quick(cs_dof, cs_X, cs_el, mob_from_CS, data.thermo.phase_records[data.thermo.phases[0]]) + cd, _ = cmob.chemical_diffusivity_quick(cs_dmudx, mobMatrix) + + depComp1 = nonVaElements.index(data.depComps[0]) + depComp2 = nonVaElements.index(data.depComps[1]) + D = cd[depComp1, depComp2] - cd[depComp1, refIndex] + diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(dexp)*np.log10(np.abs(dexp)))) + wts.append(data.weights[i]) + + return diffs, wts + +def calculate_diff_probability(diff_data : Sequence[InterdiffusivityData], parameters : np.ndarray, thermoCache : Dict) -> float: + differences = [] + weights = [] + for data in diff_data: + diffs, wts = calc_diff_differences(data, parameters, thermoCache) + if np.any(np.isinf(diffs) | np.isnan(diffs)): + return -np.inf + differences.append(diffs) + weights.append(wts) + + differences = np.concatenate(differences, axis=0) + weights = np.concatenate(weights, axis=0) + probs = norm(loc=0.0, scale=weights).logpdf(differences) + return np.sum(probs) + +class InterdiffusivityResidual(ResidualFunction): + def __init__( + self, + database: Database, + datasets: PickleableTinyDB, + phase_models: Union[PhaseModelSpecification, None], + symbols_to_fit: Optional[List[SymbolName]] = None, + weight: Optional[Dict[str, float]] = None, + additional_mcmc_args: Optional[Dict] = {}, + ): + super().__init__(database, datasets, phase_models, symbols_to_fit) + if weight is not None: + self.weight = weight.get("ZPF", 1.0) + else: + self.weight = 1.0 + if phase_models is not None: + comps = sorted(phase_models.components) + model_dict = phase_models.get_model_dict() + else: + comps = sorted(database.elements) + model_dict = dict() + phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) + if symbols_to_fit is None: + symbols_to_fit = database_symbols_to_fit(database) + # okay if parameters are initialized to zero, we only need the symbol names + parameters = dict(zip(symbols_to_fit, [0]*len(symbols_to_fit))) + self.diff_data = get_diff_data(database, comps, phases, datasets, parameters, model_dict) + + self.thermoCache = {} + + def get_likelihood(self, parameters): + likelihood = calculate_diff_probability(self.diff_data, parameters, self.thermoCache) + return likelihood + +residual_function_registry.register(InterdiffusivityResidual) diff --git a/kawin/mobility_fitting/tracer_diffusivity_error.py b/kawin/mobility_fitting/tracer_diffusivity_error.py new file mode 100644 index 0000000..974194c --- /dev/null +++ b/kawin/mobility_fitting/tracer_diffusivity_error.py @@ -0,0 +1,396 @@ +""" +Calculate error due to thermochemical quantities: heat capacity, entropy, enthalpy. +""" + +import logging +from collections import OrderedDict +from typing import Any, Dict, List, NewType, Optional, Tuple, Union + +import symengine +from scipy.stats import norm +import numpy as np +import numpy.typing as npt +from symengine import Symbol +from tinydb import where + +from pycalphad import Database, Model, ReferenceState, variables as v +from pycalphad.codegen.callables import build_phase_records +from pycalphad.core.utils import unpack_components, get_pure_elements, filter_phases + +from espei.datasets import Dataset +from espei.core_utils import ravel_conditions, get_prop_data, filter_temperatures +from espei.parameter_selection.redlich_kister import calc_interaction_product +from espei.phase_models import PhaseModelSpecification +from espei.shadow_functions import calculate_, update_phase_record_parameters +from espei.sublattice_tools import canonicalize, recursive_tuplify, tuplify +from espei.typing import SymbolName +from espei.utils import database_symbols_to_fit, PickleableTinyDB +from espei.error_functions.residual_base import ResidualFunction, residual_function_registry + +import kawin.mobility_fitting.cached_mobility as cmob +from kawin.thermo.Mobility import MobilityModel + +import tinydb + +_log = logging.getLogger(__name__) + +# TODO: make into an object similar to how ZPF data works? +FixedConfigurationCalculationData = NewType("FixedConfigurationCalculationData", Dict[str, Any]) + +def filter_sublattice_configurations(desired_data: List[Dataset], subl_model) -> List[Dataset]: # TODO: symmetry support + """Modify the desired_data to remove any configurations that cannot be represented by the sublattice model.""" + subl_model_sets = [set(subl) for subl in subl_model] + for data in desired_data: + matching_configs = [] # binary mask of whether a configuration is represented by the sublattice model + for config in data['solver']['sublattice_configurations']: + config = recursive_tuplify(canonicalize(config, None)) + if ( + len(config) == len(subl_model) and + all(subl.issuperset(tuplify(config_subl)) for subl, config_subl in zip(subl_model_sets, config)) + ): + matching_configs.append(True) + else: + matching_configs.append(False) + matching_configs = np.asarray(matching_configs, dtype=np.bool_) + + # Rewrite output values with filtered data + data['values'] = np.array(data['values'], dtype=np.float_)[..., matching_configs] + data['solver']['sublattice_configurations'] = np.array(data['solver']['sublattice_configurations'], dtype=np.object_)[matching_configs].tolist() + if 'sublattice_occupancies' in data['solver']: + data['solver']['sublattice_occupancies'] = np.array(data['solver']['sublattice_occupancies'], dtype=np.object_)[matching_configs].tolist() + return desired_data + + +def calculate_points_array(phase_constituents, configuration, occupancies=None): + """ + Calculate the points array to use in pycalphad calculate calls. + + Converts the configuration data (and occupancies for mixing data) into the + points array by looking up the indices in the active phase constituents. + + Parameters + ---------- + phase_constituents : list + List of active constituents in a phase + configuration : list + List of the sublattice configuration + occupancies : list + List of sublattice occupancies. Required for mixing sublattices, otherwise takes no effect. + + Returns + ------- + numpy.ndarray + + Notes + ----- + Errors will be raised if components in the configuration are not in the + corresponding phase constituents sublattice. + """ + # pad the occupancies for zipping if none were passed (the case for non-mixing) + if occupancies is None: + occupancies = [0] * len(configuration) + + # construct the points array from zeros + points = np.zeros(sum(len(subl) for subl in phase_constituents)) + current_subl_idx = 0 # index that marks the beginning of the sublattice + for phase_subl, config_subl, subl_occupancies in zip(phase_constituents, configuration, occupancies): + phase_subl = list(phase_subl) + if isinstance(config_subl, (tuple, list)): + # we have mixing on the sublattice + for comp, comp_occupancy in zip(config_subl, subl_occupancies): + points[current_subl_idx + phase_subl.index(comp)] = comp_occupancy + else: + points[current_subl_idx + phase_subl.index(config_subl)] = 1 + current_subl_idx += len(phase_subl) + return points + + +def get_prop_samples(desired_data, constituents): + """ + Return data values and the conditions to calculate them using pycalphad.calculate + + Parameters + ---------- + desired_data : List[Dict[str, Any]] + List of dataset dictionaries that contain the values to sample + constituents : List[List[str]] + Names of constituents in each sublattice. + + Returns + ------- + Dict[str, Union[float, ArrayLike, List[float]]] + Dictionary of condition kwargs for pycalphad's calculate and the expected values + + """ + # TODO: assumes T, P as conditions + # calculate needs points, state variable lists, and values to compare to + num_dof = sum(map(len, constituents)) + calculate_dict = { + 'P': np.array([]), + 'T': np.array([]), + 'points': np.atleast_2d([[]]).reshape(-1, num_dof), + 'values': np.array([]), + 'weights': [], + 'references': [], + 'ref_el': None, + } + + for datum in desired_data: + #reference element + # If ref_el exist, then grab reference element from there + # If not, then grab from end of output name + ref_el = datum.get('ref_el', None) + if ref_el is None: + output_name = datum.get('output') + ref_el = output_name.split('_')[-1] + calculate_dict['ref_el'] = ref_el + + # extract the data we care about + datum_T = datum['conditions']['T'] + datum_P = datum['conditions']['P'] + configurations = datum['solver']['sublattice_configurations'] + occupancies = datum['solver'].get('sublattice_occupancies') + values = np.array(datum['values']) + if values.size == 0: + # Skip any data that don't have any values left (e.g. after filtering) + continue + # Broadcast the weights to the shape of the values. This ensures that + # the sizes of the weights and values are the same, which is important + # because they are flattened later (so the shape information is lost). + weights = np.broadcast_to(np.asarray(datum.get('weight', 1.0)), values.shape) + + # broadcast and flatten the conditions arrays + P, T = ravel_conditions(values, datum_P, datum_T) + if occupancies is None: + occupancies = [None] * len(configurations) + + # calculate the points arrays, should be 2d array of points arrays + points = np.array([calculate_points_array(constituents, config, occup) for config, occup in zip(configurations, occupancies)]) + assert values.shape == weights.shape, f"Values data shape {values.shape} does not match weights shape {weights.shape}" + + # add everything to the calculate_dict + calculate_dict['P'] = np.concatenate([calculate_dict['P'], P]) + calculate_dict['T'] = np.concatenate([calculate_dict['T'], T]) + calculate_dict['points'] = np.concatenate([calculate_dict['points'], np.tile(points, (values.shape[0]*values.shape[1], 1))], axis=0) + calculate_dict['values'] = np.concatenate([calculate_dict['values'], values.flatten()]) + calculate_dict['weights'].extend(weights.flatten()) + calculate_dict['references'].extend([datum.get('reference', "") for _ in range(values.flatten().size)]) + return calculate_dict + + +def get_tracer_data(dbf, comps, phases, datasets, model=None, weight_dict=None, symbols_to_fit=None): + """ + + Parameters + ---------- + dbf : pycalphad.Database + Database to consider + comps : list + List of active component names + phases : list + List of phases to consider + datasets : espei.utils.PickleableTinyDB + Datasets that contain single phase data + model : Optional[Dict[str, Type[Model]]] + Dictionary phase names to pycalphad Model classes. + weight_dict : dict + Dictionary of weights for each data type, e.g. {'HM': 200, 'SM': 2} + symbols_to_fit : list + Parameters to fit. Used to build the models and PhaseRecords. + + Returns + ------- + list + List of data dictionaries to iterate over + """ + # phase by phase, then property by property, then by model exclusions + if weight_dict is None: + weight_dict = {} + + if model is None: + model = {} + + if symbols_to_fit is not None: + symbols_to_fit = sorted(symbols_to_fit) + else: + symbols_to_fit = database_symbols_to_fit(dbf) + + species_comps = set(unpack_components(dbf, comps)) + + # estimated from NIST TRC uncertainties + property_std_deviation = { + 'TRACER_DIFF': 1/weight_dict.get('TRACER_DIFF', 1.0), # J/mol + 'TRACER_D0': 1/weight_dict.get('TRACER_D0', 1.0), # J/K-mol + 'TRACER_Q': 10000/weight_dict.get('TRACER_Q', 1.0), # J/K-mol + } + properties = ['TRACER_DIFF', 'TRACER_D0', 'TRACER_Q'] + + all_data_dicts = [] + for phase_name in phases: + if phase_name not in dbf.phases: + continue + # phase constituents are Species objects, so we need to be doing intersections with those + phase_constituents = dbf.phases[phase_name].constituents + # phase constituents must be filtered to only active: + constituents = [[sp.name for sp in sorted(subl_constituents.intersection(species_comps))] for subl_constituents in phase_constituents] + prop_ext = [''] + list(set([f'_{e}' for e in comps]) - set(['_VA'])) + nonvaelements = sorted(list(set(comps) - set(['VA']))) + for prop_base in properties: + for ext in prop_ext: + prop = prop_base + ext + curr_data = get_prop_data(comps, phase_name, prop, datasets, additional_query=(where('solver').exists())) + if len(curr_data) == 0: + #Search for prop_EL to see if anything pops up + continue + + data_dict = { + 'phase_name': phase_name, + 'prop': prop_base, + # needs the following keys to be added: + # species, calculate_dict, phase_records, model, output, weights + } + curr_data = filter_sublattice_configurations(curr_data, constituents) + curr_data = filter_temperatures(curr_data) + calculate_dict = get_prop_samples(curr_data, constituents) + output = prop + species = sorted(unpack_components(dbf, comps), key=str) + data_dict['species'] = species + data_dict['elements'] = nonvaelements + model_dict = MobilityModel(dbf, comps, phase_name, symbols_to_fit) + statevar_dict = {getattr(v, c, None): vals for c, vals in calculate_dict.items() if isinstance(getattr(v, c, None), v.StateVariable)} + statevar_dict = OrderedDict(sorted(statevar_dict.items(), key=lambda x: str(x[0]))) + str_statevar_dict = OrderedDict((str(k), vals) for k, vals in statevar_dict.items()) + data_dict['str_statevar_dict'] = str_statevar_dict + data_dict['calculate_dict'] = calculate_dict + data_dict['model'] = model_dict + data_dict['symbols'] = symbols_to_fit + data_dict['output'] = output + data_dict['weights'] = np.array(property_std_deviation[prop_base])/np.array(calculate_dict.pop('weights')) + all_data_dicts.append(data_dict) + return all_data_dicts + +def compute_fixed_configuration_property_differences(calc_data: FixedConfigurationCalculationData, parameters): + phase_name = calc_data['phase_name'] + output = calc_data['output'] + sample_values = calc_data['calculate_dict']['values'] + x = calc_data['calculate_dict'] + + pDict = {k:val for k,val in zip(calc_data['symbols'], parameters)} + + state_variables = sorted([v.T, v.P, v.N, v.GE]) + results = np.zeros(len(sample_values)) + for i in range(len(x['points'])): + dof = np.zeros(4 + len(calc_data['model'].site_fractions)) + dof[state_variables.index(v.T)] = x['T'][i] + dof[state_variables.index(v.P)] = x['P'][i] + dof[state_variables.index(v.N)] = 1 + dof[4:] = x['points'][i] + + refIndex = calc_data['elements'].index(x['ref_el']) + + if calc_data['prop'] == 'TRACER_DIFF': + calculated_values = cmob.mobility_from_composition_set_symbolic_quick(dof, calc_data['elements'], calc_data['model'], pDict) + r = calculated_values[refIndex] + elif calc_data['prop'] == 'TRACER_Q': + calculated_values = cmob.activation_energy_from_composition_set_quick(dof, calc_data['elements'], calc_data['model'], pDict) + r = calculated_values[refIndex] + elif calc_data['prop'] == 'TRACER_D0': + calculated_values = cmob.prefactor_from_composition_set_quick(dof, calc_data['elements'], calc_data['model'], pDict) + r = calculated_values[refIndex] + else: + r = 0 + + results[i] = r + + if calc_data['prop'] == 'TRACER_DIFF': + results = np.sign(results) * np.log10(np.abs(results)) + sample_values = np.sign(sample_values) * np.log10(np.abs(sample_values)) + elif calc_data['prop'] == 'TRACER_D0': + results = np.exp(results) + results = np.sign(results) * np.log10(results) + sample_values = np.sign(sample_values) * np.log10(np.abs(sample_values)) + + differences = results - sample_values + return differences + + +def calculate_tracer_probability(tracer_data: List[FixedConfigurationCalculationData], parameters=None): + """ + Calculate the weighted single phase error in the Database + + Parameters + ---------- + thermochemical_data : list + List of thermochemical data dicts + parameters : np.ndarray + Array of parameters to calculate the error with. + + Returns + ------- + float + A single float of the residual sum of square errors + + """ + if parameters is None: + parameters = np.array([]) + + prob_error = 0.0 + for data in tracer_data: + phase_name = data['phase_name'] + sample_values = data['calculate_dict']['values'] + differences = compute_fixed_configuration_property_differences(data, parameters) + probabilities = norm.logpdf(differences, loc=0, scale=data['weights']) + prob_sum = np.sum(probabilities) + _log.debug("%s(%s) - probability sum: %0.2f, data: %s, differences: %s, probabilities: %s, references: %s", data['prop'], phase_name, prob_sum, sample_values, differences, probabilities, data['calculate_dict']['references']) + prob_error += prob_sum + return prob_error + + +class TracerDiffusivityResidual(ResidualFunction): + def __init__( + self, + database: Database, + datasets: PickleableTinyDB, + phase_models: Union[PhaseModelSpecification, None], + symbols_to_fit: Optional[List[SymbolName]] = None, + weight: Optional[Dict[str, float]] = None, + additional_mcmc_args: Optional[Dict] = {}, + ): + super().__init__(database, datasets, phase_models, symbols_to_fit, weight) + + if weight is not None: + self.weight = weight + else: + self.weight = {} + + if phase_models is not None: + comps = sorted(phase_models.components) + model_dict = phase_models.get_model_dict() + else: + comps = sorted(database.elements) + model_dict = dict() + phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) + if symbols_to_fit is None: + symbols_to_fit = database_symbols_to_fit(database) + self.tracer_data = get_tracer_data(database, comps, phases, datasets, model_dict, weight_dict=self.weight, symbols_to_fit=symbols_to_fit) + + def get_residuals(self, parameters: npt.ArrayLike) -> Tuple[List[float], List[float]]: + residuals = [] + weights = [] + for data in self.thermochemical_data: + dataset_residuals = compute_fixed_configuration_property_differences(data, parameters).tolist() + residuals.extend(dataset_residuals) + dataset_weights = np.asarray(data["weights"], dtype=float).flatten().tolist() + if len(dataset_weights) != len(dataset_residuals): + # we need to broadcast the residuals. For now, assume the weights are a scalar, since that's all that's supported + assert len(dataset_weights) == 1 + dataset_weights = [float(dataset_weights[0]) for _ in range(len(dataset_residuals))] + weights.extend(dataset_weights) + return residuals, weights + + def get_likelihood(self, parameters) -> float: + likelihood = calculate_tracer_probability(self.tracer_data, parameters) + return likelihood + + +residual_function_registry.register(TracerDiffusivityResidual) \ No newline at end of file diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py new file mode 100644 index 0000000..aa37f1d --- /dev/null +++ b/kawin/mobility_fitting/utils.py @@ -0,0 +1,48 @@ +import numpy as np +from kawin.thermo import GeneralThermodynamics +from pycalphad import Database +from espei.utils import database_symbols_to_fit + +def getUsedDatabaseSymbols(dbname, elements, refElement, phases = None, freeSub = False): + ''' + Given the database, grab all symbols that pertain only to the given elements and phases + + If freeSub, then parameters for all subsystems (unaries, binaries, ...) will be added + If not, then only grab parameters for the specific number of elements + Ex. If fitting ternary A-B-C + If freeSub, grab parameters from A, B, C, A-B, A-C, B-C and A-B-C + Else, grab parameters only from A-B-C + + ex: + PARAMETER(BCC_A2,AL:0) 298.15 VV0001; 6000.0 N ! + PARAMETER(BCC_A2,CR:0) 298.15 VV0002; 6000.0 N ! + PARAMETER(FCC_A1,AL:0) 298.15 VV0003; 6000.0 N ! + PARAMETER(FCC_A1,CR:0) 298.15 VV0004; 6000.0 N ! + + Inputting ['AL'] and ['BCC_A2'] will output VV0001 + Inputting ['AL', 'CR'] and ['FCC_A1'] will output VV0003 and VV0004 + Inputting ['CR'] and ['BCC_A2', 'FCC_A1'] will output VV0002 and VV0004 + ''' + db = Database(dbname) + elements = sorted([e.upper() for e in elements]) + numElements = len(elements) + elSet = frozenset(elements + ['VA']) + usedSyms = frozenset() + for p in db._parameters: + if phases is not None: + if p['phase_name'] not in phases: + continue + parameterSpecies = frozenset([s.name for c in p['constituent_array'] for s in c]) + #Add symbols under 2 conditions + # 1. parameterSpecies is a subset of elSet + # 2. freeSub is False and length of parameter species (excluding VA) is equal to number of elements + pIsSubset = len((parameterSpecies-set(['VA','*'])) - elSet) == 0 + shouldBeFree = freeSub or len(parameterSpecies - set(['VA', '*'])) == numElements + isDiffusingSpecies = p['diffusing_species'].name == refElement + if pIsSubset and shouldBeFree and isDiffusingSpecies: + usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) + #if len(parameterSpecies - elSet) == 0: + # usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) + allSyms = database_symbols_to_fit(db) + usedSyms = sorted(list(usedSyms.intersection(frozenset(allSyms)))) + return usedSyms \ No newline at end of file diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index cc9f424..0398382 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -52,11 +52,17 @@ def __init__(self, dbe, comps, phase_name, parameters=None): setattr(self, 'MOB_'+name, self.mobility[name]) setattr(self, 'MQ_'+name, self.symbol_replace(getattr(self, 'MQ_'+name), symbols).xreplace(v.supported_variables_in_databases)) + setattr(self, 'lnM0_'+name, getattr(self, 'MQ_'+name).diff(v.T)/v.R) + setattr(self, 'MQa_'+name, v.T*getattr(self, 'MQ_'+name).diff(v.T) - getattr(self, 'MQ_'+name)) + for name, value in self.diffusivity.items(): self.diffusivity[name] = self.symbol_replace(value, symbols).xreplace(v.supported_variables_in_databases) setattr(self, 'DIFF_'+name, self.diffusivity[name]) setattr(self, 'DQ_'+name, self.symbol_replace(getattr(self, 'DQ_'+name), symbols).xreplace(v.supported_variables_in_databases)) + setattr(self, 'lnD0_'+name, getattr(self, 'DQ_'+name).diff(v.T)/v.R) + setattr(self, 'DQa_'+name, v.T*getattr(self, 'DQ_'+name).diff(v.T) - getattr(self, 'DQ_'+name)) + self.mob_site_fractions = {c: sorted([x for x in self.mobility_variables[c] if isinstance(x, v.SiteFraction)], key=str) for c in self.mobility} self.diff_site_fractions = {c: sorted([x for x in self.diffusivity_variables[c] if isinstance(x, v.SiteFraction)], key=str) for c in self.diffusivity} self.mob_state_variables = {c: sorted([x for x in self.mobility_variables[c] if not isinstance(x, v.SiteFraction)], key=str) for c in self.mobility} @@ -295,12 +301,95 @@ def mobility_from_composition_set(composition_set, mobility_callables = None, mo #return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](composition_set.dof) for A in range(len(elements))]) param_keys, param_values = extract_parameters(parameters) - if len(param_values) > 0: + if len(param_keys) > 0: callableInput = np.concatenate((composition_set.dof, param_values[0]), dtype=np.float_) else: callableInput = composition_set.dof return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](callableInput) for A in range(len(elements))]) + +def compute_symbolic_expr_from_composition_set(composition_set, mobility_model, symbol, parameters = {}): + ''' + Computes mobility symbol from equilibrium results using symbolic model + + NOTE: We don't build the callables for activation energy so this is a directly substitution + into the symengine model. However, since this function isn't used often, the slower + performance of this shouldn't be much of an issue + + Parameters + ---------- + composition_set : pycalphad.core.composition_set.CompositionSet + mobility_model : MobilityModel object + symbol : str + Name of symbol as symbol_el in model + parameters : dict {str : float} + List of parameters to override free symbols in the model + + Returns + ------- + Array for floats for activation energy of each element (alphabetical order) + ''' + elements = composition_set.phase_record.nonvacant_elements + param_keys, param_values = extract_parameters(parameters) + symbols = sorted([v.T, v.P, v.N, v.GE]) + mobility_model.site_fractions + var_dict = {s:val for s,val in zip(symbols, np.array(composition_set.dof))} + if len(param_keys) > 0: + for p,val in zip(param_keys, param_values[0]): + var_dict[p] = val + + return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))]) + +def mobility_from_composition_set_symbolic(composition_set, mobility_model, parameters = {}): + ''' + Computes mobility from equilibrium results using symbolic model + + Parameters + ---------- + composition_set : pycalphad.core.composition_set.CompositionSet + mobility_model : MobilityModel object + parameters : dict {str : float} + List of parameters to override free symbols in the model + + Returns + ------- + Array for floats for activation energy of each element (alphabetical order) + ''' + return compute_symbolic_expr_from_composition_set(composition_set, mobility_model, 'MQ', parameters) + +def activation_energy_from_composition_set(composition_set, mobility_model, parameters = {}): + ''' + Computes activation energy for mobility from equilibrium results + + Parameters + ---------- + composition_set : pycalphad.core.composition_set.CompositionSet + mobility_model : MobilityModel object + parameters : dict {str : float} + List of parameters to override free symbols in the model + + Returns + ------- + Array for floats for activation energy of each element (alphabetical order) + ''' + return compute_symbolic_expr_from_composition_set(composition_set, mobility_model, 'MQa', parameters) + +def prefactor_from_composition_set(composition_set, mobility_model, parameters = {}): + ''' + Computes prefactor term, ln(M0), for mobility from equilibrium results + + Parameters + ---------- + composition_set : pycalphad.core.composition_set.CompositionSet + mobility_model : MobilityModel object + parameters : dict {str : float} + List of parameters to override free symbols in the model + + Returns + ------- + Array for floats for activation energy of each element (alphabetical order) + ''' + return compute_symbolic_expr_from_composition_set(composition_set, mobility_model, 'lnM0', parameters) + def tracer_diffusivity(composition_set, mobility_callables = None, mobility_correction = None, parameters = {}): ''' Computes tracer diffusivity for given equilibrium results From 2549beb3e50e6d92b193978be534e4f5ce46f177 Mon Sep 17 00:00:00 2001 From: Ury Date: Mon, 15 Apr 2024 16:46:23 -0700 Subject: [PATCH 02/53] manual fitting module --- kawin/diffusion/Diffusion.py | 21 +- kawin/diffusion/Homogenization.py | 6 +- .../error_functions/__init__.py | 0 .../{ => error_functions}/cached_mobility.py | 38 +-- .../interdiffusivity_error.py | 4 + .../tracer_diffusivity_error.py | 22 +- kawin/mobility_fitting/fitting_steps.py | 16 +- kawin/mobility_fitting/generate.py | 4 +- kawin/mobility_fitting/manual_fitting.py | 246 ++++++++++++++++++ kawin/mobility_fitting/utils.py | 2 +- kawin/thermo/LocalEquilibrium.py | 4 + kawin/thermo/Mobility.py | 29 ++- kawin/thermo/Thermodynamics.py | 18 +- 13 files changed, 327 insertions(+), 83 deletions(-) create mode 100644 kawin/mobility_fitting/error_functions/__init__.py rename kawin/mobility_fitting/{ => error_functions}/cached_mobility.py (80%) rename kawin/mobility_fitting/{ => error_functions}/interdiffusivity_error.py (99%) rename kawin/mobility_fitting/{ => error_functions}/tracer_diffusivity_error.py (96%) create mode 100644 kawin/mobility_fitting/manual_fitting.py diff --git a/kawin/diffusion/Diffusion.py b/kawin/diffusion/Diffusion.py index d5dc1ab..25f1318 100644 --- a/kawin/diffusion/Diffusion.py +++ b/kawin/diffusion/Diffusion.py @@ -434,7 +434,7 @@ def setup(self): if any(xsum > 1): print('Compositions add up to above 1 between z = [{:.3e}, {:.3e}]'.format(np.amin(self.z[xsum>1]), np.amax(self.z[xsum>1]))) raise Exception('Some compositions sum up to above 1') - self.x[self.x > self.minComposition] = self.x[self.x > self.minComposition] - len(self.allElements) * self.minComposition + self.x[self.x > 1-self.minComposition] = self.x[self.x > 1-self.minComposition] - len(self.allElements) * self.minComposition self.x[self.x < self.minComposition] = self.minComposition self.T = self.Tfunc(self.z, 0) self.isSetup = True @@ -457,6 +457,23 @@ def printStatus(self, iteration, modelTime, simTimeElapsed): def getCurrentX(self): return self.t, [self.x] + def correctdXdt(self, dt, x, dXdt): + #For undefined fluxes, interpolated between the defined fluxes + for i in range(len(dXdt[0])): + indices = np.isnan(dXdt[0][i]) + dXdt[0][i][indices] = np.interp(self.z[indices], self.z[~indices], dXdt[0][i][~indices]) + + #Adjust flux by a scale if it predicts that a composition will go below 0 + xfull = np.concatenate((np.array([np.sum(x[0],axis=0)]), x[0]), axis=0) + dXdtfull = np.concatenate((np.array([np.sum(dXdt[0],axis=0)]), dXdt[0]), axis=0) + xpred = dt * dXdtfull + alpha = np.ones(xfull.shape) + den = xpred - xfull + alpha[den != 0] = (0 - xfull[den != 0]) / den[den != 0] + alpha[(alpha > 1) | (alpha <= 0)] = 1 + for i in range(len(dXdt[0])): + dXdt[0][i] *= np.amin(alpha, axis=0) + def getdXdt(self, t, x): ''' dXdt is defined as -dJ/dz @@ -472,6 +489,8 @@ def postProcess(self, time, x): Stores new x and t Records new values if recording is enabled ''' + x[0][x[0] > 1-self.minComposition] = 1-3*self.minComposition + x[0][x[0] < 3*self.minComposition] = self.minComposition self.t = time self.x = x[0] self.record(self.t) diff --git a/kawin/diffusion/Homogenization.py b/kawin/diffusion/Homogenization.py index a4b610d..93cf96e 100644 --- a/kawin/diffusion/Homogenization.py +++ b/kawin/diffusion/Homogenization.py @@ -339,4 +339,8 @@ def getDt(self, dXdt): This is done by finding the time interval such that the composition change caused by the fluxes will be lower than self.maxCompositionChange ''' - return self.maxCompositionChange / np.amax(np.abs(dXdt[0][dXdt[0]!=0])) \ No newline at end of file + #Account for dependent element + dXdtSum = np.sum(dXdt[0], axis=0) + t0 = self.maxCompositionChange / np.amax(np.abs(dXdt[0][dXdt[0]!=0])) + t1 = self.maxCompositionChange / np.amax(np.abs(dXdtSum[dXdtSum!=0])) + return np.amin([t0, t1]) \ No newline at end of file diff --git a/kawin/mobility_fitting/error_functions/__init__.py b/kawin/mobility_fitting/error_functions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kawin/mobility_fitting/cached_mobility.py b/kawin/mobility_fitting/error_functions/cached_mobility.py similarity index 80% rename from kawin/mobility_fitting/cached_mobility.py rename to kawin/mobility_fitting/error_functions/cached_mobility.py index 8416209..4484295 100644 --- a/kawin/mobility_fitting/cached_mobility.py +++ b/kawin/mobility_fitting/error_functions/cached_mobility.py @@ -1,8 +1,7 @@ import numpy as np from pycalphad.core.utils import extract_parameters from pycalphad import variables as v - -interstitials = ['C', 'N', 'O', 'H', 'B'] +from kawin.thermo.Mobility import interstitials # ------------------------------------------------------------------ # For ESPEI assessments @@ -89,13 +88,6 @@ def mobility_matrix_quick(dof, composition, elements, mob_from_CS, phase_record) mobMatrix[a, b] = -U[a] * mob[b] mobMatrix *= Usum - #for a in range(len(elements)): - # for b in range(len(elements)): - # if a == b: - # mobMatrix[a, b] = (1 - U[a]) * mob[b] - # else: - # mobMatrix[a, b] = -U[a] * mob[b] - return mobMatrix def chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian = False): @@ -104,30 +96,4 @@ def chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian = False): if returnHessian: return Dkj, dmudx else: - return Dkj, None - -def interdiffusivity_quick(dmudx, mobMatrix, elements, refElement, mobility_callables = None, mobility_correction = None, returnHessian = False, parameters = {}): - Dkj, hessian = chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian) - - refIndex = 0 - for a in range(len(elements)): - if elements[a] == refElement: - refIndex = a - break - - Dnkj = np.zeros((len(elements) - 1, len(elements) - 1)) - c = 0 - d = 0 - for a in range(len(elements)): - if a != refIndex: - for b in range(len(elements)): - if b != refIndex: - if elements[b] in interstitials: - Dnkj[c, d] = Dkj[a, b] - else: - Dnkj[c, d] = Dkj[a, b] - Dkj[a, refIndex] - d += 1 - c += 1 - d = 0 - - return Dnkj, hessian \ No newline at end of file + return Dkj, None \ No newline at end of file diff --git a/kawin/mobility_fitting/interdiffusivity_error.py b/kawin/mobility_fitting/error_functions/interdiffusivity_error.py similarity index 99% rename from kawin/mobility_fitting/interdiffusivity_error.py rename to kawin/mobility_fitting/error_functions/interdiffusivity_error.py index aa1dd29..af65f30 100644 --- a/kawin/mobility_fitting/interdiffusivity_error.py +++ b/kawin/mobility_fitting/error_functions/interdiffusivity_error.py @@ -193,5 +193,9 @@ def __init__( def get_likelihood(self, parameters): likelihood = calculate_diff_probability(self.diff_data, parameters, self.thermoCache) return likelihood + + def __getstate__(self): + print('i am pickled') + return self.__dict__ residual_function_registry.register(InterdiffusivityResidual) diff --git a/kawin/mobility_fitting/tracer_diffusivity_error.py b/kawin/mobility_fitting/error_functions/tracer_diffusivity_error.py similarity index 96% rename from kawin/mobility_fitting/tracer_diffusivity_error.py rename to kawin/mobility_fitting/error_functions/tracer_diffusivity_error.py index 974194c..b3f3e41 100644 --- a/kawin/mobility_fitting/tracer_diffusivity_error.py +++ b/kawin/mobility_fitting/error_functions/tracer_diffusivity_error.py @@ -6,22 +6,17 @@ from collections import OrderedDict from typing import Any, Dict, List, NewType, Optional, Tuple, Union -import symengine from scipy.stats import norm import numpy as np import numpy.typing as npt -from symengine import Symbol from tinydb import where -from pycalphad import Database, Model, ReferenceState, variables as v -from pycalphad.codegen.callables import build_phase_records -from pycalphad.core.utils import unpack_components, get_pure_elements, filter_phases +from pycalphad import Database, variables as v +from pycalphad.core.utils import unpack_components, filter_phases from espei.datasets import Dataset from espei.core_utils import ravel_conditions, get_prop_data, filter_temperatures -from espei.parameter_selection.redlich_kister import calc_interaction_product from espei.phase_models import PhaseModelSpecification -from espei.shadow_functions import calculate_, update_phase_record_parameters from espei.sublattice_tools import canonicalize, recursive_tuplify, tuplify from espei.typing import SymbolName from espei.utils import database_symbols_to_fit, PickleableTinyDB @@ -217,11 +212,11 @@ def get_tracer_data(dbf, comps, phases, datasets, model=None, weight_dict=None, species_comps = set(unpack_components(dbf, comps)) - # estimated from NIST TRC uncertainties + # made up values property_std_deviation = { - 'TRACER_DIFF': 1/weight_dict.get('TRACER_DIFF', 1.0), # J/mol - 'TRACER_D0': 1/weight_dict.get('TRACER_D0', 1.0), # J/K-mol - 'TRACER_Q': 10000/weight_dict.get('TRACER_Q', 1.0), # J/K-mol + 'TRACER_DIFF': 1/weight_dict.get('TRACER_DIFF', 1.0), # decade + 'TRACER_D0': 1/weight_dict.get('TRACER_D0', 1.0), # decade + 'TRACER_Q': 10000/weight_dict.get('TRACER_Q', 1.0), # J/mol } properties = ['TRACER_DIFF', 'TRACER_D0', 'TRACER_Q'] @@ -252,7 +247,6 @@ def get_tracer_data(dbf, comps, phases, datasets, model=None, weight_dict=None, curr_data = filter_sublattice_configurations(curr_data, constituents) curr_data = filter_temperatures(curr_data) calculate_dict = get_prop_samples(curr_data, constituents) - output = prop species = sorted(unpack_components(dbf, comps), key=str) data_dict['species'] = species data_dict['elements'] = nonvaelements @@ -264,14 +258,12 @@ def get_tracer_data(dbf, comps, phases, datasets, model=None, weight_dict=None, data_dict['calculate_dict'] = calculate_dict data_dict['model'] = model_dict data_dict['symbols'] = symbols_to_fit - data_dict['output'] = output + data_dict['output'] = prop data_dict['weights'] = np.array(property_std_deviation[prop_base])/np.array(calculate_dict.pop('weights')) all_data_dicts.append(data_dict) return all_data_dicts def compute_fixed_configuration_property_differences(calc_data: FixedConfigurationCalculationData, parameters): - phase_name = calc_data['phase_name'] - output = calc_data['output'] sample_values = calc_data['calculate_dict']['values'] x = calc_data['calculate_dict'] diff --git a/kawin/mobility_fitting/fitting_steps.py b/kawin/mobility_fitting/fitting_steps.py index 7011c67..d4c5b7d 100644 --- a/kawin/mobility_fitting/fitting_steps.py +++ b/kawin/mobility_fitting/fitting_steps.py @@ -2,7 +2,7 @@ from pycalphad import Model, variables as v import numpy as np import symengine -from typing import Optional, Dict, Any +from typing import Optional, Dict, Any, List from numpy.typing import ArrayLike from espei.utils import build_sitefractions import itertools @@ -40,8 +40,8 @@ ''' class StepD0(FittingStep): - supported_reference_states: [str] = [""] - features: [symengine.Expr] = [v.T] + supported_reference_states: List[str] = [""] + features: List[symengine.Expr] = [v.T] @staticmethod def transform_data(d: ArrayLike, model: Optional[Model] = None) -> ArrayLike: # np.object_ @@ -53,7 +53,7 @@ def transform_feature(cls, expr: symengine.Expr, model: Optional[Model] = None) return symengine.diff(expr, v.T) @classmethod - def shift_reference_state(cls, desired_data: [Dataset], fixed_model: Model, mole_atoms_per_mole_formula_unit: symengine.Expr) -> ArrayLike: # np.object_ + def shift_reference_state(cls, desired_data: List[Dataset], fixed_model: Model, mole_atoms_per_mole_formula_unit: symengine.Expr) -> ArrayLike: # np.object_ """ Shift _MIX or _FORM data to a common reference state in per mole-atom units. @@ -109,7 +109,7 @@ def shift_reference_state(cls, desired_data: [Dataset], fixed_model: Model, mole return total_response @classmethod - def get_response_vector(cls, fixed_model: Model, fixed_portions: [symengine.Basic], data: [Dataset], sample_condition_dicts: [Dict[str, Any]]) -> ArrayLike: # np.float_ + def get_response_vector(cls, fixed_model: Model, fixed_portions: List[symengine.Basic], data: List[Dataset], sample_condition_dicts: [Dict[str, Any]]) -> ArrayLike: # np.float_ mole_atoms_per_mole_formula_unit = fixed_model._site_ratio_normalization # Define site fraction symbols that will be reused phase_name = fixed_model.phase_name @@ -143,7 +143,7 @@ def get_response_vector(cls, fixed_model: Model, fixed_portions: [symengine.Basi return data_qtys class StepQ(StepD0): - features: [symengine.Expr] = [symengine.S.One] + features: List[symengine.Expr] = [symengine.S.One] @staticmethod def transform_data(d: ArrayLike, model: Optional[Model] = None) -> ArrayLike: # np.object_ @@ -154,8 +154,8 @@ def transform_feature(cls, expr: symengine.Expr, model: Optional[Model] = None) # Fitting to -Q = MQ - T dMQ/dT return expr - v.T*symengine.diff(expr, v.T) -class TracerDiffusivityStep(AbstractLinearPropertyStep): - features: [symengine.Expr] = [symengine.S.One, v.T] +class StepTracerDiffusivity(AbstractLinearPropertyStep): + features: List[symengine.Expr] = [symengine.S.One, v.T] @staticmethod def transform_data(d: ArrayLike, model: Optional[Model] = None) -> ArrayLike: # np.object_ diff --git a/kawin/mobility_fitting/generate.py b/kawin/mobility_fitting/generate.py index 7c73710..134f2e6 100644 --- a/kawin/mobility_fitting/generate.py +++ b/kawin/mobility_fitting/generate.py @@ -4,7 +4,7 @@ from pycalphad import Database from espei.espei_script import run_espei from espei.parameter_selection.fitting_descriptions import ModelFittingDescription -from kawin.mobility_fitting.fitting_steps import StepQ, StepD0, TracerDiffusivityStep +from kawin.mobility_fitting.fitting_steps import StepQ, StepD0, StepTracerDiffusivity from kawin.thermo.Mobility import MobilityModel fitting_description = None @@ -83,7 +83,7 @@ def setup_mobility_fitting_description(elements, fit_to_tracer = False): steps = [] for e in elements: if fit_to_tracer: - Dstar = type(f'Tracer_{e}', (TracerDiffusivityStep,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_DIFF_{e}'}) + Dstar = type(f'Tracer_{e}', (StepTracerDiffusivity,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_DIFF_{e}'}) steps.append(Dstar) else: D0 = type(f'D0_{e}', (StepD0,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_D0_{e}'}) diff --git a/kawin/mobility_fitting/manual_fitting.py b/kawin/mobility_fitting/manual_fitting.py new file mode 100644 index 0000000..be05d54 --- /dev/null +++ b/kawin/mobility_fitting/manual_fitting.py @@ -0,0 +1,246 @@ +import numpy as np +from pycalphad import Database, Model, variables as v +from pycalphad.codegen.callables import build_phase_records +from pycalphad.core.utils import unpack_condition +from symengine import Piecewise, And +from tinydb import where +from kawin.thermo.LocalEquilibrium import local_equilibrium +from espei.datasets import load_datasets, recursive_glob + +class EquilibriumSiteFractionGenerator: + def __init__(self, database : Database, phase : str): + self.db = database + self.phase = phase + self.models = {} + self.phase_records = {} + self.constituents = {} + + self.full_constituents = [c for cons in self.db.phases[self.phase].constituents for c in sorted(list(cons))] + self._conditions_override = {v.N: 1, v.GE: 0} + + def set_override_condition(self, variable, value): + self._conditions_override[variable] = value + + def remove_override_condition(self, variable): + self._conditions_override.pop(variable) + + def _generate_comps_key(self, components): + comps = sorted(components) + return frozenset(comps), comps + + def _generate_phase_records(self, components): + active_comps, comps = self._generate_comps_key(components) + if active_comps not in self.models: + self.models[active_comps] = {self.phase: Model(self.db, comps, self.phase)} + self.phase_records[active_comps] = build_phase_records(self.db, comps, [self.phase], {v.T, v.P, v.N, v.GE}, self.models[active_comps]) + self.constituents[active_comps] = [c for cons in self.models[active_comps][self.phase].constituents for c in sorted(list(cons))] + + def __call__(self, components, conditions : dict[v.StateVariable: float]) -> dict[v.Species: float]: + active_comps, comps = self._generate_comps_key(components) + self._generate_phase_records(components) + + for oc in self._conditions_override: + conditions[oc] = self._conditions_override[oc] + results, comp_sets = local_equilibrium(self.db, comps, [self.phase], conditions, self.models[active_comps], self.phase_records[active_comps]) + sfg = {c:val for c,val in zip(self.constituents[active_comps], comp_sets[0].dof[4:])} + for c in self.full_constituents: + sfg[c] = sfg.get(c,0) + return sfg + +class SiteFractionGenerator: + def create_site_fractions(self, composition): + return NotImplementedError() + + def __call__(self, components, conditions): + comps_no_va = list(set(components) - set(['VA'])) + composition = {c:1 for c in comps_no_va} + for key,val in conditions.items(): + if type(key) == v.MoleFraction: + for c in composition: + composition[c] -= val + composition[key.name[2:]] = val + + return self.create_site_fractions(composition) + +class MobilityTerm: + ''' + Utility class to hold data for a mobility term + + Attributes + ---------- + constituent_array : list[list[str]] + Constituent array + order : int + Redlich-kister polynomial order + ''' + def __init__(self, constituent_array : list[list[v.SiteFraction]], order : int = 0): + self.constituent_array = tuple(constituent_array) + self.order = order + self.expr = None + + def generate_multiplier(self, site_fractions): + val = 1 + for clist in self.constituent_array: + clist = np.atleast_1d(clist) + for c in clist: + val *= site_fractions.get(c,0) + if len(clist) == 2: + ordered = sorted(clist) + val *= (site_fractions.get(ordered[1],0) - site_fractions.get(ordered[0],0))**self.order + return val + + def create_constituent_array_list(self): + return [[c.species.name for c in np.atleast_1d(clist)] for clist in self.constituent_array] + + def __eq__(self, other): + return self.constituent_array == other.constituent_array and self.order == other.order + +def add_mobility_model(database : Database, phase : str, diffusing_species : str, mobility_terms : list[MobilityTerm]): + ''' + Add mobility parameters to database + + Parameters + ---------- + database : Pycalphad database object + phase : str + diffusing_species : str + mobility_terms : list[MobilityParameter] + ''' + for mp in mobility_terms: + database.add_parameter('MQ', phase, mp.create_constituent_array_list(), mp.order, mp.expr, diffusing_species=diffusing_species) + +def least_squares_fit(A, b, p=1): + ''' + Given site fractions and function to generate Redlich-kister terms, + compute RK coefficients and AICC criteria + ''' + A + x = np.linalg.lstsq(A, b, rcond=None)[0] + k = len(A[0]) + b_pred = np.matmul(A, x) + L = np.log(np.sum((b_pred - b)**2) / len(A)) + aicc = np.array(2*p*k + len(A)*L + (2*(k*p)**2 + 2*k*p) / (len(A) - k*p - 1)) + return x, aicc + +def find_last_variable(database): + index = 0 + vname = 'VV{:04d}'.format(index) + while vname in database.symbols: + index += 1 + vname = 'VV{:04d}'.format(index) + return vname, index + + +def fit(datasets, database, components, phase, diffusing_species, mobility_test_models, site_fraction_generator, p = 1): + ''' + Fit mobility models to datasets + + Parameters + ---------- + datasets : list[dict] + Espei datasets + species : list[v.Species] + List of species in mobility_test_models + components : list[str] + phase : str + diffusing_species : str + mobility_test_models : list[list[MobilityTerm]] + site_fraction_generator : function + Takes in components and list of conditions and returns dictionary {v.SiteFraction : float} + ''' + if type(datasets) == str: + datasets = load_datasets(sorted(recursive_glob(datasets, '*.json'))) + + components = list(set(components).union(set(['VA']))) + + fitted_mobility_model = [] + + q_query = ( + (where('components').test(lambda x: set(x).issubset(components))) & + (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & + (where('output').test(lambda x : 'TRACER_Q' in x and x.endswith(diffusing_species))) + ) + d0_query = ( + (where('components').test(lambda x: set(x).issubset(components))) & + (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & + (where('output').test(lambda x : 'TRACER_D0' in x and x.endswith(diffusing_species))) + ) + q_transform = lambda x : x + d0_transform = lambda x : np.log(x) + data_types = { + 'Q': (q_query, q_transform, -1), + 'D0': (d0_query, d0_transform, 8.314*v.T) + } + + for data_key, data_val in data_types.items(): + query, transform, multiplier = data_val + data = datasets.search(query) + + site_fractions = [] + Y = [] + for d in data: + conds_grid = [] + conds_key = [] + for c in d['conditions']: + conds_grid.append(np.atleast_1d(d['conditions'][c])) + conds_key.append(v.X(c[2:]) if c.startswith('X_') else getattr(v, c)) + conds_grid = np.meshgrid(*conds_grid) + y_sub = transform(np.array(d['values']).flatten()) + + conds_list = {key:val.flatten() for key,val in zip(conds_key, conds_grid)} + + if 'solver' in d: + for sub_conf, sub_lat in zip(d['solver']['sublattice_configurations'], d['solver']['sublattice_occupancies']): + sub_index = 0 + sf = {} + for species, occs in zip(sub_conf, sub_lat): + species, occs = np.atleast_1d(species), np.atleast_1d(occs) + for s, o in zip(species, occs): + y = v.SiteFraction(phase, sub_index, s) + sf[y] = o + sub_index += 1 + site_fractions.append(sf) + + else: + for i in range(len(Y)): + sf = site_fraction_generator(d['components'], {key:val[i] for key,val in conds_list.items()}) + site_fractions.append(sf) + + Y = np.concatenate((Y, y_sub)) + + fitted_models = [] + aiccs = [] + for mob_model in mobility_test_models: + X = [[mi.generate_multiplier(sf) for mi in mob_model] for sf in site_fractions] + X = np.array(X) + terms, aicc = least_squares_fit(X, Y, p) + fitted_models.append(terms*multiplier) + aiccs.append(aicc) + + index = np.argmin(aiccs) + best_model = mobility_test_models[index] + best_fit = fitted_models[index] + + for term, coef in zip(best_model, best_fit): + if term not in fitted_mobility_model: + fitted_mobility_model.append(MobilityTerm(term.constituent_array, term.order)) + + combined_term = fitted_mobility_model[fitted_mobility_model.index(term)] + if combined_term.expr is None: + combined_term.expr = 0 + combined_term.expr += coef + + for f in fitted_mobility_model: + f.expr = Piecewise((f.expr, And(0 <= v.T, v.T < 10000)), (0, True)) + print(f.constituent_array, f.expr) + + return fitted_mobility_model + + + + + + + + + diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py index aa37f1d..5decf31 100644 --- a/kawin/mobility_fitting/utils.py +++ b/kawin/mobility_fitting/utils.py @@ -3,7 +3,7 @@ from pycalphad import Database from espei.utils import database_symbols_to_fit -def getUsedDatabaseSymbols(dbname, elements, refElement, phases = None, freeSub = False): +def get_used_database_symbols(dbname, elements, refElement, phases = None, freeSub = False): ''' Given the database, grab all symbols that pertain only to the given elements and phases diff --git a/kawin/thermo/LocalEquilibrium.py b/kawin/thermo/LocalEquilibrium.py index cb7c08b..9f82705 100644 --- a/kawin/thermo/LocalEquilibrium.py +++ b/kawin/thermo/LocalEquilibrium.py @@ -47,7 +47,11 @@ def local_equilibrium(dbf, comps, phases, conds, models, phase_records, composit pdens=10, model=models, phase_records=phase_records) idx_p = np.argmin(calc_p.GM.values.squeeze()) compset = CompositionSet(phase_records[phase]) + #For phases with a single site fraction (e.g. stoichiometric at a pure composition), + #squeezing will result in a 0D array, so we make sure the site fractions are at least 1D site_fractions = np.array(calc_p.Y.isel(points=idx_p).values.squeeze()) + if len(site_fractions.shape) == 0: + site_fractions = np.array([site_fractions]) compset.update(site_fractions, phase_amt, state_variables) composition_sets.append(compset) else: diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index 0398382..66fb7f6 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -465,15 +465,24 @@ def mobility_matrix(composition_set, mobility_callables = None, mobility_correct #There are no entries for M_ab if one index is interstitial and the other is substitutional mobMatrix = np.zeros((len(elements), len(elements))) for a in range(len(elements)): - if elements[a] in interstitials: - mobMatrix[a, a] = vaTerms.get(interstitialTerms[elements[a]], 1) * mob[a] - else: - for b in range(len(elements)): + for b in range(len(elements)): + if a == b: + if elements[a] in interstitials: + mobMatrix[a, a] = vaTerms.get(interstitialTerms[elements[a]], 1) * mob[a] + else: + mobMatrix[a, b] = (1 - U[a]) * mob[b] + else: if elements[b] not in interstitials: - if a == b: - mobMatrix[a, b] = (1 - U[a]) * mob[b] - else: - mobMatrix[a, b] = -U[a] * mob[b] + mobMatrix[a, b] = -U[a] * mob[b] + # if elements[a] in interstitials: + # mobMatrix[a, a] = vaTerms.get(interstitialTerms[elements[a]], 1) * mob[a] + # else: + # for b in range(len(elements)): + # if elements[b] not in interstitials: + # if a == b: + # mobMatrix[a, b] = (1 - U[a]) * mob[b] + # else: + # mobMatrix[a, b] = -U[a] * mob[b] #Diffusivity requires dmu_a/dU_b; however, the free energy curvature gives dmu_a/dX_b #Assuming that Usum is constant and using chain-rule derivatives, # the conversion from dmu_a/dX_b to dmu_a/dU_b can be done by multiplying the sum(substitutionals) @@ -552,7 +561,7 @@ def interdiffusivity(chemical_potentials, composition_set, refElement, mobility_ free energy hessian will be None if returnHessian is False ''' Dkj, hessian = chemical_diffusivity(chemical_potentials, composition_set, mobility_callables, mobility_correction, returnHessian, parameters) - #print('Dkj', Dkj) + elements = list(composition_set.phase_record.nonvacant_elements) #Find index of reference element @@ -577,7 +586,7 @@ def interdiffusivity(chemical_potentials, composition_set, refElement, mobility_ d += 1 c += 1 d = 0 - + return Dnkj, hessian def inverseMobility(chemical_potentials, composition_set, refElement, mobility_callables, mobility_correction = None, returnOther = True, parameters = {}): diff --git a/kawin/thermo/Thermodynamics.py b/kawin/thermo/Thermodynamics.py index 9360e84..f5d2175 100644 --- a/kawin/thermo/Thermodynamics.py +++ b/kawin/thermo/Thermodynamics.py @@ -3,7 +3,7 @@ from pycalphad.codegen.callables import build_callables, build_phase_records from pycalphad.core.composition_set import CompositionSet from pycalphad.core.utils import extract_parameters -from kawin.thermo.Mobility import MobilityModel, inverseMobility, inverseMobility_from_diffusivity, tracer_diffusivity, tracer_diffusivity_from_diff +from kawin.thermo.Mobility import MobilityModel, inverseMobility, inverseMobility_from_diffusivity, tracer_diffusivity, tracer_diffusivity_from_diff, interdiffusivity, interdiffusivity_from_diff from kawin.thermo.FreeEnergyHessian import dMudX from kawin.thermo.LocalEquilibrium import local_equilibrium import matplotlib.pyplot as plt @@ -557,15 +557,15 @@ def _interdiffusivitySingle(self, x, T, removeCache = True, phase = None): chemical_potentials = self._parentEq.chemical_potentials if self.mobCallables[phase] is None: - Dnkj, _, _ = inverseMobility_from_diffusivity(chemical_potentials, cs_matrix, - self.elements[0], self.diffCallables[phase], - diffusivity_correction=self.mobility_correction, - parameters = self._parameters) + Dnkj = interdiffusivity_from_diff(chemical_potentials, cs_matrix, self.elements[0], + self.mobCallables[phase], + mobility_correction=self.mobility_correction, + parameters=self._parameters) else: - Dnkj, _, _ = inverseMobility(chemical_potentials, cs_matrix, self.elements[0], - self.mobCallables[phase], - mobility_correction=self.mobility_correction, - parameters=self._parameters) + Dnkj, _ = interdiffusivity(chemical_potentials, cs_matrix, self.elements[0], + self.mobCallables[phase], + mobility_correction=self.mobility_correction, + parameters=self._parameters) if len(x) == 1: return Dnkj.ravel()[0] From 6d404ca3808c7daa8ea82a8f436db7598fd200b3 Mon Sep 17 00:00:00 2001 From: Ury Date: Wed, 17 Apr 2024 16:31:51 -0700 Subject: [PATCH 03/53] refactor eq and non-eq error functions --- .../error_functions/cached_mobility.py | 2 +- .../equilibrium_mobility_error.py | 215 ++++++++++ .../error_functions/interdiffusivity_error.py | 201 --------- .../non_equilibrium_mobility_error.py | 208 ++++++++++ .../tracer_diffusivity_error.py | 388 ------------------ .../mobility_fitting/error_functions/utils.py | 40 ++ kawin/mobility_fitting/liquid_mobility.py | 35 ++ kawin/mobility_fitting/manual_fitting.py | 117 ++++-- kawin/mobility_fitting/utils.py | 17 +- kawin/thermo/Mobility.py | 32 +- 10 files changed, 628 insertions(+), 627 deletions(-) create mode 100644 kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py delete mode 100644 kawin/mobility_fitting/error_functions/interdiffusivity_error.py create mode 100644 kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py delete mode 100644 kawin/mobility_fitting/error_functions/tracer_diffusivity_error.py create mode 100644 kawin/mobility_fitting/error_functions/utils.py create mode 100644 kawin/mobility_fitting/liquid_mobility.py diff --git a/kawin/mobility_fitting/error_functions/cached_mobility.py b/kawin/mobility_fitting/error_functions/cached_mobility.py index 4484295..6d3e1bf 100644 --- a/kawin/mobility_fitting/error_functions/cached_mobility.py +++ b/kawin/mobility_fitting/error_functions/cached_mobility.py @@ -40,7 +40,7 @@ def compute_symbolic_quick(dof, elements, mobility_model, symbol, parameters = { for p,val in zip(param_keys, param_values[0]): var_dict[p] = val - return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))]) + return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))], dtype=np.float_) def mobility_from_composition_set_symbolic_quick(dof, elements, mobility_model, parameters = {}): return compute_symbolic_quick(dof, elements, mobility_model, 'MQ', parameters) diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py new file mode 100644 index 0000000..535e6e4 --- /dev/null +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -0,0 +1,215 @@ +from collections import OrderedDict +from typing import Sequence, Dict, Union, List, Optional + +import numpy as np +from pycalphad import Database, variables as v +from pycalphad.core.utils import filter_phases, unpack_components, unpack_condition, extract_parameters +from scipy.stats import norm +import tinydb + +from espei.phase_models import PhaseModelSpecification +from espei.typing import SymbolName +from espei.utils import PickleableTinyDB, database_symbols_to_fit +from espei.error_functions.residual_base import ResidualFunction, residual_function_registry + +from kawin.thermo.LocalEquilibrium import local_equilibrium +from kawin.thermo.FreeEnergyHessian import partialdMudX +from itertools import product + +import kawin.mobility_fitting.error_functions.cached_mobility as cmob +from kawin.mobility_fitting.error_functions.utils import get_output_base_name, get_base_names, build_model, get_base_std + +class EquilibriumMobilityData: + def __init__(self, dbf, data, parameters = None, data_weight_dict = None): + self.parameters = parameters if parameters is not None else {} + self.parameter_keys = [p for p in self.parameters] + self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} + self.output = get_output_base_name(data['output']) + + pot_conds = OrderedDict([(getattr(v, key), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if not key.startswith('X_')]) + comp_conds = OrderedDict([(v.X(key[2:]), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if key.startswith('X_')]) + rav_comp_conds = [OrderedDict(zip(comp_conds.keys(), pt_comps)) for pt_comps in zip(*comp_conds.values())] + + self.comps = data['components'] + self.elements = sorted(list(set([v.Species(c).name for c in self.comps]))) + self.non_va_elements = sorted(list(set(self.elements) - set(['VA']))) + self.phases = data['phases'] + self.refComp = data.get('ref_el', None) + if self.refComp is None and 'TRACER' in data['output']: + self.refComp = [data['output'][len(self.output)+1:]] + + self.depComps = data.get('dependent_el', []) + self.diffusing_species = sorted(list(set(self.refComp) | set(self.depComps) | set(self.elements) - set(['VA']))) + self.models, self.phase_records, self.mob_models, self.mob_callables = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) + self.mobility_correction = {c:1 for c in self.non_va_elements} + + self.conditions = {} + for c in data['conditions']: + condList = unpack_condition(data['conditions'][c]) + if 'X_' not in c: + self.conditions[getattr(v,c)] = condList + self.conditions['composition'] = rav_comp_conds + + self.values = np.array(data['values']) + self._compute_cached_equilibrium(dbf) + + total_num_calculations = len(rav_comp_conds)*np.prod([len(vals) for vals in pot_conds.values()]) + dataset_weights = np.array(data.get('weight', 1.0)) * np.ones(total_num_calculations) + property_std_deviation = get_base_std() + self.weights = (property_std_deviation.get(self.output, 1.0)/data_weight_dict.get(self.output, 1.0)/dataset_weights).flatten() + + def _compute_cached_equilibrium(self, dbf): + self.cache = {} + + keys, values = zip(*self.conditions.items()) + allConds = [dict(zip(keys,p)) for p in product(*values)] + + for i in range(len(allConds)): + inds = np.array([self.conditions[k].index(v) for k,v in allConds[i].items()], dtype=np.int32) + + currConds = {v.N: 1, v.GE: 0, v.P: allConds[i][v.P], v.T: allConds[i][v.T]} + for c in allConds[i]['composition']: + currConds[c] = allConds[i]['composition'][c] + + #Grab data from global cache + result, cs = local_equilibrium(dbf, self.elements, self.phases, currConds, self.models, self.phase_records) + cs_el = list(cs[0].phase_record.nonvacant_elements) + cs_T = cs[0].dof[cs[0].phase_record.state_variables.index(v.T)] + cs_dof = np.array(cs[0].dof) + cs_X = np.array(cs[0].X) + cs_dmudx = partialdMudX(result.chemical_potentials, cs[0]) + self.cache[tuple(inds)] = (cs_el, cs_T, cs_dof, cs_X, cs_dmudx) + +def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], datasets: PickleableTinyDB, parameters: Dict[str, float], data_weight_dict: Optional[Dict[str, float]] = None): + ''' + Return the ZPF data used in the calculation of ZPF error + + Parameters + ---------- + comps : list + List of active component names + phases : list + List of phases to consider + datasets : espei.utils.PickleableTinyDB + Datasets that contain single phase data + parameters : dict + Dictionary mapping symbols to optimize to their initial values + model : Optional[Dict[str, Type[Model]]] + Dictionary phase names to pycalphad Model classes. + + Returns + ------- + list + List of data dictionaries with keys ``weight``, ``phase_regions`` and ``dataset_references``. + ''' + base_names = get_base_names() + desired_data = datasets.search((tinydb.where('output').test(lambda x: get_output_base_name(x) in base_names)) & + (tinydb.where('components').test(lambda x: set(x).issubset(comps))) & + (tinydb.where('phases').test(lambda x: len(set(phases).intersection(x)) > 0)) & + (~tinydb.where('solver').exists())) + + mod_data = [] + for data in desired_data: + mod_data.append(EquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) + return mod_data + +def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray): + diffs, wts = [], [] + paramDict = {data.parameter_keys[i] : parameters[i] for i in range(len(data.parameter_keys))} + + #Update phase record parameters + param_keys, param_values = extract_parameters(paramDict) + for p in data.phases: + data.phase_records[p].parameters[:] = np.asarray(param_values, dtype=np.float_) + + keys, values = zip(*data.conditions.items()) + allConds = [dict(zip(keys,p)) for p in product(*values)] + for i in range(len(allConds)): + inds = np.array([data.conditions[k].index(v) for k,v in allConds[i].items()], dtype=np.int32) + value = data.values[tuple(inds)] + cs_data = data.cache[tuple(inds)] + + cs_el, cs_T, cs_dof, cs_X, cs_dmudx = cs_data + mob_from_CS = cmob.mobility_from_composition_set_quick(cs_dof, cs_el, data.mob_callables[data.phases[0]], data.mobility_correction, parameters = paramDict) + + refIndex = data.non_va_elements.index(data.refComp[0]) + + if data.output == 'INTER_DIFF': + mobMatrix = cmob.mobility_matrix_quick(cs_dof, cs_X, cs_el, mob_from_CS, data.phase_records[data.phases[0]]) + cd, _ = cmob.chemical_diffusivity_quick(cs_dmudx, mobMatrix) + + depComp1 = data.non_va_elements.index(data.depComps[0]) + depComp2 = data.non_va_elements.index(data.depComps[1]) + D = cd[depComp1, depComp2] - cd[depComp1, refIndex] + diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) + + elif data.output == 'TRACER_DIFF': + tracer_diff = cmob.tracer_diffusivity_quick(cs_T, mob_from_CS) + D = tracer_diff[refIndex] + diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) + + elif data.output == 'TRACER_D0': + D0 = cmob.prefactor_from_composition_set_quick(cs_dof, cs_el, data.mob_models[data.phases[0]], parameters = paramDict) + D = np.exp(D0[refIndex]) + diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) + + elif data.output == 'TRACER_Q': + Qs = cmob.activation_energy_from_composition_set_quick(cs_dof, cs_el, data.mob_models[data.phases[0]], parameters = paramDict) + Q = Qs[refIndex] + diffs.append(Q - value) + + wts.append(data.weights[i]) + + return diffs, wts + +def calculate_mob_probability(mob_data : Sequence[EquilibriumMobilityData], parameters : np.ndarray) -> float: + differences = [] + weights = [] + for data in mob_data: + diffs, wts = calc_mob_differences(data, parameters) + if np.any(np.isinf(diffs) | np.isnan(diffs)): + return -np.inf + differences.append(diffs) + weights.append(wts) + + differences = np.concatenate(differences, axis=0) + weights = np.concatenate(weights, axis=0) + probs = norm(loc=0.0, scale=weights).logpdf(differences) + return np.sum(probs) + +class EquilibriumMobilityResidual(ResidualFunction): + def __init__( + self, + database: Database, + datasets: PickleableTinyDB, + phase_models: Union[PhaseModelSpecification, None], + symbols_to_fit: Optional[List[SymbolName]] = None, + weight: Optional[Dict[str, float]] = None, + additional_mcmc_args: Optional[Dict] = {}, + ): + super().__init__(database, datasets, phase_models, symbols_to_fit) + if weight is not None: + weight = {name: weight.get(name, 1.0) for name in get_base_names()} + else: + weight = {name: 1.0 for name in get_base_names()} + if phase_models is not None: + comps = sorted(phase_models.components) + else: + comps = sorted(database.elements) + phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) + if symbols_to_fit is None: + symbols_to_fit = database_symbols_to_fit(database) + # okay if parameters are initialized to zero, we only need the symbol names + parameters = dict(zip(symbols_to_fit, [0]*len(symbols_to_fit))) + + self.mob_data = get_mob_data(database, comps, phases, datasets, parameters, weight) + + def get_likelihood(self, parameters): + likelihood = calculate_mob_probability(self.mob_data, parameters) + return likelihood + + def __getstate__(self): + print('i am pickled') + return self.__dict__ + +residual_function_registry.register(EquilibriumMobilityResidual) diff --git a/kawin/mobility_fitting/error_functions/interdiffusivity_error.py b/kawin/mobility_fitting/error_functions/interdiffusivity_error.py deleted file mode 100644 index af65f30..0000000 --- a/kawin/mobility_fitting/error_functions/interdiffusivity_error.py +++ /dev/null @@ -1,201 +0,0 @@ -from collections import OrderedDict -from typing import Sequence, Dict, Union, List, Optional - -import numpy as np -from pycalphad import Database, variables as v -from pycalphad.core.utils import filter_phases, unpack_components, unpack_condition -from scipy.stats import norm -import tinydb - -from espei.phase_models import PhaseModelSpecification -from espei.typing import SymbolName -from espei.utils import PickleableTinyDB, database_symbols_to_fit -from espei.error_functions.residual_base import ResidualFunction, residual_function_registry - -from kawin.thermo import GeneralThermodynamics -from kawin.thermo.LocalEquilibrium import local_equilibrium -from kawin.thermo.FreeEnergyHessian import partialdMudX -from itertools import product - -import kawin.mobility_fitting.cached_mobility as cmob - -def getCachedData(cache, conds, data): - strConds = {c.__str__(): conds[c] for c in conds} - hashStr = str(strConds) - if hashStr in cache: - return cache[hashStr] - else: - result, cs = local_equilibrium(data.thermo.db, data.thermo.elements, data.thermo.phases, conds, data.thermo.models, data.thermo.phase_records) - cs_el = list(cs[0].phase_record.nonvacant_elements) - cs_T = cs[0].dof[cs[0].phase_record.state_variables.index(v.T)] - cs_dof = np.array(cs[0].dof) - cs_X = np.array(cs[0].X) - cs_dmudx = partialdMudX(result.chemical_potentials, cs[0]) - cache[hashStr] = (cs_el, cs_T, cs_dof, cs_X, cs_dmudx) - return cache[hashStr] - -class InterdiffusivityData: - def __init__(self, dbf, data, parameters = None, data_weight_dict = None): - self.dbf = dbf - self.parameters = parameters if parameters is not None else {} - self.parameter_keys = [p for p in self.parameters] - self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} - self.output = data['output'] - self.property_std_deviation = { - 'D': 0.1 # decade - } - - pot_conds = OrderedDict([(getattr(v, key), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if not key.startswith('X_')]) - comp_conds = OrderedDict([(v.X(key[2:]), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if key.startswith('X_')]) - rav_comp_conds = [OrderedDict(zip(comp_conds.keys(), pt_comps)) for pt_comps in zip(*comp_conds.values())] - - comps = data['components'] - phases = data['phases'] - self.refComp = data.get('ref_el') - self.depComps = data.get('dependent_el', []) - self.thermo = GeneralThermodynamics(dbf, comps, phases, parameters=parameters) - self.conditions = {} - for c in data['conditions']: - condList = unpack_condition(data['conditions'][c]) - if 'X_' not in c: - self.conditions[getattr(v,c)] = condList - self.conditions['composition'] = rav_comp_conds - - self.values = np.array(data['values']) - - total_num_calculations = len(rav_comp_conds)*np.prod([len(vals) for vals in pot_conds.values()]) - dataset_weights = np.array(data.get('weight', 1.0)) * np.ones(total_num_calculations) - self.weights = (self.property_std_deviation.get('D', 1.0)/data_weight_dict.get('D', 1.0)/dataset_weights).flatten() - -def get_diff_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], datasets: PickleableTinyDB, parameters: Dict[str, float], data_weight_dict: Optional[Dict[str, float]] = None): - ''' - Return the ZPF data used in the calculation of ZPF error - - Parameters - ---------- - comps : list - List of active component names - phases : list - List of phases to consider - datasets : espei.utils.PickleableTinyDB - Datasets that contain single phase data - parameters : dict - Dictionary mapping symbols to optimize to their initial values - model : Optional[Dict[str, Type[Model]]] - Dictionary phase names to pycalphad Model classes. - - Returns - ------- - list - List of data dictionaries with keys ``weight``, ``phase_regions`` and ``dataset_references``. - ''' - desired_data = datasets.search((tinydb.where('output').test(lambda x: 'INTER_DIFF' in x)) & - (tinydb.where('components').test(lambda x: set(x).issubset(comps))) & - (tinydb.where('phases').test(lambda x: len(set(phases).intersection(x)) > 0))) - - diff_data = [] - for data in desired_data: - diff_data.append(InterdiffusivityData(dbf, data, parameters, data_weight_dict)) - return diff_data - -def calc_diff_differences(data : InterdiffusivityData, parameters : np.ndarray, thermoCache : Dict): - diffs, wts = [], [] - paramDict = {} - for i in range(len(data.parameter_keys)): - paramDict[data.parameter_keys[i]] = parameters[i] - data.thermo.updateParameters(paramDict) - - nonVaElements = sorted([e for e in data.thermo.elements if e != 'VA']) - - keys, values = zip(*data.conditions.items()) - allConds = [dict(zip(keys,p)) for p in product(*values)] - for i in range(len(allConds)): - inds = np.array([data.conditions[k].index(v) for k,v in allConds[i].items()], dtype=np.int32) - dexp = data.values[tuple(inds)] - - currConds = {v.N: 1, v.GE: 0, v.P: allConds[i][v.P], v.T: allConds[i][v.T]} - for c in allConds[i]['composition']: - currConds[c] = allConds[i]['composition'][c] - - #Grab data from global cache - cs_data = getCachedData(thermoCache, currConds, data) - cs_el, cs_T, cs_dof, cs_X, cs_dmudx = cs_data - mob_from_CS = cmob.mobility_from_composition_set_quick(cs_dof, cs_el, data.thermo.mobCallables[data.thermo.phases[0]], data.thermo.mobility_correction, parameters = data.thermo._parameters) - - #eq_result = local_equilibrium(data.thermo.db, data.thermo.elements, data.thermo.phases, currConds, data.thermo.models, data.thermo.phase_records) - #result, cs = eq_result - - if data.refComp is None: - refComp = data.output.split('_')[-1] - refIndex = nonVaElements.index(refComp) - else: - refIndex = nonVaElements.index(data.refComp[0]) - - if 'INTER_DIFF' in data.output: - #cd, _ = chemical_diffusivity(result.chemical_potentials, cs[0], data.thermo.mobCallables[data.thermo.phases[0]], data.thermo.mobility_correction, parameters = data.thermo._parameters) - - mobMatrix = cmob.mobility_matrix_quick(cs_dof, cs_X, cs_el, mob_from_CS, data.thermo.phase_records[data.thermo.phases[0]]) - cd, _ = cmob.chemical_diffusivity_quick(cs_dmudx, mobMatrix) - - depComp1 = nonVaElements.index(data.depComps[0]) - depComp2 = nonVaElements.index(data.depComps[1]) - D = cd[depComp1, depComp2] - cd[depComp1, refIndex] - diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(dexp)*np.log10(np.abs(dexp)))) - wts.append(data.weights[i]) - - return diffs, wts - -def calculate_diff_probability(diff_data : Sequence[InterdiffusivityData], parameters : np.ndarray, thermoCache : Dict) -> float: - differences = [] - weights = [] - for data in diff_data: - diffs, wts = calc_diff_differences(data, parameters, thermoCache) - if np.any(np.isinf(diffs) | np.isnan(diffs)): - return -np.inf - differences.append(diffs) - weights.append(wts) - - differences = np.concatenate(differences, axis=0) - weights = np.concatenate(weights, axis=0) - probs = norm(loc=0.0, scale=weights).logpdf(differences) - return np.sum(probs) - -class InterdiffusivityResidual(ResidualFunction): - def __init__( - self, - database: Database, - datasets: PickleableTinyDB, - phase_models: Union[PhaseModelSpecification, None], - symbols_to_fit: Optional[List[SymbolName]] = None, - weight: Optional[Dict[str, float]] = None, - additional_mcmc_args: Optional[Dict] = {}, - ): - super().__init__(database, datasets, phase_models, symbols_to_fit) - if weight is not None: - self.weight = weight.get("ZPF", 1.0) - else: - self.weight = 1.0 - if phase_models is not None: - comps = sorted(phase_models.components) - model_dict = phase_models.get_model_dict() - else: - comps = sorted(database.elements) - model_dict = dict() - phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) - if symbols_to_fit is None: - symbols_to_fit = database_symbols_to_fit(database) - # okay if parameters are initialized to zero, we only need the symbol names - parameters = dict(zip(symbols_to_fit, [0]*len(symbols_to_fit))) - self.diff_data = get_diff_data(database, comps, phases, datasets, parameters, model_dict) - - self.thermoCache = {} - - def get_likelihood(self, parameters): - likelihood = calculate_diff_probability(self.diff_data, parameters, self.thermoCache) - return likelihood - - def __getstate__(self): - print('i am pickled') - return self.__dict__ - -residual_function_registry.register(InterdiffusivityResidual) diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py new file mode 100644 index 0000000..350019f --- /dev/null +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -0,0 +1,208 @@ +""" +Calculate error due to thermochemical quantities: heat capacity, entropy, enthalpy. +""" + +import logging +from collections import OrderedDict +from typing import Any, Dict, List, NewType, Optional, Tuple, Union, Sequence + +from scipy.stats import norm +import numpy as np +import numpy.typing as npt +from tinydb import where + +from pycalphad import Database, variables as v +from pycalphad.core.utils import unpack_components, filter_phases, unpack_condition, extract_parameters + +from espei.datasets import Dataset +from espei.core_utils import ravel_conditions, get_prop_data, filter_temperatures +from espei.phase_models import PhaseModelSpecification +from espei.sublattice_tools import canonicalize, recursive_tuplify, tuplify +from espei.typing import SymbolName +from espei.utils import database_symbols_to_fit, PickleableTinyDB +from espei.error_functions.residual_base import ResidualFunction, residual_function_registry +from espei.error_functions.non_equilibrium_thermochemical_error import FixedConfigurationCalculationData, filter_sublattice_configurations, calculate_points_array + +import kawin.mobility_fitting.error_functions.cached_mobility as cmob +from kawin.thermo.Mobility import MobilityModel +from kawin.mobility_fitting.error_functions.utils import get_output_base_name, get_base_names, build_model, get_base_std + +import tinydb + +_log = logging.getLogger(__name__) + +class NonEquilibriumMobilityData: + def __init__(self, dbf, data, parameters = None, data_weight_dict = None): + self.parameters = parameters if parameters is not None else {} + self.parameter_keys = [p for p in self.parameters] + self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} + self.output = get_output_base_name(data['output']) + + self.comps = data['components'] + self.elements = sorted(list(set([v.Species(c).name for c in self.comps]))) + self.non_va_elements = sorted(list(set(self.elements) - set(['VA']))) + self.phases = data['phases'] + self.refComp = data.get('ref_el', None) + if self.refComp is None and 'TRACER' in data['output']: + self.refComp = [data['output'][len(self.output)+1:]] + + self.depComps = data.get('dependent_el', []) + self.diffusing_species = sorted(list(set(self.refComp) | set(self.depComps) | set(self.elements) - set(['VA']))) + self.models, self.phase_records, self.mob_models, self.mob_callables = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) + self.mobility_correction = {c:1 for c in self.non_va_elements} + + self._processConditions(data) + + dataset_weights = np.array(data.get('weight', 1.0)) * np.ones(len(self.values)) + property_std_deviation = get_base_std() + self.weights = (property_std_deviation.get(self.output, 1.0)/data_weight_dict.get(self.output, 1.0)/dataset_weights).flatten() + + def _processConditions(self, data): + T = data['conditions']['T'] + P = data['conditions']['P'] + values = np.array(data['values']) + self.values = values.flatten() + self.P, self.T = ravel_conditions(values, P, T) + + sub_conf = data['solver']['sublattice_configurations'] + sub_occ = data['solver']['sublattice_occupancies'] + phase_cons = [[c.name for c in s] for s in self.models[self.phases[0]].constituents] + single_points = np.array([calculate_points_array(phase_cons, conf, occ) for conf, occ in zip(sub_conf, sub_occ)]) + self.points = np.tile(single_points, (values.shape[0]*values.shape[1], 1)) + +def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], datasets: PickleableTinyDB, parameters: Dict[str, float], data_weight_dict: Optional[Dict[str, float]] = None): + ''' + Return the ZPF data used in the calculation of ZPF error + + Parameters + ---------- + comps : list + List of active component names + phases : list + List of phases to consider + datasets : espei.utils.PickleableTinyDB + Datasets that contain single phase data + parameters : dict + Dictionary mapping symbols to optimize to their initial values + model : Optional[Dict[str, Type[Model]]] + Dictionary phase names to pycalphad Model classes. + + Returns + ------- + list + List of data dictionaries with keys ``weight``, ``phase_regions`` and ``dataset_references``. + ''' + base_names = get_base_names() + #Don't support interdiffusivity for now + #I suppose it is possible to support it by computing composition from + # the site fractions and computing it similar to equilibrium mobility error, + # but I feel like you may as well set the dataset to be an equilibrium data at + # that point + #Does interdiffusivity even make sense to have a value at a specific sublattice configuration? + base_names = list(set(base_names) - set(['INTER_DIFF'])) + desired_data = datasets.search((tinydb.where('output').test(lambda x: get_output_base_name(x) in base_names)) & + (tinydb.where('components').test(lambda x: set(x).issubset(comps))) & + (tinydb.where('phases').test(lambda x: len(set(phases).intersection(x)) > 0)) & + (tinydb.where('solver').exists())) + + mod_data = [] + for data in desired_data: + mod_data.append(NonEquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) + return mod_data + +def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndarray): + diffs, wts = [], [] + paramDict = {data.parameter_keys[i] : parameters[i] for i in range(len(data.parameter_keys))} + + #Update phase record parameters + param_keys, param_values = extract_parameters(paramDict) + for p in data.phases: + data.phase_records[p].parameters[:] = np.asarray(param_values, dtype=np.float_) + + state_variables = sorted([v.T, v.P, v.N, v.GE]) + + for i in range(len(data.values)): + T = data.T[i] + P = data.P[i] + value = data.values[i] + point = data.points[i] + + dof = np.zeros(4 + len(data.mob_models[data.phases[0]].site_fractions)) + dof[state_variables.index(v.T)] = T + dof[state_variables.index(v.P)] = P + dof[state_variables.index(v.N)] = 1 + dof[4:] = point + + refIndex = data.diffusing_species.index(data.refComp[0]) + + if data.output == 'TRACER_DIFF': + calculated_values = cmob.mobility_from_composition_set_symbolic_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) + r = calculated_values[refIndex] + elif data.output == 'TRACER_Q': + calculated_values = cmob.activation_energy_from_composition_set_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) + r = calculated_values[refIndex] + elif data.output == 'TRACER_D0': + calculated_values = cmob.prefactor_from_composition_set_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) + r = calculated_values[refIndex] + + if data.output == 'TRACER_DIFF': + r = np.sign(r) * np.log10(np.abs(r)) + value = np.sign(value) * np.log10(np.abs(value)) + elif data.output == 'TRACER_D0': + r = np.sign(r) * np.log10(np.exp(r)) + value = np.sign(value) * np.log10(np.abs(value)) + + diffs.append(r - value) + wts.append(data.weights[i]) + + return diffs, wts + +def calculate_mob_probability(mob_data : Sequence[NonEquilibriumMobilityData], parameters : np.ndarray) -> float: + differences = [] + weights = [] + for data in mob_data: + diffs, wts = calc_mob_differences(data, parameters) + if np.any(np.isinf(diffs) | np.isnan(diffs)): + return -np.inf + differences.append(diffs) + weights.append(wts) + + differences = np.concatenate(differences, axis=0) + weights = np.concatenate(weights, axis=0) + probs = norm(loc=0.0, scale=weights).logpdf(differences) + return np.sum(probs) + +class NonEquilibriumMobilityResidual(ResidualFunction): + def __init__( + self, + database: Database, + datasets: PickleableTinyDB, + phase_models: Union[PhaseModelSpecification, None], + symbols_to_fit: Optional[List[SymbolName]] = None, + weight: Optional[Dict[str, float]] = None, + additional_mcmc_args: Optional[Dict] = {}, + ): + super().__init__(database, datasets, phase_models, symbols_to_fit) + if weight is not None: + weight = {name: weight.get(name, 1.0) for name in get_base_names()} + else: + weight = {name: 1.0 for name in get_base_names()} + if phase_models is not None: + comps = sorted(phase_models.components) + else: + comps = sorted(database.elements) + phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) + if symbols_to_fit is None: + symbols_to_fit = database_symbols_to_fit(database) + # okay if parameters are initialized to zero, we only need the symbol names + parameters = dict(zip(symbols_to_fit, [0]*len(symbols_to_fit))) + + self.mob_data = get_mob_data(database, comps, phases, datasets, parameters, weight) + + def get_likelihood(self, parameters) -> float: + likelihood = calculate_mob_probability(self.mob_data, parameters) + return likelihood + + +residual_function_registry.register(NonEquilibriumMobilityResidual) + diff --git a/kawin/mobility_fitting/error_functions/tracer_diffusivity_error.py b/kawin/mobility_fitting/error_functions/tracer_diffusivity_error.py deleted file mode 100644 index b3f3e41..0000000 --- a/kawin/mobility_fitting/error_functions/tracer_diffusivity_error.py +++ /dev/null @@ -1,388 +0,0 @@ -""" -Calculate error due to thermochemical quantities: heat capacity, entropy, enthalpy. -""" - -import logging -from collections import OrderedDict -from typing import Any, Dict, List, NewType, Optional, Tuple, Union - -from scipy.stats import norm -import numpy as np -import numpy.typing as npt -from tinydb import where - -from pycalphad import Database, variables as v -from pycalphad.core.utils import unpack_components, filter_phases - -from espei.datasets import Dataset -from espei.core_utils import ravel_conditions, get_prop_data, filter_temperatures -from espei.phase_models import PhaseModelSpecification -from espei.sublattice_tools import canonicalize, recursive_tuplify, tuplify -from espei.typing import SymbolName -from espei.utils import database_symbols_to_fit, PickleableTinyDB -from espei.error_functions.residual_base import ResidualFunction, residual_function_registry - -import kawin.mobility_fitting.cached_mobility as cmob -from kawin.thermo.Mobility import MobilityModel - -import tinydb - -_log = logging.getLogger(__name__) - -# TODO: make into an object similar to how ZPF data works? -FixedConfigurationCalculationData = NewType("FixedConfigurationCalculationData", Dict[str, Any]) - -def filter_sublattice_configurations(desired_data: List[Dataset], subl_model) -> List[Dataset]: # TODO: symmetry support - """Modify the desired_data to remove any configurations that cannot be represented by the sublattice model.""" - subl_model_sets = [set(subl) for subl in subl_model] - for data in desired_data: - matching_configs = [] # binary mask of whether a configuration is represented by the sublattice model - for config in data['solver']['sublattice_configurations']: - config = recursive_tuplify(canonicalize(config, None)) - if ( - len(config) == len(subl_model) and - all(subl.issuperset(tuplify(config_subl)) for subl, config_subl in zip(subl_model_sets, config)) - ): - matching_configs.append(True) - else: - matching_configs.append(False) - matching_configs = np.asarray(matching_configs, dtype=np.bool_) - - # Rewrite output values with filtered data - data['values'] = np.array(data['values'], dtype=np.float_)[..., matching_configs] - data['solver']['sublattice_configurations'] = np.array(data['solver']['sublattice_configurations'], dtype=np.object_)[matching_configs].tolist() - if 'sublattice_occupancies' in data['solver']: - data['solver']['sublattice_occupancies'] = np.array(data['solver']['sublattice_occupancies'], dtype=np.object_)[matching_configs].tolist() - return desired_data - - -def calculate_points_array(phase_constituents, configuration, occupancies=None): - """ - Calculate the points array to use in pycalphad calculate calls. - - Converts the configuration data (and occupancies for mixing data) into the - points array by looking up the indices in the active phase constituents. - - Parameters - ---------- - phase_constituents : list - List of active constituents in a phase - configuration : list - List of the sublattice configuration - occupancies : list - List of sublattice occupancies. Required for mixing sublattices, otherwise takes no effect. - - Returns - ------- - numpy.ndarray - - Notes - ----- - Errors will be raised if components in the configuration are not in the - corresponding phase constituents sublattice. - """ - # pad the occupancies for zipping if none were passed (the case for non-mixing) - if occupancies is None: - occupancies = [0] * len(configuration) - - # construct the points array from zeros - points = np.zeros(sum(len(subl) for subl in phase_constituents)) - current_subl_idx = 0 # index that marks the beginning of the sublattice - for phase_subl, config_subl, subl_occupancies in zip(phase_constituents, configuration, occupancies): - phase_subl = list(phase_subl) - if isinstance(config_subl, (tuple, list)): - # we have mixing on the sublattice - for comp, comp_occupancy in zip(config_subl, subl_occupancies): - points[current_subl_idx + phase_subl.index(comp)] = comp_occupancy - else: - points[current_subl_idx + phase_subl.index(config_subl)] = 1 - current_subl_idx += len(phase_subl) - return points - - -def get_prop_samples(desired_data, constituents): - """ - Return data values and the conditions to calculate them using pycalphad.calculate - - Parameters - ---------- - desired_data : List[Dict[str, Any]] - List of dataset dictionaries that contain the values to sample - constituents : List[List[str]] - Names of constituents in each sublattice. - - Returns - ------- - Dict[str, Union[float, ArrayLike, List[float]]] - Dictionary of condition kwargs for pycalphad's calculate and the expected values - - """ - # TODO: assumes T, P as conditions - # calculate needs points, state variable lists, and values to compare to - num_dof = sum(map(len, constituents)) - calculate_dict = { - 'P': np.array([]), - 'T': np.array([]), - 'points': np.atleast_2d([[]]).reshape(-1, num_dof), - 'values': np.array([]), - 'weights': [], - 'references': [], - 'ref_el': None, - } - - for datum in desired_data: - #reference element - # If ref_el exist, then grab reference element from there - # If not, then grab from end of output name - ref_el = datum.get('ref_el', None) - if ref_el is None: - output_name = datum.get('output') - ref_el = output_name.split('_')[-1] - calculate_dict['ref_el'] = ref_el - - # extract the data we care about - datum_T = datum['conditions']['T'] - datum_P = datum['conditions']['P'] - configurations = datum['solver']['sublattice_configurations'] - occupancies = datum['solver'].get('sublattice_occupancies') - values = np.array(datum['values']) - if values.size == 0: - # Skip any data that don't have any values left (e.g. after filtering) - continue - # Broadcast the weights to the shape of the values. This ensures that - # the sizes of the weights and values are the same, which is important - # because they are flattened later (so the shape information is lost). - weights = np.broadcast_to(np.asarray(datum.get('weight', 1.0)), values.shape) - - # broadcast and flatten the conditions arrays - P, T = ravel_conditions(values, datum_P, datum_T) - if occupancies is None: - occupancies = [None] * len(configurations) - - # calculate the points arrays, should be 2d array of points arrays - points = np.array([calculate_points_array(constituents, config, occup) for config, occup in zip(configurations, occupancies)]) - assert values.shape == weights.shape, f"Values data shape {values.shape} does not match weights shape {weights.shape}" - - # add everything to the calculate_dict - calculate_dict['P'] = np.concatenate([calculate_dict['P'], P]) - calculate_dict['T'] = np.concatenate([calculate_dict['T'], T]) - calculate_dict['points'] = np.concatenate([calculate_dict['points'], np.tile(points, (values.shape[0]*values.shape[1], 1))], axis=0) - calculate_dict['values'] = np.concatenate([calculate_dict['values'], values.flatten()]) - calculate_dict['weights'].extend(weights.flatten()) - calculate_dict['references'].extend([datum.get('reference', "") for _ in range(values.flatten().size)]) - return calculate_dict - - -def get_tracer_data(dbf, comps, phases, datasets, model=None, weight_dict=None, symbols_to_fit=None): - """ - - Parameters - ---------- - dbf : pycalphad.Database - Database to consider - comps : list - List of active component names - phases : list - List of phases to consider - datasets : espei.utils.PickleableTinyDB - Datasets that contain single phase data - model : Optional[Dict[str, Type[Model]]] - Dictionary phase names to pycalphad Model classes. - weight_dict : dict - Dictionary of weights for each data type, e.g. {'HM': 200, 'SM': 2} - symbols_to_fit : list - Parameters to fit. Used to build the models and PhaseRecords. - - Returns - ------- - list - List of data dictionaries to iterate over - """ - # phase by phase, then property by property, then by model exclusions - if weight_dict is None: - weight_dict = {} - - if model is None: - model = {} - - if symbols_to_fit is not None: - symbols_to_fit = sorted(symbols_to_fit) - else: - symbols_to_fit = database_symbols_to_fit(dbf) - - species_comps = set(unpack_components(dbf, comps)) - - # made up values - property_std_deviation = { - 'TRACER_DIFF': 1/weight_dict.get('TRACER_DIFF', 1.0), # decade - 'TRACER_D0': 1/weight_dict.get('TRACER_D0', 1.0), # decade - 'TRACER_Q': 10000/weight_dict.get('TRACER_Q', 1.0), # J/mol - } - properties = ['TRACER_DIFF', 'TRACER_D0', 'TRACER_Q'] - - all_data_dicts = [] - for phase_name in phases: - if phase_name not in dbf.phases: - continue - # phase constituents are Species objects, so we need to be doing intersections with those - phase_constituents = dbf.phases[phase_name].constituents - # phase constituents must be filtered to only active: - constituents = [[sp.name for sp in sorted(subl_constituents.intersection(species_comps))] for subl_constituents in phase_constituents] - prop_ext = [''] + list(set([f'_{e}' for e in comps]) - set(['_VA'])) - nonvaelements = sorted(list(set(comps) - set(['VA']))) - for prop_base in properties: - for ext in prop_ext: - prop = prop_base + ext - curr_data = get_prop_data(comps, phase_name, prop, datasets, additional_query=(where('solver').exists())) - if len(curr_data) == 0: - #Search for prop_EL to see if anything pops up - continue - - data_dict = { - 'phase_name': phase_name, - 'prop': prop_base, - # needs the following keys to be added: - # species, calculate_dict, phase_records, model, output, weights - } - curr_data = filter_sublattice_configurations(curr_data, constituents) - curr_data = filter_temperatures(curr_data) - calculate_dict = get_prop_samples(curr_data, constituents) - species = sorted(unpack_components(dbf, comps), key=str) - data_dict['species'] = species - data_dict['elements'] = nonvaelements - model_dict = MobilityModel(dbf, comps, phase_name, symbols_to_fit) - statevar_dict = {getattr(v, c, None): vals for c, vals in calculate_dict.items() if isinstance(getattr(v, c, None), v.StateVariable)} - statevar_dict = OrderedDict(sorted(statevar_dict.items(), key=lambda x: str(x[0]))) - str_statevar_dict = OrderedDict((str(k), vals) for k, vals in statevar_dict.items()) - data_dict['str_statevar_dict'] = str_statevar_dict - data_dict['calculate_dict'] = calculate_dict - data_dict['model'] = model_dict - data_dict['symbols'] = symbols_to_fit - data_dict['output'] = prop - data_dict['weights'] = np.array(property_std_deviation[prop_base])/np.array(calculate_dict.pop('weights')) - all_data_dicts.append(data_dict) - return all_data_dicts - -def compute_fixed_configuration_property_differences(calc_data: FixedConfigurationCalculationData, parameters): - sample_values = calc_data['calculate_dict']['values'] - x = calc_data['calculate_dict'] - - pDict = {k:val for k,val in zip(calc_data['symbols'], parameters)} - - state_variables = sorted([v.T, v.P, v.N, v.GE]) - results = np.zeros(len(sample_values)) - for i in range(len(x['points'])): - dof = np.zeros(4 + len(calc_data['model'].site_fractions)) - dof[state_variables.index(v.T)] = x['T'][i] - dof[state_variables.index(v.P)] = x['P'][i] - dof[state_variables.index(v.N)] = 1 - dof[4:] = x['points'][i] - - refIndex = calc_data['elements'].index(x['ref_el']) - - if calc_data['prop'] == 'TRACER_DIFF': - calculated_values = cmob.mobility_from_composition_set_symbolic_quick(dof, calc_data['elements'], calc_data['model'], pDict) - r = calculated_values[refIndex] - elif calc_data['prop'] == 'TRACER_Q': - calculated_values = cmob.activation_energy_from_composition_set_quick(dof, calc_data['elements'], calc_data['model'], pDict) - r = calculated_values[refIndex] - elif calc_data['prop'] == 'TRACER_D0': - calculated_values = cmob.prefactor_from_composition_set_quick(dof, calc_data['elements'], calc_data['model'], pDict) - r = calculated_values[refIndex] - else: - r = 0 - - results[i] = r - - if calc_data['prop'] == 'TRACER_DIFF': - results = np.sign(results) * np.log10(np.abs(results)) - sample_values = np.sign(sample_values) * np.log10(np.abs(sample_values)) - elif calc_data['prop'] == 'TRACER_D0': - results = np.exp(results) - results = np.sign(results) * np.log10(results) - sample_values = np.sign(sample_values) * np.log10(np.abs(sample_values)) - - differences = results - sample_values - return differences - - -def calculate_tracer_probability(tracer_data: List[FixedConfigurationCalculationData], parameters=None): - """ - Calculate the weighted single phase error in the Database - - Parameters - ---------- - thermochemical_data : list - List of thermochemical data dicts - parameters : np.ndarray - Array of parameters to calculate the error with. - - Returns - ------- - float - A single float of the residual sum of square errors - - """ - if parameters is None: - parameters = np.array([]) - - prob_error = 0.0 - for data in tracer_data: - phase_name = data['phase_name'] - sample_values = data['calculate_dict']['values'] - differences = compute_fixed_configuration_property_differences(data, parameters) - probabilities = norm.logpdf(differences, loc=0, scale=data['weights']) - prob_sum = np.sum(probabilities) - _log.debug("%s(%s) - probability sum: %0.2f, data: %s, differences: %s, probabilities: %s, references: %s", data['prop'], phase_name, prob_sum, sample_values, differences, probabilities, data['calculate_dict']['references']) - prob_error += prob_sum - return prob_error - - -class TracerDiffusivityResidual(ResidualFunction): - def __init__( - self, - database: Database, - datasets: PickleableTinyDB, - phase_models: Union[PhaseModelSpecification, None], - symbols_to_fit: Optional[List[SymbolName]] = None, - weight: Optional[Dict[str, float]] = None, - additional_mcmc_args: Optional[Dict] = {}, - ): - super().__init__(database, datasets, phase_models, symbols_to_fit, weight) - - if weight is not None: - self.weight = weight - else: - self.weight = {} - - if phase_models is not None: - comps = sorted(phase_models.components) - model_dict = phase_models.get_model_dict() - else: - comps = sorted(database.elements) - model_dict = dict() - phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) - if symbols_to_fit is None: - symbols_to_fit = database_symbols_to_fit(database) - self.tracer_data = get_tracer_data(database, comps, phases, datasets, model_dict, weight_dict=self.weight, symbols_to_fit=symbols_to_fit) - - def get_residuals(self, parameters: npt.ArrayLike) -> Tuple[List[float], List[float]]: - residuals = [] - weights = [] - for data in self.thermochemical_data: - dataset_residuals = compute_fixed_configuration_property_differences(data, parameters).tolist() - residuals.extend(dataset_residuals) - dataset_weights = np.asarray(data["weights"], dtype=float).flatten().tolist() - if len(dataset_weights) != len(dataset_residuals): - # we need to broadcast the residuals. For now, assume the weights are a scalar, since that's all that's supported - assert len(dataset_weights) == 1 - dataset_weights = [float(dataset_weights[0]) for _ in range(len(dataset_residuals))] - weights.extend(dataset_weights) - return residuals, weights - - def get_likelihood(self, parameters) -> float: - likelihood = calculate_tracer_probability(self.tracer_data, parameters) - return likelihood - - -residual_function_registry.register(TracerDiffusivityResidual) \ No newline at end of file diff --git a/kawin/mobility_fitting/error_functions/utils.py b/kawin/mobility_fitting/error_functions/utils.py new file mode 100644 index 0000000..790ad62 --- /dev/null +++ b/kawin/mobility_fitting/error_functions/utils.py @@ -0,0 +1,40 @@ +from pycalphad import Model, Database, calculate, equilibrium, variables as v +from pycalphad.codegen.callables import build_callables, build_phase_records +from pycalphad.core.utils import extract_parameters +from kawin.thermo.Mobility import MobilityModel + +def get_output_base_name(output_name): + base_names = get_base_names() + for bn in base_names: + if bn in output_name: + return bn + +def get_base_names(): + return ['INTER_DIFF', 'TRACER_DIFF', 'TRACER_D0', 'TRACER_Q'] + +def get_base_std(): + return { + 'INTER_DIFF': 0.1, # decade + 'TRACER_D0': 0.1, # decade + 'TRACER_DIFF': 0.1, # decade + 'TRACER_Q': 10000, # J/mol + } + +def build_model(db, elements, phase, parameters, diffusing_species): + param_keys, _ = extract_parameters(parameters) + model = {phase: Model(db, elements, phase, parameters=param_keys)} + model[phase].state_variables = sorted([v.T, v.P, v.N, v.GE], key=str) + + phase_record = build_phase_records(db, elements, [phase], model[phase].state_variables, + model, build_gradients=True, build_hessians=True, + parameters=parameters) + + mob_model = {phase: MobilityModel(db, elements, phase, parameters=param_keys)} + mob_model[phase].set_diffusing_species(db, diffusing_species) + mob_callable = {phase: {}} + diffusing_species = sorted(list(set(diffusing_species) - set(['VA']))) + for c in diffusing_species: + bcp = build_callables(db, elements, [phase], mob_model, parameter_symbols=parameters, output=f'MOB_{c}', build_gradients=False, build_hessians=False, additional_statevars=[v.T, v.P, v.N, v.GE]) + mob_callable[phase][c] = bcp[f'MOB_{c}']['callables'][phase] + + return model, phase_record, mob_model, mob_callable \ No newline at end of file diff --git a/kawin/mobility_fitting/liquid_mobility.py b/kawin/mobility_fitting/liquid_mobility.py new file mode 100644 index 0000000..19a9602 --- /dev/null +++ b/kawin/mobility_fitting/liquid_mobility.py @@ -0,0 +1,35 @@ +import numpy as np + +class SpeciesData: + def __init__(self, name, atomic_number, diameter, Tm, melting_phase = None): + self.name = name + self.atomic_number = atomic_number + self.diameter = diameter + self.Tm = Tm + self.melting_phase = melting_phase + self.K0 = self._getK0(melting_phase) + + def _getK0(self, melting_phase): + if melting_phase is None: + return 0 + + phases = {'BCC': 1, 'HCP': 2, 'FCC': 3} + for p in phases: + if p in melting_phase: + return phases[p] + return 0 + +def compute_liquid_mobility(species = list[SpeciesData]): + liquid_mobility_data = [] + n = len(species) + for i in range(n): + for j in range(n): + Q = 0.17 * 8.314 * species[i].Tm * (16 + species[i].K0) + D0 = (8.95 - 0.0734 * species[i].atomic_number) * 1e-8 + + d_ratio = species[i].diameter / species[j].diameter + D0 *= d_ratio + liquid_mobility_data.append((species[i].name, species[j].name, Q, D0)) + + return liquid_mobility_data + diff --git a/kawin/mobility_fitting/manual_fitting.py b/kawin/mobility_fitting/manual_fitting.py index be05d54..f3ddfdc 100644 --- a/kawin/mobility_fitting/manual_fitting.py +++ b/kawin/mobility_fitting/manual_fitting.py @@ -1,13 +1,16 @@ import numpy as np from pycalphad import Database, Model, variables as v from pycalphad.codegen.callables import build_phase_records -from pycalphad.core.utils import unpack_condition -from symengine import Piecewise, And +from symengine import Piecewise, And, Symbol from tinydb import where from kawin.thermo.LocalEquilibrium import local_equilibrium from espei.datasets import load_datasets, recursive_glob +from kawin.mobility_fitting.utils import _vname, find_last_variable class EquilibriumSiteFractionGenerator: + ''' + Grabs site fraction values from local equilibrium calculations + ''' def __init__(self, database : Database, phase : str): self.db = database self.phase = phase @@ -29,6 +32,7 @@ def _generate_comps_key(self, components): return frozenset(comps), comps def _generate_phase_records(self, components): + # Caches models, phase_records and constituents based off active components active_comps, comps = self._generate_comps_key(components) if active_comps not in self.models: self.models[active_comps] = {self.phase: Model(self.db, comps, self.phase)} @@ -36,11 +40,18 @@ def _generate_phase_records(self, components): self.constituents[active_comps] = [c for cons in self.models[active_comps][self.phase].constituents for c in sorted(list(cons))] def __call__(self, components, conditions : dict[v.StateVariable: float]) -> dict[v.Species: float]: + # Get phase records from active components active_comps, comps = self._generate_comps_key(components) self._generate_phase_records(components) + # Override any conditions for oc in self._conditions_override: conditions[oc] = self._conditions_override[oc] + + # Compute local equilibrium (to avoid miscibility gaps) + # Store site fractions + # The first 4 items of CompositionSet.dof refers to v.GE, v.N, v.P and v.T + # The order of the site fractions in CompositionSet.dof should correspond to the order in the pycalphad model results, comp_sets = local_equilibrium(self.db, comps, [self.phase], conditions, self.models[active_comps], self.phase_records[active_comps]) sfg = {c:val for c,val in zip(self.constituents[active_comps], comp_sets[0].dof[4:])} for c in self.full_constituents: @@ -76,26 +87,40 @@ class MobilityTerm: def __init__(self, constituent_array : list[list[v.SiteFraction]], order : int = 0): self.constituent_array = tuple(constituent_array) self.order = order - self.expr = None + self.expr = 0 def generate_multiplier(self, site_fractions): + ''' + Given site fraction values, return result for xA*xB*(xA-xB)**n + + Notes + This will account for multiple sublattices, but mixing on both sublattices will + assume to have the same order polynomial + Tertiary contributions are not included yet + ''' val = 1 for clist in self.constituent_array: clist = np.atleast_1d(clist) for c in clist: - val *= site_fractions.get(c,0) + #The wildcards will be treated as the sum for each component on the sublattice + #However, since the sum is 1, we can ignore it here + if c.species != v.Species('*'): + val *= site_fractions.get(c,0) if len(clist) == 2: ordered = sorted(clist) val *= (site_fractions.get(ordered[1],0) - site_fractions.get(ordered[0],0))**self.order return val def create_constituent_array_list(self): + ''' + Create constituent array list compatible with Database.add_parameter + ''' return [[c.species.name for c in np.atleast_1d(clist)] for clist in self.constituent_array] def __eq__(self, other): return self.constituent_array == other.constituent_array and self.order == other.order -def add_mobility_model(database : Database, phase : str, diffusing_species : str, mobility_terms : list[MobilityTerm]): +def add_mobility_model(database : Database, phase : str, diffusing_species : str, mobility_terms : list[MobilityTerm], symbols : dict[str,float]): ''' Add mobility parameters to database @@ -108,30 +133,32 @@ def add_mobility_model(database : Database, phase : str, diffusing_species : str ''' for mp in mobility_terms: database.add_parameter('MQ', phase, mp.create_constituent_array_list(), mp.order, mp.expr, diffusing_species=diffusing_species) + for s,val in symbols.items(): + database.symbols[s] = val def least_squares_fit(A, b, p=1): ''' Given site fractions and function to generate Redlich-kister terms, compute RK coefficients and AICC criteria ''' - A + # Fit coefficients using least squares regression x = np.linalg.lstsq(A, b, rcond=None)[0] + + # AICC criteria k = len(A[0]) + n = len(A) b_pred = np.matmul(A, x) - L = np.log(np.sum((b_pred - b)**2) / len(A)) - aicc = np.array(2*p*k + len(A)*L + (2*(k*p)**2 + 2*k*p) / (len(A) - k*p - 1)) + rss = np.sum((b_pred-b)**2) + pk = p*k + aic = 2*pk + n*np.log(rss/n) + if pk >= n-1: + correction = (2*pk**2 + 2*pk) / (-n + pk + 3) + else: + correction = (2*pk**2 + 2*pk) / (n - pk - 1) + aicc = aic + correction return x, aicc -def find_last_variable(database): - index = 0 - vname = 'VV{:04d}'.format(index) - while vname in database.symbols: - index += 1 - vname = 'VV{:04d}'.format(index) - return vname, index - - -def fit(datasets, database, components, phase, diffusing_species, mobility_test_models, site_fraction_generator, p = 1): +def fit(datasets, database, components, phase, diffusing_species, Q_test_models, D0_test_models, site_fraction_generator, p = 1): ''' Fit mobility models to datasets @@ -154,7 +181,10 @@ def fit(datasets, database, components, phase, diffusing_species, mobility_test_ components = list(set(components).union(set(['VA']))) fitted_mobility_model = [] + symbols = {} + vIndex = find_last_variable(database) + # Queries for activation energy (Q) and pre-factor (D0) q_query = ( (where('components').test(lambda x: set(x).issubset(components))) & (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & @@ -165,17 +195,24 @@ def fit(datasets, database, components, phase, diffusing_species, mobility_test_ (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & (where('output').test(lambda x : 'TRACER_D0' in x and x.endswith(diffusing_species))) ) - q_transform = lambda x : x - d0_transform = lambda x : np.log(x) + q_transform = lambda x : -x + d0_transform = lambda x : 8.314*np.log(x) + + # Data_types will include: + # query - to search for data from datasets + # transform - transforms value to form to fit to (should lead to no extra multiplying factors in the database) + # multiplier - term to multiply by when storing in database + # test_models - list of models to test against data_types = { - 'Q': (q_query, q_transform, -1), - 'D0': (d0_query, d0_transform, 8.314*v.T) + 'Q': (q_query, q_transform, 1, Q_test_models), + 'D0': (d0_query, d0_transform, v.T, D0_test_models) } for data_key, data_val in data_types.items(): - query, transform, multiplier = data_val + query, transform, multiplier, test_models = data_val data = datasets.search(query) + # Collect site fractions and output values from datasets site_fractions = [] Y = [] for d in data: @@ -189,6 +226,7 @@ def fit(datasets, database, components, phase, diffusing_species, mobility_test_ conds_list = {key:val.flatten() for key,val in zip(conds_key, conds_grid)} + # If non-equilibrium data, we could grab the site fractions directly if 'solver' in d: for sub_conf, sub_lat in zip(d['solver']['sublattice_configurations'], d['solver']['sublattice_occupancies']): sub_index = 0 @@ -200,41 +238,52 @@ def fit(datasets, database, components, phase, diffusing_species, mobility_test_ sf[y] = o sub_index += 1 site_fractions.append(sf) - + # If equilibrium data, we need a site_fraction_generator function to + # convert composition to site fractions else: - for i in range(len(Y)): + for i in range(len(y_sub)): sf = site_fraction_generator(d['components'], {key:val[i] for key,val in conds_list.items()}) site_fractions.append(sf) Y = np.concatenate((Y, y_sub)) + # Fit models and evaluate AICC fitted_models = [] aiccs = [] - for mob_model in mobility_test_models: + for mob_model in test_models: X = [[mi.generate_multiplier(sf) for mi in mob_model] for sf in site_fractions] X = np.array(X) terms, aicc = least_squares_fit(X, Y, p) - fitted_models.append(terms*multiplier) + fitted_models.append(terms) aiccs.append(aicc) + # Grab best model based off AICC index = np.argmin(aiccs) - best_model = mobility_test_models[index] + best_model = test_models[index] best_fit = fitted_models[index] + # Store each coefficient in the best model to a list of MobilityTerms + # MobilityTerms can be polled for equality, so if a term shows up + # again, the coefficient will be added on rather than overriding it + + # We store the equations as VV00XX + VV00XX*T + # and store the symbols VV00XX as piecewise functions separately for term, coef in zip(best_model, best_fit): if term not in fitted_mobility_model: fitted_mobility_model.append(MobilityTerm(term.constituent_array, term.order)) combined_term = fitted_mobility_model[fitted_mobility_model.index(term)] - if combined_term.expr is None: - combined_term.expr = 0 - combined_term.expr += coef + var_name = _vname(vIndex) + symbols[var_name] = Piecewise((coef, And(0 <= v.T, v.T < 10000)), (0, True)) + combined_term.expr += Symbol(var_name) * multiplier + vIndex += 1 + + # For each mobility term, convert to piecewise function to be compatible with database for f in fitted_mobility_model: - f.expr = Piecewise((f.expr, And(0 <= v.T, v.T < 10000)), (0, True)) - print(f.constituent_array, f.expr) + f.expr = Piecewise((f.expr, And(0 <= v.T, v.T < 6000)), (0, True)) - return fitted_mobility_model + return fitted_mobility_model, symbols diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py index 5decf31..800d8f4 100644 --- a/kawin/mobility_fitting/utils.py +++ b/kawin/mobility_fitting/utils.py @@ -45,4 +45,19 @@ def get_used_database_symbols(dbname, elements, refElement, phases = None, freeS # usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) allSyms = database_symbols_to_fit(db) usedSyms = sorted(list(usedSyms.intersection(frozenset(allSyms)))) - return usedSyms \ No newline at end of file + return usedSyms + +def _vname(index): + ''' + Converts index to VV00XX format + ''' + return 'VV{:04d}'.format(index) + +def find_last_variable(database): + ''' + Searches database to find the last symbol noted as VV00XX + ''' + index = 0 + while _vname(index) in database.symbols: + index += 1 + return index \ No newline at end of file diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index 66fb7f6..67af164 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -34,8 +34,29 @@ class MobilityModel(Model): Dictionary of symbols in diffusivity functions for each element ''' def __init__(self, dbe, comps, phase_name, parameters=None): + self.diffusing_species = None + super().__init__(dbe, comps, phase_name, parameters) + self._setup_mobility_models(dbe) + + def set_diffusing_species(self, dbe, diffusing_species): + ''' + Allows user to override diffusing species + + This will rebuild all the models, which is a bit + inefficient, but I can't seem to add a parameter to + the constructor due to the _dispatch_on function in + pycalphad.model.Model + ''' + # diffusing_species is list[v.Species] to be similar to components + self.diffusing_species = [v.Species(s) for s in diffusing_species] + #We only need to rebuild the mobility models since we're just changing + #what mobility models we have + self.mobility, self.diffusivity = self.build_mobility(dbe) + self._setup_mobility_models(dbe) + + def _setup_mobility_models(self, dbe): symbols = {Symbol(s): val for s, val in dbe.symbols.items()} if self._parameters_arg is not None: if isinstance(self._parameters_arg, dict): @@ -120,6 +141,9 @@ def build_mobility(self, dbe): ---------- dbe : Database ''' + if self.diffusing_species is None: + self.diffusing_species = self.components + phase = dbe.phases[self.phase_name] param_search = dbe.search @@ -129,7 +153,7 @@ def build_mobility(self, dbe): param_names = ['MF', 'MQ', 'DF', 'DQ'] - for c in self.components: + for c in self.diffusing_species: if c.name != 'VA': for name in param_names: param_query = ( @@ -162,7 +186,7 @@ def build_mobility(self, dbe): self.mob_models[p[1]][c.name] += rk self.checkOrderingContribution(dbe) - for c in self.components: + for c in self.diffusing_species: if c.name != 'VA': #In thermo-calc, the mobility model is defined as exp(sum(MF)/RT) * exp(sum(MQ)/RT) / RT #The diffusivity model is defined either as dilute - exp(sum(DF)/RT) * exp(sum(DQ)/RT) @@ -203,6 +227,10 @@ def checkOrderingContribution(self, dbe): constituents = [sorted(set(c).intersection(self.components)) for c in ordered_phase.constituents] disordered_phase = dbe.phases[disordered_phase_name] disordered_model = self.__class__(dbe, sorted(self.components), disordered_phase_name) + + #If diffusing species are different, then set diffusing species for disordered model + if set(self.components).symmetric_difference(self.diffusing_species) != 0: + disordered_model.set_diffusing_species(dbe, self.diffusing_species) disordered_subl_constituents = disordered_phase.constituents[0] ordered_constituents = ordered_phase.constituents From 542dc44ae3814479bc87366284b00b38fc4ebd41 Mon Sep 17 00:00:00 2001 From: Ury Date: Thu, 18 Apr 2024 15:09:42 -0700 Subject: [PATCH 04/53] bug fixes and some comments --- .../equilibrium_mobility_error.py | 49 +++++++++--- .../non_equilibrium_mobility_error.py | 78 ++++++++++--------- .../mobility_fitting/error_functions/utils.py | 4 + kawin/thermo/Mobility.py | 25 +----- 4 files changed, 90 insertions(+), 66 deletions(-) diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index 535e6e4..3c010da 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -1,12 +1,19 @@ +""" +Calculate error due to interdiffusivity, tracer diffusivity, activation energy and diffusion prefactor +based off equilibrium +""" +import logging from collections import OrderedDict -from typing import Sequence, Dict, Union, List, Optional +from typing import Dict, List, Optional, Union, Sequence +from itertools import product import numpy as np -from pycalphad import Database, variables as v -from pycalphad.core.utils import filter_phases, unpack_components, unpack_condition, extract_parameters from scipy.stats import norm import tinydb +from pycalphad import Database, variables as v +from pycalphad.core.utils import filter_phases, unpack_components, unpack_condition, extract_parameters + from espei.phase_models import PhaseModelSpecification from espei.typing import SymbolName from espei.utils import PickleableTinyDB, database_symbols_to_fit @@ -14,17 +21,22 @@ from kawin.thermo.LocalEquilibrium import local_equilibrium from kawin.thermo.FreeEnergyHessian import partialdMudX -from itertools import product import kawin.mobility_fitting.error_functions.cached_mobility as cmob from kawin.mobility_fitting.error_functions.utils import get_output_base_name, get_base_names, build_model, get_base_std +_log = logging.getLogger(__name__) + class EquilibriumMobilityData: + """ + Stores internal values for each dataset needed to compute output + """ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.parameters = parameters if parameters is not None else {} self.parameter_keys = [p for p in self.parameters] self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} self.output = get_output_base_name(data['output']) + self.reference = data['reference'] pot_conds = OrderedDict([(getattr(v, key), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if not key.startswith('X_')]) comp_conds = OrderedDict([(v.X(key[2:]), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if key.startswith('X_')]) @@ -37,8 +49,10 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.refComp = data.get('ref_el', None) if self.refComp is None and 'TRACER' in data['output']: self.refComp = [data['output'][len(self.output)+1:]] - self.depComps = data.get('dependent_el', []) + + #Set diffusing species - this is necessary for tracer data of a component at the limit of X->0 + # in which case, the dataset will not include the component when building the model self.diffusing_species = sorted(list(set(self.refComp) | set(self.depComps) | set(self.elements) - set(['VA']))) self.models, self.phase_records, self.mob_models, self.mob_callables = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) self.mobility_correction = {c:1 for c in self.non_va_elements} @@ -59,6 +73,15 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.weights = (property_std_deviation.get(self.output, 1.0)/data_weight_dict.get(self.output, 1.0)/dataset_weights).flatten() def _compute_cached_equilibrium(self, dbf): + """ + Computes local equilibrium at each condition and stores results + This is to avoid computing equilibrium every time the log probability is calculated + + NOTE: this is only valid if the thermodynamic parameters are fixed + TODO: add option to disable this in case the user wants to fit both thermodynamic and mobility parameters (why?) + + Cached data includes: non-vacant elements, temperature, internal degrees of freedom, composition and chemical potential gradient + """ self.cache = {} keys, values = zip(*self.conditions.items()) @@ -129,11 +152,21 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray value = data.values[tuple(inds)] cs_data = data.cache[tuple(inds)] + #Compute mobility from cached equilibrium data cs_el, cs_T, cs_dof, cs_X, cs_dmudx = cs_data mob_from_CS = cmob.mobility_from_composition_set_quick(cs_dof, cs_el, data.mob_callables[data.phases[0]], data.mobility_correction, parameters = paramDict) refIndex = data.non_va_elements.index(data.refComp[0]) + #NOTE: for interdiffusivity, tracer diffusivity and prefactor, we multiply by the sign of the value + # This is for cases if the computed and desired values are of different signs + # and taking the log of the absolute value will remove this possible difference + # + # 1) In reality, tracer diffusivity and prefactor should always be positive, so + # this may not be necessary + # 2) If the desired interdiffusivity correctly accounts for potential miscibility gaps + # that exists in the database, then the sign of the calculated and desired interdiffusivity + # should be the same if data.output == 'INTER_DIFF': mobMatrix = cmob.mobility_matrix_quick(cs_dof, cs_X, cs_el, mob_from_CS, data.phase_records[data.phases[0]]) cd, _ = cmob.chemical_diffusivity_quick(cs_dmudx, mobMatrix) @@ -160,6 +193,8 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray wts.append(data.weights[i]) + _log.debug('Output: %s differences: %s, weights: %s, reference: %s', data.output, diffs, wts, data.reference) + return diffs, wts def calculate_mob_probability(mob_data : Sequence[EquilibriumMobilityData], parameters : np.ndarray) -> float: @@ -207,9 +242,5 @@ def __init__( def get_likelihood(self, parameters): likelihood = calculate_mob_probability(self.mob_data, parameters) return likelihood - - def __getstate__(self): - print('i am pickled') - return self.__dict__ residual_function_registry.register(EquilibriumMobilityResidual) diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py index 350019f..ff1bb38 100644 --- a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -1,42 +1,39 @@ """ -Calculate error due to thermochemical quantities: heat capacity, entropy, enthalpy. +Calculate error due to tracer diffusivity, activation energy and diffusion prefactor +based off constituent site-fraction data """ - import logging -from collections import OrderedDict -from typing import Any, Dict, List, NewType, Optional, Tuple, Union, Sequence +from typing import Dict, List, Optional, Union, Sequence -from scipy.stats import norm import numpy as np -import numpy.typing as npt -from tinydb import where +from scipy.stats import norm +import tinydb from pycalphad import Database, variables as v -from pycalphad.core.utils import unpack_components, filter_phases, unpack_condition, extract_parameters +from pycalphad.core.utils import unpack_components, filter_phases, extract_parameters -from espei.datasets import Dataset -from espei.core_utils import ravel_conditions, get_prop_data, filter_temperatures +from espei.core_utils import ravel_conditions from espei.phase_models import PhaseModelSpecification -from espei.sublattice_tools import canonicalize, recursive_tuplify, tuplify from espei.typing import SymbolName from espei.utils import database_symbols_to_fit, PickleableTinyDB from espei.error_functions.residual_base import ResidualFunction, residual_function_registry -from espei.error_functions.non_equilibrium_thermochemical_error import FixedConfigurationCalculationData, filter_sublattice_configurations, calculate_points_array +from espei.error_functions.non_equilibrium_thermochemical_error import calculate_points_array import kawin.mobility_fitting.error_functions.cached_mobility as cmob -from kawin.thermo.Mobility import MobilityModel from kawin.mobility_fitting.error_functions.utils import get_output_base_name, get_base_names, build_model, get_base_std -import tinydb - _log = logging.getLogger(__name__) class NonEquilibriumMobilityData: + """ + Stores internal values for each dataset needed to compute output + """ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.parameters = parameters if parameters is not None else {} self.parameter_keys = [p for p in self.parameters] self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} self.output = get_output_base_name(data['output']) + self.reference = data['reference'] self.comps = data['components'] self.elements = sorted(list(set([v.Species(c).name for c in self.comps]))) @@ -45,8 +42,11 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.refComp = data.get('ref_el', None) if self.refComp is None and 'TRACER' in data['output']: self.refComp = [data['output'][len(self.output)+1:]] - self.depComps = data.get('dependent_el', []) + + #Set diffusing species - this is necessary for tracer data of a component at the limit of X->0 + # in which case, the dataset will not include the component when building the model + #TODO: check if we only need refComp for the diffusing species self.diffusing_species = sorted(list(set(self.refComp) | set(self.depComps) | set(self.elements) - set(['VA']))) self.models, self.phase_records, self.mob_models, self.mob_callables = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) self.mobility_correction = {c:1 for c in self.non_va_elements} @@ -58,6 +58,9 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.weights = (property_std_deviation.get(self.output, 1.0)/data_weight_dict.get(self.output, 1.0)/dataset_weights).flatten() def _processConditions(self, data): + """ + Creates flat list of T, P, X (points) and values + """ T = data['conditions']['T'] P = data['conditions']['P'] values = np.array(data['values']) @@ -66,7 +69,7 @@ def _processConditions(self, data): sub_conf = data['solver']['sublattice_configurations'] sub_occ = data['solver']['sublattice_occupancies'] - phase_cons = [[c.name for c in s] for s in self.models[self.phases[0]].constituents] + phase_cons = [[c.name for c in sorted(s)] for s in self.models[self.phases[0]].constituents] single_points = np.array([calculate_points_array(phase_cons, conf, occ) for conf, occ in zip(sub_conf, sub_occ)]) self.points = np.tile(single_points, (values.shape[0]*values.shape[1], 1)) @@ -105,10 +108,10 @@ def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], dat (tinydb.where('phases').test(lambda x: len(set(phases).intersection(x)) > 0)) & (tinydb.where('solver').exists())) - mod_data = [] + mob_data = [] for data in desired_data: - mod_data.append(NonEquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) - return mod_data + mob_data.append(NonEquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) + return mob_data def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndarray): diffs, wts = [], [] @@ -120,41 +123,44 @@ def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndar data.phase_records[p].parameters[:] = np.asarray(param_values, dtype=np.float_) state_variables = sorted([v.T, v.P, v.N, v.GE]) - for i in range(len(data.values)): - T = data.T[i] - P = data.P[i] - value = data.values[i] - point = data.points[i] - + #Internal degrees of freedom (we include v.GE here to be compatible with kawin) dof = np.zeros(4 + len(data.mob_models[data.phases[0]].site_fractions)) - dof[state_variables.index(v.T)] = T - dof[state_variables.index(v.P)] = P + dof[state_variables.index(v.T)] = data.T[i] + dof[state_variables.index(v.P)] = data.P[i] dof[state_variables.index(v.N)] = 1 - dof[4:] = point + dof[4:] = data.points[i] + + value = data.values[i] refIndex = data.diffusing_species.index(data.refComp[0]) + #NOTE: for tracer diffusivity and prefactor, we multiply by the sign of the value + # This is for cases if the computed and desired values are of different signs + # and taking the log of the absolute value will remove this possible difference + # In reality, tracer diffusivity and prefactor should always be positive, so + # this may not be necessary if data.output == 'TRACER_DIFF': calculated_values = cmob.mobility_from_composition_set_symbolic_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) r = calculated_values[refIndex] + r = np.sign(r) * np.log10(np.abs(r)) + value = np.sign(value) * np.log10(np.abs(value)) + elif data.output == 'TRACER_Q': calculated_values = cmob.activation_energy_from_composition_set_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) r = calculated_values[refIndex] - elif data.output == 'TRACER_D0': - calculated_values = cmob.prefactor_from_composition_set_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) - r = calculated_values[refIndex] - if data.output == 'TRACER_DIFF': - r = np.sign(r) * np.log10(np.abs(r)) - value = np.sign(value) * np.log10(np.abs(value)) elif data.output == 'TRACER_D0': - r = np.sign(r) * np.log10(np.exp(r)) + calculated_values = cmob.prefactor_from_composition_set_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) + r = np.exp(calculated_values[refIndex]) + r = np.sign(r) * np.log10(r) value = np.sign(value) * np.log10(np.abs(value)) diffs.append(r - value) wts.append(data.weights[i]) + _log.debug('Output: %s differences: %s, weights: %s, reference: %s', data.output, diffs, wts, data.reference) + return diffs, wts def calculate_mob_probability(mob_data : Sequence[NonEquilibriumMobilityData], parameters : np.ndarray) -> float: diff --git a/kawin/mobility_fitting/error_functions/utils.py b/kawin/mobility_fitting/error_functions/utils.py index 790ad62..06d4fcd 100644 --- a/kawin/mobility_fitting/error_functions/utils.py +++ b/kawin/mobility_fitting/error_functions/utils.py @@ -23,6 +23,10 @@ def get_base_std(): def build_model(db, elements, phase, parameters, diffusing_species): param_keys, _ = extract_parameters(parameters) model = {phase: Model(db, elements, phase, parameters=param_keys)} + + #Include v.GE to be compatible with kawin + #TODO: this may not be necessary since v.GE is only added if the model + # is built in the GeneralThermodynamics module model[phase].state_variables = sorted([v.T, v.P, v.N, v.GE], key=str) phase_record = build_phase_records(db, elements, [phase], model[phase].state_variables, diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index 67af164..62381c5 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -484,13 +484,13 @@ def mobility_matrix(composition_set, mobility_callables = None, mobility_correct if composition_set.phase_record.variables[i].species.name in interstitials: interstitialTerms[composition_set.phase_record.variables[i].species.name] = composition_set.phase_record.variables[i].sublattice_index - #For interstitials + # For interstitials # M_aa = y_Va * M_a # y_Va is taken from the same sublattice that a is on, where more vacancies on the sublattice implies faster diffusion - #For substitutionals + # For substitutionals # M_aa = (1-U_a) * U_a * M_a # M_ab = -U_a * U_b * M_b - #There are no entries for M_ab if one index is interstitial and the other is substitutional + # There are no entries for M_ab if one index is interstitial and the other is substitutional mobMatrix = np.zeros((len(elements), len(elements))) for a in range(len(elements)): for b in range(len(elements)): @@ -502,29 +502,12 @@ def mobility_matrix(composition_set, mobility_callables = None, mobility_correct else: if elements[b] not in interstitials: mobMatrix[a, b] = -U[a] * mob[b] - # if elements[a] in interstitials: - # mobMatrix[a, a] = vaTerms.get(interstitialTerms[elements[a]], 1) * mob[a] - # else: - # for b in range(len(elements)): - # if elements[b] not in interstitials: - # if a == b: - # mobMatrix[a, b] = (1 - U[a]) * mob[b] - # else: - # mobMatrix[a, b] = -U[a] * mob[b] + #Diffusivity requires dmu_a/dU_b; however, the free energy curvature gives dmu_a/dX_b #Assuming that Usum is constant and using chain-rule derivatives, # the conversion from dmu_a/dX_b to dmu_a/dU_b can be done by multiplying the sum(substitutionals) mobMatrix *= Usum - #Old way of computing mobility assuming only substitutional elements (so much simpler...) - #mob = np.array([X[A] * computedMob[A] for A in range(len(elements))]) - #for a in range(len(elements)): - # for b in range(len(elements)): - # if a == b: - # mobMatrix[a, b] = (1 - X[a]) * mob[b] - # else: - # mobMatrix[a, b] = -X[a] * mob[b] - return mobMatrix def chemical_diffusivity(chemical_potentials, composition_set, mobility_callables, mobility_correction = None, returnHessian = False, parameters = {}): From dbd5ebb6fe487df12ae614975d4d82562489be7e Mon Sep 17 00:00:00 2001 From: Ury Date: Fri, 10 May 2024 14:48:09 -0700 Subject: [PATCH 05/53] liquid mobility models --- kawin/diffusion/Diffusion.py | 19 +-- kawin/diffusion/Homogenization.py | 8 +- kawin/diffusion/Plot.py | 2 + .../error_functions/cached_mobility.py | 56 +++++++- .../equilibrium_mobility_error.py | 6 +- kawin/mobility_fitting/generate.py | 9 +- kawin/mobility_fitting/liquid_mobility.py | 120 ++++++++++++++++-- kawin/mobility_fitting/manual_fitting.py | 69 +--------- kawin/mobility_fitting/utils.py | 65 +++++++++- kawin/thermo/Mobility.py | 2 +- kawin/thermo/Thermodynamics.py | 1 + 11 files changed, 259 insertions(+), 98 deletions(-) diff --git a/kawin/diffusion/Diffusion.py b/kawin/diffusion/Diffusion.py index 25f1318..4395613 100644 --- a/kawin/diffusion/Diffusion.py +++ b/kawin/diffusion/Diffusion.py @@ -464,15 +464,18 @@ def correctdXdt(self, dt, x, dXdt): dXdt[0][i][indices] = np.interp(self.z[indices], self.z[~indices], dXdt[0][i][~indices]) #Adjust flux by a scale if it predicts that a composition will go below 0 - xfull = np.concatenate((np.array([np.sum(x[0],axis=0)]), x[0]), axis=0) - dXdtfull = np.concatenate((np.array([np.sum(dXdt[0],axis=0)]), dXdt[0]), axis=0) - xpred = dt * dXdtfull + xfull = np.concatenate((np.array([1-np.sum(x[0],axis=0)]), x[0]), axis=0) + dXdtfull = np.concatenate((np.array([-np.sum(dXdt[0],axis=0)]), dXdt[0]), axis=0) + xfull[xfull < self.minComposition] = self.minComposition + dXdtmin = (self.minComposition - xfull) / dt alpha = np.ones(xfull.shape) - den = xpred - xfull - alpha[den != 0] = (0 - xfull[den != 0]) / den[den != 0] - alpha[(alpha > 1) | (alpha <= 0)] = 1 - for i in range(len(dXdt[0])): - dXdt[0][i] *= np.amin(alpha, axis=0) + indices = dXdtfull != 0 + alpha[indices] = dXdtmin[indices] / dXdtfull[indices] + alpha[alpha < 0] = 1 + for i in range(dXdt[0].shape[1]): + min_alpha = np.amin(alpha[:,i]) + dXdt[0][:,i] *= min_alpha + def getdXdt(self, t, x): ''' diff --git a/kawin/diffusion/Homogenization.py b/kawin/diffusion/Homogenization.py index 93cf96e..1b0fca1 100644 --- a/kawin/diffusion/Homogenization.py +++ b/kawin/diffusion/Homogenization.py @@ -96,8 +96,9 @@ def _newEqCalc(self, x, T): comp.append(cs) if len(comp) == 0: + print(x) comp = None - + return self.therm.getLocalEq(x, T, 0, self.phases, comp) def updateCompSets(self, xarray): @@ -209,7 +210,7 @@ def wienerLower(self, xarray): ''' #(p, e, N) mob = self.getMobility(xarray) - avgMob = 1/np.sum(np.multiply(self.p[:,np.newaxis], 1/mob), axis=0) + avgMob = 1/np.sum(np.multiply(self.p[:,np.newaxis], 1/(mob+1e-8)), axis=0) return avgMob def labyrinth(self, xarray): @@ -289,7 +290,8 @@ def _getFluxes(self, t, x_curr): #Get average mobility between nodes avgMob = self.mobilityFunction(x) - avgMob = 0.5 * (avgMob[:,1:] + avgMob[:,:-1]) + avgMob = np.exp(0.5 * (np.log(avgMob[:,1:]) + np.log(avgMob[:,:-1]))) + #avgMob = 0.5 * (avgMob[:,1:] + avgMob[:,:-1]) #Composition between nodes avgX = 0.5 * (x[:,1:] + x[:,:-1]) diff --git a/kawin/diffusion/Plot.py b/kawin/diffusion/Plot.py index 7adba76..9eb192c 100644 --- a/kawin/diffusion/Plot.py +++ b/kawin/diffusion/Plot.py @@ -124,6 +124,8 @@ def plotPhases(diffModel, ax = None, plotPhase = None, zScale = 1, *args, **kwar if not diffModel.isSetup: diffModel.setup() + else: + diffModel.p = diffModel.updateCompSets(diffModel.x) if plotPhase is not None: p = diffModel._getPhaseIndex(plotPhase) diff --git a/kawin/mobility_fitting/error_functions/cached_mobility.py b/kawin/mobility_fitting/error_functions/cached_mobility.py index 6d3e1bf..3c472c3 100644 --- a/kawin/mobility_fitting/error_functions/cached_mobility.py +++ b/kawin/mobility_fitting/error_functions/cached_mobility.py @@ -96,4 +96,58 @@ def chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian = False): if returnHessian: return Dkj, dmudx else: - return Dkj, None \ No newline at end of file + return Dkj, None + +def interdiffusivity_quick(dmudx, mobMatrix, elements, refElement, returnHessian = False): + ''' + Interdiffusivity (D^n_ab) + + D^n_ab = D_ab - D_an (for substitutional element) + D^n_ab = D_ab (for interstitial element) + + Parameters + ---------- + chemical_potentials : 1-D ndarray + composition_set : pycalphad.core.composition_set.CompositionSet + refElement : str + Reference element n + mobility_callables : dict (optional) + Pre-computed mobility callables for each element + mobility_correction : dict (optional) + Factor to multiply mobility by for each given element (defaults to 1) + returnHessian : bool (optional) + Whether to return chemical potential derivative (defaults to False) + + Returns + ------- + (matrix of floats, free energy hessian) + Each index along an axis correspond to elements in + alphabetical order excluding reference element + free energy hessian will be None if returnHessian is False + ''' + Dkj, hessian = chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian) + + #Find index of reference element + refIndex = 0 + for a in range(len(elements)): + if elements[a] == refElement: + refIndex = a + break + + #Build Dnkj, skipping the reference element + Dnkj = np.zeros((len(elements) - 1, len(elements) - 1)) + c = 0 + d = 0 + for a in range(len(elements)): + if a != refIndex: + for b in range(len(elements)): + if b != refIndex: + if elements[b] in interstitials: + Dnkj[c, d] = Dkj[a, b] + else: + Dnkj[c, d] = Dkj[a, b] - Dkj[a, refIndex] + d += 1 + c += 1 + d = 0 + + return Dnkj, hessian \ No newline at end of file diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index 3c010da..9952ff4 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -21,6 +21,7 @@ from kawin.thermo.LocalEquilibrium import local_equilibrium from kawin.thermo.FreeEnergyHessian import partialdMudX +from kawin.thermo.Mobility import interstitials import kawin.mobility_fitting.error_functions.cached_mobility as cmob from kawin.mobility_fitting.error_functions.utils import get_output_base_name, get_base_names, build_model, get_base_std @@ -173,7 +174,10 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray depComp1 = data.non_va_elements.index(data.depComps[0]) depComp2 = data.non_va_elements.index(data.depComps[1]) - D = cd[depComp1, depComp2] - cd[depComp1, refIndex] + if data.depComps[1] in interstitials: + D = cd[depComp1, depComp2] + else: + D = cd[depComp1, depComp2] - cd[depComp1, refIndex] diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_DIFF': diff --git a/kawin/mobility_fitting/generate.py b/kawin/mobility_fitting/generate.py index 134f2e6..15eacc4 100644 --- a/kawin/mobility_fitting/generate.py +++ b/kawin/mobility_fitting/generate.py @@ -36,7 +36,7 @@ def add_mobility_keywords(elements): pycalphad.io.tdb_keywords.TDB_PARAM_TYPES.append(aliases[-1]) return aliases -def rewrite_mobility_terms(db_name, mob_aliases): +def rewrite_mobility_terms(db_name, mob_aliases, tdb_save_params = {}): ''' Rewrites the database to replace MQ_el with MQ(Phase&el,...) @@ -62,7 +62,8 @@ def rewrite_mobility_terms(db_name, mob_aliases): for m in mob_aliases: db._parameters.remove(where('parameter_type') == m) - db.to_file(db_name, if_exists='overwrite') + tdb_save_params['if_exists'] = 'overwrite' + db.to_file(db_name, **tdb_save_params) def setup_mobility_fitting_description(elements, fit_to_tracer = False): ''' @@ -93,7 +94,7 @@ def setup_mobility_fitting_description(elements, fit_to_tracer = False): global fitting_description fitting_description = ModelFittingDescription(steps, model=MobilityModel) -def fit_mobility(input_settings, fit_to_tracer=False): +def fit_mobility(input_settings, fit_to_tracer=False, tdb_save_params = {}): ''' Wrapper around run_espei to do the following: 1. Find components to fit mobility to @@ -120,4 +121,4 @@ def fit_mobility(input_settings, fit_to_tracer=False): out_db = input_settings['output']['output_db'] run_espei(input_settings) - rewrite_mobility_terms(out_db, aliases) \ No newline at end of file + rewrite_mobility_terms(out_db, aliases, tdb_save_params=tdb_save_params) \ No newline at end of file diff --git a/kawin/mobility_fitting/liquid_mobility.py b/kawin/mobility_fitting/liquid_mobility.py index 19a9602..7b4463b 100644 --- a/kawin/mobility_fitting/liquid_mobility.py +++ b/kawin/mobility_fitting/liquid_mobility.py @@ -1,4 +1,7 @@ import numpy as np +from pycalphad import Database, variables as v +from symengine import Piecewise, And, Symbol, log +from kawin.mobility_fitting.utils import _vname, find_last_variable, MobilityTerm class SpeciesData: def __init__(self, name, atomic_number, diameter, Tm, melting_phase = None): @@ -19,17 +22,108 @@ def _getK0(self, melting_phase): return phases[p] return 0 -def compute_liquid_mobility(species = list[SpeciesData]): - liquid_mobility_data = [] - n = len(species) - for i in range(n): - for j in range(n): - Q = 0.17 * 8.314 * species[i].Tm * (16 + species[i].K0) - D0 = (8.95 - 0.0734 * species[i].atomic_number) * 1e-8 - - d_ratio = species[i].diameter / species[j].diameter - D0 *= d_ratio - liquid_mobility_data.append((species[i].name, species[j].name, Q, D0)) - - return liquid_mobility_data +def _get_liquid_phase_name(database): + for ph in database.phases: + if ph.upper() == 'LIQUID': + return ph + elif ph.upper() == 'LIQ': + return ph + elif ph.upper() == 'L': + return ph + return 'LIQUID' + +def _getK0(melting_phase): + phases = {'BCC': 1, 'HCP': 2, 'FCC': 3} + for p in phases: + if p in melting_phase: + return phases[p] + return 0 + +def compute_liquid_mobility_liu(database, species): + ''' + Species data will include {diameter, atomic_number, T_m, phase} + + Units: + diameter: Angstroms + T_m: K + ''' + R = 8.314 + + liq_name = _get_liquid_phase_name(database) + mobility_models = {} + for solute in species: + models = [] + for solvent in species: + d_solv, A_solv, Tm_solv, phase_solv = (species[solvent][t] for t in ['diameter', 'atomic_number', 'T_m', 'phase']) + K0_solv = _getK0(phase_solv) + d_solu = species[solute]['diameter'] + + Q = -0.17 * R * Tm_solv * (16 + K0_solv) + D0 = (8.95 - 0.0734 * A_solv) * 1e-8 + D0 *= d_solv / d_solu + + const_array = [[v.SiteFraction(liq_name, 0, solvent)]] + mob_term = MobilityTerm(const_array, 0) + mob_term.expr = Piecewise((Q + R*np.log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) + models.append(mob_term) + + mobility_models[solute] = models + + return mobility_models + +def compute_liquid_mobility_su(database, species): + ''' + Species data will include {atomic_mass, density, T_m, CTE (optional)} + If CTE is included, then density/molar volume will be assumed to be at room temperature + And will be adjusted to the melting point + + Units: + atomic_mass: g/mol + density: g/cm3 + T_m: K + CTE: m/m + ''' + vIndex = find_last_variable(database) + C1 = 1.8e-8 + C2 = 2.34 + R = 8.314 + k = 1.38e-23 + R0 = 0.644e-10 + + liq_name = _get_liquid_phase_name(database) + mobility_models = {} + for solute in species: + models = [] + for solvent in species: + M_solv, rho_solv, Tm_solv = (species[solvent][t] for t in ['atomic_mass', 'density', 'T_m']) + cte_solv = species[solvent].get('CTE', 0) + + M_solu, rho_solu, Tm_solu = (species[solute][t] for t in ['atomic_mass', 'density', 'T_m']) + cte_solu = species[solute].get('CTE', 0) + + rho_solv *= (1 + cte_solv * (Tm_solv - 298.15))**3 + rho_solu *= (1 + cte_solu * (Tm_solv - 298.15))**3 + V_solv = M_solv / rho_solv * 1e-6 #m3/mol + V_solu = M_solu / rho_solu * 1e-6 #m3/mol + + Q = -C2 * Tm_solv * R + D1 = C1 * np.power(M_solv/1000, 1/2) / np.power(V_solv, 2/3) + D2 = R0 * np.power(M_solu / rho_solu, 1/3) + D3 = k / (4*np.pi) + D0 = D3/(D1*D2) * v.T**(1/2) / (1 - 0.112 * (v.T / Tm_solv)**(1/2)) + + const_array = [[v.SiteFraction(liq_name, 0, solvent)]] + mob_term = MobilityTerm(const_array, 0) + mob_term.expr = Piecewise((Q + R*log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) + models.append(mob_term) + + mobility_models[solute] = models + + return mobility_models + + + + + + diff --git a/kawin/mobility_fitting/manual_fitting.py b/kawin/mobility_fitting/manual_fitting.py index f3ddfdc..392604c 100644 --- a/kawin/mobility_fitting/manual_fitting.py +++ b/kawin/mobility_fitting/manual_fitting.py @@ -5,7 +5,7 @@ from tinydb import where from kawin.thermo.LocalEquilibrium import local_equilibrium from espei.datasets import load_datasets, recursive_glob -from kawin.mobility_fitting.utils import _vname, find_last_variable +from kawin.mobility_fitting.utils import _vname, find_last_variable, MobilityTerm class EquilibriumSiteFractionGenerator: ''' @@ -73,69 +73,6 @@ def __call__(self, components, conditions): return self.create_site_fractions(composition) -class MobilityTerm: - ''' - Utility class to hold data for a mobility term - - Attributes - ---------- - constituent_array : list[list[str]] - Constituent array - order : int - Redlich-kister polynomial order - ''' - def __init__(self, constituent_array : list[list[v.SiteFraction]], order : int = 0): - self.constituent_array = tuple(constituent_array) - self.order = order - self.expr = 0 - - def generate_multiplier(self, site_fractions): - ''' - Given site fraction values, return result for xA*xB*(xA-xB)**n - - Notes - This will account for multiple sublattices, but mixing on both sublattices will - assume to have the same order polynomial - Tertiary contributions are not included yet - ''' - val = 1 - for clist in self.constituent_array: - clist = np.atleast_1d(clist) - for c in clist: - #The wildcards will be treated as the sum for each component on the sublattice - #However, since the sum is 1, we can ignore it here - if c.species != v.Species('*'): - val *= site_fractions.get(c,0) - if len(clist) == 2: - ordered = sorted(clist) - val *= (site_fractions.get(ordered[1],0) - site_fractions.get(ordered[0],0))**self.order - return val - - def create_constituent_array_list(self): - ''' - Create constituent array list compatible with Database.add_parameter - ''' - return [[c.species.name for c in np.atleast_1d(clist)] for clist in self.constituent_array] - - def __eq__(self, other): - return self.constituent_array == other.constituent_array and self.order == other.order - -def add_mobility_model(database : Database, phase : str, diffusing_species : str, mobility_terms : list[MobilityTerm], symbols : dict[str,float]): - ''' - Add mobility parameters to database - - Parameters - ---------- - database : Pycalphad database object - phase : str - diffusing_species : str - mobility_terms : list[MobilityParameter] - ''' - for mp in mobility_terms: - database.add_parameter('MQ', phase, mp.create_constituent_array_list(), mp.order, mp.expr, diffusing_species=diffusing_species) - for s,val in symbols.items(): - database.symbols[s] = val - def least_squares_fit(A, b, p=1): ''' Given site fractions and function to generate Redlich-kister terms, @@ -275,13 +212,13 @@ def fit(datasets, database, components, phase, diffusing_species, Q_test_models, combined_term = fitted_mobility_model[fitted_mobility_model.index(term)] var_name = _vname(vIndex) - symbols[var_name] = Piecewise((coef, And(0 <= v.T, v.T < 10000)), (0, True)) + symbols[var_name] = Piecewise((coef, And(1.0 <= v.T, v.T < 10000)), (0, True)) combined_term.expr += Symbol(var_name) * multiplier vIndex += 1 # For each mobility term, convert to piecewise function to be compatible with database for f in fitted_mobility_model: - f.expr = Piecewise((f.expr, And(0 <= v.T, v.T < 6000)), (0, True)) + f.expr = Piecewise((f.expr, And(1.0 <= v.T, v.T < 6000)), (0, True)) return fitted_mobility_model, symbols diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py index 800d8f4..fd6099a 100644 --- a/kawin/mobility_fitting/utils.py +++ b/kawin/mobility_fitting/utils.py @@ -1,6 +1,6 @@ import numpy as np from kawin.thermo import GeneralThermodynamics -from pycalphad import Database +from pycalphad import Database, variables as v from espei.utils import database_symbols_to_fit def get_used_database_symbols(dbname, elements, refElement, phases = None, freeSub = False): @@ -47,6 +47,69 @@ def get_used_database_symbols(dbname, elements, refElement, phases = None, freeS usedSyms = sorted(list(usedSyms.intersection(frozenset(allSyms)))) return usedSyms +class MobilityTerm: + ''' + Utility class to hold data for a mobility term + + Attributes + ---------- + constituent_array : list[list[str]] + Constituent array + order : int + Redlich-kister polynomial order + ''' + def __init__(self, constituent_array : list[list[v.SiteFraction]], order : int = 0): + self.constituent_array = tuple(constituent_array) + self.order = order + self.expr = 0 + + def generate_multiplier(self, site_fractions): + ''' + Given site fraction values, return result for xA*xB*(xA-xB)**n + + Notes + This will account for multiple sublattices, but mixing on both sublattices will + assume to have the same order polynomial + Tertiary contributions are not included yet + ''' + val = 1 + for clist in self.constituent_array: + clist = np.atleast_1d(clist) + for c in clist: + #The wildcards will be treated as the sum for each component on the sublattice + #However, since the sum is 1, we can ignore it here + if c.species != v.Species('*'): + val *= site_fractions.get(c,0) + if len(clist) == 2: + ordered = sorted(clist) + val *= (site_fractions.get(ordered[1],0) - site_fractions.get(ordered[0],0))**self.order + return val + + def create_constituent_array_list(self): + ''' + Create constituent array list compatible with Database.add_parameter + ''' + return [[c.species.name for c in np.atleast_1d(clist)] for clist in self.constituent_array] + + def __eq__(self, other): + return self.constituent_array == other.constituent_array and self.order == other.order + +def add_mobility_model(database : Database, phase : str, diffusing_species : str, mobility_terms : list[MobilityTerm], symbols : dict[str,float] = {}): + ''' + Add mobility parameters to database + + Parameters + ---------- + database : Pycalphad database object + phase : str + diffusing_species : str + mobility_terms : list[MobilityParameter] + ''' + for mp in mobility_terms: + database.add_parameter('MQ', phase, mp.create_constituent_array_list(), mp.order, mp.expr, diffusing_species=diffusing_species) + for s,val in symbols.items(): + database.symbols[s] = val + def _vname(index): ''' Converts index to VV00XX format diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index 62381c5..32ac5ee 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -365,7 +365,7 @@ def compute_symbolic_expr_from_composition_set(composition_set, mobility_model, for p,val in zip(param_keys, param_values[0]): var_dict[p] = val - return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))]) + return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))], np.float_) def mobility_from_composition_set_symbolic(composition_set, mobility_model, parameters = {}): ''' diff --git a/kawin/thermo/Thermodynamics.py b/kawin/thermo/Thermodynamics.py index f5d2175..97a4205 100644 --- a/kawin/thermo/Thermodynamics.py +++ b/kawin/thermo/Thermodynamics.py @@ -168,6 +168,7 @@ def _buildMobilityModels(self): if len(pMob) > 0 or len(pDiff) > 0: self.mobModels[p] = MobilityModel(self.db, self.elements, p, parameters=param_keys) + self.mobModels[p].set_diffusing_species(self.db, list(set(self.elements)-{'VA'})) if len(pMob) > 0: self.mobCallables[p] = {} for c in self.phase_records[p].nonvacant_elements: From d60346b629f815678895d38c8bf8f2436c8d0ff9 Mon Sep 17 00:00:00 2001 From: Ury Date: Mon, 13 May 2024 10:41:35 -0700 Subject: [PATCH 06/53] additional comments --- kawin/mobility_fitting/liquid_mobility.py | 44 +++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/kawin/mobility_fitting/liquid_mobility.py b/kawin/mobility_fitting/liquid_mobility.py index 7b4463b..cb60c70 100644 --- a/kawin/mobility_fitting/liquid_mobility.py +++ b/kawin/mobility_fitting/liquid_mobility.py @@ -46,6 +46,22 @@ def compute_liquid_mobility_liu(database, species): Units: diameter: Angstroms T_m: K + + From Y. Liu et al, "A predictive equation for solute diffusivity in liquid metals" Scripta Materialia 55 (2006), 367 + + Q = 0.17*R*Tm*(16+K0) J/mol + K0 is integer corresponding to solid phase at melting (BCC = 1, HCP = 2, FCC = 3) + If the phase is neither of those 3, then we assume K0 = 0 + + For self diffusion + D0_BB = (8.95 - 0.0734*A) * 1e-8 m2/s + + For solute diffusion + D0_AB = r_B / r_A * D0_BB + + Then M_AB = D0_AB * exp(-Q/RT) + + In a calphad database, this becomes MQ = -Q + R*T*ln(D0_AB) ''' R = 8.314 @@ -82,6 +98,34 @@ def compute_liquid_mobility_su(database, species): density: g/cm3 T_m: K CTE: m/m + + From X. Su et al, "A new equation for temperature dependent solute impurity diffusivity in liquid metals" Journal of Phase Equilibria and Diffusion 31 (2010) 333 + + Diffusivity starts with Sutherlan-Einstein equation - D = k*T / 4*pi*mu*r + + Dynamic viscosity (mu) + mu_B = C1 * M_B^1/2 * T^1/2 / V_B^2/3 * exp(C2 * TM_B / T) J*s/m3 + C1 = 1.8e-8 (J/K/mol^1/3)^1/2 + C2 = 2.34 + + Radius in liquid + r_A = R0 * (M_A/rho_A)^1/3 * (1 - 0.122 * (T/TM)^1/2) m + R0 = 0.644e-10 + Note: In Su et al, TM is suggested to be melting point of solute (TM_A), but in + P. Protopapas et al, J. Chem. Phys. 59 (1973) 15 (where this equation comes from), + TM is noted to be the melting point of the alloy, in which the solvent (TM_B) is used + Here, we used TM_B for the melting point since it seems to be the trend of smaller radius + leading to higher diffusivity + + D_AB = k*T / 4*pi*mu_B*r_A + + To put in a Calphad database, it's helpful to define equivalents for D0_AB and Q + Q = -C2 * TM_B * R (coming from the viscosity equation) + D0_AB = D0 * T^1/2 / (1 - 0.112 * (T/TM_B)^1/2) + D0 = (k / 4*pi) * (V_B^2/3 / C1*M_B^1/2) * (rho_A^1/3 / M_A^1/3*R0) + Then M = D_AB = D0_AB * exp(-Q/RT) + And MQ = -Q + R*T*ln(D0_AB) + ''' vIndex = find_last_variable(database) C1 = 1.8e-8 From a9e332519aafc80ee70b7272960e98962bef672a Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 17 Sep 2024 14:09:24 -0700 Subject: [PATCH 07/53] workspace compatibility to mobility fitting --- .../error_functions/cached_mobility.py | 153 ------------- .../equilibrium_mobility_error.py | 27 +-- .../non_equilibrium_mobility_error.py | 27 +-- .../mobility_fitting/error_functions/utils.py | 18 +- kawin/mobility_fitting/manual_fitting.py | 4 +- kawin/thermo/Mobility.py | 216 ++++++++++++------ 6 files changed, 174 insertions(+), 271 deletions(-) delete mode 100644 kawin/mobility_fitting/error_functions/cached_mobility.py diff --git a/kawin/mobility_fitting/error_functions/cached_mobility.py b/kawin/mobility_fitting/error_functions/cached_mobility.py deleted file mode 100644 index 3c472c3..0000000 --- a/kawin/mobility_fitting/error_functions/cached_mobility.py +++ /dev/null @@ -1,153 +0,0 @@ -import numpy as np -from pycalphad.core.utils import extract_parameters -from pycalphad import variables as v -from kawin.thermo.Mobility import interstitials - -# ------------------------------------------------------------------ -# For ESPEI assessments -# Quick compute functions using serializable composition set data -# The CompositionSet object itself doesn't appear serializable -# So this will take in data such as dof or elements, which are serializable -# If assessing only mobility parameters, then the thermodynamic factor will be constant for each data point -# Thus, we can cache all the thermodynamic factors and use them to compute mobility without having to compute equilibrium each time -# ------------------------------------------------------------------ -def mobility_from_composition_set_quick(dof, elements, mobility_callables = None, mobility_correction = None, parameters = {}): - if mobility_callables is None: - raise ValueError('mobility_callables is required') - - #Set mobility correction if not set - if mobility_correction is None: - mobility_correction = {A: 1 for A in elements} - else: - for A in elements: - if A not in mobility_correction: - mobility_correction[A] = 1 - - #return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](composition_set.dof) for A in range(len(elements))]) - param_keys, param_values = extract_parameters(parameters) - if len(param_values) > 0: - callableInput = np.concatenate((dof, param_values[0]), dtype=np.float_) - else: - callableInput = dof - return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](callableInput) for A in range(len(elements))]) - -def compute_symbolic_quick(dof, elements, mobility_model, symbol, parameters = {}): - param_keys, param_values = extract_parameters(parameters) - - symbols = sorted([v.T, v.P, v.N, v.GE]) + mobility_model.site_fractions - var_dict = {s:val for s,val in zip(symbols, np.array(dof))} - if len(param_keys) > 0: - for p,val in zip(param_keys, param_values[0]): - var_dict[p] = val - - return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))], dtype=np.float_) - -def mobility_from_composition_set_symbolic_quick(dof, elements, mobility_model, parameters = {}): - return compute_symbolic_quick(dof, elements, mobility_model, 'MQ', parameters) - -def activation_energy_from_composition_set_quick(dof, elements, mobility_model, parameters = {}): - return compute_symbolic_quick(dof, elements, mobility_model, 'MQa', parameters) - -def prefactor_from_composition_set_quick(dof, elements, mobility_model, parameters = {}): - return compute_symbolic_quick(dof, elements, mobility_model, 'lnM0', parameters) - -def tracer_diffusivity_quick(T, mob_from_CS): - R = 8.314 - return R * T * mob_from_CS - -def mobility_matrix_quick(dof, composition, elements, mob_from_CS, phase_record): - X = composition - Usum = np.sum([X[A] for A in range(len(elements)) if elements[A] not in interstitials]) - U = X / Usum - - mob = np.array([U[A] * mob_from_CS[A] for A in range(len(elements))]) - - #Find vacancy site fractions for multiplying with interstitials when making the mobility matrix - #If vacancies are not found on the same sublattice, we'll defualt to 1 so there's at least some mobility and not 0 - # A mobility of 0 would be quite unrealistic - # In addition, as we're working with interstitals, the vacancies are going to be close to 1, so this assumption wouldn't hurt - vaTerms = {} #Maps sublattice index to site fraction index for vacancies - interstitialTerms = {} #Maps interstitial to sublattice index - index = len(phase_record.state_variables) - for i in range(len(phase_record.variables)): - if phase_record.variables[i].species.name == 'VA': - vaTerms[phase_record.variables[i].sublattice_index] = dof[index+i] - if phase_record.variables[i].species.name in interstitials: - interstitialTerms[phase_record.variables[i].species.name] = phase_record.variables[i].sublattice_index - - mobMatrix = np.zeros((len(elements), len(elements))) - for a in range(len(elements)): - if elements[a] in interstitials: - mobMatrix[a, a] = vaTerms.get(interstitialTerms[elements[a]], 1) * mob[a] - else: - for b in range(len(elements)): - if elements[b] not in interstitials: - if a == b: - mobMatrix[a, b] = (1 - U[a]) * mob[b] - else: - mobMatrix[a, b] = -U[a] * mob[b] - mobMatrix *= Usum - - return mobMatrix - -def chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian = False): - Dkj = np.matmul(mobMatrix, dmudx) - - if returnHessian: - return Dkj, dmudx - else: - return Dkj, None - -def interdiffusivity_quick(dmudx, mobMatrix, elements, refElement, returnHessian = False): - ''' - Interdiffusivity (D^n_ab) - - D^n_ab = D_ab - D_an (for substitutional element) - D^n_ab = D_ab (for interstitial element) - - Parameters - ---------- - chemical_potentials : 1-D ndarray - composition_set : pycalphad.core.composition_set.CompositionSet - refElement : str - Reference element n - mobility_callables : dict (optional) - Pre-computed mobility callables for each element - mobility_correction : dict (optional) - Factor to multiply mobility by for each given element (defaults to 1) - returnHessian : bool (optional) - Whether to return chemical potential derivative (defaults to False) - - Returns - ------- - (matrix of floats, free energy hessian) - Each index along an axis correspond to elements in - alphabetical order excluding reference element - free energy hessian will be None if returnHessian is False - ''' - Dkj, hessian = chemical_diffusivity_quick(dmudx, mobMatrix, returnHessian) - - #Find index of reference element - refIndex = 0 - for a in range(len(elements)): - if elements[a] == refElement: - refIndex = a - break - - #Build Dnkj, skipping the reference element - Dnkj = np.zeros((len(elements) - 1, len(elements) - 1)) - c = 0 - d = 0 - for a in range(len(elements)): - if a != refIndex: - for b in range(len(elements)): - if b != refIndex: - if elements[b] in interstitials: - Dnkj[c, d] = Dkj[a, b] - else: - Dnkj[c, d] = Dkj[a, b] - Dkj[a, refIndex] - d += 1 - c += 1 - d = 0 - - return Dnkj, hessian \ No newline at end of file diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index 9952ff4..e834ab5 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -12,7 +12,7 @@ import tinydb from pycalphad import Database, variables as v -from pycalphad.core.utils import filter_phases, unpack_components, unpack_condition, extract_parameters +from pycalphad.core.utils import filter_phases, unpack_species, unpack_condition, extract_parameters from espei.phase_models import PhaseModelSpecification from espei.typing import SymbolName @@ -23,7 +23,8 @@ from kawin.thermo.FreeEnergyHessian import partialdMudX from kawin.thermo.Mobility import interstitials -import kawin.mobility_fitting.error_functions.cached_mobility as cmob +#import kawin.mobility_fitting.error_functions.cached_mobility as cmob +from kawin.thermo.Mobility import mobility_from_dof_phase_record, mobility_matrix_from_dof, chemical_diffusivity_from_mob, interdiffusivity_from_Dkj, prefactor_from_dof_phase_record, activation_energy_from_dof_phase_record, tracer_diffusivity_from_mobility from kawin.mobility_fitting.error_functions.utils import get_output_base_name, get_base_names, build_model, get_base_std _log = logging.getLogger(__name__) @@ -55,7 +56,7 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): #Set diffusing species - this is necessary for tracer data of a component at the limit of X->0 # in which case, the dataset will not include the component when building the model self.diffusing_species = sorted(list(set(self.refComp) | set(self.depComps) | set(self.elements) - set(['VA']))) - self.models, self.phase_records, self.mob_models, self.mob_callables = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) + self.models, self.phase_records, self.mob_models, self.mob_phase_records = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) self.mobility_correction = {c:1 for c in self.non_va_elements} self.conditions = {} @@ -144,7 +145,7 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray #Update phase record parameters param_keys, param_values = extract_parameters(paramDict) for p in data.phases: - data.phase_records[p].parameters[:] = np.asarray(param_values, dtype=np.float_) + data.phase_records[p].parameters[:] = np.asarray(param_values, dtype=np.float64) keys, values = zip(*data.conditions.items()) allConds = [dict(zip(keys,p)) for p in product(*values)] @@ -155,7 +156,8 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray #Compute mobility from cached equilibrium data cs_el, cs_T, cs_dof, cs_X, cs_dmudx = cs_data - mob_from_CS = cmob.mobility_from_composition_set_quick(cs_dof, cs_el, data.mob_callables[data.phases[0]], data.mobility_correction, parameters = paramDict) + #mob_from_CS = cmob.mobility_from_composition_set_quick(cs_dof, cs_el, data.mob_callables[data.phases[0]], data.mobility_correction, parameters = paramDict) + mob_from_CS = mobility_from_dof_phase_record(cs_dof, data.mob_phase_records, data.phases[0], cs_el, paramDict) refIndex = data.non_va_elements.index(data.refComp[0]) @@ -169,8 +171,8 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray # that exists in the database, then the sign of the calculated and desired interdiffusivity # should be the same if data.output == 'INTER_DIFF': - mobMatrix = cmob.mobility_matrix_quick(cs_dof, cs_X, cs_el, mob_from_CS, data.phase_records[data.phases[0]]) - cd, _ = cmob.chemical_diffusivity_quick(cs_dmudx, mobMatrix) + mobMatrix = mobility_matrix_from_dof(cs_dof, cs_X, cs_el, mob_from_CS, data.phase_records[data.phases[0]]) + cd, _ = chemical_diffusivity_from_mob(cs_dmudx, mobMatrix) depComp1 = data.non_va_elements.index(data.depComps[0]) depComp2 = data.non_va_elements.index(data.depComps[1]) @@ -181,18 +183,17 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_DIFF': - tracer_diff = cmob.tracer_diffusivity_quick(cs_T, mob_from_CS) + tracer_diff = tracer_diffusivity_from_mobility(cs_T, mob_from_CS) D = tracer_diff[refIndex] diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_D0': - D0 = cmob.prefactor_from_composition_set_quick(cs_dof, cs_el, data.mob_models[data.phases[0]], parameters = paramDict) - D = np.exp(D0[refIndex]) + D0 = prefactor_from_dof_phase_record(cs_dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] + D = np.exp(D0) diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_Q': - Qs = cmob.activation_energy_from_composition_set_quick(cs_dof, cs_el, data.mob_models[data.phases[0]], parameters = paramDict) - Q = Qs[refIndex] + Q = activation_energy_from_dof_phase_record(cs_dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] diffs.append(Q - value) wts.append(data.weights[i]) @@ -235,7 +236,7 @@ def __init__( comps = sorted(phase_models.components) else: comps = sorted(database.elements) - phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) + phases = sorted(filter_phases(database, unpack_species(database, comps), database.phases.keys())) if symbols_to_fit is None: symbols_to_fit = database_symbols_to_fit(database) # okay if parameters are initialized to zero, we only need the symbol names diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py index ff1bb38..f3c1870 100644 --- a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -10,7 +10,7 @@ import tinydb from pycalphad import Database, variables as v -from pycalphad.core.utils import unpack_components, filter_phases, extract_parameters +from pycalphad.core.utils import unpack_species, filter_phases, extract_parameters from espei.core_utils import ravel_conditions from espei.phase_models import PhaseModelSpecification @@ -19,7 +19,8 @@ from espei.error_functions.residual_base import ResidualFunction, residual_function_registry from espei.error_functions.non_equilibrium_thermochemical_error import calculate_points_array -import kawin.mobility_fitting.error_functions.cached_mobility as cmob +#import kawin.mobility_fitting.error_functions.cached_mobility as cmob +from kawin.thermo.Mobility import mobility_from_dof_phase_record, prefactor_from_dof_phase_record, activation_energy_from_dof_phase_record, tracer_diffusivity_from_mobility from kawin.mobility_fitting.error_functions.utils import get_output_base_name, get_base_names, build_model, get_base_std _log = logging.getLogger(__name__) @@ -48,7 +49,7 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): # in which case, the dataset will not include the component when building the model #TODO: check if we only need refComp for the diffusing species self.diffusing_species = sorted(list(set(self.refComp) | set(self.depComps) | set(self.elements) - set(['VA']))) - self.models, self.phase_records, self.mob_models, self.mob_callables = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) + self.models, self.phase_records, self.mob_models, self.mob_phase_records = build_model(dbf, self.elements, self.phases[0], parameters, self.diffusing_species) self.mobility_correction = {c:1 for c in self.non_va_elements} self._processConditions(data) @@ -120,9 +121,9 @@ def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndar #Update phase record parameters param_keys, param_values = extract_parameters(paramDict) for p in data.phases: - data.phase_records[p].parameters[:] = np.asarray(param_values, dtype=np.float_) + data.phase_records[p].parameters[:] = np.asarray(param_values, dtype=np.float64) - state_variables = sorted([v.T, v.P, v.N, v.GE]) + state_variables = sorted([v.T, v.P, v.N, v.GE], key=str) for i in range(len(data.values)): #Internal degrees of freedom (we include v.GE here to be compatible with kawin) dof = np.zeros(4 + len(data.mob_models[data.phases[0]].site_fractions)) @@ -130,29 +131,25 @@ def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndar dof[state_variables.index(v.P)] = data.P[i] dof[state_variables.index(v.N)] = 1 dof[4:] = data.points[i] - value = data.values[i] - refIndex = data.diffusing_species.index(data.refComp[0]) - #NOTE: for tracer diffusivity and prefactor, we multiply by the sign of the value # This is for cases if the computed and desired values are of different signs # and taking the log of the absolute value will remove this possible difference # In reality, tracer diffusivity and prefactor should always be positive, so # this may not be necessary if data.output == 'TRACER_DIFF': - calculated_values = cmob.mobility_from_composition_set_symbolic_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) - r = calculated_values[refIndex] + mob_from_CS = mobility_from_dof_phase_record(dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] + r = tracer_diffusivity_from_mobility(data.T[i], mob_from_CS) r = np.sign(r) * np.log10(np.abs(r)) value = np.sign(value) * np.log10(np.abs(value)) elif data.output == 'TRACER_Q': - calculated_values = cmob.activation_energy_from_composition_set_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) - r = calculated_values[refIndex] + r = activation_energy_from_dof_phase_record(dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] elif data.output == 'TRACER_D0': - calculated_values = cmob.prefactor_from_composition_set_quick(dof, data.diffusing_species, data.mob_models[data.phases[0]], paramDict) - r = np.exp(calculated_values[refIndex]) + r = prefactor_from_dof_phase_record(dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] + r = np.exp(r) r = np.sign(r) * np.log10(r) value = np.sign(value) * np.log10(np.abs(value)) @@ -197,7 +194,7 @@ def __init__( comps = sorted(phase_models.components) else: comps = sorted(database.elements) - phases = sorted(filter_phases(database, unpack_components(database, comps), database.phases.keys())) + phases = sorted(filter_phases(database, unpack_species(database, comps), database.phases.keys())) if symbols_to_fit is None: symbols_to_fit = database_symbols_to_fit(database) # okay if parameters are initialized to zero, we only need the symbol names diff --git a/kawin/mobility_fitting/error_functions/utils.py b/kawin/mobility_fitting/error_functions/utils.py index 06d4fcd..2359f03 100644 --- a/kawin/mobility_fitting/error_functions/utils.py +++ b/kawin/mobility_fitting/error_functions/utils.py @@ -1,5 +1,5 @@ -from pycalphad import Model, Database, calculate, equilibrium, variables as v -from pycalphad.codegen.callables import build_callables, build_phase_records +from pycalphad import Model, variables as v +from pycalphad.codegen.phase_record_factory import PhaseRecordFactory from pycalphad.core.utils import extract_parameters from kawin.thermo.Mobility import MobilityModel @@ -28,17 +28,11 @@ def build_model(db, elements, phase, parameters, diffusing_species): #TODO: this may not be necessary since v.GE is only added if the model # is built in the GeneralThermodynamics module model[phase].state_variables = sorted([v.T, v.P, v.N, v.GE], key=str) - - phase_record = build_phase_records(db, elements, [phase], model[phase].state_variables, - model, build_gradients=True, build_hessians=True, - parameters=parameters) + prf = PhaseRecordFactory(db, elements, model[phase].state_variables, model, parameters=parameters) mob_model = {phase: MobilityModel(db, elements, phase, parameters=param_keys)} + mob_model[phase].state_variables = sorted([v.T, v.P, v.N, v.GE], key=str) mob_model[phase].set_diffusing_species(db, diffusing_species) - mob_callable = {phase: {}} - diffusing_species = sorted(list(set(diffusing_species) - set(['VA']))) - for c in diffusing_species: - bcp = build_callables(db, elements, [phase], mob_model, parameter_symbols=parameters, output=f'MOB_{c}', build_gradients=False, build_hessians=False, additional_statevars=[v.T, v.P, v.N, v.GE]) - mob_callable[phase][c] = bcp[f'MOB_{c}']['callables'][phase] + mob_prf = PhaseRecordFactory(db, elements, mob_model[phase].state_variables, mob_model, parameters=parameters) - return model, phase_record, mob_model, mob_callable \ No newline at end of file + return model, prf, mob_model, mob_prf \ No newline at end of file diff --git a/kawin/mobility_fitting/manual_fitting.py b/kawin/mobility_fitting/manual_fitting.py index 392604c..f460d27 100644 --- a/kawin/mobility_fitting/manual_fitting.py +++ b/kawin/mobility_fitting/manual_fitting.py @@ -1,6 +1,6 @@ import numpy as np from pycalphad import Database, Model, variables as v -from pycalphad.codegen.callables import build_phase_records +from pycalphad.codegen.phase_record_factory import PhaseRecordFactory from symengine import Piecewise, And, Symbol from tinydb import where from kawin.thermo.LocalEquilibrium import local_equilibrium @@ -36,7 +36,7 @@ def _generate_phase_records(self, components): active_comps, comps = self._generate_comps_key(components) if active_comps not in self.models: self.models[active_comps] = {self.phase: Model(self.db, comps, self.phase)} - self.phase_records[active_comps] = build_phase_records(self.db, comps, [self.phase], {v.T, v.P, v.N, v.GE}, self.models[active_comps]) + self.phase_records[active_comps] = PhaseRecordFactory(self.db, comps, {v.T, v.P, v.N, v.GE}, self.models[active_comps]) self.constituents[active_comps] = [c for cons in self.models[active_comps][self.phase].constituents for c in sorted(list(cons))] def __call__(self, components, conditions : dict[v.StateVariable: float]) -> dict[v.Species: float]: diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index 5c438c9..8c4e2d9 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -311,14 +311,29 @@ def checkOrderingContribution(self, dbe): return -def _get_mobility_arguments(composition_set, parameters): +def _get_mobility_arguments(cs_dof, parameters): param_keys, param_values = extract_parameters(parameters) if len(param_values) > 0: - callableInput = np.concatenate((composition_set.dof, param_values[0]), dtype=np.float64) + callableInput = np.concatenate((cs_dof, param_values[0]), dtype=np.float64) else: - callableInput = composition_set.dof + callableInput = cs_dof return callableInput +def mobility_from_dof(dof, elements, mobility_callables = None, mobility_correction = None, parameters = {}): + if mobility_callables is None: + raise ValueError('mobility_callables is required') + + #Set mobility correction if not set + if mobility_correction is None: + mobility_correction = {A: 1 for A in elements} + else: + for A in elements: + if A not in mobility_correction: + mobility_correction[A] = 1 + + callableInput = _get_mobility_arguments(dof, parameters) + return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](callableInput) for A in range(len(elements))]) + def mobility_from_composition_set(composition_set, mobility_callables = None, mobility_correction = None, parameters = {}): ''' Computes mobility from equilibrium results @@ -337,23 +352,27 @@ def mobility_from_composition_set(composition_set, mobility_callables = None, mo ------- Array for floats for mobility of each element (alphabetical order) ''' - if mobility_callables is None: - raise ValueError('mobility_callables is required') - elements = list(composition_set.phase_record.nonvacant_elements) + return mobility_from_dof(composition_set.dof, elements, mobility_callables, mobility_correction, parameters) - #Set mobility correction if not set - if mobility_correction is None: - mobility_correction = {A: 1 for A in elements} - else: - for A in elements: - if A not in mobility_correction: - mobility_correction[A] = 1 +def compute_phase_record_func_from_dof(dof, prf, phase, symbol, parameters={}): + prop = prf.get_phase_property(phase, symbol, include_grad=False, include_hess=False) + callableInput = _get_mobility_arguments(dof, parameters) + return prop.func(callableInput) - callableInput = _get_mobility_arguments(composition_set, parameters) - return np.array([mobility_correction[elements[A]] * mobility_callables[elements[A]](callableInput) for A in range(len(elements))]) +def mobility_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): + return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MQ_{e}', parameters) for e in elements], + dtype=np.float64) + +def activation_energy_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): + return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MQa_{e}', parameters) for e in elements], + dtype=np.float64) + +def prefactor_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): + return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'lnM0_{e}', parameters) for e in elements], + dtype=np.float64) -def compute_symbolic_expr_from_composition_set(composition_set, mobility_model, symbol, parameters = {}): +def compute_phase_record_func_from_composition_set(composition_set, prf, phase, symbol, parameters={}): ''' Computes mobility symbol from equilibrium results using symbolic model @@ -374,18 +393,9 @@ def compute_symbolic_expr_from_composition_set(composition_set, mobility_model, ------- Array for floats for activation energy of each element (alphabetical order) ''' - elements = composition_set.phase_record.nonvacant_elements - param_keys, param_values = extract_parameters(parameters) - - symbols = sorted([v.T, v.P, v.N, v.GE]) + mobility_model.site_fractions - var_dict = {s:val for s,val in zip(symbols, np.array(composition_set.dof))} - if len(param_keys) > 0: - for p,val in zip(param_keys, param_values[0]): - var_dict[p] = val + return compute_phase_record_func_from_composition_set(composition_set.dof, prf, phase, symbol, parameters) - return np.array([getattr(mobility_model, f'{symbol}_{elements[A]}').subs(var_dict).n(53, real=True) for A in range(len(elements))], np.float_) - -def mobility_from_composition_set_symbolic(composition_set, mobility_model, parameters = {}): +def mobility_from_composition_set_phase_record(composition_set, prf, phase, elements, parameters = {}): ''' Computes mobility from equilibrium results using symbolic model @@ -400,9 +410,9 @@ def mobility_from_composition_set_symbolic(composition_set, mobility_model, para ------- Array for floats for activation energy of each element (alphabetical order) ''' - return compute_symbolic_expr_from_composition_set(composition_set, mobility_model, 'MQ', parameters) - -def activation_energy_from_composition_set(composition_set, mobility_model, parameters = {}): + return mobility_from_dof_phase_record(composition_set.dof, prf, phase, elements, parameters) + +def activation_energy_from_composition_set_phase_record(composition_set, prf, phase, elements, parameters = {}): ''' Computes activation energy for mobility from equilibrium results @@ -417,9 +427,9 @@ def activation_energy_from_composition_set(composition_set, mobility_model, para ------- Array for floats for activation energy of each element (alphabetical order) ''' - return compute_symbolic_expr_from_composition_set(composition_set, mobility_model, 'MQa', parameters) + return activation_energy_from_dof_phase_record(composition_set.dof, prf, phase, elements, parameters) -def prefactor_from_composition_set(composition_set, mobility_model, parameters = {}): +def prefactor_from_composition_set_phase_record(composition_set, prf, phase, elements, parameters = {}): ''' Computes prefactor term, ln(M0), for mobility from equilibrium results @@ -434,7 +444,11 @@ def prefactor_from_composition_set(composition_set, mobility_model, parameters = ------- Array for floats for activation energy of each element (alphabetical order) ''' - return compute_symbolic_expr_from_composition_set(composition_set, mobility_model, 'lnM0', parameters) + return prefactor_from_dof_phase_record(composition_set.dof, prf, phase, elements, parameters) + +def tracer_diffusivity_from_mobility(T, mob_value): + R = 8.314 + return R*T*mob_value def tracer_diffusivity(composition_set, mobility_callables = None, mobility_correction = None, parameters = {}): ''' @@ -455,12 +469,11 @@ def tracer_diffusivity(composition_set, mobility_callables = None, mobility_corr ''' if mobility_callables is None: raise ValueError('mobility_callables is required') - - R = 8.314 T = composition_set.dof[composition_set.phase_record.state_variables.index(v.T)] - return R * T * mobility_from_composition_set(composition_set, mobility_callables, mobility_correction, parameters) + mob_values = mobility_from_composition_set(composition_set, mobility_callables, mobility_correction, parameters) + return tracer_diffusivity_from_mobility(T, mob_values) -def mobility_matrix(composition_set, mobility_callables = None, mobility_correction = None, vacancy_poor_interstitial_sublattice = False, parameters = {}): +def mobility_matrix_from_dof(dof, composition, elements, mob_values, phase_record, vacancy_poor_interstitial_sublattice = False): ''' Mobility matrix Used to obtain diffusivity when multipled with free energy hessian @@ -502,13 +515,10 @@ def mobility_matrix(composition_set, mobility_callables = None, mobility_correct Matrix of floats Each index along an axis correspond to elements in alphabetical order ''' - elements = list(composition_set.phase_record.nonvacant_elements) - X = composition_set.X - U, Usum = x_to_u_frac(X, elements, interstitials, return_usum=True) + U, Usum = x_to_u_frac(composition, elements, interstitials, return_usum=True) #Multiply mobility by U-fraction for ease of use when constructing the mobility matrix - computedMob = mobility_from_composition_set(composition_set, mobility_callables, mobility_correction, parameters) - mob = np.array([U[A] * computedMob[A] for A in range(len(elements))]) + mob = np.array([U[A] * mob_values[A] for A in range(len(elements))]) #Find vacancy site fractions for multiplying with interstitials when making the mobility matrix #If vacancies are not found on the same sublattice, we'll defualt to 1 so there's at least some mobility and not 0 @@ -516,12 +526,12 @@ def mobility_matrix(composition_set, mobility_callables = None, mobility_correct # In addition, as we're working with interstitals, the vacancies are going to be close to 1, so this assumption wouldn't hurt vaTerms = {} #Maps sublattice index to site fraction index for vacancies interstitialTerms = {} #Maps interstitial to sublattice index - index = len(composition_set.phase_record.state_variables) - for i in range(len(composition_set.phase_record.variables)): - if composition_set.phase_record.variables[i].species.name == 'VA': - vaTerms[composition_set.phase_record.variables[i].sublattice_index] = composition_set.dof[index+i] - if composition_set.phase_record.variables[i].species.name in interstitials: - interstitialTerms[composition_set.phase_record.variables[i].species.name] = composition_set.phase_record.variables[i].sublattice_index + index = len(phase_record.state_variables) + for i in range(len(phase_record.variables)): + if phase_record.variables[i].species.name == 'VA': + vaTerms[phase_record.variables[i].sublattice_index] = dof[index+i] + if phase_record.variables[i].species.name in interstitials: + interstitialTerms[phase_record.variables[i].species.name] = phase_record.variables[i].sublattice_index # For interstitials # M_aa = y_Va * M_a @@ -552,6 +562,62 @@ def mobility_matrix(composition_set, mobility_callables = None, mobility_correct return mobMatrix +def mobility_matrix(composition_set, mobility_callables = None, mobility_correction = None, vacancy_poor_interstitial_sublattice = False, parameters = {}): + ''' + Mobility matrix + Used to obtain diffusivity when multipled with free energy hessian + + Parameters + ---------- + composition_set : pycalphad.core.composition_set.CompositionSet + mobility_callables : dict (optional) + Pre-computed mobility callables for each element + mobility_correction : dict (optional) + Factor to multiply mobility by for each given element (defaults to 1) + vacancy_poor_interstitial_sublattice : bool (optional) + Denotes whether the interstitial sublattice is to be modeled assuming that vacancy fraction is near 0 (see notes below) + Defaults to False + parameters : dict (optional) + Maps free parameters names to parameter values + + Notes + ----- + - Substitutional and interstitial components are modeled differently based off the following assumptions: + 1. Substitutional components contribute to the volume of the alloy while interstitials have zero volume + 2. Vacancy fraction in substitutional sublattice is near 0 while vacancy fraction in interstitial sublattice is near 1 + + - Assumption 1 is accounted by considering u-fraction of other components for substitutional and accounting for reference element + when computing interdiffusivity. Interstitials do not account for this since they do not contribute to the volume + + - Assumption 2 is accounted for by multiplying the vacancy site fraction on interstitial mobility + - Mobility is defined in terms of a kinetic parameter (\Omega) that describes the rate of exchange for a component given that + it is near a vacancy + - For substitutionals, we define mobility M = y_VA * \Omega, so the mobility term itself includes the vacancy fraction + since in practice, the vacancy fraction is near 0 + - For interstitials, we define mobility M = \Omega, so it does not factor in the vacancy fraction. Thus we have to + include the vacancy fraction to represent the probability that the component is near a vacancy + - We can override this assumption for interstitials using the vacancy_poor_interstitial_sublattice parameter. This can + be useful for compounds like carbides, where the interstitial sublattice is mostly carbon and the vacancy fraction is near 0 + + Returns + ------- + Matrix of floats + Each index along an axis correspond to elements in alphabetical order + ''' + elements = list(composition_set.phase_record.nonvacant_elements) + X = composition_set.X + computedMob = mobility_from_composition_set(composition_set, mobility_callables, mobility_correction, parameters) + + return mobility_matrix_from_dof(composition_set.dof, X, elements, computedMob, composition_set.phase_record, vacancy_poor_interstitial_sublattice) + +def chemical_diffusivity_from_mob(dmudx, mob_matrix, returnHessian = False): + Dkj = np.matmul(mob_matrix, dmudx) + + if returnHessian: + return Dkj, dmudx + else: + return Dkj, None + def chemical_diffusivity(chemical_potentials, composition_set, mobility_callables, mobility_correction = None, returnHessian = False, vacancy_poor_interstitial_sublattice = False, parameters = {}): ''' Chemical diffusivity (D_kj) @@ -581,12 +647,28 @@ def chemical_diffusivity(chemical_potentials, composition_set, mobility_callable mobility_correction=mobility_correction, vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, parameters=parameters) - Dkj = np.matmul(mobMatrix, dmudx) - - if returnHessian: - return Dkj, dmudx - else: - return Dkj, None + return chemical_diffusivity_from_mob(dmudx, mobMatrix, returnHessian) + +def interdiffusivity_from_Dkj(Dkj, hessian, elements, refElement): + + #Build Dnkj, skipping the reference element + refIndex = elements.index(refElement) + Dnkj = np.zeros((len(elements) - 1, len(elements) - 1)) + c = 0 + d = 0 + for a in range(len(elements)): + if a != refIndex: + for b in range(len(elements)): + if b != refIndex: + if elements[b] in interstitials: + Dnkj[c, d] = Dkj[a, b] + else: + Dnkj[c, d] = Dkj[a, b] - Dkj[a, refIndex] + d += 1 + c += 1 + d = 0 + + return Dnkj, hessian def interdiffusivity(chemical_potentials, composition_set, refElement, mobility_callables = None, mobility_correction = None, returnHessian = False, vacancy_poor_interstitial_sublattice = False, parameters = {}): ''' @@ -619,29 +701,11 @@ def interdiffusivity(chemical_potentials, composition_set, refElement, mobility_ composition_set=composition_set, mobility_callables=mobility_callables, mobility_correction=mobility_correction, - returnHessian=returnHessian, + returnHessian=True, vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, parameters=parameters) elements = list(composition_set.phase_record.nonvacant_elements) - - #Build Dnkj, skipping the reference element - refIndex = elements.index(refElement) - Dnkj = np.zeros((len(elements) - 1, len(elements) - 1)) - c = 0 - d = 0 - for a in range(len(elements)): - if a != refIndex: - for b in range(len(elements)): - if b != refIndex: - if elements[b] in interstitials: - Dnkj[c, d] = Dkj[a, b] - else: - Dnkj[c, d] = Dkj[a, b] - Dkj[a, refIndex] - d += 1 - c += 1 - d = 0 - - return Dnkj, hessian + return interdiffusivity_from_Dkj(Dkj, hessian, elements, refElement) def inverseMobility(chemical_potentials, composition_set, refElement, mobility_callables, mobility_correction = None, returnOther = True, vacancy_poor_interstitial_sublattice = False, parameters = {}): ''' @@ -713,7 +777,7 @@ def tracer_diffusivity_from_diff(composition_set, diffusivity_callables = None, if A not in diffusivity_correction: diffusivity_correction[A] = 1 - callableInput = _get_mobility_arguments(composition_set, parameters) + callableInput = _get_mobility_arguments(composition_set.dof, parameters) return np.array([diffusivity_correction[elements[A]] * diffusivity_callables[elements[A]](callableInput) for A in range(len(elements))]) def interdiffusivity_from_diff(composition_set, refElement, diffusivity_callables, diffusivity_correction = None, parameters = {}): @@ -749,7 +813,7 @@ def interdiffusivity_from_diff(composition_set, refElement, diffusivity_callable if A not in diffusivity_correction: diffusivity_correction[A] = 1 - callableInput = _get_mobility_arguments(composition_set, parameters) + callableInput = _get_mobility_arguments(composition_set.dof, parameters) Dnkj = np.zeros((len(elements) - 1, len(elements) - 1)) eleIndex = 0 for a in range(len(elements) - 1): From 66a21fb81046d8dc71668f2a37c6cfc29423c172 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 17 Sep 2024 14:12:38 -0700 Subject: [PATCH 08/53] fitting with vacancy poor interstitial sublattice --- .../error_functions/equilibrium_mobility_error.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index e834ab5..d8d08d1 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -52,6 +52,7 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): if self.refComp is None and 'TRACER' in data['output']: self.refComp = [data['output'][len(self.output)+1:]] self.depComps = data.get('dependent_el', []) + self.vacancyPoor = data.get('vacancy_poor_interstitial_sublattice', False) #Set diffusing species - this is necessary for tracer data of a component at the limit of X->0 # in which case, the dataset will not include the component when building the model @@ -171,7 +172,7 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray # that exists in the database, then the sign of the calculated and desired interdiffusivity # should be the same if data.output == 'INTER_DIFF': - mobMatrix = mobility_matrix_from_dof(cs_dof, cs_X, cs_el, mob_from_CS, data.phase_records[data.phases[0]]) + mobMatrix = mobility_matrix_from_dof(cs_dof, cs_X, cs_el, mob_from_CS, data.phase_records[data.phases[0]], data.vacancyPoor) cd, _ = chemical_diffusivity_from_mob(cs_dmudx, mobMatrix) depComp1 = data.non_va_elements.index(data.depComps[0]) From 7507516b1cf94ce6e34edccd117d75941af51a40 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Mon, 7 Oct 2024 15:34:20 -0700 Subject: [PATCH 09/53] minor changes --- kawin/diffusion/Diffusion.py | 12 +++---- kawin/diffusion/Homogenization.py | 12 +++++-- kawin/diffusion/Plot.py | 32 +++++++++---------- .../equilibrium_mobility_error.py | 1 + kawin/thermo/Mobility.py | 2 +- 5 files changed, 33 insertions(+), 26 deletions(-) diff --git a/kawin/diffusion/Diffusion.py b/kawin/diffusion/Diffusion.py index bc55fa0..91f95b5 100644 --- a/kawin/diffusion/Diffusion.py +++ b/kawin/diffusion/Diffusion.py @@ -93,7 +93,7 @@ def _getVarDict(self): 'elements': 'elements', 'phases': 'phases', 'z': 'z', - 'zLim': 'zLim', + 'zlim': 'zlim', 'N': 'N', 'finalTime': 't', 'finalX': 'x', @@ -108,7 +108,7 @@ def load(filename): Loads data from filename and returns a PrecipitateModel ''' data = np.load(filename) - model = DiffusionModel(data['zLim'], data['N'], data['elements'], data['phases']) + model = DiffusionModel(data['zlim'], data['N'], data['elements'], data['phases']) model._loadData(data) model.isSetup = True return model @@ -299,8 +299,8 @@ def correctdXdt(self, dt, x, dXdt): #Adjust flux by a scale if it predicts that a composition will go below 0 xfull = np.concatenate((np.array([1-np.sum(x[0],axis=0)]), x[0]), axis=0) dXdtfull = np.concatenate((np.array([-np.sum(dXdt[0],axis=0)]), dXdt[0]), axis=0) - xfull[xfull < self.minComposition] = self.minComposition - dXdtmin = (self.minComposition - xfull) / dt + xfull[xfull < self.parameters.minComposition] = self.parameters.minComposition + dXdtmin = (self.parameters.minComposition - xfull) / dt alpha = np.ones(xfull.shape) indices = dXdtfull != 0 alpha[indices] = dXdtmin[indices] / dXdtfull[indices] @@ -325,8 +325,8 @@ def postProcess(self, time, x): Stores new x and t Records new values if recording is enabled ''' - x[0][x[0] > 1-self.minComposition] = 1-3*self.minComposition - x[0][x[0] < 3*self.minComposition] = self.minComposition + x[0][x[0] > 1-self.parameters.minComposition] = 1-3*self.parameters.minComposition + x[0][x[0] < 3*self.parameters.minComposition] = self.parameters.minComposition self.t = time self.x = x[0] self.x = np.clip(self.x, self.parameters.minComposition, 1-self.parameters.minComposition) diff --git a/kawin/diffusion/Homogenization.py b/kawin/diffusion/Homogenization.py index 9a6f4bc..6198b01 100644 --- a/kawin/diffusion/Homogenization.py +++ b/kawin/diffusion/Homogenization.py @@ -80,7 +80,11 @@ def getFluxes(self): ''' vfluxes = self._getFluxes(self.t, [self.x]) dJ = np.abs(vfluxes[:,1:] - vfluxes[:,:-1]) / self.dz - dt = self.parameters.maxCompositionChange / np.amax(dJ[dJ!=0]) + nonzero_dJ = dJ[dJ!=0] + if len(nonzero_dJ) == 0: + dt = 1 + else: + dt = self.parameters.maxCompositionChange / np.amax(dJ[dJ!=0]) return vfluxes, dt def getDt(self, dXdt): @@ -89,4 +93,8 @@ def getDt(self, dXdt): This is done by finding the time interval such that the composition change caused by the fluxes will be lower than self.maxCompositionChange ''' - return self.parameters.maxCompositionChange / np.amax(np.abs(dXdt[0][dXdt[0]!=0])) + nonzero_dXdt = dXdt[0][dXdt[0]!=0] + if len(nonzero_dXdt) == 0: + return 1 + else: + return self.parameters.maxCompositionChange / np.amax(np.abs(dXdt[0][dXdt[0]!=0])) diff --git a/kawin/diffusion/Plot.py b/kawin/diffusion/Plot.py index 64ef144..8807dd3 100644 --- a/kawin/diffusion/Plot.py +++ b/kawin/diffusion/Plot.py @@ -3,7 +3,7 @@ from kawin.diffusion.DiffusionParameters import computeMobility -def plot(diffModel, ax = None, plotReference = True, plotElement = None, zScale = 1, *args, **kwargs): +def plot(diffModel, ax = None, plotReference = True, plotElement = None, zScale = 1, zOffset = 0, *args, **kwargs): ''' Plots composition profile @@ -30,15 +30,15 @@ def plot(diffModel, ax = None, plotReference = True, plotElement = None, zScale else: e = diffModel._getElementIndex(plotElement) x = diffModel.x[e] - ax.plot(diffModel.z/zScale, x, *args, **kwargs) + ax.plot((diffModel.z+zOffset)/zScale, x, *args, **kwargs) else: if plotReference: refE = 1 - np.sum(diffModel.x, axis=0) - ax.plot(diffModel.z/zScale, refE, label=diffModel.allElements[0], *args, **kwargs) + ax.plot((diffModel.z+zOffset)/zScale, refE, label=diffModel.allElements[0], *args, **kwargs) for e in range(len(diffModel.elements)): - ax.plot(diffModel.z/zScale, diffModel.x[e], label=diffModel.elements[e], *args, **kwargs) + ax.plot((diffModel.z+zOffset)/zScale, diffModel.x[e], label=diffModel.elements[e], *args, **kwargs) - ax.set_xlim([diffModel.zlim[0]/zScale, diffModel.zlim[1]/zScale]) + ax.set_xlim([(diffModel.zlim[0]+zOffset)/zScale, (diffModel.zlim[1]+zOffset)/zScale]) if plotElement is None: ax.legend() ax.set_xlabel('Distance (m)') @@ -46,7 +46,7 @@ def plot(diffModel, ax = None, plotReference = True, plotElement = None, zScale return ax -def plotTwoAxis(diffModel, Lelements, Relements, zScale = 1, axL = None, axR = None, *args, **kwargs): +def plotTwoAxis(diffModel, Lelements, Relements, zScale = 1, zOffset = 0, axL = None, axR = None, *args, **kwargs): ''' Plots composition profile with two y-axes @@ -82,22 +82,22 @@ def plotTwoAxis(diffModel, Lelements, Relements, zScale = 1, axL = None, axR = N for e in range(len(Lelements)): if Lelements[e] in diffModel.elements: eIndex = diffModel._getElementIndex(Lelements[e]) - axL.plot(diffModel.z/zScale, diffModel.x[eIndex], label=diffModel.elements[eIndex], color = 'C' + str(ci), *args, **kwargs) + axL.plot((diffModel.z+zOffset)/zScale, diffModel.x[eIndex], label=diffModel.elements[eIndex], color = 'C' + str(ci), *args, **kwargs) ci = ci+1 if ci <= 9 else 0 elif Lelements[e] in diffModel.allElements: - axL.plot(diffModel.z/zScale, refE, label=diffModel.allElements[0], color = 'C' + str(ci), *args, **kwargs) + axL.plot((diffModel.z+zOffset)/zScale, refE, label=diffModel.allElements[0], color = 'C' + str(ci), *args, **kwargs) ci = ci+1 if ci <= 9 else 0 for e in range(len(Relements)): if Relements[e] in diffModel.elements: eIndex = diffModel._getElementIndex(Relements[e]) - axR.plot(diffModel.z/zScale, diffModel.x[eIndex], label=diffModel.elements[eIndex], color = 'C' + str(ci), *args, **kwargs) + axR.plot((diffModel.z+zOffset)/zScale, diffModel.x[eIndex], label=diffModel.elements[eIndex], color = 'C' + str(ci), *args, **kwargs) ci = ci+1 if ci <= 9 else 0 elif Relements[e] in diffModel.allElements: - axR.plot(diffModel.z/zScale, refE, label=diffModel.allElements[0], color = 'C' + str(ci), *args, **kwargs) + axR.plot((diffModel.z+zOffset)/zScale, refE, label=diffModel.allElements[0], color = 'C' + str(ci), *args, **kwargs) ci = ci+1 if ci <= 9 else 0 - axL.set_xlim([diffModel.zlim[0]/zScale, diffModel.zlim[1]/zScale]) + axL.set_xlim([(diffModel.zlim[0]+zOffset)/zScale, (diffModel.zlim[1]+zOffset)/zScale]) axL.set_xlabel('Distance (m)') axL.set_ylabel('Composition (at.%) ' + str(Lelements)) axR.set_ylabel('Composition (at.%) ' + str(Relements)) @@ -108,7 +108,7 @@ def plotTwoAxis(diffModel, Lelements, Relements, zScale = 1, axL = None, axR = N return axL, axR -def plotPhases(diffModel, ax = None, plotPhase = None, zScale = 1, *args, **kwargs): +def plotPhases(diffModel, ax = None, plotPhase = None, zScale = 1, zOffset = 0, *args, **kwargs): ''' Plots phase fractions over z @@ -126,8 +126,6 @@ def plotPhases(diffModel, ax = None, plotPhase = None, zScale = 1, *args, **kwar if not diffModel.isSetup: diffModel.setup() - else: - diffModel.p = diffModel.updateCompSets(diffModel.x) T = diffModel.parameters.temperature(diffModel.z, diffModel.t) mob_data = computeMobility(diffModel.therm, diffModel.x.T, T, diffModel.parameters) @@ -136,14 +134,14 @@ def plotPhases(diffModel, ax = None, plotPhase = None, zScale = 1, *args, **kwar pf = [] for p_labels, p_fracs in zip(mob_data.phases, mob_data.phase_fractions): pf.append(np.sum(p_fracs[p_labels==plotPhase])) - ax.plot(diffModel.z/zScale, pf, *args, **kwargs) + ax.plot((diffModel.z+zOffset)/zScale, pf, *args, **kwargs) else: for p in range(len(diffModel.phases)): pf = [] for p_labels, p_fracs in zip(mob_data.phases, mob_data.phase_fractions): pf.append(np.sum(p_fracs[p_labels==diffModel.phases[p]])) - ax.plot(diffModel.z/zScale, pf, label=diffModel.phases[p], *args, **kwargs) - ax.set_xlim([diffModel.zlim[0]/zScale, diffModel.zlim[1]/zScale]) + ax.plot((diffModel.z+zOffset)/zScale, pf, label=diffModel.phases[p], *args, **kwargs) + ax.set_xlim([(diffModel.zlim[0]+zOffset)/zScale, (diffModel.zlim[1]+zOffset)/zScale]) ax.set_ylim([0, 1]) ax.set_xlabel('Distance (m)') ax.set_ylabel('Phase Fraction') diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index d8d08d1..958e4f7 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -181,6 +181,7 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray D = cd[depComp1, depComp2] else: D = cd[depComp1, depComp2] - cd[depComp1, refIndex] + print(data.phases[0], cs_T, data.refComp, data.depComps, D, value) diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_DIFF': diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index 8c4e2d9..3fc7edf 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -361,7 +361,7 @@ def compute_phase_record_func_from_dof(dof, prf, phase, symbol, parameters={}): return prop.func(callableInput) def mobility_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): - return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MQ_{e}', parameters) for e in elements], + return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MOB_{e}', parameters) for e in elements], dtype=np.float64) def activation_energy_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): From 8db40a637999756dd1489c1bc7a50e89975af0ab Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Fri, 17 Jan 2025 16:12:43 -0800 Subject: [PATCH 10/53] unit tests for residual functions --- kawin/diffusion/Diffusion.py | 3 +- .../error_functions/__init__.py | 2 + .../equilibrium_mobility_error.py | 53 ++-- .../non_equilibrium_mobility_error.py | 11 +- kawin/mobility_fitting/liquid_mobility.py | 120 ++++---- kawin/mobility_fitting/utils.py | 48 ++-- kawin/tests/test_fitting.py | 271 ++++++++++++++++++ 7 files changed, 400 insertions(+), 108 deletions(-) create mode 100644 kawin/tests/test_fitting.py diff --git a/kawin/diffusion/Diffusion.py b/kawin/diffusion/Diffusion.py index 3575818..02ce680 100644 --- a/kawin/diffusion/Diffusion.py +++ b/kawin/diffusion/Diffusion.py @@ -418,8 +418,9 @@ def printHeader(self): print('Iteration\tSim Time (h)\tRun time (s)') def printStatus(self, iteration, modelTime, simTimeElapsed): + print('{}\t\t{:.3e}\t\t{:.1f}'.format(iteration, modelTime/3600, simTimeElapsed)) # Convert time to hours - super().printStatus(iteration, modelTime/3600, simTimeElapsed) + #super().printStatus(iteration, modelTime/3600, simTimeElapsed) def getCurrentX(self): return self.t, [self.x] diff --git a/kawin/mobility_fitting/error_functions/__init__.py b/kawin/mobility_fitting/error_functions/__init__.py index e69de29..4ee03a6 100644 --- a/kawin/mobility_fitting/error_functions/__init__.py +++ b/kawin/mobility_fitting/error_functions/__init__.py @@ -0,0 +1,2 @@ +from .non_equilibrium_mobility_error import NonEquilibriumMobilityResidual +from .equilibrium_mobility_error import EquilibriumMobilityResidual \ No newline at end of file diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index 958e4f7..348c689 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -3,7 +3,7 @@ based off equilibrium """ import logging -from collections import OrderedDict +from collections import OrderedDict, namedtuple from typing import Dict, List, Optional, Union, Sequence from itertools import product @@ -29,6 +29,8 @@ _log = logging.getLogger(__name__) +CachedCS = namedtuple("CachedCS", ["elements", "temperature", "dof", "x", "dmudx"]) + class EquilibriumMobilityData: """ Stores internal values for each dataset needed to compute output @@ -38,7 +40,7 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.parameter_keys = [p for p in self.parameters] self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} self.output = get_output_base_name(data['output']) - self.reference = data['reference'] + self.reference = data.get('reference', '') pot_conds = OrderedDict([(getattr(v, key), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if not key.startswith('X_')]) comp_conds = OrderedDict([(v.X(key[2:]), unpack_condition(data['conditions'][key])) for key in sorted(data['conditions'].keys()) if key.startswith('X_')]) @@ -99,12 +101,11 @@ def _compute_cached_equilibrium(self, dbf): #Grab data from global cache result, cs = local_equilibrium(dbf, self.elements, self.phases, currConds, self.models, self.phase_records) - cs_el = list(cs[0].phase_record.nonvacant_elements) - cs_T = cs[0].dof[cs[0].phase_record.state_variables.index(v.T)] - cs_dof = np.array(cs[0].dof) - cs_X = np.array(cs[0].X) - cs_dmudx = partialdMudX(result.chemical_potentials, cs[0]) - self.cache[tuple(inds)] = (cs_el, cs_T, cs_dof, cs_X, cs_dmudx) + self.cache[tuple(inds)] = CachedCS(elements=list(cs[0].phase_record.nonvacant_elements), + temperature=cs[0].dof[cs[0].phase_record.state_variables.index(v.T)], + dof=np.array(cs[0].dof), + x=np.array(cs[0].X), + dmudx=partialdMudX(result.chemical_potentials, cs[0])) def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], datasets: PickleableTinyDB, parameters: Dict[str, float], data_weight_dict: Optional[Dict[str, float]] = None): ''' @@ -156,11 +157,12 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray cs_data = data.cache[tuple(inds)] #Compute mobility from cached equilibrium data - cs_el, cs_T, cs_dof, cs_X, cs_dmudx = cs_data - #mob_from_CS = cmob.mobility_from_composition_set_quick(cs_dof, cs_el, data.mob_callables[data.phases[0]], data.mobility_correction, parameters = paramDict) - mob_from_CS = mobility_from_dof_phase_record(cs_dof, data.mob_phase_records, data.phases[0], cs_el, paramDict) - - refIndex = data.non_va_elements.index(data.refComp[0]) + # For interdiffusivity, we want mobilities of the composition set elements + # For tracer diffusivity, we want mobilities of the reference element + if data.output == 'INTER_DIFF': + mob_from_CS = mobility_from_dof_phase_record(cs_data.dof, data.mob_phase_records, data.phases[0], cs_data.elements, paramDict) + else: + mob_from_CS = mobility_from_dof_phase_record(cs_data.dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict) #NOTE: for interdiffusivity, tracer diffusivity and prefactor, we multiply by the sign of the value # This is for cases if the computed and desired values are of different signs @@ -172,30 +174,32 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray # that exists in the database, then the sign of the calculated and desired interdiffusivity # should be the same if data.output == 'INTER_DIFF': - mobMatrix = mobility_matrix_from_dof(cs_dof, cs_X, cs_el, mob_from_CS, data.phase_records[data.phases[0]], data.vacancyPoor) - cd, _ = chemical_diffusivity_from_mob(cs_dmudx, mobMatrix) + mobMatrix = mobility_matrix_from_dof(cs_data.dof, cs_data.x, cs_data.elements, mob_from_CS, data.phase_records[data.phases[0]], data.vacancyPoor) + cd, _ = chemical_diffusivity_from_mob(cs_data.dmudx, mobMatrix) depComp1 = data.non_va_elements.index(data.depComps[0]) depComp2 = data.non_va_elements.index(data.depComps[1]) + refIndex = data.non_va_elements.index(data.refComp[0]) + if data.depComps[1] in interstitials: D = cd[depComp1, depComp2] else: D = cd[depComp1, depComp2] - cd[depComp1, refIndex] - print(data.phases[0], cs_T, data.refComp, data.depComps, D, value) + print(data.phases[0], cs_data.temperature, data.refComp, data.depComps, D, value) diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_DIFF': - tracer_diff = tracer_diffusivity_from_mobility(cs_T, mob_from_CS) - D = tracer_diff[refIndex] + tracer_diff = tracer_diffusivity_from_mobility(cs_data.temperature, mob_from_CS) + D = tracer_diff[0] diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_D0': - D0 = prefactor_from_dof_phase_record(cs_dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] + D0 = prefactor_from_dof_phase_record(cs_data.dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] D = np.exp(D0) diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_Q': - Q = activation_energy_from_dof_phase_record(cs_dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] + Q = activation_energy_from_dof_phase_record(cs_data.dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict)[0] diffs.append(Q - value) wts.append(data.weights[i]) @@ -246,6 +250,15 @@ def __init__( self.mob_data = get_mob_data(database, comps, phases, datasets, parameters, weight) + def get_residuals(self, parameters) -> tuple[list[float], list[float]]: + residuals = [] + weights = [] + for data in self.mob_data: + diffs, wts = calc_mob_differences(data, parameters) + residuals.append(diffs) + weights.append(wts) + return np.concatenate(residuals, axis=0), np.concatenate(weights, axis=0) + def get_likelihood(self, parameters): likelihood = calculate_mob_probability(self.mob_data, parameters) return likelihood diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py index f3c1870..b943b4c 100644 --- a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -34,7 +34,7 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): self.parameter_keys = [p for p in self.parameters] self.data_weight_dict = data_weight_dict if data_weight_dict is not None else {} self.output = get_output_base_name(data['output']) - self.reference = data['reference'] + self.reference = data.get('reference', '') self.comps = data['components'] self.elements = sorted(list(set([v.Species(c).name for c in self.comps]))) @@ -201,6 +201,15 @@ def __init__( parameters = dict(zip(symbols_to_fit, [0]*len(symbols_to_fit))) self.mob_data = get_mob_data(database, comps, phases, datasets, parameters, weight) + + def get_residuals(self, parameters) -> tuple[list[float], list[float]]: + residuals = [] + weights = [] + for data in self.mob_data: + diffs, wts = calc_mob_differences(data, parameters) + residuals.append(diffs) + weights.append(wts) + return np.concatenate(residuals, axis=0), np.concatenate(weights, axis=0) def get_likelihood(self, parameters) -> float: likelihood = calculate_mob_probability(self.mob_data, parameters) diff --git a/kawin/mobility_fitting/liquid_mobility.py b/kawin/mobility_fitting/liquid_mobility.py index cb60c70..17e1fdc 100644 --- a/kawin/mobility_fitting/liquid_mobility.py +++ b/kawin/mobility_fitting/liquid_mobility.py @@ -1,26 +1,34 @@ import numpy as np -from pycalphad import Database, variables as v from symengine import Piecewise, And, Symbol, log + +from pycalphad import Database, variables as v + +from kawin.Constants import GAS_CONSTANT, BOLTZMANN_CONSTANT from kawin.mobility_fitting.utils import _vname, find_last_variable, MobilityTerm -class SpeciesData: - def __init__(self, name, atomic_number, diameter, Tm, melting_phase = None): +def _getK0(melting_phase): + phases = {'BCC': 1, 'HCP': 2, 'FCC': 3} + for p in phases: + if p in melting_phase: + return phases[p] + return 0 + +class LiuSpecies: + def __init__(self, name, diameter, atomic_number, Tm, melting_phase = None): self.name = name - self.atomic_number = atomic_number self.diameter = diameter + self.atomic_number = atomic_number self.Tm = Tm self.melting_phase = melting_phase - self.K0 = self._getK0(melting_phase) - - def _getK0(self, melting_phase): - if melting_phase is None: - return 0 - - phases = {'BCC': 1, 'HCP': 2, 'FCC': 3} - for p in phases: - if p in melting_phase: - return phases[p] - return 0 + self.K0 = _getK0(melting_phase) + +class SuSpecies: + def __init__(self, name, atomic_mass, density, Tm, cte = 0): + self.name = name + self.atomic_mass = atomic_mass + self.density = density + self.Tm = Tm + self.cte = cte def _get_liquid_phase_name(database): for ph in database.phases: @@ -32,14 +40,7 @@ def _get_liquid_phase_name(database): return ph return 'LIQUID' -def _getK0(melting_phase): - phases = {'BCC': 1, 'HCP': 2, 'FCC': 3} - for p in phases: - if p in melting_phase: - return phases[p] - return 0 - -def compute_liquid_mobility_liu(database, species): +def compute_liquid_mobility_liu(database: Database, species: list[LiuSpecies]): ''' Species data will include {diameter, atomic_number, T_m, phase} @@ -47,7 +48,8 @@ def compute_liquid_mobility_liu(database, species): diameter: Angstroms T_m: K - From Y. Liu et al, "A predictive equation for solute diffusivity in liquid metals" Scripta Materialia 55 (2006), 367 + From Y. Liu et al, "A predictive equation for solute diffusivity in liquid metals" + Scripta Materialia 55 (2006), 367. doi:10.1016/j.scriptamat.2006.04.019 Q = 0.17*R*Tm*(16+K0) J/mol K0 is integer corresponding to solid phase at melting (BCC = 1, HCP = 2, FCC = 3) @@ -63,31 +65,25 @@ def compute_liquid_mobility_liu(database, species): In a calphad database, this becomes MQ = -Q + R*T*ln(D0_AB) ''' - R = 8.314 - liq_name = _get_liquid_phase_name(database) mobility_models = {} for solute in species: models = [] for solvent in species: - d_solv, A_solv, Tm_solv, phase_solv = (species[solvent][t] for t in ['diameter', 'atomic_number', 'T_m', 'phase']) - K0_solv = _getK0(phase_solv) - d_solu = species[solute]['diameter'] - - Q = -0.17 * R * Tm_solv * (16 + K0_solv) - D0 = (8.95 - 0.0734 * A_solv) * 1e-8 - D0 *= d_solv / d_solu + Q = -0.17 * GAS_CONSTANT * solvent.Tm * (16 + solvent.K0) + D0 = (8.95 - 0.0734 * solvent.atomic_number) * 1e-8 + D0 *= solvent.diameter / solute.diameter - const_array = [[v.SiteFraction(liq_name, 0, solvent)]] + const_array = [[v.SiteFraction(liq_name, 0, solvent.name)]] mob_term = MobilityTerm(const_array, 0) - mob_term.expr = Piecewise((Q + R*np.log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) + mob_term.expr = Piecewise((Q + GAS_CONSTANT*np.log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) models.append(mob_term) - mobility_models[solute] = models + mobility_models[solute.name] = models return mobility_models -def compute_liquid_mobility_su(database, species): +def compute_liquid_mobility_su(database: Database, species: list[SuSpecies]): ''' Species data will include {atomic_mass, density, T_m, CTE (optional)} If CTE is included, then density/molar volume will be assumed to be at room temperature @@ -99,7 +95,8 @@ def compute_liquid_mobility_su(database, species): T_m: K CTE: m/m - From X. Su et al, "A new equation for temperature dependent solute impurity diffusivity in liquid metals" Journal of Phase Equilibria and Diffusion 31 (2010) 333 + From X. Su et al, "A new equation for temperature dependent solute impurity diffusivity in liquid metals" + Journal of Phase Equilibria and Diffusion 31 (2010) 333. doi:10.1007/s11669-010-9726-4 Diffusivity starts with Sutherlan-Einstein equation - D = k*T / 4*pi*mu*r @@ -127,11 +124,8 @@ def compute_liquid_mobility_su(database, species): And MQ = -Q + R*T*ln(D0_AB) ''' - vIndex = find_last_variable(database) C1 = 1.8e-8 C2 = 2.34 - R = 8.314 - k = 1.38e-23 R0 = 0.644e-10 liq_name = _get_liquid_phase_name(database) @@ -139,35 +133,27 @@ def compute_liquid_mobility_su(database, species): for solute in species: models = [] for solvent in species: - M_solv, rho_solv, Tm_solv = (species[solvent][t] for t in ['atomic_mass', 'density', 'T_m']) - cte_solv = species[solvent].get('CTE', 0) - - M_solu, rho_solu, Tm_solu = (species[solute][t] for t in ['atomic_mass', 'density', 'T_m']) - cte_solu = species[solute].get('CTE', 0) - - rho_solv *= (1 + cte_solv * (Tm_solv - 298.15))**3 - rho_solu *= (1 + cte_solu * (Tm_solv - 298.15))**3 - V_solv = M_solv / rho_solv * 1e-6 #m3/mol - V_solu = M_solu / rho_solu * 1e-6 #m3/mol - - Q = -C2 * Tm_solv * R - D1 = C1 * np.power(M_solv/1000, 1/2) / np.power(V_solv, 2/3) - D2 = R0 * np.power(M_solu / rho_solu, 1/3) - D3 = k / (4*np.pi) - D0 = D3/(D1*D2) * v.T**(1/2) / (1 - 0.112 * (v.T / Tm_solv)**(1/2)) - - const_array = [[v.SiteFraction(liq_name, 0, solvent)]] + rho_solv = solvent.density + rho_solu = solute.density + + # If CTE is non-zero, adjust density to that of the solvent melting point + rho_solv *= (1 + solvent.cte * (solvent.Tm - 298.15))**3 + rho_solu *= (1 + solute.cte * (solvent.Tm - 298.15))**3 + V_solv = solvent.atomic_mass / rho_solv * 1e-6 #m3/mol + V_solu = solute.atomic_mass / rho_solu * 1e-6 #m3/mol + + Q = -C2 * solvent.Tm * GAS_CONSTANT + D1 = C1 * np.power(solvent.atomic_mass/1000, 1/2) / np.power(V_solv, 2/3) + D2 = R0 * np.power(solute.atomic_mass / rho_solu, 1/3) + D3 = BOLTZMANN_CONSTANT / (4*np.pi) + D0 = D3/(D1*D2) * v.T**(1/2) / (1 - 0.112 * (v.T / solvent.Tm)**(1/2)) + + const_array = [[v.SiteFraction(liq_name, 0, solvent.name)]] mob_term = MobilityTerm(const_array, 0) - mob_term.expr = Piecewise((Q + R*log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) + mob_term.expr = Piecewise((Q + GAS_CONSTANT*log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) models.append(mob_term) - mobility_models[solute] = models + mobility_models[solute.name] = models return mobility_models - - - - - - diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py index fd6099a..71f87d3 100644 --- a/kawin/mobility_fitting/utils.py +++ b/kawin/mobility_fitting/utils.py @@ -3,32 +3,42 @@ from pycalphad import Database, variables as v from espei.utils import database_symbols_to_fit -def get_used_database_symbols(dbname, elements, refElement, phases = None, freeSub = False): +def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, includeSub = False): ''' Given the database, grab all symbols that pertain only to the given elements and phases - If freeSub, then parameters for all subsystems (unaries, binaries, ...) will be added - If not, then only grab parameters for the specific number of elements - Ex. If fitting ternary A-B-C - If freeSub, grab parameters from A, B, C, A-B, A-C, B-C and A-B-C - Else, grab parameters only from A-B-C + example: + PARAMETER(BCC_A2&C,AL:0) 298.15 VV0001; 6000.0 N ! + PARAMETER(BCC_A2&C,CR:0) 298.15 VV0002; 6000.0 N ! + PARAMETER(FCC_A1&C,AL:0) 298.15 VV0003; 6000.0 N ! + PARAMETER(FCC_A1&C,CR:0) 298.15 VV0004; 6000.0 N ! - ex: - PARAMETER(BCC_A2,AL:0) 298.15 VV0001; 6000.0 N ! - PARAMETER(BCC_A2,CR:0) 298.15 VV0002; 6000.0 N ! - PARAMETER(FCC_A1,AL:0) 298.15 VV0003; 6000.0 N ! - PARAMETER(FCC_A1,CR:0) 298.15 VV0004; 6000.0 N ! + get_used_database_symbols(db, ['AL'], ['C'], ['BCC_A2'], True) -> VV0001 + get_used_database_symbols(db, ['AL', 'CR'], ['C'], ['FCC_A1'], True) -> [VV0003, VV0004] + get_used_database_symbols(db, ['CR'], ['C'], ['BCC_A2', 'FCC_A1'], True) -> [VV0002, VV0004] - Inputting ['AL'] and ['BCC_A2'] will output VV0001 - Inputting ['AL', 'CR'] and ['FCC_A1'] will output VV0003 and VV0004 - Inputting ['CR'] and ['BCC_A2', 'FCC_A1'] will output VV0002 and VV0004 + Parameters + ---------- + dbf : Database + elements : list[str] + Symbols will be taken from parameters that have all elements in the constituents + diffusingSpecies : str + Name of diffusing species + phases : list[str] (optional) + Default = None + Symbols will be taken from parameters attributed to the phases + If None, all phases will be considered + includeSub : bool (optional) + Default = False + If True, then symbols will also be taken from parameters where constituents is a subset of elements ''' - db = Database(dbname) + if not isinstance(dbf, Database): + dbf = Database(dbf) elements = sorted([e.upper() for e in elements]) numElements = len(elements) elSet = frozenset(elements + ['VA']) usedSyms = frozenset() - for p in db._parameters: + for p in dbf._parameters: if phases is not None: if p['phase_name'] not in phases: continue @@ -37,13 +47,13 @@ def get_used_database_symbols(dbname, elements, refElement, phases = None, freeS # 1. parameterSpecies is a subset of elSet # 2. freeSub is False and length of parameter species (excluding VA) is equal to number of elements pIsSubset = len((parameterSpecies-set(['VA','*'])) - elSet) == 0 - shouldBeFree = freeSub or len(parameterSpecies - set(['VA', '*'])) == numElements - isDiffusingSpecies = p['diffusing_species'].name == refElement + shouldBeFree = includeSub or len(parameterSpecies - set(['VA', '*'])) == numElements + isDiffusingSpecies = p['diffusing_species'].name == diffusingSpecies if pIsSubset and shouldBeFree and isDiffusingSpecies: usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) #if len(parameterSpecies - elSet) == 0: # usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) - allSyms = database_symbols_to_fit(db) + allSyms = database_symbols_to_fit(dbf) usedSyms = sorted(list(usedSyms.intersection(frozenset(allSyms)))) return usedSyms diff --git a/kawin/tests/test_fitting.py b/kawin/tests/test_fitting.py new file mode 100644 index 0000000..9dfcd7e --- /dev/null +++ b/kawin/tests/test_fitting.py @@ -0,0 +1,271 @@ +import numpy as np + +from pycalphad import Database +from espei.utils import PickleableTinyDB, MemoryStorage +from espei.phase_models import PhaseModelSpecification + +from kawin.mobility_fitting.error_functions import NonEquilibriumMobilityResidual, EquilibriumMobilityResidual +from kawin.tests.datasets import * + +def test_non_eq_tracer_D0(): + dataset = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [[["AL", "SI"], "VA"]], + "sublattice_occupancies": [[[0.9, 0.1], 1]] + }, + "output": "TRACER_D0_AL", + "values": [[[1.75e-5]]] + } + + phase_models = { + "components": ["AL", "SI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "SI"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + phase_models = PhaseModelSpecification(**phase_models) + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + datasets_db.insert(dataset) + dbf = Database(ALMGSI_DB) + residual_func = NonEquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) + + residuals, weights = residual_func.get_residuals(np.asarray([])) + assert np.isclose(residuals, [-0.1], rtol=1e-3) + + likelihood = residual_func.get_likelihood(np.asarray([])) + assert np.isclose(likelihood, 0.88341, rtol=1e-3) + +def test_non_eq_tracer_Q(): + dataset = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [[["AL", "SI"], "VA"]], + "sublattice_occupancies": [[[0.9, 0.1], 1]] + }, + "output": "TRACER_Q_SI", + "values": [[[160000]]] + } + + phase_models = { + "components": ["AL", "SI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "SI"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + phase_models = PhaseModelSpecification(**phase_models) + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + datasets_db.insert(dataset) + dbf = Database(ALMGSI_DB) + residual_func = NonEquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) + + residuals, weights = residual_func.get_residuals(np.asarray([])) + assert np.isclose(residuals, [7600], rtol=1e-3) + + likelihood = residual_func.get_likelihood(np.asarray([])) + assert np.isclose(likelihood, -10.41807, rtol=1e-3) + +def test_non_eq_tracer_diff(): + dataset = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [[["AL", "SI"], "VA"]], + "sublattice_occupancies": [[[0.9, 0.1], 1]] + }, + "output": "TRACER_DIFF_MG", + "values": [[[5.2e-26]]] + } + + phase_models = { + "components": ["AL", "SI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "SI"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + phase_models = PhaseModelSpecification(**phase_models) + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + datasets_db.insert(dataset) + dbf = Database(ALMGSI_DB) + residual_func = NonEquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) + + residuals, weights = residual_func.get_residuals(np.asarray([])) + assert np.isclose(residuals, [0.00436798], rtol=1e-3) + + likelihood = residual_func.get_likelihood(np.asarray([])) + assert np.isclose(likelihood, 1.3826926, rtol=1e-3) + +def test_eq_tracer_D0(): + dataset = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_SI": 0.1 + }, + "output": "TRACER_D0_AL", + "values": [[[1.75e-5]]] + } + + phase_models = { + "components": ["AL", "SI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "SI"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + phase_models = PhaseModelSpecification(**phase_models) + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + datasets_db.insert(dataset) + dbf = Database(ALMGSI_DB) + residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) + + residuals, weights = residual_func.get_residuals(np.asarray([])) + assert np.isclose(residuals, [-0.1], rtol=1e-3) + + likelihood = residual_func.get_likelihood(np.asarray([])) + assert np.isclose(likelihood, 0.88341, rtol=1e-3) + +def test_eq_tracer_Q(): + dataset = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_SI": 0.1 + }, + "output": "TRACER_Q_SI", + "values": [[[160000]]] + } + + phase_models = { + "components": ["AL", "SI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "SI"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + phase_models = PhaseModelSpecification(**phase_models) + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + datasets_db.insert(dataset) + dbf = Database(ALMGSI_DB) + residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) + + residuals, weights = residual_func.get_residuals(np.asarray([])) + assert np.isclose(residuals, [7600], rtol=1e-3) + + likelihood = residual_func.get_likelihood(np.asarray([])) + assert np.isclose(likelihood, -10.41807, rtol=1e-3) + +def test_eq_tracer_diff(): + dataset = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_SI": 0.1 + }, + "output": "TRACER_DIFF_MG", + "values": [[[5.2e-26]]] + } + + phase_models = { + "components": ["AL", "SI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "SI"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + phase_models = PhaseModelSpecification(**phase_models) + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + datasets_db.insert(dataset) + dbf = Database(ALMGSI_DB) + residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) + + residuals, weights = residual_func.get_residuals(np.asarray([])) + assert np.isclose(residuals, [0.00436798], rtol=1e-3) + + likelihood = residual_func.get_likelihood(np.asarray([])) + assert np.isclose(likelihood, 1.3826926, rtol=1e-3) + +def test_eq_tracer_interdiff(): + dataset = { + "components": ["AL", "MG", "VA"], + "phases": ["FCC_A1"], + "ref_el": ["AL"], + "dependent_el": ["MG", "MG"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_MG": 0.1 + }, + "output": "INTER_DIFF", + "values": [[[4.6e-25]]] + } + + phase_models = { + "components": ["AL", "MG", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "MG"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + phase_models = PhaseModelSpecification(**phase_models) + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + datasets_db.insert(dataset) + dbf = Database(ALMGSI_DB) + residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) + + residuals, weights = residual_func.get_residuals(np.asarray([])) + assert np.isclose(residuals, [0.00409745], rtol=1e-3) + + likelihood = residual_func.get_likelihood(np.asarray([])) + assert np.isclose(likelihood, 1.382807, rtol=1e-3) + From a6a40038e558fe115c8fbcf99e4a7e9866edb07f Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Thu, 23 Jan 2025 12:34:21 -0800 Subject: [PATCH 11/53] refactor manual fitting --- .github/workflows/pytest.yaml | 2 + kawin/mobility_fitting/liquid_mobility.py | 42 +- kawin/mobility_fitting/manual_fitting.py | 457 ++++++++++++++-------- kawin/mobility_fitting/utils.py | 376 ++++++++++++++---- 4 files changed, 634 insertions(+), 243 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index a92d906..ba85e54 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -29,6 +29,8 @@ jobs: - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV + # temporary - this will install the mobility fitting compatibility espei branch + - run: python -m pip install git+https://github.com/nury12n/ESPEI.git@mobility_fitting_compatibility - run: python -m pip install build - run: python -m build --wheel - run: python -m pip install dist/*.whl diff --git a/kawin/mobility_fitting/liquid_mobility.py b/kawin/mobility_fitting/liquid_mobility.py index 17e1fdc..31e9c69 100644 --- a/kawin/mobility_fitting/liquid_mobility.py +++ b/kawin/mobility_fitting/liquid_mobility.py @@ -1,10 +1,10 @@ import numpy as np -from symengine import Piecewise, And, Symbol, log +from symengine import Piecewise, And, log from pycalphad import Database, variables as v from kawin.Constants import GAS_CONSTANT, BOLTZMANN_CONSTANT -from kawin.mobility_fitting.utils import _vname, find_last_variable, MobilityTerm +from kawin.mobility_fitting.utils import MobilityTemplate def _getK0(melting_phase): phases = {'BCC': 1, 'HCP': 2, 'FCC': 3} @@ -40,7 +40,7 @@ def _get_liquid_phase_name(database): return ph return 'LIQUID' -def compute_liquid_mobility_liu(database: Database, species: list[LiuSpecies]): +def compute_liquid_mobility_liu(dbf: Database, species: list[LiuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: ''' Species data will include {diameter, atomic_number, T_m, phase} @@ -65,25 +65,23 @@ def compute_liquid_mobility_liu(database: Database, species: list[LiuSpecies]): In a calphad database, this becomes MQ = -Q + R*T*ln(D0_AB) ''' - liq_name = _get_liquid_phase_name(database) - mobility_models = {} + liq_name = _get_liquid_phase_name(dbf) + components = [s.name for s in species] + templates = {c: MobilityTemplate(liq_name, c, [1], components, False) for c in components} + # Solute is the diffusing species while solvent is the endmember component for solute in species: - models = [] for solvent in species: Q = -0.17 * GAS_CONSTANT * solvent.Tm * (16 + solvent.K0) D0 = (8.95 - 0.0734 * solvent.atomic_number) * 1e-8 D0 *= solvent.diameter / solute.diameter + templates[solute.name].add_term([solvent.name], 0, Q + GAS_CONSTANT*np.log(D0)*v.T) - const_array = [[v.SiteFraction(liq_name, 0, solvent.name)]] - mob_term = MobilityTerm(const_array, 0) - mob_term.expr = Piecewise((Q + GAS_CONSTANT*np.log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) - models.append(mob_term) - - mobility_models[solute.name] = models + if add_to_database: + templates[solute.name].add_to_database(dbf, {}) - return mobility_models + return templates -def compute_liquid_mobility_su(database: Database, species: list[SuSpecies]): +def compute_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: ''' Species data will include {atomic_mass, density, T_m, CTE (optional)} If CTE is included, then density/molar volume will be assumed to be at room temperature @@ -128,8 +126,10 @@ def compute_liquid_mobility_su(database: Database, species: list[SuSpecies]): C2 = 2.34 R0 = 0.644e-10 - liq_name = _get_liquid_phase_name(database) - mobility_models = {} + liq_name = _get_liquid_phase_name(dbf) + components = [s.name for s in species] + templates = {c: MobilityTemplate(liq_name, c, [1], components, False) for c in components} + # Solute is the diffusing species while solvent is the endmember component for solute in species: models = [] for solvent in species: @@ -148,12 +148,10 @@ def compute_liquid_mobility_su(database: Database, species: list[SuSpecies]): D3 = BOLTZMANN_CONSTANT / (4*np.pi) D0 = D3/(D1*D2) * v.T**(1/2) / (1 - 0.112 * (v.T / solvent.Tm)**(1/2)) - const_array = [[v.SiteFraction(liq_name, 0, solvent.name)]] - mob_term = MobilityTerm(const_array, 0) - mob_term.expr = Piecewise((Q + GAS_CONSTANT*log(D0)*v.T, And(1.0 < v.T, v.T < 10000)), (0, True)) - models.append(mob_term) + templates[solute.name].add_term([solvent.name], 0, Q + GAS_CONSTANT*np.log(D0)*v.T) - mobility_models[solute.name] = models + if add_to_database: + templates[solute.name].add_to_database(dbf, {}) - return mobility_models + return templates diff --git a/kawin/mobility_fitting/manual_fitting.py b/kawin/mobility_fitting/manual_fitting.py index f460d27..f695562 100644 --- a/kawin/mobility_fitting/manual_fitting.py +++ b/kawin/mobility_fitting/manual_fitting.py @@ -1,25 +1,58 @@ +import itertools +from typing import Union +from abc import abstractmethod, ABC + import numpy as np +import matplotlib.pyplot as plt +from symengine import Symbol, Basic +from tinydb import TinyDB, where + from pycalphad import Database, Model, variables as v from pycalphad.codegen.phase_record_factory import PhaseRecordFactory -from symengine import Piecewise, And, Symbol -from tinydb import where -from kawin.thermo.LocalEquilibrium import local_equilibrium from espei.datasets import load_datasets, recursive_glob -from kawin.mobility_fitting.utils import _vname, find_last_variable, MobilityTerm -class EquilibriumSiteFractionGenerator: +from kawin.thermo.LocalEquilibrium import local_equilibrium +from kawin.mobility_fitting.utils import DatasetPair, FittingResult, MobilityTemplate, _eval_symengine_expr + +class SiteFractionGenerator(ABC): + ''' + Object to compute site fractions from conditions + ''' + @abstractmethod + def generate_site_fractions(self, phase: str, components: list[str], conditions : dict[v.StateVariable, float]) -> dict[v.Species, float]: + ''' + Generate site fractions from conditions + + Parameters + ---------- + phase: str + components: list[str] + conditions: dict[v.StateVariable, float] + + Returns + ------- + {v.SiteFraction: float} + ''' + raise NotImplementedError() + +class EquilibriumSiteFractionGenerator(SiteFractionGenerator): ''' Grabs site fraction values from local equilibrium calculations + + Parameters + ---------- + database: Database ''' - def __init__(self, database : Database, phase : str): - self.db = database - self.phase = phase + def __init__(self, database : Database, override_conditions = {}): + if isinstance(database, str): + database = Database(database) + self.dbf = database self.models = {} self.phase_records = {} - self.constituents = {} - self.full_constituents = [c for cons in self.db.phases[self.phase].constituents for c in sorted(list(cons))] self._conditions_override = {v.N: 1, v.GE: 0} + for key, value in override_conditions: + self.set_override_condition(key, value) def set_override_condition(self, variable, value): self._conditions_override[variable] = value @@ -31,18 +64,23 @@ def _generate_comps_key(self, components): comps = sorted(components) return frozenset(comps), comps - def _generate_phase_records(self, components): - # Caches models, phase_records and constituents based off active components + def _generate_phase_records(self, phase, components): + # Caches models, phase_records and constituents based off active components and phase active_comps, comps = self._generate_comps_key(components) if active_comps not in self.models: - self.models[active_comps] = {self.phase: Model(self.db, comps, self.phase)} - self.phase_records[active_comps] = PhaseRecordFactory(self.db, comps, {v.T, v.P, v.N, v.GE}, self.models[active_comps]) - self.constituents[active_comps] = [c for cons in self.models[active_comps][self.phase].constituents for c in sorted(list(cons))] + self.models[active_comps] = {} + self.phase_records[active_comps] = {} + + if phase not in self.models[active_comps]: + self.models[active_comps][phase] = {phase: Model(self.dbf, comps, phase)} + self.phase_records[active_comps][phase] = PhaseRecordFactory(self.dbf, comps, {v.T, v.P, v.N, v.GE}, self.models[active_comps][phase]) + + return self.models[active_comps][phase], self.phase_records[active_comps][phase] - def __call__(self, components, conditions : dict[v.StateVariable: float]) -> dict[v.Species: float]: + def generate_site_fractions(self, phase: str, components: list[str], conditions : dict[v.StateVariable: float]) -> dict[v.Species: float]: # Get phase records from active components active_comps, comps = self._generate_comps_key(components) - self._generate_phase_records(components) + models, prf = self._generate_phase_records(phase, components) # Override any conditions for oc in self._conditions_override: @@ -52,31 +90,101 @@ def __call__(self, components, conditions : dict[v.StateVariable: float]) -> dic # Store site fractions # The first 4 items of CompositionSet.dof refers to v.GE, v.N, v.P and v.T # The order of the site fractions in CompositionSet.dof should correspond to the order in the pycalphad model - results, comp_sets = local_equilibrium(self.db, comps, [self.phase], conditions, self.models[active_comps], self.phase_records[active_comps]) - sfg = {c:val for c,val in zip(self.constituents[active_comps], comp_sets[0].dof[4:])} - for c in self.full_constituents: - sfg[c] = sfg.get(c,0) + results, comp_sets = local_equilibrium(self.dbf, comps, [phase], conditions, models, prf) + sfg = {c:val for c,val in zip(prf[phase].variables, comp_sets[0].dof[4:])} return sfg -class SiteFractionGenerator: - def create_site_fractions(self, composition): - return NotImplementedError() +def grab_datasets(datasets: Union[TinyDB, str], data_type: str, phase: str, components: list[str], diffusing_species: str) -> tuple[list, list]: + ''' + Grabs all datasets for diffusing species of data type + + Parameters + ---------- + datasets: TinyDB | str + If str, must be a folder to load datasets from + data_type: str + Must be Q or D0 + phase: str + components: list[str] + diffusing_species: str + ''' + if data_type != 'Q' and data_type != 'D0': + raise ValueError('Data type must be Q or D0') + + if type(datasets) == str: + datasets = load_datasets(sorted(recursive_glob(datasets, '*.json'))) - def __call__(self, components, conditions): - comps_no_va = list(set(components) - set(['VA'])) - composition = {c:1 for c in comps_no_va} - for key,val in conditions.items(): - if type(key) == v.MoleFraction: - for c in composition: - composition[c] -= val - composition[key.name[2:]] = val + components = list(set(components).union(set(['VA']))) - return self.create_site_fractions(composition) + query = ( + (where('components').test(lambda x: set(x).issubset(components))) & + (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & + (where('output').test(lambda x : f'TRACER_{data_type}' in x and x.endswith(diffusing_species))) + ) + return datasets.search(query) + +def generate_site_fractions(data: list, site_fraction_generator: SiteFractionGenerator = None) -> DatasetPair: + ''' + Collect site fractions and output values from datasets -def least_squares_fit(A, b, p=1): + data: list + List of datasets to grab conditions from + site_fraction_generator: SiteFractionGenerator (optional) + Object that converts conditions to site fraction values + If all datasets are non-equilibrium data, then this is not needed + ''' + site_fractions = [] + Y = [] + for d in data: + conds_grid = [] + conds_key = [] + for c in d['conditions']: + conds_grid.append(np.atleast_1d(d['conditions'][c])) + conds_key.append(v.X(c[2:]) if c.startswith('X_') else getattr(v, c)) + conds_grid = np.meshgrid(*conds_grid) + y_sub = np.array(d['values']).flatten() + + conds_list = {key:val.flatten() for key,val in zip(conds_key, conds_grid)} + + # If non-equilibrium data, we could grab the site fractions directly + if 'solver' in d: + for sub_conf, sub_lat in zip(d['solver']['sublattice_configurations'], d['solver']['sublattice_occupancies']): + sub_index = 0 + sf = {} + for species, occs in zip(sub_conf, sub_lat): + species, occs = np.atleast_1d(species), np.atleast_1d(occs) + for s, o in zip(species, occs): + y = v.SiteFraction(d['phases'][0], sub_index, s) + sf[y] = o + sub_index += 1 + site_fractions.append(sf) + # If equilibrium data, we need a site_fraction_generator function to + # convert composition to site fractions + else: + for i in range(len(y_sub)): + sf = site_fraction_generator.generate_site_fractions(d['phases'][0], d['components'], {key:val[i] for key,val in conds_list.items()}) + site_fractions.append(sf) + + Y = np.concatenate((Y, y_sub)) + + return DatasetPair(site_fractions=site_fractions, values=Y) + +def least_squares_fit(A: np.ndarray, b: np.ndarray, p: int = 1) -> tuple[np.ndarray, float]: ''' Given site fractions and function to generate Redlich-kister terms, compute RK coefficients and AICC criteria + + Parameters + ---------- + A: np.ndarray (M,N) + b: np.ndarray (M,1) + p: int + Penalty factor + + Returns + ------- + x: np.ndarray + aicc: float ''' # Fit coefficients using least squares regression x = np.linalg.lstsq(A, b, rcond=None)[0] @@ -95,138 +203,181 @@ def least_squares_fit(A, b, p=1): aicc = aic + correction return x, aicc -def fit(datasets, database, components, phase, diffusing_species, Q_test_models, D0_test_models, site_fraction_generator, p = 1): +def _fit_model(datasets: Union[TinyDB, str], data_type: str, template: MobilityTemplate, function: Basic, site_fraction_generator: SiteFractionGenerator = None, p = 1, transform = None): ''' - Fit mobility models to datasets + Fits activation energy or prefactor model + This is really more of a helper function for fit_prefactor and fit_activation_energy Parameters ---------- - datasets : list[dict] - Espei datasets - species : list[v.Species] - List of species in mobility_test_models - components : list[str] - phase : str - diffusing_species : str - mobility_test_models : list[list[MobilityTerm]] - site_fraction_generator : function - Takes in components and list of conditions and returns dictionary {v.SiteFraction : float} + datasets: Union[TinyDB, str] + data_type: str + Either 'D0' or 'Q' + template: MobilityTemplate + function: Basic + either MobilityTemplate.prefactor or MobilityTemplate.activation_energy + site_fraction_generate: SiteFractionGenerator + p: int + AICC penalty factor + transform: callable (optional) + Transformation on dataset values to be compatible with the mobility template function + For prefactor, this should be f(x) = ln(x) + For activation energy, this is not needed (i.e. f(x) = x) ''' - if type(datasets) == str: - datasets = load_datasets(sorted(recursive_glob(datasets, '*.json'))) + data = grab_datasets(datasets, data_type, template.phase, template.elements, template.diffusing_species.name) + derivatives = template.get_derivatives(function) + sf_data = generate_site_fractions(data, site_fraction_generator) - components = list(set(components).union(set(['VA']))) + A = np.zeros((len(sf_data.values), len(derivatives.symbols))) + b = np.array(sf_data.values) + if transform is not None: + b = transform(b) - fitted_mobility_model = [] - symbols = {} - vIndex = find_last_variable(database) + for i,j in itertools.product(range(len(sf_data.site_fractions)), range(len(derivatives.functions))): + A[i,j] = _eval_symengine_expr(derivatives.functions[j], sf_data.site_fractions[i]) - # Queries for activation energy (Q) and pre-factor (D0) - q_query = ( - (where('components').test(lambda x: set(x).issubset(components))) & - (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & - (where('output').test(lambda x : 'TRACER_Q' in x and x.endswith(diffusing_species))) - ) - d0_query = ( - (where('components').test(lambda x: set(x).issubset(components))) & - (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & - (where('output').test(lambda x : 'TRACER_D0' in x and x.endswith(diffusing_species))) - ) - q_transform = lambda x : -x - d0_transform = lambda x : 8.314*np.log(x) - - # Data_types will include: - # query - to search for data from datasets - # transform - transforms value to form to fit to (should lead to no extra multiplying factors in the database) - # multiplier - term to multiply by when storing in database - # test_models - list of models to test against - data_types = { - 'Q': (q_query, q_transform, 1, Q_test_models), - 'D0': (d0_query, d0_transform, v.T, D0_test_models) - } - - for data_key, data_val in data_types.items(): - query, transform, multiplier, test_models = data_val - data = datasets.search(query) - - # Collect site fractions and output values from datasets - site_fractions = [] - Y = [] - for d in data: - conds_grid = [] - conds_key = [] - for c in d['conditions']: - conds_grid.append(np.atleast_1d(d['conditions'][c])) - conds_key.append(v.X(c[2:]) if c.startswith('X_') else getattr(v, c)) - conds_grid = np.meshgrid(*conds_grid) - y_sub = transform(np.array(d['values']).flatten()) - - conds_list = {key:val.flatten() for key,val in zip(conds_key, conds_grid)} - - # If non-equilibrium data, we could grab the site fractions directly - if 'solver' in d: - for sub_conf, sub_lat in zip(d['solver']['sublattice_configurations'], d['solver']['sublattice_occupancies']): - sub_index = 0 - sf = {} - for species, occs in zip(sub_conf, sub_lat): - species, occs = np.atleast_1d(species), np.atleast_1d(occs) - for s, o in zip(species, occs): - y = v.SiteFraction(phase, sub_index, s) - sf[y] = o - sub_index += 1 - site_fractions.append(sf) - # If equilibrium data, we need a site_fraction_generator function to - # convert composition to site fractions - else: - for i in range(len(y_sub)): - sf = site_fraction_generator(d['components'], {key:val[i] for key,val in conds_list.items()}) - site_fractions.append(sf) - - Y = np.concatenate((Y, y_sub)) - - # Fit models and evaluate AICC - fitted_models = [] - aiccs = [] - for mob_model in test_models: - X = [[mi.generate_multiplier(sf) for mi in mob_model] for sf in site_fractions] - X = np.array(X) - terms, aicc = least_squares_fit(X, Y, p) - fitted_models.append(terms) - aiccs.append(aicc) - - # Grab best model based off AICC - index = np.argmin(aiccs) - best_model = test_models[index] - best_fit = fitted_models[index] - - # Store each coefficient in the best model to a list of MobilityTerms - # MobilityTerms can be polled for equality, so if a term shows up - # again, the coefficient will be added on rather than overriding it - - # We store the equations as VV00XX + VV00XX*T - # and store the symbols VV00XX as piecewise functions separately - for term, coef in zip(best_model, best_fit): - if term not in fitted_mobility_model: - fitted_mobility_model.append(MobilityTerm(term.constituent_array, term.order)) - - combined_term = fitted_mobility_model[fitted_mobility_model.index(term)] - - var_name = _vname(vIndex) - symbols[var_name] = Piecewise((coef, And(1.0 <= v.T, v.T < 10000)), (0, True)) - combined_term.expr += Symbol(var_name) * multiplier - vIndex += 1 - - # For each mobility term, convert to piecewise function to be compatible with database - for f in fitted_mobility_model: - f.expr = Piecewise((f.expr, And(1.0 <= v.T, v.T < 6000)), (0, True)) - - return fitted_mobility_model, symbols + x, aicc = least_squares_fit(A, b, p) + return {s:xi for s,xi in zip(derivatives.symbols, x)}, aicc +def fit_prefactor(datasets: Union[TinyDB, str], template: MobilityTemplate, site_fraction_generator: SiteFractionGenerator = None, p = 1): + ''' + Fits prefactor model + Parameters + ---------- + datasets: Union[TinyDB, str] + template: MobilityTemplate + site_fraction_generate: SiteFractionGenerator + p: int + AICC penalty factor + + Returns + ------- + symbols: {Symbol: float} + aicc: int + ''' + return _fit_model(datasets, 'D0', template, template.prefactor, site_fraction_generator, p, lambda x: np.log(x)) +def fit_activation_energy(datasets: Union[TinyDB, str], template: MobilityTemplate, site_fraction_generator: SiteFractionGenerator = None, p = 1): + ''' + Fits activation energy model - + Parameters + ---------- + datasets: Union[TinyDB, str] + template: MobilityTemplate + site_fraction_generate: SiteFractionGenerator + p: int + AICC penalty factor + + Returns + ------- + symbols: {Symbol: float} + aicc: int + ''' + return _fit_model(datasets, 'Q', template, template.activation_energy, site_fraction_generator, p) +def select_best_model(datasets: Union[TinyDB, str], templates: list[MobilityTemplate], fit_function: callable, site_fraction_generator: SiteFractionGenerator = None, p = 1, return_all_models = False): + ''' + Fits multiple templates and selects the best one based off the AICC criteria + Parameters + ---------- + datasets: Union[TinyDB, str] + templates: list[MobliityTemplate] + List of mobility templates to fit and compare + fit_function: callable + Function that takes in (datasets, MobilityTemplate, SiteFractionGenerate, penalty factor) and returns fitted parameters and AICC + Options are fit_prefactor and fit_activation_energy + site_fraction_generator: SiteFractionGenerator + p: int + AICC penalty factor + return_all_models: bool + If true, this will also return a list of FittingResults for each template + + Returns + ------- + FittingResults for best model + list[FittingResults] of all models if return_all_models = True + ''' + params_list = [] + aicc_list = [] + for template in templates: + params, aicc = fit_function(datasets, template, site_fraction_generator, p=p) + params_list.append(params) + aicc_list.append(aicc) + + best_index = np.argmin(aicc_list) + + if return_all_models: + all_fits = [FittingResult(template=t, parameters=p, aicc=a) for t,p,a in zip(templates, params_list, aicc_list)] + return all_fits[best_index], all_fits + else: + return FittingResult(template=templates[best_index], parameters=params_list[best_index], aicc=aicc_list[best_index]) +def evaluate_model(template: MobilityTemplate, function: Basic, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float]): + ''' + Evaluates model template along single variable + Parameters + ---------- + template: MobilityTemplate + function: symengine.Basic + Function to evaluate + parameter_values: dict[Symbol, float] + Fitted parameters + Parameters in function that are not defined here will assume to be 0 + site_fraction_generator: SiteFractionGenerator + conditions: dict[v.StateVariable, float] + Conditions to evaluate function, 1 variable must be a list + + Returns + ------- + xs: values of evaluated dependent condition + ys: values of evaluated function + dependent_var: dependent condition + ''' + dependent_var = [key for key, val in conditions.items() if len(np.atleast_1d(val)) > 1] + if len(dependent_var) != 1: + raise ValueError(f"Number of free conditions must be 1, but is {len(dependent_var)}") + + dependent_vals = conditions[dependent_var[0]] + xs = np.linspace(dependent_vals[0], dependent_vals[1], int((dependent_vals[1] - dependent_vals[0])/dependent_vals[2])) + ys = np.zeros(len(xs)) + for i,x in enumerate(xs): + new_conds = {v.N: 1, v.P: 101325, v.GE: 0, v.T: 298.15} + new_conds.update({**conditions}) + new_conds[dependent_var[0]] = x + site_fractions = site_fraction_generator.generate_site_fractions(template.phase, template.elements, new_conds) + ys[i] = _eval_symengine_expr(function, {**site_fractions, **parameter_values, **new_conds}) + + return xs, ys, dependent_var[0] + +def plot_prefactor(template: MobilityTemplate, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float], ax=None, *args, **kwargs): + ''' + Plots mobility prefactor using input parameters + ''' + if ax is None: + fig, ax = plt.subplots() + + xs, ys, dep_var = evaluate_model(template, template.prefactor, parameter_values, site_fraction_generator, conditions) + ax.plot(xs, np.exp(ys), *args, **kwargs) + ax.set_xlim([xs[0], xs[-1]]) + ax.set_xlabel(dep_var) + ax.set_ylabel(r'Diffusion Prefactor ($cm^2/s$)') + ax.set_yscale('log') + return ax + +def plot_activation_energy(template: MobilityTemplate, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float], ax=None, *args, **kwargs): + ''' + Plots mobility activation energy using input parameters + ''' + if ax is None: + fig, ax = plt.subplots() + + xs, ys, dep_var = evaluate_model(template, template.activation_energy, parameter_values, site_fraction_generator, conditions) + ax.plot(xs, ys, *args, **kwargs) + ax.set_xlim([xs[0], xs[-1]]) + ax.set_xlabel(dep_var) + ax.set_ylabel('Activation Energy (J/mol)') + return ax diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py index 71f87d3..d218388 100644 --- a/kawin/mobility_fitting/utils.py +++ b/kawin/mobility_fitting/utils.py @@ -1,8 +1,301 @@ -import numpy as np -from kawin.thermo import GeneralThermodynamics +import itertools +from collections import namedtuple +from typing import Union + +from symengine import Symbol, Basic, S +from tinydb import Query + from pycalphad import Database, variables as v +from pycalphad.io.tdb import _molmass from espei.utils import database_symbols_to_fit +from kawin.thermo.Mobility import MobilityModel + +DerivativePair = namedtuple('DerivativePair', ['functions', 'symbols']) +DatasetPair = namedtuple('SystemPair', ['site_fractions', 'values']) +FittingResult = namedtuple('FittingResult', ['template', 'parameters', 'aicc']) + +def _upsert_parameters(dbf: Database, parameter_type: str, phase: str, constituent_array, parameter_order: int, diffusing_species: str, function: Basic): + species_dict = {s.name: s for s in dbf.species} + tuple_const = tuple(tuple(species_dict.get(s.upper(), v.Species(s)) for s in xs) for xs in constituent_array) + query = Query() + search_query = (query.parameter_type == parameter_type) &\ + (query.phase_name == phase) & \ + (query.constituent_array == tuple_const) & \ + (query.diffusing_species == diffusing_species) & \ + (query.parameter_order == parameter_order) + param = dbf.search(search_query) + if len(param) == 0: + dbf.add_parameter(parameter_type, phase, constituent_array, + parameter_order, function, + diffusing_species=diffusing_species) + else: + dbf._parameters.upsert({'parameter': param[0]['parameter'] + function}, search_query) + +class MobilityTemplate: + ''' + Creates a template of a mobility model for a single diffusing species + + Attributes + ---------- + dbf: Database + phase: str + sublattices: list[int] + constituents: list + diffusing_species: v.Species + num_params: int + Number of parameters added to the database + elements: list[str] + + Parameters + ---------- + phase: str + diffusing_species: str | v.Species + sublattices: list[int] + constituents: list[list[str]] + ''' + def __init__(self, phase: str, diffusing_species: Union[str, v.Species], sublattices: list[int], constituents: list, add_endmembers: bool = True): + self.dbf = Database() + self.phase = phase + self.sublattices = sublattices + self.constituents = constituents + self.diffusing_species = v.Species(diffusing_species) + self.num_params = 0 + self._model = None + + unique_species = list(set(itertools.chain(*constituents))) + for s in unique_species: + sp = v.Species(s) + self.dbf.species.add(sp) + self.dbf.elements.update(list(sp.constituents.keys())) + + # Add reference state, this is to be compatible for phase records, but values aren't + # necessary since we intend to add the parameters to the thermodynamic database in the end + for el in self.dbf.elements: + self.dbf.refstates[el] = {'phase': phase, 'mass': _molmass.get(el, 0.0), 'H298': 0, 'S298': 0} + + self.dbf.add_phase(phase, {}, sublattices) + self.dbf.add_phase_constituents(phase, constituents) + + if add_endmembers: + self.add_endmember_parameters() + + @property + def elements(self) -> list[str]: + return list(self.dbf.elements) + + def _create_constant(self) -> Basic: + ''' + Creates a constant parameter symbol as VV00XX + ''' + parameter_symbol = Symbol(_vname(self.num_params)) + self.num_params += 1 + return parameter_symbol + + def _create_T_term(self) -> Basic: + ''' + Creates a T dependent parameter symbol as VV00XX*T + ''' + parameter_symbol = Symbol(_vname(self.num_params))*v.T + self.num_params += 1 + return parameter_symbol + + def add_endmember_parameters(self): + ''' + Creates A+B*T terms for all endmembers of phase + ''' + for prod in itertools.product(*self.constituents): + constituent_array = [[species] for species in prod] + self.dbf.add_parameter('MQ', self.phase, constituent_array, + 0, self._create_constant() + self._create_T_term(), + diffusing_species=self.diffusing_species) + + # Not really needed since this function is called upon initialization, but to be safe since we modified the database here + self._model = None + + def add_term(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter: Union[callable, Basic], parameter_type: str = 'MQ'): + ''' + Adds a term to a parameter in the database + + If parameter already exists (same symbol, constituent_array and parameter order), then the parameter is + added on to the existing value rather than overwriting it + + Parameters + ---------- + constituent_array: list[list[str]] + param_order: int | list[int] + If list, will add parameters for all specified orders + parameter: callable | Any + If callable, should be a function that generates a parameter symbol + If not callable, should be compatible with a symengine expression + symbol: str (Optional) + Defaults to 'MQ' + Parameter symbol to add in database + By default, we always use 'MQ', but this adds the option to create the 'MF' terms + if they the prefactor and activation energies need to be separate terms (i.e. for + magnetic contributions which are yet unsupported) + ''' + if not isinstance(parameter_order, list): + parameter_order = [parameter_order] + + # If param_func is not callable, then convert to a self-generating function + if callable(parameter): + param_func = parameter + else: + param_func = lambda: parameter + + for p in parameter_order: + _upsert_parameters(self.dbf, parameter_type, self.phase, constituent_array, p, self.diffusing_species, param_func()) + + # Since we updated the database, clear the mobility model if it was made at some point + self._model = None + + def add_prefactor(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter_type: str = 'MQ'): + ''' + Adds a diffusion prefactor term (in form of VV00XX*T) + While the prefactor is defined as M0 in + M = M0/RT * exp(Q/RT), + the prefactor is treated as part of the exponential term as + M = 1/RT * exp((MQ+MF)/RT) where MQ+MF = A+B*T + Here, A refers to the activation energy and B refers to the prefactor + + Parameters + ---------- + constituent_array: list[list[str]] + param_order: int | list[int] + If list, then terms will be added to all specified orders + symbols: str (Optional) + Defaults to 'MQ' + ''' + self.add_term(constituent_array, parameter_order, self._create_T_term, parameter_type=parameter_type) + + def add_activation_energy(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter_type: str='MQ'): + ''' + Adds a activation energy term (in form of VV00XX) + + Parameters + ---------- + constituent_array: list[list[str]] + param_order: int | list[int] + If list, then terms will be added to all specified orders + symbols: str (Optional) + Defaults to 'MQ' + ''' + self.add_term(constituent_array, parameter_order, self._create_constant, parameter_type=parameter_type) + + def copy_parameter(self, constituent_array: list, new_constituent_array: list, parameter_order: int, parameter_type: str = 'MQ'): + ''' + Copies parameter function to new set of constituent array + This is for cases to avoid wildcard usage when a value might be constant across composition space + ''' + species_dict = {s.name: s for s in self.dbf.species} + tuple_const = tuple(tuple(species_dict.get(s.upper(), v.Species(s)) for s in xs) for xs in constituent_array) + query = Query() + search_query = (query.parameter_type == parameter_type) &\ + (query.phase_name == self.phase) & \ + (query.constituent_array == tuple_const) & \ + (query.diffusing_species == self.diffusing_species) & \ + (query.parameter_order == parameter_order) + param = self.dbf.search(search_query) + if len(param) > 0: + p = param[0] + self.dbf.add_parameter(p['parameter_type'], p['phase_name'], new_constituent_array, + p['parameter_order'], p['parameter'], + diffusing_species=p['diffusing_species']) + + @property + def parameters(self) -> list: + ''' + Returns all database parameters for mobility model + ''' + query = Query() + search_query = (query.phase_name == self.phase) & (query.diffusing_species == self.diffusing_species) + return self.dbf._parameters.search(search_query) + + @property + def model(self) -> MobilityModel: + ''' + Returns mobility model built from database parameters + ''' + if self._model is None: + self._model = MobilityModel(self.dbf, self.elements, self.phase) + return self._model + + # mobility_function, MQ, pre_factor and activation_energy are wrappers to + # retrieve the underlying functions in the MobilityModel directly + @property + def mobility_function(self) -> Basic: + ''' + Mobility function: M = 1/RT * exp(-(MQ+MF)/RT) + ''' + return getattr(self.model, f'MOB_{self.diffusing_species.name}') + + @property + def MQ(self) -> Basic: + ''' + Exp part of mobility function: MQ+MF + ''' + return getattr(self.model, f'MQ_{self.diffusing_species}') + + @property + def prefactor(self) -> Basic: + ''' + Natural log of pre-diffusion factor + This refers to all the T-dependent terms in MQ+MF + ''' + return getattr(self.model, f'lnM0_{self.diffusing_species.name}') + + @property + def activation_energy(self) -> Basic: + ''' + Activation energy of pre-diffusion factor + This refers to all the constant terms in MQ+MF + ''' + return getattr(self.model, f'MQa_{self.diffusing_species.name}') + + def get_derivatives(self, function: Basic) -> DerivativePair: + ''' + Creates derivative and corresponding variables for function (would be either lnM0 or Q) + ''' + # NOTE: this assumes that all free variables of interest are in VV00XX format + # If the user doesn't add custom parameters directly, then this assumption should hold + symbol_list = _get_variable_terms(function) + diffs, symbols = [], [] + for s in symbol_list: + diff = function.diff(s) + if diff != S.Zero: + diffs.append(diff) + symbols.append(s) + return DerivativePair(functions=diffs, symbols=symbols) + + def add_to_database(self, dbf: Database, parameter_values: dict[Union[Symbol, str], float]): + ''' + Adds parameters to an existing database + + Parameters + ---------- + dbf: Database + database to add parameters to + parameter_values: dict[Symbol|str, float] + Values for each VV00XX parameter in the mobility model + Any parameter that isn't specified is assumed to be 0 and won't be added to database + ''' + last_var_index = find_last_variable(dbf) + parameter_values = {Symbol(key) if isinstance(key, str) else key: value for key,value in parameter_values.items()} + + symbol_replace_map = {param_name: _vname(i+last_var_index) for i, param_name in enumerate(parameter_values)} + unused_symbols = {s: 0 for s in (set(self.MQ.free_symbols) - set(symbol_replace_map.keys())) if str(s).startswith('VV')} + + for p in self.parameters: + new_func = p['parameter'].subs(unused_symbols) + new_func = new_func.xreplace(symbol_replace_map) + constituent_array = tuple(tuple(s.name for s in xs) for xs in p['constituent_array']) + _upsert_parameters(dbf, p['parameter_type'], p['phase_name'], constituent_array, + p['parameter_order'], p['diffusing_species'], new_func) + + for s in parameter_values: + dbf.symbols[symbol_replace_map[s]] = parameter_values[s] + def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, includeSub = False): ''' Given the database, grab all symbols that pertain only to the given elements and phases @@ -57,80 +350,27 @@ def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, in usedSyms = sorted(list(usedSyms.intersection(frozenset(allSyms)))) return usedSyms -class MobilityTerm: - ''' - Utility class to hold data for a mobility term - - Attributes - ---------- - constituent_array : list[list[str]] - Constituent array - order : int - Redlich-kister polynomial order - ''' - def __init__(self, constituent_array : list[list[v.SiteFraction]], order : int = 0): - self.constituent_array = tuple(constituent_array) - self.order = order - self.expr = 0 - - def generate_multiplier(self, site_fractions): - ''' - Given site fraction values, return result for xA*xB*(xA-xB)**n - - Notes - This will account for multiple sublattices, but mixing on both sublattices will - assume to have the same order polynomial - Tertiary contributions are not included yet - ''' - val = 1 - for clist in self.constituent_array: - clist = np.atleast_1d(clist) - for c in clist: - #The wildcards will be treated as the sum for each component on the sublattice - #However, since the sum is 1, we can ignore it here - if c.species != v.Species('*'): - val *= site_fractions.get(c,0) - if len(clist) == 2: - ordered = sorted(clist) - val *= (site_fractions.get(ordered[1],0) - site_fractions.get(ordered[0],0))**self.order - return val - - def create_constituent_array_list(self): - ''' - Create constituent array list compatible with Database.add_parameter - ''' - return [[c.species.name for c in np.atleast_1d(clist)] for clist in self.constituent_array] - - def __eq__(self, other): - return self.constituent_array == other.constituent_array and self.order == other.order - -def add_mobility_model(database : Database, phase : str, diffusing_species : str, mobility_terms : list[MobilityTerm], symbols : dict[str,float] = {}): - ''' - Add mobility parameters to database - - Parameters - ---------- - database : Pycalphad database object - phase : str - diffusing_species : str - mobility_terms : list[MobilityParameter] - ''' - for mp in mobility_terms: - database.add_parameter('MQ', phase, mp.create_constituent_array_list(), mp.order, mp.expr, diffusing_species=diffusing_species) - for s,val in symbols.items(): - database.symbols[s] = val - -def _vname(index): +def _vname(index: int) -> str: ''' Converts index to VV00XX format ''' return 'VV{:04d}'.format(index) -def find_last_variable(database): +def find_last_variable(database: Database) -> int: ''' Searches database to find the last symbol noted as VV00XX ''' index = 0 while _vname(index) in database.symbols: index += 1 - return index \ No newline at end of file + return index + +def _get_variable_terms(function: Basic) -> list[Symbol]: + return sorted([s for s in function.free_symbols if str(s).startswith('VV')], key=str) + +def _eval_symengine_expr(function: Basic, symbol_map: dict[Symbol, float], ignore_missing = True) -> float: + default_symbols = {} + if ignore_missing: + default_symbols = {s: 0 for s in function.free_symbols} + default_symbols.update(symbol_map) + return float(function.subs(default_symbols).n(73, real=True)) \ No newline at end of file From aa8f0b7ca46caad3642d6f801c77067074a40ede Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Thu, 23 Jan 2025 12:38:53 -0800 Subject: [PATCH 12/53] add mobility fitting model to setup.py --- setup.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 01e1f4b..950bfd9 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,7 @@ def read(fname): author='Nicholas Ury', author_email='nury12n@gmail.com', description='Tool for simulating precipitation using the KWN model coupled with Calphad.', - packages=['kawin', 'kawin.tests', 'kawin.diffusion', 'kawin.precipitation', 'kawin.precipitation.coupling', 'kawin.precipitation.parameters', 'kawin.solver', 'kawin.thermo'], + packages=['kawin', 'kawin.tests', 'kawin.diffusion', 'kawin.precipitation', 'kawin.precipitation.coupling', 'kawin.precipitation.parameters', 'kawin.solver', 'kawin.thermo', 'kawin.mobility_fitting', 'kawin.mobility_fitting.error_functions'], license='MIT', long_description=read('README.md'), long_description_content_type='text/markdown', @@ -21,6 +21,7 @@ def read(fname): 'matplotlib>=3.3', 'numpy>=2.0', 'pycalphad>=0.11', + 'espei', 'scipy', 'setuptools_scm[toml]>=6.0', ], From 88d8121efddc868f95920b007a805cf31d02a7af Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 29 Jan 2025 14:24:23 -0800 Subject: [PATCH 13/53] minor changes --- kawin/diffusion/Diffusion.py | 1 + kawin/mobility_fitting/__init__.py | 4 +- .../equilibrium_mobility_error.py | 1 - kawin/mobility_fitting/fitting_steps.py | 6 +- kawin/mobility_fitting/generate.py | 32 +- kawin/mobility_fitting/liquid_mobility.py | 40 +- kawin/mobility_fitting/manual_fitting.py | 189 +------ kawin/mobility_fitting/template.py | 473 ++++++++++++++++++ kawin/mobility_fitting/utils.py | 298 +---------- kawin/precipitation/KWNBase.py | 1 + 10 files changed, 547 insertions(+), 498 deletions(-) create mode 100644 kawin/mobility_fitting/template.py diff --git a/kawin/diffusion/Diffusion.py b/kawin/diffusion/Diffusion.py index 02ce680..49fbe2d 100644 --- a/kawin/diffusion/Diffusion.py +++ b/kawin/diffusion/Diffusion.py @@ -144,6 +144,7 @@ def fromDict(self, data): self.x = data['finalX'] self._recordedX = data['recordX'] self._recordedTime = data['recordTime'] + self.isSetup = True def setHashSensitivity(self, s): ''' diff --git a/kawin/mobility_fitting/__init__.py b/kawin/mobility_fitting/__init__.py index 02f357f..5ebb0aa 100644 --- a/kawin/mobility_fitting/__init__.py +++ b/kawin/mobility_fitting/__init__.py @@ -1 +1,3 @@ -from .generate import fit_mobility \ No newline at end of file +from .generate import fit_mobility +from .template import MobilityTemplate, SiteFractionGenerator, EquilibriumSiteFractionGenerator, plot_prefactor, plot_activation_energy, transform_activation_energy, transform_prefactor +from .liquid_mobility import SuSpecies, LiuSpecies, generate_liquid_mobility_su, generate_liquid_mobility_liu \ No newline at end of file diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index 348c689..b520a18 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -185,7 +185,6 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray D = cd[depComp1, depComp2] else: D = cd[depComp1, depComp2] - cd[depComp1, refIndex] - print(data.phases[0], cs_data.temperature, data.refComp, data.depComps, D, value) diffs.append((np.sign(D)*np.log10(np.abs(D)) - np.sign(value)*np.log10(np.abs(value)))) elif data.output == 'TRACER_DIFF': diff --git a/kawin/mobility_fitting/fitting_steps.py b/kawin/mobility_fitting/fitting_steps.py index d4c5b7d..8347aa1 100644 --- a/kawin/mobility_fitting/fitting_steps.py +++ b/kawin/mobility_fitting/fitting_steps.py @@ -109,7 +109,7 @@ def shift_reference_state(cls, desired_data: List[Dataset], fixed_model: Model, return total_response @classmethod - def get_response_vector(cls, fixed_model: Model, fixed_portions: List[symengine.Basic], data: List[Dataset], sample_condition_dicts: [Dict[str, Any]]) -> ArrayLike: # np.float_ + def get_response_vector(cls, fixed_model: Model, fixed_portions: List[symengine.Basic], data: List[Dataset], sample_condition_dicts: list[dict[str, Any]]) -> ArrayLike: # np.float64 mole_atoms_per_mole_formula_unit = fixed_model._site_ratio_normalization # Define site fraction symbols that will be reused phase_name = fixed_model.phase_name @@ -118,7 +118,7 @@ def get_response_vector(cls, fixed_model: Model, fixed_portions: List[symengine. site_fractions = [] for ds in data: for _ in ds['conditions']['T']: - sf = build_sitefractions(phase_name, ds['solver']['sublattice_configurations'], ds['solver'].get('sublattice_occupancies', np.ones((len(ds['solver']['sublattice_configurations']), len(ds['solver']['sublattice_configurations'][0])), dtype=np.float_))) + sf = build_sitefractions(phase_name, ds['solver']['sublattice_configurations'], ds['solver'].get('sublattice_occupancies', np.ones((len(ds['solver']['sublattice_configurations']), len(ds['solver']['sublattice_configurations'][0])), dtype=np.float64))) site_fractions.append(sf) site_fractions = list(itertools.chain(*site_fractions)) @@ -139,7 +139,7 @@ def get_response_vector(cls, fixed_model: Model, fixed_portions: List[symengine. sf.update(cond_dict) # also replace with database symbols in case we did higher order fitting data_qtys = [fixed_model.symbol_replace(symengine.S(i).xreplace(sf), fixed_model._symbols).evalf() for i, sf in zip(data_qtys, site_fractions)] - data_qtys = np.asarray(data_qtys, dtype=np.float_) + data_qtys = np.asarray(data_qtys, dtype=np.float64) return data_qtys class StepQ(StepD0): diff --git a/kawin/mobility_fitting/generate.py b/kawin/mobility_fitting/generate.py index 15eacc4..757b6ca 100644 --- a/kawin/mobility_fitting/generate.py +++ b/kawin/mobility_fitting/generate.py @@ -1,9 +1,13 @@ -from tinydb import where import json +import copy + +from tinydb import where + import pycalphad from pycalphad import Database from espei.espei_script import run_espei from espei.parameter_selection.fitting_descriptions import ModelFittingDescription + from kawin.mobility_fitting.fitting_steps import StepQ, StepD0, StepTracerDiffusivity from kawin.thermo.Mobility import MobilityModel @@ -36,7 +40,7 @@ def add_mobility_keywords(elements): pycalphad.io.tdb_keywords.TDB_PARAM_TYPES.append(aliases[-1]) return aliases -def rewrite_mobility_terms(db_name, mob_aliases, tdb_save_params = {}): +def rewrite_mobility_terms(db_name, mob_aliases, tdb_write_kwargs = {}): ''' Rewrites the database to replace MQ_el with MQ(Phase&el,...) @@ -62,17 +66,17 @@ def rewrite_mobility_terms(db_name, mob_aliases, tdb_save_params = {}): for m in mob_aliases: db._parameters.remove(where('parameter_type') == m) - tdb_save_params['if_exists'] = 'overwrite' - db.to_file(db_name, **tdb_save_params) + tdb_write_kwargs['if_exists'] = tdb_write_kwargs.get('if_exists', 'overwrite') + db.to_file(db_name, **tdb_write_kwargs) -def setup_mobility_fitting_description(elements, fit_to_tracer = False): +def setup_mobility_fitting_description(diffusing_species, fit_to_tracer = False): ''' - Create custom classes for diffusion prefactor, activation energy and tracer diffusivity + Defines custom classes for diffusion prefactor, activation energy and tracer diffusivity and add to the global mobility_fitting_description Parameters ---------- - elements : [str] + diffusing_species : [str] List of elements to fit mobility models to fit_to_tracer : bool If False, will fit to datasets of activation energy and pre-factor terms @@ -82,7 +86,7 @@ def setup_mobility_fitting_description(elements, fit_to_tracer = False): to those values instead ''' steps = [] - for e in elements: + for e in diffusing_species: if fit_to_tracer: Dstar = type(f'Tracer_{e}', (StepTracerDiffusivity,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_DIFF_{e}'}) steps.append(Dstar) @@ -94,7 +98,7 @@ def setup_mobility_fitting_description(elements, fit_to_tracer = False): global fitting_description fitting_description = ModelFittingDescription(steps, model=MobilityModel) -def fit_mobility(input_settings, fit_to_tracer=False, tdb_save_params = {}): +def fit_mobility(input_settings, diffusing_species = None, fit_to_tracer=False, tdb_write_kwargs = {}): ''' Wrapper around run_espei to do the following: 1. Find components to fit mobility to @@ -116,9 +120,13 @@ def fit_mobility(input_settings, fit_to_tracer=False, tdb_save_params = {}): #Get non-VA components components = list(set(phase_models['components']) - set(['VA'])) - aliases = add_mobility_keywords(components) - setup_mobility_fitting_description(components, fit_to_tracer=fit_to_tracer) + # If no diffusing species, then assume same as components + if diffusing_species is None: + diffusing_species = components + + aliases = add_mobility_keywords(diffusing_species) + setup_mobility_fitting_description(diffusing_species, fit_to_tracer=fit_to_tracer) out_db = input_settings['output']['output_db'] run_espei(input_settings) - rewrite_mobility_terms(out_db, aliases, tdb_save_params=tdb_save_params) \ No newline at end of file + rewrite_mobility_terms(out_db, aliases, tdb_write_kwargs=tdb_write_kwargs) \ No newline at end of file diff --git a/kawin/mobility_fitting/liquid_mobility.py b/kawin/mobility_fitting/liquid_mobility.py index 31e9c69..2013d52 100644 --- a/kawin/mobility_fitting/liquid_mobility.py +++ b/kawin/mobility_fitting/liquid_mobility.py @@ -1,12 +1,14 @@ import numpy as np -from symengine import Piecewise, And, log +from symengine import log from pycalphad import Database, variables as v from kawin.Constants import GAS_CONSTANT, BOLTZMANN_CONSTANT -from kawin.mobility_fitting.utils import MobilityTemplate +from kawin.mobility_fitting.template import MobilityTemplate def _getK0(melting_phase): + if melting_phase is None: + return 0 phases = {'BCC': 1, 'HCP': 2, 'FCC': 3} for p in phases: if p in melting_phase: @@ -14,6 +16,11 @@ def _getK0(melting_phase): return 0 class LiuSpecies: + ''' + Units: + diameter: Angstroms + T_m: K + ''' def __init__(self, name, diameter, atomic_number, Tm, melting_phase = None): self.name = name self.diameter = diameter @@ -23,6 +30,13 @@ def __init__(self, name, diameter, atomic_number, Tm, melting_phase = None): self.K0 = _getK0(melting_phase) class SuSpecies: + ''' + Units: + atomic_mass: g/mol + density: g/cm3 + T_m: K + CTE: m/m + ''' def __init__(self, name, atomic_mass, density, Tm, cte = 0): self.name = name self.atomic_mass = atomic_mass @@ -40,14 +54,10 @@ def _get_liquid_phase_name(database): return ph return 'LIQUID' -def compute_liquid_mobility_liu(dbf: Database, species: list[LiuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: +def generate_liquid_mobility_liu(dbf: Database, species: list[LiuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: ''' Species data will include {diameter, atomic_number, T_m, phase} - Units: - diameter: Angstroms - T_m: K - From Y. Liu et al, "A predictive equation for solute diffusivity in liquid metals" Scripta Materialia 55 (2006), 367. doi:10.1016/j.scriptamat.2006.04.019 @@ -67,32 +77,26 @@ def compute_liquid_mobility_liu(dbf: Database, species: list[LiuSpecies], add_to ''' liq_name = _get_liquid_phase_name(dbf) components = [s.name for s in species] - templates = {c: MobilityTemplate(liq_name, c, [1], components, False) for c in components} + templates = {c: MobilityTemplate(liq_name, c, [1], [components], False) for c in components} # Solute is the diffusing species while solvent is the endmember component for solute in species: for solvent in species: Q = -0.17 * GAS_CONSTANT * solvent.Tm * (16 + solvent.K0) D0 = (8.95 - 0.0734 * solvent.atomic_number) * 1e-8 D0 *= solvent.diameter / solute.diameter - templates[solute.name].add_term([solvent.name], 0, Q + GAS_CONSTANT*np.log(D0)*v.T) + templates[solute.name].add_term([[solvent.name]], 0, Q + GAS_CONSTANT*np.log(D0)*v.T) if add_to_database: templates[solute.name].add_to_database(dbf, {}) return templates -def compute_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: +def generate_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: ''' Species data will include {atomic_mass, density, T_m, CTE (optional)} If CTE is included, then density/molar volume will be assumed to be at room temperature And will be adjusted to the melting point - Units: - atomic_mass: g/mol - density: g/cm3 - T_m: K - CTE: m/m - From X. Su et al, "A new equation for temperature dependent solute impurity diffusivity in liquid metals" Journal of Phase Equilibria and Diffusion 31 (2010) 333. doi:10.1007/s11669-010-9726-4 @@ -128,7 +132,7 @@ def compute_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_d liq_name = _get_liquid_phase_name(dbf) components = [s.name for s in species] - templates = {c: MobilityTemplate(liq_name, c, [1], components, False) for c in components} + templates = {c: MobilityTemplate(liq_name, c, [1], [components], False) for c in components} # Solute is the diffusing species while solvent is the endmember component for solute in species: models = [] @@ -148,7 +152,7 @@ def compute_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_d D3 = BOLTZMANN_CONSTANT / (4*np.pi) D0 = D3/(D1*D2) * v.T**(1/2) / (1 - 0.112 * (v.T / solvent.Tm)**(1/2)) - templates[solute.name].add_term([solvent.name], 0, Q + GAS_CONSTANT*np.log(D0)*v.T) + templates[solute.name].add_term([[solvent.name]], 0, Q + GAS_CONSTANT*log(D0)*v.T) if add_to_database: templates[solute.name].add_to_database(dbf, {}) diff --git a/kawin/mobility_fitting/manual_fitting.py b/kawin/mobility_fitting/manual_fitting.py index f695562..f65df01 100644 --- a/kawin/mobility_fitting/manual_fitting.py +++ b/kawin/mobility_fitting/manual_fitting.py @@ -1,100 +1,21 @@ import itertools from typing import Union -from abc import abstractmethod, ABC +from collections import namedtuple import numpy as np -import matplotlib.pyplot as plt -from symengine import Symbol, Basic +from symengine import Basic from tinydb import TinyDB, where -from pycalphad import Database, Model, variables as v -from pycalphad.codegen.phase_record_factory import PhaseRecordFactory +from pycalphad import variables as v from espei.datasets import load_datasets, recursive_glob -from kawin.thermo.LocalEquilibrium import local_equilibrium -from kawin.mobility_fitting.utils import DatasetPair, FittingResult, MobilityTemplate, _eval_symengine_expr - -class SiteFractionGenerator(ABC): - ''' - Object to compute site fractions from conditions - ''' - @abstractmethod - def generate_site_fractions(self, phase: str, components: list[str], conditions : dict[v.StateVariable, float]) -> dict[v.Species, float]: - ''' - Generate site fractions from conditions - - Parameters - ---------- - phase: str - components: list[str] - conditions: dict[v.StateVariable, float] - - Returns - ------- - {v.SiteFraction: float} - ''' - raise NotImplementedError() - -class EquilibriumSiteFractionGenerator(SiteFractionGenerator): - ''' - Grabs site fraction values from local equilibrium calculations - - Parameters - ---------- - database: Database - ''' - def __init__(self, database : Database, override_conditions = {}): - if isinstance(database, str): - database = Database(database) - self.dbf = database - self.models = {} - self.phase_records = {} +from kawin.mobility_fitting.template import MobilityTemplate, SiteFractionGenerator +from kawin.mobility_fitting.utils import _eval_symengine_expr - self._conditions_override = {v.N: 1, v.GE: 0} - for key, value in override_conditions: - self.set_override_condition(key, value) - - def set_override_condition(self, variable, value): - self._conditions_override[variable] = value - - def remove_override_condition(self, variable): - self._conditions_override.pop(variable) - - def _generate_comps_key(self, components): - comps = sorted(components) - return frozenset(comps), comps - - def _generate_phase_records(self, phase, components): - # Caches models, phase_records and constituents based off active components and phase - active_comps, comps = self._generate_comps_key(components) - if active_comps not in self.models: - self.models[active_comps] = {} - self.phase_records[active_comps] = {} - - if phase not in self.models[active_comps]: - self.models[active_comps][phase] = {phase: Model(self.dbf, comps, phase)} - self.phase_records[active_comps][phase] = PhaseRecordFactory(self.dbf, comps, {v.T, v.P, v.N, v.GE}, self.models[active_comps][phase]) - - return self.models[active_comps][phase], self.phase_records[active_comps][phase] - - def generate_site_fractions(self, phase: str, components: list[str], conditions : dict[v.StateVariable: float]) -> dict[v.Species: float]: - # Get phase records from active components - active_comps, comps = self._generate_comps_key(components) - models, prf = self._generate_phase_records(phase, components) - - # Override any conditions - for oc in self._conditions_override: - conditions[oc] = self._conditions_override[oc] - - # Compute local equilibrium (to avoid miscibility gaps) - # Store site fractions - # The first 4 items of CompositionSet.dof refers to v.GE, v.N, v.P and v.T - # The order of the site fractions in CompositionSet.dof should correspond to the order in the pycalphad model - results, comp_sets = local_equilibrium(self.dbf, comps, [phase], conditions, models, prf) - sfg = {c:val for c,val in zip(prf[phase].variables, comp_sets[0].dof[4:])} - return sfg +DatasetPair = namedtuple('SystemPair', ['site_fractions', 'values']) +FittingResult = namedtuple('FittingResult', ['template', 'parameters', 'aicc']) -def grab_datasets(datasets: Union[TinyDB, str], data_type: str, phase: str, components: list[str], diffusing_species: str) -> tuple[list, list]: +def grab_datasets(datasets: Union[TinyDB, str], data_type: str, phase: str, components: list[str], diffusing_species: str, include_disabled: bool = False) -> tuple[list, list]: ''' Grabs all datasets for diffusing species of data type @@ -112,10 +33,10 @@ def grab_datasets(datasets: Union[TinyDB, str], data_type: str, phase: str, comp raise ValueError('Data type must be Q or D0') if type(datasets) == str: - datasets = load_datasets(sorted(recursive_glob(datasets, '*.json'))) + datasets = load_datasets(sorted(recursive_glob(datasets, '*.json')), include_disabled) components = list(set(components).union(set(['VA']))) - + query = ( (where('components').test(lambda x: set(x).issubset(components))) & (where('phases').test(lambda x: len(x) == 1 and x[0] == phase)) & @@ -203,14 +124,14 @@ def least_squares_fit(A: np.ndarray, b: np.ndarray, p: int = 1) -> tuple[np.ndar aicc = aic + correction return x, aicc -def _fit_model(datasets: Union[TinyDB, str], data_type: str, template: MobilityTemplate, function: Basic, site_fraction_generator: SiteFractionGenerator = None, p = 1, transform = None): +def _fit_model(data: list, template: MobilityTemplate, function: Basic, site_fraction_generator: SiteFractionGenerator = None, p = 1, transform = None): ''' Fits activation energy or prefactor model This is really more of a helper function for fit_prefactor and fit_activation_energy Parameters ---------- - datasets: Union[TinyDB, str] + datasets: list data_type: str Either 'D0' or 'Q' template: MobilityTemplate @@ -224,7 +145,6 @@ def _fit_model(datasets: Union[TinyDB, str], data_type: str, template: MobilityT For prefactor, this should be f(x) = ln(x) For activation energy, this is not needed (i.e. f(x) = x) ''' - data = grab_datasets(datasets, data_type, template.phase, template.elements, template.diffusing_species.name) derivatives = template.get_derivatives(function) sf_data = generate_site_fractions(data, site_fraction_generator) @@ -239,13 +159,13 @@ def _fit_model(datasets: Union[TinyDB, str], data_type: str, template: MobilityT x, aicc = least_squares_fit(A, b, p) return {s:xi for s,xi in zip(derivatives.symbols, x)}, aicc -def fit_prefactor(datasets: Union[TinyDB, str], template: MobilityTemplate, site_fraction_generator: SiteFractionGenerator = None, p = 1): +def fit_prefactor(data: list, template: MobilityTemplate, site_fraction_generator: SiteFractionGenerator = None, p = 1): ''' Fits prefactor model Parameters ---------- - datasets: Union[TinyDB, str] + data: list template: MobilityTemplate site_fraction_generate: SiteFractionGenerator p: int @@ -256,15 +176,15 @@ def fit_prefactor(datasets: Union[TinyDB, str], template: MobilityTemplate, site symbols: {Symbol: float} aicc: int ''' - return _fit_model(datasets, 'D0', template, template.prefactor, site_fraction_generator, p, lambda x: np.log(x)) + return _fit_model(data, template, template.prefactor, site_fraction_generator, p, lambda x: np.log(x)) -def fit_activation_energy(datasets: Union[TinyDB, str], template: MobilityTemplate, site_fraction_generator: SiteFractionGenerator = None, p = 1): +def fit_activation_energy(data: list, template: MobilityTemplate, site_fraction_generator: SiteFractionGenerator = None, p = 1): ''' Fits activation energy model Parameters ---------- - datasets: Union[TinyDB, str] + data: list template: MobilityTemplate site_fraction_generate: SiteFractionGenerator p: int @@ -275,15 +195,15 @@ def fit_activation_energy(datasets: Union[TinyDB, str], template: MobilityTempla symbols: {Symbol: float} aicc: int ''' - return _fit_model(datasets, 'Q', template, template.activation_energy, site_fraction_generator, p) + return _fit_model(data, template, template.activation_energy, site_fraction_generator, p) -def select_best_model(datasets: Union[TinyDB, str], templates: list[MobilityTemplate], fit_function: callable, site_fraction_generator: SiteFractionGenerator = None, p = 1, return_all_models = False): +def select_best_model(data: list, templates: list[MobilityTemplate], fit_function: callable, site_fraction_generator: SiteFractionGenerator = None, p = 1, return_all_models = False): ''' Fits multiple templates and selects the best one based off the AICC criteria Parameters ---------- - datasets: Union[TinyDB, str] + data: list templates: list[MobliityTemplate] List of mobility templates to fit and compare fit_function: callable @@ -303,7 +223,7 @@ def select_best_model(datasets: Union[TinyDB, str], templates: list[MobilityTemp params_list = [] aicc_list = [] for template in templates: - params, aicc = fit_function(datasets, template, site_fraction_generator, p=p) + params, aicc = fit_function(data, template, site_fraction_generator, p=p) params_list.append(params) aicc_list.append(aicc) @@ -314,70 +234,3 @@ def select_best_model(datasets: Union[TinyDB, str], templates: list[MobilityTemp return all_fits[best_index], all_fits else: return FittingResult(template=templates[best_index], parameters=params_list[best_index], aicc=aicc_list[best_index]) - -def evaluate_model(template: MobilityTemplate, function: Basic, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float]): - ''' - Evaluates model template along single variable - - Parameters - ---------- - template: MobilityTemplate - function: symengine.Basic - Function to evaluate - parameter_values: dict[Symbol, float] - Fitted parameters - Parameters in function that are not defined here will assume to be 0 - site_fraction_generator: SiteFractionGenerator - conditions: dict[v.StateVariable, float] - Conditions to evaluate function, 1 variable must be a list - - Returns - ------- - xs: values of evaluated dependent condition - ys: values of evaluated function - dependent_var: dependent condition - ''' - dependent_var = [key for key, val in conditions.items() if len(np.atleast_1d(val)) > 1] - if len(dependent_var) != 1: - raise ValueError(f"Number of free conditions must be 1, but is {len(dependent_var)}") - - dependent_vals = conditions[dependent_var[0]] - xs = np.linspace(dependent_vals[0], dependent_vals[1], int((dependent_vals[1] - dependent_vals[0])/dependent_vals[2])) - ys = np.zeros(len(xs)) - for i,x in enumerate(xs): - new_conds = {v.N: 1, v.P: 101325, v.GE: 0, v.T: 298.15} - new_conds.update({**conditions}) - new_conds[dependent_var[0]] = x - site_fractions = site_fraction_generator.generate_site_fractions(template.phase, template.elements, new_conds) - ys[i] = _eval_symengine_expr(function, {**site_fractions, **parameter_values, **new_conds}) - - return xs, ys, dependent_var[0] - -def plot_prefactor(template: MobilityTemplate, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float], ax=None, *args, **kwargs): - ''' - Plots mobility prefactor using input parameters - ''' - if ax is None: - fig, ax = plt.subplots() - - xs, ys, dep_var = evaluate_model(template, template.prefactor, parameter_values, site_fraction_generator, conditions) - ax.plot(xs, np.exp(ys), *args, **kwargs) - ax.set_xlim([xs[0], xs[-1]]) - ax.set_xlabel(dep_var) - ax.set_ylabel(r'Diffusion Prefactor ($cm^2/s$)') - ax.set_yscale('log') - return ax - -def plot_activation_energy(template: MobilityTemplate, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float], ax=None, *args, **kwargs): - ''' - Plots mobility activation energy using input parameters - ''' - if ax is None: - fig, ax = plt.subplots() - - xs, ys, dep_var = evaluate_model(template, template.activation_energy, parameter_values, site_fraction_generator, conditions) - ax.plot(xs, ys, *args, **kwargs) - ax.set_xlim([xs[0], xs[-1]]) - ax.set_xlabel(dep_var) - ax.set_ylabel('Activation Energy (J/mol)') - return ax diff --git a/kawin/mobility_fitting/template.py b/kawin/mobility_fitting/template.py new file mode 100644 index 0000000..7619227 --- /dev/null +++ b/kawin/mobility_fitting/template.py @@ -0,0 +1,473 @@ +import itertools +from typing import Union +from abc import abstractmethod, ABC +from collections import namedtuple + +import numpy as np +import matplotlib.pyplot as plt +from symengine import Symbol, Basic, S +from tinydb import Query + +from pycalphad import Database, Model, variables as v +from pycalphad.codegen.phase_record_factory import PhaseRecordFactory +from pycalphad.io.tdb import _molmass + +from kawin.thermo.LocalEquilibrium import local_equilibrium +from kawin.thermo.Mobility import MobilityModel +from kawin.mobility_fitting.utils import _vname, _get_variable_terms, _eval_symengine_expr, find_last_variable + +DerivativePair = namedtuple('DerivativePair', ['functions', 'symbols']) + +def _upsert_parameters(dbf: Database, parameter_type: str, phase: str, constituent_array, parameter_order: int, diffusing_species: str, function: Basic, add_if_exists: bool = True): + species_dict = {s.name: s for s in dbf.species} + tuple_const = tuple(tuple(species_dict.get(s.upper(), v.Species(s)) for s in xs) for xs in constituent_array) + query = Query() + search_query = (query.parameter_type == parameter_type) &\ + (query.phase_name == phase) & \ + (query.constituent_array == tuple_const) & \ + (query.diffusing_species == diffusing_species) & \ + (query.parameter_order == parameter_order) + param = dbf.search(search_query) + if len(param) == 0: + dbf.add_parameter(parameter_type, phase, constituent_array, + parameter_order, function, + diffusing_species=diffusing_species) + else: + # If parameter already exists, we can either add the function to the present paramter or overwrite it + if add_if_exists: + dbf._parameters.upsert({'parameter': param[0]['parameter'] + function}, search_query) + else: + dbf._parameters.upsert({'parameter': param[0]['parameter']}, search_query) + +def transform_activation_energy(Q: float) -> Basic: + '''Transform activation energy to A term in MQ=A+B*T''' + return -Q + +def transform_prefactor(D0: float) -> Basic: + '''Transforms diffusion prefactor to B term in MQ=A+B*T (note, this returns B, not B*T)''' + return v.R*np.log(D0) + +class SiteFractionGenerator(ABC): + ''' + Object to compute site fractions from conditions + ''' + @abstractmethod + def generate_site_fractions(self, phase: str, components: list[str], conditions : dict[v.StateVariable, float]) -> dict[v.Species, float]: + ''' + Generate site fractions from conditions + + Parameters + ---------- + phase: str + components: list[str] + conditions: dict[v.StateVariable, float] + + Returns + ------- + {v.SiteFraction: float} + ''' + raise NotImplementedError() + +class EquilibriumSiteFractionGenerator(SiteFractionGenerator): + ''' + Grabs site fraction values from local equilibrium calculations + + Parameters + ---------- + database: Database + ''' + def __init__(self, database : Database, override_conditions = {}): + if isinstance(database, str): + database = Database(database) + self.dbf = database + self.models = {} + self.phase_records = {} + + self._conditions_override = {v.N: 1, v.GE: 0} + for key, value in override_conditions: + self.set_override_condition(key, value) + + def set_override_condition(self, variable, value): + self._conditions_override[variable] = value + + def remove_override_condition(self, variable): + self._conditions_override.pop(variable) + + def _generate_comps_key(self, components): + comps = sorted(components) + return frozenset(comps), comps + + def _generate_phase_records(self, phase, components): + # Caches models, phase_records and constituents based off active components and phase + active_comps, comps = self._generate_comps_key(components) + if active_comps not in self.models: + self.models[active_comps] = {} + self.phase_records[active_comps] = {} + + if phase not in self.models[active_comps]: + self.models[active_comps][phase] = {phase: Model(self.dbf, comps, phase)} + self.phase_records[active_comps][phase] = PhaseRecordFactory(self.dbf, comps, {v.T, v.P, v.N, v.GE}, self.models[active_comps][phase]) + + return self.models[active_comps][phase], self.phase_records[active_comps][phase] + + def generate_site_fractions(self, phase: str, components: list[str], conditions : dict[v.StateVariable: float]) -> dict[v.Species: float]: + # Get phase records from active components + active_comps, comps = self._generate_comps_key(components) + models, prf = self._generate_phase_records(phase, components) + + # Override any conditions + for oc in self._conditions_override: + conditions[oc] = self._conditions_override[oc] + + # Compute local equilibrium (to avoid miscibility gaps) + # Store site fractions + # The first 4 items of CompositionSet.dof refers to v.GE, v.N, v.P and v.T + # The order of the site fractions in CompositionSet.dof should correspond to the order in the pycalphad model + results, comp_sets = local_equilibrium(self.dbf, comps, [phase], conditions, models, prf) + sfg = {c:val for c,val in zip(prf[phase].variables, comp_sets[0].dof[4:])} + return sfg + +class MobilityTemplate: + ''' + Creates a template of a mobility model for a single diffusing species + + Attributes + ---------- + dbf: Database + phase: str + sublattices: list[int] + constituents: list + diffusing_species: v.Species + num_params: int + Number of parameters added to the database + elements: list[str] + + Parameters + ---------- + phase: str + diffusing_species: str | v.Species + sublattices: list[int] + constituents: list[list[str]] + ''' + def __init__(self, phase: str, diffusing_species: Union[str, v.Species], sublattices: list[int], constituents: list, add_endmembers: bool = True): + self.dbf = Database() + self.phase = phase + self.sublattices = sublattices + self.constituents = constituents + self.diffusing_species = v.Species(diffusing_species) + self.num_params = 0 + self._model = None + + unique_species = list(set(itertools.chain(*constituents))) + for s in unique_species: + sp = v.Species(s) + self.dbf.species.add(sp) + self.dbf.elements.update(list(sp.constituents.keys())) + + # Add reference state, this is to be compatible for phase records, but values aren't + # necessary since we intend to add the parameters to the thermodynamic database in the end + for el in self.dbf.elements: + self.dbf.refstates[el] = {'phase': phase, 'mass': _molmass.get(el, 0.0), 'H298': 0, 'S298': 0} + + self.dbf.add_phase(phase, {}, sublattices) + self.dbf.add_phase_constituents(phase, constituents) + + if add_endmembers: + self.add_endmember_parameters() + + @property + def elements(self) -> list[str]: + return list(self.dbf.elements) + + def _create_constant(self) -> Basic: + ''' + Creates a constant parameter symbol as VV00XX + ''' + parameter_symbol = Symbol(_vname(self.num_params)) + self.num_params += 1 + return parameter_symbol + + def _create_T_term(self) -> Basic: + ''' + Creates a T dependent parameter symbol as VV00XX*T + ''' + parameter_symbol = Symbol(_vname(self.num_params))*v.T + self.num_params += 1 + return parameter_symbol + + def add_endmember_parameters(self): + ''' + Creates A+B*T terms for all endmembers of phase + ''' + for prod in itertools.product(*self.constituents): + constituent_array = [[species] for species in prod] + self.dbf.add_parameter('MQ', self.phase, constituent_array, + 0, self._create_constant() + self._create_T_term(), + diffusing_species=self.diffusing_species) + + # Not really needed since this function is called upon initialization, but to be safe since we modified the database here + self._model = None + + def add_term(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter: Union[callable, Basic], parameter_type: str = 'MQ'): + ''' + Adds a term to a parameter in the database + + If parameter already exists (same symbol, constituent_array and parameter order), then the parameter is + added on to the existing value rather than overwriting it + + Parameters + ---------- + constituent_array: list[list[str]] + param_order: int | list[int] + If list, will add parameters for all specified orders + parameter: callable | Any + If callable, should be a function that generates a parameter symbol + If not callable, should be compatible with a symengine expression + symbol: str (Optional) + Defaults to 'MQ' + Parameter symbol to add in database + By default, we always use 'MQ', but this adds the option to create the 'MF' terms + if they the prefactor and activation energies need to be separate terms (i.e. for + magnetic contributions which are yet unsupported) + ''' + if not isinstance(parameter_order, list): + parameter_order = [parameter_order] + + # If param_func is not callable, then convert to a self-generating function + if callable(parameter): + param_func = parameter + else: + param_func = lambda: parameter + + for p in parameter_order: + _upsert_parameters(self.dbf, parameter_type, self.phase, constituent_array, p, self.diffusing_species, param_func(), add_if_exists=True) + + # Since we updated the database, clear the mobility model if it was made at some point + self._model = None + + def add_prefactor(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter_type: str = 'MQ', parameter = None): + ''' + Adds a diffusion prefactor term (in form of VV00XX*T) + While the prefactor is defined as M0 in + M = M0/RT * exp(Q/RT), + the prefactor is treated as part of the exponential term as + M = 1/RT * exp((MQ+MF)/RT) where MQ+MF = A+B*T + Here, A refers to the activation energy and B refers to the prefactor + + Parameters + ---------- + constituent_array: list[list[str]] + param_order: int | list[int] + If list, then terms will be added to all specified orders + symbols: str (Optional) + Defaults to 'MQ' + parameter: float (Optional) + If not supplied (default), them a VV00XX*T term will be added + If supplied, this will assumed to be the prefactor and will be transformed into B*T term accordingly + ''' + if parameter is None: + parameter = self._create_T_term + else: + parameter = transform_prefactor(parameter)*v.T + self.add_term(constituent_array, parameter_order, parameter, parameter_type=parameter_type) + + def add_activation_energy(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter_type: str='MQ', parameter = None): + ''' + Adds a activation energy term (in form of VV00XX) + + Parameters + ---------- + constituent_array: list[list[str]] + param_order: int | list[int] + If list, then terms will be added to all specified orders + symbols: str (Optional) + Defaults to 'MQ' + parameter: float (Optional) + If not supplied (default), them a VV00XX term will be added + If supplied, this will assumed to be the activation energy and will be transformed into A term accordingly + ''' + if parameter is None: + parameter = self._create_constant + else: + parameter = transform_activation_energy(parameter) + self.add_term(constituent_array, parameter_order, parameter, parameter_type=parameter_type) + + def copy_parameter(self, constituent_array: list, new_constituent_array: list, parameter_order: int, parameter_type: str = 'MQ'): + ''' + Copies parameter function to new set of constituent array + This is for cases to avoid wildcard usage when a value might be constant across composition space + ''' + species_dict = {s.name: s for s in self.dbf.species} + tuple_const = tuple(tuple(species_dict.get(s.upper(), v.Species(s)) for s in xs) for xs in constituent_array) + query = Query() + search_query = (query.parameter_type == parameter_type) &\ + (query.phase_name == self.phase) & \ + (query.constituent_array == tuple_const) & \ + (query.diffusing_species == self.diffusing_species) & \ + (query.parameter_order == parameter_order) + param = self.dbf.search(search_query) + if len(param) > 0: + p = param[0] + self.dbf.add_parameter(p['parameter_type'], p['phase_name'], new_constituent_array, + p['parameter_order'], p['parameter'], + diffusing_species=p['diffusing_species']) + + @property + def parameters(self) -> list: + ''' + Returns all database parameters for mobility model + ''' + query = Query() + search_query = (query.phase_name == self.phase) & (query.diffusing_species == self.diffusing_species) + return self.dbf._parameters.search(search_query) + + @property + def model(self) -> MobilityModel: + ''' + Returns mobility model built from database parameters + ''' + if self._model is None: + self._model = MobilityModel(self.dbf, self.elements, self.phase) + return self._model + + # mobility_function, MQ, pre_factor and activation_energy are wrappers to + # retrieve the underlying functions in the MobilityModel directly + @property + def mobility_function(self) -> Basic: + ''' + Mobility function: M = 1/RT * exp(-(MQ+MF)/RT) + ''' + return getattr(self.model, f'MOB_{self.diffusing_species.name}') + + @property + def MQ(self) -> Basic: + ''' + Exp part of mobility function: MQ+MF + ''' + return getattr(self.model, f'MQ_{self.diffusing_species}') + + @property + def prefactor(self) -> Basic: + ''' + Natural log of pre-diffusion factor + This refers to all the T-dependent terms in MQ+MF + ''' + return getattr(self.model, f'lnM0_{self.diffusing_species.name}') + + @property + def activation_energy(self) -> Basic: + ''' + Activation energy of pre-diffusion factor + This refers to all the constant terms in MQ+MF + ''' + return getattr(self.model, f'MQa_{self.diffusing_species.name}') + + def get_derivatives(self, function: Basic) -> DerivativePair: + ''' + Creates derivative and corresponding variables for function (would be either lnM0 or Q) + ''' + # NOTE: this assumes that all free variables of interest are in VV00XX format + # If the user doesn't add custom parameters directly, then this assumption should hold + symbol_list = _get_variable_terms(function) + diffs, symbols = [], [] + for s in symbol_list: + diff = function.diff(s) + if diff != S.Zero: + diffs.append(diff) + symbols.append(s) + return DerivativePair(functions=diffs, symbols=symbols) + + def evaluate(self, function: Basic, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float]): + ''' + Evaluates model template along single variable + + Parameters + ---------- + template: MobilityTemplate + function: symengine.Basic + Function to evaluate + parameter_values: dict[Symbol, float] + Fitted parameters + Parameters in function that are not defined here will assume to be 0 + site_fraction_generator: SiteFractionGenerator + conditions: dict[v.StateVariable, float] + Conditions to evaluate function, 1 variable must be a list + + Returns + ------- + xs: values of evaluated dependent condition + ys: values of evaluated function + dependent_var: dependent condition + ''' + dependent_var = [key for key, val in conditions.items() if len(np.atleast_1d(val)) > 1] + if len(dependent_var) != 1: + raise ValueError(f"Number of free conditions must be 1, but is {len(dependent_var)}") + + dependent_vals = conditions[dependent_var[0]] + xs = np.linspace(dependent_vals[0], dependent_vals[1], int((dependent_vals[1] - dependent_vals[0])/dependent_vals[2])) + ys = np.zeros(len(xs)) + for i,x in enumerate(xs): + new_conds = {v.N: 1, v.P: 101325, v.GE: 0, v.T: 298.15} + new_conds.update({**conditions}) + new_conds[dependent_var[0]] = x + site_fractions = site_fraction_generator.generate_site_fractions(self.phase, self.elements, new_conds) + ys[i] = _eval_symengine_expr(function, {**site_fractions, **parameter_values, **new_conds}) + + return xs, ys, dependent_var[0] + + def add_to_database(self, dbf: Database, parameter_values: dict[Union[Symbol, str], float], add_if_exists=True): + ''' + Adds parameters to an existing database + + Parameters + ---------- + dbf: Database + database to add parameters to + parameter_values: dict[Symbol|str, float] + Values for each VV00XX parameter in the mobility model + Any parameter that isn't specified is assumed to be 0 and won't be added to database + ''' + last_var_index = find_last_variable(dbf) + parameter_values = {Symbol(key) if isinstance(key, str) else key: value for key,value in parameter_values.items()} + + symbol_replace_map = {param_name: _vname(i+last_var_index) for i, param_name in enumerate(parameter_values)} + unused_symbols = {s: 0 for s in (set(self.MQ.free_symbols) - set(symbol_replace_map.keys())) if str(s).startswith('VV')} + + for p in self.parameters: + new_func = p['parameter'].subs(unused_symbols) + new_func = new_func.xreplace(symbol_replace_map) + constituent_array = tuple(tuple(s.name for s in xs) for xs in p['constituent_array']) + _upsert_parameters(dbf, p['parameter_type'], p['phase_name'], constituent_array, + p['parameter_order'], p['diffusing_species'], new_func, add_if_exists=add_if_exists) + + for s in parameter_values: + dbf.symbols[symbol_replace_map[s]] = parameter_values[s] + +def _plot_model(template: MobilityTemplate, function: Basic, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float], ax=None, scale=1, transform = None, *args, **kwargs): + if ax is None: + fig, ax = plt.subplots() + + xs, ys, dep_var = template.evaluate(function, parameter_values, site_fraction_generator, conditions) + if transform is not None: + ys = transform(ys) + ax.plot(xs, scale*ys, *args, **kwargs) + ax.set_xlim([xs[0], xs[-1]]) + ax.set_xlabel(dep_var) + return ax + +def plot_prefactor(template: MobilityTemplate, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float], ax=None, scale=1, *args, **kwargs): + ''' + Plots mobility prefactor using input parameters + ''' + ax = _plot_model(template, template.prefactor, parameter_values, site_fraction_generator, conditions, transform=lambda x: np.exp(x), ax=ax, scale=scale, *args, **kwargs) + ax.set_ylabel(r'Diffusion Prefactor ($m^2/s$)') + ax.set_yscale('log') + return ax + +def plot_activation_energy(template: MobilityTemplate, parameter_values: dict[Symbol, float], site_fraction_generator: SiteFractionGenerator, conditions: dict[v.StateVariable, float], ax=None, scale=1, *args, **kwargs): + ''' + Plots mobility activation energy using input parameters + ''' + ax = _plot_model(template, template.activation_energy, parameter_values, site_fraction_generator, conditions, ax=ax, scale=scale, *args, **kwargs) + ax.set_ylabel('Activation Energy (J/mol)') + return ax \ No newline at end of file diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py index d218388..a317114 100644 --- a/kawin/mobility_fitting/utils.py +++ b/kawin/mobility_fitting/utils.py @@ -1,302 +1,10 @@ -import itertools -from collections import namedtuple -from typing import Union - from symengine import Symbol, Basic, S from tinydb import Query from pycalphad import Database, variables as v -from pycalphad.io.tdb import _molmass from espei.utils import database_symbols_to_fit -from kawin.thermo.Mobility import MobilityModel - -DerivativePair = namedtuple('DerivativePair', ['functions', 'symbols']) -DatasetPair = namedtuple('SystemPair', ['site_fractions', 'values']) -FittingResult = namedtuple('FittingResult', ['template', 'parameters', 'aicc']) - -def _upsert_parameters(dbf: Database, parameter_type: str, phase: str, constituent_array, parameter_order: int, diffusing_species: str, function: Basic): - species_dict = {s.name: s for s in dbf.species} - tuple_const = tuple(tuple(species_dict.get(s.upper(), v.Species(s)) for s in xs) for xs in constituent_array) - query = Query() - search_query = (query.parameter_type == parameter_type) &\ - (query.phase_name == phase) & \ - (query.constituent_array == tuple_const) & \ - (query.diffusing_species == diffusing_species) & \ - (query.parameter_order == parameter_order) - param = dbf.search(search_query) - if len(param) == 0: - dbf.add_parameter(parameter_type, phase, constituent_array, - parameter_order, function, - diffusing_species=diffusing_species) - else: - dbf._parameters.upsert({'parameter': param[0]['parameter'] + function}, search_query) - -class MobilityTemplate: - ''' - Creates a template of a mobility model for a single diffusing species - - Attributes - ---------- - dbf: Database - phase: str - sublattices: list[int] - constituents: list - diffusing_species: v.Species - num_params: int - Number of parameters added to the database - elements: list[str] - - Parameters - ---------- - phase: str - diffusing_species: str | v.Species - sublattices: list[int] - constituents: list[list[str]] - ''' - def __init__(self, phase: str, diffusing_species: Union[str, v.Species], sublattices: list[int], constituents: list, add_endmembers: bool = True): - self.dbf = Database() - self.phase = phase - self.sublattices = sublattices - self.constituents = constituents - self.diffusing_species = v.Species(diffusing_species) - self.num_params = 0 - self._model = None - - unique_species = list(set(itertools.chain(*constituents))) - for s in unique_species: - sp = v.Species(s) - self.dbf.species.add(sp) - self.dbf.elements.update(list(sp.constituents.keys())) - - # Add reference state, this is to be compatible for phase records, but values aren't - # necessary since we intend to add the parameters to the thermodynamic database in the end - for el in self.dbf.elements: - self.dbf.refstates[el] = {'phase': phase, 'mass': _molmass.get(el, 0.0), 'H298': 0, 'S298': 0} - - self.dbf.add_phase(phase, {}, sublattices) - self.dbf.add_phase_constituents(phase, constituents) - - if add_endmembers: - self.add_endmember_parameters() - - @property - def elements(self) -> list[str]: - return list(self.dbf.elements) - - def _create_constant(self) -> Basic: - ''' - Creates a constant parameter symbol as VV00XX - ''' - parameter_symbol = Symbol(_vname(self.num_params)) - self.num_params += 1 - return parameter_symbol - - def _create_T_term(self) -> Basic: - ''' - Creates a T dependent parameter symbol as VV00XX*T - ''' - parameter_symbol = Symbol(_vname(self.num_params))*v.T - self.num_params += 1 - return parameter_symbol - - def add_endmember_parameters(self): - ''' - Creates A+B*T terms for all endmembers of phase - ''' - for prod in itertools.product(*self.constituents): - constituent_array = [[species] for species in prod] - self.dbf.add_parameter('MQ', self.phase, constituent_array, - 0, self._create_constant() + self._create_T_term(), - diffusing_species=self.diffusing_species) - - # Not really needed since this function is called upon initialization, but to be safe since we modified the database here - self._model = None - - def add_term(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter: Union[callable, Basic], parameter_type: str = 'MQ'): - ''' - Adds a term to a parameter in the database - - If parameter already exists (same symbol, constituent_array and parameter order), then the parameter is - added on to the existing value rather than overwriting it - - Parameters - ---------- - constituent_array: list[list[str]] - param_order: int | list[int] - If list, will add parameters for all specified orders - parameter: callable | Any - If callable, should be a function that generates a parameter symbol - If not callable, should be compatible with a symengine expression - symbol: str (Optional) - Defaults to 'MQ' - Parameter symbol to add in database - By default, we always use 'MQ', but this adds the option to create the 'MF' terms - if they the prefactor and activation energies need to be separate terms (i.e. for - magnetic contributions which are yet unsupported) - ''' - if not isinstance(parameter_order, list): - parameter_order = [parameter_order] - - # If param_func is not callable, then convert to a self-generating function - if callable(parameter): - param_func = parameter - else: - param_func = lambda: parameter - - for p in parameter_order: - _upsert_parameters(self.dbf, parameter_type, self.phase, constituent_array, p, self.diffusing_species, param_func()) - - # Since we updated the database, clear the mobility model if it was made at some point - self._model = None - - def add_prefactor(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter_type: str = 'MQ'): - ''' - Adds a diffusion prefactor term (in form of VV00XX*T) - While the prefactor is defined as M0 in - M = M0/RT * exp(Q/RT), - the prefactor is treated as part of the exponential term as - M = 1/RT * exp((MQ+MF)/RT) where MQ+MF = A+B*T - Here, A refers to the activation energy and B refers to the prefactor - - Parameters - ---------- - constituent_array: list[list[str]] - param_order: int | list[int] - If list, then terms will be added to all specified orders - symbols: str (Optional) - Defaults to 'MQ' - ''' - self.add_term(constituent_array, parameter_order, self._create_T_term, parameter_type=parameter_type) - - def add_activation_energy(self, constituent_array: list, parameter_order: Union[int, list[int]], parameter_type: str='MQ'): - ''' - Adds a activation energy term (in form of VV00XX) - - Parameters - ---------- - constituent_array: list[list[str]] - param_order: int | list[int] - If list, then terms will be added to all specified orders - symbols: str (Optional) - Defaults to 'MQ' - ''' - self.add_term(constituent_array, parameter_order, self._create_constant, parameter_type=parameter_type) - - def copy_parameter(self, constituent_array: list, new_constituent_array: list, parameter_order: int, parameter_type: str = 'MQ'): - ''' - Copies parameter function to new set of constituent array - This is for cases to avoid wildcard usage when a value might be constant across composition space - ''' - species_dict = {s.name: s for s in self.dbf.species} - tuple_const = tuple(tuple(species_dict.get(s.upper(), v.Species(s)) for s in xs) for xs in constituent_array) - query = Query() - search_query = (query.parameter_type == parameter_type) &\ - (query.phase_name == self.phase) & \ - (query.constituent_array == tuple_const) & \ - (query.diffusing_species == self.diffusing_species) & \ - (query.parameter_order == parameter_order) - param = self.dbf.search(search_query) - if len(param) > 0: - p = param[0] - self.dbf.add_parameter(p['parameter_type'], p['phase_name'], new_constituent_array, - p['parameter_order'], p['parameter'], - diffusing_species=p['diffusing_species']) - - @property - def parameters(self) -> list: - ''' - Returns all database parameters for mobility model - ''' - query = Query() - search_query = (query.phase_name == self.phase) & (query.diffusing_species == self.diffusing_species) - return self.dbf._parameters.search(search_query) - - @property - def model(self) -> MobilityModel: - ''' - Returns mobility model built from database parameters - ''' - if self._model is None: - self._model = MobilityModel(self.dbf, self.elements, self.phase) - return self._model - - # mobility_function, MQ, pre_factor and activation_energy are wrappers to - # retrieve the underlying functions in the MobilityModel directly - @property - def mobility_function(self) -> Basic: - ''' - Mobility function: M = 1/RT * exp(-(MQ+MF)/RT) - ''' - return getattr(self.model, f'MOB_{self.diffusing_species.name}') - - @property - def MQ(self) -> Basic: - ''' - Exp part of mobility function: MQ+MF - ''' - return getattr(self.model, f'MQ_{self.diffusing_species}') - - @property - def prefactor(self) -> Basic: - ''' - Natural log of pre-diffusion factor - This refers to all the T-dependent terms in MQ+MF - ''' - return getattr(self.model, f'lnM0_{self.diffusing_species.name}') - - @property - def activation_energy(self) -> Basic: - ''' - Activation energy of pre-diffusion factor - This refers to all the constant terms in MQ+MF - ''' - return getattr(self.model, f'MQa_{self.diffusing_species.name}') - - def get_derivatives(self, function: Basic) -> DerivativePair: - ''' - Creates derivative and corresponding variables for function (would be either lnM0 or Q) - ''' - # NOTE: this assumes that all free variables of interest are in VV00XX format - # If the user doesn't add custom parameters directly, then this assumption should hold - symbol_list = _get_variable_terms(function) - diffs, symbols = [], [] - for s in symbol_list: - diff = function.diff(s) - if diff != S.Zero: - diffs.append(diff) - symbols.append(s) - return DerivativePair(functions=diffs, symbols=symbols) - - def add_to_database(self, dbf: Database, parameter_values: dict[Union[Symbol, str], float]): - ''' - Adds parameters to an existing database - - Parameters - ---------- - dbf: Database - database to add parameters to - parameter_values: dict[Symbol|str, float] - Values for each VV00XX parameter in the mobility model - Any parameter that isn't specified is assumed to be 0 and won't be added to database - ''' - last_var_index = find_last_variable(dbf) - parameter_values = {Symbol(key) if isinstance(key, str) else key: value for key,value in parameter_values.items()} - - symbol_replace_map = {param_name: _vname(i+last_var_index) for i, param_name in enumerate(parameter_values)} - unused_symbols = {s: 0 for s in (set(self.MQ.free_symbols) - set(symbol_replace_map.keys())) if str(s).startswith('VV')} - - for p in self.parameters: - new_func = p['parameter'].subs(unused_symbols) - new_func = new_func.xreplace(symbol_replace_map) - constituent_array = tuple(tuple(s.name for s in xs) for xs in p['constituent_array']) - _upsert_parameters(dbf, p['parameter_type'], p['phase_name'], constituent_array, - p['parameter_order'], p['diffusing_species'], new_func) - - for s in parameter_values: - dbf.symbols[symbol_replace_map[s]] = parameter_values[s] - -def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, includeSub = False): +def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, includeSubsystems = False): ''' Given the database, grab all symbols that pertain only to the given elements and phases @@ -321,7 +29,7 @@ def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, in Default = None Symbols will be taken from parameters attributed to the phases If None, all phases will be considered - includeSub : bool (optional) + includeSubsystems : bool (optional) Default = False If True, then symbols will also be taken from parameters where constituents is a subset of elements ''' @@ -340,7 +48,7 @@ def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, in # 1. parameterSpecies is a subset of elSet # 2. freeSub is False and length of parameter species (excluding VA) is equal to number of elements pIsSubset = len((parameterSpecies-set(['VA','*'])) - elSet) == 0 - shouldBeFree = includeSub or len(parameterSpecies - set(['VA', '*'])) == numElements + shouldBeFree = includeSubsystems or len(parameterSpecies - set(['VA', '*'])) == numElements isDiffusingSpecies = p['diffusing_species'].name == diffusingSpecies if pIsSubset and shouldBeFree and isDiffusingSpecies: usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) diff --git a/kawin/precipitation/KWNBase.py b/kawin/precipitation/KWNBase.py index c5a3547..cff6187 100644 --- a/kawin/precipitation/KWNBase.py +++ b/kawin/precipitation/KWNBase.py @@ -137,6 +137,7 @@ def fromDict(self, data): ''' Converts dictionary of data to precipitation data ''' + self.setup() self.pData.fromDict(data) def _appendArrays(self, newVals): From 2724783404a54f61996386e3058fb446db14c8d0 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Fri, 21 Feb 2025 16:55:28 -0800 Subject: [PATCH 14/53] add Cu-Ni mobility assessment example and mobility generation to use espei.paramselect.generate_parameters instead of going through espei script --- .../01_parameter_generation.ipynb | 414 +++++++++++++++ .../02_mcmc_optimization.ipynb | 478 ++++++++++++++++++ examples/mobility_fitting/databases/CuNi.tdb | 67 +++ .../databases/CuNi_manual_fit.tdb | 76 +++ .../mobility_fitting/databases/CuNi_mcmc.tdb | 91 ++++ .../databases/CuNi_mob_gen.tdb | 93 ++++ .../equilibrium/Dnkj_1273_Heumann1972.json | 58 +++ .../equilibrium/Dnkj_1273_Iijima1982.json | 74 +++ .../Cu_tracer/DCu_Cu_Ghosh2001_D0.json | 17 + .../Cu_tracer/DCu_Cu_Ghosh2001_Q.json | 17 + .../Cu_tracer/DCu_Ni_Anand1965_D0.json | 17 + .../Cu_tracer/DCu_Ni_Anand1965_Q.json | 17 + .../Cu_tracer/DCu_mix_Anusavice1972_D0.json | 29 ++ .../Cu_tracer/DCu_mix_Anusavice1972_Q.json | 29 ++ .../Cu_tracer/DCu_mix_Monma1964_D0.json | 29 ++ .../Cu_tracer/DCu_mix_Monma1964_Q.json | 29 ++ .../Ni_tracer/DNi_Cu_Anusavice1972_D0.json | 17 + .../Ni_tracer/DNi_Cu_Anusavice1972_Q.json | 17 + .../Ni_tracer/DNi_Ni_Bakker1968_D0.json | 17 + .../Ni_tracer/DNi_Ni_Bakker1968_Q.json | 17 + .../Ni_tracer/DNi_mix_Anusavice1972_D0.json | 29 ++ .../Ni_tracer/DNi_mix_Anusavice1972_Q.json | 29 ++ .../Ni_tracer/DNi_mix_Monma1964_D0.json | 29 ++ .../Ni_tracer/DNi_mix_Monma1964_Q.json | 29 ++ examples/mobility_fitting/phase_models.json | 13 + kawin/diffusion/Diffusion.py | 24 +- kawin/diffusion/Plot.py | 28 +- kawin/mobility_fitting/__init__.py | 2 +- .../equilibrium_mobility_error.py | 4 +- .../non_equilibrium_mobility_error.py | 2 - kawin/mobility_fitting/generate.py | 53 +- kawin/mobility_fitting/manual_fitting.py | 4 +- 32 files changed, 1806 insertions(+), 43 deletions(-) create mode 100644 examples/mobility_fitting/01_parameter_generation.ipynb create mode 100644 examples/mobility_fitting/02_mcmc_optimization.ipynb create mode 100644 examples/mobility_fitting/databases/CuNi.tdb create mode 100644 examples/mobility_fitting/databases/CuNi_manual_fit.tdb create mode 100644 examples/mobility_fitting/databases/CuNi_mcmc.tdb create mode 100644 examples/mobility_fitting/databases/CuNi_mob_gen.tdb create mode 100644 examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Heumann1972.json create mode 100644 examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Iijima1982.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_Q.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_Q.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_Q.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_Q.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_Q.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_Q.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_Q.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_D0.json create mode 100644 examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_Q.json create mode 100644 examples/mobility_fitting/phase_models.json diff --git a/examples/mobility_fitting/01_parameter_generation.ipynb b/examples/mobility_fitting/01_parameter_generation.ipynb new file mode 100644 index 0000000..48c21b6 --- /dev/null +++ b/examples/mobility_fitting/01_parameter_generation.ipynb @@ -0,0 +1,414 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mobility Fitting Module\n", + "\n", + "Kawin supplies some utilities to aid in mobility model generation and optimization. The module includes:\n", + "- Compatibility with Espei parameter generation\n", + "- Manual least squares fitting (intended for situations when mobility data does not exists at the endmembers of a phase)\n", + "- Liquid mobility\n", + "- Compatibility with Espei parameter optimization\n", + "\n", + "This example will go through the following steps to generate and optimize mobility for the Cu-Ni system. This first example goes over parameter generation.\n", + "\n", + "First we need a thermodynamic database. This one is taken from S. Mey, Calphad 16:3 (1992) 255." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from pycalphad import Database, variables as v\n", + "from pycalphad.mapping import BinaryStrategy, plot_binary\n", + "\n", + "dbf = Database('databases/CuNi.tdb')\n", + "comps = ['CU', 'NI', 'VA']\n", + "phases = ['FCC_A1', 'LIQUID']\n", + "conds = {v.T: (1200, 1800, 20), v.P: 101325, v.X('NI'): (0, 1, 0.01)}\n", + "\n", + "strategy = BinaryStrategy(dbf, comps, phases, conds)\n", + "strategy.initialize()\n", + "strategy.do_map()\n", + "\n", + "plot_binary(strategy)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Espei parameter generation\n", + "\n", + "Since we have mobility data for all endmembers of the FCC_A1 phase, we can use Espei to build the models.\n", + "\n", + "The FCC_A1 phase is modeled as $(Cu, Ni)_1 (Va)_1$, so for endmembers, we want the following:\n", + "- Cu diffusion in $(Cu)_1 (Va)_1$\n", + "- Cu diffusion in $(Ni)_1 (Va)_1$\n", + "- Ni diffusion in $(Cu)_1 (Va)_1$\n", + "- Ni diffusion in $(Ni)_1 (Va)_1$\n", + "\n", + "In Espei, parameter generation using custom models can be done by supplying a corresponding fitting description. To have mobility models for each component, we require a fitting description and fitting steps for each component, which is created in the `generate_mobility` funtion." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from kawin.mobility_fitting import generate_mobility\n", + "\n", + "# Increase aicc penalty to limit number of parameters on Ni mobility\n", + "aicc = {\n", + " 'FCC_A1': {\n", + " 'TRACER_Q_NI': 2,\n", + " 'TRACER_D0_NI': 2\n", + " }\n", + "}\n", + "dbf = generate_mobility('phase_models.json', 'datasets', aicc_penalty_factor=aicc, dbf=dbf)\n", + "dbf.to_file('databases/CuNi_mob_gen.tdb', if_exists='overwrite')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have a generated mobility models for the FCC_A1 phase, let's plot the model in comparison with the experimental data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import itertools\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from kawin.thermo import GeneralThermodynamics\n", + "from kawin.mobility_fitting.manual_fitting import grab_tracer_datasets\n", + "from kawin.thermo.Mobility import activation_energy_from_composition_set_phase_record, prefactor_from_composition_set_phase_record\n", + "\n", + "# Helper function to plot Q or D0 for a given species\n", + "def plot_datasets(ax, output, diffusing_species, scale=1):\n", + " symbols = ['o', 'v', 'x', 's', '+', '1', 'd', '_', '^', '<']\n", + " symbol_cycle = itertools.cycle(symbols)\n", + "\n", + " datasets = grab_tracer_datasets('datasets', output, 'FCC_A1', ['CU', 'NI', 'VA'], diffusing_species)\n", + " for d in datasets:\n", + " sub_config = d['solver']['sublattice_configurations']\n", + " sub_occ = d['solver']['sublattice_occupancies']\n", + " x_ni = []\n", + " for sc, so in zip(sub_config, sub_occ):\n", + " if isinstance(sc[0], str):\n", + " if sc[0] == 'CU':\n", + " x_ni.append(1-so[0])\n", + " elif sc[0] == 'NI':\n", + " x_ni.append(so[0])\n", + " else:\n", + " x_ni.append(so[0][sc[0].index('NI')])\n", + " values = np.array(d['values']).flatten()\n", + " ref = d['reference']\n", + " ax.scatter(x_ni, scale*values, label=ref, marker=next(symbol_cycle), color='k')\n", + "\n", + "components = ['CU', 'NI']\n", + "phase = 'FCC_A1'\n", + "therm = GeneralThermodynamics(dbf, components+['VA'], [phase])\n", + "\n", + "# Compute activation energy and pre-factor for Nb and Ti\n", + "N = 50\n", + "xs = np.linspace(1e-3, 1-1e-3, N)\n", + "T = 1273\n", + "lnd0s = np.zeros((N, 2))\n", + "qs = np.zeros((N, 2))\n", + "for i, x in enumerate(xs):\n", + " results, comp_sets = therm.getLocalEq(x, T, precPhase=[phase])\n", + " qs[i] = activation_energy_from_composition_set_phase_record(comp_sets[0], therm.mob_phase_records, phase, components)\n", + " lnd0s[i] = prefactor_from_composition_set_phase_record(comp_sets[0], therm.mob_phase_records, phase, components)\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(8, 8))\n", + "\n", + "# Plot D0 for Cu mobility\n", + "axes[0,0].plot(xs, 1e4*np.exp(lnd0s[:,0]))\n", + "plot_datasets(axes[0,0], 'D0', 'CU', scale=1e4)\n", + "axes[0,0].set_yscale('log')\n", + "axes[0,0].set_ylabel('$D^0_{Cu}$ ($cm^2/s$)')\n", + "\n", + "# Plot Q for Cu mobility\n", + "axes[0,1].plot(xs, 1e-3*qs[:,0])\n", + "plot_datasets(axes[0,1], 'Q', 'CU', scale=1e-3)\n", + "axes[0,1].set_ylabel('$Q_{Cu}$ (kJ/mol)')\n", + "\n", + "# Plot D0 for Ni mobility\n", + "axes[1,0].plot(xs, 1e4*np.exp(lnd0s[:,1]))\n", + "plot_datasets(axes[1,0], 'D0', 'NI', scale=1e4)\n", + "axes[1,0].set_yscale('log')\n", + "axes[1,0].set_ylabel('$D^0_{Ni}$ ($cm^2/s$)')\n", + "\n", + "# Plot Q for Ni mobility\n", + "axes[1,1].plot(xs, 1e-3*qs[:,1])\n", + "plot_datasets(axes[1,1], 'Q', 'NI', scale=1e-3)\n", + "axes[1,1].set_ylabel('$Q_{Ni}$ (kJ/mol)')\n", + "\n", + "for ax in axes.reshape(-1):\n", + " ax.set_xlim([0,1])\n", + " ax.set_xlabel('X(Ni)')\n", + " ax.legend()\n", + "\n", + "fig.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Liquid mobility\n", + "\n", + "Since we don't have any mobility data for the liquid phase, we can estimate them using some available models in the literature. To models are available in kawin:\n", + "\n", + "Y. Liu et al, \"A predictive equation for solute diffusivity in liquid metals\" Scripta Materialia 55 (2006), 367. doi:10.1016/j.scriptamat.2006.04.019\n", + "- $ Q = 0.17 R T_m (16+K_0) $ $ J/mol $\n", + "- $ K_0 $ is an integer corresponding to solid phase at melting (BCC = 1, HCP = 2, FCC = 3)\n", + "- For self-diffusion: $ D^0_{BB} = (8.95 - 0.0734*A) * 10^{-8} $ $ m^2/s $ where $A$ is atomic number\n", + "- For solute-diffusion: $ D^0_{AB} = \\frac{r_B}{r_A} D^0_{BB} $ where $r$ is atomic radius\n", + "- $ D_AB = D^0_{AB} exp \\left( \\frac{Q}{R T} \\right) $\n", + "\n", + "X. Su et al, \"A new equation for temperature dependent solute impurity diffusivity in liquid metals\" Journal of Phase Equilibria and Diffusion 31 (2010) 333. doi:10.1007/s11669-010-9726-4\n", + "- Sutherland-Einstein equation: $ D = \\frac{k T}{4 \\pi \\mu r} $\n", + "- $ \\mu_B = \\frac{C_1 M_B^{1/2} T^{1/2}}{V_B^{2/3}} exp \\left(\\frac{C_2 T_{M,B}}{T} \\right) $ \n", + " - $ C_1 = 1.8*10^{-8} $ and $ C_2 = 2.34 $\n", + "- Radius in liquid: $ r_A = R_0 \\left( \\frac{M_A}{\\rho_A} \\right)^{1/3} \\left(1 - 0.122 \\left( \\frac{T}{T_M} \\right)^{1/2} \\right) $\n", + " - $ R_0 = 0.644*10^{-10} $\n", + "- $ D_{AB} = \\frac{k T}{4 \\pi \\mu_B r_A} $\n", + "\n", + "Both models predict mobility to be within an order of magnitude, so here, we'll add the Liu model to the database due it its simplicity" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Liquid mobility CU: (-46404.09216 - 137.295100407725*T)*LIQUID0NI + (-36468.03076 - 137.186121545147*T)*LIQUID0CU\n", + "Liquid mobility NI: (-46404.09216 - 137.097138674486*T)*LIQUID0NI + (-36468.03076 - 136.988159811907*T)*LIQUID0CU\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from pycalphad import Database, variables as v\n", + "from kawin.mobility_fitting import generate_liquid_mobility_liu, LiuSpecies\n", + "from kawin.mobility_fitting import generate_liquid_mobility_su, SuSpecies\n", + "from kawin.mobility_fitting import EquilibriumSiteFractionGenerator\n", + "\n", + "# Create mobility parameters using the Liu and Su model\n", + "liu_species = [\n", + " LiuSpecies('CU', diameter=2.55, atomic_number=29, Tm=1358, melting_phase='FCC_A1'),\n", + " LiuSpecies('NI', diameter=2.49, atomic_number=28, Tm=1728, melting_phase='FCC_A1'),\n", + " ]\n", + "liu_templates = generate_liquid_mobility_liu(dbf, liu_species, add_to_database=False)\n", + "\n", + "su_species = [\n", + " SuSpecies('CU', atomic_mass=63.55, density=8.96, Tm=1358),\n", + " SuSpecies('NI', atomic_mass=58.69, density=8.90, Tm=1728),\n", + "]\n", + "su_templates = generate_liquid_mobility_su(dbf, su_species, add_to_database=False)\n", + "\n", + "# Add liquid mobility from the liu model to database and save database\n", + "for s, template in liu_templates.items():\n", + " print(f'Liquid mobility {s}: {template.MQ}')\n", + " template.add_to_database(dbf, {}, add_if_exists=False)\n", + "dbf.to_file('databases/CuNi_mob_gen.tdb', if_exists='overwrite')\n", + "\n", + "fig, ax = plt.subplots()\n", + "colors = {'CU': 'C0', 'NI': 'C1'}\n", + "conds = {v.T: 2000, v.P: 101325, v.X('NI'): (1e-3, 1-1e-3, 0.01)}\n", + "eqgen = EquilibriumSiteFractionGenerator(dbf)\n", + "\n", + "# Plot mobility from Liu and Su model\n", + "for s, template in liu_templates.items():\n", + " x, y, var = template.evaluate(template.mobility_function, {}, eqgen, conds)\n", + " ax.plot(x, 1000*y, color=colors[s], linestyle='-', label=f'Liu {s}')\n", + "\n", + "for s, template in su_templates.items():\n", + " x, y, var = template.evaluate(template.mobility_function, {}, eqgen, conds)\n", + " ax.plot(x, 1000*y, color=colors[s], linestyle='--', label=f'Su {s}')\n", + " \n", + "ax.set_ylabel(r'Mobility ($cm^2/s$)')\n", + "ax.set_xlim([0, 1])\n", + "ax.set_xlabel('X(Ni)')\n", + "ax.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Manual fitting\n", + "\n", + "For cases where we don't have diffusion data for all endmembers, we can use the manual fitting module. An example of this would be fitting intermetallics or carbides, where the endmembers may not be thermodynamically stable, and diffusion data cannot be obtained.\n", + "\n", + "The following will show how to manually fit the Cu mobility in the FCC_A1 phase. You may notice that the selected model is different that the one that Espei chooses. This is because in Espei, the endmembers are fitted first, followed by mixing parameters. In the manual fitting module, both the endmembers and mixing parameters are fit in a single step, so the endmember parameters are not fit strictly to just the endmember data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from kawin.mobility_fitting import MobilityTemplate, plot_prefactor, plot_activation_energy\n", + "from kawin.mobility_fitting.manual_fitting import grab_tracer_datasets, fit_prefactor, fit_activation_energy, select_best_model\n", + "from kawin.mobility_fitting import EquilibriumSiteFractionGenerator\n", + "\n", + "dbf = Database('databases/CuNi.tdb')\n", + "eqgen = EquilibriumSiteFractionGenerator(dbf)\n", + "\n", + "phase = 'FCC_A1'\n", + "sublattice_model = [1, 1]\n", + "constituents = [['CU', 'NI'], ['VA']]\n", + "diffusing_species = 'CU'\n", + "\n", + "# Create mobility templates. We'll do three options here: \n", + "# a) no mixing term, b) 1st order mixing, c) 1st and 2nd order mixing\n", + "t0 = MobilityTemplate(phase, diffusing_species, sublattice_model, constituents)\n", + "\n", + "t1 = MobilityTemplate(phase, diffusing_species, sublattice_model, constituents)\n", + "t1.add_activation_energy([['CU', 'NI'], ['VA']], 0)\n", + "t1.add_prefactor([['CU', 'NI'], ['VA']], 0)\n", + "\n", + "t2 = MobilityTemplate(phase, diffusing_species, sublattice_model, constituents)\n", + "t2.add_activation_energy([['CU', 'NI'], ['VA']], [0, 1])\n", + "t2.add_prefactor([['CU', 'NI'], ['VA']], [0, 1])\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n", + "conds = {v.T: 1673, v.P: 101325, v.X('NI'): (0, 1, 0.01)}\n", + "\n", + "# Fit prefactor parameters to data\n", + "# Here, we use a AICC penalty factor of 0.5 (p=0.5 in select_best_model) to favor a higher order model\n", + "d_data = grab_tracer_datasets('datasets', 'D0', phase, ['CU', 'NI', 'VA'], diffusing_species)\n", + "d_model, d_results = select_best_model(d_data, [t0, t1, t2], fit_prefactor, eqgen, p=0.5, return_all_models = True)\n", + "for i, res in enumerate(d_results):\n", + " plot_prefactor(res.template, res.parameters, eqgen, conditions=conds, ax=ax[0], scale=1e4, label=f'Model {i}: AICC = {res.aicc:.3f}')\n", + "plot_datasets(ax[0], 'D0', diffusing_species, scale=1e4)\n", + "ax[0].set_ylabel('$D^0_{Cu}$ ($cm^2/s$)')\n", + "ax[0].set_yscale('log')\n", + "ax[0].legend()\n", + "\n", + "# Fit activation energy parameters to data\n", + "q_data = grab_tracer_datasets('datasets', 'Q', phase, ['CU', 'NI', 'VA'], diffusing_species)\n", + "q_model, q_results = select_best_model(q_data, [t0, t1, t2], fit_activation_energy, eqgen, return_all_models = True)\n", + "for i, res in enumerate(q_results):\n", + " plot_activation_energy(res.template, res.parameters, eqgen, conditions=conds, ax=ax[1], scale=1e-3, label=f'Model {i}: AICC = {res.aicc:.3f}')\n", + "plot_datasets(ax[1], 'Q', diffusing_species, scale=1e-3)\n", + "ax[1].set_ylabel('$Q_{Cu}$ (kJ/mol)')\n", + "ax[1].legend()\n", + "\n", + "# Add pre-factor and activation energy parameter to database and save\n", + "d_model.template.add_to_database(dbf, d_model.parameters)\n", + "q_model.template.add_to_database(dbf, q_model.parameters)\n", + "dbf.to_file('databases/CuNi_manual_fit.tdb', if_exists='overwrite')\n", + "\n", + "fig.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References for dataset\n", + "\n", + "1. G. Ghosh, Acta Mater. 49 (2001) 2609.\n", + "2. M.S. Anand, S.P. Murarka, R.P. Agarwala, J. Appl. Phys. 36 (1965) 3860.\n", + "3. H. Bakker, Phys. Stat. Sol. 28 (1958) 569.\n", + "4. K.J. Anusavice, J.J. Pinajian, K. Oikawa, R.T. DeHoff, Trans. Metal. Soc. AIME 242 (1968) 2027.\n", + "5. K. Monma, H. Suto, H. Oikawa, J. Japan Inst. Met. 28 (1964) 192.\n", + "6. V.T. Heumann, K.J. Grundhoff, Z. Metallk. 63 (1972) 173.\n", + "7. Y. Iijima, K. Hirano, M. Kikuchi, Trans. Japan Inst. Met. 23 (1982) 19." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "calphad_312", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/mobility_fitting/02_mcmc_optimization.ipynb b/examples/mobility_fitting/02_mcmc_optimization.ipynb new file mode 100644 index 0000000..d0f2052 --- /dev/null +++ b/examples/mobility_fitting/02_mcmc_optimization.ipynb @@ -0,0 +1,478 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MCMC optimization\n", + "\n", + "This example will optimize the generated mobility models we created in 01_parameter_generation\n", + "\n", + "During parameter generation, we only fitted models against tracer diffusivity data since no thermodynamic information is necessary to compute these terms. However, these types of data does not account for chemical potential gradients. Diffusion data computed from a diffusion coupled (interdiffusivity) considered chemical potential gradients and must be assessed against. We can do that through MCMC optimization using Espei" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from espei.espei_script import run_espei\n", + "\n", + "from kawin.mobility_fitting.utils import get_used_database_symbols\n", + "\n", + "# register mobility error functions to espei\n", + "from kawin.mobility_fitting.error_functions import equilibrium_mobility_error, non_equilibrium_mobility_error\n", + "\n", + "dbf_input = 'databases/CuNi_mob_gen.tdb'\n", + "dbf_output = 'databases/CuNi_mcmc.tdb'\n", + "\n", + "cu_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'CU', 'FCC_A1', includeSubsystems=True)\n", + "ni_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'NI', 'FCC_A1', includeSubsystems=True)\n", + "params = sorted(cu_params + ni_params)\n", + "\n", + "input_settings = {\n", + " 'system': {\n", + " 'phase_models': 'phase_models.json', \n", + " 'datasets': 'datasets'\n", + " },\n", + " 'mcmc': {\n", + " 'iterations': 1000,\n", + " 'scheduler': 'dask',\n", + " 'chains_per_parameter': 8,\n", + " 'cores': 8,\n", + " 'input_db': dbf_input,\n", + " 'symbols': params,\n", + " 'save_interval': 100,\n", + " },\n", + " 'output': {\n", + " 'output_db': dbf_output,\n", + " 'tracefile': 'output/CuNi_trace.npy',\n", + " 'probfile': 'output/CuNi_prob.npy',\n", + " 'verbosity': 1\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "run_espei(input_settings)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll plot the probability to check if the MCMC converged, which appears to occur after around 400 iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "trace = np.load('output/CuNi_prob.npy')\n", + "ax.plot(trace.T)\n", + "ax.set_xlabel('Iterations')\n", + "ax.set_xlim([0, 1000])\n", + "ax.set_ylabel('lnprob')\n", + "ax.set_ylim([-450, -350])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing generated models to interdiffusivity\n", + "\n", + "Before we optimize the model, let's check how well the initial mobility models compare against the interdiffusivity data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from tinydb import where\n", + "\n", + "from espei.datasets import load_datasets, recursive_glob\n", + "\n", + "from kawin.thermo import GeneralThermodynamics\n", + "\n", + "# Helper function to plot interdiffusivity\n", + "def plot_interdiffusivity_datasets(ax, components, reference, scale=1, *args, **kwargs):\n", + " datasets = load_datasets(sorted(recursive_glob('datasets', '*.json')))\n", + " query = (\n", + " (where('components').test(lambda x: set(x).issubset(components + ['VA']))) & \n", + " (where('output').test(lambda x: x == 'INTER_DIFF')) &\n", + " (where('reference').test(lambda x: x == reference))\n", + " )\n", + " data = datasets.search(query)\n", + "\n", + " for d in data:\n", + " x_cu = np.array(d['conditions']['X_CU'])\n", + " T = d['conditions']['T']\n", + " values = np.array(d['values']).flatten()\n", + " ref = d['reference']\n", + " \n", + " # Plot Ni composition\n", + " x_ni = 1-x_cu\n", + " ax.scatter(x_ni, scale*np.array(values), label=f'{ref} ({int(T)}K)', *args, **kwargs)\n", + "\n", + "components = ['CU', 'NI']\n", + "phase = 'FCC_A1'\n", + "\n", + "T = 1273\n", + "x = np.linspace(1e-3, 1-1e-3, 100)\n", + "therm_gen = GeneralThermodynamics('databases/CuNi_mob_gen.tdb', components, [phase])\n", + "therm_mcmc = GeneralThermodynamics('databases/CuNi_mcmc.tdb', components, [phase])\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "ax.plot(x, therm_gen.getInterdiffusivity(x, T)*1e4, label='Generated', zorder=0)\n", + "ax.plot(x, therm_mcmc.getInterdiffusivity(x, T)*1e4, label='MCMC', zorder=0)\n", + "plot_interdiffusivity_datasets(ax, components, 'Heumann1972', scale=1e4, marker='o', color='k')\n", + "plot_interdiffusivity_datasets(ax, components, 'Iijima1982', scale=1e4, marker='x', color='k')\n", + "\n", + "ax.set_xlim([0,1])\n", + "ax.set_xlabel('X(Cu)')\n", + "ax.set_ylabel('$D^{Cu}_{NiNi}$ ($cm^2/s$)')\n", + "ax.set_yscale('log')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could plot the prefactor and activation energy of the tracer diffusivity with the optimized database to show that agreement is retained with the original tracer diffusivity data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import itertools\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from kawin.thermo import GeneralThermodynamics\n", + "from kawin.mobility_fitting.manual_fitting import grab_tracer_datasets\n", + "from kawin.thermo.Mobility import activation_energy_from_composition_set_phase_record, prefactor_from_composition_set_phase_record\n", + "\n", + "# Helper function to plot Q or D0 for a given species\n", + "def plot_datasets(ax, output, diffusing_species, scale=1):\n", + " symbols = ['o', 'v', 'x', 's', '+', '1', 'd', '_', '^', '<']\n", + " symbol_cycle = itertools.cycle(symbols)\n", + "\n", + " datasets = grab_tracer_datasets('datasets', output, 'FCC_A1', ['CU', 'NI', 'VA'], diffusing_species)\n", + " for d in datasets:\n", + " sub_config = d['solver']['sublattice_configurations']\n", + " sub_occ = d['solver']['sublattice_occupancies']\n", + " x_ni = []\n", + " for sc, so in zip(sub_config, sub_occ):\n", + " if isinstance(sc[0], str):\n", + " if sc[0] == 'CU':\n", + " x_ni.append(1-so[0])\n", + " elif sc[0] == 'NI':\n", + " x_ni.append(so[0])\n", + " else:\n", + " x_ni.append(so[0][sc[0].index('NI')])\n", + " values = np.array(d['values']).flatten()\n", + " ref = d['reference']\n", + " ax.scatter(x_ni, scale*values, label=ref, marker=next(symbol_cycle), color='k')\n", + "\n", + "components = ['CU', 'NI']\n", + "phase = 'FCC_A1'\n", + "\n", + "# Compute activation energy and pre-factor for Nb and Ti\n", + "N = 50\n", + "xs = np.linspace(1e-3, 1-1e-3, N)\n", + "T = 1273\n", + "qs_gen = np.zeros((N, 2))\n", + "qs_mcmc = np.zeros((N, 2))\n", + "lnd0s_gen = np.zeros((N, 2))\n", + "lnd0s_mcmc = np.zeros((N, 2))\n", + "for i, x in enumerate(xs):\n", + " results, comp_sets = therm_gen.getLocalEq(x, T, precPhase=[phase])\n", + " qs_gen[i] = activation_energy_from_composition_set_phase_record(comp_sets[0], therm_gen.mob_phase_records, phase, components)\n", + " qs_mcmc[i] = activation_energy_from_composition_set_phase_record(comp_sets[0], therm_mcmc.mob_phase_records, phase, components)\n", + "\n", + " lnd0s_gen[i] = prefactor_from_composition_set_phase_record(comp_sets[0], therm_gen.mob_phase_records, phase, components)\n", + " lnd0s_mcmc[i] = prefactor_from_composition_set_phase_record(comp_sets[0], therm_mcmc.mob_phase_records, phase, components)\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(8, 8))\n", + "\n", + "# Plot D0 for Nb mobility\n", + "axes[0,0].plot(xs, 1e4*np.exp(lnd0s_gen[:,0]), label='Generated')\n", + "axes[0,0].plot(xs, 1e4*np.exp(lnd0s_mcmc[:,0]), label='MCMC')\n", + "plot_datasets(axes[0,0], 'D0', 'CU', scale=1e4)\n", + "axes[0,0].set_yscale('log')\n", + "axes[0,0].set_ylabel('$D^0_{Cu}$ ($cm^2/s$)')\n", + "\n", + "# Plot Q for Nb mobility\n", + "axes[0,1].plot(xs, 1e-3*qs_gen[:,0], label='Generated')\n", + "axes[0,1].plot(xs, 1e-3*qs_mcmc[:,0], label='MCMC')\n", + "plot_datasets(axes[0,1], 'Q', 'CU', scale=1e-3)\n", + "axes[0,1].set_ylabel('$Q_{Cu}$ (kJ/mol)')\n", + "\n", + "# Plot D0 for Ti mobility\n", + "axes[1,0].plot(xs, 1e4*np.exp(lnd0s_gen[:,1]), label='Generated')\n", + "axes[1,0].plot(xs, 1e4*np.exp(lnd0s_mcmc[:,1]), label='MCMC')\n", + "plot_datasets(axes[1,0], 'D0', 'NI', scale=1e4)\n", + "axes[1,0].set_yscale('log')\n", + "axes[1,0].set_ylabel('$D^0_{Ni}$ ($cm^2/s$)')\n", + "\n", + "# Plot Q for Ti mobility\n", + "axes[1,1].plot(xs, 1e-3*qs_gen[:,1], label='Generated')\n", + "axes[1,1].plot(xs, 1e-3*qs_mcmc[:,1], label='MCMC')\n", + "plot_datasets(axes[1,1], 'Q', 'NI', scale=1e-3)\n", + "axes[1,1].set_ylabel('$Q_{Ni}$ (kJ/mol)')\n", + "\n", + "for ax in axes.reshape(-1):\n", + " ax.set_xlim([0,1])\n", + " ax.set_xlabel('X(Ni)')\n", + " ax.legend()\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Uncertainty quantification\n", + "\n", + "Since we have the trace files, we can compute the interdiffusivity for the sampled parameters to obtain 99% confidence intervals. Since we fixed the unary parameters, the uncertainty of the interdiffusivity goes to 0 as you approach pure Nb or pure Ti." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "T = 1273\n", + "x = np.linspace(1e-3, 1-1e-3, 100)\n", + "\n", + "# Set our fitted parameters to be freed symbols\n", + "therm = GeneralThermodynamics('databases/CuNi_mcmc.tdb', ['CU', 'NI', 'VA'], ['FCC_A1'], parameters = params)\n", + "\n", + "# Plot datasets\n", + "plot_interdiffusivity_datasets(ax, components, 'Heumann1972', scale=1e4, marker='o', color='k')\n", + "plot_interdiffusivity_datasets(ax, components, 'Iijima1982', scale=1e4, marker='x', color='k')\n", + "\n", + "# Remove first 75 parameters from trace and reshape to (N, params)\n", + "trace = np.load('output/CuNi_trace.npy')\n", + "trace = trace[:,500:]\n", + "trace = trace.reshape(-1, trace.shape[-1])\n", + "\n", + "# Sample 100 iterations from the trace and compute interdiffusivity\n", + "diffs = []\n", + "N = 200\n", + "for n in range(N):\n", + " index = int(n*trace.shape[0] / N)\n", + " param_map = {p: trace[index, i] for i, p in enumerate(params)}\n", + " therm.updateParameters(param_map)\n", + " diffs.append(therm.getInterdiffusivity(x, T))\n", + "\n", + "# Plot the average diffusivity along with 2 sigma intervals\n", + "diffs = np.array(diffs)\n", + "avg = np.exp(np.average(np.log(diffs), axis=0))\n", + "d_low = np.percentile(diffs, 97.5, axis=0)\n", + "d_high = np.percentile(diffs, 2.5, axis=0)\n", + "ax.plot(x, 1e4*avg, color='C0', linewidth=1, zorder=1)\n", + "ax.fill_between(x, 1e4*d_low, 1e4*d_high, alpha=0.35, zorder=0)\n", + "\n", + "ax.set_xlim([0, 1])\n", + "ax.set_xlabel('X(Ni)')\n", + "ax.set_ylabel('$D^{Cu}_{NiNi}$ ($cm^2/s$)')\n", + "ax.set_yscale('log')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, now that we have an assessed database, we can simulate a diffusion couple." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration\tSim Time (h)\tRun time (s)\n", + "0\t\t0.000e+00\t\t0.0\n", + "100\t\t2.092e+01\t\t2.9\n", + "200\t\t4.183e+01\t\t5.1\n", + "300\t\t6.275e+01\t\t6.7\n", + "400\t\t8.366e+01\t\t8.0\n", + "500\t\t1.046e+02\t\t9.0\n", + "600\t\t1.255e+02\t\t10.0\n", + "700\t\t1.466e+02\t\t10.9\n", + "717\t\t1.500e+02\t\t11.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from kawin.diffusion import SinglePhaseModel, CompositionProfile, TemperatureParameters\n", + "\n", + "components = ['NI', 'CU']\n", + "phases = ['FCC_A1']\n", + "therm = GeneralThermodynamics('databases/CuNi_mcmc.tdb', components, phases)\n", + "\n", + "temperature = TemperatureParameters(1273)\n", + "profile = CompositionProfile()\n", + "profile.addStepCompositionStep('CU', 1e-3, 1-1e-3, 4e-4)\n", + "\n", + "model = SinglePhaseModel([0, 12e-4], 100, components, phases, thermodynamics=therm,\n", + " compositionProfile=profile, temperatureParameters=temperature)\n", + "\n", + "model.solve(150*3600, verbose=True, vIt=100)\n", + "\n", + "fig, ax = plt.subplots()\n", + "model.plot(ax, plotReference=False, zScale=1e-4)\n", + "\n", + "heumann_data = np.array([\n", + " [2.508e-4, 0.005],\n", + " [2.749e-4, 0.008],\n", + " [3.275e-4, 0.063],\n", + " [3.494e-4, 0.307],\n", + " [3.801e-4, 0.485],\n", + " [3.823e-4, 0.571],\n", + " [4.239e-4, 0.723],\n", + " [4.765e-4, 0.830],\n", + " [5.203e-4, 0.879],\n", + " [5.773e-4, 0.923],\n", + " [6.474e-4, 0.959],\n", + " [7.525e-4, 0.988],\n", + " [8.478e-4, 0.994],\n", + " [9.584e-4, 0.995],\n", + " [10.986e-4, 0.995],\n", + "])\n", + "ax.scatter(heumann_data[:,0]/1e-4, heumann_data[:,1], marker='x', color='k', label='Heumann1972', zorder=2)\n", + "ax.set_xlabel('Distance * 1e4 (m)')\n", + "ax.set_ylim([0,1])\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References for dataset\n", + "\n", + "1. G. Ghosh, Acta Mater. 49 (2001) 2609.\n", + "2. M.S. Anand, S.P. Murarka, R.P. Agarwala, J. Appl. Phys. 36 (1965) 3860.\n", + "3. H. Bakker, Phys. Stat. Sol. 28 (1958) 569.\n", + "4. K.J. Anusavice, J.J. Pinajian, K. Oikawa, R.T. DeHoff, Trans. Metal. Soc. AIME 242 (1968) 2027.\n", + "5. K. Monma, H. Suto, H. Oikawa, J. Japan Inst. Met. 28 (1964) 192.\n", + "6. V.T. Heumann, K.J. Grundhoff, Z. Metallk. 63 (1972) 173.\n", + "7. Y. Iijima, K. Hirano, M. Kikuchi, Trans. Japan Inst. Met. 23 (1982) 19." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "calphad_312", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/mobility_fitting/databases/CuNi.tdb b/examples/mobility_fitting/databases/CuNi.tdb new file mode 100644 index 0000000..63d07d9 --- /dev/null +++ b/examples/mobility_fitting/databases/CuNi.tdb @@ -0,0 +1,67 @@ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$$ Cu-Ni thermodynamic database +$$ +$$ Unaries from SGTE 1991 +$$ Binary assessment from S. Mey, Calphad 16:3 (1992) 255 +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +ELEMENT VA VACUUM 0.0000E+00 0.0000E+00 0.0000E+00 ! +ELEMENT CU FCC_A1 6.3546E+01 5.0041E+03 3.3150E+01 ! +ELEMENT NI FCC_A1 5.8690E+01 4.7870E+03 2.9796E+01 ! + + TYPE_DEFINITION % SEQ *! + DEFINE_SYSTEM_DEFAULT SPECIE 2 ! + DEFAULT_COMMAND DEF_SYS_ELEMENT VA ! + + TYPE_DEFINITION ( GES A_P_D FCC_A1 MAGNETIC -3.0 0.28 ! + PHASE FCC_A1 %( 2 1 1 ! + CONSTITUENT FCC_A1 : CU,NI : VA : ! + + PHASE LIQUID:L % 1 1 ! + CONSTITUENT LIQUID:L : CU,NI : ! + +$ Cu +$ ------------------------------------- + FUNCTION GHSERCU 298.15 + -7770.458+130.485235*T-24.112392*T*LN(T)-2.65684E-3*T**2+0.129223E-6*T**3 + +52478*T**(-1); 1357.77 Y + -13542.026+183.803828*T-31.38*T*LN(T)+364.167E27*T**(-9); 3200.00 N ! + + FUNCTION GBCCCU 298.15 4017-1.255*T+GHSERCU; 3200 N ! + + FUNCTION GHCPCU 298.15 600+0.2*T+GHSERCU; 3200 N ! + + FUNCTION GLIQCU 298.15 12964.735-9.511904*T-584.89E-23*T**7+GHSERCU; 1357.77 Y + -46.545+173.881484*T-31.38*T*LN(T); 3200 N ! + +$ Ni +$ ------------------------------------- + FUNCTION GHSERNI 298.15 + -5179.159+117.854*T-22.096*T*LN(T)-4.8407E-3*T**2; 1728.00 Y + -27840.620+279.134977*T-43.1*T*LN(T)+1127.54E28*T**(-9); 3000.00 N ! + + FUNCTION GLIQNI 298.15 16414.686-9.397*T-382.318E-23*T**7+GHSERNI; 1728 Y + -9549.817+268.597977*T-43.1*T*LN(T); 3000 N ! + + FUNCTION GBCCNI 298.15 8715.084-3.556*T+GHSERNI; 3000 N ! + + FUNCTION GHCPNI 298.15 1046+1.2552*T+GHSERNI; 3000 N ! + +$ Unaries parameters + PARAMETER G(FCC_A1,CU:VA;0) 298.15 GHSERCU; 3200 N ! + PARAMETER G(LIQUID,CU;0) 298.15 GLIQCU; 3200 N ! + + PARAMETER G(FCC_A1,NI:VA;0) 298.15 GHSERNI; 3000 N ! + PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633; 3000 N ! + PARAMETER BM(FCC_A1,NI:VA;0) 298.15 0.52; 3000 N ! + PARAMETER G(LIQUID,NI;0) 298.15 GLIQNI; 3000 N ! + +$ Binary parameters + PARAMETER G(FCC_A1,CU,NI:VA;0) 298.15 8047.72 + 3.42217*T; 6000 N ! + PARAMETER G(FCC_A1,CU,NI:VA;1) 298.15 -2041.30 + 0.99714*T; 6000 N ! + PARAMETER TC(FCC_A1,CU,NI:VA;0) 298.15 -935.5; 3000 N ! + PARAMETER TC(FCC_A1,CU,NI:VA;1) 298.15 -594.9; 3000 N ! + PARAMETER BM(FCC_A1,CU,NI:VA;0) 298.15 -0.732; 3000 N ! + PARAMETER BM(FCC_A1,CU,NI:VA;1) 298.15 -0.317; 3000 N ! + + PARAMETER G(LIQUID,CU,NI;0) 298.15 12048.61 + 1.29093*T; 6000 N ! + PARAMETER G(LIQUID,CU,NI;1) 298.15 -1861.61 + 0.94201*T; 6000 N ! diff --git a/examples/mobility_fitting/databases/CuNi_manual_fit.tdb b/examples/mobility_fitting/databases/CuNi_manual_fit.tdb new file mode 100644 index 0000000..742f939 --- /dev/null +++ b/examples/mobility_fitting/databases/CuNi_manual_fit.tdb @@ -0,0 +1,76 @@ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ Date: 2025-02-21 16:31 +$ Components: CU, NI, VA +$ Phases: FCC_A1, LIQUID +$ Generated by ury3 (pycalphad 0.11.1.dev27+g2e830294) +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +ELEMENT CU FCC_A1 63.546 5004.1 33.15 ! +ELEMENT NI FCC_A1 58.69 4787.0 29.796 ! +ELEMENT VA VACUUM 0.0 0.0 0.0 ! + + +FUNCTION GBCCCU 298.15 4017.0-1.255*T+GHSERCU; 3200.0 N ! +FUNCTION GBCCNI 298.15 8715.084-3.556*T+GHSERNI; 3000.0 N ! +FUNCTION GHCPCU 298.15 600.0+0.2*T+GHSERCU; 3200.0 N ! +FUNCTION GHCPNI 298.15 1046.0+1.2552*T+GHSERNI; 3000.0 N ! +FUNCTION GHSERCU 298.15 -7770.458+130.485235*T-24.112392*T*LOG(T) + +1.29223E-07*T**(3)-0.00265684*T**(2)+52478.0*T**(-1); 1357.77 Y -13542.026 + +183.803828*T-31.38*T*LOG(T)+3.64167E+29*T**(-9); 3200.0 N ! +FUNCTION GHSERNI 298.15 -5179.159+117.854*T-22.096*T*LOG(T)-0.0048407*T**(2); + 1728.0 Y -27840.62+279.134977*T-43.1*T*LOG(T)+1.12754E+31*T**(-9); 3000.0 + N ! +FUNCTION GLIQCU 298.15 12964.735-5.8489E-21*T**(7)-9.511904*T+GHSERCU; + 1357.77 Y -46.545-31.38*T*LOG(T)+173.881484*T; 3200.0 N ! +FUNCTION GLIQNI 298.15 16414.686-3.82318E-21*T**(7)-9.397*T+GHSERNI; 1728.0 Y + -9549.817-43.1*T*LOG(T)+268.597977*T; 3000.0 N ! +FUNCTION VV0000 1 -83.6320706404982; 10000 N ! +FUNCTION VV0001 1 -73.7313841197274; 10000 N ! +FUNCTION VV0002 1 -206518.560463178; 10000 N ! +FUNCTION VV0003 1 -266996.179041866; 10000 N ! + +TYPE_DEFINITION % SEQ * ! +DEFINE_SYSTEM_DEFAULT ELEMENT 2 ! +DEFAULT_COMMAND DEFINE_SYSTEM_ELEMENT VA ! + +TYPE_DEFINITION ^ GES AMEND_PHASE_DESCRIPTION FCC_A1 MAGNETIC -3.0 0.28 ! +PHASE FCC_A1 %^ 2 1.0 1.0 ! +CONSTITUENT FCC_A1 :CU, NI:VA: ! + +PHASE LIQUID:L % 1 1.0 ! +CONSTITUENT LIQUID:L :CU, NI: ! + + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ CU $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER G(FCC_A1,CU:VA;0) 298.15 GHSERCU; 3200.0 N ! +PARAMETER MQ(FCC_A1&CU,CU:VA;0) 1 T*VV0000+VV0002; 10000 N ! +PARAMETER G(LIQUID,CU;0) 298.15 GLIQCU; 3200.0 N ! + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ NI $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 0.52; 3000.0 N ! +PARAMETER G(FCC_A1,NI:VA;0) 298.15 GHSERNI; 3000.0 N ! +PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633.0; 3000.0 N ! +PARAMETER G(LIQUID,NI;0) 298.15 GLIQNI; 3000.0 N ! + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ CU-NI $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER BMAGN(FCC_A1,CU,NI:VA;0) 298.15 -0.732; 3000.0 N ! +PARAMETER BMAGN(FCC_A1,CU,NI:VA;1) 298.15 -0.317; 3000.0 N ! +PARAMETER G(FCC_A1,CU,NI:VA;0) 298.15 8047.72+3.42217*T; 6000.0 N ! +PARAMETER G(FCC_A1,CU,NI:VA;1) 298.15 -2041.3+0.99714*T; 6000.0 N ! +PARAMETER MQ(FCC_A1&CU,NI:VA;0) 1 VV0003+T*VV0001; 10000 N ! +PARAMETER TC(FCC_A1,CU,NI:VA;0) 298.15 -935.5; 3000.0 N ! +PARAMETER TC(FCC_A1,CU,NI:VA;1) 298.15 -594.9; 3000.0 N ! +PARAMETER G(LIQUID,CU,NI;0) 298.15 12048.61+1.29093*T; 6000.0 N ! +PARAMETER G(LIQUID,CU,NI;1) 298.15 -1861.61+0.94201*T; 6000.0 N ! diff --git a/examples/mobility_fitting/databases/CuNi_mcmc.tdb b/examples/mobility_fitting/databases/CuNi_mcmc.tdb new file mode 100644 index 0000000..9ab9db3 --- /dev/null +++ b/examples/mobility_fitting/databases/CuNi_mcmc.tdb @@ -0,0 +1,91 @@ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ Date: 2025-02-21 16:11 +$ Components: CU, NI, VA +$ Phases: FCC_A1, LIQUID +$ Generated by ury3 (pycalphad 0.11.1.dev27+g2e830294) +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +ELEMENT CU FCC_A1 63.546 5004.1 33.15 ! +ELEMENT NI FCC_A1 58.69 4787.0 29.796 ! +ELEMENT VA VACUUM 0.0 0.0 0.0 ! + + +FUNCTION GBCCCU 298.15 4017.0-1.255*T+GHSERCU; 3200.0 N ! +FUNCTION GBCCNI 298.15 8715.084-3.556*T+GHSERNI; 3000.0 N ! +FUNCTION GHCPCU 298.15 600.0+0.2*T+GHSERCU; 3200.0 N ! +FUNCTION GHCPNI 298.15 1046.0+1.2552*T+GHSERNI; 3000.0 N ! +FUNCTION GHSERCU 298.15 -7770.458+130.485235*T-24.112392*T*LOG(T) + -0.00265684*T**(2)+1.29223E-07*T**(3)+52478.0*T**(-1); 1357.77 Y -13542.026 + +183.803828*T-31.38*T*LOG(T)+3.64167E+29*T**(-9); 3200.0 N ! +FUNCTION GHSERNI 298.15 -5179.159+117.854*T-22.096*T*LOG(T)-0.0048407*T**(2); + 1728.0 Y -27840.62+279.134977*T-43.1*T*LOG(T)+1.12754E+31*T**(-9); 3000.0 + N ! +FUNCTION GHSERVA 1.0 0.0; 10000.0 N ! +FUNCTION GLIQCU 298.15 12964.735-9.511904*T-5.8489E-21*T**(7)+GHSERCU; + 1357.77 Y -46.545+173.881484*T-31.38*T*LOG(T); 3200.0 N ! +FUNCTION GLIQNI 298.15 16414.686-9.397*T-3.82318E-21*T**(7)+GHSERNI; 1728.0 Y + -9549.817+268.597977*T-43.1*T*LOG(T); 3000.0 N ! +FUNCTION VV0000 1 -91.4920573062081; 10000 N ! +FUNCTION VV0001 1 -202921.189415445; 10000 N ! +FUNCTION VV0002 1 -87.0602560306477; 10000 N ! +FUNCTION VV0003 1 -201732.971510536; 10000 N ! +FUNCTION VV0004 1 -59.8942795283338; 10000 N ! +FUNCTION VV0005 1 -305030.362438795; 10000 N ! +FUNCTION VV0006 1 -75.9323138428472; 10000 N ! +FUNCTION VV0007 1 -263795.147024709; 10000 N ! +FUNCTION VV0008 1 17.2258916644087; 10000 N ! +FUNCTION VV0009 1 -9602.55757245648; 10000 N ! +FUNCTION VV0010 1 23.3771617222535; 10000 N ! +FUNCTION VV0011 1 -21866.3156442164; 10000 N ! + +TYPE_DEFINITION % SEQ * ! +DEFINE_SYSTEM_DEFAULT ELEMENT 2 ! +DEFAULT_COMMAND DEFINE_SYSTEM_ELEMENT VA ! + +TYPE_DEFINITION ^ GES AMEND_PHASE_DESCRIPTION FCC_A1 MAGNETIC -3.0 0.28 ! +PHASE FCC_A1 %^ 2 1.0 1.0 ! +CONSTITUENT FCC_A1 :CU, NI:VA: ! + +PHASE LIQUID:L % 1 1.0 ! +CONSTITUENT LIQUID:L :CU, NI: ! + + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ CU $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER G(FCC_A1,CU:VA;0) 298.15 GHSERCU; 3200.0 N ! +PARAMETER MQ(FCC_A1&CU,CU:VA;0) 1.0 T*VV0002+VV0003; 10000.0 N ! +PARAMETER G(LIQUID,CU;0) 298.15 GLIQCU; 3200.0 N ! + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ NI $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 0.52; 3000.0 N ! +PARAMETER G(FCC_A1,NI:VA;0) 298.15 GHSERNI; 3000.0 N ! +PARAMETER MQ(FCC_A1&NI,NI:VA;0) 1.0 T*VV0004+VV0005; 10000.0 N ! +PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633.0; 3000.0 N ! +PARAMETER G(LIQUID,NI;0) 298.15 GLIQNI; 3000.0 N ! + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ CU-NI $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER BMAGN(FCC_A1,CU,NI:VA;0) 298.15 -0.732; 3000.0 N ! +PARAMETER BMAGN(FCC_A1,CU,NI:VA;1) 298.15 -0.317; 3000.0 N ! +PARAMETER G(FCC_A1,CU,NI:VA;0) 298.15 8047.72+3.42217*T; 6000.0 N ! +PARAMETER G(FCC_A1,CU,NI:VA;1) 298.15 -2041.3+0.99714*T; 6000.0 N ! +PARAMETER MQ(FCC_A1&NI,CU:VA;0) 1.0 T*VV0000+VV0001; 10000.0 N ! +PARAMETER MQ(FCC_A1&CU,NI:VA;0) 1.0 T*VV0006+VV0007; 10000.0 N ! +PARAMETER MQ(FCC_A1&CU,CU,NI:VA;0) 1.0 T*VV0010+VV0011; 10000.0 N ! +PARAMETER MQ(FCC_A1&NI,CU,NI:VA;0) 1.0 T*VV0008+VV0009; 10000.0 N ! +PARAMETER TC(FCC_A1,CU,NI:VA;0) 298.15 -935.5; 3000.0 N ! +PARAMETER TC(FCC_A1,CU,NI:VA;1) 298.15 -594.9; 3000.0 N ! +PARAMETER G(LIQUID,CU,NI;0) 298.15 12048.61+1.29093*T; 6000.0 N ! +PARAMETER G(LIQUID,CU,NI;1) 298.15 -1861.61+0.94201*T; 6000.0 N ! +PARAMETER MQ(LIQUID&NI,CU;0) 1 -36468.03076-136.988159811907*T; 10000 N ! +PARAMETER MQ(LIQUID&CU,NI;0) 1 -46404.09216-137.295100407725*T; 10000 N ! diff --git a/examples/mobility_fitting/databases/CuNi_mob_gen.tdb b/examples/mobility_fitting/databases/CuNi_mob_gen.tdb new file mode 100644 index 0000000..ee83e87 --- /dev/null +++ b/examples/mobility_fitting/databases/CuNi_mob_gen.tdb @@ -0,0 +1,93 @@ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ Date: 2025-02-21 16:30 +$ Components: CU, NI, VA +$ Phases: FCC_A1, LIQUID +$ Generated by ury3 (pycalphad 0.11.1.dev27+g2e830294) +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +ELEMENT CU FCC_A1 63.546 5004.1 33.15 ! +ELEMENT NI FCC_A1 58.69 4787.0 29.796 ! +ELEMENT VA VACUUM 0.0 0.0 0.0 ! + + +FUNCTION GBCCCU 298.15 4017.0-1.255*T+GHSERCU; 3200.0 N ! +FUNCTION GBCCNI 298.15 8715.084-3.556*T+GHSERNI; 3000.0 N ! +FUNCTION GHCPCU 298.15 600.0+0.2*T+GHSERCU; 3200.0 N ! +FUNCTION GHCPNI 298.15 1046.0+1.2552*T+GHSERNI; 3000.0 N ! +FUNCTION GHSERCU 298.15 -7770.458+130.485235*T-24.112392*T*LOG(T) + +1.29223E-07*T**(3)-0.00265684*T**(2)+52478.0*T**(-1); 1357.77 Y -13542.026 + +183.803828*T-31.38*T*LOG(T)+3.64167E+29*T**(-9); 3200.0 N ! +FUNCTION GHSERNI 298.15 -5179.159+117.854*T-22.096*T*LOG(T)-0.0048407*T**(2); + 1728.0 Y -27840.62+279.134977*T-43.1*T*LOG(T)+1.12754E+31*T**(-9); 3000.0 + N ! +FUNCTION GHSERVA 1 0; 10000 N ! +FUNCTION GLIQCU 298.15 12964.735-5.8489E-21*T**(7)-9.511904*T+GHSERCU; + 1357.77 Y -46.545-31.38*T*LOG(T)+173.881484*T; 3200.0 N ! +FUNCTION GLIQNI 298.15 16414.686-3.82318E-21*T**(7)-9.397*T+GHSERNI; 1728.0 Y + -9549.817-43.1*T*LOG(T)+268.597977*T; 3000.0 N ! +FUNCTION VV0000 1 -82.5275; 10000 N ! +FUNCTION VV0001 1 -205872.0; 10000 N ! +FUNCTION VV0002 1 -71.0695; 10000 N ! +FUNCTION VV0003 1 -232826.0; 10000 N ! +FUNCTION VV0004 1 -79.2647; 10000 N ! +FUNCTION VV0005 1 -255224.0; 10000 N ! +FUNCTION VV0006 1 -71.7851; 10000 N ! +FUNCTION VV0007 1 -285142.0; 10000 N ! +FUNCTION VV0008 1 13.9161; 10000 N ! +FUNCTION VV0009 1 -42473.8; 10000 N ! +FUNCTION VV0010 1 -31.3775; 10000 N ! +FUNCTION VV0011 1 43996.2; 10000 N ! + +TYPE_DEFINITION % SEQ * ! +DEFINE_SYSTEM_DEFAULT ELEMENT 2 ! +DEFAULT_COMMAND DEFINE_SYSTEM_ELEMENT VA ! + +TYPE_DEFINITION ^ GES AMEND_PHASE_DESCRIPTION FCC_A1 MAGNETIC -3.0 0.28 ! +PHASE FCC_A1 %^ 2 1.0 1.0 ! +CONSTITUENT FCC_A1 :CU, NI:VA: ! + +PHASE LIQUID:L % 1 1.0 ! +CONSTITUENT LIQUID:L :CU, NI: ! + + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ CU $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER G(FCC_A1,CU:VA;0) 298.15 GHSERCU; 3200.0 N ! +PARAMETER MQ(FCC_A1&CU,CU:VA;0) 1 T*VV0000+VV0001; 10000 N ! +PARAMETER G(LIQUID,CU;0) 298.15 GLIQCU; 3200.0 N ! +PARAMETER MQ(LIQUID&CU,CU;0) 1 -36468.03076-137.186121545147*T; 10000 N ! + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ NI $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 0.52; 3000.0 N ! +PARAMETER G(FCC_A1,NI:VA;0) 298.15 GHSERNI; 3000.0 N ! +PARAMETER MQ(FCC_A1&NI,NI:VA;0) 1 T*VV0006+VV0007; 10000 N ! +PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633.0; 3000.0 N ! +PARAMETER G(LIQUID,NI;0) 298.15 GLIQNI; 3000.0 N ! +PARAMETER MQ(LIQUID&NI,NI;0) 1 -46404.09216-137.097138674486*T; 10000 N ! + + +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$ CU-NI $ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ + +PARAMETER BMAGN(FCC_A1,CU,NI:VA;0) 298.15 -0.732; 3000.0 N ! +PARAMETER BMAGN(FCC_A1,CU,NI:VA;1) 298.15 -0.317; 3000.0 N ! +PARAMETER G(FCC_A1,CU,NI:VA;0) 298.15 8047.72+3.42217*T; 6000.0 N ! +PARAMETER G(FCC_A1,CU,NI:VA;1) 298.15 -2041.3+0.99714*T; 6000.0 N ! +PARAMETER MQ(FCC_A1&NI,CU:VA;0) 1 T*VV0002+VV0003; 10000 N ! +PARAMETER MQ(FCC_A1&CU,NI:VA;0) 1 T*VV0004+VV0005; 10000 N ! +PARAMETER MQ(FCC_A1&CU,CU,NI:VA;0) 1 T*VV0008+VV0009; 10000 N ! +PARAMETER MQ(FCC_A1&NI,CU,NI:VA;0) 1 T*VV0010+VV0011; 10000 N ! +PARAMETER TC(FCC_A1,CU,NI:VA;0) 298.15 -935.5; 3000.0 N ! +PARAMETER TC(FCC_A1,CU,NI:VA;1) 298.15 -594.9; 3000.0 N ! +PARAMETER G(LIQUID,CU,NI;0) 298.15 12048.61+1.29093*T; 6000.0 N ! +PARAMETER G(LIQUID,CU,NI;1) 298.15 -1861.61+0.94201*T; 6000.0 N ! +PARAMETER MQ(LIQUID&NI,CU;0) 1 -36468.03076-136.988159811907*T; 10000 N ! +PARAMETER MQ(LIQUID&CU,NI;0) 1 -46404.09216-137.295100407725*T; 10000 N ! diff --git a/examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Heumann1972.json b/examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Heumann1972.json new file mode 100644 index 0000000..df0d37f --- /dev/null +++ b/examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Heumann1972.json @@ -0,0 +1,58 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "ref_el": ["CU"], + "dependent_el": ["NI", "NI"], + "conditions": { + "P": 101325, + "T": 1273, + "X_CU": [ + 0.047, + 0.101, + 0.155, + 0.201, + 0.250, + 0.299, + 0.358, + 0.400, + 0.454, + 0.507, + 0.556, + 0.603, + 0.655, + 0.703, + 0.757, + 0.806, + 0.858, + 0.905, + 0.931, + 0.956, + 0.981 + ] + }, + "output": "INTER_DIFF", + "values": [[[ + 1.546E-15, + 1.670E-15, + 2.046E-15, + 2.232E-15, + 2.276E-15, + 2.657E-15, + 3.319E-15, + 3.875E-15, + 4.567E-15, + 5.332E-15, + 6.285E-15, + 6.924E-15, + 8.904E-15, + 1.091E-14, + 1.458E-14, + 1.931E-14, + 2.762E-14, + 3.484E-14, + 3.989E-14, + 4.480E-14, + 4.840E-14 + ]]], + "reference": "Heumann1972" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Iijima1982.json b/examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Iijima1982.json new file mode 100644 index 0000000..942af52 --- /dev/null +++ b/examples/mobility_fitting/datasets/equilibrium/Dnkj_1273_Iijima1982.json @@ -0,0 +1,74 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "ref_el": ["CU"], + "dependent_el": ["NI", "NI"], + "conditions": { + "P": 101325, + "T": 1273, + "X_CU": [ + 0.098, + 0.128, + 0.162, + 0.209, + 0.245, + 0.277, + 0.316, + 0.358, + 0.402, + 0.420, + 0.461, + 0.470, + 0.514, + 0.530, + 0.577, + 0.623, + 0.649, + 0.683, + 0.706, + 0.744, + 0.768, + 0.798, + 0.827, + 0.845, + 0.857, + 0.878, + 0.917, + 0.926, + 0.949 + ] + }, + "output": "INTER_DIFF", + "values": [[[ + 1.787E-15, + 2.046E-15, + 1.875E-15, + 2.106E-15, + 1.931E-15, + 2.843E-15, + 2.298E-15, + 2.927E-15, + 3.351E-15, + 4.146E-15, + 3.986E-15, + 5.043E-15, + 5.215E-15, + 6.561E-15, + 7.547E-15, + 8.071E-15, + 1.068E-14, + 1.292E-14, + 1.598E-14, + 1.767E-14, + 2.211E-14, + 2.660E-14, + 3.025E-14, + 3.764E-14, + 4.735E-14, + 5.570E-14, + 5.923E-14, + 8.619E-14, + 9.804E-14 + ]]], + "reference": "Iijima1982" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_D0.json new file mode 100644 index 0000000..e74074e --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_D0.json @@ -0,0 +1,17 @@ +{ + "components": ["CU", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_D0_CU", + "values": [[[4.89e-5]]], + "reference": "Ghosh2001" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_Q.json new file mode 100644 index 0000000..281fef0 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Cu_Ghosh2001_Q.json @@ -0,0 +1,17 @@ +{ + "components": ["CU", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_CU", + "values": [[[205872]]], + "reference": "Ghosh2001" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_D0.json new file mode 100644 index 0000000..4aeb4e2 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_D0.json @@ -0,0 +1,17 @@ +{ + "components": ["NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["NI", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_D0_CU", + "values": [[[7.24e-5]]], + "reference": "Anand1965" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_Q.json new file mode 100644 index 0000000..d6ba916 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_Ni_Anand1965_Q.json @@ -0,0 +1,17 @@ +{ + "components": ["NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["NI", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_CU", + "values": [[[255224]]], + "reference": "Anand1965" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_D0.json new file mode 100644 index 0000000..9f11781 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_D0.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.7173, 0.2827], 1], + [[0.8028, 0.1972], 1], + [[0.9008, 0.0992], 1] + ] +}, + "output": "TRACER_D0_CU", + "values": [[[ + 2.67e-5, + 1.63e-5, + 4.14e-5 + ]]], + "reference": "Anusavice1972" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_Q.json new file mode 100644 index 0000000..646fed1 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Anusavice1972_Q.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.7173, 0.2827], 1], + [[0.8028, 0.1972], 1], + [[0.9008, 0.0992], 1] + ] +}, + "output": "TRACER_Q_CU", + "values": [[[ + 215847, + 205847, + 210162 + ]]], + "reference": "Anusavice1972" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_D0.json new file mode 100644 index 0000000..d5522db --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_D0.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.15, 0.85], 1], + [[0.50, 0.50], 1], + [[0.80, 0.20], 1] + ] +}, + "output": "TRACER_D0_CU", + "values": [[[ + 1.87e-4, + 2.16e-4, + 1.82e-4 + ]]], + "reference": "Monma1964" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_Q.json new file mode 100644 index 0000000..114914a --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Cu_tracer/DCu_mix_Monma1964_Q.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.15, 0.85], 1], + [[0.50, 0.50], 1], + [[0.80, 0.20], 1] + ] +}, + "output": "TRACER_Q_CU", + "values": [[[ + 265978, + 251502, + 230957 + ]]], + "reference": "Monma1964" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_D0.json new file mode 100644 index 0000000..ef06fa2 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_D0.json @@ -0,0 +1,17 @@ +{ + "components": ["CU", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_D0_NI", + "values": [[[1.94e-4]]], + "reference": "Anusavice1972" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_Q.json new file mode 100644 index 0000000..bc47756 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Cu_Anusavice1972_Q.json @@ -0,0 +1,17 @@ +{ + "components": ["CU", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_NI", + "values": [[[232826]]], + "reference": "Anusavice1972" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_D0.json new file mode 100644 index 0000000..723c9de --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_D0.json @@ -0,0 +1,17 @@ +{ + "components": ["NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["NI", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_D0_NI", + "values": [[[1.78e-4]]], + "reference": "Bakker1968" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_Q.json new file mode 100644 index 0000000..6b8a766 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_Ni_Bakker1968_Q.json @@ -0,0 +1,17 @@ +{ + "components": ["NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["NI", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_NI", + "values": [[[285142]]], + "reference": "Bakker1968" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_D0.json new file mode 100644 index 0000000..a850919 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_D0.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.7173, 0.2827], 1], + [[0.8028, 0.1972], 1], + [[0.9008, 0.0992], 1] + ] +}, + "output": "TRACER_D0_NI", + "values": [[[ + 3.80e-5, + 6.63e-6, + 2.07e-5 + ]]], + "reference": "Anusavice1972" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_Q.json new file mode 100644 index 0000000..e5e325d --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Anusavice1972_Q.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.7173, 0.2827], 1], + [[0.8028, 0.1972], 1], + [[0.9008, 0.0992], 1] + ] +}, + "output": "TRACER_Q_NI", + "values": [[[ + 220283, + 206225, + 222906 + ]]], + "reference": "Anusavice1972" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_D0.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_D0.json new file mode 100644 index 0000000..34bbbdf --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_D0.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.15, 0.85], 1], + [[0.50, 0.50], 1], + [[0.80, 0.20], 1] + ] +}, + "output": "TRACER_D0_NI", + "values": [[[ + 2.474e-3, + 1.935e-3, + 6.66e-6 + ]]], + "reference": "Monma1964" +} \ No newline at end of file diff --git a/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_Q.json b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_Q.json new file mode 100644 index 0000000..b6d5954 --- /dev/null +++ b/examples/mobility_fitting/datasets/non_equilibrium/Ni_tracer/DNi_mix_Monma1964_Q.json @@ -0,0 +1,29 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 1273 +}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"], + [["CU", "NI"], "VA"] + ], + "sublattice_occupancies": [ + [[0.15, 0.85], 1], + [[0.50, 0.50], 1], + [[0.80, 0.20], 1] + ] +}, + "output": "TRACER_Q_NI", + "values": [[[ + 309080, + 284997, + 207833 + ]]], + "reference": "Monma1964" +} \ No newline at end of file diff --git a/examples/mobility_fitting/phase_models.json b/examples/mobility_fitting/phase_models.json new file mode 100644 index 0000000..b363506 --- /dev/null +++ b/examples/mobility_fitting/phase_models.json @@ -0,0 +1,13 @@ +{ + "components": ["CU", "NI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["CU", "NI"], ["VA"]], + "sublattice_site_ratios": [1, 1] + }, + "LIQUID": { + "sublattice_model": [["CU", "NI"]], + "sublattice_site_ratios": [1] + } + } +} \ No newline at end of file diff --git a/kawin/diffusion/Diffusion.py b/kawin/diffusion/Diffusion.py index 49fbe2d..974760b 100644 --- a/kawin/diffusion/Diffusion.py +++ b/kawin/diffusion/Diffusion.py @@ -128,6 +128,7 @@ def toDict(self): ''' Converts diffusion data to dictionary ''' + self._finalizeRecording() data = { 'finalTime': self.t, 'finalX': self.x, @@ -144,6 +145,8 @@ def fromDict(self, data): self.x = data['finalX'] self._recordedX = data['recordX'] self._recordedTime = data['recordTime'] + if hasattr(self._recordedTime, '__len__'): + self._recordIndex = len(self._recordedTime) self.isSetup = True def setHashSensitivity(self, s): @@ -182,6 +185,7 @@ def enableRecording(self): Enables recording of composition and phase ''' self._record = True + self._recordIndex = 0 self._recordedX = np.zeros((1, len(self.elements), self.N)) self._recordedTime = np.zeros(1) @@ -204,11 +208,21 @@ def record(self, time): ''' if self._record: if time > 0: - self._recordedX = np.pad(self._recordedX, ((0, 1), (0, 0), (0, 0))) - self._recordedTime = np.pad(self._recordedTime, (0, 1)) - - self._recordedX[-1] = self.x - self._recordedTime[-1] = time + self._recordIndex += 1 + + # Pad a bunch of data to the array so we don't have to copy often + N = 10000 + if self._recordIndex >= self._recordedTime.shape[0]: + self._recordedX = np.pad(self._recordedX, ((0, N), (0, 0), (0, 0))) + self._recordedTime = np.pad(self._recordedTime, (0, N)) + + self._recordedX[self._recordIndex] = self.x + self._recordedTime[self._recordIndex] = time + + def _finalizeRecording(self): + if self._record: + self._recordedX = self._recordedX[:self._recordIndex] + self._recordedTime = self._recordedTime[:self._recordIndex] def setMeshtoRecordedTime(self, time): ''' diff --git a/kawin/diffusion/Plot.py b/kawin/diffusion/Plot.py index b3f503e..5eacede 100644 --- a/kawin/diffusion/Plot.py +++ b/kawin/diffusion/Plot.py @@ -3,6 +3,13 @@ from kawin.diffusion.DiffusionParameters import computeMobility +def _fill_kwargs(default_kwargs, **original_kwargs): + new_kwargs = {**original_kwargs} + for key, value in default_kwargs.items(): + if key not in new_kwargs: + new_kwargs[key] = value + return new_kwargs + def plot(diffModel, ax = None, plotReference = True, plotElement = None, zScale = 1, zOffset = 0, *args, **kwargs): ''' Plots composition profile @@ -34,9 +41,11 @@ def plot(diffModel, ax = None, plotReference = True, plotElement = None, zScale else: if plotReference: refE = 1 - np.sum(diffModel.x, axis=0) - ax.plot((diffModel.z+zOffset)/zScale, refE, label=diffModel.allElements[0], *args, **kwargs) + new_kwargs = _fill_kwargs({'label': diffModel.allElements[0]}, **kwargs) + ax.plot((diffModel.z+zOffset)/zScale, refE, *args, **new_kwargs) for e in range(len(diffModel.elements)): - ax.plot((diffModel.z+zOffset)/zScale, diffModel.x[e], label=diffModel.elements[e], *args, **kwargs) + new_kwargs = _fill_kwargs({'label': diffModel.elements[e]}, **kwargs) + ax.plot((diffModel.z+zOffset)/zScale, diffModel.x[e], *args, **new_kwargs) ax.set_xlim([(diffModel.zlim[0]+zOffset)/zScale, (diffModel.zlim[1]+zOffset)/zScale]) if plotElement is None: @@ -82,18 +91,22 @@ def plotTwoAxis(diffModel, Lelements, Relements, zScale = 1, zOffset = 0, axL = for e in range(len(Lelements)): if Lelements[e] in diffModel.elements: eIndex = diffModel._getElementIndex(Lelements[e]) - axL.plot((diffModel.z+zOffset)/zScale, diffModel.x[eIndex], label=diffModel.elements[eIndex], color = 'C' + str(ci), *args, **kwargs) + new_kwargs = _fill_kwargs({'label': diffModel.elements[eIndex], 'color': 'C' + str(ci)}) + axL.plot((diffModel.z+zOffset)/zScale, diffModel.x[eIndex], *args, **new_kwargs) ci = ci+1 if ci <= 9 else 0 elif Lelements[e] in diffModel.allElements: - axL.plot((diffModel.z+zOffset)/zScale, refE, label=diffModel.allElements[0], color = 'C' + str(ci), *args, **kwargs) + new_kwargs = _fill_kwargs({'label': diffModel.allElements[0], 'color': 'C' + str(ci)}) + axL.plot((diffModel.z+zOffset)/zScale, refE, *args, **new_kwargs) ci = ci+1 if ci <= 9 else 0 for e in range(len(Relements)): if Relements[e] in diffModel.elements: eIndex = diffModel._getElementIndex(Relements[e]) - axR.plot((diffModel.z+zOffset)/zScale, diffModel.x[eIndex], label=diffModel.elements[eIndex], color = 'C' + str(ci), *args, **kwargs) + new_kwargs = _fill_kwargs({'label': diffModel.elements[eIndex], 'color': 'C' + str(ci)}) + axR.plot((diffModel.z+zOffset)/zScale, diffModel.x[eIndex], *args, **new_kwargs) ci = ci+1 if ci <= 9 else 0 elif Relements[e] in diffModel.allElements: - axR.plot((diffModel.z+zOffset)/zScale, refE, label=diffModel.allElements[0], color = 'C' + str(ci), *args, **kwargs) + new_kwargs = _fill_kwargs({'label': diffModel.allElements[0], 'color': 'C' + str(ci)}) + axR.plot((diffModel.z+zOffset)/zScale, refE, *args, **new_kwargs) ci = ci+1 if ci <= 9 else 0 @@ -140,7 +153,8 @@ def plotPhases(diffModel, ax = None, plotPhase = None, zScale = 1, zOffset = 0, pf = [] for p_labels, p_fracs in zip(mob_data.phases, mob_data.phase_fractions): pf.append(np.sum(p_fracs[p_labels==diffModel.phases[p]])) - ax.plot((diffModel.z+zOffset)/zScale, pf, label=diffModel.phases[p], *args, **kwargs) + new_kwargs = _fill_kwargs({'label': diffModel.phases[p]}, **kwargs) + ax.plot((diffModel.z+zOffset)/zScale, pf, *args, **new_kwargs) ax.set_xlim([(diffModel.zlim[0]+zOffset)/zScale, (diffModel.zlim[1]+zOffset)/zScale]) ax.set_ylim([0, 1]) ax.set_xlabel('Distance (m)') diff --git a/kawin/mobility_fitting/__init__.py b/kawin/mobility_fitting/__init__.py index 5ebb0aa..b7cfef3 100644 --- a/kawin/mobility_fitting/__init__.py +++ b/kawin/mobility_fitting/__init__.py @@ -1,3 +1,3 @@ -from .generate import fit_mobility +from .generate import generate_mobility from .template import MobilityTemplate, SiteFractionGenerator, EquilibriumSiteFractionGenerator, plot_prefactor, plot_activation_energy, transform_activation_energy, transform_prefactor from .liquid_mobility import SuSpecies, LiuSpecies, generate_liquid_mobility_su, generate_liquid_mobility_liu \ No newline at end of file diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index b520a18..da17019 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -93,7 +93,7 @@ def _compute_cached_equilibrium(self, dbf): allConds = [dict(zip(keys,p)) for p in product(*values)] for i in range(len(allConds)): - inds = np.array([self.conditions[k].index(v) for k,v in allConds[i].items()], dtype=np.int32) + inds = np.array([self.conditions[k].index(val) for k,val in allConds[i].items()], dtype=np.int32) currConds = {v.N: 1, v.GE: 0, v.P: allConds[i][v.P], v.T: allConds[i][v.T]} for c in allConds[i]['composition']: @@ -152,7 +152,7 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray keys, values = zip(*data.conditions.items()) allConds = [dict(zip(keys,p)) for p in product(*values)] for i in range(len(allConds)): - inds = np.array([data.conditions[k].index(v) for k,v in allConds[i].items()], dtype=np.int32) + inds = np.array([data.conditions[k].index(val) for k,val in allConds[i].items()], dtype=np.int32) value = data.values[tuple(inds)] cs_data = data.cache[tuple(inds)] diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py index b943b4c..cde3856 100644 --- a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -215,6 +215,4 @@ def get_likelihood(self, parameters) -> float: likelihood = calculate_mob_probability(self.mob_data, parameters) return likelihood - residual_function_registry.register(NonEquilibriumMobilityResidual) - diff --git a/kawin/mobility_fitting/generate.py b/kawin/mobility_fitting/generate.py index 757b6ca..5b81165 100644 --- a/kawin/mobility_fitting/generate.py +++ b/kawin/mobility_fitting/generate.py @@ -5,14 +5,13 @@ import pycalphad from pycalphad import Database -from espei.espei_script import run_espei +from espei.datasets import load_datasets, recursive_glob +from espei.paramselect import generate_parameters from espei.parameter_selection.fitting_descriptions import ModelFittingDescription from kawin.mobility_fitting.fitting_steps import StepQ, StepD0, StepTracerDiffusivity from kawin.thermo.Mobility import MobilityModel -fitting_description = None - def add_mobility_keywords(elements): ''' Adds MQ_el keywords to the pycalphad tdb keyword list @@ -40,7 +39,7 @@ def add_mobility_keywords(elements): pycalphad.io.tdb_keywords.TDB_PARAM_TYPES.append(aliases[-1]) return aliases -def rewrite_mobility_terms(db_name, mob_aliases, tdb_write_kwargs = {}): +def rewrite_mobility_terms(dbf, mob_aliases): ''' Rewrites the database to replace MQ_el with MQ(Phase&el,...) @@ -51,23 +50,19 @@ def rewrite_mobility_terms(db_name, mob_aliases, tdb_write_kwargs = {}): mob_aliases : {str: str} Maps tdb keyword (MQ_el) to element (el) ''' - db = Database(db_name) - for p in db._parameters: + for p in dbf._parameters: if p['parameter_type'] in mob_aliases: ptype = p['parameter_type'] index = ptype.index('_') diff_species = ptype[index+1:] cons_array = tuple(tuple(s.name for s in xs) for xs in p['constituent_array']) - db.add_parameter( + dbf.add_parameter( 'MQ', p['phase_name'], cons_array, p['parameter_order'], p['parameter'], ref=p['reference'], diffusing_species = diff_species) for m in mob_aliases: - db._parameters.remove(where('parameter_type') == m) - - tdb_write_kwargs['if_exists'] = tdb_write_kwargs.get('if_exists', 'overwrite') - db.to_file(db_name, **tdb_write_kwargs) + dbf._parameters.remove(where('parameter_type') == m) def setup_mobility_fitting_description(diffusing_species, fit_to_tracer = False): ''' @@ -95,10 +90,9 @@ def setup_mobility_fitting_description(diffusing_species, fit_to_tracer = False) Q = type(f'Q_{e}', (StepQ,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_Q_{e}'}) steps += [D0, Q] - global fitting_description - fitting_description = ModelFittingDescription(steps, model=MobilityModel) + return ModelFittingDescription(steps, model=MobilityModel) -def fit_mobility(input_settings, diffusing_species = None, fit_to_tracer=False, tdb_write_kwargs = {}): +def generate_mobility(phase_models, datasets, diffusing_species = None, ridge_alpha=None, aicc_penalty_factor=None, dbf=None, fit_to_tracer=False): ''' Wrapper around run_espei to do the following: 1. Find components to fit mobility to @@ -112,21 +106,32 @@ def fit_mobility(input_settings, diffusing_species = None, fit_to_tracer=False, input_settings : dict Input dictionary used for an espei assessment ''' - #Get phase models to get components in system to fit to - phase_model_file = input_settings['system']['phase_models'] - with open(phase_model_file, 'r') as f: - phase_models = json.load(f) - - #Get non-VA components + # If phase models is a file, then load it in + if isinstance(phase_models, str): + with open(phase_models, 'r') as f: + phase_models = json.load(f) + + # If datasets is a folder, then load it in + if isinstance(datasets, str): + datasets = load_datasets(sorted(recursive_glob(datasets, '*.json'))) + + # Get non-VA components components = list(set(phase_models['components']) - set(['VA'])) # If no diffusing species, then assume same as components if diffusing_species is None: diffusing_species = components + # Get mobility fitting description + mobility_fitting_description = setup_mobility_fitting_description(diffusing_species, fit_to_tracer=fit_to_tracer) + + # Generate dbf + mob_dbf = generate_parameters(phase_models, datasets, 'SGTE91', 'linear', + ridge_alpha=ridge_alpha, aicc_penalty_factor=aicc_penalty_factor, + dbf=dbf, fitting_description=mobility_fitting_description) + aliases = add_mobility_keywords(diffusing_species) - setup_mobility_fitting_description(diffusing_species, fit_to_tracer=fit_to_tracer) + rewrite_mobility_terms(mob_dbf, aliases) + return mob_dbf - out_db = input_settings['output']['output_db'] - run_espei(input_settings) - rewrite_mobility_terms(out_db, aliases, tdb_write_kwargs=tdb_write_kwargs) \ No newline at end of file + \ No newline at end of file diff --git a/kawin/mobility_fitting/manual_fitting.py b/kawin/mobility_fitting/manual_fitting.py index f65df01..8d23227 100644 --- a/kawin/mobility_fitting/manual_fitting.py +++ b/kawin/mobility_fitting/manual_fitting.py @@ -15,7 +15,7 @@ DatasetPair = namedtuple('SystemPair', ['site_fractions', 'values']) FittingResult = namedtuple('FittingResult', ['template', 'parameters', 'aicc']) -def grab_datasets(datasets: Union[TinyDB, str], data_type: str, phase: str, components: list[str], diffusing_species: str, include_disabled: bool = False) -> tuple[list, list]: +def grab_tracer_datasets(datasets: Union[TinyDB, str], data_type: str, phase: str, components: list[str], diffusing_species: str, include_disabled: bool = False) -> tuple[list, list]: ''' Grabs all datasets for diffusing species of data type @@ -32,7 +32,7 @@ def grab_datasets(datasets: Union[TinyDB, str], data_type: str, phase: str, comp if data_type != 'Q' and data_type != 'D0': raise ValueError('Data type must be Q or D0') - if type(datasets) == str: + if isinstance(datasets, str): datasets = load_datasets(sorted(recursive_glob(datasets, '*.json')), include_disabled) components = list(set(components).union(set(['VA']))) From eee241fd676febd35989d261c477232112861ce0 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Fri, 21 Feb 2025 16:58:53 -0800 Subject: [PATCH 15/53] update 02_mcmc_optimization text --- examples/mobility_fitting/02_mcmc_optimization.ipynb | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/examples/mobility_fitting/02_mcmc_optimization.ipynb b/examples/mobility_fitting/02_mcmc_optimization.ipynb index d0f2052..23746e1 100644 --- a/examples/mobility_fitting/02_mcmc_optimization.ipynb +++ b/examples/mobility_fitting/02_mcmc_optimization.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -27,6 +27,8 @@ "dbf_input = 'databases/CuNi_mob_gen.tdb'\n", "dbf_output = 'databases/CuNi_mcmc.tdb'\n", "\n", + "# We set includeSubsystems to True to assess the endmember parameters as well. If we want to\n", + "# only free the mixing parameters, set this to False\n", "cu_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'CU', 'FCC_A1', includeSubsystems=True)\n", "ni_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'NI', 'FCC_A1', includeSubsystems=True)\n", "params = sorted(cu_params + ni_params)\n", @@ -294,7 +296,7 @@ "source": [ "### Uncertainty quantification\n", "\n", - "Since we have the trace files, we can compute the interdiffusivity for the sampled parameters to obtain 99% confidence intervals. Since we fixed the unary parameters, the uncertainty of the interdiffusivity goes to 0 as you approach pure Nb or pure Ti." + "Since we have the trace files, we can compute the interdiffusivity for the sampled parameters to obtain 95% confidence intervals." ] }, { From d3e7a6d0535fc275684cedd054cd0b97b7a1cd1a Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Mon, 24 Feb 2025 13:53:49 -0800 Subject: [PATCH 16/53] unit tests for mobility parameter generation --- .../01_parameter_generation.ipynb | 139 +- .../02_mcmc_optimization.ipynb | 26 +- .../databases/CuNi_manual_fit.tdb | 2 +- .../databases/CuNi_mob_gen.tdb | 38 +- .../mobility_fitting/error_functions/utils.py | 1 + kawin/mobility_fitting/fitting_steps.py | 23 +- kawin/mobility_fitting/generate.py | 5 +- kawin/mobility_fitting/liquid_mobility.py | 50 +- kawin/mobility_fitting/template.py | 32 +- kawin/mobility_fitting/utils.py | 32 +- kawin/tests/databases.py | 2507 ++++++++++++++++ kawin/tests/datasets.py | 2579 +---------------- kawin/tests/test_diffusion.py | 2 +- kawin/tests/test_mobility_generation.py | 220 ++ ...{test_fitting.py => test_mobility_mcmc.py} | 2 +- kawin/tests/test_precipitation.py | 2 +- kawin/tests/test_solver.py | 2 +- kawin/tests/test_surrogate.py | 2 +- kawin/tests/test_thermodynamics.py | 2 +- 19 files changed, 3080 insertions(+), 2586 deletions(-) create mode 100644 kawin/tests/databases.py create mode 100644 kawin/tests/test_mobility_generation.py rename kawin/tests/{test_fitting.py => test_mobility_mcmc.py} (99%) diff --git a/examples/mobility_fitting/01_parameter_generation.ipynb b/examples/mobility_fitting/01_parameter_generation.ipynb index 48c21b6..7b8b85c 100644 --- a/examples/mobility_fitting/01_parameter_generation.ipynb +++ b/examples/mobility_fitting/01_parameter_generation.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -96,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -219,15 +219,42 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from pycalphad import Database, variables as v\n", + "from kawin.mobility_fitting import generate_liquid_mobility_liu, LiuSpecies\n", + "from kawin.mobility_fitting import EquilibriumSiteFractionGenerator\n", + "\n", + "# Create mobility parameters using the Liu model\n", + "liu_species = [\n", + " LiuSpecies('CU', diameter=2.55, atomic_number=29, Tm=1358, melting_phase='FCC_A1'),\n", + " LiuSpecies('NI', diameter=2.49, atomic_number=28, Tm=1728, melting_phase='FCC_A1'),\n", + " ]\n", + "liu_templates = generate_liquid_mobility_liu(dbf, liu_species)\n", + "dbf.to_file('databases/CuNi_mob_gen.tdb', if_exists='overwrite')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could compare the models from Su et al and Liu et al to see how close the values are and what formst he models take" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Liquid mobility CU: (-46404.09216 - 137.295100407725*T)*LIQUID0NI + (-36468.03076 - 137.186121545147*T)*LIQUID0CU\n", - "Liquid mobility NI: (-46404.09216 - 137.097138674486*T)*LIQUID0NI + (-36468.03076 - 136.988159811907*T)*LIQUID0CU\n" + "Liu model for Cu: (-46404.09216 - 137.295100407725*T)*LIQUID0NI + (-36468.03076 - 137.186121545147*T)*LIQUID0CU\n", + "Su model for Cu: LIQUID0CU*(-26419.56408 + 8.314*T*log(7.223468281731e-10*T**0.5/(1 - 0.00303926198312384*T**0.5))) + LIQUID0NI*(-33617.82528 + 8.314*T*log(7.16032164165535e-10*T**0.5/(1 - 0.00269430125621825*T**0.5)))\n" ] }, { @@ -242,34 +269,26 @@ } ], "source": [ - "import matplotlib.pyplot as plt\n", - "from pycalphad import Database, variables as v\n", - "from kawin.mobility_fitting import generate_liquid_mobility_liu, LiuSpecies\n", "from kawin.mobility_fitting import generate_liquid_mobility_su, SuSpecies\n", - "from kawin.mobility_fitting import EquilibriumSiteFractionGenerator\n", - "\n", - "# Create mobility parameters using the Liu and Su model\n", - "liu_species = [\n", - " LiuSpecies('CU', diameter=2.55, atomic_number=29, Tm=1358, melting_phase='FCC_A1'),\n", - " LiuSpecies('NI', diameter=2.49, atomic_number=28, Tm=1728, melting_phase='FCC_A1'),\n", - " ]\n", - "liu_templates = generate_liquid_mobility_liu(dbf, liu_species, add_to_database=False)\n", "\n", + "# Create mobility parameters using the Su model\n", "su_species = [\n", " SuSpecies('CU', atomic_mass=63.55, density=8.96, Tm=1358),\n", " SuSpecies('NI', atomic_mass=58.69, density=8.90, Tm=1728),\n", "]\n", + "# We could disable adding the liquid mobility models to the database\n", "su_templates = generate_liquid_mobility_su(dbf, su_species, add_to_database=False)\n", "\n", - "# Add liquid mobility from the liu model to database and save database\n", - "for s, template in liu_templates.items():\n", - " print(f'Liquid mobility {s}: {template.MQ}')\n", - " template.add_to_database(dbf, {}, add_if_exists=False)\n", - "dbf.to_file('databases/CuNi_mob_gen.tdb', if_exists='overwrite')\n", + "print('Liu model for Cu: ', liu_templates['CU'].MQ)\n", + "print('Su model for Cu: ', su_templates['CU'].MQ)\n", "\n", "fig, ax = plt.subplots()\n", "colors = {'CU': 'C0', 'NI': 'C1'}\n", "conds = {v.T: 2000, v.P: 101325, v.X('NI'): (1e-3, 1-1e-3, 0.01)}\n", + "\n", + "# The SiteFractionGenerator object creates the sitefractions corresponding to \n", + "# a (phase, components, conditions) input. Since we have thermodynamic information\n", + "# of the Cu-Ni system, we could use the EquilibriumSiteFractionGenerator\n", "eqgen = EquilibriumSiteFractionGenerator(dbf)\n", "\n", "# Plot mobility from Liu and Su model\n", @@ -285,7 +304,6 @@ "ax.set_xlim([0, 1])\n", "ax.set_xlabel('X(Ni)')\n", "ax.legend()\n", - "\n", "plt.show()" ] }, @@ -297,27 +315,16 @@ "\n", "For cases where we don't have diffusion data for all endmembers, we can use the manual fitting module. An example of this would be fitting intermetallics or carbides, where the endmembers may not be thermodynamically stable, and diffusion data cannot be obtained.\n", "\n", - "The following will show how to manually fit the Cu mobility in the FCC_A1 phase. You may notice that the selected model is different that the one that Espei chooses. This is because in Espei, the endmembers are fitted first, followed by mixing parameters. In the manual fitting module, both the endmembers and mixing parameters are fit in a single step, so the endmember parameters are not fit strictly to just the endmember data." + "The following will show how to manually fit the Cu mobility in the FCC_A1 phase." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "from kawin.mobility_fitting import MobilityTemplate, plot_prefactor, plot_activation_energy\n", + "from kawin.mobility_fitting import MobilityTemplate\n", "from kawin.mobility_fitting.manual_fitting import grab_tracer_datasets, fit_prefactor, fit_activation_energy, select_best_model\n", "from kawin.mobility_fitting import EquilibriumSiteFractionGenerator\n", "\n", @@ -341,13 +348,51 @@ "t2.add_activation_energy([['CU', 'NI'], ['VA']], [0, 1])\n", "t2.add_prefactor([['CU', 'NI'], ['VA']], [0, 1])\n", "\n", - "fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n", - "conds = {v.T: 1673, v.P: 101325, v.X('NI'): (0, 1, 0.01)}\n", - "\n", "# Fit prefactor parameters to data\n", - "# Here, we use a AICC penalty factor of 0.5 (p=0.5 in select_best_model) to favor a higher order model\n", + "# Here, we could set the AICC penalty factor to 0.5 by setting p=0.5 in select_best_model\n", "d_data = grab_tracer_datasets('datasets', 'D0', phase, ['CU', 'NI', 'VA'], diffusing_species)\n", "d_model, d_results = select_best_model(d_data, [t0, t1, t2], fit_prefactor, eqgen, p=0.5, return_all_models = True)\n", + "\n", + "# Fit activation energy parameters to data\n", + "q_data = grab_tracer_datasets('datasets', 'Q', phase, ['CU', 'NI', 'VA'], diffusing_species)\n", + "q_model, q_results = select_best_model(q_data, [t0, t1, t2], fit_activation_energy, eqgen, return_all_models = True)\n", + "\n", + "# Add pre-factor and activation energy parameter to database and save\n", + "d_model.template.add_to_database(dbf, d_model.parameters)\n", + "q_model.template.add_to_database(dbf, q_model.parameters)\n", + "dbf.to_file('databases/CuNi_manual_fit.tdb', if_exists='overwrite')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could plot the different model templates to view how they fit the data and the AICC value. You may notice that the selected model is different that the one that Espei chooses (the manual fitting selects no mixing parameters while Espei selects a first ordered mixing term). This is because in Espei, the endmembers and mixing parameters are fitting in sequential order, where the data in binary Cu-Ni does not affect the endmember parameters. In the manual fitting module, both the endmembers and mixing parameters are fit in a single step, so the endmember parameters are affected by the binary data." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from kawin.mobility_fitting import plot_prefactor, plot_activation_energy\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n", + "conds = {v.T: 1673, v.P: 101325, v.X('NI'): (0, 1, 0.01)}\n", + "\n", + "# Plot prefactor for each template\n", "for i, res in enumerate(d_results):\n", " plot_prefactor(res.template, res.parameters, eqgen, conditions=conds, ax=ax[0], scale=1e4, label=f'Model {i}: AICC = {res.aicc:.3f}')\n", "plot_datasets(ax[0], 'D0', diffusing_species, scale=1e4)\n", @@ -355,22 +400,14 @@ "ax[0].set_yscale('log')\n", "ax[0].legend()\n", "\n", - "# Fit activation energy parameters to data\n", - "q_data = grab_tracer_datasets('datasets', 'Q', phase, ['CU', 'NI', 'VA'], diffusing_species)\n", - "q_model, q_results = select_best_model(q_data, [t0, t1, t2], fit_activation_energy, eqgen, return_all_models = True)\n", + "# Plot activation energy for each template\n", "for i, res in enumerate(q_results):\n", " plot_activation_energy(res.template, res.parameters, eqgen, conditions=conds, ax=ax[1], scale=1e-3, label=f'Model {i}: AICC = {res.aicc:.3f}')\n", "plot_datasets(ax[1], 'Q', diffusing_species, scale=1e-3)\n", "ax[1].set_ylabel('$Q_{Cu}$ (kJ/mol)')\n", "ax[1].legend()\n", "\n", - "# Add pre-factor and activation energy parameter to database and save\n", - "d_model.template.add_to_database(dbf, d_model.parameters)\n", - "q_model.template.add_to_database(dbf, q_model.parameters)\n", - "dbf.to_file('databases/CuNi_manual_fit.tdb', if_exists='overwrite')\n", - "\n", "fig.tight_layout()\n", - "\n", "plt.show()" ] }, diff --git a/examples/mobility_fitting/02_mcmc_optimization.ipynb b/examples/mobility_fitting/02_mcmc_optimization.ipynb index 23746e1..c583172 100644 --- a/examples/mobility_fitting/02_mcmc_optimization.ipynb +++ b/examples/mobility_fitting/02_mcmc_optimization.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -29,8 +29,8 @@ "\n", "# We set includeSubsystems to True to assess the endmember parameters as well. If we want to\n", "# only free the mixing parameters, set this to False\n", - "cu_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'CU', 'FCC_A1', includeSubsystems=True)\n", - "ni_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'NI', 'FCC_A1', includeSubsystems=True)\n", + "cu_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'CU', 'FCC_A1', include_subsystems=True)\n", + "ni_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'NI', 'FCC_A1', include_subsystems=True)\n", "params = sorted(cu_params + ni_params)\n", "\n", "input_settings = {\n", @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -114,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -188,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -301,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -362,12 +362,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Applying the assessed database to a diffusion simulation\n", + "\n", "Finally, now that we have an assessed database, we can simulate a diffusion couple." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -379,11 +381,11 @@ "100\t\t2.092e+01\t\t2.9\n", "200\t\t4.183e+01\t\t5.1\n", "300\t\t6.275e+01\t\t6.7\n", - "400\t\t8.366e+01\t\t8.0\n", + "400\t\t8.366e+01\t\t7.9\n", "500\t\t1.046e+02\t\t9.0\n", - "600\t\t1.255e+02\t\t10.0\n", - "700\t\t1.466e+02\t\t10.9\n", - "717\t\t1.500e+02\t\t11.0\n" + "600\t\t1.255e+02\t\t9.9\n", + "700\t\t1.466e+02\t\t10.7\n", + "717\t\t1.500e+02\t\t10.8\n" ] }, { diff --git a/examples/mobility_fitting/databases/CuNi_manual_fit.tdb b/examples/mobility_fitting/databases/CuNi_manual_fit.tdb index 742f939..f48109b 100644 --- a/examples/mobility_fitting/databases/CuNi_manual_fit.tdb +++ b/examples/mobility_fitting/databases/CuNi_manual_fit.tdb @@ -1,5 +1,5 @@ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ -$ Date: 2025-02-21 16:31 +$ Date: 2025-02-23 08:23 $ Components: CU, NI, VA $ Phases: FCC_A1, LIQUID $ Generated by ury3 (pycalphad 0.11.1.dev27+g2e830294) diff --git a/examples/mobility_fitting/databases/CuNi_mob_gen.tdb b/examples/mobility_fitting/databases/CuNi_mob_gen.tdb index ee83e87..4672654 100644 --- a/examples/mobility_fitting/databases/CuNi_mob_gen.tdb +++ b/examples/mobility_fitting/databases/CuNi_mob_gen.tdb @@ -1,5 +1,5 @@ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ -$ Date: 2025-02-21 16:30 +$ Date: 2025-02-23 08:23 $ Components: CU, NI, VA $ Phases: FCC_A1, LIQUID $ Generated by ury3 (pycalphad 0.11.1.dev27+g2e830294) @@ -25,18 +25,18 @@ FUNCTION GLIQCU 298.15 12964.735-5.8489E-21*T**(7)-9.511904*T+GHSERCU; 1357.77 Y -46.545-31.38*T*LOG(T)+173.881484*T; 3200.0 N ! FUNCTION GLIQNI 298.15 16414.686-3.82318E-21*T**(7)-9.397*T+GHSERNI; 1728.0 Y -9549.817-43.1*T*LOG(T)+268.597977*T; 3000.0 N ! -FUNCTION VV0000 1 -82.5275; 10000 N ! -FUNCTION VV0001 1 -205872.0; 10000 N ! -FUNCTION VV0002 1 -71.0695; 10000 N ! -FUNCTION VV0003 1 -232826.0; 10000 N ! -FUNCTION VV0004 1 -79.2647; 10000 N ! -FUNCTION VV0005 1 -255224.0; 10000 N ! -FUNCTION VV0006 1 -71.7851; 10000 N ! -FUNCTION VV0007 1 -285142.0; 10000 N ! -FUNCTION VV0008 1 13.9161; 10000 N ! -FUNCTION VV0009 1 -42473.8; 10000 N ! -FUNCTION VV0010 1 -31.3775; 10000 N ! -FUNCTION VV0011 1 43996.2; 10000 N ! +FUNCTION VV0000 1 -71.0695; 10000 N ! +FUNCTION VV0001 1 -232826.0; 10000 N ! +FUNCTION VV0002 1 -82.5275; 10000 N ! +FUNCTION VV0003 1 -205872.0; 10000 N ! +FUNCTION VV0004 1 -71.7851; 10000 N ! +FUNCTION VV0005 1 -285142.0; 10000 N ! +FUNCTION VV0006 1 -79.2647; 10000 N ! +FUNCTION VV0007 1 -255224.0; 10000 N ! +FUNCTION VV0008 1 -31.3775; 10000 N ! +FUNCTION VV0009 1 43996.2; 10000 N ! +FUNCTION VV0010 1 13.9161; 10000 N ! +FUNCTION VV0011 1 -42473.8; 10000 N ! TYPE_DEFINITION % SEQ * ! DEFINE_SYSTEM_DEFAULT ELEMENT 2 ! @@ -56,7 +56,7 @@ $ CU $ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ PARAMETER G(FCC_A1,CU:VA;0) 298.15 GHSERCU; 3200.0 N ! -PARAMETER MQ(FCC_A1&CU,CU:VA;0) 1 T*VV0000+VV0001; 10000 N ! +PARAMETER MQ(FCC_A1&CU,CU:VA;0) 1 T*VV0002+VV0003; 10000 N ! PARAMETER G(LIQUID,CU;0) 298.15 GLIQCU; 3200.0 N ! PARAMETER MQ(LIQUID&CU,CU;0) 1 -36468.03076-137.186121545147*T; 10000 N ! @@ -67,7 +67,7 @@ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 0.52; 3000.0 N ! PARAMETER G(FCC_A1,NI:VA;0) 298.15 GHSERNI; 3000.0 N ! -PARAMETER MQ(FCC_A1&NI,NI:VA;0) 1 T*VV0006+VV0007; 10000 N ! +PARAMETER MQ(FCC_A1&NI,NI:VA;0) 1 T*VV0004+VV0005; 10000 N ! PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633.0; 3000.0 N ! PARAMETER G(LIQUID,NI;0) 298.15 GLIQNI; 3000.0 N ! PARAMETER MQ(LIQUID&NI,NI;0) 1 -46404.09216-137.097138674486*T; 10000 N ! @@ -81,10 +81,10 @@ PARAMETER BMAGN(FCC_A1,CU,NI:VA;0) 298.15 -0.732; 3000.0 N ! PARAMETER BMAGN(FCC_A1,CU,NI:VA;1) 298.15 -0.317; 3000.0 N ! PARAMETER G(FCC_A1,CU,NI:VA;0) 298.15 8047.72+3.42217*T; 6000.0 N ! PARAMETER G(FCC_A1,CU,NI:VA;1) 298.15 -2041.3+0.99714*T; 6000.0 N ! -PARAMETER MQ(FCC_A1&NI,CU:VA;0) 1 T*VV0002+VV0003; 10000 N ! -PARAMETER MQ(FCC_A1&CU,NI:VA;0) 1 T*VV0004+VV0005; 10000 N ! -PARAMETER MQ(FCC_A1&CU,CU,NI:VA;0) 1 T*VV0008+VV0009; 10000 N ! -PARAMETER MQ(FCC_A1&NI,CU,NI:VA;0) 1 T*VV0010+VV0011; 10000 N ! +PARAMETER MQ(FCC_A1&NI,CU:VA;0) 1 T*VV0000+VV0001; 10000 N ! +PARAMETER MQ(FCC_A1&CU,NI:VA;0) 1 T*VV0006+VV0007; 10000 N ! +PARAMETER MQ(FCC_A1&CU,CU,NI:VA;0) 1 T*VV0010+VV0011; 10000 N ! +PARAMETER MQ(FCC_A1&NI,CU,NI:VA;0) 1 T*VV0008+VV0009; 10000 N ! PARAMETER TC(FCC_A1,CU,NI:VA;0) 298.15 -935.5; 3000.0 N ! PARAMETER TC(FCC_A1,CU,NI:VA;1) 298.15 -594.9; 3000.0 N ! PARAMETER G(LIQUID,CU,NI;0) 298.15 12048.61+1.29093*T; 6000.0 N ! diff --git a/kawin/mobility_fitting/error_functions/utils.py b/kawin/mobility_fitting/error_functions/utils.py index 2359f03..959b0f8 100644 --- a/kawin/mobility_fitting/error_functions/utils.py +++ b/kawin/mobility_fitting/error_functions/utils.py @@ -1,6 +1,7 @@ from pycalphad import Model, variables as v from pycalphad.codegen.phase_record_factory import PhaseRecordFactory from pycalphad.core.utils import extract_parameters + from kawin.thermo.Mobility import MobilityModel def get_output_base_name(output_name): diff --git a/kawin/mobility_fitting/fitting_steps.py b/kawin/mobility_fitting/fitting_steps.py index 8347aa1..757b061 100644 --- a/kawin/mobility_fitting/fitting_steps.py +++ b/kawin/mobility_fitting/fitting_steps.py @@ -1,14 +1,3 @@ -from espei.parameter_selection.fitting_steps import AbstractLinearPropertyStep, FittingStep -from pycalphad import Model, variables as v -import numpy as np -import symengine -from typing import Optional, Dict, Any, List -from numpy.typing import ArrayLike -from espei.utils import build_sitefractions -import itertools - -Dataset = Dict[str, Any] - ''' Fitting steps for Mobility models from tracer diffusivity data @@ -38,6 +27,18 @@ Then we could fit MQ as a linear model where each RK term is in the form of A+B*T NOTE: This method is not recommended since it can lead to overfitting ''' +import itertools +from typing import Optional, Dict, Any, List + +import numpy as np +from numpy.typing import ArrayLike +import symengine + +from pycalphad import Model, variables as v +from espei.parameter_selection.fitting_steps import AbstractLinearPropertyStep, FittingStep +from espei.utils import build_sitefractions + +Dataset = Dict[str, Any] class StepD0(FittingStep): supported_reference_states: List[str] = [""] diff --git a/kawin/mobility_fitting/generate.py b/kawin/mobility_fitting/generate.py index 5b81165..d4a0741 100644 --- a/kawin/mobility_fitting/generate.py +++ b/kawin/mobility_fitting/generate.py @@ -1,5 +1,4 @@ import json -import copy from tinydb import where @@ -81,6 +80,7 @@ def setup_mobility_fitting_description(diffusing_species, fit_to_tracer = False) to those values instead ''' steps = [] + print(diffusing_species) for e in diffusing_species: if fit_to_tracer: Dstar = type(f'Tracer_{e}', (StepTracerDiffusivity,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_DIFF_{e}'}) @@ -89,7 +89,6 @@ def setup_mobility_fitting_description(diffusing_species, fit_to_tracer = False) D0 = type(f'D0_{e}', (StepD0,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_D0_{e}'}) Q = type(f'Q_{e}', (StepQ,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_Q_{e}'}) steps += [D0, Q] - return ModelFittingDescription(steps, model=MobilityModel) def generate_mobility(phase_models, datasets, diffusing_species = None, ridge_alpha=None, aicc_penalty_factor=None, dbf=None, fit_to_tracer=False): @@ -116,7 +115,7 @@ def generate_mobility(phase_models, datasets, diffusing_species = None, ridge_al datasets = load_datasets(sorted(recursive_glob(datasets, '*.json'))) # Get non-VA components - components = list(set(phase_models['components']) - set(['VA'])) + components = sorted(list(set(phase_models['components']) - set(['VA']))) # If no diffusing species, then assume same as components if diffusing_species is None: diff --git a/kawin/mobility_fitting/liquid_mobility.py b/kawin/mobility_fitting/liquid_mobility.py index 2013d52..08744fb 100644 --- a/kawin/mobility_fitting/liquid_mobility.py +++ b/kawin/mobility_fitting/liquid_mobility.py @@ -1,5 +1,11 @@ +''' +Tools for generating liquid mobility models and adding them to a database + +TODO: this is only valid for liquid models with 1 sublattice. wo-sublattice ionic + liquid models are not supported yet +''' import numpy as np -from symengine import log +from symengine import Symbol, log from pycalphad import Database, variables as v @@ -54,6 +60,22 @@ def _get_liquid_phase_name(database): return ph return 'LIQUID' +def _generate_liquid_mobility(dbf: Database, parameters: dict[str, dict[str, Symbol]], add_to_database: bool = True) -> dict[str, MobilityTemplate]: + ''' + Creates liquid mobility templates and add to database + ''' + liq_name = _get_liquid_phase_name(dbf) + components = sorted(list(parameters.keys())) + templates = {c: MobilityTemplate(liq_name, c, [1], [components], False) for c in components} + for solute in parameters: + for solvent in parameters[solute]: + templates[solute].add_term([[solvent]], 0, parameters[solute][solvent]) + + if add_to_database: + templates[solute].add_to_database(dbf, {}) + + return templates + def generate_liquid_mobility_liu(dbf: Database, species: list[LiuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: ''' Species data will include {diameter, atomic_number, T_m, phase} @@ -75,21 +97,17 @@ def generate_liquid_mobility_liu(dbf: Database, species: list[LiuSpecies], add_t In a calphad database, this becomes MQ = -Q + R*T*ln(D0_AB) ''' - liq_name = _get_liquid_phase_name(dbf) - components = [s.name for s in species] - templates = {c: MobilityTemplate(liq_name, c, [1], [components], False) for c in components} # Solute is the diffusing species while solvent is the endmember component + parameters = {} for solute in species: + parameters[solute.name] = {} for solvent in species: Q = -0.17 * GAS_CONSTANT * solvent.Tm * (16 + solvent.K0) D0 = (8.95 - 0.0734 * solvent.atomic_number) * 1e-8 D0 *= solvent.diameter / solute.diameter - templates[solute.name].add_term([[solvent.name]], 0, Q + GAS_CONSTANT*np.log(D0)*v.T) + parameters[solute.name][solvent.name] = Q + GAS_CONSTANT*np.log(D0)*v.T - if add_to_database: - templates[solute.name].add_to_database(dbf, {}) - - return templates + return _generate_liquid_mobility(dbf, parameters, add_to_database) def generate_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_database: bool = True) -> dict[str, MobilityTemplate]: ''' @@ -130,12 +148,10 @@ def generate_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_ C2 = 2.34 R0 = 0.644e-10 - liq_name = _get_liquid_phase_name(dbf) - components = [s.name for s in species] - templates = {c: MobilityTemplate(liq_name, c, [1], [components], False) for c in components} # Solute is the diffusing species while solvent is the endmember component + parameters = {} for solute in species: - models = [] + parameters[solute.name] = {} for solvent in species: rho_solv = solvent.density rho_solu = solute.density @@ -152,10 +168,6 @@ def generate_liquid_mobility_su(dbf: Database, species: list[SuSpecies], add_to_ D3 = BOLTZMANN_CONSTANT / (4*np.pi) D0 = D3/(D1*D2) * v.T**(1/2) / (1 - 0.112 * (v.T / solvent.Tm)**(1/2)) - templates[solute.name].add_term([[solvent.name]], 0, Q + GAS_CONSTANT*log(D0)*v.T) - - if add_to_database: - templates[solute.name].add_to_database(dbf, {}) - - return templates + parameters[solute.name][solvent.name] = Q + GAS_CONSTANT*log(D0)*v.T + return _generate_liquid_mobility(dbf, parameters, add_to_database) diff --git a/kawin/mobility_fitting/template.py b/kawin/mobility_fitting/template.py index 7619227..3de81f8 100644 --- a/kawin/mobility_fitting/template.py +++ b/kawin/mobility_fitting/template.py @@ -400,20 +400,26 @@ def evaluate(self, function: Basic, parameter_values: dict[Symbol, float], site_ dependent_var: dependent condition ''' dependent_var = [key for key, val in conditions.items() if len(np.atleast_1d(val)) > 1] - if len(dependent_var) != 1: + # Single point condition, then return evaluated function + if len(dependent_var) == 0: + site_fractions = site_fraction_generator.generate_site_fractions(self.phase, self.elements, conditions) + y = _eval_symengine_expr(function, {**site_fractions, **parameter_values, **conditions}) + return y + # If 1 dependent variable, then return coordinates of dependent variable (x), evaluated function (y), and variable + elif len(dependent_var) == 1: + dependent_vals = conditions[dependent_var[0]] + xs = np.linspace(dependent_vals[0], dependent_vals[1], int((dependent_vals[1] - dependent_vals[0])/dependent_vals[2])) + ys = np.zeros(len(xs)) + for i,x in enumerate(xs): + new_conds = {v.N: 1, v.P: 101325, v.GE: 0, v.T: 298.15} + new_conds.update({**conditions}) + new_conds[dependent_var[0]] = x + site_fractions = site_fraction_generator.generate_site_fractions(self.phase, self.elements, new_conds) + ys[i] = _eval_symengine_expr(function, {**site_fractions, **parameter_values, **new_conds}) + + return xs, ys, dependent_var[0] + else: raise ValueError(f"Number of free conditions must be 1, but is {len(dependent_var)}") - - dependent_vals = conditions[dependent_var[0]] - xs = np.linspace(dependent_vals[0], dependent_vals[1], int((dependent_vals[1] - dependent_vals[0])/dependent_vals[2])) - ys = np.zeros(len(xs)) - for i,x in enumerate(xs): - new_conds = {v.N: 1, v.P: 101325, v.GE: 0, v.T: 298.15} - new_conds.update({**conditions}) - new_conds[dependent_var[0]] = x - site_fractions = site_fraction_generator.generate_site_fractions(self.phase, self.elements, new_conds) - ys[i] = _eval_symengine_expr(function, {**site_fractions, **parameter_values, **new_conds}) - - return xs, ys, dependent_var[0] def add_to_database(self, dbf: Database, parameter_values: dict[Union[Symbol, str], float], add_if_exists=True): ''' diff --git a/kawin/mobility_fitting/utils.py b/kawin/mobility_fitting/utils.py index a317114..5181031 100644 --- a/kawin/mobility_fitting/utils.py +++ b/kawin/mobility_fitting/utils.py @@ -4,7 +4,7 @@ from pycalphad import Database, variables as v from espei.utils import database_symbols_to_fit -def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, includeSubsystems = False): +def get_used_database_symbols(dbf, elements, diffusing_species, phases = None, include_subsystems = False): ''' Given the database, grab all symbols that pertain only to the given elements and phases @@ -23,40 +23,38 @@ def get_used_database_symbols(dbf, elements, diffusingSpecies, phases = None, in dbf : Database elements : list[str] Symbols will be taken from parameters that have all elements in the constituents - diffusingSpecies : str + diffusing_species : str Name of diffusing species phases : list[str] (optional) Default = None Symbols will be taken from parameters attributed to the phases If None, all phases will be considered - includeSubsystems : bool (optional) + include_subsystems : bool (optional) Default = False If True, then symbols will also be taken from parameters where constituents is a subset of elements ''' if not isinstance(dbf, Database): dbf = Database(dbf) elements = sorted([e.upper() for e in elements]) - numElements = len(elements) - elSet = frozenset(elements + ['VA']) - usedSyms = frozenset() + num_elements = len(elements) + element_set = frozenset(elements + ['VA']) + used_syms = frozenset() for p in dbf._parameters: if phases is not None: if p['phase_name'] not in phases: continue - parameterSpecies = frozenset([s.name for c in p['constituent_array'] for s in c]) + parameter_species = frozenset([s.name for c in p['constituent_array'] for s in c]) #Add symbols under 2 conditions # 1. parameterSpecies is a subset of elSet # 2. freeSub is False and length of parameter species (excluding VA) is equal to number of elements - pIsSubset = len((parameterSpecies-set(['VA','*'])) - elSet) == 0 - shouldBeFree = includeSubsystems or len(parameterSpecies - set(['VA', '*'])) == numElements - isDiffusingSpecies = p['diffusing_species'].name == diffusingSpecies - if pIsSubset and shouldBeFree and isDiffusingSpecies: - usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) - #if len(parameterSpecies - elSet) == 0: - # usedSyms = usedSyms.union(frozenset([s.name for s in p['parameter'].free_symbols])) - allSyms = database_symbols_to_fit(dbf) - usedSyms = sorted(list(usedSyms.intersection(frozenset(allSyms)))) - return usedSyms + p_is_subset = len((parameter_species-set(['VA','*'])) - element_set) == 0 + should_be_free = include_subsystems or len(parameter_species - set(['VA', '*'])) == num_elements + is_diffusing_species = p['diffusing_species'].name == diffusing_species + if p_is_subset and should_be_free and is_diffusing_species: + used_syms = used_syms.union(frozenset([s.name for s in p['parameter'].free_symbols])) + all_syms = database_symbols_to_fit(dbf) + used_syms = sorted(list(used_syms.intersection(frozenset(all_syms)))) + return used_syms def _vname(index: int) -> str: ''' diff --git a/kawin/tests/databases.py b/kawin/tests/databases.py new file mode 100644 index 0000000..05478be --- /dev/null +++ b/kawin/tests/databases.py @@ -0,0 +1,2507 @@ +''' +Databases for unit testing +''' + +ALZR_TDB = """ +$Al-Zr database +$From T. Wang, Z. Jin, J. Zhao, Journal of Phase Equilibria, 22 (2001) p. 544 +$ +TEMP_LIM 298.15 6000 ! +$Element Standard state mass [g/mol] H_298 S_298 +ELEMENT /- ELECTRON_GAS 0.0 0.0 0.0 ! +ELEMENT VA VACUUM 0.0000E+00 0.0000E+00 0.0000E+00 ! +ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01 ! +ELEMENT ZR HCP_A3 9.1224E+01 5.5663E+03 3.9181E+01 ! +$ +$ + TYPE_DEFINITION % SEQ *! +$ +$PHASE AL3ZR +PHASE AL3ZR % 2 0.75 0.25 ! +CONST AL3ZR : AL : ZR : ! +$ +$PHASE FCC_A1 +PHASE FCC_A1 % 2 1 1 ! +CONST FCC_A1 : AL%,ZR : VA : ! +$ +$ +$ +$ +$UNARY DATA +$ +$AL (FCC_A1) +FUNCTION GHSERAL 298.15 -7976.15+137.093038*T-24.3671976*T*LOG(T) + -1.884662E-3*T**2-0.877664E-6*T**3+74092*T**(-1); + 700.00 Y -11276.24+223.048446*T-38.5844296*T*LOG(T) + +18.531982E-3*T**2-5.764227E-6*T**3+74092*T**(-1); + 933.47 Y -11278.378+188.684153*T-31.748192*T*LOG(T) + -1230.524E25*T**(-9); 2900.00 N ! +$ +$ ZIRCONIUM (GHSERZR FOR HCP_A3) +$ +FUNCTION GHSERZR 130.00 -7827.595+125.64905*T-24.1618*T*LOG(T) + -4.37791E-3*T**2+34971*T**(-1); + 2128.00 Y -26085.921+262.724183*T-42.144*T*LOG(T) + -1342.895E28*T**(-9); 6000.00 N ! + +$ +$ PHASE FCC_A1 +$ +PARAMETER G(FCC_A1,AL:VA;0) 298.15 GHSERAL; 6000.00 N ! +PARAMETER G(FCC_A1,ZR:VA;0) 298.15 7600.00-0.9*T+GHSERZR; 6000.00 N ! +PARAMETER G(FCC_A1,AL,ZR:VA;0) 298.15 -152947+21.3*T; 6000.00 N ! + +$ +$ PHASE AL3ZR +$ +PARAMETER G(AL3ZR,AL:ZR;0) 298.15 -47381 - 24.373*T + 3.894*T*LOG(T) + +0.75*GHSERAL+0.25*GHSERZR; 6000.00 N ! + +$ +$ Diffusion parameters +$ +PARAMETER DF(FCC_A1&ZR,*:VA;0) 298.15 -2.56655 * 8.314 * T; 6000 N ! +PARAMETER DQ(FCC_A1&ZR,*:VA;0) 298.15 -242000; 6000 N ! +""" + +ALZR_TDB_NO_MOB = """ +$Al-Zr database without any mobility parameters +$From T. Wang, Z. Jin, J. Zhao, Journal of Phase Equilibria, 22 (2001) p. 544 +$ +TEMP_LIM 298.15 6000 ! +$Element Standard state mass [g/mol] H_298 S_298 +ELEMENT /- ELECTRON_GAS 0.0 0.0 0.0 ! +ELEMENT VA VACUUM 0.0000E+00 0.0000E+00 0.0000E+00 ! +ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01 ! +ELEMENT ZR HCP_A3 9.1224E+01 5.5663E+03 3.9181E+01 ! +$ +$ + TYPE_DEFINITION % SEQ *! +$ +$PHASE AL3ZR +PHASE AL3ZR % 2 0.75 0.25 ! +CONST AL3ZR : AL : ZR : ! +$ +$PHASE FCC_A1 +PHASE FCC_A1 % 2 1 1 ! +CONST FCC_A1 : AL%,ZR : VA : ! +$ +$ +$ +$ +$UNARY DATA +$ +$AL (FCC_A1) +FUNCTION GHSERAL 298.15 -7976.15+137.093038*T-24.3671976*T*LOG(T) + -1.884662E-3*T**2-0.877664E-6*T**3+74092*T**(-1); + 700.00 Y -11276.24+223.048446*T-38.5844296*T*LOG(T) + +18.531982E-3*T**2-5.764227E-6*T**3+74092*T**(-1); + 933.47 Y -11278.378+188.684153*T-31.748192*T*LOG(T) + -1230.524E25*T**(-9); 2900.00 N ! +$ +$ ZIRCONIUM (GHSERZR FOR HCP_A3) +$ +FUNCTION GHSERZR 130.00 -7827.595+125.64905*T-24.1618*T*LOG(T) + -4.37791E-3*T**2+34971*T**(-1); + 2128.00 Y -26085.921+262.724183*T-42.144*T*LOG(T) + -1342.895E28*T**(-9); 6000.00 N ! + +$ +$ PHASE FCC_A1 +$ +PARAMETER G(FCC_A1,AL:VA;0) 298.15 GHSERAL; 6000.00 N ! +PARAMETER G(FCC_A1,ZR:VA;0) 298.15 7600.00-0.9*T+GHSERZR; 6000.00 N ! +PARAMETER G(FCC_A1,AL,ZR:VA;0) 298.15 -152947+21.3*T; 6000.00 N ! + +$ +$ PHASE AL3ZR +$ +PARAMETER G(AL3ZR,AL:ZR;0) 298.15 -47381 - 24.373*T + 3.894*T*LOG(T) + +0.75*GHSERAL+0.25*GHSERZR; 6000.00 N ! +""" + +NICRAL_TDB = """ + +$ The parameters of the following database follows the publication +$ N. Dupin, I. Ansara, Thermodynamic Re-Assessment of the Ternary System +$ Al-Cr-Ni, Calphad, 25 (2), 279-298 (2001). +$ + +$Element Standard state mass [g/mol] H_298 S_298 + ELEMENT /- ELECTRON_GAS .0000E+00 .0000E+00 .0000E+00! + ELEMENT VA VACUUM .0000E+00 .0000E+00 .0000E+00! + ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01! + ELEMENT CR BCC_A2 5.1996E+01 4.0500E+03 2.3560E+01! + ELEMENT NI FCC_A1 5.8690E+01 4.7870E+03 2.9796E+01! + + SPECIES AL2 AL2! + SPECIES CR2 CR2! + SPECIES NI2 NI2! + + + FUNCTION UNASS 298.15 0;,,N ! + + + TYPE_DEFINITION % SEQ *! + DEFINE_SYSTEM_DEFAULT E 2 ! + DEFAULT_COMMAND DEF_SYS_ELEMENT VA ! + DEFAULT_COMMAND REJECT_PHASE NEWSIGMA ! + + DATABASE_INFO ''' + BASE TC-Ni, version 29-09-99' + + ' + ELEMENTS : Al, Cr, Ni' + ' + ASSESSED SYSTEMS :' + ' + BINARIES' + Al-Cr, Al-Ni, Cr-Ni' + TERNARIES' + Al-Cr-Ni' +' + MODELLING ORDER/DISORDER:' +' + A1 and L12 phases are modelled with a single Gibbs energy curve.' + They are FCC_L12#1 (A1) based on (Ni) and FCC_L12#2 (L12) based on' + Ni3Al, differing by their site occupation.' + The same type of relation exists for the A2 and B2 phases. There are' + several possible sets for the phase named BCC_B2. They are either' + disordered (A2) and correspond to the solid solution based on Cr,' + or ordered based on the B2 compound AlNi.' + ! + +ASSESSED_SYSTEMS + AL-CR(;G5 MAJ:BCC_B2/CR:CR:VA ;P3 STP:.75/1200/1) + AL-NI(;P3 STP:.75/1200/1) + CR-NI(;G5 MAJ:BCC_B2/CR:CR:VA C_S:BCC_B2/NI:NI:VA + ;P3 STP:.5/1200/2) + ! + + TYPE_DEFINITION A GES A_P_D FCC_L12 MAGNETIC -3.0 .28 ! + TYPE_DEFINITION E GES A_P_D FCC_A1 MAGNETIC -3.0 .28 ! + TYPE_DEFINITION B GES A_P_D BCC_B2 MAGNETIC -1.0 .40 ! + TYPE_DEFINITION F GES A_P_D BCC_A2 MAGNETIC -1.0 .40 ! + + TYPE_DEFINITION C GES A_P_D BCC_B2 DIS_PART BCC_A2 ! + TYPE_DEFINITION D GES A_P_D FCC_L12 DIS_PART FCC_A1 ! + +$ TYPE_DEFINITION G GES A_P_D FCC_L12 C_S 2 NI:AL:VA ! +$ TYPE_DEFINITION G GES A_P_D FCC_L12 MAJ 1 NI:NI:VA ! +$ TYPE_DEFINITION W GES A_P_D BCC_B2 C_S,, NI:AL:VA ! +$ TYPE_DEFINITION W GES A_P_D BCC_B2 MAJ 1 CR:CR:VA ! + + PHASE GAS:G % 1 1.0 ! + CONST GAS:G :AL,AL2,CR,CR2,NI,NI2 : ! + + PHASE LIQUID:L % 1 1.0 ! + CONST LIQUID:L :AL,CR,NI : ! + + PHASE FCC_A1 %E 2 1 1 ! + CONST FCC_A1 :AL,CR,NI% : VA% : ! + + PHASE BCC_A2 %F 2 1 3 ! + CONST BCC_A2 :AL,CR%,NI,VA : VA : ! + + PHASE HCP_A3 %A 2 1 .5 ! + CONST HCP_A3 :AL,CR,NI : VA% : ! + + PHASE BCC_B2 %BC 3 .5 .5 3 ! + CONST BCC_B2 :AL,CR,NI%,VA : AL%,CR,NI,VA : VA: ! + + PHASE FCC_L12 %AD 3 .75 .25 1 ! + CONST FCC_L12 :AL,CR,NI : AL,CR,NI : VA : ! + + + PHASE C14_LAVES % 2 2.0 1.0 ! + CONST C14_LAVES : AL,CR%,NI : AL,CR,NI : ! + + PHASE C15_LAVES % 2 2.0 1.0 ! + CONST C15_LAVES : AL,CR%,NI : AL,CR,NI : ! + + PHASE C36_LAVES % 2 2.0 1.0 ! + CONST C36_LAVES : AL,CR%,NI : AL,CR,NI : ! + + PHASE SIGMA % 3 8 4 18 ! + CONSTITUENT SIGMA :AL,NI : CR : AL,CR%,NI : ! + + PHASE NEWSIGMA % 3 10 4 16 ! + CONSTITUENT NEWSIGMA :AL,NI : CR : AL,CR,NI : ! + + PHASE CHI_A12 % 3 24 10 24 ! + CONST CHI_A12 :CR,NI : CR : CR,NI : ! + + PHASE MTI2 % 2 1.0 2.0 ! + CONST MTI2 : CR,NI% : AL,CR,NI : ! + + + FUNCTION ZERO 298.15 0;,,N ! + FUNCTION DP 298.15 +P-101325;,,N ! + FUNCTION TROIS 298.15 3;,,N ! + FUNCTION UNTIER 298.15 TROIS**(-1);,,N ! + +$**************************************************************************** +$ +$ UNARY PARAMETERS +$ +$---------------------------------------------------------------------------- +$ +$ Al +$ +$ FUNCTIONS +$ + FUNCTION F154T 298.15 + +323947.58-25.1480943*T-20.859*T*LN(T) + +4.5665E-05*T**2-3.942E-09*T**3-24275.5*T**(-1); + 4300.0 Y + +342017.233-54.0526109*T-17.7891*T*LN(T)+6.822E-05*T**2 + -1.91111667E-08*T**3-14782200*T**(-1); + 8200.0 Y + +542396.07-411.214335*T+22.2419*T*LN(T)-.00349619*T**2 + +4.0491E-08*T**3-2.0366965E+08*T**(-1); 1.00000E+04 N ! +$ + FUNCTION F625T 298.15 + +496408.232+35.479739*T-41.6397*T*LN(T) + +.00249636*T**2-4.90507333E-07*T**3+85390.3*T**(-1); + 900.00 Y + +497613.221+17.368131*T-38.85476*T*LN(T)-2.249805E-04*T**2 + -9.49003167E-09*T**3-5287.23*T**(-1); 2.80000E+03 N ! +$ + FUNCTION GHSERAL 298.15 + -7976.15+137.093038*T-24.3671976*T*LN(T) + -.001884662*T**2-8.77664E-07*T**3+74092*T**(-1); + 700.00 Y + -11276.24+223.048446*T-38.5844296*T*LN(T) + +.018531982*T**2-5.764227E-06*T**3+74092*T**(-1); + 933.60 Y + -11278.378+188.684153*T-31.748192*T*LN(T) + -1.231E+28*T**(-9);,, N ! +$ + FUNCTION GHCPAL 298.15 +5481-1.8*T+GHSERAL;,,N ! +$ + FUNCTION GBCCAL 298.15 +10083-4.813*T+GHSERAL;,,N ! +$ + FUNCTION GLIQAL 298.14 + +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; + 933.59 Y + +10482.282-11.253974*T+1.231E+28*T**(-9)+GHSERAL;,,N ! +$ +$ GAS PHASE +$ + PARAMETER G(GAS,AL;0) 298.15 +F154T+R*T*LN(1E-05*P);,,N REF184 ! + PARAMETER G(GAS,AL2;0) 298.15 +F625T+R*T*LN(1E-05*P);,,N REF448 ! +$ +$ LIQUID PHASE +$ + PARAMETER G(LIQUID,AL;0) 298.13 + +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; + 933.60 Y + +10482.382-11.253974*T+1.231E+28*T**(-9) + +GHSERAL;,,N 91DIN ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,AL:VA;0) 298.15 +GHSERAL;,,N 91DIN ! +$ +$ BCC_A2 PHASE +$ + PARAMETER G(BCC_A2,AL:VA;0) 298.15 +GBCCAL;,,N 91DIN ! + FUNC B2ALVA 295.15 10000-T;,,N ! + FUNC LB2ALVA 298.15 150000;,,N ! + PARAMETER L(BCC_A2,AL,VA:VA;0) 298.15 B2ALVA+LB2ALVA;,,N 99DUP ! +$ +$ HCP_A3 PHASE +$ + PARAMETER G(HCP_A3,AL:VA;0) 298.15 +GHCPAL;,,N 91DIN ! +$ +$ BCC_B2 PHASE +$ + PARAMETER G(BCC_B2,AL:VA:VA;0) 298.15 .5*B2ALVA-.5*LB2ALVA;,,N 99DUP ! + PARAMETER G(BCC_B2,VA:AL:VA;0) 298.15 .5*B2ALVA-.5*LB2ALVA;,,N 99DUP ! +$ +$ ALTI_L10 PHASE +$ + PARAMETER G(ALTI_L10,AL:AL;0) 298.15 2*GHSERAL+4;,,N COST507 ! +$ +$ ALTI3_DO19 PHASE +$ + PARAMETER G(ALTI3_DO19,AL:AL;0) 298.15 +4*GHCPAL;,,N COST507 ! +$ +$ C14_LAVES PHASE +$ + PARAMETER G(C14_LAVES,AL:AL;0) 298.15 +3*GHSERAL+15000;,,N 95DUP8 ! +$ +$ C15_LAVES PHASE +$ + PARAMETER G(C15_LAVES,AL:AL;0) 298.15 +3*GHSERAL+15000;,,N REFLAV ! +$ +$ C36_LAVES PHASE +$ + PARAMETER G(C36_LAVES,AL:AL;0) 298.15 +3*GHSERAL+15000;,,N REFLAV ! +$ +$ H_L21 PHASE +$ + PARAMETER G(H_L21,AL:AL:VA;0) 298.15 +10000-T+GBCCAL;,,N 95DUP8 ! +$ +$ NI3TI_DO24 PHASE +$ + PARAMETER G(NI3TI_DO24,AL:AL;0) 298.15 GHCPAL;,,N 95DUP8 ! +$ +$---------------------------------------------------------------------------- +$ +$ Cr +$ +$ FUNCTIONS +$ + FUNCTION F7454T 298.15 + +390765.331-31.5192154*T-21.36083*T*LN(T) + +7.253215E-04*T**2-1.588679E-07*T**3+10285.15*T**(-1); + 1100.0 Y + +393886.928-44.107465*T-19.96003*T*LN(T)+.001513089*T**2 + -4.23648333E-07*T**3-722515*T**(-1); + 2000.0 Y + +421372.003-231.888524*T+5.362886*T*LN(T)-.00848877*T**2 + +2.984635E-07*T**3-6015405*T**(-1); + 3300.0 Y + +305164.698+251.019831*T-55.20304*T*LN(T)+.005324585*T**2 + -2.850405E-07*T**3+34951485*T**(-1); + 5100.0 Y + +1069921.1-1708.93262*T+175.0508*T*LN(T)-.025574185*T**2 + +4.94447E-07*T**3-4.4276355E+08*T**(-1); + 7600.0 Y + -871952.838+1686.47356*T-204.5589*T*LN(T)+.007475225*T**2 + -4.618745E-08*T**3+1.423504E+09*T**(-1); 1.00000E+04 N ! +$ + FUNCTION F7735T 298.15 +598511.402+41.5353219*T-40.56798*T*LN(T) + +.004961847*T**2-1.61216717E-06*T**3+154422.85*T**(-1); + 800.00 Y + +613345.232-104.20799*T-19.7643*T*LN(T)-.007085085*T**2 + -4.69883E-07*T**3-1738066.5*T**(-1); + 1400.0 Y + +642608.843-369.286259*T+17.64743*T*LN(T)-.02767321*T**2 + +1.605906E-06*T**3-5831655*T**(-1); + 2300.0 Y + +553119.895+159.188556*T-52.07969*T*LN(T)-.004229401*T**2 + +1.5939925E-07*T**3+14793625*T**(-1); + 3900.0 Y + +347492.339+623.137624*T-105.0428*T*LN(T)+3.9699545E-04*T**2 + +1.51783483E-07*T**3+1.4843765E+08*T**(-1); + 5800.0 Y + -484185.055+2598.25559*T-334.7145*T*LN(T)+.028597625*T**2 + -4.97520167E-07*T**3+7.135805E+08*T**(-1); 6.00000E+03 N ! +$ + FUNCTION GHSERCR 298.14 + -8856.94+157.48*T-26.908*T*LN(T) + +.00189435*T**2-1.47721E-06*T**3+139250*T**(-1); + 2180.0 Y + -34869.344+344.18*T-50*T*LN(T)-2.88526E+32*T**(-9);,,N ! +$ + FUNCTION GCRLIQ 298.15 + +24339.955-11.420225*T+2.37615E-21*T**7+GHSERCR; + 2180.0 Y + -16459.984+335.616316*T-50*T*LN(T);,,N ! +$ + FUNCTION GFCCCR 298.15 +7284+.163*T+GHSERCR;,,N ! +$ + FUNCTION GHCPCR 298.15 +4438+GHSERCR;,,N ! +$ + FUNCTION ACRBCC 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! + FUNCTION BCRBCC 298.15 +1+2.6E-11*P;,,N ! + FUNCTION CCRBCC 298.15 2.08E-11;,,N ! + FUNCTION DCRBCC 298.15 +1*LN(BCRBCC);,,N ! + FUNCTION VCRBCC 298.15 +7.188E-06*EXP(ACRBCC);,,N ! + FUNCTION ECRBCC 298.15 +1*LN(CCRBCC);,,N ! + FUNCTION XCRBCC 298.15 +1*EXP(.8*DCRBCC)-1;,,N ! + FUNCTION YCRBCC 298.15 +VCRBCC*EXP(-ECRBCC);,,N ! + FUNCTION ZCRBCC 298.15 +1*LN(XCRBCC);,,N ! + FUNCTION GPCRBCC 298.15 +YCRBCC*EXP(ZCRBCC);,,N ! +$ + FUNCTION ACRLIQ 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! + FUNCTION BCRLIQ 298.15 +1+4.65E-11*P;,,N ! + FUNCTION CCRLIQ 298.15 3.72E-11;,,N ! + FUNCTION DCRLIQ 298.15 +1*LN(BCRLIQ);,,N ! + FUNCTION VCRLIQ 298.15 +7.653E-06*EXP(ACRLIQ);,,N ! + FUNCTION ECRLIQ 298.15 +1*LN(CCRLIQ);,,N ! + FUNCTION XCRLIQ 298.15 +1*EXP(.8*DCRLIQ)-1;,,N ! + FUNCTION YCRLIQ 298.15 +VCRLIQ*EXP(-ECRLIQ);,,N ! + FUNCTION ZCRLIQ 298.15 +1*LN(XCRLIQ);,,N ! + FUNCTION GPCRLIQ 298.15 +YCRLIQ*EXP(ZCRLIQ);,,N ! +$ +$ GAS PHASE +$ + PARAMETER G(GAS,CR;0) 298.15 +F7454T+R*T*LN(1E-05*P);,,N REF4465 ! + PARAMETER G(GAS,CR2;0) 298.15 +F7735T+R*T*LN(1E-05*P);,, N REF4591 ! +$ +$ LIQUID PHASE +$ + PARAMETER G(LIQUID,CR;0) 298.15 +GCRLIQ+GPCRLIQ;,, N 91DIN ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,CR:VA;0) 298.15 +GFCCCR+GPCRBCC;,,N 89DIN ! + PARAMETER TC(FCC_A1,CR:VA;0) 298.15 -1109;,,N 89DIN ! + PARAMETER BMAGN(FCC_A1,CR:VA;0) 298.15 -2.46;,,N 89DIN ! +$ +$ BCC_A2 PHASE +$ + PARAMETER G(BCC_A2,CR:VA;0) 298.15 +GHSERCR+GPCRBCC;,,N 91DIN ! + PARAMETER TC(BCC_A2,CR:VA;0) 298.15 -311.5;,,N 89DIN ! + PARAMETER BMAGN(BCC_A2,CR:VA;0) 298.15 -.008;,,N 89DIN ! + PARAMETER L(BCC_A2,CR,VA:VA;0) 298.15 100000;,,N 99DUP6 ! +$ +$ HCP_A3 PHASE +$ + PARAMETER G(HCP_A3,CR:VA;0) 298.15 +GHCPCR;,,N 91DIN ! + PARAMETER TC(HCP_A3,CR:VA;0) 298.15 -1109;,,N 89DIN ! + PARAMETER BMAGN(HCP_A3,CR:VA;0) 298.15 -2.46;,,N 89DIN ! +$ +$ BCC_B2 PHASE +$ + PARAMETER G(BCC_B2,CR:VA:VA;0) 298.15 0;,,N 99DUP6 ! + PARAMETER G(BCC_B2,VA:CR:VA;0) 298.15 0;,,N 99DUP6 ! +$ +$ CHI_A12 PHASE +$ + PARAMETER G(CHI_A12,CR:CR:CR;0) 298.15 + +48*GFCCCR+10*GHSERCR+109000+123*T;,,N 87GUS ! +$ +$ ALTI3_DO19 PHASE +$ + PARAMETER G(ALTI3_DO19,CR:CR;0) 298.15 +4*GHCPCR;,,N COST507 ! +$ +$ C14_LAVES PHASE +$ + PARAMETER G(C14_LAVES,CR:CR;0) 298.15 +3*GHSERCR+15000;,,N REFLAV ! +$ +$ C15_LAVES PHASE +$ + PARAMETER G(C15_LAVES,CR:CR;0) 298.15 +3*GHSERCR+15000;,,N REFLAV ! +$ +$ C36_LAVES PHASE +$ + PARAMETER G(C36_LAVES,CR:CR;0) 298.15 +3*GHSERCR+15000;,,N REFLAV ! +$ +$ MTI2 PHASE +$ + PARAMETER G(MTI2,CR:CR;0) 298.15 3*GHSERCR+15000;,,N 99DUP9 ! +$ +$ NI3TI_DO24 PHASE +$ + PARAMETER G(NI3TI_DO24,CR:CR;0) 298.15 GHCPCR;,,N 95DUP9 ! +$ +$ ALTI_L10 PHASE +$ + PARAMETER G(ALTI_L10,CR:CR;0) 298.15 2*GFCCCR;,,N COST507 ! +$ +$---------------------------------------------------------------------------- +$ +$ Ni +$ +$ FUNCTIONS +$ + FUNCTION F13191T 298.15 + +417658.868-44.7777921*T-20.056*T*LN(T) + -.0060415*T**2+1.24774E-06*T**3-16320*T**(-1); + 800.00 Y + +413885.448+9.41787679*T-28.332*T*LN(T)+.00173115*T**2 + -8.399E-08*T**3+289050*T**(-1); + 3900.0 Y + +440866.732-62.5810038*T-19.819*T*LN(T)+5.067E-04*T**2 + -4.93233333E-08*T**3-15879735*T**(-1); + 7600.0 Y + +848806.287-813.398164*T+64.69*T*LN(T)-.00731865*T**2 + +8.71833333E-08*T**3-3.875846E+08*T**(-1); 10000. N ! +$ + FUNCTION F13265T 298.15 + +638073.279-68.1901928*T-24.897*T*LN(T) + -.0313584*T**2+5.93355333E-06*T**3-14215*T**(-1); + 800.00 Y + +611401.772+268.084821*T-75.25401*T*LN(T)+.01088525*T**2 + -7.08741667E-07*T**3+2633835*T**(-1); + 2100.0 Y + +637459.339+72.0712678*T-48.587*T*LN(T)-9.09E-05*T**2 + +9.12933333E-08*T**3-1191755*T**(-1); + 4500.0 Y + +564540.781+329.599011*T-80.11301*T*LN(T)+.00578085*T**2 + -1.08841667E-07*T**3+29137900*T**(-1); 6000.0 N ! +$ + FUNCTION GHSERNI 298.14 + -5179.159+117.854*T-22.096*T*LN(T) + -.0048407*T**2; + 1728.0 Y + -27840.655+279.135*T-43.1*T*LN(T)+1.12754E+31*T**(-9);,, N ! +$ + FUNCTION GHCPNI 298.15 +1046+1.2552*T+GHSERNI;,,N ! +$ + FUNCTION GBCCNI 298.15 +8715.084-3.556*T+GHSERNI;,,, N ! +$ +$ GAS PHASE +$ + PARAMETER G(GAS,NI;0) 298.15 +F13191T+R*T*LN(1E-05*P);,,N REF7504 ! + PARAMETER G(GAS,NI2;0) 298.15 +F13265T+R*T*LN(1E-05*P);,,N REF7553 ! +$ +$ LIQUID PHASE +$ + PARAMETER G(LIQUID,NI;0) 298.13 + +16414.686-9.397*T-3.82318E-21*T**7+GHSERNI; + 1728.0 Y + +18290.88-10.537*T-1.12754E+31*T**(-9) + +GHSERNI;,,N 91DIN ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,NI:VA;0) 298.15 +GHSERNI;,,N 91DIN ! + PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633;,,N 89DIN ! + PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 .52;,,N 89DIN ! +$ +$ BCC_A2 PHASE +$ + PARAMETER G(BCC_A2,NI:VA;0) 298.15 +GBCCNI;,,N 91DIN ! + PARAMETER TC(BCC_A2,NI:VA;0) 298.15 575;,,N 89DIN ! + PARAMETER BMAGN(BCC_A2,NI:VA;0) 298.15 .85;,,N 89DIN ! + FUNC B2NIVA 295.15 +162397.3-27.40575*T;,,N ! + FUNC LB2NIVA 298.15 -64024.38+26.49419*T;,,N ! + PARAMETER L(BCC_A2,NI,VA:VA;0) 298.15 B2NIVA+LB2NIVA;,,N 99DUP ! +$ +$ HCP_A3 PHASE +$ + PARAMETER G(HCP_A3,NI:VA;0) 298.15 +GHCPNI;,,N 91DIN ! + PARAMETER TC(HCP_A3,NI:VA;0) 298.15 633;,,N 86FER1 ! + PARAMETER BMAGN(HCP_A3,NI:VA;0) 298.15 .52;,,N 86FER1 ! +$ +$ BCC_B2 PHASE +$ + PARAMETER G(BCC_B2,VA:NI:VA;0) 298.15 .5*B2NIVA-.5*LB2NIVA;,,N 99DUP ! + PARAMETER G(BCC_B2,NI:VA:VA;0) 298.15 .5*B2NIVA-.5*LB2NIVA;,,N 99DUP ! +$ +$ NI3TI_DO24 PHASE +$ + PARAMETER G(NI3TI_DO24,NI:NI;0) 298.15 +GHCPNI;,,N 90SAU ! +$ +$ ALTI3_DO19 PHASE +$ + PARAMETER G(ALTI3_DO19,NI:NI;0) 298.15 +4*GHCPNI;,,N COST507 ! +$ +$ C14_LAVES PHASE +$ + PARAMETER G(C14_LAVES,NI:NI;0) 298.15 +15000+3*GHSERNI;,,N REFLAV ! +$ +$ C15_LAVES PHASE +$ + PARAMETER G(C15_LAVES,NI:NI;0) 298.15 +15000+3*GHSERNI;,,N REFLAV ! +$ +$ C36_LAVES PHASE +$ + PARAMETER G(C36_LAVES,NI:NI;0) 298.15 +15000+3*GHSERNI;,,N REFLAV ! +$ +$ H_L21 PHASE +$ + PARAMETER G(H_L21,NI:NI:NI;0) 298.15 +2*GBCCNI;,,N 95DUP8 ! + PARAMETER G(H_L21,NI:NI:VA;0) 298.15 +100000+GHSERNI;,,N 95DUP8 ! +$ +$ MTI2 PHASE +$ + PARAMETER G(MTI2,NI:NI;0) 298.15 3*GHSERNI+15000;,,N 99DUP9 ! +$ +$**************************************************************************** +$ +$ BINARY PARAMETERS +$ +$---------------------------------------------------------------------------- +$ +$ Al-Cr +$ Mainly from Saunders (COST507) +$ Metastable B2 and L12 from revision of Al-Cr-Ni +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,AL,CR;0) 298.15 -29000;,,N 91SAU1 ! + PARAMETER L(LIQUID,AL,CR;1) 298.15 -11000;,,N 91SAU1 ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,AL,CR:VA;0) 298.15 -45900+6*T;,,N 91SAU1 ! +$ +$ BCC_A2 PHASE +$ + PARAMETER G(BCC_A2,AL,CR:VA;0) 298.15 -54900+10*T;,,N 91SAU1 ! +$ +$ BCC_B2 PHASE +$ metastable +$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. The B2 +$ phase is not stabilized enough to become stable in the Al-Cr. It is +$ thus not in agreement with "T. Helander, and O. Tolochko, J. of Phase +$ Eq, 20 (1) 1999, 57-60." Further study on the extension of the B2 phase +$ towards AlCr in Al-Cr-Ni would be desirable. + PARAMETER G(BCC_B2,AL:CR:VA;0) 298.15 -2000;,,N 99DUP6 ! + PARAMETER G(BCC_B2,CR:AL:VA;0) 298.15 -2000;,,N 99DUP6 ! +$ +$ FCC_L12 PHASE +$ metastable +$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. + FUN U1ALCR 298.15 -830;,,N 99DUP6 ! + FUN U3ALCR 298.15 0.0; 6000.00 99DUP6 ! + FUN U4ALCR 298.15 0.0; 6000.00 N 99DUP6 ! + FUNCTION L04ALCR 298.15 U3ALCR;,,N ! + FUNCTION L14ALCR 298.15 U4ALCR;,,N ! + FUNCTION ALCR3 298.15 3*U1ALCR;,,N ! + FUNCTION AL2CR2 298.15 4*U1ALCR;,,N ! + FUNCTION AL3CR 298.15 3*U1ALCR;,,N ! + PARAMETER G(FCC_L12,CR:AL:VA;0) 298.15 +ALCR3;,, N 99DUP6 ! + PARAMETER G(FCC_L12,AL:CR:VA;0) 298.15 +AL3CR;,, N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:AL:VA;0) 298.15 + -1.5*ALCR3+1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:CR:VA;0) 298.15 + +1.5*ALCR3+1.5*AL2CR2-1.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:AL:VA;1) 298.15 + +0.5*ALCR3-1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:CR:VA;1) 298.15 + -1.5*ALCR3+1.5*AL2CR2-0.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:AL,CR:VA;0) 298.15 +L04ALCR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:AL,CR:VA;1) 298.15 +L14ALCR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:*:VA;0) 298.15 +3*L04ALCR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:*:VA;1) 298.15 +3*L14ALCR;,,N 99DUP6 ! +$ +$ AL11CR2 PHASE +$ + PHASE AL11CR2 % 3 10 1 2 ! + CONST AL11CR2 :AL : AL : CR : ! + PARAMETER G(AL11CR2,AL:AL:CR;0) 298.15 + +11*GHSERAL+2*GHSERCR-175500+25.805*T;,,N 91SAU1 ! +$ +$ AL13CR2 PHASE +$ + PHASE AL13CR2 % 2 13 2 ! + CONST AL13CR2 :AL : CR : ! + PARAMETER G(AL13CR2,AL:CR;0) 298.15 + +13*GHSERAL+2*GHSERCR-174405+22.2*T;,,N 91SAU1 ! +$ +$ AL4CR PHASE +$ + PHASE AL4CR % 2 4 1 ! + CONST AL4CR :AL : CR : ! + PARAMETER G(AL4CR,AL:CR;0) 298.15 + +4*GHSERAL+GHSERCR-89025+19.05*T;,,N 91SAU1 ! +$ +$ AL8CR5_H PHASE +$ + PHASE AL8CR5_H % 2 8 5 ! + CONST AL8CR5_H :AL : CR : ! + PARAMETER G(AL8CR5_H,AL:CR;0) 298.15 + +8*GHSERAL+5*GHSERCR-147732-58.5*T;,,N 91SAU1 ! +$ +$ AL8CR5_L PHASE +$ + PHASE AL8CR5_L % 2 8 5 ! + CONST AL8CR5_L :AL : CR : ! + PARAMETER G(AL8CR5_L,AL:CR;0) 298.15 + +8*GHSERAL+5*GHSERCR-229515;,,N 91SAU1 ! +$ +$ AL9CR4_H PHASE +$ + PHASE AL9CR4_H % 2 9 4 ! + CONST AL9CR4_H :AL : CR : ! + PARAMETER G(AL9CR4_H,AL:CR;0) 298.15 + +9*GHSERAL+4*GHSERCR-134433-56.16*T;,,N 91SAU1 ! +$ +$ AL9CR4_L PHASE +$ + PHASE AL9CR4_L % 2 9 4 ! + CONST AL9CR4_L :AL : CR : ! + PARAMETER G(AL9CR4_L,AL:CR;0) 298.15 + +9*GHSERAL+4*GHSERCR-230750+16.094*T;,,N 91SAU1 ! +$ +$ ALCR2 PHASE +$ + PHASE ALCR2 % 2 1 2 ! + CONST ALCR2 :AL : CR : ! + PARAMETER G(ALCR2,AL:CR;0) 298.15 + +GHSERAL+2*GHSERCR-32700-8.79*T;,,N 91SAU1 ! +$ +$ AL3TI_DO22 PHASE +$ metastable +$ + PARAMETER G(AL3TI_DO22,AL:CR;0) 298.15 + +3*GHSERAL+GHSERCR-53000;,,N COST507 ! +$ +$ NI3TI_DO24 PHASE +$ metastable +$ + PARA G(NI3TI_DO24,CR:AL;0) 298.15 .25*GHCPAL+.75*GHCPCR;,,N LINEAR ! + PARA G(NI3TI_DO24,AL:CR;0) 298.15 .75*GHCPAL+.25*GHCPCR;,,N LINEAR ! +$ +$ MTI2 PHASE +$ metastable +$ + PARA G(MTI2,CR:AL;0) 298.15 +GHSERCR+2*GHSERAL;,,N LINEAR ! +$ +$ ALTI3_DO19 PHASE +$ metastable +$ + PARA G(ALTI3_DO19,CR:AL;0) 298.15 +GHCPAL+3*GHCPCR;,,N COST507 ! + PARA G(ALTI3_DO19,AL:CR;0) 298.15 +3*GHCPAL+GHCPCR;,,N COST507 ! + PARA L(ALTI3_DO19,AL,CR:AL;0) 298.15 1E-04;,,N COST507 ! + PARA L(ALTI3_DO19,AL:AL,CR;0) 298.15 1E-04;,,N COST507 ! + PARA L(ALTI3_DO19,CR:AL,CR;0) 298.15 1E-04;,,N COST507 ! + PARA L(ALTI3_DO19,AL,CR:CR;0) 298.15 1E-04;,,N COST507 ! +$ +$ ALTI_L10 PHASE +$ metastable +$ + PARA G(ALTI_L10,CR:AL;0) 298.15 -25000+3*T+GHSERAL+GFCCCR;,,N COST507 ! + PARA G(ALTI_L10,AL:CR;0) 298.15 -25000+3*T+GHSERAL+GFCCCR;,,N COST507 ! + PARA L(ALTI_L10,AL,CR:AL;0) 298.15 1E-04;,,N COST507 ! + PARA L(ALTI_L10,AL:AL,CR;0) 298.15 1E-04;,,N COST507 ! + PARA L(ALTI_L10,CR:AL,CR;0) 298.15 1E-04;,,N COST507 ! + PARA L(ALTI_L10,AL,CR:CR;0) 298.15 1E-04;,,N COST507 ! +$ +$ SIGMA PHASE +$ metastable +$ + PARA G(SIGMA,AL:CR:AL;0) 298.15 + 8*GHSERAL+4*GHSERCR+18*GBCCAL+UNASS;,,N 99LEE ! + PARA G(SIGMA,AL:CR:CR;0) 298.15 + 8*GHSERAL+4*GHSERCR+18*GHSERCR+UNASS;,,N 99LEE ! +$ +$ NEWSIGMA PHASE +$ metastable +$ + PARA G(NEWSIGMA,AL:CR:AL;0) 298.15 + +10*GHSERAL+4*GHSERCR+16*GBCCAL;,,N LINEAR ! + PARA G(NEWSIGMA,AL:CR:CR;0) 298.15 + +10*GHSERAL+4*GHSERCR+16*GHSERCR;,,N LINEAR ! +$ +$ C14_LAVES PHASE +$ metastable +$ + PARAMETER G(C14_LAVES,CR:AL;0) 298.15 + +2*GHSERCR+GHSERAL;,,N LINEAR ! + PARAMETER G(C14_LAVES,AL:CR;0) 298.15 + +GHSERCR+2*GHSERAL;,,N LINEAR ! +$ +$ C15_LAVES PHASE +$ metastable +$ + PARAMETER G(C15_LAVES,CR:AL;0) 298.15 + +2*GHSERCR+GHSERAL;,,N LINEAR ! + PARAMETER G(C15_LAVES,AL:CR;0) 298.15 + +GHSERCR+2*GHSERAL;,,N LINEAR ! +$ +$ C36_LAVES PHASE +$ metastable +$ + PARAMETER G(C36_LAVES,CR:AL;0) 298.15 + +2*GHSERCR+GHSERAL;,,N LINEAR ! + PARAMETER G(C36_LAVES,AL:CR;0) 298.15 + +GHSERCR+2*GHSERAL;,,N LINEAR ! +$ +$---------------------------------------------------------------------------- +$ +$ Al-Ni +$ Mainly from ND thesis, +$ slighly revised to get better solvus at low temperature +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,AL,NI;0) 298.15 -207109.28+41.31501*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;1) 298.15 -10185.79+5.8714*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;2) 298.15 +81204.81-31.95713*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;3) 298.15 +4365.35-2.51632*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;4) 298.15 -22101.64+13.16341*T;,,N 95DUP3 ! +$ +$ FCC_A1 PHASE +$ + PARAMETER TC(FCC_A1,AL,NI:VA;0) 298.15 -1112;,,N 95DUP3 ! + PARAMETER TC(FCC_A1,AL,NI:VA;1) 298.15 1745;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;0) 298.15 -162407.75+16.212965*T;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;1) 298.15 +73417.798-34.914168*T;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;2) 298.15 +33471.014-9.8373558*T;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;3) 298.15 -30758.01+10.25267*T;,,N 95DUP3 ! +$ +$ BCC_A2 PHASE +$ metastable +$ + FUNC B2ALNI 295.15 -152397.3+26.40575*T;,,N ! + FUNC LB2ALNI 298.15 -52440.88+11.30117*T;,,N ! + PARAMETER L(BCC_A2,AL,NI:VA;0) 298.15 B2ALNI+LB2ALNI;,,N 99DUP! +$ +$ HCP_A3 PHASE +$ metastable +$ + PARAMETER TC(HCP_A3,AL,NI:VA;0) 298.15 -1112;,,N 95DUP8 ! + PARAMETER TC(HCP_A3,AL,NI:VA;1) 298.15 1745;,,N 95DUP8 ! + PARAMETER L(HCP_A3,AL,NI:VA;0) 298.15 -162407.75+16.212965*T;,,N 95DUP8 ! + PARAMETER L(HCP_A3,AL,NI:VA;1) 298.15 +73417.798-34.914168*T;,,N 95DUP8 ! + PARAMETER L(HCP_A3,AL,NI:VA;2) 298.15 +33471.014-9.8373558*T;,,N 95DUP8 ! + PARAMETER L(HCP_A3,AL,NI:VA;3) 298.15 -30758.01+10.25267*T;,,N 95DUP8 ! +$ +$ BCC_B2 PHASE +$ + PARAMETER G(BCC_B2,AL:NI:VA;0) 298.15 .5*B2ALNI-.5*LB2ALNI;,,N 99DUP ! + PARAMETER G(BCC_B2,NI:AL:VA;0) 298.15 .5*B2ALNI-.5*LB2ALNI;,,N 99DUP ! +$ +$ FCC_L12 PHASE +$ + FUN UALNI 298.15 -22212.8931+4.39570389*T;,,,N 99DUP3 ! + FUN U1ALNI 298.15 2*UNTIER*UALNI;,,,N 99DUP3 ! + FUN U3ALNI 298.15 0;,,,N 99DUP3 ! + FUN U4ALNI 298.15 7203.60609-3.74273030*T;,,,N 99DUP3 ! + FUNCTION L04ALNI 298.15 U3ALNI;,,N 99DUP3 ! + FUNCTION L14ALNI 298.15 U4ALNI;,,N 99DUP3 ! + FUNCTION ALNI3 298.15 +3*U1ALNI;,,,N 99DUP3 ! + FUNCTION AL2NI2 298.15 +4*U1ALNI;,,,N 99DUP3 ! + FUNCTION AL3NI 298.15 +3*U1ALNI;,,,N 99DUP3 ! + PARAMETER G(FCC_L12,NI:AL:VA;0) 298.15 +ALNI3;,,N 99DUP3 ! + PARAMETER G(FCC_L12,AL:NI:VA;0) 298.15 +AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:AL:VA;0) 298.15 + -1.5*ALNI3+1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:NI:VA;0) 298.15 + +1.5*ALNI3+1.5*AL2NI2-1.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:AL:VA;1) 298.15 + +0.5*ALNI3-1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:NI:VA;1) 298.15 + -1.5*ALNI3+1.5*AL2NI2-0.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,*:AL,NI:VA;0) 298.15 +L04ALNI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,*:AL,NI:VA;1) 298.15 +L14ALNI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:*:VA;0) 298.15 +3*L04ALNI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:*:VA;1) 298.15 +3*L14ALNI;,,N 99DUP3 ! +$ +$ AL3NI1 PHASE +$ + PHASE AL3NI1 % 2 .75 .25 ! + CONST AL3NI1 :AL : NI : ! + PARAMETER G(AL3NI1,AL:NI;0) 298.15 + -48483.73+12.29913*T + +.75*GHSERAL+.25*GHSERNI;,,N 95DUP3 ! +$ +$ AL3NI2 PHASE +$ + PHASE AL3NI2 % 3 3 2 1 ! + CONST AL3NI2 :AL : AL,NI% : NI,VA% : ! + PARAMETER G(AL3NI2,AL:AL:NI;0) 298.15 +5*GBCCAL+GBCCNI + -39465.978+7.89525*T;,,N 95DUP3 ! + PARAMETER G(AL3NI2,AL:NI:NI;0) 298.15 +3*GBCCAL+3*GBCCNI + -427191.9+79.21725*T;,,N 95DUP3 ! + PARAMETER G(AL3NI2,AL:AL:VA;0) 298.15 +5*GBCCAL + +30000-3*T;,,N 95DUP3 ! + PARAMETER G(AL3NI2,AL:NI:VA;0) 298.15 +3*GBCCAL+2*GBCCNI + -357725.92+68.322*T;,,N 95DUP3 ! + PARAMETER L(AL3NI2,AL:AL,NI:*;0) 298.15 + -193484.18+131.79*T;,,N 95DUP3 ! + PARAMETER L(AL3NI2,AL:*:NI,VA;0) 298.15 + -22001.7+7.0332*T;,,N 95DUP3 ! +$ +$ AL3NI5 PHASE +$ + PHASE AL3NI5 % 2 .375 .625 ! + CONST AL3NI5 :AL : NI : ! + PARAMETER G(AL3NI5,AL:NI;0) 298.15 +.375*GHSERAL+.625*GHSERNI + -55507.7594+7.2648103*T;,,N 95DUP3 ! +$ +$ MTI2 PHASE +$ metastable +$ + PARAMETER G(MTI2,NI:AL;0) 298.15 GHSERNI+2*GHSERAL+80810;,,N 95DUP8 ! +$ +$ C14_LAVES PHASE +$ metastable +$ + PARAMETER G(C14_LAVES,NI:AL;0) 298.15 + +2*GHSERNI+GHSERAL+130000;,,N 99DUP8 ! + PARAMETER G(C14_LAVES,AL:NI;0) 298.15 + +GHSERNI+2*GHSERAL-100000;,,N 99DUP8 ! +$ +$ C15_LAVES PHASE +$ metastable +$ + PARAMETER G(C15_LAVES,NI:AL;0) 298.15 + +2*GHSERNI+GHSERAL+130000-2000;,,N 99DUP8 ! + PARAMETER G(C15_LAVES,AL:NI;0) 298.15 + +GHSERNI+2*GHSERAL-100000+2000;,,N 99DUP8 ! +$ +$ C36_LAVES PHASE +$ metastable +$ + PARAMETER G(C36_LAVES,NI:AL;0) 298.15 + +2*GHSERNI+GHSERAL+130000-3000;,,N 99DUP8 ! + PARAMETER G(C36_LAVES,AL:NI;0) 298.15 + +GHSERNI+2*GHSERAL-100000+3000;,,N 99DUP8 ! +$ +$ H_L21 PHASE +$ metastable +$ + FUNCTION GHALNI 298.15 -152397.3+26.40575*T+GBCCAL+GBCCNI+4000;,,N 99DUP8 ! + PARAMETER G(H_L21,AL:AL:NI;0) 298.15 +GHALNI;,,N 99DUP8 ! + PARAMETER G(H_L21,NI:AL:NI;0) 298.15 +.5*GHALNI+GBCCNI;,,N 99DUP8 ! + PARAMETER G(H_L21,AL:NI:NI;0) 298.15 +.5*GHALNI+GBCCNI;,,N 99DUP8 ! + PARAMETER G(H_L21,NI:AL:VA;0) 298.15 +.5*GBCCAL+.5*GHSERNI + +55000-.5*T;,,N 99DUP8 ! + PARAMETER G(H_L21,AL:NI:VA;0) 298.15 +.5*GBCCAL+.5*GHSERNI + +55000-.5*T;,,N 99DUP8 ! +$ +$ NI3TI_DO24 PHASE +$ metastable +$ + FUN DO24NIAL 298.15 +3*GHCPNI+GHCPAL-80000;,,N 99DUP8 ! + PARAMETER G(NI3TI_DO24,NI:AL;0) 298.15 + .25*DO24NIAL;,,N 99DUP8 ! + PARAMETER G(NI3TI_DO24,AL:NI;0) 298.15 + +.75*GHCPAL+.25*GHCPNI;,,N 95DUP8 ! +$ +$ ALTI3_DO19 PHASE +$ metastable +$ + PARAMETER G(ALTI3_DO19,NI:AL;0) 298.15 + 3*GHCPNI+GHCPAL;,,N 99DUP8 ! + PARAMETER G(ALTI3_DO19,AL:NI;0) 298.15 + 3*GHCPAL+GHCPNI;,,N 95DUP8 ! +$ +$---------------------------------------------------------------------------- +$ +$ Cr-Ni +$ Mainly from SSOL +$ Metastable B2 and L12 from revision of Al-Cr-Ni +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,CR,NI;0) 298.15 +318-7.3318*T;,,N 91LEE ! + PARAMETER L(LIQUID,CR,NI;1) 298.15 +16941-6.3696*T;,,N 91LEE ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,CR,NI:VA;0) 298.15 +8030-12.8801*T;,,N 91LEE ! + PARAMETER G(FCC_A1,CR,NI:VA;1) 298.15 +33080-16.0362*T;,,N 91LEE ! + PARAMETER TC(FCC_A1,CR,NI:VA;0) 298.15 -3605;,,N 86DIN ! + PARAMETER BMAGN(FCC_A1,CR,NI:VA;0) 298.15 -1.91;,,N 86DIN ! +$ +$ BCC_A2 PHASE +$ + PARAMETER G(BCC_A2,CR,NI:VA;0) 298.15 +17170-11.8199*T;,,N 91LEE ! + PARAMETER G(BCC_A2,CR,NI:VA;1) 298.15 +34418-11.8577*T;,,N 91LEE ! + PARAMETER TC(BCC_A2,CR,NI:VA;0) 298.15 2373;,,N 86DIN ! + PARAMETER TC(BCC_A2,CR,NI:VA;1) 298.15 617;,,N 86DIN ! + PARAMETER BMAGN(BCC_A2,CR,NI:VA;0) 298.15 4;,,N 86DIN ! +$ +$ HCP_A3 PHASE +$ metastable +$ + PARAMETER G(HCP_A3,CR,NI:VA;0) 298.15 50000;,,N 95DUP6 ! + PARAMETER TC(HCP_A3,CR,NI:VA;0) 298.15 -3605;,,N 95DUP6 ! + PARAMETER BMAGN(HCP_A3,CR,NI:VA;0) 298.15 -1.91;,,N 95DUP6 ! +$ +$ BCC_B2 PHASE +$ metastable +$ +$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. + PARAMETER G(BCC_B2,CR:NI:VA;0) 298.15 4000;,,N 99DUP6 ! + PARAMETER G(BCC_B2,NI:CR:VA;0) 298.15 4000;,,N 99DUP6 ! +$ +$ FCC_L12 PHASE +$ metastable +$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. +$ The L12 phase is metastable in the binary Cr-Ni while it was stable in NDTH. + FUN U1CRNI 298.15 -1980;,,,N 99DUP6 ! +$ FUN U1CRNI 298.15 -7060+3.63*T;,,,N 99DUP6 ! + FUN U3CRNI 298.15 0;,,,N 99DUP6 ! + FUN U4CRNI 298.15 0;,,,N 99DUP6 ! + FUNCTION L04CRNI 298.15 U3CRNI;,,N 99DUP6 ! + FUNCTION L14CRNI 298.15 U4CRNI;,,N 99DUP6 ! + FUNCTION CRNI3 298.15 +3*U1CRNI;,,,N 99DUP6 ! + FUNCTION CR2NI2 298.15 +4*U1CRNI;,,,N 99DUP6 ! + FUNCTION CR3NI 298.15 +3*U1CRNI;,,,N 99DUP6 ! + PARAMETER G(FCC_L12,NI:CR:VA;0) 298.15 +CRNI3;,, N 99DUP6 ! + PARAMETER G(FCC_L12,CR:NI:VA;0) 298.15 +CR3NI;,, N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:CR:VA;0) 298.15 + -1.5*CRNI3+1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:NI:VA;0) 298.15 + +1.5*CRNI3+1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:CR:VA;1) 298.15 + +0.5*CRNI3-1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:NI:VA;1) 298.15 + -1.5*CRNI3+1.5*CR2NI2-0.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:CR,NI:VA;0) 298.15 +L04CRNI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:CR,NI:VA;1) 298.15 +L14CRNI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:*:VA;0) 298.15 +3*L04CRNI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:*:VA;1) 298.15 +3*L14CRNI;,,N 99DUP6 ! +$ +$ SIGMA PHASE +$ metastable +$ + PARAMETER G(SIGMA,NI:CR:CR;0) 298.15 + +8*GHSERNI+4*GHSERCR+18*GHSERCR+221157-227*T;,,N 91LEE ! + PARAMETER G(SIGMA,NI:CR:NI;0) 298.15 + +8*GHSERNI+4*GHSERCR+18*GBCCNI+175400;,,N 86GUS ! +$ +$ NEWSIGMA PHASE +$ metastable +$ + PARAMETER G(NEWSIGMA,NI:CR:CR;0) 298.15 + +10*GHSERNI+4*GHSERCR+16*GHSERCR+221157-227*T;,,N SIG10416 ! + PARAMETER G(NEWSIGMA,NI:CR:NI;0) 298.15 + +10*GHSERNI+4*GHSERCR+16*GBCCNI+175400;,,N SIG10416 ! +$ +$ CHI_A12 PHASE +$ metastable +$ + PARAMETER G(CHI_A12,NI:CR:CR;0) 298.15 + +24*GHSERNI+10*GHSERCR+24*GFCCCR;,, N 99LEE ! + PARAMETER G(CHI_A12,CR:CR:NI;0) 298.15 + +24*GFCCCR+10*GHSERCR+24*GHSERNI;,, N 99LEE ! + PARAMETER G(CHI_A12,NI:CR:NI;0) 298.15 + +24*GHSERNI+10*GHSERCR+24*GHSERNI;,, N 99LEE ! +$ +$ C14_LAVES PHASE +$ metastable +$ + PARAMETER G(C14_LAVES,NI:CR;0) 298.15 2*GHSERNI+GHSERCR+15000;,,N 95DUP4 ! + PARAMETER G(C14_LAVES,CR:NI;0) 298.15 2*GHSERCR+GHSERNI+15000;,,N 95DUP4 ! +$ +$ C15_LAVES PHASE +$ metastable +$ + PARAMETER G(C15_LAVES,NI:CR;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 95DUP4 ! + PARAMETER G(C15_LAVES,CR:NI;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 95DUP4 ! +$ +$ C36_LAVES PHASE +$ metastable +$ + PARAMETER G(C36_LAVES,NI:CR;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 99DUP9 ! + PARAMETER G(C36_LAVES,CR:NI;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 99DUP9 ! +$ +$ MTI2 PHASE +$ metastable +$ + PARAMETER G(MTI2,NI:CR;0) 298.15 GHSERNI+2*GHSERCR+5000;,,N 95DUP9 ! + PARAMETER G(MTI2,CR:NI;0) 298.15 GHSERCR+2*GHSERNI+5000;,,N 95DUP9 ! +$ +$ NI3TI_DO24 PHASE +$ metastable +$ + PARAMETER G(NI3TI_DO24,CR:NI;0) 298.15 .75*GHCPCR+.25*GHCPNI;,,N 95DUP9 ! + PARAMETER G(NI3TI_DO24,NI:CR;0) 298.15 .75*GHCPNI+.25*GHCPCR;,,N 95DUP9 ! +$ +$ ALTI3_DO19 PHASE +$ metastable +$ + PARAMETER G(ALTI3_DO19,NI:CR;0) 298.15 + 3*GHCPNI+GHCPCR;,,N LINEAR ! + PARAMETER G(ALTI3_DO19,CR:NI;0) 298.15 + 3*GHCPCR+GHCPNI;,,N LINEAR ! +$ +$**************************************************************************** +$ +$ TERNARY PARAMETERS +$ +$---------------------------------------------------------------------------- +$ +$ Al-Cr-Ni +$ July 1999, ND +$ Revision. Main changes: +$ - description of the A2/B2 +$ - new liquidus data taken into account +$ - simpler ternary interaction parameters +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,AL,CR,NI;0) 298.15 16000;,,N 99DUP6 ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,AL,CR,NI:VA;0) 298.15 30300;,,N 99DUP6 ! +$ +$ BCC_A2 PHASE +$ + PARAMETER G(BCC_A2,AL,CR,NI:VA;0) 298.15 42500;,,N 99DUP6 ! +$ +$ FCC_L12 PHASE +$ + FUN U1ALCRNI 298.15 6650;,,N 99DUP6 ! + FUN U2ALCRNI 298.15 0;,,N 99DUP6 ! + FUN U3ALCRNI 298.15 0;,,N 99DUP6 ! + FUN ALCRNI2 298.15 U1ALCR+2*U1ALNI+2*U1CRNI+U1ALCRNI;,,N 99DUP6 ! + FUN ALCR2NI 298.15 2*U1ALCR+U1ALNI+2*U1CRNI+U2ALCRNI;,,N 99DUP6 ! + FUN AL2CRNI 298.15 2*U1ALCR+2*U1ALNI+U1CRNI+U3ALCRNI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR,NI:AL:VA;0) 298.15 + -1.5*ALCRNI2-1.5*ALCR2NI+ALCR3+ALNI3+6*AL2CRNI + -1.5*AL2CR2-1.5*AL2NI2-1.5*AL3CR-1.5*AL3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR,NI:CR:VA;0) 298.15 + -1.5*ALCRNI2+6*ALCR2NI-1.5*ALCR3-1.5*AL2CRNI + -1.5*AL2CR2+AL3CR+CRNI3-1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR,NI:NI:VA;0) 298.15 + +6*ALCRNI2-1.5*ALCR2NI-1.5*ALNI3-1.5*AL2CRNI + -1.5*AL2NI2+AL3NI-1.5*CRNI3-1.5*CR2NI2+CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR:NI:VA;0) 298.15 + +1.5*ALCR2NI+1.5*AL2CRNI-1.5*AL3NI-1.5*CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,NI:CR:VA;0) 298.15 + +1.5*ALCRNI2+1.5*AL2CRNI-1.5*AL3CR-1.5*CRNI3;,,N 99DUP6 ! + PARA L(FCC_L12,CR,NI:AL:VA;0) 298.15 + +1.5*ALCRNI2+1.5*ALCR2NI-1.5*ALCR3-1.5*ALNI3;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR:NI:VA;1) 298.15 + -1.5*ALCR2NI+1.5*AL2CRNI-0.5*AL3NI+0.5*CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,NI:CR:VA;1) 298.15 + -1.5*ALCRNI2+1.5*AL2CRNI-0.5*AL3CR+0.5*CRNI3;,,N 99DUP6 ! + PARA L(FCC_L12,CR,NI:AL:VA;1) 298.15 + -1.5*ALCRNI2+1.5*ALCR2NI-0.5*ALCR3+0.5*ALNI3;,,N 99DUP6 ! +$ +$ SIGMA PHASE +$ metastable + PARA G(SIGMA,NI:CR:AL;0) 298.15 + +8*GHSERNI+4*GHSERCR+18*GBCCAL+UNASS;,, N 99LEE ! + PARA G(SIGMA,AL:CR:NI;0) 298.15 + +8*GHSERAL+4*GHSERCR+18*GBCCNI+UNASS;,, N 99LEE ! +$ +$ NEWSIGMA PHASE +$ metastable + PARA G(NEWSIGMA,NI:CR:AL;0) 298.15 + +10*GHSERNI+4*GHSERCR+16*GBCCAL;,, N LINEAR ! + PARA G(NEWSIGMA,AL:CR:NI;0) 298.15 + +10*GHSERAL+4*GHSERCR+16*GBCCNI;,, N LINEAR ! +$ +$ +$**************************************************************************** +$ Diffusion parameters +$ +PARAMETER MQ(FCC_A1&AL,NI;0) 298.15 -284000+R*T*LN(7.5E-4); + 6.000E+3 N 96Eng ! +PARAMETER MQ(FCC_A1&AL,AL;0) 298.15 -142000+R*T*LN(1.71E-4); + 6.000E+3 N 96Eng ! +PARAMETER MQ(FCC_A1&AL,AL,NI;0) 298.15 -41300-91.2*T; + 6.000E+3 N 96Eng ! +PARAMETER MQ(FCC_A1&AL,CR;0) 298.15 -235000-82*T; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&AL,CR,NI;0) 298.15 -53200; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&AL,Al,Cr;0) 298.15 +335000; 6000 N 96Eng ! + +PARAMETER MQ(FCC_A1&NI,AL;0) 298.15 -145900+R*T*LN(4.4E-4); + 6.000E+3 N 96Eng ! +PARAMETER MQ(FCC_A1&NI,NI;0)298.15 -287000-69.8*T; + 6.000E+3 N 96Eng ! +PARAMETER MQ(FCC_A1&NI,AL,NI;0) 298.15 -113000+65.5*T; + 6.000E+3 N 96Eng ! +PARAMETER MQ(FCC_A1&NI,CR;0) 298.15 -235000-82*T; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&NI,CR,NI;0) 298.15 -81000; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&NI,AL,CR;0) 298.15 211000; 6000 N 96Eng ! + + +PARAMETER MQ(FCC_A1&CR,AL;0) 298.15 -261700+R*T*LN(0.64); + 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&CR,CR;0) 298.15 -235000-82*T; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&CR,NI;0) 298.15 -287000-64.4*T; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&CR,AL,CR;0) 298.15 +487000; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&CR,AL,NI;0) 298.15 -118000; 6000 N 96Eng ! +PARAMETER MQ(FCC_A1&CR,CR,NI;0) 298.15 -68000; 6000 N 96Eng ! +$ +$**************************************************************************** + + LIST_OF_REFERENCES + NUMBER SOURCE + LINEAR 'Unassessed parameter, linear combination of unary data. (MU, + SIGMA)' + REFLAV 'G(LAVES,AA)=3*G(SER,AA)+15000' + 86DIN 'A. Dinsdale, T. Chart, MTDS NPL, Unpublished work (1986); CR-NI' + 86FER1 'A. Fernandez Guillermet, + Z metallkde, Vol 78 (1987) p 639-647, + TRITA-MAC 324B (1986); CO-NI' + 86GUS 'P. Gustafson, Calphad Vol 11 (1987) p 277-292, + TRITA-MAC 320 (1986); CR-NI-W ' + 87GUS 'P. Gustafson, TRITA-MAC 342, (1987); CR-FE-W' + 89DIN 'Alan Dinsdale, SGTE Data for Pure Elements, + NPL Report DMA(A)195 September 1989' + 91DIN 'Alan Dinsdale, SGTE Data for Pure Elements, NPL Report + DMA(A)195 Rev. August 1990' + 91LEE 'Byeong-Joo Lee, unpublished revision (1991); C-Cr-Fe-Ni' + 91SAU1 'Nigel Saunders, 1991, based on + N. Saunders, V.G. Rivlin + Z. metallkde, 78 (11), 795-801 (1987); Al-Cr' + 91DIN 'Alan Dinsdale, SGTE Data for Pure Elements, + Calphad Vol 15(1991) p 317-425, + also in NPL Report DMA(A)195 Rev. August 1990' + 95DUP3 'N. Dupin, Thesis, LTPCM, France, 1995; + Al-Ni, + also in I. Ansara, N. Dupin, H.L. Lukas, B. SUndman + J. Alloys Compds, 247 (1-2), 20-30 (1997)' + 95DUP4 'N. Dupin, Thesis, LTPCM, France, 1995; + Cr-Ni-Ta' + 95DUP6 'N. Dupin, Thesis, LTPCM, France, 1995; + Al-Cr-Ni' + 95DUP8 'N. Dupin, Thesis, LTPCM, France, 1995; + Al-Ni-Ti' + 95DUP9 'N. Dupin, Thesis, LTPCM, France, 1995; + Cr-Ni-Ti' + 99DUP 'N. Dupin, I. Ansara, + Z. metallkd., Vol 90 (1999) p 76-85; + Al-Ni' + 99DUP3 'N. Dupin, + July 1999, unpublished revision + ; Al-Ni' + 99DUP6 'N. Dupin, + July 1999, unpublished revision + ; Al-Cr-Ni' + 99DUP8 'N. Dupin, + August 1999, unpublished revision + ; Al-Ni-Ti' + 99DUP9 'N. Dupin, + August 1999, unpublished revision + ; Cr-Ni-Ti' + 99LEE 'Byeong-Joo Lee, unpublished work at KTH (1999); + update of steel database' + REF184 'AL1 CODATA KEY VALUES SGTE ** + ALUMINIUM + Cp values similar in Codata Key Values and IVTAN Vol. 3' + REF448 'AL2 CHATILLON(1992) + Enthalpy of formation for Al1 taken from Codata Key Values. + Enthalpy of form. from TPIS dissociation energy mean Value + corrected with new fef from Sunil K.K. and Jordan K.D. + (J.Phys. Chem. 92(1988)2774) ab initio calculations.' + REF4465 'CR1 T.C.R.A.S. Class: 1 + CHROMIUM ' + REF4591 'CR2 T.C.R.A.S. Class: 6' + REF7504 'NI1 T.C.R.A.S Class: 1 + Data provided by T.C.R.A.S. October 1996' + REF7553 'NI2 T.C.R.A.S Class: 5 + Data provided by T.C.R.A.S. October 1996' + ! +""" + +NICRAL_TDB_DIFF = """ + +$ Same as NICRAL_TDB with the following changes +$ Shortened to include just FCC_A1, FCC_L12, LIQUID +$ Mobility parameters replaced with arbitrary diffusivity parameter to test diffusivity and tracer outputs +$ + + + ELEMENT /- ELECTRON_GAS .0000E+00 .0000E+00 .0000E+00! + ELEMENT VA VACUUM .0000E+00 .0000E+00 .0000E+00! + ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01! + ELEMENT CR BCC_A2 5.1996E+01 4.0500E+03 2.3560E+01! + ELEMENT NI FCC_A1 5.8690E+01 4.7870E+03 2.9796E+01! + + SPECIES AL2 AL2! + SPECIES CR2 CR2! + SPECIES NI2 NI2! + + + FUNCTION UNASS 298.15 0;,,N ! + + + TYPE_DEFINITION % SEQ *! + DEFINE_SYSTEM_DEFAULT E 2 ! + DEFAULT_COMMAND DEF_SYS_ELEMENT VA ! + DEFAULT_COMMAND REJECT_PHASE NEWSIGMA ! + + TYPE_DEFINITION A GES A_P_D FCC_L12 MAGNETIC -3.0 .28 ! + TYPE_DEFINITION E GES A_P_D FCC_A1 MAGNETIC -3.0 .28 ! + + TYPE_DEFINITION D GES A_P_D FCC_L12 DIS_PART FCC_A1 ! + + PHASE GAS:G % 1 1.0 ! + CONST GAS:G :AL,AL2,CR,CR2,NI,NI2 : ! + + PHASE LIQUID:L % 1 1.0 ! + CONST LIQUID:L :AL,CR,NI : ! + + PHASE FCC_A1 %E 2 1 1 ! + CONST FCC_A1 :AL,CR,NI% : VA% : ! + +$ PHASE FCC_L12 %ADG 3 .75 .25 1 ! + PHASE FCC_L12 %AD 3 .75 .25 1 ! + CONST FCC_L12 :AL,CR,NI : AL,CR,NI : VA : ! + + FUNCTION ZERO 298.15 0;,,N ! + FUNCTION DP 298.15 +P-101325;,,N ! + FUNCTION TROIS 298.15 3;,,N ! + FUNCTION UNTIER 298.15 TROIS**(-1);,,N ! + +$**************************************************************************** +$ +$ UNARY PARAMETERS +$ +$---------------------------------------------------------------------------- +$ +$ Al +$ +$ FUNCTIONS +$ + FUNCTION F154T 298.15 + +323947.58-25.1480943*T-20.859*T*LN(T) + +4.5665E-05*T**2-3.942E-09*T**3-24275.5*T**(-1); + 4300.0 Y + +342017.233-54.0526109*T-17.7891*T*LN(T)+6.822E-05*T**2 + -1.91111667E-08*T**3-14782200*T**(-1); + 8200.0 Y + +542396.07-411.214335*T+22.2419*T*LN(T)-.00349619*T**2 + +4.0491E-08*T**3-2.0366965E+08*T**(-1); 1.00000E+04 N ! +$ + FUNCTION F625T 298.15 + +496408.232+35.479739*T-41.6397*T*LN(T) + +.00249636*T**2-4.90507333E-07*T**3+85390.3*T**(-1); + 900.00 Y + +497613.221+17.368131*T-38.85476*T*LN(T)-2.249805E-04*T**2 + -9.49003167E-09*T**3-5287.23*T**(-1); 2.80000E+03 N ! +$ + FUNCTION GHSERAL 298.15 + -7976.15+137.093038*T-24.3671976*T*LN(T) + -.001884662*T**2-8.77664E-07*T**3+74092*T**(-1); + 700.00 Y + -11276.24+223.048446*T-38.5844296*T*LN(T) + +.018531982*T**2-5.764227E-06*T**3+74092*T**(-1); + 933.60 Y + -11278.378+188.684153*T-31.748192*T*LN(T) + -1.231E+28*T**(-9);,, N ! +$ + FUNCTION GHCPAL 298.15 +5481-1.8*T+GHSERAL;,,N ! +$ + FUNCTION GBCCAL 298.15 +10083-4.813*T+GHSERAL;,,N ! +$ + FUNCTION GLIQAL 298.14 + +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; + 933.59 Y + +10482.282-11.253974*T+1.231E+28*T**(-9)+GHSERAL;,,N ! +$ +$ GAS PHASE +$ + PARAMETER G(GAS,AL;0) 298.15 +F154T+R*T*LN(1E-05*P);,,N REF184 ! + PARAMETER G(GAS,AL2;0) 298.15 +F625T+R*T*LN(1E-05*P);,,N REF448 ! +$ +$ LIQUID PHASE +$ + PARAMETER G(LIQUID,AL;0) 298.13 + +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; + 933.60 Y + +10482.382-11.253974*T+1.231E+28*T**(-9) + +GHSERAL;,,N 91DIN ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,AL:VA;0) 298.15 +GHSERAL;,,N 91DIN ! +$ +$ +$---------------------------------------------------------------------------- +$ +$ Cr +$ +$ FUNCTIONS +$ + FUNCTION F7454T 298.15 + +390765.331-31.5192154*T-21.36083*T*LN(T) + +7.253215E-04*T**2-1.588679E-07*T**3+10285.15*T**(-1); + 1100.0 Y + +393886.928-44.107465*T-19.96003*T*LN(T)+.001513089*T**2 + -4.23648333E-07*T**3-722515*T**(-1); + 2000.0 Y + +421372.003-231.888524*T+5.362886*T*LN(T)-.00848877*T**2 + +2.984635E-07*T**3-6015405*T**(-1); + 3300.0 Y + +305164.698+251.019831*T-55.20304*T*LN(T)+.005324585*T**2 + -2.850405E-07*T**3+34951485*T**(-1); + 5100.0 Y + +1069921.1-1708.93262*T+175.0508*T*LN(T)-.025574185*T**2 + +4.94447E-07*T**3-4.4276355E+08*T**(-1); + 7600.0 Y + -871952.838+1686.47356*T-204.5589*T*LN(T)+.007475225*T**2 + -4.618745E-08*T**3+1.423504E+09*T**(-1); 1.00000E+04 N ! +$ + FUNCTION F7735T 298.15 +598511.402+41.5353219*T-40.56798*T*LN(T) + +.004961847*T**2-1.61216717E-06*T**3+154422.85*T**(-1); + 800.00 Y + +613345.232-104.20799*T-19.7643*T*LN(T)-.007085085*T**2 + -4.69883E-07*T**3-1738066.5*T**(-1); + 1400.0 Y + +642608.843-369.286259*T+17.64743*T*LN(T)-.02767321*T**2 + +1.605906E-06*T**3-5831655*T**(-1); + 2300.0 Y + +553119.895+159.188556*T-52.07969*T*LN(T)-.004229401*T**2 + +1.5939925E-07*T**3+14793625*T**(-1); + 3900.0 Y + +347492.339+623.137624*T-105.0428*T*LN(T)+3.9699545E-04*T**2 + +1.51783483E-07*T**3+1.4843765E+08*T**(-1); + 5800.0 Y + -484185.055+2598.25559*T-334.7145*T*LN(T)+.028597625*T**2 + -4.97520167E-07*T**3+7.135805E+08*T**(-1); 6.00000E+03 N ! +$ + FUNCTION GHSERCR 298.14 + -8856.94+157.48*T-26.908*T*LN(T) + +.00189435*T**2-1.47721E-06*T**3+139250*T**(-1); + 2180.0 Y + -34869.344+344.18*T-50*T*LN(T)-2.88526E+32*T**(-9);,,N ! +$ + FUNCTION GCRLIQ 298.15 + +24339.955-11.420225*T+2.37615E-21*T**7+GHSERCR; + 2180.0 Y + -16459.984+335.616316*T-50*T*LN(T);,,N ! +$ + FUNCTION GFCCCR 298.15 +7284+.163*T+GHSERCR;,,N ! +$ + FUNCTION GHCPCR 298.15 +4438+GHSERCR;,,N ! +$ + FUNCTION ACRBCC 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! + FUNCTION BCRBCC 298.15 +1+2.6E-11*P;,,N ! + FUNCTION CCRBCC 298.15 2.08E-11;,,N ! + FUNCTION DCRBCC 298.15 +1*LN(BCRBCC);,,N ! + FUNCTION VCRBCC 298.15 +7.188E-06*EXP(ACRBCC);,,N ! + FUNCTION ECRBCC 298.15 +1*LN(CCRBCC);,,N ! + FUNCTION XCRBCC 298.15 +1*EXP(.8*DCRBCC)-1;,,N ! + FUNCTION YCRBCC 298.15 +VCRBCC*EXP(-ECRBCC);,,N ! + FUNCTION ZCRBCC 298.15 +1*LN(XCRBCC);,,N ! + FUNCTION GPCRBCC 298.15 +YCRBCC*EXP(ZCRBCC);,,N ! +$ + FUNCTION ACRLIQ 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! + FUNCTION BCRLIQ 298.15 +1+4.65E-11*P;,,N ! + FUNCTION CCRLIQ 298.15 3.72E-11;,,N ! + FUNCTION DCRLIQ 298.15 +1*LN(BCRLIQ);,,N ! + FUNCTION VCRLIQ 298.15 +7.653E-06*EXP(ACRLIQ);,,N ! + FUNCTION ECRLIQ 298.15 +1*LN(CCRLIQ);,,N ! + FUNCTION XCRLIQ 298.15 +1*EXP(.8*DCRLIQ)-1;,,N ! + FUNCTION YCRLIQ 298.15 +VCRLIQ*EXP(-ECRLIQ);,,N ! + FUNCTION ZCRLIQ 298.15 +1*LN(XCRLIQ);,,N ! + FUNCTION GPCRLIQ 298.15 +YCRLIQ*EXP(ZCRLIQ);,,N ! +$ +$ GAS PHASE +$ + PARAMETER G(GAS,CR;0) 298.15 +F7454T+R*T*LN(1E-05*P);,,N REF4465 ! + PARAMETER G(GAS,CR2;0) 298.15 +F7735T+R*T*LN(1E-05*P);,, N REF4591 ! +$ +$ LIQUID PHASE +$ + PARAMETER G(LIQUID,CR;0) 298.15 +GCRLIQ+GPCRLIQ;,, N 91DIN ! +$ +$ FCC_A1 PHASE +$ +$ +$---------------------------------------------------------------------------- +$ +$ Ni +$ +$ FUNCTIONS +$ + FUNCTION F13191T 298.15 + +417658.868-44.7777921*T-20.056*T*LN(T) + -.0060415*T**2+1.24774E-06*T**3-16320*T**(-1); + 800.00 Y + +413885.448+9.41787679*T-28.332*T*LN(T)+.00173115*T**2 + -8.399E-08*T**3+289050*T**(-1); + 3900.0 Y + +440866.732-62.5810038*T-19.819*T*LN(T)+5.067E-04*T**2 + -4.93233333E-08*T**3-15879735*T**(-1); + 7600.0 Y + +848806.287-813.398164*T+64.69*T*LN(T)-.00731865*T**2 + +8.71833333E-08*T**3-3.875846E+08*T**(-1); 10000. N ! +$ + FUNCTION F13265T 298.15 + +638073.279-68.1901928*T-24.897*T*LN(T) + -.0313584*T**2+5.93355333E-06*T**3-14215*T**(-1); + 800.00 Y + +611401.772+268.084821*T-75.25401*T*LN(T)+.01088525*T**2 + -7.08741667E-07*T**3+2633835*T**(-1); + 2100.0 Y + +637459.339+72.0712678*T-48.587*T*LN(T)-9.09E-05*T**2 + +9.12933333E-08*T**3-1191755*T**(-1); + 4500.0 Y + +564540.781+329.599011*T-80.11301*T*LN(T)+.00578085*T**2 + -1.08841667E-07*T**3+29137900*T**(-1); 6000.0 N ! +$ + FUNCTION GHSERNI 298.14 + -5179.159+117.854*T-22.096*T*LN(T) + -.0048407*T**2; + 1728.0 Y + -27840.655+279.135*T-43.1*T*LN(T)+1.12754E+31*T**(-9);,, N ! +$ + FUNCTION GHCPNI 298.15 +1046+1.2552*T+GHSERNI;,,N ! +$ + FUNCTION GBCCNI 298.15 +8715.084-3.556*T+GHSERNI;,,, N ! +$ +$ GAS PHASE +$ + PARAMETER G(GAS,NI;0) 298.15 +F13191T+R*T*LN(1E-05*P);,,N REF7504 ! + PARAMETER G(GAS,NI2;0) 298.15 +F13265T+R*T*LN(1E-05*P);,,N REF7553 ! +$ +$ LIQUID PHASE +$ + PARAMETER G(LIQUID,NI;0) 298.13 + +16414.686-9.397*T-3.82318E-21*T**7+GHSERNI; + 1728.0 Y + +18290.88-10.537*T-1.12754E+31*T**(-9) + +GHSERNI;,,N 91DIN ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,NI:VA;0) 298.15 +GHSERNI;,,N 91DIN ! + PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633;,,N 89DIN ! + PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 .52;,,N 89DIN ! +$ +$ +$**************************************************************************** +$ +$ BINARY PARAMETERS +$ +$---------------------------------------------------------------------------- +$ +$ Al-Cr +$ Mainly from Saunders (COST507) +$ Metastable B2 and L12 from revision of Al-Cr-Ni +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,AL,CR;0) 298.15 -29000;,,N 91SAU1 ! + PARAMETER L(LIQUID,AL,CR;1) 298.15 -11000;,,N 91SAU1 ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,AL,CR:VA;0) 298.15 -45900+6*T;,,N 91SAU1 ! +$ +$ +$ FCC_L12 PHASE +$ metastable +$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. + FUN U1ALCR 298.15 -830;,,N 99DUP6 ! + FUN U3ALCR 298.15 0.0; 6000.00 99DUP6 ! + FUN U4ALCR 298.15 0.0; 6000.00 N 99DUP6 ! + FUNCTION L04ALCR 298.15 U3ALCR;,,N ! + FUNCTION L14ALCR 298.15 U4ALCR;,,N ! + FUNCTION ALCR3 298.15 3*U1ALCR;,,N ! + FUNCTION AL2CR2 298.15 4*U1ALCR;,,N ! + FUNCTION AL3CR 298.15 3*U1ALCR;,,N ! + PARAMETER G(FCC_L12,CR:AL:VA;0) 298.15 +ALCR3;,, N 99DUP6 ! + PARAMETER G(FCC_L12,AL:CR:VA;0) 298.15 +AL3CR;,, N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:AL:VA;0) 298.15 + -1.5*ALCR3+1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:CR:VA;0) 298.15 + +1.5*ALCR3+1.5*AL2CR2-1.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:AL:VA;1) 298.15 + +0.5*ALCR3-1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:CR:VA;1) 298.15 + -1.5*ALCR3+1.5*AL2CR2-0.5*AL3CR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:AL,CR:VA;0) 298.15 +L04ALCR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:AL,CR:VA;1) 298.15 +L14ALCR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:*:VA;0) 298.15 +3*L04ALCR;,,N 99DUP6 ! + PARAMETER L(FCC_L12,AL,CR:*:VA;1) 298.15 +3*L14ALCR;,,N 99DUP6 ! +$ +$ +$---------------------------------------------------------------------------- +$ +$ Al-Ni +$ Mainly from ND thesis, +$ slighly revised to get better solvus at low temperature +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,AL,NI;0) 298.15 -207109.28+41.31501*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;1) 298.15 -10185.79+5.8714*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;2) 298.15 +81204.81-31.95713*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;3) 298.15 +4365.35-2.51632*T;,,N 95DUP3 ! + PARAMETER L(LIQUID,AL,NI;4) 298.15 -22101.64+13.16341*T;,,N 95DUP3 ! +$ +$ FCC_A1 PHASE +$ + PARAMETER TC(FCC_A1,AL,NI:VA;0) 298.15 -1112;,,N 95DUP3 ! + PARAMETER TC(FCC_A1,AL,NI:VA;1) 298.15 1745;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;0) 298.15 -162407.75+16.212965*T;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;1) 298.15 +73417.798-34.914168*T;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;2) 298.15 +33471.014-9.8373558*T;,,N 95DUP3 ! + PARAMETER G(FCC_A1,AL,NI:VA;3) 298.15 -30758.01+10.25267*T;,,N 95DUP3 ! +$ +$ FCC_L12 PHASE +$ + FUN UALNI 298.15 -22212.8931+4.39570389*T;,,,N 99DUP3 ! + FUN U1ALNI 298.15 2*UNTIER*UALNI;,,,N 99DUP3 ! + FUN U3ALNI 298.15 0;,,,N 99DUP3 ! + FUN U4ALNI 298.15 7203.60609-3.74273030*T;,,,N 99DUP3 ! + FUNCTION L04ALNI 298.15 U3ALNI;,,N 99DUP3 ! + FUNCTION L14ALNI 298.15 U4ALNI;,,N 99DUP3 ! + FUNCTION ALNI3 298.15 +3*U1ALNI;,,,N 99DUP3 ! + FUNCTION AL2NI2 298.15 +4*U1ALNI;,,,N 99DUP3 ! + FUNCTION AL3NI 298.15 +3*U1ALNI;,,,N 99DUP3 ! + PARAMETER G(FCC_L12,NI:AL:VA;0) 298.15 +ALNI3;,,N 99DUP3 ! + PARAMETER G(FCC_L12,AL:NI:VA;0) 298.15 +AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:AL:VA;0) 298.15 + -1.5*ALNI3+1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:NI:VA;0) 298.15 + +1.5*ALNI3+1.5*AL2NI2-1.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:AL:VA;1) 298.15 + +0.5*ALNI3-1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:NI:VA;1) 298.15 + -1.5*ALNI3+1.5*AL2NI2-0.5*AL3NI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,*:AL,NI:VA;0) 298.15 +L04ALNI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,*:AL,NI:VA;1) 298.15 +L14ALNI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:*:VA;0) 298.15 +3*L04ALNI;,,N 99DUP3 ! + PARAMETER L(FCC_L12,AL,NI:*:VA;1) 298.15 +3*L14ALNI;,,N 99DUP3 ! +$ +$ +$---------------------------------------------------------------------------- +$ +$ Cr-Ni +$ Mainly from SSOL +$ Metastable B2 and L12 from revision of Al-Cr-Ni +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,CR,NI;0) 298.15 +318-7.3318*T;,,N 91LEE ! + PARAMETER L(LIQUID,CR,NI;1) 298.15 +16941-6.3696*T;,,N 91LEE ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,CR,NI:VA;0) 298.15 +8030-12.8801*T;,,N 91LEE ! + PARAMETER G(FCC_A1,CR,NI:VA;1) 298.15 +33080-16.0362*T;,,N 91LEE ! + PARAMETER TC(FCC_A1,CR,NI:VA;0) 298.15 -3605;,,N 86DIN ! + PARAMETER BMAGN(FCC_A1,CR,NI:VA;0) 298.15 -1.91;,,N 86DIN ! +$ +$ +$ FCC_L12 PHASE +$ metastable +$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. +$ The L12 phase is metastable in the binary Cr-Ni while it was stable in NDTH. + FUN U1CRNI 298.15 -1980;,,,N 99DUP6 ! +$ FUN U1CRNI 298.15 -7060+3.63*T;,,,N 99DUP6 ! + FUN U3CRNI 298.15 0;,,,N 99DUP6 ! + FUN U4CRNI 298.15 0;,,,N 99DUP6 ! + FUNCTION L04CRNI 298.15 U3CRNI;,,N 99DUP6 ! + FUNCTION L14CRNI 298.15 U4CRNI;,,N 99DUP6 ! + FUNCTION CRNI3 298.15 +3*U1CRNI;,,,N 99DUP6 ! + FUNCTION CR2NI2 298.15 +4*U1CRNI;,,,N 99DUP6 ! + FUNCTION CR3NI 298.15 +3*U1CRNI;,,,N 99DUP6 ! + PARAMETER G(FCC_L12,NI:CR:VA;0) 298.15 +CRNI3;,, N 99DUP6 ! + PARAMETER G(FCC_L12,CR:NI:VA;0) 298.15 +CR3NI;,, N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:CR:VA;0) 298.15 + -1.5*CRNI3+1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:NI:VA;0) 298.15 + +1.5*CRNI3+1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:CR:VA;1) 298.15 + +0.5*CRNI3-1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:NI:VA;1) 298.15 + -1.5*CRNI3+1.5*CR2NI2-0.5*CR3NI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:CR,NI:VA;0) 298.15 +L04CRNI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,*:CR,NI:VA;1) 298.15 +L14CRNI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:*:VA;0) 298.15 +3*L04CRNI;,,N 99DUP6 ! + PARAMETER L(FCC_L12,CR,NI:*:VA;1) 298.15 +3*L14CRNI;,,N 99DUP6 ! +$ +$ +$**************************************************************************** +$ +$ TERNARY PARAMETERS +$ +$---------------------------------------------------------------------------- +$ +$ Al-Cr-Ni +$ July 1999, ND +$ Revision. Main changes: +$ - description of the A2/B2 +$ - new liquidus data taken into account +$ - simpler ternary interaction parameters +$ +$ LIQUID PHASE +$ + PARAMETER L(LIQUID,AL,CR,NI;0) 298.15 16000;,,N 99DUP6 ! +$ +$ FCC_A1 PHASE +$ + PARAMETER G(FCC_A1,AL,CR,NI:VA;0) 298.15 30300;,,N 99DUP6 ! +$ +$ +$ FCC_L12 PHASE +$ + FUN U1ALCRNI 298.15 6650;,,N 99DUP6 ! + FUN U2ALCRNI 298.15 0;,,N 99DUP6 ! + FUN U3ALCRNI 298.15 0;,,N 99DUP6 ! + FUN ALCRNI2 298.15 U1ALCR+2*U1ALNI+2*U1CRNI+U1ALCRNI;,,N 99DUP6 ! + FUN ALCR2NI 298.15 2*U1ALCR+U1ALNI+2*U1CRNI+U2ALCRNI;,,N 99DUP6 ! + FUN AL2CRNI 298.15 2*U1ALCR+2*U1ALNI+U1CRNI+U3ALCRNI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR,NI:AL:VA;0) 298.15 + -1.5*ALCRNI2-1.5*ALCR2NI+ALCR3+ALNI3+6*AL2CRNI + -1.5*AL2CR2-1.5*AL2NI2-1.5*AL3CR-1.5*AL3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR,NI:CR:VA;0) 298.15 + -1.5*ALCRNI2+6*ALCR2NI-1.5*ALCR3-1.5*AL2CRNI + -1.5*AL2CR2+AL3CR+CRNI3-1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR,NI:NI:VA;0) 298.15 + +6*ALCRNI2-1.5*ALCR2NI-1.5*ALNI3-1.5*AL2CRNI + -1.5*AL2NI2+AL3NI-1.5*CRNI3-1.5*CR2NI2+CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR:NI:VA;0) 298.15 + +1.5*ALCR2NI+1.5*AL2CRNI-1.5*AL3NI-1.5*CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,NI:CR:VA;0) 298.15 + +1.5*ALCRNI2+1.5*AL2CRNI-1.5*AL3CR-1.5*CRNI3;,,N 99DUP6 ! + PARA L(FCC_L12,CR,NI:AL:VA;0) 298.15 + +1.5*ALCRNI2+1.5*ALCR2NI-1.5*ALCR3-1.5*ALNI3;,,N 99DUP6 ! + PARA L(FCC_L12,AL,CR:NI:VA;1) 298.15 + -1.5*ALCR2NI+1.5*AL2CRNI-0.5*AL3NI+0.5*CR3NI;,,N 99DUP6 ! + PARA L(FCC_L12,AL,NI:CR:VA;1) 298.15 + -1.5*ALCRNI2+1.5*AL2CRNI-0.5*AL3CR+0.5*CRNI3;,,N 99DUP6 ! + PARA L(FCC_L12,CR,NI:AL:VA;1) 298.15 + -1.5*ALCRNI2+1.5*ALCR2NI-0.5*ALCR3+0.5*ALNI3;,,N 99DUP6 ! +$ +$**************************************************************************** +$ Diffusion parameters +$ +PARAMETER DQ(FCC_A1&AL,*;0) 298.15 -70000+R*T*LN(5E-5); 6000 N ! +PARAMETER DQ(FCC_A1&CR,*;0) 298.15 -40800+R*T*LN(3e-6); 6000 N ! +PARAMETER DQ(FCC_A1&NI,*;0) 298.15 -271960+R*T*LN(1.27E-4); 6000 N ! +$ +""" + +FECRNI_DB = """ +$ FeCrNi database using parameters taken from MatCalc open steel database mc_fe_v2.060.tdb +$ +$ The mc_fe_v2.059.tdb database is made available under the +$ Open Database License: http://opendatacommons.org/licenses/odbl/1.0/. +$ Any rights in individual contents of the database are licensed under the +$ Database Contents License: http://opendatacommons.org/licenses/dbcl/1.0/. +$ +$ ########################################################################## + +ELEMENT VA VACUUM 0.0 0.00 0.00 ! +ELEMENT CR BCC_A2 51.996 4050.0 23.5429 ! +ELEMENT FE BCC_A2 55.847 4489.0 27.2797 ! +ELEMENT NI FCC_A1 58.69 4787.0 29.7955 ! + +FUNCTION GHSERCR + 273.00 -8856.94+157.48*T-26.908*T*LN(T) + +0.00189435*T**2-1.47721E-6*T**3+139250*T**(-1); 2180.00 Y + -34869.344+344.18*T-50*T*LN(T)-2.88526E+32*T**(-9); 6000.00 N +REF:0 ! +FUNCTION GCRFCC + 273.00 +7284+0.163*T+GHSERCR#; 6000.00 N +REF:0 ! +FUNCTION GHSERFE + 273.00 +1225.7+124.134*T-23.5143*T*LN(T)-0.00439752*T**2 + -5.89269E-8*T**3+77358.5*T**(-1); 1811.00 Y + -25383.581+299.31255*T-46*T*LN(T)+2.2960305E+31*T**(-9); 6000.00 N +REF:0 ! +FUNCTION GFEFCC + 273.00 -1462.4+8.282*T-1.15*T*LN(T)+6.4E-04*T**2+GHSERFE#; 1811.00 Y + -27098.266+300.25256*T-46*T*LN(T)+2.78854E+31*T**(-9); 6000.00 N +REF:0 ! +FUNCTION GHSERNI + 273.00 -5179.159+117.854*T-22.096*T*LN(T)-4.8407E-3*T**2; 1728.00 Y + -27840.655+279.135*T-43.10*T*LN(T)+1.12754E+31*T**(-9); 6000.00 N +REF:0 ! +FUNCTION GNIBCC + 273.00 +8715.084-3.556*T+GHSERNI#; 6000.00 N +REF:0 ! + +$FCC_A1 phase + +TYPE_DEFINITION ' GES A_P_D FCC_A1 MAGNETIC -3.0 0.28 ! +TYPE_DEFINITION % SEQ *! +PHASE FCC_A1 %' 2 1 1 ! +CONSTITUENT FCC_A1 : CR,FE%,NI : VA% : ! + +PARAMETER G(FCC_A1,CR:VA;0) 273.00 +7284+0.163*T+GHSERCR#; 6000.00 N +REF:0 ! +PARAMETER G(FCC_A1,FE:VA;0) 273.00 -1462.4+8.282*T-1.15*T*LN(T) + +0.00064*T**2+GHSERFE#; 1811.00 Y + -1713.815+0.94001*T+0.4925095E+31*T**(-9)+GHSERFE#; 6000.00 N +REF:0 ! +PARAMETER G(FCC_A1,NI:VA;0) 273.00 +GHSERNI#; 3000.00 N +REF:0 ! +PARAMETER L(FCC_A1,CR,FE:VA;0) 273.00 +10833-7.477*T; 6000.00 N +REF:11 ! +PARAMETER L(FCC_A1,CR,FE:VA;1) 273.00 +1410; 6000.00 N +REF:11 ! +PARAMETER L(FCC_A1,CR,NI:VA;0) 273.00 +8030-12.8801*T; 6000.00 N +REF:11 ! +PARAMETER L(FCC_A1,CR,NI:VA;1) 273.00 +33080-16.0362*T; 6000.00 N +REF:11 ! +PARAMETER L(FCC_A1,FE,NI:VA;0) 273.00 -12054.355+3.27413*T; 6000.00 N +REF:20 ! +PARAMETER L(FCC_A1,FE,NI:VA;1) 273.00 +11082.1315-4.45077*T; 6000.00 N +REF:20 ! +PARAMETER L(FCC_A1,FE,NI:VA;2) 273.00 -725.805174; 6000.00 N +REF:20 ! +PARAMETER L(FCC_A1,CR,FE,NI:VA;0) 273.00 +8000-8*T; 6000.00 N +REF:jac17 ! +PARAMETER L(FCC_A1,CR,FE,NI:VA;1) 273.00 -6500; 6000.00 N +REF:jac17 ! +PARAMETER L(FCC_A1,CR,FE,NI:VA;2) 273.00 +30000; 6000.00 N +REF:jac17 ! +PARAMETER TC(FCC_A1,CR:VA;0) 273.00 -1109; 6000.00 N +REF:11 ! +PARAMETER BMAGN(FCC_A1,CR:VA;0) 273.00 -2.46; 6000.00 N +REF:11 ! +PARAMETER TC(FCC_A1,CR,NI:VA;0) 273.00 -3605; 6000.00 N +REF:11 ! +PARAMETER BMAGN(FCC_A1,CR,NI:VA;0) 273.00 -1.91; 6000.00 N +REF:11 ! +PARAMETER TC(FCC_A1,FE:VA;0) 273.00 -201; 6000.00 N +REF:20 ! +PARAMETER BMAGN(FCC_A1,FE:VA;0) 273.00 -2.1; 6000.00 N +REF:20 ! +PARAMETER TC(FCC_A1,FE,NI:VA;0) 273.00 +2133; 6000.00 N +REF:20 ! +PARAMETER TC(FCC_A1,FE,NI:VA;1) 273.00 -682; 6000.00 N +REF:20 ! +PARAMETER BMAGN(FCC_A1,FE,NI:VA;0) 273.00 +9.55; 6000.00 N +REF:20 ! +PARAMETER BMAGN(FCC_A1,FE,NI:VA;1) 273.00 +7.23; 6000.00 N +REF:20 ! +PARAMETER BMAGN(FCC_A1,FE,NI:VA;2) 273.00 +5.93; 6000.00 N +REF:20 ! +PARAMETER BMAGN(FCC_A1,FE,NI:VA;3) 273.00 +6.18; 6000.00 N +REF:20 ! +PARAMETER TC(FCC_A1,NI:VA;0) 273.00 +633; 6000.00 N +REF:0 ! +PARAMETER BMAGN(FCC_A1,NI:VA;0) 273.00 +0.52; 6000.00 N +REF:0 ! + +$BCC_A2 phase + +TYPE_DEFINITION & GES A_P_D BCC_A2 MAGNETIC -1.0 0.4 ! +PHASE BCC_A2 %& 2 1 3 ! +CONSTITUENT BCC_A2 : CR,FE%,NI : VA% : ! + +PARAMETER G(BCC_A2,CR:VA;0) 273.00 +GHSERCR#; 6000.00 N +REF:0 ! +PARAMETER G(BCC_A2,FE:VA;0) 273.00 +GHSERFE#; 6000.00 N +REF:0 ! +PARAMETER G(BCC_A2,NI:VA;0) 273.00 +8715.084-3.556*T+GHSERNI#; 3000.00 N +REF:0 ! +PARAMETER L(BCC_A2,CR,FE:VA;0) 273.00 +20500-9.68*T; 6000.00 N +REF:11 ! +PARAMETER L(BCC_A2,CR,NI:VA;0) 273.00 +17170-11.8199*T; 6000.00 N +REF:11 ! +PARAMETER L(BCC_A2,CR,NI:VA;1) 273.00 +34418-11.8577*T; 6000.00 N +REF:11 ! +PARAMETER L(BCC_A2,CR,NI:VA;2) 273.00 +1e-8; 6000.00 N +REF:11 ! +PARAMETER L(BCC_A2,FE,NI:VA;0) 273.00 -956.63-1.28726*T; 6000.00 N +REF:20 ! +PARAMETER L(BCC_A2,FE,NI:VA;1) 273.00 +5000-5*T; 6000.00 N +REF:pov12 ! +PARAMETER L(BCC_A2,CR,FE,NI:VA;0) 273.00 +3000+5*T; 6000.00 N +REF:jac17 ! +PARAMETER L(BCC_A2,CR,FE,NI:VA;1) 273.00 +9000-6*T; 6000.00 N +REF:jac17 ! +PARAMETER L(BCC_A2,CR,FE,NI:VA;2) 273.00 -30000+20*T; 6000.00 N +REF:jac17 ! +PARAMETER TC(BCC_A2,CR:VA;0) 273.00 -311.5; 6000.00 N +REF:22 ! +PARAMETER BMAGN(BCC_A2,CR:VA;0) 273.00 -0.008; 6000.00 N +REF:0 ! +PARAMETER TC(BCC_A2,FE:VA;0) 273.00 +1043; 6000.00 N +REF:0 ! +PARAMETER BMAGN(BCC_A2,FE:VA;0) 273.00 +2.22; 6000.00 N +REF:0 ! +PARAMETER TC(BCC_A2,NI:VA;0) 273.00 +575; 6000.00 N +REF:0 ! +PARAMETER BMAGN(BCC_A2,NI:VA;0) 273.00 +0.85; 6000.00 N +REF:0 ! +PARAMETER TC(BCC_A2,CR,FE:VA;0) 273.00 +1650; 6000.00 N +REF:11 ! +PARAMETER TC(BCC_A2,CR,FE:VA;1) 273.00 +550; 6000.00 N +REF:11 ! +PARAMETER BMAGN(BCC_A2,CR,FE:VA;0) 273.00 -0.85; 6000.00 N +REF:pov09 ! +PARAMETER TC(BCC_A2,CR,NI:VA;0) 273.00 +2373; 6000.00 N +REF:11 ! +PARAMETER TC(BCC_A2,CR,NI:VA;1) 273.00 +617; 6000.00 N +REF:11 ! +PARAMETER BMAGN(BCC_A2,CR,NI:VA;0) 273.00 +4; 6000.00 N +REF:11 ! + +$SIGMA phase + +PHASE SIGMA % 3 8 4 18 ! +CONSTITUENT SIGMA : FE%,NI : CR% : CR,FE,NI :! + +PARAMETER G(SIGMA,FE:CR:CR;0) 273.00 +8*GFEFCC#+22*GHSERCR# + +92300-95.96*T; 6000.00 N +REF:62 ! +PARAMETER G(SIGMA,FE:CR:FE;0) 273.00 +117300-95.96*T+8*GFEFCC# + +4*GHSERCR#+18*GHSERFE#; 6000.00 N +REF:62 ! +PARAMETER G(SIGMA,FE:CR:NI;0) 273.00 -50000+32*T+8*GFEFCC#+4*GHSERCR# + +18*GNIBCC#; 6000.00 N +REF:pov13 ! +PARAMETER G(SIGMA,NI:CR:CR;0) 273.00 +8*GHSERNI#+22*GHSERCR# + +180000-170*T; 6000.00 N +REF:13 ! +PARAMETER G(SIGMA,NI:CR:FE;0) 273.00 +8*GHSERNI#+4*GHSERCR# + +18*GHSERFE#-50000+32*T; 6000.00 N +REF:pov13 ! +PARAMETER G(SIGMA,NI:CR:NI;0) 273.00 +8*GHSERNI#+4*GHSERCR# + +18*GNIBCC#+175400; 6000.00 N +REF:13 ! +PARAMETER L(SIGMA,FE:CR:CR,NI;0) 273.00 +1e-8; 6000.00 N +REF:pov12 ! +PARAMETER L(SIGMA,FE:CR:FE,NI;0) 273.00 -200000; 6000.00 N +REF:pov13 ! + +$FCC mobility +$CR + +PARAMETER MQ(FCC_A1&CR,CR:*) 273.00 -235000-82.0*T; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&CR,FE:*) 273.00 -286000-71.9*T; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&CR,NI:*) 273.00 -287000-64.4*T; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&CR,CR,FE:*;0) 273.00 -105000; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&CR,CR,NI:*;0) 273.00 -68000; 6000.00 N +Ref:41 ! +PARAMETER MQ(FCC_A1&CR,FE,NI:*;0) 273.00 +16100; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&CR,CR,FE,NI:*;0) 273.00 +310000; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&CR,CR,FE,NI:*;1) 273.00 +320000; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&CR,CR,FE,NI:*;2) 273.00 +120000; 6000.00 N +Ref:17 ! + +$FE + +PARAMETER MQ(FCC_A1&FE,CR:*) 273.00 -235000-82.0*T; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&FE,FE:*) 273.00 -286000+R*T*LN(7.0E-5); 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&FE,NI:*) 273.00 -287000-67.5*T; 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&FE,CR,FE:*;0) 273.00 +15900; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&FE,CR,NI:*;0) 273.00 -77500; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&FE,FE,NI:*;0) 273.00 -115000+104*T; 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&FE,FE,NI:*;1) 273.00 +78800-73.3*T; 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&FE,CR,FE,NI:*;0) 273.00 -740000; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&FE,CR,FE,NI:*;1) 273.00 -540000; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&FE,CR,FE,NI:*;2) 273.00 +750000; 6000.00 N +Ref:17 ! + +$NI + +PARAMETER MQ(FCC_A1&NI,CR:*) 273.00 -235000-82.0*T; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&NI,FE:*) 273.00 -286000-86.0*T; 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&NI,NI:*) 273.00 -287000-69.8*T; 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&NI,CR,FE:*;0) 273.00 -119000; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&NI,CR,NI:*;0) 273.00 -81000; 6000.00 N +Ref:19 ! +PARAMETER MQ(FCC_A1&NI,FE,NI:*;0) 273.00 +124000-51.4*T; 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&NI,FE,NI:*;1) 273.00 -300000+213*T; 6000.00 N +Ref:18 ! +PARAMETER MQ(FCC_A1&NI,CR,FE,NI:*;0) 273.00 +1840000; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&NI,CR,FE,NI:*;1) 273.00 +670000; 6000.00 N +Ref:17 ! +PARAMETER MQ(FCC_A1&NI,CR,FE,NI:*;2) 273.00 -1120000; 6000.00 N +Ref:17 ! + +$BCC Mobility + +$CR + +PARAMETER MQ(BCC_A2&CR,CR:*) 273.00 -407000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,CR:*) 273.00 -35.6*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,FE:*) 273.00 -218000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,FE:*) 273.00 +R*T*LN(8.5E-5); 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,NI:*) 273.00 -218000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,NI:*) 273.00 +R*T*LN(8.5E-5); 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,CR,FE:*;0) 273.00 +361000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,CR,FE:*;0) 273.00 -116*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,CR,FE:*;1) 273.00 +2820; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,CR,FE:*;1) 273.00 +37.5*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,CR,NI:*;0) 273.00 +350000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,CR,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,FE,NI:*;0) 273.00 +150000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,FE,NI:*;1) 273.00 +150000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,CR,FE,NI:*;1) 273.00 -2400000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&CR,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&CR,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! + +$FE + +PARAMETER MQ(BCC_A2&FE,CR:*) 273.00 -407000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,CR:*) 273.00 -17.2*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,FE:*) 273.00 -218000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,FE:*) 273.00 +R*T*LN(4.6E-5); 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,NI:*) 273.00 -218000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,NI:*) 273.00 +R*T*LN(4.6E-5); 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,CR,FE:*;0) 273.00 +267000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,CR,FE:*;0) 273.00 -117*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,CR,FE:*;1) 273.00 -416000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,CR,FE:*;1) 273.00 +348*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,CR,NI:*;0) 273.00 +350000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,CR,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,FE,NI:*;0) 273.00 +150000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,CR,FE,NI:*;1) 273.00 +1400000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&FE,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&FE,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! + +$NI + +PARAMETER MQ(BCC_A2&NI,CR:*) 273.00 -407000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,CR:*) 273.00 -17.2*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,FE:*) 273.00 -204000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,FE:*) 273.00 +R*T*LN(1.8E-5); 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,NI:*) 273.00 -204000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,NI:*) 273.00 +R*T*LN(1.8E-5); 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,CR,FE:*;0) 273.00 +88000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,CR,FE:*;0) 273.00 +10*T; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,CR,NI:*;0) 273.00 +350000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,CR,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,FE,NI:*;0) 273.00 +150000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,CR,FE,NI:*;1) 273.00 -500000; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MQ(BCC_A2&NI,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! +PARAMETER MF(BCC_A2&NI,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N +Ref:14 ! + +""" + +ALMGSI_DB = """ + + +$ AL-MG-SI system with metastable phases +$ +$ Parameters for metastable phases and mobility +$ taken from E. Povoden-Karadeniz et al, CALPHAD 43 (2011) p. 94 +$ + +$Element Standard state mass [g/mol] H_298 S_298 +ELEMENT VA VACUUM 0.0 0.00 0.00 ! +ELEMENT AL FCC_A1 26.98154 4540 28.30 ! +ELEMENT MG HCP_A3 24.305 4998.0 32.671 ! +ELEMENT SI DIA_A4 28.0855 3217. 18.81 ! + + +$ +$FUNCTIONS FOR PURE ELEMENT +$ +FUNCTION GHSERAL + 273.00 -7976.15+137.093038*T-24.3671976*T*LN(T) + -1.884662E-3*T**2-0.877664E-6*T**3+74092*T**(-1); 700.00 Y + -11276.24+223.048446*T-38.5844296*T*LN(T) + +18.531982E-3*T**2-5.764227E-6*T**3+74092*T**(-1); 933.47 Y + -11278.378+188.684153*T-31.748192*T*LN(T)-1.231E+28*T**(-9); 2900.00 N +REF:0 ! +FUNCTION GHSERMG + 273.00 -8367.34+143.675547*T-26.1849782*T*LN(T)+0.4858E-3*T**2 + -1.393669E-6*T**3+78950*T**(-1); 923.00 Y + -14130.185+204.716215*T-34.3088*T*LN(T)+1038.192E25*T**(-9); 3000.00 N +REF:0 ! +FUNCTION GHSERSI + 273.00 -8162.609+137.236859*T-22.8317533*T*LN(T) + -1.912904E-3*T**2-0.003552E-6*T**3+176667*T**(-1); 1687.00 Y + -9457.642+167.271767*T-27.196*T*LN(T)-4.2037E+30*T**(-9); 3600.00 N +REF:0 ! + +$ +$ OTHER FUNCTIONS +$ +FUNCTION R + 273.00 +8.31451; 6000.00 N ! +FUNCTION GMG2SI 273.00 -92250.0+440.4*T-75.9*T*LN(T) + -0.0018*T**2+630000*T**(-1); 6000.00 N +REF:31 ! + +$ +$ LIQUID +$ + TYPE-DEF % SEQ * ! + PHASE LIQUID % 1 1.0 > +Random substitutional model. +>> 6 ! + CONSTITUENT LIQUID : AL,MG,SI: ! + +PARAMETER G(LIQUID,AL;0) + 273.00 +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL#; 700.00 Y + +11005.03-11.841867*T+7.9337E-20*T**7+GHSERAL#; 933.47 Y + +10482.382-11.253974*T+1.231E+28*T**(-9)+GHSERAL#; 2900.00 N +REF:0 ! +PARAMETER G(LIQUID,MG;0) + 273.00 +8202.243-8.83693*T+GHSERMG#-8.0176E-20*T**7; 923.00 Y + +8690.316-9.392158*T+GHSERMG#-1.038192E+28*T**(-9); 6000.00 N +REF:31 ! +PARAMETER G(LIQUID,SI;0) + 273.00 +50696.36-30.099439*T+2.0931E-21*T**7+GHSERSI#; 1687.00 Y + +49828.165-29.559068*T+4.2037E+30*T**(-9)+GHSERSI#; 3600.00 N +REF:0 ! + +PARAMETER L(LIQUID,AL,MG;0) 273.00 -12000.0+8.566*T; 6000.00 N +REF:31 ! +PARAMETER L(LIQUID,AL,MG;1) 273.00 +1894.0-3.000*T; 6000.00 N +REF:31 ! +PARAMETER L(LIQUID,AL,MG;2) 273.00 +2000.0; 6000.00 N +REF:31 ! +PARAMETER L(LIQUID,AL,SI;0) 273.00 -11655.93-0.92934*T; 6000.00 N +REF:37 ! +PARAMETER L(LIQUID,AL,SI;1) 273.00 -2873.45+0.2945*T; 6000.00 N +REF:37 ! +PARAMETER L(LIQUID,AL,SI;2) 273.00 +2520; 6000.00 N +REF:37 ! +PARAMETER L(LIQUID,MG,SI;0) 273.00 -70055+24.98*T; 6000.00 N +REF:39 ! +PARAMETER L(LIQUID,MG,SI;1) 273.00 -1300; 6000.00 N +REF:39 ! +PARAMETER L(LIQUID,MG,SI;2) 273.00 +6272; 6000.00 N +REF:39 ! + +PARAMETER L(LIQUID,AL,MG,SI;0) 273.00 +11882; 6000.00 N +REF:34 ! +PARAMETER L(LIQUID,AL,MG,SI;1) 273.00 -24207; 6000.00 N +REF:34 ! +PARAMETER L(LIQUID,AL,MG,SI;2) 273.00 -38223; 6000.00 N +REF:34 ! + +$ +$ FCC_A1 +$ + PHASE FCC_A1 % 2 1 1 > Al-Matrix phase, face-centered cubic >> 6 ! + CONSTITUENT FCC_A1 : AL%,MG,SI : VA : ! + +PARAMETER G(FCC_A1,AL:VA;0) 273.00 +GHSERAL#; 2900.00 N +REF:0 ! +PARAMETER G(FCC_A1,MG:VA;0) 273.00 +2600-0.90*T+GHSERMG#; 6000.00 N +REF:0 ! +PARAMETER G(FCC_A1,SI:VA;0) 273.00 +51000-21.8*T+GHSERSI#; 3600.00 N +REF:0 ! + +PARAMETER L(FCC_A1,AL,MG:VA;0) 273.00 +1*LDF0ALMG#; 6000.00 N +REF:41 ! +PARAMETER L(FCC_A1,AL,MG:VA;1) 273.00 +1*LDF1ALMG#; 6000.00 N +REF:41 ! +PARAMETER L(FCC_A1,AL,MG:VA;2) 273.00 +1*LDF2ALMG#; 6000.00 N +REF:41 ! +PARAMETER L(FCC_A1,AL,SI:VA;0) 273.00 +1*LDF0ALSI#; 6000.00 N +REF:41 ! +PARAMETER L(FCC_A1,AL,SI:VA;1) 273.00 +1*LDF1ALSI#; 6000.00 N +REF:37 ! +PARAMETER L(FCC_A1,AL,SI:VA;2) 273.00 +1*LDF2ALSI#; 6000.00 N +REF:37 ! +PARAMETER L(FCC_A1,MG,SI:VA;0) 273.00 +1*LDF0SIMG#; 6000.00 N +REF:41 ! +PARAMETER L(FCC_A1,MG,SI:VA;1) 273.00 +1*LDF1SIMG#; 6000.00 N +REF:31 ! +PARAMETER L(FCC_A1,MG,SI:VA;2) 273.00 +1*LDF2SIMG#; 6000.00 N +REF:31 ! + +$ +$ SI_DIAMOND_A4 +$ + PHASE SI_DIAMOND_A4 % 1 1 > +Silicon precipitate. Space group Fd3m, prototype: C(diamond) +>> 4 ! + CONSTITUENT SI_DIAMOND_A4 : AL,MG,SI% : ! +PARAMETER G(SI_DIAMOND_A4,AL;0) 273.00 +30.0*T+GHSERAL#; 6000.00 N +REF:31 ! +PARAMETER G(SI_DIAMOND_A4,MG;0) 273.00 +GHSERMG#; 6000.00 N +REF:41 ! +PARAMETER G(SI_DIAMOND_A4,SI;0) 273.00 +GHSERSI#; 6000.00 N +REF:31 ! +PARAMETER L(SI_DIAMOND_A4,AL,SI;0) 273.00 +111417.7-46.1392*T; 6000.00 N +REF:37 ! +PARAMETER L(SI_DIAMOND_A4,MG,SI;0) 273.00 +65000; 6000.00 N +REF:41 ! + +$ +$ MG2SI_B +$ + PHASE MG2SI_B % 2 2 1 > +Face-centered cubic equilibrium phase. +Incoherent precipitates (plates or cubes) in the overaging regime, 6xxx alloys. [REF:C31,C32] +>> 5 ! + CONSTITUENT MG2SI_B : MG : SI : ! +PARAMETER G(MG2SI_B,MG:SI;0) 273.00 GMG2SI; 6000.00 N +REF:31 ! + +$ +$ BETA_AL3MG2 +$ + PHASE BETA_AL3MG2 % 2 89 140 > +Cubic (Al,Zn)3Mg2 equilibrium phase, prototype: Al3Mg2. +>> 2 ! + CONSTITUENT BETA_AL3MG2 : MG : AL : ! +PARAMETER G(BETA_AL3MG2,MG:AL;0) 273.00 -246175.0-675.5500*T + +89*GHSERMG#+140*GHSERAL#; 6000.00 N +REF:31 ! + +$ +$ E_AL30MG23 +$ + PHASE E_AL30MG23 % 2 23 30 > +Epsilon equilibrium phase, prototype: Co5Cr2Mo3 +>> 1 ! + CONSTITUENT E_AL30MG23 : MG : AL : ! +PARAMETER G(E_AL30MG23,MG:AL;0) 273.00 -52565.4-173.1775*T + +23*GHSERMG#+30*GHSERAL#; 6000.00 N +REF:31 ! + +$ +$ G_AL12MG17 +$ + PHASE G_AL12MG17 % 3 10 24 24 > +Gamma equilibrium phase, space group: I43m, prototype: Alpha-Mn. +Precipitate in Al-Mg-Zn alloy +>> 2 ! + CONSTITUENT G_AL12MG17 : MG : AL,MG% : AL : ! +PARAMETER G(G_AL12MG17,MG:MG:MG;0) 273.00 +266939.2-174.638*T+58*GHSERMG#; 6000.00 N +REF:40 ! +PARAMETER G(G_AL12MG17,MG:AL:AL;0) 273.00 +195750-203*T + +10*GHSERMG#+48*GHSERAL#; 6000.00 N +REF:40 ! +PARAMETER G(G_AL12MG17,MG:MG:AL;0) 273.00 -105560-101.5*T + +34*GHSERMG#+24*GHSERAL#; 6000.00 N +REF:40 ! +PARAMETER G(G_AL12MG17,MG:AL:MG;0) 273.00 +568249.2-276.138*T + +34*GHSERMG#+24*GHSERAL#; 6000.00 N +REF:40 ! +PARAMETER L(G_AL12MG17,MG:AL:AL,MG;0) 273.00 +226200-29*T; 6000.00 N +REF:40 ! +PARAMETER L(G_AL12MG17,MG:MG:AL,MG;0) 273.00 +226200-29*T; 6000.00 N +REF:40 ! + +$ +$ B_PRIME_L +$ + PHASE B_PRIME_L % 3 3 9 7 > +Metastable B´ phase - low-T type reflecting lowest energy modification from 1st principles. +Structure can be related to the hexagonal structure of Q-Phase, with empty Cu-sites. [REF:C11,C37] +>> 2 ! + CONSTITUENT B_PRIME_L : AL : MG : SI : ! +PARAMETER G(B_PRIME_L,AL:MG:SI;0) 273.00 -140000-10*T+3*GHSERAL#+9*GHSERMG#+7*GHSERSI#; 6000.00 N +REF:41 ! + +$ +$ MGSI_B_P +$ + PHASE MGSI_B_P % 2 1.8 1 > +Beta´, metastable hexagonal close-packed rod-like Mg-Si precipitates in 6xxx alloys. [REF:C31,C32,C34] +>> 5 ! + CONSTITUENT MGSI_B_P : MG : SI : ! + +PARAMETER G(MGSI_B_P,MG:SI;0) 273.00 GMG2SI + 24250 - 40.4*T + 5.9*T*LN(T) - 0.0042*T**2 - 130000*T**(-1); 6000.00 N +REF:41 ! + +$ +$ MG5SI6_B_DP +$ + PHASE MG5SI6_B_DP % 2 5 6 > +Main metastable hardening phase in 6xxx, monoclinic with space group C2/m. Al-free Mg5Si6. +Semicoherent needles. [REF:C31,C32,C35]. +>> 5 ! + CONSTITUENT MG5SI6_B_DP : MG : SI : ! +PARAMETER G(MG5SI6_B_DP,MG:SI;0) 273.00 -5000-30*T-0.0096*T**2 + -1e-7*T**3+5*GHSERMG#+6*GHSERSI#; 6000.00 N +REF:41 ! + +$ +$ U1_PHASE +$ + PHASE U1_PHASE % 3 2 1 2 > +Needle-like precipitate with trigonal structure observed in 6xxx in the beta´ precipitation regime. [REF:C37] +>> 3 ! + CONSTITUENT U1_PHASE : AL : MG : SI : ! +PARAMETER G(U1_PHASE,AL:MG:SI;0) 273.00 -5000-10*T-0.0055*T**2 + +3e-6*T**3+150000*T**(-1)+2*GHSERAL#+GHSERMG#+2*GHSERSI#; 6000.00 N +REF:41 ! + +$ +$ U2_PHASE +$ + PHASE U2_PHASE % 3 1 1 1 > +Needle-like precipitate with orthorhombic structure in 6xxx in the beta' precipitation regime. [REF:C37] +>> 3 ! + CONSTITUENT U2_PHASE : AL : MG : SI : ! +PARAMETER G(U2_PHASE,AL:MG:SI;0) 273.00 -14000-3.75*T-0.0015*T**2 + +7.5e-7*T**3+62500*T**(-1)+1*GHSERAL#+1*GHSERMG#+1*GHSERSI#; 6000.00 N +REF:41 ! + +$ +$ Mobility terms +$ +PARAMETER MQ(FCC_A1&AL,*) 273.00 -127200+R*T*LN(1.39e-5); 6000.00 N +Ref:41 ! + +PARAMETER MQ(FCC_A1&MG,AL:*) 273.00 -119000+R*T*LN(3.7e-5); 6000.00 N +Ref:41! +PARAMETER MQ(FCC_A1&MG,MG:*) 273.00 -112499+R*T*LN(5.7e-5); 6000.00 N +Ref:41! +PARAMETER MQ(FCC_A1&MG,MG,AL:*) 273.00 54511; 6000.00 N +Ref:41! +PARAMETER MQ(FCC_A1&MG,SI:*) 273.00 -119000+R*T*LN(3.7e-5); 6000.00 N +Ref:41! + +PARAMETER MQ(FCC_A1&SI,AL:*) 273.00 -136400+R*T*LN(2.31e-4); 6000.00 N +Ref:41 ! +PARAMETER MQ(FCC_A1&SI,MG:*) 273.00 -136400+R*T*LN(2.31e-4); 6000.00 N +Ref:41 ! +PARAMETER MQ(FCC_A1&SI,SI:*) 273.00 -448400+R*T*LN(154e-4); 6000.00 N +Ref:41 ! + +$ +$ References +$ + +LIST_OF_REFERENCES + +A00201-0 unary A.T. Dinsdale, SGTE Data of pure elements, CALPHAD, Vol. 15, No. 4, pp 317-425, 1991. + 31 bin, tern N. Saunders, COST 507: Thermochemical database for light metal alloys, Vol. 2, pp 23-27, 1998. +A00166-34 Al-Mg-Si J. Lacaze and R. Valdes, CALPHAD-type assessment of the Al-Mg-Si system, Monatshefte f. Chemie, Vol. 136, A00169-37 Al-Fe-Si Z.-K. Liu, Y.A. Chang, Thermodynamic assessment of the Al-Fe-Si system, Metall. Mater. Trans A, Vol. 30A, pp 1081-1095, 1999. +A00172-39 Mg-Si-Li D. Kevorkov, R. Schmid-Fetzer, F. Zhang, Phase equilibria and thermodynamics of the Mg-Si-Li system and remodeling of the Mg-Si system, J. Phase Equilib. Diffusion, Vol. 25, pp 140-151, 2004. +A00173-40 Al-Mg-Zn P. Liang et al., Experimental investigation and thermodynamic calculation of the Al-Mg-Zn system, Thermochim. Acta, Vol. 314, pp 87-110, 1998. + 41 E. Povoden-Karadeniz et al, Calphad modeling of metastable phases in the Al-Mg-Si system, CALPHAD, Vol. 42 pp 94-104, 1991 +$ ################################################################################################################################################################################################################################################################################ + +$ References of phase descriptions + + C31 Al-Mg-Si J.P. Lynch, L.M. Brown, M.H.Jacobs, Microanalysis of age-hardening precipitates in Aluminium-alloys, Acta metall. mater. 30 (1982) 1389. +C00025-C32 Al-Mg-Si G.A. Edwards, K. Stiller, G.L. Dunlop, M.J. Couper, The precipitaton sequence in Al-Mg-Si alloys, Acta mater. 46 (1998) 3893-3904. +C00026-C33 Al-Mg-Si, GP-zones K. Matsuda, H. Gamada, K. Fujii, Y. Uetani, T. Sato, A. Kamio, S. Ikeno, High-resolution electron microscopy on the structure of Guinier-Preston zones in an Al-1.6mass% Mg2Si alloy, Metall. mater. trans. A 29 (1998) 1161-1167. +C00027-C34 Mg-Si beta´ R. Vissers, M.A. van Huis, J. Jansen, H.W. Zandbergen, C.D. Marioara, S.J. Andersen, The structure of the beta´ phase in Al-Mg-Si alloys, Acta mater. 55 (2007) 3815-3823. +C00028-C35 Mg-Si beta´´ H.W. Zandbergen, S.J. Andersen, J. Jansen, Structure determination of Mg5Si6 particles in Al by dynamic electron diffraction studies, Science 277 (1997) 1221-1225. + C36 Al-Mg-Si H.S. Hasting, A.G. Froseth, S.J. Andersen, R. Vissers, J.C. Walmsley, C.D. Marioara, F. Danoix, W. Lefebvre, R. Holmestad, Composition of beta´´ precipitates in Al-Mg-Si alloys by atom probe tomography and first principles calculations, J. appl. phys. 106 (2009) 123527. +C00029-C37 Al-Mg-Si, U-phases S.J. Andersen, C.D. Marioara, R. Vissers, A. Froseth, H.W. Zandbergen, The structural relation between precipitates in Al-Mg-Si alloys, the Al-matrix and diamond silicon, with emphasis on the trigonal U1-MgAl2Si2, Mater. sci. eng. A 444 (2007) 157-169. + + 11 Smithells Metals Reference Book, Seventh Edition, Butterworth-Heinemann, Oxford, 1999. + 32 J. Yao, Y.W. Cui, H. Liu, H. Kou, J. Li, L. Zhou, Computer Coupling of Phase Diagrams and Thermochemistry Vol.32, 602-607, 2008. +""" + +CUNI_TDB = """ +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +$$ Cu-Ni thermodynamic database +$$ +$$ Unaries from SGTE 1991 +$$ Binary assessment from S. Mey, Calphad 16:3 (1992) 255 +$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ +ELEMENT VA VACUUM 0.0000E+00 0.0000E+00 0.0000E+00 ! +ELEMENT CU FCC_A1 6.3546E+01 5.0041E+03 3.3150E+01 ! +ELEMENT NI FCC_A1 5.8690E+01 4.7870E+03 2.9796E+01 ! + + TYPE_DEFINITION % SEQ *! + DEFINE_SYSTEM_DEFAULT SPECIE 2 ! + DEFAULT_COMMAND DEF_SYS_ELEMENT VA ! + + TYPE_DEFINITION ( GES A_P_D FCC_A1 MAGNETIC -3.0 0.28 ! + PHASE FCC_A1 %( 2 1 1 ! + CONSTITUENT FCC_A1 : CU,NI : VA : ! + + PHASE LIQUID:L % 1 1 ! + CONSTITUENT LIQUID:L : CU,NI : ! + +$ Cu +$ ------------------------------------- + FUNCTION GHSERCU 298.15 + -7770.458+130.485235*T-24.112392*T*LN(T)-2.65684E-3*T**2+0.129223E-6*T**3 + +52478*T**(-1); 1357.77 Y + -13542.026+183.803828*T-31.38*T*LN(T)+364.167E27*T**(-9); 3200.00 N ! + + FUNCTION GBCCCU 298.15 4017-1.255*T+GHSERCU; 3200 N ! + + FUNCTION GHCPCU 298.15 600+0.2*T+GHSERCU; 3200 N ! + + FUNCTION GLIQCU 298.15 12964.735-9.511904*T-584.89E-23*T**7+GHSERCU; 1357.77 Y + -46.545+173.881484*T-31.38*T*LN(T); 3200 N ! + +$ Ni +$ ------------------------------------- + FUNCTION GHSERNI 298.15 + -5179.159+117.854*T-22.096*T*LN(T)-4.8407E-3*T**2; 1728.00 Y + -27840.620+279.134977*T-43.1*T*LN(T)+1127.54E28*T**(-9); 3000.00 N ! + + FUNCTION GLIQNI 298.15 16414.686-9.397*T-382.318E-23*T**7+GHSERNI; 1728 Y + -9549.817+268.597977*T-43.1*T*LN(T); 3000 N ! + + FUNCTION GBCCNI 298.15 8715.084-3.556*T+GHSERNI; 3000 N ! + + FUNCTION GHCPNI 298.15 1046+1.2552*T+GHSERNI; 3000 N ! + +$ Unaries parameters + PARAMETER G(FCC_A1,CU:VA;0) 298.15 GHSERCU; 3200 N ! + PARAMETER G(LIQUID,CU;0) 298.15 GLIQCU; 3200 N ! + + PARAMETER G(FCC_A1,NI:VA;0) 298.15 GHSERNI; 3000 N ! + PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633; 3000 N ! + PARAMETER BM(FCC_A1,NI:VA;0) 298.15 0.52; 3000 N ! + PARAMETER G(LIQUID,NI;0) 298.15 GLIQNI; 3000 N ! + +$ Binary parameters + PARAMETER G(FCC_A1,CU,NI:VA;0) 298.15 8047.72 + 3.42217*T; 6000 N ! + PARAMETER G(FCC_A1,CU,NI:VA;1) 298.15 -2041.30 + 0.99714*T; 6000 N ! + PARAMETER TC(FCC_A1,CU,NI:VA;0) 298.15 -935.5; 3000 N ! + PARAMETER TC(FCC_A1,CU,NI:VA;1) 298.15 -594.9; 3000 N ! + PARAMETER BM(FCC_A1,CU,NI:VA;0) 298.15 -0.732; 3000 N ! + PARAMETER BM(FCC_A1,CU,NI:VA;1) 298.15 -0.317; 3000 N ! + + PARAMETER G(LIQUID,CU,NI;0) 298.15 12048.61 + 1.29093*T; 6000 N ! + PARAMETER G(LIQUID,CU,NI;1) 298.15 -1861.61 + 0.94201*T; 6000 N ! +""" \ No newline at end of file diff --git a/kawin/tests/datasets.py b/kawin/tests/datasets.py index c9914b0..2a9b4de 100644 --- a/kawin/tests/datasets.py +++ b/kawin/tests/datasets.py @@ -1,2437 +1,148 @@ ''' -Databases for unit testing +Espei datasets for unit testing ''' -ALZR_TDB = """ -$Al-Zr database -$From T. Wang, Z. Jin, J. Zhao, Journal of Phase Equilibria, 22 (2001) p. 544 -$ -TEMP_LIM 298.15 6000 ! -$Element Standard state mass [g/mol] H_298 S_298 -ELEMENT /- ELECTRON_GAS 0.0 0.0 0.0 ! -ELEMENT VA VACUUM 0.0000E+00 0.0000E+00 0.0000E+00 ! -ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01 ! -ELEMENT ZR HCP_A3 9.1224E+01 5.5663E+03 3.9181E+01 ! -$ -$ - TYPE_DEFINITION % SEQ *! -$ -$PHASE AL3ZR -PHASE AL3ZR % 2 0.75 0.25 ! -CONST AL3ZR : AL : ZR : ! -$ -$PHASE FCC_A1 -PHASE FCC_A1 % 2 1 1 ! -CONST FCC_A1 : AL%,ZR : VA : ! -$ -$ -$ -$ -$UNARY DATA -$ -$AL (FCC_A1) -FUNCTION GHSERAL 298.15 -7976.15+137.093038*T-24.3671976*T*LOG(T) - -1.884662E-3*T**2-0.877664E-6*T**3+74092*T**(-1); - 700.00 Y -11276.24+223.048446*T-38.5844296*T*LOG(T) - +18.531982E-3*T**2-5.764227E-6*T**3+74092*T**(-1); - 933.47 Y -11278.378+188.684153*T-31.748192*T*LOG(T) - -1230.524E25*T**(-9); 2900.00 N ! -$ -$ ZIRCONIUM (GHSERZR FOR HCP_A3) -$ -FUNCTION GHSERZR 130.00 -7827.595+125.64905*T-24.1618*T*LOG(T) - -4.37791E-3*T**2+34971*T**(-1); - 2128.00 Y -26085.921+262.724183*T-42.144*T*LOG(T) - -1342.895E28*T**(-9); 6000.00 N ! - -$ -$ PHASE FCC_A1 -$ -PARAMETER G(FCC_A1,AL:VA;0) 298.15 GHSERAL; 6000.00 N ! -PARAMETER G(FCC_A1,ZR:VA;0) 298.15 7600.00-0.9*T+GHSERZR; 6000.00 N ! -PARAMETER G(FCC_A1,AL,ZR:VA;0) 298.15 -152947+21.3*T; 6000.00 N ! - -$ -$ PHASE AL3ZR -$ -PARAMETER G(AL3ZR,AL:ZR;0) 298.15 -47381 - 24.373*T + 3.894*T*LOG(T) - +0.75*GHSERAL+0.25*GHSERZR; 6000.00 N ! - -$ -$ Diffusion parameters -$ -PARAMETER DF(FCC_A1&ZR,*:VA;0) 298.15 -2.56655 * 8.314 * T; 6000 N ! -PARAMETER DQ(FCC_A1&ZR,*:VA;0) 298.15 -242000; 6000 N ! -""" - -ALZR_TDB_NO_MOB = """ -$Al-Zr database without any mobility parameters -$From T. Wang, Z. Jin, J. Zhao, Journal of Phase Equilibria, 22 (2001) p. 544 -$ -TEMP_LIM 298.15 6000 ! -$Element Standard state mass [g/mol] H_298 S_298 -ELEMENT /- ELECTRON_GAS 0.0 0.0 0.0 ! -ELEMENT VA VACUUM 0.0000E+00 0.0000E+00 0.0000E+00 ! -ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01 ! -ELEMENT ZR HCP_A3 9.1224E+01 5.5663E+03 3.9181E+01 ! -$ -$ - TYPE_DEFINITION % SEQ *! -$ -$PHASE AL3ZR -PHASE AL3ZR % 2 0.75 0.25 ! -CONST AL3ZR : AL : ZR : ! -$ -$PHASE FCC_A1 -PHASE FCC_A1 % 2 1 1 ! -CONST FCC_A1 : AL%,ZR : VA : ! -$ -$ -$ -$ -$UNARY DATA -$ -$AL (FCC_A1) -FUNCTION GHSERAL 298.15 -7976.15+137.093038*T-24.3671976*T*LOG(T) - -1.884662E-3*T**2-0.877664E-6*T**3+74092*T**(-1); - 700.00 Y -11276.24+223.048446*T-38.5844296*T*LOG(T) - +18.531982E-3*T**2-5.764227E-6*T**3+74092*T**(-1); - 933.47 Y -11278.378+188.684153*T-31.748192*T*LOG(T) - -1230.524E25*T**(-9); 2900.00 N ! -$ -$ ZIRCONIUM (GHSERZR FOR HCP_A3) -$ -FUNCTION GHSERZR 130.00 -7827.595+125.64905*T-24.1618*T*LOG(T) - -4.37791E-3*T**2+34971*T**(-1); - 2128.00 Y -26085.921+262.724183*T-42.144*T*LOG(T) - -1342.895E28*T**(-9); 6000.00 N ! - -$ -$ PHASE FCC_A1 -$ -PARAMETER G(FCC_A1,AL:VA;0) 298.15 GHSERAL; 6000.00 N ! -PARAMETER G(FCC_A1,ZR:VA;0) 298.15 7600.00-0.9*T+GHSERZR; 6000.00 N ! -PARAMETER G(FCC_A1,AL,ZR:VA;0) 298.15 -152947+21.3*T; 6000.00 N ! - -$ -$ PHASE AL3ZR -$ -PARAMETER G(AL3ZR,AL:ZR;0) 298.15 -47381 - 24.373*T + 3.894*T*LOG(T) - +0.75*GHSERAL+0.25*GHSERZR; 6000.00 N ! -""" - -NICRAL_TDB = """ - -$ The parameters of the following database follows the publication -$ N. Dupin, I. Ansara, Thermodynamic Re-Assessment of the Ternary System -$ Al-Cr-Ni, Calphad, 25 (2), 279-298 (2001). -$ - -$Element Standard state mass [g/mol] H_298 S_298 - ELEMENT /- ELECTRON_GAS .0000E+00 .0000E+00 .0000E+00! - ELEMENT VA VACUUM .0000E+00 .0000E+00 .0000E+00! - ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01! - ELEMENT CR BCC_A2 5.1996E+01 4.0500E+03 2.3560E+01! - ELEMENT NI FCC_A1 5.8690E+01 4.7870E+03 2.9796E+01! - - SPECIES AL2 AL2! - SPECIES CR2 CR2! - SPECIES NI2 NI2! - - - FUNCTION UNASS 298.15 0;,,N ! - - - TYPE_DEFINITION % SEQ *! - DEFINE_SYSTEM_DEFAULT E 2 ! - DEFAULT_COMMAND DEF_SYS_ELEMENT VA ! - DEFAULT_COMMAND REJECT_PHASE NEWSIGMA ! - - DATABASE_INFO ''' - BASE TC-Ni, version 29-09-99' - - ' - ELEMENTS : Al, Cr, Ni' - ' - ASSESSED SYSTEMS :' - ' - BINARIES' - Al-Cr, Al-Ni, Cr-Ni' - TERNARIES' - Al-Cr-Ni' -' - MODELLING ORDER/DISORDER:' -' - A1 and L12 phases are modelled with a single Gibbs energy curve.' - They are FCC_L12#1 (A1) based on (Ni) and FCC_L12#2 (L12) based on' - Ni3Al, differing by their site occupation.' - The same type of relation exists for the A2 and B2 phases. There are' - several possible sets for the phase named BCC_B2. They are either' - disordered (A2) and correspond to the solid solution based on Cr,' - or ordered based on the B2 compound AlNi.' - ! - -ASSESSED_SYSTEMS - AL-CR(;G5 MAJ:BCC_B2/CR:CR:VA ;P3 STP:.75/1200/1) - AL-NI(;P3 STP:.75/1200/1) - CR-NI(;G5 MAJ:BCC_B2/CR:CR:VA C_S:BCC_B2/NI:NI:VA - ;P3 STP:.5/1200/2) - ! - - TYPE_DEFINITION A GES A_P_D FCC_L12 MAGNETIC -3.0 .28 ! - TYPE_DEFINITION E GES A_P_D FCC_A1 MAGNETIC -3.0 .28 ! - TYPE_DEFINITION B GES A_P_D BCC_B2 MAGNETIC -1.0 .40 ! - TYPE_DEFINITION F GES A_P_D BCC_A2 MAGNETIC -1.0 .40 ! - - TYPE_DEFINITION C GES A_P_D BCC_B2 DIS_PART BCC_A2 ! - TYPE_DEFINITION D GES A_P_D FCC_L12 DIS_PART FCC_A1 ! - -$ TYPE_DEFINITION G GES A_P_D FCC_L12 C_S 2 NI:AL:VA ! -$ TYPE_DEFINITION G GES A_P_D FCC_L12 MAJ 1 NI:NI:VA ! -$ TYPE_DEFINITION W GES A_P_D BCC_B2 C_S,, NI:AL:VA ! -$ TYPE_DEFINITION W GES A_P_D BCC_B2 MAJ 1 CR:CR:VA ! - - PHASE GAS:G % 1 1.0 ! - CONST GAS:G :AL,AL2,CR,CR2,NI,NI2 : ! - - PHASE LIQUID:L % 1 1.0 ! - CONST LIQUID:L :AL,CR,NI : ! - - PHASE FCC_A1 %E 2 1 1 ! - CONST FCC_A1 :AL,CR,NI% : VA% : ! - - PHASE BCC_A2 %F 2 1 3 ! - CONST BCC_A2 :AL,CR%,NI,VA : VA : ! - - PHASE HCP_A3 %A 2 1 .5 ! - CONST HCP_A3 :AL,CR,NI : VA% : ! - - PHASE BCC_B2 %BC 3 .5 .5 3 ! - CONST BCC_B2 :AL,CR,NI%,VA : AL%,CR,NI,VA : VA: ! - - PHASE FCC_L12 %AD 3 .75 .25 1 ! - CONST FCC_L12 :AL,CR,NI : AL,CR,NI : VA : ! - - - PHASE C14_LAVES % 2 2.0 1.0 ! - CONST C14_LAVES : AL,CR%,NI : AL,CR,NI : ! - - PHASE C15_LAVES % 2 2.0 1.0 ! - CONST C15_LAVES : AL,CR%,NI : AL,CR,NI : ! - - PHASE C36_LAVES % 2 2.0 1.0 ! - CONST C36_LAVES : AL,CR%,NI : AL,CR,NI : ! - - PHASE SIGMA % 3 8 4 18 ! - CONSTITUENT SIGMA :AL,NI : CR : AL,CR%,NI : ! - - PHASE NEWSIGMA % 3 10 4 16 ! - CONSTITUENT NEWSIGMA :AL,NI : CR : AL,CR,NI : ! - - PHASE CHI_A12 % 3 24 10 24 ! - CONST CHI_A12 :CR,NI : CR : CR,NI : ! - - PHASE MTI2 % 2 1.0 2.0 ! - CONST MTI2 : CR,NI% : AL,CR,NI : ! - - - FUNCTION ZERO 298.15 0;,,N ! - FUNCTION DP 298.15 +P-101325;,,N ! - FUNCTION TROIS 298.15 3;,,N ! - FUNCTION UNTIER 298.15 TROIS**(-1);,,N ! - -$**************************************************************************** -$ -$ UNARY PARAMETERS -$ -$---------------------------------------------------------------------------- -$ -$ Al -$ -$ FUNCTIONS -$ - FUNCTION F154T 298.15 - +323947.58-25.1480943*T-20.859*T*LN(T) - +4.5665E-05*T**2-3.942E-09*T**3-24275.5*T**(-1); - 4300.0 Y - +342017.233-54.0526109*T-17.7891*T*LN(T)+6.822E-05*T**2 - -1.91111667E-08*T**3-14782200*T**(-1); - 8200.0 Y - +542396.07-411.214335*T+22.2419*T*LN(T)-.00349619*T**2 - +4.0491E-08*T**3-2.0366965E+08*T**(-1); 1.00000E+04 N ! -$ - FUNCTION F625T 298.15 - +496408.232+35.479739*T-41.6397*T*LN(T) - +.00249636*T**2-4.90507333E-07*T**3+85390.3*T**(-1); - 900.00 Y - +497613.221+17.368131*T-38.85476*T*LN(T)-2.249805E-04*T**2 - -9.49003167E-09*T**3-5287.23*T**(-1); 2.80000E+03 N ! -$ - FUNCTION GHSERAL 298.15 - -7976.15+137.093038*T-24.3671976*T*LN(T) - -.001884662*T**2-8.77664E-07*T**3+74092*T**(-1); - 700.00 Y - -11276.24+223.048446*T-38.5844296*T*LN(T) - +.018531982*T**2-5.764227E-06*T**3+74092*T**(-1); - 933.60 Y - -11278.378+188.684153*T-31.748192*T*LN(T) - -1.231E+28*T**(-9);,, N ! -$ - FUNCTION GHCPAL 298.15 +5481-1.8*T+GHSERAL;,,N ! -$ - FUNCTION GBCCAL 298.15 +10083-4.813*T+GHSERAL;,,N ! -$ - FUNCTION GLIQAL 298.14 - +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; - 933.59 Y - +10482.282-11.253974*T+1.231E+28*T**(-9)+GHSERAL;,,N ! -$ -$ GAS PHASE -$ - PARAMETER G(GAS,AL;0) 298.15 +F154T+R*T*LN(1E-05*P);,,N REF184 ! - PARAMETER G(GAS,AL2;0) 298.15 +F625T+R*T*LN(1E-05*P);,,N REF448 ! -$ -$ LIQUID PHASE -$ - PARAMETER G(LIQUID,AL;0) 298.13 - +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; - 933.60 Y - +10482.382-11.253974*T+1.231E+28*T**(-9) - +GHSERAL;,,N 91DIN ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,AL:VA;0) 298.15 +GHSERAL;,,N 91DIN ! -$ -$ BCC_A2 PHASE -$ - PARAMETER G(BCC_A2,AL:VA;0) 298.15 +GBCCAL;,,N 91DIN ! - FUNC B2ALVA 295.15 10000-T;,,N ! - FUNC LB2ALVA 298.15 150000;,,N ! - PARAMETER L(BCC_A2,AL,VA:VA;0) 298.15 B2ALVA+LB2ALVA;,,N 99DUP ! -$ -$ HCP_A3 PHASE -$ - PARAMETER G(HCP_A3,AL:VA;0) 298.15 +GHCPAL;,,N 91DIN ! -$ -$ BCC_B2 PHASE -$ - PARAMETER G(BCC_B2,AL:VA:VA;0) 298.15 .5*B2ALVA-.5*LB2ALVA;,,N 99DUP ! - PARAMETER G(BCC_B2,VA:AL:VA;0) 298.15 .5*B2ALVA-.5*LB2ALVA;,,N 99DUP ! -$ -$ ALTI_L10 PHASE -$ - PARAMETER G(ALTI_L10,AL:AL;0) 298.15 2*GHSERAL+4;,,N COST507 ! -$ -$ ALTI3_DO19 PHASE -$ - PARAMETER G(ALTI3_DO19,AL:AL;0) 298.15 +4*GHCPAL;,,N COST507 ! -$ -$ C14_LAVES PHASE -$ - PARAMETER G(C14_LAVES,AL:AL;0) 298.15 +3*GHSERAL+15000;,,N 95DUP8 ! -$ -$ C15_LAVES PHASE -$ - PARAMETER G(C15_LAVES,AL:AL;0) 298.15 +3*GHSERAL+15000;,,N REFLAV ! -$ -$ C36_LAVES PHASE -$ - PARAMETER G(C36_LAVES,AL:AL;0) 298.15 +3*GHSERAL+15000;,,N REFLAV ! -$ -$ H_L21 PHASE -$ - PARAMETER G(H_L21,AL:AL:VA;0) 298.15 +10000-T+GBCCAL;,,N 95DUP8 ! -$ -$ NI3TI_DO24 PHASE -$ - PARAMETER G(NI3TI_DO24,AL:AL;0) 298.15 GHCPAL;,,N 95DUP8 ! -$ -$---------------------------------------------------------------------------- -$ -$ Cr -$ -$ FUNCTIONS -$ - FUNCTION F7454T 298.15 - +390765.331-31.5192154*T-21.36083*T*LN(T) - +7.253215E-04*T**2-1.588679E-07*T**3+10285.15*T**(-1); - 1100.0 Y - +393886.928-44.107465*T-19.96003*T*LN(T)+.001513089*T**2 - -4.23648333E-07*T**3-722515*T**(-1); - 2000.0 Y - +421372.003-231.888524*T+5.362886*T*LN(T)-.00848877*T**2 - +2.984635E-07*T**3-6015405*T**(-1); - 3300.0 Y - +305164.698+251.019831*T-55.20304*T*LN(T)+.005324585*T**2 - -2.850405E-07*T**3+34951485*T**(-1); - 5100.0 Y - +1069921.1-1708.93262*T+175.0508*T*LN(T)-.025574185*T**2 - +4.94447E-07*T**3-4.4276355E+08*T**(-1); - 7600.0 Y - -871952.838+1686.47356*T-204.5589*T*LN(T)+.007475225*T**2 - -4.618745E-08*T**3+1.423504E+09*T**(-1); 1.00000E+04 N ! -$ - FUNCTION F7735T 298.15 +598511.402+41.5353219*T-40.56798*T*LN(T) - +.004961847*T**2-1.61216717E-06*T**3+154422.85*T**(-1); - 800.00 Y - +613345.232-104.20799*T-19.7643*T*LN(T)-.007085085*T**2 - -4.69883E-07*T**3-1738066.5*T**(-1); - 1400.0 Y - +642608.843-369.286259*T+17.64743*T*LN(T)-.02767321*T**2 - +1.605906E-06*T**3-5831655*T**(-1); - 2300.0 Y - +553119.895+159.188556*T-52.07969*T*LN(T)-.004229401*T**2 - +1.5939925E-07*T**3+14793625*T**(-1); - 3900.0 Y - +347492.339+623.137624*T-105.0428*T*LN(T)+3.9699545E-04*T**2 - +1.51783483E-07*T**3+1.4843765E+08*T**(-1); - 5800.0 Y - -484185.055+2598.25559*T-334.7145*T*LN(T)+.028597625*T**2 - -4.97520167E-07*T**3+7.135805E+08*T**(-1); 6.00000E+03 N ! -$ - FUNCTION GHSERCR 298.14 - -8856.94+157.48*T-26.908*T*LN(T) - +.00189435*T**2-1.47721E-06*T**3+139250*T**(-1); - 2180.0 Y - -34869.344+344.18*T-50*T*LN(T)-2.88526E+32*T**(-9);,,N ! -$ - FUNCTION GCRLIQ 298.15 - +24339.955-11.420225*T+2.37615E-21*T**7+GHSERCR; - 2180.0 Y - -16459.984+335.616316*T-50*T*LN(T);,,N ! -$ - FUNCTION GFCCCR 298.15 +7284+.163*T+GHSERCR;,,N ! -$ - FUNCTION GHCPCR 298.15 +4438+GHSERCR;,,N ! -$ - FUNCTION ACRBCC 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! - FUNCTION BCRBCC 298.15 +1+2.6E-11*P;,,N ! - FUNCTION CCRBCC 298.15 2.08E-11;,,N ! - FUNCTION DCRBCC 298.15 +1*LN(BCRBCC);,,N ! - FUNCTION VCRBCC 298.15 +7.188E-06*EXP(ACRBCC);,,N ! - FUNCTION ECRBCC 298.15 +1*LN(CCRBCC);,,N ! - FUNCTION XCRBCC 298.15 +1*EXP(.8*DCRBCC)-1;,,N ! - FUNCTION YCRBCC 298.15 +VCRBCC*EXP(-ECRBCC);,,N ! - FUNCTION ZCRBCC 298.15 +1*LN(XCRBCC);,,N ! - FUNCTION GPCRBCC 298.15 +YCRBCC*EXP(ZCRBCC);,,N ! -$ - FUNCTION ACRLIQ 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! - FUNCTION BCRLIQ 298.15 +1+4.65E-11*P;,,N ! - FUNCTION CCRLIQ 298.15 3.72E-11;,,N ! - FUNCTION DCRLIQ 298.15 +1*LN(BCRLIQ);,,N ! - FUNCTION VCRLIQ 298.15 +7.653E-06*EXP(ACRLIQ);,,N ! - FUNCTION ECRLIQ 298.15 +1*LN(CCRLIQ);,,N ! - FUNCTION XCRLIQ 298.15 +1*EXP(.8*DCRLIQ)-1;,,N ! - FUNCTION YCRLIQ 298.15 +VCRLIQ*EXP(-ECRLIQ);,,N ! - FUNCTION ZCRLIQ 298.15 +1*LN(XCRLIQ);,,N ! - FUNCTION GPCRLIQ 298.15 +YCRLIQ*EXP(ZCRLIQ);,,N ! -$ -$ GAS PHASE -$ - PARAMETER G(GAS,CR;0) 298.15 +F7454T+R*T*LN(1E-05*P);,,N REF4465 ! - PARAMETER G(GAS,CR2;0) 298.15 +F7735T+R*T*LN(1E-05*P);,, N REF4591 ! -$ -$ LIQUID PHASE -$ - PARAMETER G(LIQUID,CR;0) 298.15 +GCRLIQ+GPCRLIQ;,, N 91DIN ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,CR:VA;0) 298.15 +GFCCCR+GPCRBCC;,,N 89DIN ! - PARAMETER TC(FCC_A1,CR:VA;0) 298.15 -1109;,,N 89DIN ! - PARAMETER BMAGN(FCC_A1,CR:VA;0) 298.15 -2.46;,,N 89DIN ! -$ -$ BCC_A2 PHASE -$ - PARAMETER G(BCC_A2,CR:VA;0) 298.15 +GHSERCR+GPCRBCC;,,N 91DIN ! - PARAMETER TC(BCC_A2,CR:VA;0) 298.15 -311.5;,,N 89DIN ! - PARAMETER BMAGN(BCC_A2,CR:VA;0) 298.15 -.008;,,N 89DIN ! - PARAMETER L(BCC_A2,CR,VA:VA;0) 298.15 100000;,,N 99DUP6 ! -$ -$ HCP_A3 PHASE -$ - PARAMETER G(HCP_A3,CR:VA;0) 298.15 +GHCPCR;,,N 91DIN ! - PARAMETER TC(HCP_A3,CR:VA;0) 298.15 -1109;,,N 89DIN ! - PARAMETER BMAGN(HCP_A3,CR:VA;0) 298.15 -2.46;,,N 89DIN ! -$ -$ BCC_B2 PHASE -$ - PARAMETER G(BCC_B2,CR:VA:VA;0) 298.15 0;,,N 99DUP6 ! - PARAMETER G(BCC_B2,VA:CR:VA;0) 298.15 0;,,N 99DUP6 ! -$ -$ CHI_A12 PHASE -$ - PARAMETER G(CHI_A12,CR:CR:CR;0) 298.15 - +48*GFCCCR+10*GHSERCR+109000+123*T;,,N 87GUS ! -$ -$ ALTI3_DO19 PHASE -$ - PARAMETER G(ALTI3_DO19,CR:CR;0) 298.15 +4*GHCPCR;,,N COST507 ! -$ -$ C14_LAVES PHASE -$ - PARAMETER G(C14_LAVES,CR:CR;0) 298.15 +3*GHSERCR+15000;,,N REFLAV ! -$ -$ C15_LAVES PHASE -$ - PARAMETER G(C15_LAVES,CR:CR;0) 298.15 +3*GHSERCR+15000;,,N REFLAV ! -$ -$ C36_LAVES PHASE -$ - PARAMETER G(C36_LAVES,CR:CR;0) 298.15 +3*GHSERCR+15000;,,N REFLAV ! -$ -$ MTI2 PHASE -$ - PARAMETER G(MTI2,CR:CR;0) 298.15 3*GHSERCR+15000;,,N 99DUP9 ! -$ -$ NI3TI_DO24 PHASE -$ - PARAMETER G(NI3TI_DO24,CR:CR;0) 298.15 GHCPCR;,,N 95DUP9 ! -$ -$ ALTI_L10 PHASE -$ - PARAMETER G(ALTI_L10,CR:CR;0) 298.15 2*GFCCCR;,,N COST507 ! -$ -$---------------------------------------------------------------------------- -$ -$ Ni -$ -$ FUNCTIONS -$ - FUNCTION F13191T 298.15 - +417658.868-44.7777921*T-20.056*T*LN(T) - -.0060415*T**2+1.24774E-06*T**3-16320*T**(-1); - 800.00 Y - +413885.448+9.41787679*T-28.332*T*LN(T)+.00173115*T**2 - -8.399E-08*T**3+289050*T**(-1); - 3900.0 Y - +440866.732-62.5810038*T-19.819*T*LN(T)+5.067E-04*T**2 - -4.93233333E-08*T**3-15879735*T**(-1); - 7600.0 Y - +848806.287-813.398164*T+64.69*T*LN(T)-.00731865*T**2 - +8.71833333E-08*T**3-3.875846E+08*T**(-1); 10000. N ! -$ - FUNCTION F13265T 298.15 - +638073.279-68.1901928*T-24.897*T*LN(T) - -.0313584*T**2+5.93355333E-06*T**3-14215*T**(-1); - 800.00 Y - +611401.772+268.084821*T-75.25401*T*LN(T)+.01088525*T**2 - -7.08741667E-07*T**3+2633835*T**(-1); - 2100.0 Y - +637459.339+72.0712678*T-48.587*T*LN(T)-9.09E-05*T**2 - +9.12933333E-08*T**3-1191755*T**(-1); - 4500.0 Y - +564540.781+329.599011*T-80.11301*T*LN(T)+.00578085*T**2 - -1.08841667E-07*T**3+29137900*T**(-1); 6000.0 N ! -$ - FUNCTION GHSERNI 298.14 - -5179.159+117.854*T-22.096*T*LN(T) - -.0048407*T**2; - 1728.0 Y - -27840.655+279.135*T-43.1*T*LN(T)+1.12754E+31*T**(-9);,, N ! -$ - FUNCTION GHCPNI 298.15 +1046+1.2552*T+GHSERNI;,,N ! -$ - FUNCTION GBCCNI 298.15 +8715.084-3.556*T+GHSERNI;,,, N ! -$ -$ GAS PHASE -$ - PARAMETER G(GAS,NI;0) 298.15 +F13191T+R*T*LN(1E-05*P);,,N REF7504 ! - PARAMETER G(GAS,NI2;0) 298.15 +F13265T+R*T*LN(1E-05*P);,,N REF7553 ! -$ -$ LIQUID PHASE -$ - PARAMETER G(LIQUID,NI;0) 298.13 - +16414.686-9.397*T-3.82318E-21*T**7+GHSERNI; - 1728.0 Y - +18290.88-10.537*T-1.12754E+31*T**(-9) - +GHSERNI;,,N 91DIN ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,NI:VA;0) 298.15 +GHSERNI;,,N 91DIN ! - PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633;,,N 89DIN ! - PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 .52;,,N 89DIN ! -$ -$ BCC_A2 PHASE -$ - PARAMETER G(BCC_A2,NI:VA;0) 298.15 +GBCCNI;,,N 91DIN ! - PARAMETER TC(BCC_A2,NI:VA;0) 298.15 575;,,N 89DIN ! - PARAMETER BMAGN(BCC_A2,NI:VA;0) 298.15 .85;,,N 89DIN ! - FUNC B2NIVA 295.15 +162397.3-27.40575*T;,,N ! - FUNC LB2NIVA 298.15 -64024.38+26.49419*T;,,N ! - PARAMETER L(BCC_A2,NI,VA:VA;0) 298.15 B2NIVA+LB2NIVA;,,N 99DUP ! -$ -$ HCP_A3 PHASE -$ - PARAMETER G(HCP_A3,NI:VA;0) 298.15 +GHCPNI;,,N 91DIN ! - PARAMETER TC(HCP_A3,NI:VA;0) 298.15 633;,,N 86FER1 ! - PARAMETER BMAGN(HCP_A3,NI:VA;0) 298.15 .52;,,N 86FER1 ! -$ -$ BCC_B2 PHASE -$ - PARAMETER G(BCC_B2,VA:NI:VA;0) 298.15 .5*B2NIVA-.5*LB2NIVA;,,N 99DUP ! - PARAMETER G(BCC_B2,NI:VA:VA;0) 298.15 .5*B2NIVA-.5*LB2NIVA;,,N 99DUP ! -$ -$ NI3TI_DO24 PHASE -$ - PARAMETER G(NI3TI_DO24,NI:NI;0) 298.15 +GHCPNI;,,N 90SAU ! -$ -$ ALTI3_DO19 PHASE -$ - PARAMETER G(ALTI3_DO19,NI:NI;0) 298.15 +4*GHCPNI;,,N COST507 ! -$ -$ C14_LAVES PHASE -$ - PARAMETER G(C14_LAVES,NI:NI;0) 298.15 +15000+3*GHSERNI;,,N REFLAV ! -$ -$ C15_LAVES PHASE -$ - PARAMETER G(C15_LAVES,NI:NI;0) 298.15 +15000+3*GHSERNI;,,N REFLAV ! -$ -$ C36_LAVES PHASE -$ - PARAMETER G(C36_LAVES,NI:NI;0) 298.15 +15000+3*GHSERNI;,,N REFLAV ! -$ -$ H_L21 PHASE -$ - PARAMETER G(H_L21,NI:NI:NI;0) 298.15 +2*GBCCNI;,,N 95DUP8 ! - PARAMETER G(H_L21,NI:NI:VA;0) 298.15 +100000+GHSERNI;,,N 95DUP8 ! -$ -$ MTI2 PHASE -$ - PARAMETER G(MTI2,NI:NI;0) 298.15 3*GHSERNI+15000;,,N 99DUP9 ! -$ -$**************************************************************************** -$ -$ BINARY PARAMETERS -$ -$---------------------------------------------------------------------------- -$ -$ Al-Cr -$ Mainly from Saunders (COST507) -$ Metastable B2 and L12 from revision of Al-Cr-Ni -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,AL,CR;0) 298.15 -29000;,,N 91SAU1 ! - PARAMETER L(LIQUID,AL,CR;1) 298.15 -11000;,,N 91SAU1 ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,AL,CR:VA;0) 298.15 -45900+6*T;,,N 91SAU1 ! -$ -$ BCC_A2 PHASE -$ - PARAMETER G(BCC_A2,AL,CR:VA;0) 298.15 -54900+10*T;,,N 91SAU1 ! -$ -$ BCC_B2 PHASE -$ metastable -$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. The B2 -$ phase is not stabilized enough to become stable in the Al-Cr. It is -$ thus not in agreement with "T. Helander, and O. Tolochko, J. of Phase -$ Eq, 20 (1) 1999, 57-60." Further study on the extension of the B2 phase -$ towards AlCr in Al-Cr-Ni would be desirable. - PARAMETER G(BCC_B2,AL:CR:VA;0) 298.15 -2000;,,N 99DUP6 ! - PARAMETER G(BCC_B2,CR:AL:VA;0) 298.15 -2000;,,N 99DUP6 ! -$ -$ FCC_L12 PHASE -$ metastable -$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. - FUN U1ALCR 298.15 -830;,,N 99DUP6 ! - FUN U3ALCR 298.15 0.0; 6000.00 99DUP6 ! - FUN U4ALCR 298.15 0.0; 6000.00 N 99DUP6 ! - FUNCTION L04ALCR 298.15 U3ALCR;,,N ! - FUNCTION L14ALCR 298.15 U4ALCR;,,N ! - FUNCTION ALCR3 298.15 3*U1ALCR;,,N ! - FUNCTION AL2CR2 298.15 4*U1ALCR;,,N ! - FUNCTION AL3CR 298.15 3*U1ALCR;,,N ! - PARAMETER G(FCC_L12,CR:AL:VA;0) 298.15 +ALCR3;,, N 99DUP6 ! - PARAMETER G(FCC_L12,AL:CR:VA;0) 298.15 +AL3CR;,, N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:AL:VA;0) 298.15 - -1.5*ALCR3+1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:CR:VA;0) 298.15 - +1.5*ALCR3+1.5*AL2CR2-1.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:AL:VA;1) 298.15 - +0.5*ALCR3-1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:CR:VA;1) 298.15 - -1.5*ALCR3+1.5*AL2CR2-0.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:AL,CR:VA;0) 298.15 +L04ALCR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:AL,CR:VA;1) 298.15 +L14ALCR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:*:VA;0) 298.15 +3*L04ALCR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:*:VA;1) 298.15 +3*L14ALCR;,,N 99DUP6 ! -$ -$ AL11CR2 PHASE -$ - PHASE AL11CR2 % 3 10 1 2 ! - CONST AL11CR2 :AL : AL : CR : ! - PARAMETER G(AL11CR2,AL:AL:CR;0) 298.15 - +11*GHSERAL+2*GHSERCR-175500+25.805*T;,,N 91SAU1 ! -$ -$ AL13CR2 PHASE -$ - PHASE AL13CR2 % 2 13 2 ! - CONST AL13CR2 :AL : CR : ! - PARAMETER G(AL13CR2,AL:CR;0) 298.15 - +13*GHSERAL+2*GHSERCR-174405+22.2*T;,,N 91SAU1 ! -$ -$ AL4CR PHASE -$ - PHASE AL4CR % 2 4 1 ! - CONST AL4CR :AL : CR : ! - PARAMETER G(AL4CR,AL:CR;0) 298.15 - +4*GHSERAL+GHSERCR-89025+19.05*T;,,N 91SAU1 ! -$ -$ AL8CR5_H PHASE -$ - PHASE AL8CR5_H % 2 8 5 ! - CONST AL8CR5_H :AL : CR : ! - PARAMETER G(AL8CR5_H,AL:CR;0) 298.15 - +8*GHSERAL+5*GHSERCR-147732-58.5*T;,,N 91SAU1 ! -$ -$ AL8CR5_L PHASE -$ - PHASE AL8CR5_L % 2 8 5 ! - CONST AL8CR5_L :AL : CR : ! - PARAMETER G(AL8CR5_L,AL:CR;0) 298.15 - +8*GHSERAL+5*GHSERCR-229515;,,N 91SAU1 ! -$ -$ AL9CR4_H PHASE -$ - PHASE AL9CR4_H % 2 9 4 ! - CONST AL9CR4_H :AL : CR : ! - PARAMETER G(AL9CR4_H,AL:CR;0) 298.15 - +9*GHSERAL+4*GHSERCR-134433-56.16*T;,,N 91SAU1 ! -$ -$ AL9CR4_L PHASE -$ - PHASE AL9CR4_L % 2 9 4 ! - CONST AL9CR4_L :AL : CR : ! - PARAMETER G(AL9CR4_L,AL:CR;0) 298.15 - +9*GHSERAL+4*GHSERCR-230750+16.094*T;,,N 91SAU1 ! -$ -$ ALCR2 PHASE -$ - PHASE ALCR2 % 2 1 2 ! - CONST ALCR2 :AL : CR : ! - PARAMETER G(ALCR2,AL:CR;0) 298.15 - +GHSERAL+2*GHSERCR-32700-8.79*T;,,N 91SAU1 ! -$ -$ AL3TI_DO22 PHASE -$ metastable -$ - PARAMETER G(AL3TI_DO22,AL:CR;0) 298.15 - +3*GHSERAL+GHSERCR-53000;,,N COST507 ! -$ -$ NI3TI_DO24 PHASE -$ metastable -$ - PARA G(NI3TI_DO24,CR:AL;0) 298.15 .25*GHCPAL+.75*GHCPCR;,,N LINEAR ! - PARA G(NI3TI_DO24,AL:CR;0) 298.15 .75*GHCPAL+.25*GHCPCR;,,N LINEAR ! -$ -$ MTI2 PHASE -$ metastable -$ - PARA G(MTI2,CR:AL;0) 298.15 +GHSERCR+2*GHSERAL;,,N LINEAR ! -$ -$ ALTI3_DO19 PHASE -$ metastable -$ - PARA G(ALTI3_DO19,CR:AL;0) 298.15 +GHCPAL+3*GHCPCR;,,N COST507 ! - PARA G(ALTI3_DO19,AL:CR;0) 298.15 +3*GHCPAL+GHCPCR;,,N COST507 ! - PARA L(ALTI3_DO19,AL,CR:AL;0) 298.15 1E-04;,,N COST507 ! - PARA L(ALTI3_DO19,AL:AL,CR;0) 298.15 1E-04;,,N COST507 ! - PARA L(ALTI3_DO19,CR:AL,CR;0) 298.15 1E-04;,,N COST507 ! - PARA L(ALTI3_DO19,AL,CR:CR;0) 298.15 1E-04;,,N COST507 ! -$ -$ ALTI_L10 PHASE -$ metastable -$ - PARA G(ALTI_L10,CR:AL;0) 298.15 -25000+3*T+GHSERAL+GFCCCR;,,N COST507 ! - PARA G(ALTI_L10,AL:CR;0) 298.15 -25000+3*T+GHSERAL+GFCCCR;,,N COST507 ! - PARA L(ALTI_L10,AL,CR:AL;0) 298.15 1E-04;,,N COST507 ! - PARA L(ALTI_L10,AL:AL,CR;0) 298.15 1E-04;,,N COST507 ! - PARA L(ALTI_L10,CR:AL,CR;0) 298.15 1E-04;,,N COST507 ! - PARA L(ALTI_L10,AL,CR:CR;0) 298.15 1E-04;,,N COST507 ! -$ -$ SIGMA PHASE -$ metastable -$ - PARA G(SIGMA,AL:CR:AL;0) 298.15 - 8*GHSERAL+4*GHSERCR+18*GBCCAL+UNASS;,,N 99LEE ! - PARA G(SIGMA,AL:CR:CR;0) 298.15 - 8*GHSERAL+4*GHSERCR+18*GHSERCR+UNASS;,,N 99LEE ! -$ -$ NEWSIGMA PHASE -$ metastable -$ - PARA G(NEWSIGMA,AL:CR:AL;0) 298.15 - +10*GHSERAL+4*GHSERCR+16*GBCCAL;,,N LINEAR ! - PARA G(NEWSIGMA,AL:CR:CR;0) 298.15 - +10*GHSERAL+4*GHSERCR+16*GHSERCR;,,N LINEAR ! -$ -$ C14_LAVES PHASE -$ metastable -$ - PARAMETER G(C14_LAVES,CR:AL;0) 298.15 - +2*GHSERCR+GHSERAL;,,N LINEAR ! - PARAMETER G(C14_LAVES,AL:CR;0) 298.15 - +GHSERCR+2*GHSERAL;,,N LINEAR ! -$ -$ C15_LAVES PHASE -$ metastable -$ - PARAMETER G(C15_LAVES,CR:AL;0) 298.15 - +2*GHSERCR+GHSERAL;,,N LINEAR ! - PARAMETER G(C15_LAVES,AL:CR;0) 298.15 - +GHSERCR+2*GHSERAL;,,N LINEAR ! -$ -$ C36_LAVES PHASE -$ metastable -$ - PARAMETER G(C36_LAVES,CR:AL;0) 298.15 - +2*GHSERCR+GHSERAL;,,N LINEAR ! - PARAMETER G(C36_LAVES,AL:CR;0) 298.15 - +GHSERCR+2*GHSERAL;,,N LINEAR ! -$ -$---------------------------------------------------------------------------- -$ -$ Al-Ni -$ Mainly from ND thesis, -$ slighly revised to get better solvus at low temperature -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,AL,NI;0) 298.15 -207109.28+41.31501*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;1) 298.15 -10185.79+5.8714*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;2) 298.15 +81204.81-31.95713*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;3) 298.15 +4365.35-2.51632*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;4) 298.15 -22101.64+13.16341*T;,,N 95DUP3 ! -$ -$ FCC_A1 PHASE -$ - PARAMETER TC(FCC_A1,AL,NI:VA;0) 298.15 -1112;,,N 95DUP3 ! - PARAMETER TC(FCC_A1,AL,NI:VA;1) 298.15 1745;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;0) 298.15 -162407.75+16.212965*T;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;1) 298.15 +73417.798-34.914168*T;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;2) 298.15 +33471.014-9.8373558*T;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;3) 298.15 -30758.01+10.25267*T;,,N 95DUP3 ! -$ -$ BCC_A2 PHASE -$ metastable -$ - FUNC B2ALNI 295.15 -152397.3+26.40575*T;,,N ! - FUNC LB2ALNI 298.15 -52440.88+11.30117*T;,,N ! - PARAMETER L(BCC_A2,AL,NI:VA;0) 298.15 B2ALNI+LB2ALNI;,,N 99DUP! -$ -$ HCP_A3 PHASE -$ metastable -$ - PARAMETER TC(HCP_A3,AL,NI:VA;0) 298.15 -1112;,,N 95DUP8 ! - PARAMETER TC(HCP_A3,AL,NI:VA;1) 298.15 1745;,,N 95DUP8 ! - PARAMETER L(HCP_A3,AL,NI:VA;0) 298.15 -162407.75+16.212965*T;,,N 95DUP8 ! - PARAMETER L(HCP_A3,AL,NI:VA;1) 298.15 +73417.798-34.914168*T;,,N 95DUP8 ! - PARAMETER L(HCP_A3,AL,NI:VA;2) 298.15 +33471.014-9.8373558*T;,,N 95DUP8 ! - PARAMETER L(HCP_A3,AL,NI:VA;3) 298.15 -30758.01+10.25267*T;,,N 95DUP8 ! -$ -$ BCC_B2 PHASE -$ - PARAMETER G(BCC_B2,AL:NI:VA;0) 298.15 .5*B2ALNI-.5*LB2ALNI;,,N 99DUP ! - PARAMETER G(BCC_B2,NI:AL:VA;0) 298.15 .5*B2ALNI-.5*LB2ALNI;,,N 99DUP ! -$ -$ FCC_L12 PHASE -$ - FUN UALNI 298.15 -22212.8931+4.39570389*T;,,,N 99DUP3 ! - FUN U1ALNI 298.15 2*UNTIER*UALNI;,,,N 99DUP3 ! - FUN U3ALNI 298.15 0;,,,N 99DUP3 ! - FUN U4ALNI 298.15 7203.60609-3.74273030*T;,,,N 99DUP3 ! - FUNCTION L04ALNI 298.15 U3ALNI;,,N 99DUP3 ! - FUNCTION L14ALNI 298.15 U4ALNI;,,N 99DUP3 ! - FUNCTION ALNI3 298.15 +3*U1ALNI;,,,N 99DUP3 ! - FUNCTION AL2NI2 298.15 +4*U1ALNI;,,,N 99DUP3 ! - FUNCTION AL3NI 298.15 +3*U1ALNI;,,,N 99DUP3 ! - PARAMETER G(FCC_L12,NI:AL:VA;0) 298.15 +ALNI3;,,N 99DUP3 ! - PARAMETER G(FCC_L12,AL:NI:VA;0) 298.15 +AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:AL:VA;0) 298.15 - -1.5*ALNI3+1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:NI:VA;0) 298.15 - +1.5*ALNI3+1.5*AL2NI2-1.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:AL:VA;1) 298.15 - +0.5*ALNI3-1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:NI:VA;1) 298.15 - -1.5*ALNI3+1.5*AL2NI2-0.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,*:AL,NI:VA;0) 298.15 +L04ALNI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,*:AL,NI:VA;1) 298.15 +L14ALNI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:*:VA;0) 298.15 +3*L04ALNI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:*:VA;1) 298.15 +3*L14ALNI;,,N 99DUP3 ! -$ -$ AL3NI1 PHASE -$ - PHASE AL3NI1 % 2 .75 .25 ! - CONST AL3NI1 :AL : NI : ! - PARAMETER G(AL3NI1,AL:NI;0) 298.15 - -48483.73+12.29913*T - +.75*GHSERAL+.25*GHSERNI;,,N 95DUP3 ! -$ -$ AL3NI2 PHASE -$ - PHASE AL3NI2 % 3 3 2 1 ! - CONST AL3NI2 :AL : AL,NI% : NI,VA% : ! - PARAMETER G(AL3NI2,AL:AL:NI;0) 298.15 +5*GBCCAL+GBCCNI - -39465.978+7.89525*T;,,N 95DUP3 ! - PARAMETER G(AL3NI2,AL:NI:NI;0) 298.15 +3*GBCCAL+3*GBCCNI - -427191.9+79.21725*T;,,N 95DUP3 ! - PARAMETER G(AL3NI2,AL:AL:VA;0) 298.15 +5*GBCCAL - +30000-3*T;,,N 95DUP3 ! - PARAMETER G(AL3NI2,AL:NI:VA;0) 298.15 +3*GBCCAL+2*GBCCNI - -357725.92+68.322*T;,,N 95DUP3 ! - PARAMETER L(AL3NI2,AL:AL,NI:*;0) 298.15 - -193484.18+131.79*T;,,N 95DUP3 ! - PARAMETER L(AL3NI2,AL:*:NI,VA;0) 298.15 - -22001.7+7.0332*T;,,N 95DUP3 ! -$ -$ AL3NI5 PHASE -$ - PHASE AL3NI5 % 2 .375 .625 ! - CONST AL3NI5 :AL : NI : ! - PARAMETER G(AL3NI5,AL:NI;0) 298.15 +.375*GHSERAL+.625*GHSERNI - -55507.7594+7.2648103*T;,,N 95DUP3 ! -$ -$ MTI2 PHASE -$ metastable -$ - PARAMETER G(MTI2,NI:AL;0) 298.15 GHSERNI+2*GHSERAL+80810;,,N 95DUP8 ! -$ -$ C14_LAVES PHASE -$ metastable -$ - PARAMETER G(C14_LAVES,NI:AL;0) 298.15 - +2*GHSERNI+GHSERAL+130000;,,N 99DUP8 ! - PARAMETER G(C14_LAVES,AL:NI;0) 298.15 - +GHSERNI+2*GHSERAL-100000;,,N 99DUP8 ! -$ -$ C15_LAVES PHASE -$ metastable -$ - PARAMETER G(C15_LAVES,NI:AL;0) 298.15 - +2*GHSERNI+GHSERAL+130000-2000;,,N 99DUP8 ! - PARAMETER G(C15_LAVES,AL:NI;0) 298.15 - +GHSERNI+2*GHSERAL-100000+2000;,,N 99DUP8 ! -$ -$ C36_LAVES PHASE -$ metastable -$ - PARAMETER G(C36_LAVES,NI:AL;0) 298.15 - +2*GHSERNI+GHSERAL+130000-3000;,,N 99DUP8 ! - PARAMETER G(C36_LAVES,AL:NI;0) 298.15 - +GHSERNI+2*GHSERAL-100000+3000;,,N 99DUP8 ! -$ -$ H_L21 PHASE -$ metastable -$ - FUNCTION GHALNI 298.15 -152397.3+26.40575*T+GBCCAL+GBCCNI+4000;,,N 99DUP8 ! - PARAMETER G(H_L21,AL:AL:NI;0) 298.15 +GHALNI;,,N 99DUP8 ! - PARAMETER G(H_L21,NI:AL:NI;0) 298.15 +.5*GHALNI+GBCCNI;,,N 99DUP8 ! - PARAMETER G(H_L21,AL:NI:NI;0) 298.15 +.5*GHALNI+GBCCNI;,,N 99DUP8 ! - PARAMETER G(H_L21,NI:AL:VA;0) 298.15 +.5*GBCCAL+.5*GHSERNI - +55000-.5*T;,,N 99DUP8 ! - PARAMETER G(H_L21,AL:NI:VA;0) 298.15 +.5*GBCCAL+.5*GHSERNI - +55000-.5*T;,,N 99DUP8 ! -$ -$ NI3TI_DO24 PHASE -$ metastable -$ - FUN DO24NIAL 298.15 +3*GHCPNI+GHCPAL-80000;,,N 99DUP8 ! - PARAMETER G(NI3TI_DO24,NI:AL;0) 298.15 - .25*DO24NIAL;,,N 99DUP8 ! - PARAMETER G(NI3TI_DO24,AL:NI;0) 298.15 - +.75*GHCPAL+.25*GHCPNI;,,N 95DUP8 ! -$ -$ ALTI3_DO19 PHASE -$ metastable -$ - PARAMETER G(ALTI3_DO19,NI:AL;0) 298.15 - 3*GHCPNI+GHCPAL;,,N 99DUP8 ! - PARAMETER G(ALTI3_DO19,AL:NI;0) 298.15 - 3*GHCPAL+GHCPNI;,,N 95DUP8 ! -$ -$---------------------------------------------------------------------------- -$ -$ Cr-Ni -$ Mainly from SSOL -$ Metastable B2 and L12 from revision of Al-Cr-Ni -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,CR,NI;0) 298.15 +318-7.3318*T;,,N 91LEE ! - PARAMETER L(LIQUID,CR,NI;1) 298.15 +16941-6.3696*T;,,N 91LEE ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,CR,NI:VA;0) 298.15 +8030-12.8801*T;,,N 91LEE ! - PARAMETER G(FCC_A1,CR,NI:VA;1) 298.15 +33080-16.0362*T;,,N 91LEE ! - PARAMETER TC(FCC_A1,CR,NI:VA;0) 298.15 -3605;,,N 86DIN ! - PARAMETER BMAGN(FCC_A1,CR,NI:VA;0) 298.15 -1.91;,,N 86DIN ! -$ -$ BCC_A2 PHASE -$ - PARAMETER G(BCC_A2,CR,NI:VA;0) 298.15 +17170-11.8199*T;,,N 91LEE ! - PARAMETER G(BCC_A2,CR,NI:VA;1) 298.15 +34418-11.8577*T;,,N 91LEE ! - PARAMETER TC(BCC_A2,CR,NI:VA;0) 298.15 2373;,,N 86DIN ! - PARAMETER TC(BCC_A2,CR,NI:VA;1) 298.15 617;,,N 86DIN ! - PARAMETER BMAGN(BCC_A2,CR,NI:VA;0) 298.15 4;,,N 86DIN ! -$ -$ HCP_A3 PHASE -$ metastable -$ - PARAMETER G(HCP_A3,CR,NI:VA;0) 298.15 50000;,,N 95DUP6 ! - PARAMETER TC(HCP_A3,CR,NI:VA;0) 298.15 -3605;,,N 95DUP6 ! - PARAMETER BMAGN(HCP_A3,CR,NI:VA;0) 298.15 -1.91;,,N 95DUP6 ! -$ -$ BCC_B2 PHASE -$ metastable -$ -$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. - PARAMETER G(BCC_B2,CR:NI:VA;0) 298.15 4000;,,N 99DUP6 ! - PARAMETER G(BCC_B2,NI:CR:VA;0) 298.15 4000;,,N 99DUP6 ! -$ -$ FCC_L12 PHASE -$ metastable -$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. -$ The L12 phase is metastable in the binary Cr-Ni while it was stable in NDTH. - FUN U1CRNI 298.15 -1980;,,,N 99DUP6 ! -$ FUN U1CRNI 298.15 -7060+3.63*T;,,,N 99DUP6 ! - FUN U3CRNI 298.15 0;,,,N 99DUP6 ! - FUN U4CRNI 298.15 0;,,,N 99DUP6 ! - FUNCTION L04CRNI 298.15 U3CRNI;,,N 99DUP6 ! - FUNCTION L14CRNI 298.15 U4CRNI;,,N 99DUP6 ! - FUNCTION CRNI3 298.15 +3*U1CRNI;,,,N 99DUP6 ! - FUNCTION CR2NI2 298.15 +4*U1CRNI;,,,N 99DUP6 ! - FUNCTION CR3NI 298.15 +3*U1CRNI;,,,N 99DUP6 ! - PARAMETER G(FCC_L12,NI:CR:VA;0) 298.15 +CRNI3;,, N 99DUP6 ! - PARAMETER G(FCC_L12,CR:NI:VA;0) 298.15 +CR3NI;,, N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:CR:VA;0) 298.15 - -1.5*CRNI3+1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:NI:VA;0) 298.15 - +1.5*CRNI3+1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:CR:VA;1) 298.15 - +0.5*CRNI3-1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:NI:VA;1) 298.15 - -1.5*CRNI3+1.5*CR2NI2-0.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:CR,NI:VA;0) 298.15 +L04CRNI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:CR,NI:VA;1) 298.15 +L14CRNI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:*:VA;0) 298.15 +3*L04CRNI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:*:VA;1) 298.15 +3*L14CRNI;,,N 99DUP6 ! -$ -$ SIGMA PHASE -$ metastable -$ - PARAMETER G(SIGMA,NI:CR:CR;0) 298.15 - +8*GHSERNI+4*GHSERCR+18*GHSERCR+221157-227*T;,,N 91LEE ! - PARAMETER G(SIGMA,NI:CR:NI;0) 298.15 - +8*GHSERNI+4*GHSERCR+18*GBCCNI+175400;,,N 86GUS ! -$ -$ NEWSIGMA PHASE -$ metastable -$ - PARAMETER G(NEWSIGMA,NI:CR:CR;0) 298.15 - +10*GHSERNI+4*GHSERCR+16*GHSERCR+221157-227*T;,,N SIG10416 ! - PARAMETER G(NEWSIGMA,NI:CR:NI;0) 298.15 - +10*GHSERNI+4*GHSERCR+16*GBCCNI+175400;,,N SIG10416 ! -$ -$ CHI_A12 PHASE -$ metastable -$ - PARAMETER G(CHI_A12,NI:CR:CR;0) 298.15 - +24*GHSERNI+10*GHSERCR+24*GFCCCR;,, N 99LEE ! - PARAMETER G(CHI_A12,CR:CR:NI;0) 298.15 - +24*GFCCCR+10*GHSERCR+24*GHSERNI;,, N 99LEE ! - PARAMETER G(CHI_A12,NI:CR:NI;0) 298.15 - +24*GHSERNI+10*GHSERCR+24*GHSERNI;,, N 99LEE ! -$ -$ C14_LAVES PHASE -$ metastable -$ - PARAMETER G(C14_LAVES,NI:CR;0) 298.15 2*GHSERNI+GHSERCR+15000;,,N 95DUP4 ! - PARAMETER G(C14_LAVES,CR:NI;0) 298.15 2*GHSERCR+GHSERNI+15000;,,N 95DUP4 ! -$ -$ C15_LAVES PHASE -$ metastable -$ - PARAMETER G(C15_LAVES,NI:CR;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 95DUP4 ! - PARAMETER G(C15_LAVES,CR:NI;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 95DUP4 ! -$ -$ C36_LAVES PHASE -$ metastable -$ - PARAMETER G(C36_LAVES,NI:CR;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 99DUP9 ! - PARAMETER G(C36_LAVES,CR:NI;0) 298.15 +2*GHSERNI+GHSERCR+15000;,,N 99DUP9 ! -$ -$ MTI2 PHASE -$ metastable -$ - PARAMETER G(MTI2,NI:CR;0) 298.15 GHSERNI+2*GHSERCR+5000;,,N 95DUP9 ! - PARAMETER G(MTI2,CR:NI;0) 298.15 GHSERCR+2*GHSERNI+5000;,,N 95DUP9 ! -$ -$ NI3TI_DO24 PHASE -$ metastable -$ - PARAMETER G(NI3TI_DO24,CR:NI;0) 298.15 .75*GHCPCR+.25*GHCPNI;,,N 95DUP9 ! - PARAMETER G(NI3TI_DO24,NI:CR;0) 298.15 .75*GHCPNI+.25*GHCPCR;,,N 95DUP9 ! -$ -$ ALTI3_DO19 PHASE -$ metastable -$ - PARAMETER G(ALTI3_DO19,NI:CR;0) 298.15 - 3*GHCPNI+GHCPCR;,,N LINEAR ! - PARAMETER G(ALTI3_DO19,CR:NI;0) 298.15 - 3*GHCPCR+GHCPNI;,,N LINEAR ! -$ -$**************************************************************************** -$ -$ TERNARY PARAMETERS -$ -$---------------------------------------------------------------------------- -$ -$ Al-Cr-Ni -$ July 1999, ND -$ Revision. Main changes: -$ - description of the A2/B2 -$ - new liquidus data taken into account -$ - simpler ternary interaction parameters -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,AL,CR,NI;0) 298.15 16000;,,N 99DUP6 ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,AL,CR,NI:VA;0) 298.15 30300;,,N 99DUP6 ! -$ -$ BCC_A2 PHASE -$ - PARAMETER G(BCC_A2,AL,CR,NI:VA;0) 298.15 42500;,,N 99DUP6 ! -$ -$ FCC_L12 PHASE -$ - FUN U1ALCRNI 298.15 6650;,,N 99DUP6 ! - FUN U2ALCRNI 298.15 0;,,N 99DUP6 ! - FUN U3ALCRNI 298.15 0;,,N 99DUP6 ! - FUN ALCRNI2 298.15 U1ALCR+2*U1ALNI+2*U1CRNI+U1ALCRNI;,,N 99DUP6 ! - FUN ALCR2NI 298.15 2*U1ALCR+U1ALNI+2*U1CRNI+U2ALCRNI;,,N 99DUP6 ! - FUN AL2CRNI 298.15 2*U1ALCR+2*U1ALNI+U1CRNI+U3ALCRNI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR,NI:AL:VA;0) 298.15 - -1.5*ALCRNI2-1.5*ALCR2NI+ALCR3+ALNI3+6*AL2CRNI - -1.5*AL2CR2-1.5*AL2NI2-1.5*AL3CR-1.5*AL3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR,NI:CR:VA;0) 298.15 - -1.5*ALCRNI2+6*ALCR2NI-1.5*ALCR3-1.5*AL2CRNI - -1.5*AL2CR2+AL3CR+CRNI3-1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR,NI:NI:VA;0) 298.15 - +6*ALCRNI2-1.5*ALCR2NI-1.5*ALNI3-1.5*AL2CRNI - -1.5*AL2NI2+AL3NI-1.5*CRNI3-1.5*CR2NI2+CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR:NI:VA;0) 298.15 - +1.5*ALCR2NI+1.5*AL2CRNI-1.5*AL3NI-1.5*CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,NI:CR:VA;0) 298.15 - +1.5*ALCRNI2+1.5*AL2CRNI-1.5*AL3CR-1.5*CRNI3;,,N 99DUP6 ! - PARA L(FCC_L12,CR,NI:AL:VA;0) 298.15 - +1.5*ALCRNI2+1.5*ALCR2NI-1.5*ALCR3-1.5*ALNI3;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR:NI:VA;1) 298.15 - -1.5*ALCR2NI+1.5*AL2CRNI-0.5*AL3NI+0.5*CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,NI:CR:VA;1) 298.15 - -1.5*ALCRNI2+1.5*AL2CRNI-0.5*AL3CR+0.5*CRNI3;,,N 99DUP6 ! - PARA L(FCC_L12,CR,NI:AL:VA;1) 298.15 - -1.5*ALCRNI2+1.5*ALCR2NI-0.5*ALCR3+0.5*ALNI3;,,N 99DUP6 ! -$ -$ SIGMA PHASE -$ metastable - PARA G(SIGMA,NI:CR:AL;0) 298.15 - +8*GHSERNI+4*GHSERCR+18*GBCCAL+UNASS;,, N 99LEE ! - PARA G(SIGMA,AL:CR:NI;0) 298.15 - +8*GHSERAL+4*GHSERCR+18*GBCCNI+UNASS;,, N 99LEE ! -$ -$ NEWSIGMA PHASE -$ metastable - PARA G(NEWSIGMA,NI:CR:AL;0) 298.15 - +10*GHSERNI+4*GHSERCR+16*GBCCAL;,, N LINEAR ! - PARA G(NEWSIGMA,AL:CR:NI;0) 298.15 - +10*GHSERAL+4*GHSERCR+16*GBCCNI;,, N LINEAR ! -$ -$ -$**************************************************************************** -$ Diffusion parameters -$ -PARAMETER MQ(FCC_A1&AL,NI;0) 298.15 -284000+R*T*LN(7.5E-4); - 6.000E+3 N 96Eng ! -PARAMETER MQ(FCC_A1&AL,AL;0) 298.15 -142000+R*T*LN(1.71E-4); - 6.000E+3 N 96Eng ! -PARAMETER MQ(FCC_A1&AL,AL,NI;0) 298.15 -41300-91.2*T; - 6.000E+3 N 96Eng ! -PARAMETER MQ(FCC_A1&AL,CR;0) 298.15 -235000-82*T; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&AL,CR,NI;0) 298.15 -53200; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&AL,Al,Cr;0) 298.15 +335000; 6000 N 96Eng ! - -PARAMETER MQ(FCC_A1&NI,AL;0) 298.15 -145900+R*T*LN(4.4E-4); - 6.000E+3 N 96Eng ! -PARAMETER MQ(FCC_A1&NI,NI;0)298.15 -287000-69.8*T; - 6.000E+3 N 96Eng ! -PARAMETER MQ(FCC_A1&NI,AL,NI;0) 298.15 -113000+65.5*T; - 6.000E+3 N 96Eng ! -PARAMETER MQ(FCC_A1&NI,CR;0) 298.15 -235000-82*T; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&NI,CR,NI;0) 298.15 -81000; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&NI,AL,CR;0) 298.15 211000; 6000 N 96Eng ! - - -PARAMETER MQ(FCC_A1&CR,AL;0) 298.15 -261700+R*T*LN(0.64); - 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&CR,CR;0) 298.15 -235000-82*T; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&CR,NI;0) 298.15 -287000-64.4*T; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&CR,AL,CR;0) 298.15 +487000; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&CR,AL,NI;0) 298.15 -118000; 6000 N 96Eng ! -PARAMETER MQ(FCC_A1&CR,CR,NI;0) 298.15 -68000; 6000 N 96Eng ! -$ -$**************************************************************************** - - LIST_OF_REFERENCES - NUMBER SOURCE - LINEAR 'Unassessed parameter, linear combination of unary data. (MU, - SIGMA)' - REFLAV 'G(LAVES,AA)=3*G(SER,AA)+15000' - 86DIN 'A. Dinsdale, T. Chart, MTDS NPL, Unpublished work (1986); CR-NI' - 86FER1 'A. Fernandez Guillermet, - Z metallkde, Vol 78 (1987) p 639-647, - TRITA-MAC 324B (1986); CO-NI' - 86GUS 'P. Gustafson, Calphad Vol 11 (1987) p 277-292, - TRITA-MAC 320 (1986); CR-NI-W ' - 87GUS 'P. Gustafson, TRITA-MAC 342, (1987); CR-FE-W' - 89DIN 'Alan Dinsdale, SGTE Data for Pure Elements, - NPL Report DMA(A)195 September 1989' - 91DIN 'Alan Dinsdale, SGTE Data for Pure Elements, NPL Report - DMA(A)195 Rev. August 1990' - 91LEE 'Byeong-Joo Lee, unpublished revision (1991); C-Cr-Fe-Ni' - 91SAU1 'Nigel Saunders, 1991, based on - N. Saunders, V.G. Rivlin - Z. metallkde, 78 (11), 795-801 (1987); Al-Cr' - 91DIN 'Alan Dinsdale, SGTE Data for Pure Elements, - Calphad Vol 15(1991) p 317-425, - also in NPL Report DMA(A)195 Rev. August 1990' - 95DUP3 'N. Dupin, Thesis, LTPCM, France, 1995; - Al-Ni, - also in I. Ansara, N. Dupin, H.L. Lukas, B. SUndman - J. Alloys Compds, 247 (1-2), 20-30 (1997)' - 95DUP4 'N. Dupin, Thesis, LTPCM, France, 1995; - Cr-Ni-Ta' - 95DUP6 'N. Dupin, Thesis, LTPCM, France, 1995; - Al-Cr-Ni' - 95DUP8 'N. Dupin, Thesis, LTPCM, France, 1995; - Al-Ni-Ti' - 95DUP9 'N. Dupin, Thesis, LTPCM, France, 1995; - Cr-Ni-Ti' - 99DUP 'N. Dupin, I. Ansara, - Z. metallkd., Vol 90 (1999) p 76-85; - Al-Ni' - 99DUP3 'N. Dupin, - July 1999, unpublished revision - ; Al-Ni' - 99DUP6 'N. Dupin, - July 1999, unpublished revision - ; Al-Cr-Ni' - 99DUP8 'N. Dupin, - August 1999, unpublished revision - ; Al-Ni-Ti' - 99DUP9 'N. Dupin, - August 1999, unpublished revision - ; Cr-Ni-Ti' - 99LEE 'Byeong-Joo Lee, unpublished work at KTH (1999); - update of steel database' - REF184 'AL1 CODATA KEY VALUES SGTE ** - ALUMINIUM - Cp values similar in Codata Key Values and IVTAN Vol. 3' - REF448 'AL2 CHATILLON(1992) - Enthalpy of formation for Al1 taken from Codata Key Values. - Enthalpy of form. from TPIS dissociation energy mean Value - corrected with new fef from Sunil K.K. and Jordan K.D. - (J.Phys. Chem. 92(1988)2774) ab initio calculations.' - REF4465 'CR1 T.C.R.A.S. Class: 1 - CHROMIUM ' - REF4591 'CR2 T.C.R.A.S. Class: 6' - REF7504 'NI1 T.C.R.A.S Class: 1 - Data provided by T.C.R.A.S. October 1996' - REF7553 'NI2 T.C.R.A.S Class: 5 - Data provided by T.C.R.A.S. October 1996' - ! -""" - -NICRAL_TDB_DIFF = """ - -$ Same as NICRAL_TDB with the following changes -$ Shortened to include just FCC_A1, FCC_L12, LIQUID -$ Mobility parameters replaced with arbitrary diffusivity parameter to test diffusivity and tracer outputs -$ - - - ELEMENT /- ELECTRON_GAS .0000E+00 .0000E+00 .0000E+00! - ELEMENT VA VACUUM .0000E+00 .0000E+00 .0000E+00! - ELEMENT AL FCC_A1 2.6982E+01 4.5773E+03 2.8322E+01! - ELEMENT CR BCC_A2 5.1996E+01 4.0500E+03 2.3560E+01! - ELEMENT NI FCC_A1 5.8690E+01 4.7870E+03 2.9796E+01! - - SPECIES AL2 AL2! - SPECIES CR2 CR2! - SPECIES NI2 NI2! - - - FUNCTION UNASS 298.15 0;,,N ! - - - TYPE_DEFINITION % SEQ *! - DEFINE_SYSTEM_DEFAULT E 2 ! - DEFAULT_COMMAND DEF_SYS_ELEMENT VA ! - DEFAULT_COMMAND REJECT_PHASE NEWSIGMA ! - - TYPE_DEFINITION A GES A_P_D FCC_L12 MAGNETIC -3.0 .28 ! - TYPE_DEFINITION E GES A_P_D FCC_A1 MAGNETIC -3.0 .28 ! - - TYPE_DEFINITION D GES A_P_D FCC_L12 DIS_PART FCC_A1 ! - - PHASE GAS:G % 1 1.0 ! - CONST GAS:G :AL,AL2,CR,CR2,NI,NI2 : ! - - PHASE LIQUID:L % 1 1.0 ! - CONST LIQUID:L :AL,CR,NI : ! - - PHASE FCC_A1 %E 2 1 1 ! - CONST FCC_A1 :AL,CR,NI% : VA% : ! - -$ PHASE FCC_L12 %ADG 3 .75 .25 1 ! - PHASE FCC_L12 %AD 3 .75 .25 1 ! - CONST FCC_L12 :AL,CR,NI : AL,CR,NI : VA : ! - - FUNCTION ZERO 298.15 0;,,N ! - FUNCTION DP 298.15 +P-101325;,,N ! - FUNCTION TROIS 298.15 3;,,N ! - FUNCTION UNTIER 298.15 TROIS**(-1);,,N ! - -$**************************************************************************** -$ -$ UNARY PARAMETERS -$ -$---------------------------------------------------------------------------- -$ -$ Al -$ -$ FUNCTIONS -$ - FUNCTION F154T 298.15 - +323947.58-25.1480943*T-20.859*T*LN(T) - +4.5665E-05*T**2-3.942E-09*T**3-24275.5*T**(-1); - 4300.0 Y - +342017.233-54.0526109*T-17.7891*T*LN(T)+6.822E-05*T**2 - -1.91111667E-08*T**3-14782200*T**(-1); - 8200.0 Y - +542396.07-411.214335*T+22.2419*T*LN(T)-.00349619*T**2 - +4.0491E-08*T**3-2.0366965E+08*T**(-1); 1.00000E+04 N ! -$ - FUNCTION F625T 298.15 - +496408.232+35.479739*T-41.6397*T*LN(T) - +.00249636*T**2-4.90507333E-07*T**3+85390.3*T**(-1); - 900.00 Y - +497613.221+17.368131*T-38.85476*T*LN(T)-2.249805E-04*T**2 - -9.49003167E-09*T**3-5287.23*T**(-1); 2.80000E+03 N ! -$ - FUNCTION GHSERAL 298.15 - -7976.15+137.093038*T-24.3671976*T*LN(T) - -.001884662*T**2-8.77664E-07*T**3+74092*T**(-1); - 700.00 Y - -11276.24+223.048446*T-38.5844296*T*LN(T) - +.018531982*T**2-5.764227E-06*T**3+74092*T**(-1); - 933.60 Y - -11278.378+188.684153*T-31.748192*T*LN(T) - -1.231E+28*T**(-9);,, N ! -$ - FUNCTION GHCPAL 298.15 +5481-1.8*T+GHSERAL;,,N ! -$ - FUNCTION GBCCAL 298.15 +10083-4.813*T+GHSERAL;,,N ! -$ - FUNCTION GLIQAL 298.14 - +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; - 933.59 Y - +10482.282-11.253974*T+1.231E+28*T**(-9)+GHSERAL;,,N ! -$ -$ GAS PHASE -$ - PARAMETER G(GAS,AL;0) 298.15 +F154T+R*T*LN(1E-05*P);,,N REF184 ! - PARAMETER G(GAS,AL2;0) 298.15 +F625T+R*T*LN(1E-05*P);,,N REF448 ! -$ -$ LIQUID PHASE -$ - PARAMETER G(LIQUID,AL;0) 298.13 - +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL; - 933.60 Y - +10482.382-11.253974*T+1.231E+28*T**(-9) - +GHSERAL;,,N 91DIN ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,AL:VA;0) 298.15 +GHSERAL;,,N 91DIN ! -$ -$ -$---------------------------------------------------------------------------- -$ -$ Cr -$ -$ FUNCTIONS -$ - FUNCTION F7454T 298.15 - +390765.331-31.5192154*T-21.36083*T*LN(T) - +7.253215E-04*T**2-1.588679E-07*T**3+10285.15*T**(-1); - 1100.0 Y - +393886.928-44.107465*T-19.96003*T*LN(T)+.001513089*T**2 - -4.23648333E-07*T**3-722515*T**(-1); - 2000.0 Y - +421372.003-231.888524*T+5.362886*T*LN(T)-.00848877*T**2 - +2.984635E-07*T**3-6015405*T**(-1); - 3300.0 Y - +305164.698+251.019831*T-55.20304*T*LN(T)+.005324585*T**2 - -2.850405E-07*T**3+34951485*T**(-1); - 5100.0 Y - +1069921.1-1708.93262*T+175.0508*T*LN(T)-.025574185*T**2 - +4.94447E-07*T**3-4.4276355E+08*T**(-1); - 7600.0 Y - -871952.838+1686.47356*T-204.5589*T*LN(T)+.007475225*T**2 - -4.618745E-08*T**3+1.423504E+09*T**(-1); 1.00000E+04 N ! -$ - FUNCTION F7735T 298.15 +598511.402+41.5353219*T-40.56798*T*LN(T) - +.004961847*T**2-1.61216717E-06*T**3+154422.85*T**(-1); - 800.00 Y - +613345.232-104.20799*T-19.7643*T*LN(T)-.007085085*T**2 - -4.69883E-07*T**3-1738066.5*T**(-1); - 1400.0 Y - +642608.843-369.286259*T+17.64743*T*LN(T)-.02767321*T**2 - +1.605906E-06*T**3-5831655*T**(-1); - 2300.0 Y - +553119.895+159.188556*T-52.07969*T*LN(T)-.004229401*T**2 - +1.5939925E-07*T**3+14793625*T**(-1); - 3900.0 Y - +347492.339+623.137624*T-105.0428*T*LN(T)+3.9699545E-04*T**2 - +1.51783483E-07*T**3+1.4843765E+08*T**(-1); - 5800.0 Y - -484185.055+2598.25559*T-334.7145*T*LN(T)+.028597625*T**2 - -4.97520167E-07*T**3+7.135805E+08*T**(-1); 6.00000E+03 N ! -$ - FUNCTION GHSERCR 298.14 - -8856.94+157.48*T-26.908*T*LN(T) - +.00189435*T**2-1.47721E-06*T**3+139250*T**(-1); - 2180.0 Y - -34869.344+344.18*T-50*T*LN(T)-2.88526E+32*T**(-9);,,N ! -$ - FUNCTION GCRLIQ 298.15 - +24339.955-11.420225*T+2.37615E-21*T**7+GHSERCR; - 2180.0 Y - -16459.984+335.616316*T-50*T*LN(T);,,N ! -$ - FUNCTION GFCCCR 298.15 +7284+.163*T+GHSERCR;,,N ! -$ - FUNCTION GHCPCR 298.15 +4438+GHSERCR;,,N ! -$ - FUNCTION ACRBCC 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! - FUNCTION BCRBCC 298.15 +1+2.6E-11*P;,,N ! - FUNCTION CCRBCC 298.15 2.08E-11;,,N ! - FUNCTION DCRBCC 298.15 +1*LN(BCRBCC);,,N ! - FUNCTION VCRBCC 298.15 +7.188E-06*EXP(ACRBCC);,,N ! - FUNCTION ECRBCC 298.15 +1*LN(CCRBCC);,,N ! - FUNCTION XCRBCC 298.15 +1*EXP(.8*DCRBCC)-1;,,N ! - FUNCTION YCRBCC 298.15 +VCRBCC*EXP(-ECRBCC);,,N ! - FUNCTION ZCRBCC 298.15 +1*LN(XCRBCC);,,N ! - FUNCTION GPCRBCC 298.15 +YCRBCC*EXP(ZCRBCC);,,N ! -$ - FUNCTION ACRLIQ 298.15 +1.7E-05*T+9.2E-09*T**2;,,N ! - FUNCTION BCRLIQ 298.15 +1+4.65E-11*P;,,N ! - FUNCTION CCRLIQ 298.15 3.72E-11;,,N ! - FUNCTION DCRLIQ 298.15 +1*LN(BCRLIQ);,,N ! - FUNCTION VCRLIQ 298.15 +7.653E-06*EXP(ACRLIQ);,,N ! - FUNCTION ECRLIQ 298.15 +1*LN(CCRLIQ);,,N ! - FUNCTION XCRLIQ 298.15 +1*EXP(.8*DCRLIQ)-1;,,N ! - FUNCTION YCRLIQ 298.15 +VCRLIQ*EXP(-ECRLIQ);,,N ! - FUNCTION ZCRLIQ 298.15 +1*LN(XCRLIQ);,,N ! - FUNCTION GPCRLIQ 298.15 +YCRLIQ*EXP(ZCRLIQ);,,N ! -$ -$ GAS PHASE -$ - PARAMETER G(GAS,CR;0) 298.15 +F7454T+R*T*LN(1E-05*P);,,N REF4465 ! - PARAMETER G(GAS,CR2;0) 298.15 +F7735T+R*T*LN(1E-05*P);,, N REF4591 ! -$ -$ LIQUID PHASE -$ - PARAMETER G(LIQUID,CR;0) 298.15 +GCRLIQ+GPCRLIQ;,, N 91DIN ! -$ -$ FCC_A1 PHASE -$ -$ -$---------------------------------------------------------------------------- -$ -$ Ni -$ -$ FUNCTIONS -$ - FUNCTION F13191T 298.15 - +417658.868-44.7777921*T-20.056*T*LN(T) - -.0060415*T**2+1.24774E-06*T**3-16320*T**(-1); - 800.00 Y - +413885.448+9.41787679*T-28.332*T*LN(T)+.00173115*T**2 - -8.399E-08*T**3+289050*T**(-1); - 3900.0 Y - +440866.732-62.5810038*T-19.819*T*LN(T)+5.067E-04*T**2 - -4.93233333E-08*T**3-15879735*T**(-1); - 7600.0 Y - +848806.287-813.398164*T+64.69*T*LN(T)-.00731865*T**2 - +8.71833333E-08*T**3-3.875846E+08*T**(-1); 10000. N ! -$ - FUNCTION F13265T 298.15 - +638073.279-68.1901928*T-24.897*T*LN(T) - -.0313584*T**2+5.93355333E-06*T**3-14215*T**(-1); - 800.00 Y - +611401.772+268.084821*T-75.25401*T*LN(T)+.01088525*T**2 - -7.08741667E-07*T**3+2633835*T**(-1); - 2100.0 Y - +637459.339+72.0712678*T-48.587*T*LN(T)-9.09E-05*T**2 - +9.12933333E-08*T**3-1191755*T**(-1); - 4500.0 Y - +564540.781+329.599011*T-80.11301*T*LN(T)+.00578085*T**2 - -1.08841667E-07*T**3+29137900*T**(-1); 6000.0 N ! -$ - FUNCTION GHSERNI 298.14 - -5179.159+117.854*T-22.096*T*LN(T) - -.0048407*T**2; - 1728.0 Y - -27840.655+279.135*T-43.1*T*LN(T)+1.12754E+31*T**(-9);,, N ! -$ - FUNCTION GHCPNI 298.15 +1046+1.2552*T+GHSERNI;,,N ! -$ - FUNCTION GBCCNI 298.15 +8715.084-3.556*T+GHSERNI;,,, N ! -$ -$ GAS PHASE -$ - PARAMETER G(GAS,NI;0) 298.15 +F13191T+R*T*LN(1E-05*P);,,N REF7504 ! - PARAMETER G(GAS,NI2;0) 298.15 +F13265T+R*T*LN(1E-05*P);,,N REF7553 ! -$ -$ LIQUID PHASE -$ - PARAMETER G(LIQUID,NI;0) 298.13 - +16414.686-9.397*T-3.82318E-21*T**7+GHSERNI; - 1728.0 Y - +18290.88-10.537*T-1.12754E+31*T**(-9) - +GHSERNI;,,N 91DIN ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,NI:VA;0) 298.15 +GHSERNI;,,N 91DIN ! - PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633;,,N 89DIN ! - PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 .52;,,N 89DIN ! -$ -$ -$**************************************************************************** -$ -$ BINARY PARAMETERS -$ -$---------------------------------------------------------------------------- -$ -$ Al-Cr -$ Mainly from Saunders (COST507) -$ Metastable B2 and L12 from revision of Al-Cr-Ni -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,AL,CR;0) 298.15 -29000;,,N 91SAU1 ! - PARAMETER L(LIQUID,AL,CR;1) 298.15 -11000;,,N 91SAU1 ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,AL,CR:VA;0) 298.15 -45900+6*T;,,N 91SAU1 ! -$ -$ -$ FCC_L12 PHASE -$ metastable -$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. - FUN U1ALCR 298.15 -830;,,N 99DUP6 ! - FUN U3ALCR 298.15 0.0; 6000.00 99DUP6 ! - FUN U4ALCR 298.15 0.0; 6000.00 N 99DUP6 ! - FUNCTION L04ALCR 298.15 U3ALCR;,,N ! - FUNCTION L14ALCR 298.15 U4ALCR;,,N ! - FUNCTION ALCR3 298.15 3*U1ALCR;,,N ! - FUNCTION AL2CR2 298.15 4*U1ALCR;,,N ! - FUNCTION AL3CR 298.15 3*U1ALCR;,,N ! - PARAMETER G(FCC_L12,CR:AL:VA;0) 298.15 +ALCR3;,, N 99DUP6 ! - PARAMETER G(FCC_L12,AL:CR:VA;0) 298.15 +AL3CR;,, N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:AL:VA;0) 298.15 - -1.5*ALCR3+1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:CR:VA;0) 298.15 - +1.5*ALCR3+1.5*AL2CR2-1.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:AL:VA;1) 298.15 - +0.5*ALCR3-1.5*AL2CR2+1.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:CR:VA;1) 298.15 - -1.5*ALCR3+1.5*AL2CR2-0.5*AL3CR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:AL,CR:VA;0) 298.15 +L04ALCR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:AL,CR:VA;1) 298.15 +L14ALCR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:*:VA;0) 298.15 +3*L04ALCR;,,N 99DUP6 ! - PARAMETER L(FCC_L12,AL,CR:*:VA;1) 298.15 +3*L14ALCR;,,N 99DUP6 ! -$ -$ -$---------------------------------------------------------------------------- -$ -$ Al-Ni -$ Mainly from ND thesis, -$ slighly revised to get better solvus at low temperature -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,AL,NI;0) 298.15 -207109.28+41.31501*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;1) 298.15 -10185.79+5.8714*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;2) 298.15 +81204.81-31.95713*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;3) 298.15 +4365.35-2.51632*T;,,N 95DUP3 ! - PARAMETER L(LIQUID,AL,NI;4) 298.15 -22101.64+13.16341*T;,,N 95DUP3 ! -$ -$ FCC_A1 PHASE -$ - PARAMETER TC(FCC_A1,AL,NI:VA;0) 298.15 -1112;,,N 95DUP3 ! - PARAMETER TC(FCC_A1,AL,NI:VA;1) 298.15 1745;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;0) 298.15 -162407.75+16.212965*T;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;1) 298.15 +73417.798-34.914168*T;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;2) 298.15 +33471.014-9.8373558*T;,,N 95DUP3 ! - PARAMETER G(FCC_A1,AL,NI:VA;3) 298.15 -30758.01+10.25267*T;,,N 95DUP3 ! -$ -$ FCC_L12 PHASE -$ - FUN UALNI 298.15 -22212.8931+4.39570389*T;,,,N 99DUP3 ! - FUN U1ALNI 298.15 2*UNTIER*UALNI;,,,N 99DUP3 ! - FUN U3ALNI 298.15 0;,,,N 99DUP3 ! - FUN U4ALNI 298.15 7203.60609-3.74273030*T;,,,N 99DUP3 ! - FUNCTION L04ALNI 298.15 U3ALNI;,,N 99DUP3 ! - FUNCTION L14ALNI 298.15 U4ALNI;,,N 99DUP3 ! - FUNCTION ALNI3 298.15 +3*U1ALNI;,,,N 99DUP3 ! - FUNCTION AL2NI2 298.15 +4*U1ALNI;,,,N 99DUP3 ! - FUNCTION AL3NI 298.15 +3*U1ALNI;,,,N 99DUP3 ! - PARAMETER G(FCC_L12,NI:AL:VA;0) 298.15 +ALNI3;,,N 99DUP3 ! - PARAMETER G(FCC_L12,AL:NI:VA;0) 298.15 +AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:AL:VA;0) 298.15 - -1.5*ALNI3+1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:NI:VA;0) 298.15 - +1.5*ALNI3+1.5*AL2NI2-1.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:AL:VA;1) 298.15 - +0.5*ALNI3-1.5*AL2NI2+1.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:NI:VA;1) 298.15 - -1.5*ALNI3+1.5*AL2NI2-0.5*AL3NI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,*:AL,NI:VA;0) 298.15 +L04ALNI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,*:AL,NI:VA;1) 298.15 +L14ALNI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:*:VA;0) 298.15 +3*L04ALNI;,,N 99DUP3 ! - PARAMETER L(FCC_L12,AL,NI:*:VA;1) 298.15 +3*L14ALNI;,,N 99DUP3 ! -$ -$ -$---------------------------------------------------------------------------- -$ -$ Cr-Ni -$ Mainly from SSOL -$ Metastable B2 and L12 from revision of Al-Cr-Ni -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,CR,NI;0) 298.15 +318-7.3318*T;,,N 91LEE ! - PARAMETER L(LIQUID,CR,NI;1) 298.15 +16941-6.3696*T;,,N 91LEE ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,CR,NI:VA;0) 298.15 +8030-12.8801*T;,,N 91LEE ! - PARAMETER G(FCC_A1,CR,NI:VA;1) 298.15 +33080-16.0362*T;,,N 91LEE ! - PARAMETER TC(FCC_A1,CR,NI:VA;0) 298.15 -3605;,,N 86DIN ! - PARAMETER BMAGN(FCC_A1,CR,NI:VA;0) 298.15 -1.91;,,N 86DIN ! -$ -$ -$ FCC_L12 PHASE -$ metastable -$ Present work: july 1999, study of Al-Cr-Ni, revision of NDTH. -$ The L12 phase is metastable in the binary Cr-Ni while it was stable in NDTH. - FUN U1CRNI 298.15 -1980;,,,N 99DUP6 ! -$ FUN U1CRNI 298.15 -7060+3.63*T;,,,N 99DUP6 ! - FUN U3CRNI 298.15 0;,,,N 99DUP6 ! - FUN U4CRNI 298.15 0;,,,N 99DUP6 ! - FUNCTION L04CRNI 298.15 U3CRNI;,,N 99DUP6 ! - FUNCTION L14CRNI 298.15 U4CRNI;,,N 99DUP6 ! - FUNCTION CRNI3 298.15 +3*U1CRNI;,,,N 99DUP6 ! - FUNCTION CR2NI2 298.15 +4*U1CRNI;,,,N 99DUP6 ! - FUNCTION CR3NI 298.15 +3*U1CRNI;,,,N 99DUP6 ! - PARAMETER G(FCC_L12,NI:CR:VA;0) 298.15 +CRNI3;,, N 99DUP6 ! - PARAMETER G(FCC_L12,CR:NI:VA;0) 298.15 +CR3NI;,, N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:CR:VA;0) 298.15 - -1.5*CRNI3+1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:NI:VA;0) 298.15 - +1.5*CRNI3+1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:CR:VA;1) 298.15 - +0.5*CRNI3-1.5*CR2NI2+1.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:NI:VA;1) 298.15 - -1.5*CRNI3+1.5*CR2NI2-0.5*CR3NI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:CR,NI:VA;0) 298.15 +L04CRNI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,*:CR,NI:VA;1) 298.15 +L14CRNI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:*:VA;0) 298.15 +3*L04CRNI;,,N 99DUP6 ! - PARAMETER L(FCC_L12,CR,NI:*:VA;1) 298.15 +3*L14CRNI;,,N 99DUP6 ! -$ -$ -$**************************************************************************** -$ -$ TERNARY PARAMETERS -$ -$---------------------------------------------------------------------------- -$ -$ Al-Cr-Ni -$ July 1999, ND -$ Revision. Main changes: -$ - description of the A2/B2 -$ - new liquidus data taken into account -$ - simpler ternary interaction parameters -$ -$ LIQUID PHASE -$ - PARAMETER L(LIQUID,AL,CR,NI;0) 298.15 16000;,,N 99DUP6 ! -$ -$ FCC_A1 PHASE -$ - PARAMETER G(FCC_A1,AL,CR,NI:VA;0) 298.15 30300;,,N 99DUP6 ! -$ -$ -$ FCC_L12 PHASE -$ - FUN U1ALCRNI 298.15 6650;,,N 99DUP6 ! - FUN U2ALCRNI 298.15 0;,,N 99DUP6 ! - FUN U3ALCRNI 298.15 0;,,N 99DUP6 ! - FUN ALCRNI2 298.15 U1ALCR+2*U1ALNI+2*U1CRNI+U1ALCRNI;,,N 99DUP6 ! - FUN ALCR2NI 298.15 2*U1ALCR+U1ALNI+2*U1CRNI+U2ALCRNI;,,N 99DUP6 ! - FUN AL2CRNI 298.15 2*U1ALCR+2*U1ALNI+U1CRNI+U3ALCRNI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR,NI:AL:VA;0) 298.15 - -1.5*ALCRNI2-1.5*ALCR2NI+ALCR3+ALNI3+6*AL2CRNI - -1.5*AL2CR2-1.5*AL2NI2-1.5*AL3CR-1.5*AL3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR,NI:CR:VA;0) 298.15 - -1.5*ALCRNI2+6*ALCR2NI-1.5*ALCR3-1.5*AL2CRNI - -1.5*AL2CR2+AL3CR+CRNI3-1.5*CR2NI2-1.5*CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR,NI:NI:VA;0) 298.15 - +6*ALCRNI2-1.5*ALCR2NI-1.5*ALNI3-1.5*AL2CRNI - -1.5*AL2NI2+AL3NI-1.5*CRNI3-1.5*CR2NI2+CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR:NI:VA;0) 298.15 - +1.5*ALCR2NI+1.5*AL2CRNI-1.5*AL3NI-1.5*CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,NI:CR:VA;0) 298.15 - +1.5*ALCRNI2+1.5*AL2CRNI-1.5*AL3CR-1.5*CRNI3;,,N 99DUP6 ! - PARA L(FCC_L12,CR,NI:AL:VA;0) 298.15 - +1.5*ALCRNI2+1.5*ALCR2NI-1.5*ALCR3-1.5*ALNI3;,,N 99DUP6 ! - PARA L(FCC_L12,AL,CR:NI:VA;1) 298.15 - -1.5*ALCR2NI+1.5*AL2CRNI-0.5*AL3NI+0.5*CR3NI;,,N 99DUP6 ! - PARA L(FCC_L12,AL,NI:CR:VA;1) 298.15 - -1.5*ALCRNI2+1.5*AL2CRNI-0.5*AL3CR+0.5*CRNI3;,,N 99DUP6 ! - PARA L(FCC_L12,CR,NI:AL:VA;1) 298.15 - -1.5*ALCRNI2+1.5*ALCR2NI-0.5*ALCR3+0.5*ALNI3;,,N 99DUP6 ! -$ -$**************************************************************************** -$ Diffusion parameters -$ -PARAMETER DQ(FCC_A1&AL,*;0) 298.15 -70000+R*T*LN(5E-5); 6000 N ! -PARAMETER DQ(FCC_A1&CR,*;0) 298.15 -40800+R*T*LN(3e-6); 6000 N ! -PARAMETER DQ(FCC_A1&NI,*;0) 298.15 -271960+R*T*LN(1.27E-4); 6000 N ! -$ -""" - -FECRNI_DB = """ -$ FeCrNi database using parameters taken from MatCalc open steel database mc_fe_v2.060.tdb -$ -$ The mc_fe_v2.059.tdb database is made available under the -$ Open Database License: http://opendatacommons.org/licenses/odbl/1.0/. -$ Any rights in individual contents of the database are licensed under the -$ Database Contents License: http://opendatacommons.org/licenses/dbcl/1.0/. -$ -$ ########################################################################## - -ELEMENT VA VACUUM 0.0 0.00 0.00 ! -ELEMENT CR BCC_A2 51.996 4050.0 23.5429 ! -ELEMENT FE BCC_A2 55.847 4489.0 27.2797 ! -ELEMENT NI FCC_A1 58.69 4787.0 29.7955 ! - -FUNCTION GHSERCR - 273.00 -8856.94+157.48*T-26.908*T*LN(T) - +0.00189435*T**2-1.47721E-6*T**3+139250*T**(-1); 2180.00 Y - -34869.344+344.18*T-50*T*LN(T)-2.88526E+32*T**(-9); 6000.00 N -REF:0 ! -FUNCTION GCRFCC - 273.00 +7284+0.163*T+GHSERCR#; 6000.00 N -REF:0 ! -FUNCTION GHSERFE - 273.00 +1225.7+124.134*T-23.5143*T*LN(T)-0.00439752*T**2 - -5.89269E-8*T**3+77358.5*T**(-1); 1811.00 Y - -25383.581+299.31255*T-46*T*LN(T)+2.2960305E+31*T**(-9); 6000.00 N -REF:0 ! -FUNCTION GFEFCC - 273.00 -1462.4+8.282*T-1.15*T*LN(T)+6.4E-04*T**2+GHSERFE#; 1811.00 Y - -27098.266+300.25256*T-46*T*LN(T)+2.78854E+31*T**(-9); 6000.00 N -REF:0 ! -FUNCTION GHSERNI - 273.00 -5179.159+117.854*T-22.096*T*LN(T)-4.8407E-3*T**2; 1728.00 Y - -27840.655+279.135*T-43.10*T*LN(T)+1.12754E+31*T**(-9); 6000.00 N -REF:0 ! -FUNCTION GNIBCC - 273.00 +8715.084-3.556*T+GHSERNI#; 6000.00 N -REF:0 ! - -$FCC_A1 phase - -TYPE_DEFINITION ' GES A_P_D FCC_A1 MAGNETIC -3.0 0.28 ! -TYPE_DEFINITION % SEQ *! -PHASE FCC_A1 %' 2 1 1 ! -CONSTITUENT FCC_A1 : CR,FE%,NI : VA% : ! - -PARAMETER G(FCC_A1,CR:VA;0) 273.00 +7284+0.163*T+GHSERCR#; 6000.00 N -REF:0 ! -PARAMETER G(FCC_A1,FE:VA;0) 273.00 -1462.4+8.282*T-1.15*T*LN(T) - +0.00064*T**2+GHSERFE#; 1811.00 Y - -1713.815+0.94001*T+0.4925095E+31*T**(-9)+GHSERFE#; 6000.00 N -REF:0 ! -PARAMETER G(FCC_A1,NI:VA;0) 273.00 +GHSERNI#; 3000.00 N -REF:0 ! -PARAMETER L(FCC_A1,CR,FE:VA;0) 273.00 +10833-7.477*T; 6000.00 N -REF:11 ! -PARAMETER L(FCC_A1,CR,FE:VA;1) 273.00 +1410; 6000.00 N -REF:11 ! -PARAMETER L(FCC_A1,CR,NI:VA;0) 273.00 +8030-12.8801*T; 6000.00 N -REF:11 ! -PARAMETER L(FCC_A1,CR,NI:VA;1) 273.00 +33080-16.0362*T; 6000.00 N -REF:11 ! -PARAMETER L(FCC_A1,FE,NI:VA;0) 273.00 -12054.355+3.27413*T; 6000.00 N -REF:20 ! -PARAMETER L(FCC_A1,FE,NI:VA;1) 273.00 +11082.1315-4.45077*T; 6000.00 N -REF:20 ! -PARAMETER L(FCC_A1,FE,NI:VA;2) 273.00 -725.805174; 6000.00 N -REF:20 ! -PARAMETER L(FCC_A1,CR,FE,NI:VA;0) 273.00 +8000-8*T; 6000.00 N -REF:jac17 ! -PARAMETER L(FCC_A1,CR,FE,NI:VA;1) 273.00 -6500; 6000.00 N -REF:jac17 ! -PARAMETER L(FCC_A1,CR,FE,NI:VA;2) 273.00 +30000; 6000.00 N -REF:jac17 ! -PARAMETER TC(FCC_A1,CR:VA;0) 273.00 -1109; 6000.00 N -REF:11 ! -PARAMETER BMAGN(FCC_A1,CR:VA;0) 273.00 -2.46; 6000.00 N -REF:11 ! -PARAMETER TC(FCC_A1,CR,NI:VA;0) 273.00 -3605; 6000.00 N -REF:11 ! -PARAMETER BMAGN(FCC_A1,CR,NI:VA;0) 273.00 -1.91; 6000.00 N -REF:11 ! -PARAMETER TC(FCC_A1,FE:VA;0) 273.00 -201; 6000.00 N -REF:20 ! -PARAMETER BMAGN(FCC_A1,FE:VA;0) 273.00 -2.1; 6000.00 N -REF:20 ! -PARAMETER TC(FCC_A1,FE,NI:VA;0) 273.00 +2133; 6000.00 N -REF:20 ! -PARAMETER TC(FCC_A1,FE,NI:VA;1) 273.00 -682; 6000.00 N -REF:20 ! -PARAMETER BMAGN(FCC_A1,FE,NI:VA;0) 273.00 +9.55; 6000.00 N -REF:20 ! -PARAMETER BMAGN(FCC_A1,FE,NI:VA;1) 273.00 +7.23; 6000.00 N -REF:20 ! -PARAMETER BMAGN(FCC_A1,FE,NI:VA;2) 273.00 +5.93; 6000.00 N -REF:20 ! -PARAMETER BMAGN(FCC_A1,FE,NI:VA;3) 273.00 +6.18; 6000.00 N -REF:20 ! -PARAMETER TC(FCC_A1,NI:VA;0) 273.00 +633; 6000.00 N -REF:0 ! -PARAMETER BMAGN(FCC_A1,NI:VA;0) 273.00 +0.52; 6000.00 N -REF:0 ! - -$BCC_A2 phase - -TYPE_DEFINITION & GES A_P_D BCC_A2 MAGNETIC -1.0 0.4 ! -PHASE BCC_A2 %& 2 1 3 ! -CONSTITUENT BCC_A2 : CR,FE%,NI : VA% : ! - -PARAMETER G(BCC_A2,CR:VA;0) 273.00 +GHSERCR#; 6000.00 N -REF:0 ! -PARAMETER G(BCC_A2,FE:VA;0) 273.00 +GHSERFE#; 6000.00 N -REF:0 ! -PARAMETER G(BCC_A2,NI:VA;0) 273.00 +8715.084-3.556*T+GHSERNI#; 3000.00 N -REF:0 ! -PARAMETER L(BCC_A2,CR,FE:VA;0) 273.00 +20500-9.68*T; 6000.00 N -REF:11 ! -PARAMETER L(BCC_A2,CR,NI:VA;0) 273.00 +17170-11.8199*T; 6000.00 N -REF:11 ! -PARAMETER L(BCC_A2,CR,NI:VA;1) 273.00 +34418-11.8577*T; 6000.00 N -REF:11 ! -PARAMETER L(BCC_A2,CR,NI:VA;2) 273.00 +1e-8; 6000.00 N -REF:11 ! -PARAMETER L(BCC_A2,FE,NI:VA;0) 273.00 -956.63-1.28726*T; 6000.00 N -REF:20 ! -PARAMETER L(BCC_A2,FE,NI:VA;1) 273.00 +5000-5*T; 6000.00 N -REF:pov12 ! -PARAMETER L(BCC_A2,CR,FE,NI:VA;0) 273.00 +3000+5*T; 6000.00 N -REF:jac17 ! -PARAMETER L(BCC_A2,CR,FE,NI:VA;1) 273.00 +9000-6*T; 6000.00 N -REF:jac17 ! -PARAMETER L(BCC_A2,CR,FE,NI:VA;2) 273.00 -30000+20*T; 6000.00 N -REF:jac17 ! -PARAMETER TC(BCC_A2,CR:VA;0) 273.00 -311.5; 6000.00 N -REF:22 ! -PARAMETER BMAGN(BCC_A2,CR:VA;0) 273.00 -0.008; 6000.00 N -REF:0 ! -PARAMETER TC(BCC_A2,FE:VA;0) 273.00 +1043; 6000.00 N -REF:0 ! -PARAMETER BMAGN(BCC_A2,FE:VA;0) 273.00 +2.22; 6000.00 N -REF:0 ! -PARAMETER TC(BCC_A2,NI:VA;0) 273.00 +575; 6000.00 N -REF:0 ! -PARAMETER BMAGN(BCC_A2,NI:VA;0) 273.00 +0.85; 6000.00 N -REF:0 ! -PARAMETER TC(BCC_A2,CR,FE:VA;0) 273.00 +1650; 6000.00 N -REF:11 ! -PARAMETER TC(BCC_A2,CR,FE:VA;1) 273.00 +550; 6000.00 N -REF:11 ! -PARAMETER BMAGN(BCC_A2,CR,FE:VA;0) 273.00 -0.85; 6000.00 N -REF:pov09 ! -PARAMETER TC(BCC_A2,CR,NI:VA;0) 273.00 +2373; 6000.00 N -REF:11 ! -PARAMETER TC(BCC_A2,CR,NI:VA;1) 273.00 +617; 6000.00 N -REF:11 ! -PARAMETER BMAGN(BCC_A2,CR,NI:VA;0) 273.00 +4; 6000.00 N -REF:11 ! - -$SIGMA phase - -PHASE SIGMA % 3 8 4 18 ! -CONSTITUENT SIGMA : FE%,NI : CR% : CR,FE,NI :! - -PARAMETER G(SIGMA,FE:CR:CR;0) 273.00 +8*GFEFCC#+22*GHSERCR# - +92300-95.96*T; 6000.00 N -REF:62 ! -PARAMETER G(SIGMA,FE:CR:FE;0) 273.00 +117300-95.96*T+8*GFEFCC# - +4*GHSERCR#+18*GHSERFE#; 6000.00 N -REF:62 ! -PARAMETER G(SIGMA,FE:CR:NI;0) 273.00 -50000+32*T+8*GFEFCC#+4*GHSERCR# - +18*GNIBCC#; 6000.00 N -REF:pov13 ! -PARAMETER G(SIGMA,NI:CR:CR;0) 273.00 +8*GHSERNI#+22*GHSERCR# - +180000-170*T; 6000.00 N -REF:13 ! -PARAMETER G(SIGMA,NI:CR:FE;0) 273.00 +8*GHSERNI#+4*GHSERCR# - +18*GHSERFE#-50000+32*T; 6000.00 N -REF:pov13 ! -PARAMETER G(SIGMA,NI:CR:NI;0) 273.00 +8*GHSERNI#+4*GHSERCR# - +18*GNIBCC#+175400; 6000.00 N -REF:13 ! -PARAMETER L(SIGMA,FE:CR:CR,NI;0) 273.00 +1e-8; 6000.00 N -REF:pov12 ! -PARAMETER L(SIGMA,FE:CR:FE,NI;0) 273.00 -200000; 6000.00 N -REF:pov13 ! - -$FCC mobility -$CR - -PARAMETER MQ(FCC_A1&CR,CR:*) 273.00 -235000-82.0*T; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&CR,FE:*) 273.00 -286000-71.9*T; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&CR,NI:*) 273.00 -287000-64.4*T; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&CR,CR,FE:*;0) 273.00 -105000; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&CR,CR,NI:*;0) 273.00 -68000; 6000.00 N -Ref:41 ! -PARAMETER MQ(FCC_A1&CR,FE,NI:*;0) 273.00 +16100; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&CR,CR,FE,NI:*;0) 273.00 +310000; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&CR,CR,FE,NI:*;1) 273.00 +320000; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&CR,CR,FE,NI:*;2) 273.00 +120000; 6000.00 N -Ref:17 ! - -$FE - -PARAMETER MQ(FCC_A1&FE,CR:*) 273.00 -235000-82.0*T; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&FE,FE:*) 273.00 -286000+R*T*LN(7.0E-5); 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&FE,NI:*) 273.00 -287000-67.5*T; 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&FE,CR,FE:*;0) 273.00 +15900; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&FE,CR,NI:*;0) 273.00 -77500; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&FE,FE,NI:*;0) 273.00 -115000+104*T; 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&FE,FE,NI:*;1) 273.00 +78800-73.3*T; 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&FE,CR,FE,NI:*;0) 273.00 -740000; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&FE,CR,FE,NI:*;1) 273.00 -540000; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&FE,CR,FE,NI:*;2) 273.00 +750000; 6000.00 N -Ref:17 ! - -$NI - -PARAMETER MQ(FCC_A1&NI,CR:*) 273.00 -235000-82.0*T; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&NI,FE:*) 273.00 -286000-86.0*T; 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&NI,NI:*) 273.00 -287000-69.8*T; 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&NI,CR,FE:*;0) 273.00 -119000; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&NI,CR,NI:*;0) 273.00 -81000; 6000.00 N -Ref:19 ! -PARAMETER MQ(FCC_A1&NI,FE,NI:*;0) 273.00 +124000-51.4*T; 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&NI,FE,NI:*;1) 273.00 -300000+213*T; 6000.00 N -Ref:18 ! -PARAMETER MQ(FCC_A1&NI,CR,FE,NI:*;0) 273.00 +1840000; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&NI,CR,FE,NI:*;1) 273.00 +670000; 6000.00 N -Ref:17 ! -PARAMETER MQ(FCC_A1&NI,CR,FE,NI:*;2) 273.00 -1120000; 6000.00 N -Ref:17 ! - -$BCC Mobility - -$CR - -PARAMETER MQ(BCC_A2&CR,CR:*) 273.00 -407000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,CR:*) 273.00 -35.6*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,FE:*) 273.00 -218000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,FE:*) 273.00 +R*T*LN(8.5E-5); 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,NI:*) 273.00 -218000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,NI:*) 273.00 +R*T*LN(8.5E-5); 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,CR,FE:*;0) 273.00 +361000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,CR,FE:*;0) 273.00 -116*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,CR,FE:*;1) 273.00 +2820; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,CR,FE:*;1) 273.00 +37.5*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,CR,NI:*;0) 273.00 +350000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,CR,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,FE,NI:*;0) 273.00 +150000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,FE,NI:*;1) 273.00 +150000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,CR,FE,NI:*;1) 273.00 -2400000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&CR,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&CR,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! - -$FE - -PARAMETER MQ(BCC_A2&FE,CR:*) 273.00 -407000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,CR:*) 273.00 -17.2*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,FE:*) 273.00 -218000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,FE:*) 273.00 +R*T*LN(4.6E-5); 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,NI:*) 273.00 -218000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,NI:*) 273.00 +R*T*LN(4.6E-5); 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,CR,FE:*;0) 273.00 +267000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,CR,FE:*;0) 273.00 -117*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,CR,FE:*;1) 273.00 -416000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,CR,FE:*;1) 273.00 +348*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,CR,NI:*;0) 273.00 +350000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,CR,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,FE,NI:*;0) 273.00 +150000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,CR,FE,NI:*;1) 273.00 +1400000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&FE,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&FE,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! - -$NI - -PARAMETER MQ(BCC_A2&NI,CR:*) 273.00 -407000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,CR:*) 273.00 -17.2*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,FE:*) 273.00 -204000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,FE:*) 273.00 +R*T*LN(1.8E-5); 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,NI:*) 273.00 -204000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,NI:*) 273.00 +R*T*LN(1.8E-5); 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,CR,FE:*;0) 273.00 +88000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,CR,FE:*;0) 273.00 +10*T; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,CR,NI:*;0) 273.00 +350000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,CR,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,FE,NI:*;0) 273.00 +150000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,CR,FE,NI:*;0) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,CR,FE,NI:*;1) 273.00 -500000; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,CR,FE,NI:*;1) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MQ(BCC_A2&NI,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! -PARAMETER MF(BCC_A2&NI,CR,FE,NI:*;2) 273.00 +1e-8; 6000.00 N -Ref:14 ! - -""" - -ALMGSI_DB = """ - - -$ AL-MG-SI system with metastable phases -$ -$ Parameters for metastable phases and mobility -$ taken from E. Povoden-Karadeniz et al, CALPHAD 43 (2011) p. 94 -$ - -$Element Standard state mass [g/mol] H_298 S_298 -ELEMENT VA VACUUM 0.0 0.00 0.00 ! -ELEMENT AL FCC_A1 26.98154 4540 28.30 ! -ELEMENT MG HCP_A3 24.305 4998.0 32.671 ! -ELEMENT SI DIA_A4 28.0855 3217. 18.81 ! - - -$ -$FUNCTIONS FOR PURE ELEMENT -$ -FUNCTION GHSERAL - 273.00 -7976.15+137.093038*T-24.3671976*T*LN(T) - -1.884662E-3*T**2-0.877664E-6*T**3+74092*T**(-1); 700.00 Y - -11276.24+223.048446*T-38.5844296*T*LN(T) - +18.531982E-3*T**2-5.764227E-6*T**3+74092*T**(-1); 933.47 Y - -11278.378+188.684153*T-31.748192*T*LN(T)-1.231E+28*T**(-9); 2900.00 N -REF:0 ! -FUNCTION GHSERMG - 273.00 -8367.34+143.675547*T-26.1849782*T*LN(T)+0.4858E-3*T**2 - -1.393669E-6*T**3+78950*T**(-1); 923.00 Y - -14130.185+204.716215*T-34.3088*T*LN(T)+1038.192E25*T**(-9); 3000.00 N -REF:0 ! -FUNCTION GHSERSI - 273.00 -8162.609+137.236859*T-22.8317533*T*LN(T) - -1.912904E-3*T**2-0.003552E-6*T**3+176667*T**(-1); 1687.00 Y - -9457.642+167.271767*T-27.196*T*LN(T)-4.2037E+30*T**(-9); 3600.00 N -REF:0 ! - -$ -$ OTHER FUNCTIONS -$ -FUNCTION R - 273.00 +8.31451; 6000.00 N ! -FUNCTION GMG2SI 273.00 -92250.0+440.4*T-75.9*T*LN(T) - -0.0018*T**2+630000*T**(-1); 6000.00 N -REF:31 ! - -$ -$ LIQUID -$ - TYPE-DEF % SEQ * ! - PHASE LIQUID % 1 1.0 > -Random substitutional model. ->> 6 ! - CONSTITUENT LIQUID : AL,MG,SI: ! - -PARAMETER G(LIQUID,AL;0) - 273.00 +11005.029-11.841867*T+7.934E-20*T**7+GHSERAL#; 700.00 Y - +11005.03-11.841867*T+7.9337E-20*T**7+GHSERAL#; 933.47 Y - +10482.382-11.253974*T+1.231E+28*T**(-9)+GHSERAL#; 2900.00 N -REF:0 ! -PARAMETER G(LIQUID,MG;0) - 273.00 +8202.243-8.83693*T+GHSERMG#-8.0176E-20*T**7; 923.00 Y - +8690.316-9.392158*T+GHSERMG#-1.038192E+28*T**(-9); 6000.00 N -REF:31 ! -PARAMETER G(LIQUID,SI;0) - 273.00 +50696.36-30.099439*T+2.0931E-21*T**7+GHSERSI#; 1687.00 Y - +49828.165-29.559068*T+4.2037E+30*T**(-9)+GHSERSI#; 3600.00 N -REF:0 ! - -PARAMETER L(LIQUID,AL,MG;0) 273.00 -12000.0+8.566*T; 6000.00 N -REF:31 ! -PARAMETER L(LIQUID,AL,MG;1) 273.00 +1894.0-3.000*T; 6000.00 N -REF:31 ! -PARAMETER L(LIQUID,AL,MG;2) 273.00 +2000.0; 6000.00 N -REF:31 ! -PARAMETER L(LIQUID,AL,SI;0) 273.00 -11655.93-0.92934*T; 6000.00 N -REF:37 ! -PARAMETER L(LIQUID,AL,SI;1) 273.00 -2873.45+0.2945*T; 6000.00 N -REF:37 ! -PARAMETER L(LIQUID,AL,SI;2) 273.00 +2520; 6000.00 N -REF:37 ! -PARAMETER L(LIQUID,MG,SI;0) 273.00 -70055+24.98*T; 6000.00 N -REF:39 ! -PARAMETER L(LIQUID,MG,SI;1) 273.00 -1300; 6000.00 N -REF:39 ! -PARAMETER L(LIQUID,MG,SI;2) 273.00 +6272; 6000.00 N -REF:39 ! - -PARAMETER L(LIQUID,AL,MG,SI;0) 273.00 +11882; 6000.00 N -REF:34 ! -PARAMETER L(LIQUID,AL,MG,SI;1) 273.00 -24207; 6000.00 N -REF:34 ! -PARAMETER L(LIQUID,AL,MG,SI;2) 273.00 -38223; 6000.00 N -REF:34 ! - -$ -$ FCC_A1 -$ - PHASE FCC_A1 % 2 1 1 > Al-Matrix phase, face-centered cubic >> 6 ! - CONSTITUENT FCC_A1 : AL%,MG,SI : VA : ! - -PARAMETER G(FCC_A1,AL:VA;0) 273.00 +GHSERAL#; 2900.00 N -REF:0 ! -PARAMETER G(FCC_A1,MG:VA;0) 273.00 +2600-0.90*T+GHSERMG#; 6000.00 N -REF:0 ! -PARAMETER G(FCC_A1,SI:VA;0) 273.00 +51000-21.8*T+GHSERSI#; 3600.00 N -REF:0 ! - -PARAMETER L(FCC_A1,AL,MG:VA;0) 273.00 +1*LDF0ALMG#; 6000.00 N -REF:41 ! -PARAMETER L(FCC_A1,AL,MG:VA;1) 273.00 +1*LDF1ALMG#; 6000.00 N -REF:41 ! -PARAMETER L(FCC_A1,AL,MG:VA;2) 273.00 +1*LDF2ALMG#; 6000.00 N -REF:41 ! -PARAMETER L(FCC_A1,AL,SI:VA;0) 273.00 +1*LDF0ALSI#; 6000.00 N -REF:41 ! -PARAMETER L(FCC_A1,AL,SI:VA;1) 273.00 +1*LDF1ALSI#; 6000.00 N -REF:37 ! -PARAMETER L(FCC_A1,AL,SI:VA;2) 273.00 +1*LDF2ALSI#; 6000.00 N -REF:37 ! -PARAMETER L(FCC_A1,MG,SI:VA;0) 273.00 +1*LDF0SIMG#; 6000.00 N -REF:41 ! -PARAMETER L(FCC_A1,MG,SI:VA;1) 273.00 +1*LDF1SIMG#; 6000.00 N -REF:31 ! -PARAMETER L(FCC_A1,MG,SI:VA;2) 273.00 +1*LDF2SIMG#; 6000.00 N -REF:31 ! - -$ -$ SI_DIAMOND_A4 -$ - PHASE SI_DIAMOND_A4 % 1 1 > -Silicon precipitate. Space group Fd3m, prototype: C(diamond) ->> 4 ! - CONSTITUENT SI_DIAMOND_A4 : AL,MG,SI% : ! -PARAMETER G(SI_DIAMOND_A4,AL;0) 273.00 +30.0*T+GHSERAL#; 6000.00 N -REF:31 ! -PARAMETER G(SI_DIAMOND_A4,MG;0) 273.00 +GHSERMG#; 6000.00 N -REF:41 ! -PARAMETER G(SI_DIAMOND_A4,SI;0) 273.00 +GHSERSI#; 6000.00 N -REF:31 ! -PARAMETER L(SI_DIAMOND_A4,AL,SI;0) 273.00 +111417.7-46.1392*T; 6000.00 N -REF:37 ! -PARAMETER L(SI_DIAMOND_A4,MG,SI;0) 273.00 +65000; 6000.00 N -REF:41 ! - -$ -$ MG2SI_B -$ - PHASE MG2SI_B % 2 2 1 > -Face-centered cubic equilibrium phase. -Incoherent precipitates (plates or cubes) in the overaging regime, 6xxx alloys. [REF:C31,C32] ->> 5 ! - CONSTITUENT MG2SI_B : MG : SI : ! -PARAMETER G(MG2SI_B,MG:SI;0) 273.00 GMG2SI; 6000.00 N -REF:31 ! - -$ -$ BETA_AL3MG2 -$ - PHASE BETA_AL3MG2 % 2 89 140 > -Cubic (Al,Zn)3Mg2 equilibrium phase, prototype: Al3Mg2. ->> 2 ! - CONSTITUENT BETA_AL3MG2 : MG : AL : ! -PARAMETER G(BETA_AL3MG2,MG:AL;0) 273.00 -246175.0-675.5500*T - +89*GHSERMG#+140*GHSERAL#; 6000.00 N -REF:31 ! - -$ -$ E_AL30MG23 -$ - PHASE E_AL30MG23 % 2 23 30 > -Epsilon equilibrium phase, prototype: Co5Cr2Mo3 ->> 1 ! - CONSTITUENT E_AL30MG23 : MG : AL : ! -PARAMETER G(E_AL30MG23,MG:AL;0) 273.00 -52565.4-173.1775*T - +23*GHSERMG#+30*GHSERAL#; 6000.00 N -REF:31 ! - -$ -$ G_AL12MG17 -$ - PHASE G_AL12MG17 % 3 10 24 24 > -Gamma equilibrium phase, space group: I43m, prototype: Alpha-Mn. -Precipitate in Al-Mg-Zn alloy ->> 2 ! - CONSTITUENT G_AL12MG17 : MG : AL,MG% : AL : ! -PARAMETER G(G_AL12MG17,MG:MG:MG;0) 273.00 +266939.2-174.638*T+58*GHSERMG#; 6000.00 N -REF:40 ! -PARAMETER G(G_AL12MG17,MG:AL:AL;0) 273.00 +195750-203*T - +10*GHSERMG#+48*GHSERAL#; 6000.00 N -REF:40 ! -PARAMETER G(G_AL12MG17,MG:MG:AL;0) 273.00 -105560-101.5*T - +34*GHSERMG#+24*GHSERAL#; 6000.00 N -REF:40 ! -PARAMETER G(G_AL12MG17,MG:AL:MG;0) 273.00 +568249.2-276.138*T - +34*GHSERMG#+24*GHSERAL#; 6000.00 N -REF:40 ! -PARAMETER L(G_AL12MG17,MG:AL:AL,MG;0) 273.00 +226200-29*T; 6000.00 N -REF:40 ! -PARAMETER L(G_AL12MG17,MG:MG:AL,MG;0) 273.00 +226200-29*T; 6000.00 N -REF:40 ! - -$ -$ B_PRIME_L -$ - PHASE B_PRIME_L % 3 3 9 7 > -Metastable B´ phase - low-T type reflecting lowest energy modification from 1st principles. -Structure can be related to the hexagonal structure of Q-Phase, with empty Cu-sites. [REF:C11,C37] ->> 2 ! - CONSTITUENT B_PRIME_L : AL : MG : SI : ! -PARAMETER G(B_PRIME_L,AL:MG:SI;0) 273.00 -140000-10*T+3*GHSERAL#+9*GHSERMG#+7*GHSERSI#; 6000.00 N -REF:41 ! - -$ -$ MGSI_B_P -$ - PHASE MGSI_B_P % 2 1.8 1 > -Beta´, metastable hexagonal close-packed rod-like Mg-Si precipitates in 6xxx alloys. [REF:C31,C32,C34] ->> 5 ! - CONSTITUENT MGSI_B_P : MG : SI : ! - -PARAMETER G(MGSI_B_P,MG:SI;0) 273.00 GMG2SI + 24250 - 40.4*T + 5.9*T*LN(T) - 0.0042*T**2 - 130000*T**(-1); 6000.00 N -REF:41 ! - -$ -$ MG5SI6_B_DP -$ - PHASE MG5SI6_B_DP % 2 5 6 > -Main metastable hardening phase in 6xxx, monoclinic with space group C2/m. Al-free Mg5Si6. -Semicoherent needles. [REF:C31,C32,C35]. ->> 5 ! - CONSTITUENT MG5SI6_B_DP : MG : SI : ! -PARAMETER G(MG5SI6_B_DP,MG:SI;0) 273.00 -5000-30*T-0.0096*T**2 - -1e-7*T**3+5*GHSERMG#+6*GHSERSI#; 6000.00 N -REF:41 ! - -$ -$ U1_PHASE -$ - PHASE U1_PHASE % 3 2 1 2 > -Needle-like precipitate with trigonal structure observed in 6xxx in the beta´ precipitation regime. [REF:C37] ->> 3 ! - CONSTITUENT U1_PHASE : AL : MG : SI : ! -PARAMETER G(U1_PHASE,AL:MG:SI;0) 273.00 -5000-10*T-0.0055*T**2 - +3e-6*T**3+150000*T**(-1)+2*GHSERAL#+GHSERMG#+2*GHSERSI#; 6000.00 N -REF:41 ! - -$ -$ U2_PHASE -$ - PHASE U2_PHASE % 3 1 1 1 > -Needle-like precipitate with orthorhombic structure in 6xxx in the beta' precipitation regime. [REF:C37] ->> 3 ! - CONSTITUENT U2_PHASE : AL : MG : SI : ! -PARAMETER G(U2_PHASE,AL:MG:SI;0) 273.00 -14000-3.75*T-0.0015*T**2 - +7.5e-7*T**3+62500*T**(-1)+1*GHSERAL#+1*GHSERMG#+1*GHSERSI#; 6000.00 N -REF:41 ! - -$ -$ Mobility terms -$ -PARAMETER MQ(FCC_A1&AL,*) 273.00 -127200+R*T*LN(1.39e-5); 6000.00 N -Ref:41 ! - -PARAMETER MQ(FCC_A1&MG,AL:*) 273.00 -119000+R*T*LN(3.7e-5); 6000.00 N -Ref:41! -PARAMETER MQ(FCC_A1&MG,MG:*) 273.00 -112499+R*T*LN(5.7e-5); 6000.00 N -Ref:41! -PARAMETER MQ(FCC_A1&MG,MG,AL:*) 273.00 54511; 6000.00 N -Ref:41! -PARAMETER MQ(FCC_A1&MG,SI:*) 273.00 -119000+R*T*LN(3.7e-5); 6000.00 N -Ref:41! - -PARAMETER MQ(FCC_A1&SI,AL:*) 273.00 -136400+R*T*LN(2.31e-4); 6000.00 N -Ref:41 ! -PARAMETER MQ(FCC_A1&SI,MG:*) 273.00 -136400+R*T*LN(2.31e-4); 6000.00 N -Ref:41 ! -PARAMETER MQ(FCC_A1&SI,SI:*) 273.00 -448400+R*T*LN(154e-4); 6000.00 N -Ref:41 ! - -$ -$ References -$ - -LIST_OF_REFERENCES - -A00201-0 unary A.T. Dinsdale, SGTE Data of pure elements, CALPHAD, Vol. 15, No. 4, pp 317-425, 1991. - 31 bin, tern N. Saunders, COST 507: Thermochemical database for light metal alloys, Vol. 2, pp 23-27, 1998. -A00166-34 Al-Mg-Si J. Lacaze and R. Valdes, CALPHAD-type assessment of the Al-Mg-Si system, Monatshefte f. Chemie, Vol. 136, A00169-37 Al-Fe-Si Z.-K. Liu, Y.A. Chang, Thermodynamic assessment of the Al-Fe-Si system, Metall. Mater. Trans A, Vol. 30A, pp 1081-1095, 1999. -A00172-39 Mg-Si-Li D. Kevorkov, R. Schmid-Fetzer, F. Zhang, Phase equilibria and thermodynamics of the Mg-Si-Li system and remodeling of the Mg-Si system, J. Phase Equilib. Diffusion, Vol. 25, pp 140-151, 2004. -A00173-40 Al-Mg-Zn P. Liang et al., Experimental investigation and thermodynamic calculation of the Al-Mg-Zn system, Thermochim. Acta, Vol. 314, pp 87-110, 1998. - 41 E. Povoden-Karadeniz et al, Calphad modeling of metastable phases in the Al-Mg-Si system, CALPHAD, Vol. 42 pp 94-104, 1991 -$ ################################################################################################################################################################################################################################################################################ - -$ References of phase descriptions - - C31 Al-Mg-Si J.P. Lynch, L.M. Brown, M.H.Jacobs, Microanalysis of age-hardening precipitates in Aluminium-alloys, Acta metall. mater. 30 (1982) 1389. -C00025-C32 Al-Mg-Si G.A. Edwards, K. Stiller, G.L. Dunlop, M.J. Couper, The precipitaton sequence in Al-Mg-Si alloys, Acta mater. 46 (1998) 3893-3904. -C00026-C33 Al-Mg-Si, GP-zones K. Matsuda, H. Gamada, K. Fujii, Y. Uetani, T. Sato, A. Kamio, S. Ikeno, High-resolution electron microscopy on the structure of Guinier-Preston zones in an Al-1.6mass% Mg2Si alloy, Metall. mater. trans. A 29 (1998) 1161-1167. -C00027-C34 Mg-Si beta´ R. Vissers, M.A. van Huis, J. Jansen, H.W. Zandbergen, C.D. Marioara, S.J. Andersen, The structure of the beta´ phase in Al-Mg-Si alloys, Acta mater. 55 (2007) 3815-3823. -C00028-C35 Mg-Si beta´´ H.W. Zandbergen, S.J. Andersen, J. Jansen, Structure determination of Mg5Si6 particles in Al by dynamic electron diffraction studies, Science 277 (1997) 1221-1225. - C36 Al-Mg-Si H.S. Hasting, A.G. Froseth, S.J. Andersen, R. Vissers, J.C. Walmsley, C.D. Marioara, F. Danoix, W. Lefebvre, R. Holmestad, Composition of beta´´ precipitates in Al-Mg-Si alloys by atom probe tomography and first principles calculations, J. appl. phys. 106 (2009) 123527. -C00029-C37 Al-Mg-Si, U-phases S.J. Andersen, C.D. Marioara, R. Vissers, A. Froseth, H.W. Zandbergen, The structural relation between precipitates in Al-Mg-Si alloys, the Al-matrix and diamond silicon, with emphasis on the trigonal U1-MgAl2Si2, Mater. sci. eng. A 444 (2007) 157-169. - - 11 Smithells Metals Reference Book, Seventh Edition, Butterworth-Heinemann, Oxford, 1999. - 32 J. Yao, Y.W. Cui, H. Liu, H. Kou, J. Li, L. Zhou, Computer Coupling of Phase Diagrams and Thermochemistry Vol.32, 602-607, 2008. -""" \ No newline at end of file +CuNi_datasets = [ + # D0 for Cu in Cu + { + "components": ["CU", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_D0_CU", + "values": [[[4.89e-5]]], + "reference": "Ghosh2001" + }, + # Q for Cu in Cu + { + "components": ["CU", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_CU", + "values": [[[205872]]], + "reference": "Ghosh2001" + }, + # D0 for Cu in Ni + { + "components": ["NI", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["NI", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_D0_CU", + "values": [[[7.24e-5]]], + "reference": "Anand1965" + }, + # Q for Cu in Ni + { + "components": ["NI", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["NI", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_CU", + "values": [[[255224]]], + "reference": "Anand1965" + }, + # D0 for Cu in Cu-Ni + { + "components": ["CU", "NI", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [ [["CU", "NI"], "VA"], [["CU", "NI"], "VA"], [["CU", "NI"], "VA"]], + "sublattice_occupancies": [ [[0.7173, 0.2827], 1], [[0.8028, 0.1972], 1], [[0.9008, 0.0992], 1]] + }, + "output": "TRACER_D0_CU", + "values": [[[2.67e-5, 1.63e-5, 4.14e-5]]], + "reference": "Anusavice1972" + }, + # Q for Cu in Cu-Ni + { + "components": ["CU", "NI", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [[["CU", "NI"], "VA"], [["CU", "NI"], "VA"], [["CU", "NI"], "VA"]], + "sublattice_occupancies": [ [[0.7173, 0.2827], 1], [[0.8028, 0.1972], 1], [[0.9008, 0.0992], 1]] + }, + "output": "TRACER_Q_CU", + "values": [[[215847, 205847, 210162]]], + "reference": "Anusavice1972" + }, + # D0 for Ni in Cu + { + "components": ["CU", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_D0_NI", + "values": [[[1.94e-4]]], + "reference": "Anusavice1972" + }, + # Q for Ni in Cu + { + "components": ["CU", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_NI", + "values": [[[232826]]], + "reference": "Anusavice1972" + }, + # Q for Ni in Ni + { + "components": ["NI", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": 1273}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["NI", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_Q_NI", + "values": [[[285142]]], + "reference": "Bakker1968" + } +] + +Cu_tracer_diff_datasets = [ + { + "components": ["CU", "VA"], "phases": ["FCC_A1"], + "conditions": {"P": 101325, "T": [1013, 1080, 1103, 1185, 1210, 1248, 1283, 1318]}, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [["CU", "VA"]], + "sublattice_occupancies": [[1, 1]] + }, + "output": "TRACER_DIFF_CU", + "values": [[[0.115e-14], [0.501e-14], [0.858e-14], [3.55e-14], [5.74e-14], [11e-14], [17.5e-14], [30.2e-14]]], + "reference": "Ghosh2001" + } +] \ No newline at end of file diff --git a/kawin/tests/test_diffusion.py b/kawin/tests/test_diffusion.py index 6d4d000..989dd3b 100644 --- a/kawin/tests/test_diffusion.py +++ b/kawin/tests/test_diffusion.py @@ -7,7 +7,7 @@ from kawin.diffusion.DiffusionParameters import computeMobility, CompositionProfile, BoundaryConditions, TemperatureParameters from kawin.diffusion.HomogenizationParameters import HomogenizationParameters, computeHomogenizationFunction from kawin.thermo import GeneralThermodynamics -from kawin.tests.datasets import * +from kawin.tests.databases import * N = 100 singleModelBinary = SinglePhaseModel([-1e-3, 1e-3], N, ['NI', 'CR'], ['FCC_A1']) diff --git a/kawin/tests/test_mobility_generation.py b/kawin/tests/test_mobility_generation.py new file mode 100644 index 0000000..0e0c623 --- /dev/null +++ b/kawin/tests/test_mobility_generation.py @@ -0,0 +1,220 @@ +from numpy.testing import assert_allclose +from tinydb import where +from tinydb.storages import MemoryStorage + +from pycalphad import Database, variables as v +from espei.utils import PickleableTinyDB + +from kawin.mobility_fitting import generate_mobility, MobilityTemplate, EquilibriumSiteFractionGenerator +from kawin.mobility_fitting import generate_liquid_mobility_liu, LiuSpecies, generate_liquid_mobility_su, SuSpecies +from kawin.mobility_fitting.manual_fitting import grab_tracer_datasets, fit_prefactor, fit_activation_energy, select_best_model +from kawin.mobility_fitting.utils import find_last_variable, get_used_database_symbols + +from kawin.tests.databases import CUNI_TDB +from kawin.tests.datasets import CuNi_datasets, Cu_tracer_diff_datasets + +def test_espei_mobility_generation(): + ''' + Test espei mobility generation from activation energy and pre-factor data + ''' + phase_models = { + "components": ["CU", "NI", "VA"], + "phases": { + "FCC_A1": {"sublattice_model": [["CU", "NI"], ["VA"]], "sublattice_site_ratios": [1, 1]}, + } + } + + with PickleableTinyDB(storage=MemoryStorage) as datasets_db: + for ds in CuNi_datasets: + datasets_db.insert(ds) + + aicc = {'FCC_A1': {'TRACER_Q_CU': 2, 'TRACER_D0_CU': 2}} + dbf = generate_mobility(phase_models, datasets_db, aicc_penalty_factor=aicc) + #print(dbf.to_string(fmt='tdb')) + vv_symbols = [s for s in dbf.symbols if s.startswith('VV00')] + vv_vals = [dbf.symbols[s] for s in vv_symbols] + # dbf should have 9 symbols (2 for Cu in Cu, 2 for Cu in Ni, 2 for Ni in Cu, 1 for Ni in Ni, and 2 for Cu in Cu-Ni) + assert len(vv_symbols) == 9 + sym_vals = [-82.5275, -205872.0, -71.0695, -232826.0, -79.2647, -255224.0, -285142.0, -39.2064, 32429.60] + assert_allclose(vv_vals, sym_vals, rtol=1e-3) + + dbf_ni = generate_mobility(phase_models, datasets_db, diffusing_species=['NI']) + #print(dbf_ni.to_string(fmt='tdb')) + vv_symbols = [s for s in dbf_ni.symbols if s.startswith('VV00')] + vv_vals = [dbf_ni.symbols[s] for s in vv_symbols] + # dbf should have 3 symbols (2 for Ni in Cu and 1 for Ni in Ni) + assert len(vv_symbols) == 3 + sym_vals = [-71.0695, -232826.0, -285142.0] + assert_allclose(vv_vals, sym_vals, rtol=1e-3) + +def test_espei_mobility_generation_from_tracer_diff(): + ''' + Test espei mobility generation from tracer diffusivity data + ''' + phase_models = { + "components": ["CU", "VA"], + "phases": { + "FCC_A1": {"sublattice_model": [["CU"], ["VA"]], "sublattice_site_ratios": [1, 1]}, + } + } + + with PickleableTinyDB(storage=MemoryStorage) as datasets_db: + for ds in Cu_tracer_diff_datasets: + datasets_db.insert(ds) + + dbf = generate_mobility(phase_models, datasets_db, fit_to_tracer=True) + #print(dbf.to_string(fmt='tdb')) + vv_symbols = [s for s in dbf.symbols if s.startswith('VV00')] + vv_vals = [dbf.symbols[s] for s in vv_symbols] + # dbf should have 2 symbols for Cu in Cu + assert len(vv_symbols) == 2 + sym_vals = [-202181.0, -86.4134] + assert_allclose(vv_vals, sym_vals, rtol=1e-3) + +def test_manual_mobility_generation(): + ''' + Tests manual mobility generation from activation and prefactor data and + that selected model templates can be added to database + ''' + dbf = Database(CUNI_TDB) + eqgen = EquilibriumSiteFractionGenerator(dbf) + + phase = 'FCC_A1' + sublattice_model = [1, 1] + constituents = [['CU', 'NI'], ['VA']] + diffusing_species = 'CU' + + # Create mobility templates. We'll do three options here: + # a) no mixing term, b) 1st order mixing, c) 1st and 2nd order mixing + t0 = MobilityTemplate(phase, diffusing_species, sublattice_model, constituents) + + t1 = MobilityTemplate(phase, diffusing_species, sublattice_model, constituents) + t1.add_activation_energy([['CU', 'NI'], ['VA']], 0) + t1.add_prefactor([['CU', 'NI'], ['VA']], 0) + + t2 = MobilityTemplate(phase, diffusing_species, sublattice_model, constituents) + t2.add_activation_energy([['CU', 'NI'], ['VA']], [0, 1]) + t2.add_prefactor([['CU', 'NI'], ['VA']], [0, 1]) + + with PickleableTinyDB(storage=MemoryStorage) as datasets_db: + for ds in CuNi_datasets: + datasets_db.insert(ds) + + # Fit prefactor parameters to data + d_data = grab_tracer_datasets(datasets_db, 'D0', phase, ['CU', 'NI', 'VA'], diffusing_species) + d_model, d_results = select_best_model(d_data, [t0, t1, t2], fit_prefactor, eqgen, p=0.1, return_all_models = True) + assert_allclose(d_model.aicc, -13.633828, rtol=1e-3) + + # Fit activation energy parameters to data + q_data = grab_tracer_datasets(datasets_db, 'Q', phase, ['CU', 'NI', 'VA'], diffusing_species) + q_model, q_results = select_best_model(q_data, [t0, t1, t2], fit_activation_energy, eqgen, return_all_models = True) + + assert_allclose(q_model.aicc, 92.05808) + + d_model.template.add_to_database(dbf, d_model.parameters) + q_model.template.add_to_database(dbf, q_model.parameters) + #print(dbf.to_string(fmt='tdb')) + vv_symbols = [s for s in dbf.symbols if s.startswith('VV00')] + vv_vals = [dbf.symbols[s] for s in vv_symbols] + # dbf should have 6 symbols (2 for Cu in Cu, 2 for Cu in Ni, 2 for D0 mixing) + assert len(vv_symbols) == 6 + sym_vals = [-81.78946, -79.25679, -18.55759, -45.44596, -202291.969, -253898.678] + assert_allclose(vv_vals, sym_vals, rtol=1e-3) + +def test_liquid_mobility(): + ''' + Test Liu and Su liquid mobility models and that they can be added to the database + ''' + dbf = Database(CUNI_TDB) + eqgen = EquilibriumSiteFractionGenerator(dbf) + + # Create mobility parameters using the Liu model + liu_species = [ + LiuSpecies('CU', diameter=2.55, atomic_number=29, Tm=1358, melting_phase='FCC_A1'), + LiuSpecies('NI', diameter=2.49, atomic_number=28, Tm=1728, melting_phase='FCC_A1'), + ] + liu_templates = generate_liquid_mobility_liu(dbf, liu_species) + + liq_mob_params = dbf.search((where('parameter_type') == 'MQ') & (where('phase_name') == 'LIQUID')) + # 4 liquid parameters for Cu in Cu, Cu in Ni, Ni in Cu and Ni in Ni + assert len(liq_mob_params) == 4 + + # Create mobility parameters using the Su model + su_species = [ + SuSpecies('CU', atomic_mass=63.55, density=8.96, Tm=1358), + SuSpecies('NI', atomic_mass=58.69, density=8.90, Tm=1728), + ] + # We could disable adding the liquid mobility models to the database + su_templates = generate_liquid_mobility_su(dbf, su_species, add_to_database=False) + + # Assert correctness of liquid mobility models + conditions = {v.T: 2000, v.P: 101325, v.X('CU'): 0.3} + vals = {'CU': 2.988006e-13, 'NI': 3.060001e-13} + for s in liu_templates: + y = liu_templates[s].evaluate(liu_templates[s].mobility_function, {}, eqgen, conditions) + assert_allclose(y, vals[s], rtol=1e-3) + + mq = liu_templates[s].evaluate(liu_templates[s].MQ, {}, eqgen, conditions) + d0 = liu_templates[s].evaluate(liu_templates[s].prefactor, {}, eqgen, conditions) + q = liu_templates[s].evaluate(liu_templates[s].activation_energy, {}, eqgen, conditions) + print(mq, d0, q) + + vals = {'CU': 3.331584e-13, 'NI': 3.413458e-13} + for s in su_templates: + y = su_templates[s].evaluate(su_templates[s].mobility_function, {}, eqgen, conditions) + assert_allclose(y, vals[s], rtol=1e-3) + +def test_template_evaluation(): + ''' + Test that template can evaluate mobility, MQ, prefactor and activation energy + Test that evaluation can also work when 1 dependent variable is present + ''' + dbf = Database(CUNI_TDB) + eqgen = EquilibriumSiteFractionGenerator(dbf) + + species = LiuSpecies('CU', diameter=2.55, atomic_number=29, Tm=1358, melting_phase='FCC_A1') + templates = generate_liquid_mobility_liu(dbf, [species]) + + conditions = {v.T: 2000, v.P: 101325} + d = templates['CU'].evaluate(templates['CU'].mobility_function, {}, eqgen, conditions) + mq = templates['CU'].evaluate(templates['CU'].MQ, {}, eqgen, conditions) + d0 = templates['CU'].evaluate(templates['CU'].prefactor, {}, eqgen, conditions) + q = templates['CU'].evaluate(templates['CU'].activation_energy, {}, eqgen, conditions) + + assert_allclose(d, 4.581566e-13, rtol=1e-3) + assert_allclose(mq, -310840.27, rtol=1e-3) + assert_allclose(d0, -16.4996237, rtol=1e-3) + assert_allclose(q, 36468.03076, rtol=1e-3) + + # Test conditions with 1 dependent value + conditions = {v.T: (2000, 3000, 100), v.P: 101325} + t, d, variable = templates['CU'].evaluate(templates['CU'].mobility_function, {}, eqgen, conditions) + assert len(t) == len(d) + assert variable == v.T + +def test_database_variable_utilities(): + phase_models = { + "components": ["CU", "NI", "VA"], + "phases": { + "FCC_A1": {"sublattice_model": [["CU", "NI"], ["VA"]], "sublattice_site_ratios": [1, 1]}, + } + } + + with PickleableTinyDB(storage=MemoryStorage) as datasets_db: + for ds in CuNi_datasets: + datasets_db.insert(ds) + + aicc = {'FCC_A1': {'TRACER_Q_CU': 2, 'TRACER_D0_CU': 2}} + dbf = generate_mobility(phase_models, datasets_db, aicc_penalty_factor=aicc) + + last_variable = find_last_variable(dbf) + # generate_mobility will generate 9 symbols, so next variable should be VV0009 + assert last_variable == 9 + + # Only mixing parameters of Cu mobility (2 symbols in total) + free_syms = get_used_database_symbols(dbf, ['CU', 'NI'], 'CU', ['FCC_A1'], include_subsystems=False) + assert len(set(free_syms).symmetric_difference({'VV0007', 'VV0008'})) == 0 + + # Endmember and mixing parameters of Cu mobility (6 symbols in total) + free_syms_endmembers = get_used_database_symbols(dbf, ['CU', 'NI'], 'CU', ['FCC_A1'], include_subsystems=True) + assert len(set(free_syms_endmembers).symmetric_difference({'VV0000', 'VV0001', 'VV0004', 'VV0005', 'VV0007', 'VV0008'})) == 0 \ No newline at end of file diff --git a/kawin/tests/test_fitting.py b/kawin/tests/test_mobility_mcmc.py similarity index 99% rename from kawin/tests/test_fitting.py rename to kawin/tests/test_mobility_mcmc.py index 9dfcd7e..df8b84d 100644 --- a/kawin/tests/test_fitting.py +++ b/kawin/tests/test_mobility_mcmc.py @@ -5,7 +5,7 @@ from espei.phase_models import PhaseModelSpecification from kawin.mobility_fitting.error_functions import NonEquilibriumMobilityResidual, EquilibriumMobilityResidual -from kawin.tests.datasets import * +from kawin.tests.databases import * def test_non_eq_tracer_D0(): dataset = { diff --git a/kawin/tests/test_precipitation.py b/kawin/tests/test_precipitation.py index 6c5cf3b..47dcde2 100644 --- a/kawin/tests/test_precipitation.py +++ b/kawin/tests/test_precipitation.py @@ -3,7 +3,7 @@ import numpy as np from numpy.testing import assert_allclose -from kawin.tests.datasets import ALZR_TDB, NICRAL_TDB, ALMGSI_DB +from kawin.tests.databases import ALZR_TDB, NICRAL_TDB, ALMGSI_DB from kawin.precipitation import PrecipitateModel, StrainEnergy from kawin.precipitation import VolumeParameter, PrecipitateParameters, MatrixParameters, TemperatureParameters from kawin.thermo import BinaryThermodynamics, MulticomponentThermodynamics diff --git a/kawin/tests/test_solver.py b/kawin/tests/test_solver.py index d9ef5f0..88c2fd9 100644 --- a/kawin/tests/test_solver.py +++ b/kawin/tests/test_solver.py @@ -6,7 +6,7 @@ from kawin.thermo import BinaryThermodynamics, MulticomponentThermodynamics from kawin.GenericModel import GenericModel, Coupler from kawin.solver import SolverType -from kawin.tests.datasets import * +from kawin.tests.databases import * AlZrTherm = BinaryThermodynamics(ALZR_TDB, ['AL', 'ZR'], ['FCC_A1', 'AL3ZR'], drivingForceMethod='tangent') NiAlCrTherm = MulticomponentThermodynamics(NICRAL_TDB, ['NI', 'AL', 'CR'], ['FCC_A1', 'FCC_L12'], drivingForceMethod='tangent') diff --git a/kawin/tests/test_surrogate.py b/kawin/tests/test_surrogate.py index e7dd2c2..5041b32 100644 --- a/kawin/tests/test_surrogate.py +++ b/kawin/tests/test_surrogate.py @@ -5,7 +5,7 @@ import pytest from kawin.thermo import BinaryThermodynamics, MulticomponentThermodynamics, BinarySurrogate, MulticomponentSurrogate -from kawin.tests.datasets import * +from kawin.tests.databases import * AlZrTherm = BinaryThermodynamics(ALZR_TDB, ['AL', 'ZR'], ['FCC_A1', 'AL3ZR'], drivingForceMethod='approximate') NiCrAlTherm = MulticomponentThermodynamics(NICRAL_TDB, ['NI', 'CR', 'AL'], ['FCC_A1', 'FCC_L12'], drivingForceMethod='approximate') diff --git a/kawin/tests/test_thermodynamics.py b/kawin/tests/test_thermodynamics.py index 84f2eaf..9f4702b 100644 --- a/kawin/tests/test_thermodynamics.py +++ b/kawin/tests/test_thermodynamics.py @@ -4,7 +4,7 @@ from pycalphad import Database from kawin.thermo import GeneralThermodynamics, BinaryThermodynamics, MulticomponentThermodynamics -from kawin.tests.datasets import * +from kawin.tests.databases import * #Default driving force method will be 'tangent' AlZrTherm = BinaryThermodynamics(ALZR_TDB, ['AL', 'ZR'], ['FCC_A1', 'AL3ZR'], drivingForceMethod='tangent') From e58bad4c9804740f057261a365f571958d855cb4 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Mon, 24 Feb 2025 14:48:20 -0800 Subject: [PATCH 17/53] grammatical fixes in mobility fitting examples --- .../mobility_fitting/01_parameter_generation.ipynb | 4 ++-- .../mobility_fitting/02_mcmc_optimization.ipynb | 14 +++++++------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/examples/mobility_fitting/01_parameter_generation.ipynb b/examples/mobility_fitting/01_parameter_generation.ipynb index 7b8b85c..9886110 100644 --- a/examples/mobility_fitting/01_parameter_generation.ipynb +++ b/examples/mobility_fitting/01_parameter_generation.ipynb @@ -197,7 +197,7 @@ "source": [ "### Liquid mobility\n", "\n", - "Since we don't have any mobility data for the liquid phase, we can estimate them using some available models in the literature. To models are available in kawin:\n", + "Since we don't have any mobility data for the liquid phase, we can estimate them using some available models in the literature. Two models are available in kawin:\n", "\n", "Y. Liu et al, \"A predictive equation for solute diffusivity in liquid metals\" Scripta Materialia 55 (2006), 367. doi:10.1016/j.scriptamat.2006.04.019\n", "- $ Q = 0.17 R T_m (16+K_0) $ $ J/mol $\n", @@ -241,7 +241,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We could compare the models from Su et al and Liu et al to see how close the values are and what formst he models take" + "We could compare the models from Su et al and Liu et al to see how close the values are and what forms the models take" ] }, { diff --git a/examples/mobility_fitting/02_mcmc_optimization.ipynb b/examples/mobility_fitting/02_mcmc_optimization.ipynb index c583172..e337508 100644 --- a/examples/mobility_fitting/02_mcmc_optimization.ipynb +++ b/examples/mobility_fitting/02_mcmc_optimization.ipynb @@ -8,12 +8,12 @@ "\n", "This example will optimize the generated mobility models we created in 01_parameter_generation\n", "\n", - "During parameter generation, we only fitted models against tracer diffusivity data since no thermodynamic information is necessary to compute these terms. However, these types of data does not account for chemical potential gradients. Diffusion data computed from a diffusion coupled (interdiffusivity) considered chemical potential gradients and must be assessed against. We can do that through MCMC optimization using Espei" + "During parameter generation, we only fitted models against tracer diffusivity data since no thermodynamic information is necessary to compute these terms and each type of data pertains to the mobility of a single component. However, these types of data does not account for chemical potential gradients. Diffusion data computed from a diffusion coupled (interdiffusivity) considered chemical potential gradients and must be assessed against. We can do that through MCMC optimization using Espei" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ "dbf_input = 'databases/CuNi_mob_gen.tdb'\n", "dbf_output = 'databases/CuNi_mcmc.tdb'\n", "\n", - "# We set includeSubsystems to True to assess the endmember parameters as well. If we want to\n", + "# We set include_subsystems to True to assess the endmember parameters as well. If we want to\n", "# only free the mixing parameters, set this to False\n", "cu_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'CU', 'FCC_A1', include_subsystems=True)\n", "ni_params = get_used_database_symbols(dbf_input, ['CU', 'NI'], 'NI', 'FCC_A1', include_subsystems=True)\n", @@ -107,9 +107,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Comparing generated models to interdiffusivity\n", + "### Comparing models to interdiffusivity\n", "\n", - "Before we optimize the model, let's check how well the initial mobility models compare against the interdiffusivity data." + "We could compare the assessed and generated mobility models against the interdiffusivity data." ] }, { @@ -301,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -342,7 +342,7 @@ " therm.updateParameters(param_map)\n", " diffs.append(therm.getInterdiffusivity(x, T))\n", "\n", - "# Plot the average diffusivity along with 2 sigma intervals\n", + "# Plot the average diffusivity along with 95% confidence intervals\n", "diffs = np.array(diffs)\n", "avg = np.exp(np.average(np.log(diffs), axis=0))\n", "d_low = np.percentile(diffs, 97.5, axis=0)\n", From 8e0790e08935c707d0969113d2511b77082a1758 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Mon, 24 Feb 2025 14:49:29 -0800 Subject: [PATCH 18/53] additional grammatical fixes on mobility examples --- examples/mobility_fitting/01_parameter_generation.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/mobility_fitting/01_parameter_generation.ipynb b/examples/mobility_fitting/01_parameter_generation.ipynb index 9886110..47b4457 100644 --- a/examples/mobility_fitting/01_parameter_generation.ipynb +++ b/examples/mobility_fitting/01_parameter_generation.ipynb @@ -65,7 +65,7 @@ "- Ni diffusion in $(Cu)_1 (Va)_1$\n", "- Ni diffusion in $(Ni)_1 (Va)_1$\n", "\n", - "In Espei, parameter generation using custom models can be done by supplying a corresponding fitting description. To have mobility models for each component, we require a fitting description and fitting steps for each component, which is created in the `generate_mobility` funtion." + "In Espei, parameter generation using custom models can be done by supplying a corresponding fitting description. To have mobility models for each component, we require a fitting description and fitting steps for each component, which is created in the `generate_mobility` function." ] }, { @@ -197,7 +197,7 @@ "source": [ "### Liquid mobility\n", "\n", - "Since we don't have any mobility data for the liquid phase, we can estimate them using some available models in the literature. Two models are available in kawin:\n", + "Since we don't have any mobility data for the liquid phase, we can estimate them using some available models in the literature. Two models are implemented in kawin:\n", "\n", "Y. Liu et al, \"A predictive equation for solute diffusivity in liquid metals\" Scripta Materialia 55 (2006), 367. doi:10.1016/j.scriptamat.2006.04.019\n", "- $ Q = 0.17 R T_m (16+K_0) $ $ J/mol $\n", @@ -214,7 +214,7 @@ " - $ R_0 = 0.644*10^{-10} $\n", "- $ D_{AB} = \\frac{k T}{4 \\pi \\mu_B r_A} $\n", "\n", - "Both models predict mobility to be within an order of magnitude, so here, we'll add the Liu model to the database due it its simplicity" + "Both models predict mobility to be within an order of magnitude, so here, we'll add the model from Liu et al to the database due it its simplicity" ] }, { From b67c36022c66133c1592c983026bb7b2ed0c57b5 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Mon, 10 Mar 2025 12:15:40 -0700 Subject: [PATCH 19/53] test development versions of pycalphad and espei --- .github/workflows/pytest.yaml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index ba85e54..4aa96fb 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -23,14 +23,13 @@ jobs: with: python-version: ${{ matrix.python-version }} - run: python -m pip install -U pip setuptools - - name: Install pycalphad development version + - name: Install pycalphad and espei development version if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop + run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV - # temporary - this will install the mobility fitting compatibility espei branch - - run: python -m pip install git+https://github.com/nury12n/ESPEI.git@mobility_fitting_compatibility - run: python -m pip install build - run: python -m build --wheel - run: python -m pip install dist/*.whl From 904e697bc64ab8024e627b7766bf4079f984704c Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Mon, 10 Mar 2025 12:17:34 -0700 Subject: [PATCH 20/53] hopefully fix test yaml to test development version of espei --- .github/workflows/pytest.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 4aa96fb..90ffb0e 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -23,9 +23,11 @@ jobs: with: python-version: ${{ matrix.python-version }} - run: python -m pip install -U pip setuptools - - name: Install pycalphad and espei development version + - name: Install pycalphad development version if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop + - name: Install espei development version + if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master - name: Save pycalphad version run: | From af63b2302b4b39fc96f267d57e612706e1eab162 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Mon, 10 Mar 2025 13:47:57 -0700 Subject: [PATCH 21/53] espei compatibility test, deprecate python 3.9 testing --- .github/workflows/pytest.yaml | 7 +- .../equilibrium_mobility_error.py | 13 +- .../non_equilibrium_mobility_error.py | 14 +- kawin/tests/datasets.py | 103 ++++++++++- kawin/tests/test_mobility_mcmc.py | 164 ++++++------------ 5 files changed, 170 insertions(+), 131 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 90ffb0e..fbf04a6 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -11,7 +11,7 @@ jobs: fail-fast: false max-parallel: 100 matrix: - python-version: ["3.9", "3.10", "3.11", "3.12"] + python-version: ["3.10", "3.11", "3.12"] pycalphad_develop_version: [true, false] steps: @@ -32,6 +32,9 @@ jobs: - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV + - name: Save espei version + run: | + echo "ESPEI_VERSION=$(python -c "from importlib.metadata import version;print(version('espei'))")" >> $GITHUB_ENV - run: python -m pip install build - run: python -m build --wheel - run: python -m pip install dist/*.whl @@ -44,7 +47,7 @@ jobs: - run: coverage xml - uses: actions/upload-artifact@v4 with: - name: coverage-${{ matrix.os }}-${{ matrix.python-version }}-pycalphad-${{ env.PYCALPHAD_VERSION }} + name: coverage-${{ matrix.os }}-${{ matrix.python-version }}-pycalphad-${{ env.PYCALPHAD_VERSION }}-espei-${{ env.ESPEI_VERSION }} path: coverage.xml Upload-Coverage: diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index da17019..714bdca 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -208,19 +208,13 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray return diffs, wts def calculate_mob_probability(mob_data : Sequence[EquilibriumMobilityData], parameters : np.ndarray) -> float: - differences = [] - weights = [] + prob_error = 0.0 for data in mob_data: diffs, wts = calc_mob_differences(data, parameters) if np.any(np.isinf(diffs) | np.isnan(diffs)): return -np.inf - differences.append(diffs) - weights.append(wts) - - differences = np.concatenate(differences, axis=0) - weights = np.concatenate(weights, axis=0) - probs = norm(loc=0.0, scale=weights).logpdf(differences) - return np.sum(probs) + prob_error += norm(loc=0.0, scale=wts).logpdf(diffs) + return prob_error class EquilibriumMobilityResidual(ResidualFunction): def __init__( @@ -230,7 +224,6 @@ def __init__( phase_models: Union[PhaseModelSpecification, None], symbols_to_fit: Optional[List[SymbolName]] = None, weight: Optional[Dict[str, float]] = None, - additional_mcmc_args: Optional[Dict] = {}, ): super().__init__(database, datasets, phase_models, symbols_to_fit) if weight is not None: diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py index cde3856..da6255d 100644 --- a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -116,6 +116,7 @@ def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], dat def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndarray): diffs, wts = [], [] + print(data.parameter_keys, parameters) paramDict = {data.parameter_keys[i] : parameters[i] for i in range(len(data.parameter_keys))} #Update phase record parameters @@ -161,19 +162,13 @@ def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndar return diffs, wts def calculate_mob_probability(mob_data : Sequence[NonEquilibriumMobilityData], parameters : np.ndarray) -> float: - differences = [] - weights = [] + prob_error = 0.0 for data in mob_data: diffs, wts = calc_mob_differences(data, parameters) if np.any(np.isinf(diffs) | np.isnan(diffs)): return -np.inf - differences.append(diffs) - weights.append(wts) - - differences = np.concatenate(differences, axis=0) - weights = np.concatenate(weights, axis=0) - probs = norm(loc=0.0, scale=weights).logpdf(differences) - return np.sum(probs) + prob_error += norm(loc=0.0, scale=wts).logpdf(diffs) + return prob_error class NonEquilibriumMobilityResidual(ResidualFunction): def __init__( @@ -183,7 +178,6 @@ def __init__( phase_models: Union[PhaseModelSpecification, None], symbols_to_fit: Optional[List[SymbolName]] = None, weight: Optional[Dict[str, float]] = None, - additional_mcmc_args: Optional[Dict] = {}, ): super().__init__(database, datasets, phase_models, symbols_to_fit) if weight is not None: diff --git a/kawin/tests/datasets.py b/kawin/tests/datasets.py index 2a9b4de..f5c3e77 100644 --- a/kawin/tests/datasets.py +++ b/kawin/tests/datasets.py @@ -145,4 +145,105 @@ "values": [[[0.115e-14], [0.501e-14], [0.858e-14], [3.55e-14], [5.74e-14], [11e-14], [17.5e-14], [30.2e-14]]], "reference": "Ghosh2001" } -] \ No newline at end of file +] + +AlSi_tracer_D0_Al = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [[["AL", "SI"], "VA"]], + "sublattice_occupancies": [[[0.9, 0.1], 1]] + }, + "output": "TRACER_D0_AL", + "values": [[[1.75e-5]]] +} + +AlSi_tracer_Q_Si = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [[["AL", "SI"], "VA"]], + "sublattice_occupancies": [[[0.9, 0.1], 1]] + }, + "output": "TRACER_Q_SI", + "values": [[[160000]]] +} + +AlSi_tracer_diff_Mg = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15 + }, + "solver": { + "mode": "manual", + "sublattice_site_ratios": [1, 3], + "sublattice_configurations": [[["AL", "SI"], "VA"]], + "sublattice_occupancies": [[[0.9, 0.1], 1]] + }, + "output": "TRACER_DIFF_MG", + "values": [[[5.2e-26]]] +} + +AlSi_eq_tracer_D0_Al = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_SI": 0.1 + }, + "output": "TRACER_D0_AL", + "values": [[[1.75e-5]]] +} + +AlSi_eq_tracer_Q_Si = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_SI": 0.1 + }, + "output": "TRACER_Q_SI", + "values": [[[160000]]] +} + +AlSi_eq_diff_Mg = { + "components": ["AL", "SI", "VA"], + "phases": ["FCC_A1"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_SI": 0.1 + }, + "output": "TRACER_DIFF_MG", + "values": [[[5.2e-26]]] +} + +AlSi_eq_interdiff = { + "components": ["AL", "MG", "VA"], + "phases": ["FCC_A1"], + "ref_el": ["AL"], + "dependent_el": ["MG", "MG"], + "conditions": { + "P": 101325, + "T": 298.15, + "X_MG": 0.1 + }, + "output": "INTER_DIFF", + "values": [[[4.6e-25]]] +} \ No newline at end of file diff --git a/kawin/tests/test_mobility_mcmc.py b/kawin/tests/test_mobility_mcmc.py index df8b84d..8d5d3fb 100644 --- a/kawin/tests/test_mobility_mcmc.py +++ b/kawin/tests/test_mobility_mcmc.py @@ -3,28 +3,13 @@ from pycalphad import Database from espei.utils import PickleableTinyDB, MemoryStorage from espei.phase_models import PhaseModelSpecification +from espei.error_functions.context import setup_context from kawin.mobility_fitting.error_functions import NonEquilibriumMobilityResidual, EquilibriumMobilityResidual from kawin.tests.databases import * +from kawin.tests.datasets import * def test_non_eq_tracer_D0(): - dataset = { - "components": ["AL", "SI", "VA"], - "phases": ["FCC_A1"], - "conditions": { - "P": 101325, - "T": 298.15 - }, - "solver": { - "mode": "manual", - "sublattice_site_ratios": [1, 3], - "sublattice_configurations": [[["AL", "SI"], "VA"]], - "sublattice_occupancies": [[[0.9, 0.1], 1]] - }, - "output": "TRACER_D0_AL", - "values": [[[1.75e-5]]] - } - phase_models = { "components": ["AL", "SI", "VA"], "phases": { @@ -37,7 +22,7 @@ def test_non_eq_tracer_D0(): phase_models = PhaseModelSpecification(**phase_models) datasets_db = PickleableTinyDB(storage=MemoryStorage) - datasets_db.insert(dataset) + datasets_db.insert(AlSi_tracer_D0_Al) dbf = Database(ALMGSI_DB) residual_func = NonEquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) @@ -48,23 +33,6 @@ def test_non_eq_tracer_D0(): assert np.isclose(likelihood, 0.88341, rtol=1e-3) def test_non_eq_tracer_Q(): - dataset = { - "components": ["AL", "SI", "VA"], - "phases": ["FCC_A1"], - "conditions": { - "P": 101325, - "T": 298.15 - }, - "solver": { - "mode": "manual", - "sublattice_site_ratios": [1, 3], - "sublattice_configurations": [[["AL", "SI"], "VA"]], - "sublattice_occupancies": [[[0.9, 0.1], 1]] - }, - "output": "TRACER_Q_SI", - "values": [[[160000]]] - } - phase_models = { "components": ["AL", "SI", "VA"], "phases": { @@ -77,7 +45,7 @@ def test_non_eq_tracer_Q(): phase_models = PhaseModelSpecification(**phase_models) datasets_db = PickleableTinyDB(storage=MemoryStorage) - datasets_db.insert(dataset) + datasets_db.insert(AlSi_tracer_Q_Si) dbf = Database(ALMGSI_DB) residual_func = NonEquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) @@ -88,23 +56,6 @@ def test_non_eq_tracer_Q(): assert np.isclose(likelihood, -10.41807, rtol=1e-3) def test_non_eq_tracer_diff(): - dataset = { - "components": ["AL", "SI", "VA"], - "phases": ["FCC_A1"], - "conditions": { - "P": 101325, - "T": 298.15 - }, - "solver": { - "mode": "manual", - "sublattice_site_ratios": [1, 3], - "sublattice_configurations": [[["AL", "SI"], "VA"]], - "sublattice_occupancies": [[[0.9, 0.1], 1]] - }, - "output": "TRACER_DIFF_MG", - "values": [[[5.2e-26]]] - } - phase_models = { "components": ["AL", "SI", "VA"], "phases": { @@ -117,7 +68,7 @@ def test_non_eq_tracer_diff(): phase_models = PhaseModelSpecification(**phase_models) datasets_db = PickleableTinyDB(storage=MemoryStorage) - datasets_db.insert(dataset) + datasets_db.insert(AlSi_tracer_diff_Mg) dbf = Database(ALMGSI_DB) residual_func = NonEquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) @@ -128,18 +79,6 @@ def test_non_eq_tracer_diff(): assert np.isclose(likelihood, 1.3826926, rtol=1e-3) def test_eq_tracer_D0(): - dataset = { - "components": ["AL", "SI", "VA"], - "phases": ["FCC_A1"], - "conditions": { - "P": 101325, - "T": 298.15, - "X_SI": 0.1 - }, - "output": "TRACER_D0_AL", - "values": [[[1.75e-5]]] - } - phase_models = { "components": ["AL", "SI", "VA"], "phases": { @@ -152,7 +91,7 @@ def test_eq_tracer_D0(): phase_models = PhaseModelSpecification(**phase_models) datasets_db = PickleableTinyDB(storage=MemoryStorage) - datasets_db.insert(dataset) + datasets_db.insert(AlSi_eq_tracer_D0_Al) dbf = Database(ALMGSI_DB) residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) @@ -163,18 +102,6 @@ def test_eq_tracer_D0(): assert np.isclose(likelihood, 0.88341, rtol=1e-3) def test_eq_tracer_Q(): - dataset = { - "components": ["AL", "SI", "VA"], - "phases": ["FCC_A1"], - "conditions": { - "P": 101325, - "T": 298.15, - "X_SI": 0.1 - }, - "output": "TRACER_Q_SI", - "values": [[[160000]]] - } - phase_models = { "components": ["AL", "SI", "VA"], "phases": { @@ -187,7 +114,7 @@ def test_eq_tracer_Q(): phase_models = PhaseModelSpecification(**phase_models) datasets_db = PickleableTinyDB(storage=MemoryStorage) - datasets_db.insert(dataset) + datasets_db.insert(AlSi_eq_tracer_Q_Si) dbf = Database(ALMGSI_DB) residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) @@ -198,18 +125,6 @@ def test_eq_tracer_Q(): assert np.isclose(likelihood, -10.41807, rtol=1e-3) def test_eq_tracer_diff(): - dataset = { - "components": ["AL", "SI", "VA"], - "phases": ["FCC_A1"], - "conditions": { - "P": 101325, - "T": 298.15, - "X_SI": 0.1 - }, - "output": "TRACER_DIFF_MG", - "values": [[[5.2e-26]]] - } - phase_models = { "components": ["AL", "SI", "VA"], "phases": { @@ -222,7 +137,7 @@ def test_eq_tracer_diff(): phase_models = PhaseModelSpecification(**phase_models) datasets_db = PickleableTinyDB(storage=MemoryStorage) - datasets_db.insert(dataset) + datasets_db.insert(AlSi_eq_diff_Mg) dbf = Database(ALMGSI_DB) residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) @@ -233,20 +148,6 @@ def test_eq_tracer_diff(): assert np.isclose(likelihood, 1.3826926, rtol=1e-3) def test_eq_tracer_interdiff(): - dataset = { - "components": ["AL", "MG", "VA"], - "phases": ["FCC_A1"], - "ref_el": ["AL"], - "dependent_el": ["MG", "MG"], - "conditions": { - "P": 101325, - "T": 298.15, - "X_MG": 0.1 - }, - "output": "INTER_DIFF", - "values": [[[4.6e-25]]] - } - phase_models = { "components": ["AL", "MG", "VA"], "phases": { @@ -259,7 +160,7 @@ def test_eq_tracer_interdiff(): phase_models = PhaseModelSpecification(**phase_models) datasets_db = PickleableTinyDB(storage=MemoryStorage) - datasets_db.insert(dataset) + datasets_db.insert(AlSi_eq_interdiff) dbf = Database(ALMGSI_DB) residual_func = EquilibriumMobilityResidual(dbf, datasets_db, phase_models=phase_models, symbols_to_fit=[]) @@ -269,3 +170,50 @@ def test_eq_tracer_interdiff(): likelihood = residual_func.get_likelihood(np.asarray([])) assert np.isclose(likelihood, 1.382807, rtol=1e-3) +def test_espei_compatibility(): + ''' + Tests that mobility residuals are recognized by espei and datasets are properly loaded in + + Main things to test: + - mobility residuals can compute without error even if no datasets exist + - mobility data is picked up by mobility residuals and not by built-in espei residuals + ''' + dbf = Database(ALMGSI_DB) + # add symbol to create context + dbf.symbols["VV0000"] = 0 + + phase_models = { + "components": ["AL", "MG", "SI", "VA"], + "phases": { + "FCC_A1": { + "sublattice_model": [["AL", "MG", "SI"], ["VA"]], + "sublattice_site_ratios": [1, 3] + } + } + } + + datasets_db = PickleableTinyDB(storage=MemoryStorage) + + # First test that everything can run without datasets + ctx = setup_context(dbf, datasets_db, None, phase_models=phase_models, make_callables=False) + for residual_obj in ctx['residual_objs']: + likelihood = residual_obj.get_likelihood(np.asarray([0], dtype=np.float64)) + + datasets_db.insert(AlSi_tracer_D0_Al) + datasets_db.insert(AlSi_tracer_Q_Si) + datasets_db.insert(AlSi_tracer_diff_Mg) + datasets_db.insert(AlSi_eq_tracer_D0_Al) + datasets_db.insert(AlSi_eq_tracer_Q_Si) + datasets_db.insert(AlSi_eq_diff_Mg) + datasets_db.insert(AlSi_eq_interdiff) + + # Test that everything can run with datasets and that NonEquilibriumMobilityResidual and EquilibriumMobilityResidual give non-zero values + # and that every other residual gives 0 for likelihood + ctx = setup_context(dbf, datasets_db, None, phase_models=phase_models, make_callables=False) + for residual_obj in ctx['residual_objs']: + likelihood = residual_obj.get_likelihood(np.asarray([0], dtype=np.float64)) + if isinstance(residual_obj, NonEquilibriumMobilityResidual) or isinstance(residual_obj, EquilibriumMobilityResidual): + assert likelihood != 0 + else: + assert likelihood == 0 + From 14429bc2057ee3b9bf43a71ea59535ca40ba0213 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 2 Apr 2025 10:21:11 -0700 Subject: [PATCH 22/53] raise error for failed equilibrium in _computeSingleMobility --- kawin/diffusion/DiffusionParameters.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/kawin/diffusion/DiffusionParameters.py b/kawin/diffusion/DiffusionParameters.py index 64cd78d..e054196 100644 --- a/kawin/diffusion/DiffusionParameters.py +++ b/kawin/diffusion/DiffusionParameters.py @@ -515,6 +515,8 @@ def _computeSingleMobility(therm: GeneralThermodynamics, x: np.array, T: np.arra wks = therm.getEq(x, T, 0, therm.phases) chemical_potentials = np.squeeze(wks.eq.MU)[unsortIndices] comp_sets = wks.get_composition_sets() + if len(comp_sets) == 0 or any(np.isnan(chemical_potentials)): + raise ValueError("Equilibrium did not converge") except Exception as e: print(f'Error at {x}, {T}') raise e From 27081d6e2ef820f415c3751883d4cce8e3e98f47 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 16 Apr 2025 13:51:59 -0700 Subject: [PATCH 23/53] removed unneeded print statements --- .../error_functions/non_equilibrium_mobility_error.py | 1 - kawin/mobility_fitting/generate.py | 1 - kawin/precipitation/PrecipitationParameters.py | 1 - 3 files changed, 3 deletions(-) diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py index da6255d..8e30630 100644 --- a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -116,7 +116,6 @@ def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], dat def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndarray): diffs, wts = [], [] - print(data.parameter_keys, parameters) paramDict = {data.parameter_keys[i] : parameters[i] for i in range(len(data.parameter_keys))} #Update phase record parameters diff --git a/kawin/mobility_fitting/generate.py b/kawin/mobility_fitting/generate.py index d4a0741..0abaf01 100644 --- a/kawin/mobility_fitting/generate.py +++ b/kawin/mobility_fitting/generate.py @@ -80,7 +80,6 @@ def setup_mobility_fitting_description(diffusing_species, fit_to_tracer = False) to those values instead ''' steps = [] - print(diffusing_species) for e in diffusing_species: if fit_to_tracer: Dstar = type(f'Tracer_{e}', (StepTracerDiffusivity,), {'parameter_name': f'MQ_{e}', 'data_types_read': f'TRACER_DIFF_{e}'}) diff --git a/kawin/precipitation/PrecipitationParameters.py b/kawin/precipitation/PrecipitationParameters.py index f457888..03dc66f 100644 --- a/kawin/precipitation/PrecipitationParameters.py +++ b/kawin/precipitation/PrecipitationParameters.py @@ -77,7 +77,6 @@ def __init__(self, *args): def setTemperatureParameters(self, *args): if len(args) == 2: - print(args) self.setTemperatureArray(*args) elif len(args) == 1: if callable(args[0]): From 5592db2921abe3edc1cbc4e28e88a9c4b510f61f Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 16 Apr 2025 13:53:49 -0700 Subject: [PATCH 24/53] python 3.13 testing --- .github/workflows/pytest.yaml | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index fbf04a6..ad04aaf 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -11,7 +11,7 @@ jobs: fail-fast: false max-parallel: 100 matrix: - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.10", "3.11", "3.12", "3.13"] pycalphad_develop_version: [true, false] steps: diff --git a/setup.py b/setup.py index 950bfd9..d8ddfe2 100644 --- a/setup.py +++ b/setup.py @@ -42,10 +42,10 @@ def read(fname): # Supported Python versions 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', + 'Programming Language :: Python :: 3.13', ], ) From 479415cb24c9238ab6817a29074feb28a8bd8f57 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 08:55:00 -0700 Subject: [PATCH 25/53] add summation to calculate_..._probability functions and check examples --- .../01_parameter_generation.ipynb | 23 +++-- .../02_mcmc_optimization.ipynb | 46 ++++----- .../databases/CuNi_manual_fit.tdb | 4 +- .../mobility_fitting/databases/CuNi_mcmc.tdb | 46 ++++----- .../databases/CuNi_mob_gen.tdb | 4 +- .../equilibrium_mobility_error.py | 14 +-- .../non_equilibrium_mobility_error.py | 16 ++-- kawin/thermo/Mobility.py | 96 +++++++++---------- 8 files changed, 125 insertions(+), 124 deletions(-) diff --git a/examples/mobility_fitting/01_parameter_generation.ipynb b/examples/mobility_fitting/01_parameter_generation.ipynb index f34b898..2ccb90b 100644 --- a/examples/mobility_fitting/01_parameter_generation.ipynb +++ b/examples/mobility_fitting/01_parameter_generation.ipynb @@ -24,7 +24,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -44,7 +44,6 @@ "conds = {v.T: (1200, 1800, 20), v.P: 101325, v.X('NI'): (0, 1, 0.01)}\n", "\n", "strategy = BinaryStrategy(dbf, comps, phases, conds)\n", - "strategy.initialize()\n", "strategy.do_map()\n", "\n", "plot_binary(strategy)\n", @@ -101,7 +100,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -246,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -259,7 +258,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHACAYAAAC21/y5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAChOElEQVR4nOzdd1RU1xbA4d/Qm4AodhBULIgo9t57T4wxlliiJs+SxKgpJjHV2DXGWKNR003sPfbeGxYUGyCoCCjS+8y8P66CRlEYLjDC/tZiPe9l5pwzmifbc/bdW6PX6/UIIYQQQognmOT3AoQQQgghjJEESUIIIYQQzyBBkhBCCCHEM0iQJIQQQgjxDBIkCSGEEEI8gwRJQgghhBDPIEGSEEIIIcQzSJAkhBBCCPEMEiQJIYQQQjyDBElCCCGEEM8gQVImDhw4QLdu3ShTpgwajYb169fn+3x6vZ4vvviC0qVLY21tTdu2bbl27VqurksIIYQorCRIykR8fDw1a9Zk/vz5RjPf9OnTmTt3LosWLeL48ePY2trSoUMHkpKS8mSNQgghRGGikQa3L6bRaFi3bh09e/ZMv5ecnMxnn33GX3/9RVRUFF5eXkybNo2WLVvmynx6vZ4yZcowbtw4xo8fD0B0dDQlS5ZkxYoVvPHGGzmeVwghhBAZZCfJQKNHj+bo0aOsXLmS8+fP07t3bzp27Jhrx1+BgYHcvXuXtm3bpt9zcHCgQYMGHD16NFfmFEIIIQozCZIMEBwczPLly1m1ahXNmjWjYsWKjB8/nqZNm7J8+fJcmfPu3bsAlCxZ8on7JUuWTP+eEEIIIdQjQZIBLly4gFarpXLlytjZ2aV/7d+/nxs3bgDg7++PRqN57tcnn3ySz59ECCGEEJkxy+8FvIzi4uIwNTXl9OnTmJqaPvE9Ozs7ACpUqMDly5efO06xYsWyPGepUqUACAsLo3Tp0un3w8LCqFWrVpbHEUIIIUTWSJBkAB8fH7RaLeHh4TRr1uyZr7GwsKBq1aqqzenu7k6pUqXYvXt3elAUExPD8ePHGTFihGrzCCGEEEIhQVIm4uLiuH79evp1YGAgvr6+ODk5UblyZfr378/AgQOZNWsWPj4+REREsHv3bry9venSpYuq87m6uqLRaBgzZgyTJk3Cw8MDd3d3Jk6cSJkyZZ54Ck4IIYQQ6pASAJnYt28frVq1eur+oEGDWLFiBampqUyaNIlff/2V27dvU7x4cRo2bMjXX39NjRo1VJ8PlDIAX375JT/99BNRUVE0bdqUBQsWULly5WzPJ4QQQojnkyBJCCGEEOIZ5Ok2IYQQQohnkCBJCCGEEOIZJHH7P3Q6HXfu3KFIkSJoNJr8Xo4QQgghskCv1xMbG0uZMmUwMVFnD0iCpP+4c+cOLi4u+b0MIYQQQhggJCSEcuXKqTKWBEn/UaRIEUD5Tba3t8/n1QghhBAiK2JiYnBxcUn/Oa4GCZL+49ERm729vQRJQgghxEtGzVQZSdwWQgghhHgGCZKEEEIIIZ5BgiQhhBBCiGeQnCQhhBDCQFqtltTU1PxeRqFgbm6Oqalpns4pQZIQQgiRTXq9nrt37xIVFZXfSylUHB0dKVWqVJ7VMZQgSQghhMimRwFSiRIlsLGxkeLDuUyv15OQkEB4eDgApUuXzpN5JUgSQgghskGr1aYHSMWKFcvv5RQa1tbWAISHh1OiRIk8OXqTxG0hhBAiGx7lINnY2OTzSgqfR7/neZUHJkGSEEIIYQA5Yst7ef17LkGSEEIIIcQzSJAkhBBCCEDZqVm/fn1+L8NoSJAkhBBCFBKDBw+mZ8+emX4/NDSUTp065Xies2fP0rt3b0qWLImVlRUeHh4MHz6cq1evArBv3z40Gs0zSyi4ubkxZ86cHK9BDRIkCSGEEAKAUqVKYWlpmaMxNm/eTMOGDUlOTuaPP/7g8uXL/P777zg4ODBx4kSVVpo3JEjKzIGZkJaS36sQQggh8szjx23P2u3x9fVFo9EQFBT0zPcnJCQwZMgQOnfuzMaNG2nbti3u7u40aNCAmTNnsnjx4tz/ECqSOkmZOTwHgndBz/lQxie/VyOEEMKI6fV6ElO1+TK3tbmp0Txpt337du7du8dHH330zO87Ojrm7YJySIKkzFgVhXA/WNIGmrwPLT4Gc6v8XpUQQggjlJiqxfOL7fky96VvOmBjYRw/zq9duwZA1apV83kl6pDjtswUKQ1VuoBeC4dmw+LmEHIyv1clhBBCGC29Xp/fS1CVcYSexijiEpgkQKcZcGAG3LsCv3aHD/zAxim/VyeEEMKIWJubcumbDvk2d24wMVH2UR4PfF5U6bpy5coA+Pv706hRo0xfZ29vD0B0dPRTR3BRUVE4ODgYsmTVSZCUGcfyEHUT9n4Hr/4EfuvBubIESEIIIZ6i0WiM5shLLc7OzoBSFqBo0aKAkrj9PO3bt6d48eJMnz6ddevWPfX9qKgoHB0d8fDwwMTEhNOnT1O+fPn07wcEBBAdHZ0ebOW3gvUnqqaBG2HLcLh1Ev4eAD0XglevjO+HnITzK6HtV2BZJN+WKYQQQmRHdHT0U8FOsWLFcHFxeeJepUqVcHFx4auvvuK7777j6tWrzJo167lj29rasnTpUnr37k337t157733qFSpEvfu3eOff/4hODiYlStXUqRIEYYNG8a4ceMwMzOjRo0ahISE8PHHH9OwYUMaN26s9sc2iOQkZca2GAzaBNW6gTYF1gyFQ9+DXg86LWwcDSeXwoJGcH1Xfq9WCCGEyJJ9+/bh4+PzxNfXX3/91OvMzc3566+/8Pf3x9vbm2nTpjFp0qQXjt+jRw+OHDmCubk5/fr1o2rVqvTt25fo6Ogn3v/DDz8waNAgPv74Y6pXr87gwYPx9vZm06ZNRvO0nkZf0LKscigmJgYHBweio6OVM1OdFnZMhGPzlRfUHgRdZsHNI7DxXeVIDqBmP+jwnRzHCSFEAZeUlERgYCDu7u5YWclTz3npeb/3T/38VoHsJL2IiSl0nAydpoPGBM78An/2UWonjTwKDUYAGjj3JyxoCJc35feKhRBCCKECCZKyqsE70OcPMLeBG7theSdIjIJOU+Gt7VC8MsSFKflLN/bm92qFEEIIkUMSJGVH1c4weAvYloCwi7C0DYSeB9cG8M5BaDYOKrWFCi3ze6VCCCGEyCEJkrKrbG0YtguKV4HYUFjWEa7uUKpxt/kC+q2CRwlnSTGwbgREheTvmoUQQgiRbRIkGaJoeRi6A9ybQ2o8/NUHTixRvmfy2G/p7m8ycpVOLAGdLn/WK4QQQohskyDJUNaO0H8N1OoPeh1sHQ/bP1OehnukwTvg2ghS4pTvr+gMEVfzbclCCCGEyDoJknLCzAJ6zIfWnyvXR+fBPwMhJUG5Lu4Bg7dC55lgYQfBR2FREzgwE7TPL+0uhBBCiPwlQVJOaTTQ/EPo9TOYWoD/ZmXHKDZM+b6JCdQfDiOPQaV2SmHKPd8q7U6EEEIIYbQkSMrE36eC0emyUWezxmtKKxNrJ7hzVnnyLexSxvcdXaD/KnjlJyjmAY1Gq79oIYQQQqhGgqRMfLvpMm8sOUZARFzW31S+kfLkW7FKEB0CP7d/smWJRgM1+8Co42BbPOP+vxMgYL96ixdCCCEMoNFoWL9+fX4vw2hIkJQJCzMTTgRG0vGHg8zfe51UbRafTCtWEYbuhPJNISUW/ngdTv785GtMTDN+7b8Fji2AX7vDhtGQ+EC9DyGEEEI8ZvDgwfTs2TPT74eGhtKpU6cczeHm5oZGo+HYsWNP3B8zZgwtW7ZMv/7qq6+oVatWjubKbRIkZcLUBLzK2pOSpmPG9it0n3eY87eisvZmGyd4cx3U7At6LWwZ+/STb4+4NYO6Q5Vfn/0N5jeASxuURrpCCCFEHipVqhSWlpY5HsfKyoqPP/5YhRXlLwmSMpGYouPSnRh61S6Lo405l0NjeG3hUcJjkrI2gJkF9FwIrR578u3vNyEl/snXWdlD19kwZJuSqxQXpjwh9/cAiLmj7ocSQgghnuPx47Z9+/ah0WiIiopK/76vry8ajYagoKDnjvP2229z7Ngxtm7dmnuLzQMSJGWie80y6PSw5sxtOnuVppt3aQY3caOEfTY6Pms00OJDeG0ZmFrClS1Khe5nBT/lG8P/DkHzj8DETHlK7o/esqMkhBAvA71e+UdwfnwZ4c8Jd3d3/ve//zFhwgR0L3EhZbP8XoCx+u4VL6qdiWDG9iv8eSKYttVK8G6rSunfvxoWy5IDAXzauRpFbS2eP5hXL3Bwgb/6wt3zsKQ19PsbStd88nXmVtD6M6jeEza+B60mZLQ4EUIIYbxSE2BymfyZ+9M7YGGbP3M/x+eff87y5cv5448/ePPNN/N7OQaRnaRMaDQaRrWqxLx+PliambDrcjiv/3SMO1GJ6PV6Pl17gVWnb9F29n42+N5G/6JI3qU+DN8NzlUzer75Z7INWbK68pRcpbYZ907/AvumQVqKeh9SCCGEyCXOzs6MHz+eL774gpSUl/Nnl+wkvUBX7zKUdbRm+K+nuBwaQ8/5h1k6qC4TOldjwtrzXA2L4/2Vvqw9c5tJPb1wcbLJfLCibkrPt1WD4cYeWNkP2n0Djd99esfo8ev4e7Djc0iOAb910H2uEnQJIYQwDuY2yo5Ofs2dC0we9iJ9fBMgNTV73SLGjh3LggULWLBggapryyuyk5QFPq5FWT+qCVVKFiE8NpnXFysJ3Jvfbca4dpWxMDVh/9UI2n9/gKUHA9A+rwillQP0W/XwiTY97JwIm957fpsSm2LQ9XuwKQ4Rl5X6S1vGQ1KM6p9VCCGEATQa5cgrP75yKS3D2dkZUMoCPOLr65utMezs7Jg4cSLfffcdsbGxai4vT0iQlEXlitqwekQjWlZxJilVx4g/zrDkYACjW1di25hm1Hd3IjFVy6Qtl1l39vbzBzM1gy6zoOM00JjAmV/h91czr5Gk0SgVvUefVBrqooeTS5RyAf5bVP+sQgghCq7o6Gh8fX2f+AoJCXnqdZUqVcLFxYWvvvqKa9eusWXLFmbNmpXt+d5++20cHBz4888/1Vh+nnppgqSpU6ei0WgYM2ZMpq9ZsWIFGo3miS8rq2w8jfYCRazMWTqwLoMbuwEwY/sVxq06R7mi1qwc3pApr9agSaVi9KyVheQ9jQYa/g/6rlSa3wYegKVt4f6NzN9j4wQ9F8DADVDUHWLvKKUCIgPU+YBCCCEKvH379uHj4/PE19dff/3U68zNzfnrr7/w9/fH29ubadOmMWnSpGzPZ25uzrfffktSUhZL6BgRjf6FGcf57+TJk7z++uvY29vTqlUr5syZ88zXrVixgvfff58rV66k39NoNJQsWTLLc8XExODg4EB0dDT29vaZvu7Xo0F8vekSWp2eem5FWfxmXZxsLdDr9Wgebn0mpWp557fTDGvmTjMP58wnvXsR/npDaWVi5Qh9fgf3Zs9faEoCHJiuPPrZ7un/uIUQQuSOpKQkAgMDcXd3V/Uf4uLFnvd7n9Wf39lh9DtJcXFx9O/fnyVLllC0aNEXvl6j0VCqVKn0r+wESNkxsJEbywfXo4ilGSeDHtBj/iGuhcWmB0gAPx8KZP/VCN78+QRj//blflzyswcr5QXDdkPZupAUBb/1VJ5mex4LG2j71ZMBUvhlWNEVwv1z+vGEEEKIQs/og6RRo0bRpUsX2rZt++IXowRV5cuXx8XFhR49euDn5/fc1ycnJxMTE/PEV1Y1r+zM2pGNcXWyISQykVcXHGH/1Yj07w9q7Mbgxm5oNLD27G3azt7P6tO3nl0uoEhJGLxZqamkS1OSuTNrZZKZ7Z9C0EFY1BT2TobUl29rUwghhDAWRh0krVy5kjNnzjBlypQsvb5KlSosW7aMDRs28Pvvv6PT6WjcuDG3bt3K9D1TpkzBwcEh/cvFxSVba/QoWYT1o5pQ382J2OQ0hiw/wYrDgej1euwszfiqe3XWjmhM1VJFeJCQyvhV5+i/9DhB9+KfHszcGnr9DC0nKNdH5yllApKz+ERAt7lQuSPoUmH/NFjUBIIOZevzCCGEEEJhtDlJISEh1K1bl507d+Lt7Q1Ay5YtqVWrVqY5Sf+VmppKtWrV6Nu3L99+++0zX5OcnExycsYxWExMDC4uLtk+00xO0/LZuousPq0EZAMauvJlt+qYmypxaKpWx9KDgczZdZXkNB3tPEuyZGDdzAe8uAbWj4S0JChRHfr+BUXLv3gher3SIHfbR0ofOACfAdDuWyXxWwghRI5ITlL+kZykh06fPk14eDi1a9fGzMwMMzMz9u/fz9y5czEzM0OrffExlLm5OT4+Ply/fj3T11haWmJvb//ElyEszUyZ8Zo3EzpVRaOB348FM3j5CaITlPpH5qYmjGhZkR0fNKdttZJ80dUz/b26Z9VV8uoFg7eAXUkI91NamQQfe/FCNBqlrcmoE1BniHLv7O9w/m+DPpcQQghRWBltkNSmTRsuXLjwRB2HunXr0r9/f3x9fTE1NX3hGFqtlgsXLlC6dOk8WLGSNP5Oi4r89GZdbCxMOXz9Pq8sOExARFz6a8oXs2XpoLpPVOb+dN0FPlt3gejE/xSULFcXhu+BUjUg4R780g18/8raYqwdodsceGsHeL0G9YZnfC87eU5CCCFEIWW0QVKRIkXw8vJ64svW1pZixYrh5eUFwMCBA5kwYUL6e7755ht27NhBQEAAZ86cYcCAAdy8eZNhw4bl6drbeZZk9f8aU8bBioB78fScf5jD1+8987UBEXH8fSqEP44H03b2fjafv/NkYrdDOXhrO1TtCtoUWP8/2PUVZLWrsmsDeO1npYAlKMncP7WAg7OfX+VbCCGEKOSMNkjKiuDg4CfKpT948IDhw4dTrVo1OnfuTExMDEeOHMHT0/M5o+QOzzL2rB/dBB9XR2KS0hi47AS/HQ166nUVnO34a3hDKjjbEhGbzOg/zzJkxUlCIhMyXmRhC6//Bs3GK9eHvleKSCbHPTXeC11YBXcvwO6vYXFzCD5u2AcUQgghCjijTdzOL2onfiWlapmw9kJ6q5I3G5bni26e6QndjySnaVmw9wYL990gRavDytyEMW0rM7Sp+5OvPf8PbBgN2mQo6aUkdDu6Zn1Ber2Sn7T9U0i4r9yrMwTafgnWL65DJYQQhZ0kbucfSdwuYKzMTZn9ek0+6lgFjQZ+O3bziYTuRyzNTPmgXWW2jWlGwwpOJKXqWHIggPjktCcH9H5dSei2LQFhF+GnVllL6H5Eo4Gab8DoU8pTbwCnl8O8+nBhtRJECSGEEEKCpLyg0WgY2bISiwfUSU/o7rngMDcinj4uq/jw+G1m75pM6umFo40FAHq9nrhHAZNLPXh7b0ZC94qucPaP7C3Kxgl6zFcCrmIeEB8Ovi9f80EhhBBZFxERwYgRI3B1dcXS0pJSpUrRoUMHDh8+nOOxr1+/zpAhQyhXrhyWlpa4u7vTt29fTp06BUBQUBAajQZfX9+n3tuyZcvn9mbNLxIk5aH21UuxZkRjyjpaE/gwofvxCt2PaDQaXqtTjk41Mp7K23w+lJYz9rHx3MPE7kcJ3dW6K8UjN4zMfoVuALemMOIwtPocusxSdppAKWCZlpKTjyuEEMLI9OrVi7Nnz/LLL79w9epVNm7cSMuWLbl//36Oxj116hR16tTh6tWrLF68mEuXLrFu3TqqVq3KuHHjVFp93pOcpP/IjTPN/7oXl8yI309zMugBJhr4tHM1hjZ1f6Lv23+98dNRjgVEAtDMoziTenpRvpit8pTb/qlKhW0Aj/bQaylYOeRskRvfhZAT0PV7KN84Z2MJIUQB8rLmJEVFRVG0aFH27dtHixYtnvmaoKAg3N3dOXv2LLVq1XrifXv37qVly5ZPvUev11OjRg2srKw4ceIEJiZP7r9ERUXh6Oj4zLEfyWqxaMlJKgSK21ny+7AGvF63HDo9TNpymY9Wnyc5LfNdoF/eqs8HbStjYWbCwWv3aP/9AebvvU6KDmj1Kby2DMys4NoOWNoO7t8wfIGJD+DKvxDhD8s7wYZRkBBp+HhCCFFIJKSkZfqVlKpV/bXZYWdnh52dHevXr3+i00RO+fr64ufnx7hx454KkAAcHR1VmyuvmeX3AgorSzNTpvXypkope77bcolVp28ReC+eRW/Wobid5TNf/35bD7rXKsPn6y9w+Pp9Zmy/wrqzt5nWy5s6Xr3AqQL81Q/uXVEqdL/+C1Romf3FWReFUceVekxnflEqdl/ZBu0nQc2+GUdyQgghnuD5xfZMv9eqijPLh9RPv67z7S4SU5/9j+MG7k78/U6j9Oum0/YSGf90CkTQ1C5ZXpuZmRkrVqxg+PDhLFq0iNq1a9OiRQveeOON9PZfhrh27RoAVatWNXgMYyU7SflIo9EwtKk7y4fUp4iVGaduPqDHvMP43YnO9D3uxW35fWgD5vSpRXE7C66Hx2XsQJXxURK6y9aFpCj47VU4/pNhT6zZOEH3uUreUwlPpVzA+hFKknhUsGEfWAghRL7q1asXd+7cYePGjXTs2JF9+/ZRu3ZtVqxYYfCYBTlrR3aSjECLys6sG9mE4b+eIvBePK8tPMqs12vSucaz26loNBp6+pSlVZUSbL90l8YVi6d/72qCLZUGbsZkyxg4vxK2faiUCug8E8wssr8414bwzgE4Oh/2TYWIy2BhZ+AnFUKIgu3SNx0y/Z7Jf3bhT09sm+XXHvq4Vc4W9hgrKyvatWtHu3btmDhxIsOGDePLL79k8ODB6cdljwc+qanP785QuXJlAPz9/fHx8cn0dY/yhKKjn94IiIqKwsEhh7m0uUB2koxEpRJ2rB/ZhGYexUlM1TLyjzPM3nn12c1vH3KwMef1ui7p17ejEuk5/zB9lp/lSqMZ0O4bQKMcmf3aHeKefpIuS0zNoekY5QjutWXKLhMoO1S3Thk2phBCFEA2FmaZflmZm6r+WjV4enoSHx8PgLOzM8AT3Sye9cj+42rVqoWnpyezZs1C94yWWVFRUQA4OTlRvHhxTp8+/cT3Y2JiuH79enqwZUwkSDIiDjbmLB9cj6FN3QGYu/saI/8483RByUxcuhMDwMmgB3T58RBTYtqT0PtvsLSH4KOwpBWEnjd8gUXLP5njdGk9LG0D/wyEmDuGjyuEECLX3b9/n9atW/P7779z/vx5AgMDWbVqFdOnT6dHjx4AWFtb07BhQ6ZOncrly5fZv38/n3/++XPH1Wg0LF++nKtXr9KsWTO2bt1KQEAA58+f57vvvksfG2Ds2LFMnjyZP/74gxs3bnDixAn69++Ps7Mzr776aq5+fkNIkGRkzExNmNjVk+mveWNhasK/fnfptfDIk73cMtHOsyQ7x7agvWdJ0nR6Fu8PoN0mc3a23ABOFSE6BJZ1AL/16iw2MgA0pnBpA8yrB8cWgjZ7T1sIIYTIG3Z2djRo0IDvv/+e5s2b4+XlxcSJExk+fDjz5s1Lf92yZctIS0ujTp06jBkzhkmTJr1w7Pr163Pq1CkqVaqU3kO1e/fu+Pn5PfFY/0cffcSXX37JtGnT8Pb2plevXtja2rJ3716sra1z42PniNRJ+o+8qJOUVadvRvLOb2e4F5dMURtzFvSvQ6OKxbL03l2Xwvhyox+3oxIB6OxZjPn6qWgC9yovaP4RtJwAz3hcM1vuXoDNH8Ctk8p1qRrQdQ6Uq5uzcYUQwki9rHWSCgKpkyTS1SnvxMbRTahR1oEHCakM+Pk4vx4NytKTBG09S7JzbHNGtKyImYkGtxKOaAashoajlBccmA7/vKlU1s6JUjXgrR1KYGTlqARNS9vCgRk5G1cIIYTIZxIkGbkyjtas+l8jetQqg1an54sNfny67gIpaU8nx/2XjYUZH3esyrb3m/Fuaw8wNYOOk7nccjHH8QL/zUrhyciAnC3SxATqDlGa5tbsB+ihXL2cjSmEEELkMwmSXgJW5qbM6VOLTzpVRaOBv06E0G/JMSJis1Yx1aNkEawtlCcltDo9n1wsR5+kTxmnH8P98FvwUyu4sTfnC7VzhlcWwqgTTyZ4+62H8Ms5H18IIYTIQxIkvSQ0Gg3/a1GRZYPqUcRSKTzZfd4hzt+KytY4KWk6qpd1QKOBNcn1aZ06hz/iaqP77TU4usCwwpP/5Vwl49fRt5W2Jouaws4vICU+5+MLIYQQeUCCpJdMq6olWD+6CRWcbQmNTqL3oqOsP3s7y++3tjBl8is1WDOiMZ6l7YnWWfNZ2jBeSf6CC9t+Uqpqpyapt2CNBtxbgC4NDv8A8+rD5c3qBGNCCCFELpIg6SVU0dmO9aOa0LpqCZLTdIz525fJWy+jfU7hyf+q7VqUjaOb8FU3T+wszTinr0T3lG85cfaM0tRWrbpH9mWg75/QdyU4ukLMLfi7P/z5OkQGqjOHEEIIkQskSHpJ2VuZs2RgXUa1qgjATwcCGLz8BFEJTzdAzIyZqQmDm7izZ1wLutcsg7ezGXVsIuDOGVjcAoKPq7fgKp1g5HFoNh5MzOHaDljUDBKj1JtDCCGEUJEESS8xUxMNH3aoyvx+tbE2N+XgtXt0n3eYK3ez91h/CXsr5vb1YeW77TF9ew+UqE5iXBTvL97I1T2/qbdgCxtoMxFGHlWO4Oq9BdaO6o0vhBBCqEiCpAKgi3dp1oxoTLmi1gRHJvDKgsP8ezH0xW/8D2sLU3Byh6E7WOD4IRu0jem8w57JP84nPv7FFb+zrLgHDNwArSdm3As9B/8Mguhb6s0jhBBC5IAESQWEZxl7No1uSpNKxUhI0fK/388wa8eV5zbIzZSlHa8PGkW7krGkYcZPt91oM2UTW05czlIhyyzRaJTGuY9s+0TpBTevPhyaA2lZPzYUQgghcoMESQVIUVsLfhlSn2EPG+T+uOc6w389RUxSarbHcnGyZckHb7CsnQkumnvcTbNj1NoABi7YxY2IOLWXDp1ngEtDSI2HXV8qJQMCD6g/jxBCFGIRERGMGDECV1dXLC0tKVWqFB06dODw4cM5Grdly5ZoNBpWrlz5xP05c+bg5uaWfr1ixQocHR1zNFdekiCpgDEzNeHzrp5836cmlmYm7PYPp+e8w1wPN6z9SOs2ndj5XiPeK7IfC1I4GJLC7H92qrxqoJQXDNkGPRaATXG4dwV+6Qarh0JM9o8OhRBCPK1Xr16cPXuWX375hatXr7Jx40ZatmzJ/fv3czy2lZUVn3/+Oamp2f+HubGSIKmAesWnHKv/15gyDlYE3Iun5/wjbPe7a9BYVqUrM3bc5+youo2OJif4NHwcbBkP2lSSUrXqHcGZmIBPf3j3FNQbDhoTuLhaaZ8ihBAiR6Kiojh48CDTpk2jVatWlC9fnvr16zNhwgS6d+8OQFBQEBqNBl9f3yfep9Fo2Ldv33PH79u3L1FRUSxZsiQXP0XekiCpAKtRzoGN7zalgbsTcclpvPPbaWYbmqdkZY/bwEUsam9DWc19OLkEfunOhL9PMmTFSYLuqVhJ27oodJkJw/eCz5tQ962M7yVFqzePEEKoLSU+86//Fup97msTs/babLCzs8POzo7169eTnJy1tlbZYW9vz2effcY333xDfHzB6K5glt8LELmruJ0lvw9rwHdbLrPiSBBz91zH704Ms/vUwsHa/MUDPM7EBFp+DKW9Ye3b3Lnpz5bkMFIwo/31A7zTogIjW1ZK7xOXY2VqQY95GdepiUptJZf60H4SFCmlzjxCCKGWyWUy/55He+i/KuN6RiVIzeTJ4fJNYciWjOs5NSDhGUdiX2X9H45mZmasWLGC4cOHs2jRImrXrk2LFi1444038Pb2zvI4zzNy5Eh++OEHZs+ezcSJE1/8BiMnO0mFgLmpCV91r86s3jWxeJSnNP8w18IMy1OiSicYvocyzsXZbvERzU0vkKLV8eOe67SdvZ/tfnfVO4J7XMB+iAqGC6vgx7pwdD5oC87ZtxBC5LZevXpx584dNm7cSMeOHdm3bx+1a9dmxYoVqoxvaWnJN998w8yZM7l3754qY+YnjT5Xfpq9vGJiYnBwcCA6Ohp7e/v8Xo7qzt+K4n+/neZOdBK2FqbMer0mHb1KGzZYUgysH4H+8ma26+ryrckIbidbA9CisjPTX/OmpL2ViqsHbp+BrePh9mnl2rmacjTn1lTdeYQQIhNJSUkEBgbi7u6OldV//o573hGYxhTMrbL4WhMwt37xay1sX7zgFxg2bBg7d+7k5s2bBAcHU758ec6cOYOPjw+gPBFXokQJ9u7dS8uWLZ85RsuWLalVqxZz5sxBp9NRq1YtWrdujZubG3PmzCEoKAhQnm4bM2YMUVFRBq31eb/3ufHzW3aSChnvco5sercpDSs4Ef+wntL0f/2z1fctnZU9vP4bmtaf09H0NLsYweiiJ7Aw1XApNAYbtY7dHle2NgzdBd3mgrUTRFyGFV2Up+DS1D9jF0KIbLGwzfzL3Cobr7XO2mtV4OnpmZ5D5OzsDEBoaMZTxY8ncWeFiYkJU6ZMYeHChenB0ctKgqRCqJidJb8PbZBeT2nBvhsMWXEyW33f0pmYQIsPod8/WFtZMz5xDv/af8cPrSwpYqXkPOn1eg5du6fuU3B1BsG7p6HuUECjnOubWaozvhBCFED379+ndevW/P7775w/f57AwEBWrVrF9OnT6dGjBwDW1tY0bNiQqVOncvnyZfbv38/nn3+e7bm6dOlCgwYNWLx4sdofI09JkFRIPaqn9MMbtbAyN+HA1Qi6zTvEpTsxhg1YuT28vRecq1Eh8SKNd70CJ5aAXs+6s7cZ8PNx3vz5hMH1mp7Jxgm6zoa390HHqRn348Lhxl715hFCiALAzs6OBg0a8P3339O8eXO8vLyYOHEiw4cPZ968jIdkli1bRlpaGnXq1GHMmDFMmjTJoPmmTZtGUlLSi19oxCQn6T8Kek7Ss1y6E8M7v58iJDIRK3MTpr7qTU+fsoYNlhwHG0YpLUYAavXn56JjmLbzBilpOsxMNAxt6s67bTyws8ylhyvXjYBzf4JnD2j/HTi65M48QohC6bk5SSJXSU6SyHOP+r61qOxMUqqOMX/78vUmP1K1uuwPZmkHvVdAu2+UxEPfPxjqP4ydQyvRtloJ0nR6Fh8IoPXMfWzwva3+U3B6PVg5KHNf2gDz6sGBGU/XJxFCCCFeQIIkAYCjjQXLBtfj3daVAFh+OIj+S44THmtAcKHRQJP34c11YFMMQs9R/p/2LG0ay7LBdSlfzIbw2GTeX+nL5+svqvtBNBroNBXeOQiujSEtEfZMggUN4ep2decSQghRoEmQJNKZmmgY174KP71ZBztLM04ERdLtx0Ocvhlp2IAVWsLb+6GMDyRGwu+9aB3xB9vfb8aHHapgbW5q+LHei5TygiFb4dUlYFcKHgTCn6/DqeW5M58QQogCR4Ik8ZT21UuxYXQTPErYERaTzBs/HePXo0GGHY05usCQf8FnAOh1sPtrrNYOYlSjEhyd0Jp6bk7pL112KJC/TgQbVo7gWTQa8H5d6QXX+D2wLwter6ozthBCiAJPgiTxTBWd7Vg/qgldapQmVavniw1+jPvnHIkp2uwPZm4F3edB1zlgaqE0rF3SGse4gPSX3I5KZNq//kxYe4FXFhzmTPAD9T6MZRFo/61SMsDKQbmn18OaYXBxjfJrIYTIJnnuKe/l9e+5BEkiU7aWZszr58NnnathaqJh7dnbvLrwCMH3M+k19DwaDdQdouwq2ZeF+9dgaRvwWw9AiSKWfNSxKkUszTh/K5pXFxxh3D/nDMuJyszjxdkub1Tam6x+C37pBmF+6s0jhCjQzM2VGnAJCQb8XShy5NHv+aM/g9wmJQD+ozCWAMiKIzfu8e6fZ7kfn4K9lRk/vOFDq6olDBssLgJWD4Ggg8p143ehzVdgakZEbDLT//Vn1elbANhZmjGmrQeDGrthbqpiTJ+aCIfnwqHZkJaktAuoNwxaTQDrourNI4QokEJDQ4mKiqJEiRLY2Nig0Wjye0kFml6vJyEhgfDwcBwdHSld+ul2Wrnx81uCpP+QIClzodGJjPj9DL4hUQC818aD99t4YGpiwF8O2jTY/TUcmatcl28KvZeDnRJ4nQ1+wFcb/Th3K1ppyju2BS5ONip9ksdEBcOOz5VyAaA8jdd6ItQeCCa50FZFCFEg6PV67t69a3APMmEYR0dHSpUq9cygVIKkPCBB0vMlp2mZtPkyvx27CSiNbH94oxaONhaGDXhpA6wfBSmxUKQ09P4FXBsAoNPpWX36FtGJqQxvXiH9LQ/iUyhqa+B8mQnYB9s+hgh/KOGplBAwzaVil0KIAkOr1ZKamprfyygUzM3NMTXN/B+vEiTlAQmSsmbtmVt8uu4CSak6yhW1ZtGAOniVdTBssHvX4O8BSoBiYgYdJkP9t5U8pv84E/yAvj8d4+3mFRjRsiI2FioGMtpUOPmzUj7AralyLy0ZEiLB/umtXSGEEMZDKm4Lo/Fq7XKsHdEEVycbbj1I5NWFR/j7ZLBhgxX3gGG7ofqroEuDbR8pT56lxD/10s3nQklO0/Hjnuu0mbWfjefuqPe0g6k5NPxfRoAEcHQe/FgHDs5WAiYhhBCFhuwk/YfsJGVPdGIq4/7xZdflcAD61HXh6x7VsTI3IJ9Hr4djC2HnRCVYcq4GfX5Tgqj0l+jZ7hfGpC2XuPUgEYD6bk580c3T8J2s563nt57KURxAUXfoOAUqd3zmLpcQQoj8I8dteUCCpOzT6fQs3H+DWTuuoNODV1l7FvavY3ii9c2jsGowxN0FiyLQc77SrPYxSalafjoQwIJ910lK1aHRwMiWFfmwQ9Wcf6DH6XRw4R/Y+aWyHoCKbaDjVHCurO5cQgghDCbHbcIomZhoGNWqEr++1QAnWwsu3o6h64+H2OMfZtiA5RvBOweUJ95SYuGfgbD9MyVn6CErc1Pea+PB7nEt6epdGr0eyhezVekTPcbEBGq+oVTtbvqBUgzzxm5Y2AjO/q7+fEIIIYyG7CT9h+wk5cydqERG/XmGs8FRAIxuVYkP2lVWp0yAa2N4bdkzk6h9Q6LwLuuAycN59vqHY2aqoZmHs6Ef5dnu31ACtuu7YNRxKFZR3fGFEEIYRI7b8oAESTmXkqZj8tbLrDgSBECTSsX44Q0fittZGjbgpY2wfqSyq2RbQgmU3Jtl+vKElDRaz9zP3Zgk2nmW5PMu1dTfZbp/48kA6eBscG2k7IIJIYTIc3LcJl4KFmYmfNW9OnP7+mBjYcrh6/fpOvcQp29GGjagZ3d4Zz+UqA7x4fBrdyUo0eme+XKdHjrVKIWpiYadl8JoN/sA0/71Jy45LQef6j8eD5DunIXd38Dyjkqbk6gQ9eYRQgiRb2Qn6T9kJ0ld18Ji+d/vp7kREY+ZiYYJnavxVhM3w0r4pyTAlrFw7i/lukpn6Lkg0zYi18Ji+WbzJQ5euweAcxFLPupQhV61y6Ufy6ki/h7s+RZO/wLowcwamo6Bxu+BRS5UCRdCCPEUOW7LAxIkqS8uOY1P1pxn8/lQADrXKMW0Xt4UsTKgQaFeD2d+ga0fgTYZHMvD679CmVqZvFzP7svhTNpyiaCHjXnXjWyMj2su9GcLPQ//fgI3DyvX9uWg3dfg1UtKBgghRC6TICkPSJCUO/R6Pb8evcmkLZdI1epxL27LwgG1qVrKwN/jO2fhn0EQdRNMLaHTNKgzONNgJDlNy4rDQdyIiGP6azXT7yelag2r6ZQZvV5ptbJjIkQHg7UTvO8LVirXcBJCCPEECZLygARJuetM8ANG/3GGO9FJWJmb8F3PGvSqU86wwRIfwLoRcHWbcu39BnSdDRZZS9K+E5VItx8PMbCRG283r4C1hYrBUmoiHPlR6UdX+03lnl6vtDixLabePEIIIQBJ3BYFQG3Xomx+rxnNPIqTlKpj3KpzfLLmPEmp2uwPZl0U3vgT2n4NGhM4vxKWtlV6wWXBqlO3uB+fwve7rtJm1j51W5yYW0OLjzICJFB2mH7wVpLOU5PUmUcIIUSukZ2k/5CdpLyh1emZt+c6c3ZfRa+HaqXtWdC/Nu7FDXxUP+gQrBqiPP1mYQfd5yq5QM+h1+vZfD6Uqdv8uR2ltDipW74oX3TzxLuco2HreJ5/BsGl9cqvHctD+0lQrZvkKwkhhArkuC0PSJCUtw5ei2DMSl/ux6dgZ2nGjNe86VTj6WKRWRIbBmuGQtBB5breMOgwGcyeX5/pUYuThftukPhwR6tfA1e+6+ll2FN4mdHp4PzfsOurjBYnbs2UfnClaqg3jxBCFEJy3CYKnGYezmx5rxn13IoSl5zGiD/O8PUmP1LSnl0D6bmKlIQ310Ozccr1yaWwrAM8CHru2x61ONkzvgWv+JQFwMHaXN0ACZQWJ7X6wrunofmHYGalBHSLmsHBWerOJYQQIsdkJ+k/ZCcpf6RqdczcfoXFBwIAqOniyPx+PpQramCdoas7YN3bSnK3lQP0XARVO2fprWeDH1CphF16iYILt6IJuh9PV+/S6gZOUcFK41y/tfDmOqjYWr2xhRCikJHjtjwgQVL+2nkpjHH/+BKTlIaDtTmzX69Jm2olDRssKgRWDYbbp5TrRqOh7VdgmvX6THq9nlcXHuFscBR1yxdlYldParo4GraezIRfhhLVMq7P/ApWjpKvJIQQ2SDHbaLAa+dZki3vNaNmOQeiE1MZ+ssppm7zJ01rwPGbowsM2QYNRyrXR+fB8s4QfSvLQ6Tp9LSqUgJrc1NO3XxAj/mHGfu3L3ejVXw67fEAKTYM/v0U/nkTVnSF0HPqzSOEECJbZCfpP2QnyTgkp2mZstU/vUluPbei/Ni3NqUcrAwb8NJG2DAakqOVAo+v/gQe7bL89rvRSUzf7s/aM7cBsDY35Z0WFXineUV16yulxMOhOXBkLqQlARqo1R/aTIQipdSbRwghChg5bssDEiQZly3nQ/l4zXniktNwsrXg+z61aFHZ2bDBIgNh1aCM3ZmmY6HVZ2BqluUhfEOi+HbzJU7ffADArN41DS+G+TxRIcpTcBdXK9fmttDsA+XI0Nxa/fmEEOIlJ0FSHpAgyfgE3Ytn5B9nuBQag0YDo1pWYkxbD8xMDTgtTk2CHZ8pT74BuDaG134G+zJZHkKv17PlQigbfO+waEAdTB82y41OTMXB2oB+dM8TclLpB3f7FJiYwcjjULySunMIIUQBUKhzkqZOnYpGo2HMmDHPfd2qVauoWrUqVlZW1KhRg61bt+bNAkWucStuy9qRjRnQ0BW9HubtvU7/pccJjzEgL8jcCrrMgteWg0URCD4Ci5rC9V1ZHkKj0dDVuwxLBtZND5ASU7R0/uEgo/48Q0hkQvbXlRmXejBsF/T6Wdn1ejxAigxUbx4hhBBPeSmCpJMnT7J48WK8vb2f+7ojR47Qt29fhg4dytmzZ+nZsyc9e/bk4sWLebRSkVuszE2Z1LMGc/v6YGthyvHASDrPPcjBaxGGDej1KryzXynimHAffu8Fu78BbZpBwx0NuEdodCJbzofSZtZ+pmy7TExSqmFr+y+NBmq8Bs3GZtwLPQc/1laqjD+4qc48QgghnmD0x21xcXHUrl2bBQsWMGnSJGrVqsWcOXOe+do+ffoQHx/P5s2b0+81bNiQWrVqsWjRoizNJ8dtxi8gIo6Rf5zB/24sGg2MblWJ99vk4Pht+6dw6mfl2oDjt0cuh8YwacslDl+/D0AxWws+aFeZN+q5GLa25zm6QFk3ejC1hEYjlRwrK/lvVghROBXK47ZRo0bRpUsX2rZt+8LXHj169KnXdejQgaNHj+bW8kQ+qOBsx/pRTejXQDl++3HPdfotPU6YocdvXWcrx1mPH79dy/rx2yPVStvz+9AG/DyoLhWcbbkfn8Ln6y/See5B4pIN26HKVKOR8M4Bpa2JNhkOfQ9zfeDUMoN3w4QQQjzJqIOklStXcubMGaZMmZKl19+9e5eSJZ8sPFiyZEnu3r2b6XuSk5OJiYl54ksYPytzUya/knH8diIwkk4/HGT/VQOP32q89vD4zVs5fvujl/J0WTYDDo1GQ5tqJdk+pjlfdfPE0cacCsXtsLPM+hN0WVbaGwZtgr4roVglSLgHmz+A33qCcW8QCyHES8Fog6SQkBDef/99/vjjD6ysDKyNkwVTpkzBwcEh/cvFxSXX5hLq616zDJvfa4ZnaXsi41MYtOwE0/41sPhksYowdCfUG65cH/oeVnSB6NvZHsrc1ITBTdzZP74VX/eonn7/bnQSE9dfJCI2OfvrexaNBqp0gpHHoNN0sC4Knj2kUrcQQqjAaIOk06dPEx4eTu3atTEzM8PMzIz9+/czd+5czMzM0Gq1T72nVKlShIWFPXEvLCyMUqUyL8I3YcIEoqOj079CQkJU/ywid7k/fPrtzYblAVi47wZv/HSMO1GJ2R/M3Aq6zITev4ClPYQcU47frm43aG0ONuaUtM8I8mdsv8Jvx27ScsZe5u25RlLq0/8dG8TUHBq8A++dhTqDM+5f3gQb31MqeQshhMgWo03cjo2N5ebNJ5/aGTJkCFWrVuXjjz/Gy8vrqff06dOHhIQENm3alH6vcePGeHt7S+J2IbHlfCifrDlPbHIajjbmzHytJm09Dez9FhmgPD0W6qtcNxoNbb4EMwuD13cyKJJJmy9x7lY0AKUdrPiwQxV61iqLiYnKuz/aNJhXFx4EgoUdNBkDjUaBhYFNg4UQwogV+mKSLVu2fOLptoEDB1K2bNn0nKUjR47QokULpk6dSpcuXVi5ciWTJ0/mzJkzzwyqnkWCpJdf8P0ERv91hvMPA5GhTd35uGNVLMwM2DhNS1Zyk44tUK7L1oHXlkFRN4PXp9Pp2XT+DtP/vcLth7tdNco68HmXajSoUMzgcZ/p5lGleObt08q1fVloPRG8+4CJ0W4kCyFEthXKp9ueJzg4mNDQ0PTrxo0b8+eff/LTTz9Rs2ZNVq9ezfr167McIImCwbWYDav/15i3mrgD8POhQHovOkLwfQOKPJpZQscp8MafYOWgBBuLmoPfeoPXZ2KioUetsuwe14KPOlbBztKMC7ej2XvFwKTz5ynfCIY+LEbp4Aoxt2H9/+CnFko1byGEEJl6qXaS8oLsJBUsOy+FMX7VOaITUyliacbkV2vQrWb2ayABEBUMq4fCrRPKdd23oMPkHPdSuxeXzKJ9N3ivrQf2Vkpbk8B78dhbmVHMzjJHYz8hNQmOL4SDsyE5BgashUpt1BtfCCHyUaE/bssLEiQVPLejEnn/r7OcetiUtm99F77oWh1rC9PsD6ZNhT2T4PAc5bqkl9LixLmyauvV6/X0XnSUK3djGdGqIm81ccfK3IC1Zib+Hvitg/rDM+5d3wWlaoKdgc2DhRAinxltkJSamsrdu3dJSEjA2dkZJycnNdaWLyRIKpjStDq+33WVBftuoNdD5ZJ2zO9XG4+SRQwb8PouWPuOUpvI3AY6z4Ra/VR59D4yPoU3fz6O3x2lZlcZBys+7FiFHjVzIbkbIC5CKUQJ0HQMNBwpyd1CiJeOUQVJsbGx/P7776xcuZITJ06QkpKCXq9Ho9FQrlw52rdvz9tvv029evVUWWhekSCpYDt07R5j/vblXlwyVuYmfNWtOn3quaAxJLiJvQtr34bA/cq1dx+lea6lgYHXY3Q6Pet9bzNj+xVCo5VK4l5l7fm0czUaVyye4/GfEHEF1r0Dd84q1/ZlofXnD5O7VdzBEkKIXGQ0QdLs2bP57rvvqFixIt26daN+/fqUKVMGa2trIiMjuXjxIgcPHmT9+vU0aNCAH3/8EQ8PD1UWnNskSCr4ImKTGfuPLwev3QOgq3dpJr9aIz0fKFt0Wjg0G/ZOBr0OnCooT7+V8VFlrUmpWpYdDmTB3hvprU1+eas+LSqrfCym08HFNUqT3+hg5V7JGtD+G6jYWt25hBAiFxhNkNS3b18+//xzqlev/tzXJScns3z5ciwsLHjrrbcMXmRekiCpcNDp9Px0MICZ26+QptPj4mTNj31rU8vF0bABbx6FNcMg5haYmEO7b6DhCNUqX9+LS2bu7mucCX7AhlFNMX147KbV6dN/rYrUJDixGA7MguRoMDGD98+DQ1n15hBCiFxgNEFSQSZBUuFyJvgB7/11llsPEjEz0fBhhyoMb1bBsNyfhEjY+C74b1auPTpAzwVgq97xWKpWh7mpUrkjKVVL1x8P0dW7NMObVcBWzf5wCZFwYAZoTKDDdxn3k6KVUghCCGFkjLJO0ltvvcWKFSvSr2/evMm2bduIjo7O6dBC5LrarkXZ8l4zutQoTZpOz5Rt/gxecdKw3mo2TtDndyWJ29QSrm2HhU0g8IBq630UIAFs9L3D9fA45uy6RsuZ+/jzeLBhPeuexcZJqQ/1eIB09wLMqga7v4UkaQQthCj4cryTVKpUKdavX0/Dhg2JioqiUqVKxMbGUrx4cfbs2UOVKlXUWmuekJ2kwkmv17PyZAhfb/IjKVVHcTsLZr9ei+aG5v7cvQirh8C9q4AGmo2DlhPAVL3dHr1ez9YLd5m+3Z+bDwtlViphxycdq9KmWgnDktGfZ8fncORH5dc2xaHlJ0qfOFMDcrmEEEJlRrmTFB0dTdmySr7CmjVrKFWqFDExMfTp04cJEybkeIFC5AWNRkPf+q5sGt2UKiWLcC8uhYHLTjBl62VS0gzYnSnlBW/vg9oDAT0cnAnLO8GDmy96Z7bW3MW7NDs/aMGX3TwpamPO9fA4hv16ijd+OqZe89xH2n2r7JQVq6SUPtg6HuY3gEsbQE7thRAFUI6DJBcXFwIDAwFYtWoVgwcPxtLSkv/9738cPnw4xwsUIi95lCzChtFNeLNheQAWHwjgtUVHCLoXn/3BLGyh+49KsUlLB6VS96JmSiFHFVmYmTCkiTv7PmzFiJYVsTQzwdHGXN0ClKAkoVfrBiOPKUeKNsUh8gb8MxBW9lN3LiGEMAI5Pm6bPHky//zzD926dWPq1KlcvnyZSpUq4e/vT506dYiPN+CHSz6S4zbxyHa/u3y0+jzRianYWpjybU8vXq1dzrDBHtyENUPh1sN+aT5vQqdpSiClsjtRiej0esoVVQpChkYnsuRAIKNaVVS3zUlyLByeC0fnQduvoME76o0thBDZZJRPt+n1eiZPnsyOHTvo3r0748aNA+C3335j8uTJXL58WZWF5hUJksTj7kQlMuZvX04ERgLwik9ZvulRnSKG1FTSpsK+KUrvNPRQzANe+xlK11R30f/x0epz/HPqFnaWZoxoqbQ5MaglS2ZiQsGmGJhZKNeXNsKNPUrOUpFS6s0jhBDPYZRBUmZmzJhBUlISEydOzI3hc40ESeK/tDo9C/ZeZ87ua2h1elydbJjb18fwmkqBB5RK3bGhYGoBbb9WtabSfx2+fo/JWy+ntzkpaW/JB20r81qdcpiZ5vjE/Uk6LcyrpxzDmdtA43eVLxWqkAshxPMYVZD0xRdf0KNHD+rUqaPKQoyFBEkiM6eCInl/pS+3o5SaSmPbV+ad5hUNK+YYfx82joYrW5XrSu2Umkp2JdRd9EM6nZ6N5+4wc8cVbj1IBMCjhB2fdq5Gq6oqz3nzCOyYCLdPKde2ztDiY3kSTgiRq4zq6bZbt27RqVMnypUrx4gRI9i2bRspKSmqLEoIY1TXzYmt7zeji7dSU2n6v1cYsPQ4dx/2VssW22Lwxp8ZNZWu71RqKl3bpf7CARMTDT19yrJ7XAs+71INRxtzroXHcfzhMaKqyjeGYbvg9V/BqSLERzx8Eq6+cgwnhBAviRwdt+l0Og4fPsymTZvYsGEDoaGhtGvXjh49etC1a1ecnJzUXGuekJ0k8SJ6vZ5Vp2/x1UY/ElK0ONqYM62XNx2qG5h/E3ZJSeoOv6RcNxwFbb8EMxWTrP8jOjGVnw8GMLRZBRysld2dK3djMTXRUKmEnXoTaVPhzC+wbxrEh8OAtVCpjXrjCyHEQ0Z13PYsly9fTg+YTp8+Tf369enevTt9+/ZNr6Vk7CRIElkVEBHHeyvPcvG2kuvTr4ErE7t4GpYUnZqoHFGdXKJcl6yhJHU7500xVr1ez+uLj3ImOIrX67owpq0HJe2t1JsgOU6pp1SrX0bu1cW1UNwDStVQbx4hRKFl9EHS4yIiIti4cSMbN26kWbNmjB8/PjemUZ0ESSI7UtJ0zNxxhZ8OBABQ0dmWuX19qF7GwP5mV7bB+pGQGAlm1tBxMtQZkmtJ3Y/EJ6fx/kpfdl0OA8DK3IShTd15p0VF7A15ku+FE96HH2pCShx4vw6tPoOi5dWfRwhRaBhFkJSYmEhkZORTO0N+fn5Ur15dlUXlJwmShCEOXotg3D/nCI9NxsLUhI86VuGtJu6GNcqNCYX1/4OAfcp1lS5KUUrbYqqu+VlOBEYyddtlzgRHAeBoY87oVpV4s1F5LM1ULhuw/VPwW6tcm1pAvWHQbHyefE4hRMGT70HS6tWrGTNmDMWLF0en07FkyRIaNGgAQO3atTlz5owqi8pPEiQJQ0XGp/DR6vPpuzHNPIozq3dNShhybKXTwbH5sOtr0KWCXSl4ZRFUbKXyqp+m1+vZcSmM6f/6cyNCKQb7fZ+avOJjYCHN57l9BnZ9mdEE2KIINHkfGo3MlUKbQoiCK9+DpFq1arF9+3ZKlizJ6dOnGTRoEJ9++in9+vXDx8eHs2fPqrKo/CRBksgJvV7PH8eD+XbzJZLTdDjZWjCtlzftPEsaNmDoOVgz7GGjXJSaQ60n5mpS9yNpWh1rztxi8/lQVgypn17qICwmiRJFLNVroKvXK0+97foK7p4HEzMYdQKKVVRnfCFEoZDvQVL16tXx8/NLv46MjOSVV16hTZs2rF+/XnaShHjoWlgs76305XKoktTdv4Ernxua1J2SoBxNnV6uXJfyhl5L8yyp+3FJqVpaz9xH2aLWfNKpKnXKq/gEq06nHL89CITmH2bcDzkJZeuAicqFL4UQBUq+10kqUaIE58+fT792cnJi586dXL58+Yn7QhR2HiWLsH5UY4Y3cwfgj+PBdP3xIBdvR2d/MAsb6DZHqatk7aTstixuASd/VnZh8tC5kCjux6dwMugBvRYeZdgvp7gaFqvO4CYmUOO1JwOkuxfh53awpCVc353nn1cIUbhlayfp1q1bmJmZUarU0/VgDh8+TJMmTVRdXH6QnSShtseTus1NNYxvX4XhzSrkIKl7BATsVa4rd4Ie88C2uLqLfo7Q6ETm7LzGqtMh6PTKg3ev+pTjg3Ye6U11VXNxDWx8T3kKDsC9udJMt2zBqvQvhMi5fD9uKwwkSBK5ITI+hU/WnGfHJSWpu1GFYsx6vSZlHK2zP5hOB8cXKQnP2hSwLaG0NPFop/Kqn+96eCwzt1/lX7+7AFiYmbB3fEvKGvKZnif+HhycBSeXKp8XoFp3JTfLubK6cwkhXloSJOUBCZJEbtHr9fx9MoSvN10iMVWLvZUZk1+tQVfvMoYNePeiktQdcVm5rv82tPsGzFUOUl7gbPADpv3rj52lOUsH1U2/r9XpDetrl5kHN2HfFDi3EtCDXUkYcxHMLNSbQwjx0jLKICkmJobly5dz9+5d3N3dqVmzJjVq1MDGRuVt9zwiQZLIbYH34hmz8iznbin5Sa/6lOXrHtUpYkjRxtRE5amw44uU6+JVlKTu0t7qLTgL9Ho9ialabCzMAOVI7rWFRxnWzJ1+DVzVrbEUdgn2fKscvTUc8WgBkBQF1kXVm0cI8VIxyiCpbdu2nDt3jnr16hEcHMyVK1cAqFixIjVr1uTvv/9WZaF5RYIkkRdStTrm7r7G/L3X0emhXFFrvu9Ti3puBj4tdn2XUqk7LgxMzKHNRGg0GkxUDE6yYfq//izYdwOAso7WfNCuMq/4lFV3Z0mvz6hEfmkDbBgNjd9TAidLFfvPCSFeCkYZJNna2rJv3z7q1asHQHJyMhcuXMDX15dz587x448/qrLQvCJBkshLp4IiGfO3L7ceJGKigREtK/J+m8pYmBnwuHv8fdj0HvhvVq7LN1UKUDq6qLvoLEjV6lh16hZzdl0lPDYZAI8SdoxrX4UO1UuqV2PpkVWDwW+d8mtbZ+UJuTqD86SelBDCOBhlkNSoUSMWLFiAj4+PKgvKbxIkibwWm5TKVxsvsebMLQBqlHXg+z61qFTCgN0QvR7O/Ar/ToDUeLB0gC6zwLu3yqvOmsQULb8cDWLhvhtEJ6YC0LCCE38Oa2jY032ZeVRjac8kpc4SgIMrtJoA3n3ybUdNCJF3jDJIOnjwINOnT2f16tVYWr78/2qTIEnkl60XQpmw9gLRialYmZvwWRdPBjRwNWzX5f4NWPcO3DqpXHu9Bl1m5lvOTnRiKj8duMGyQ0EMbFSeCZ2r5c5E2lQlSNw/HeKUp+7w6gWvLcud+YQQRsMog6SQkBAGDBjArVu36NOnDw0bNsTHxwcXl7zf4leDBEkiP92NTmL8qnMcun4PgJZVnJn+mjclihjQ/02bpjw6v38a6LVgXxZ6LoQKLVReddaFxyZhaWaKg7WSpH76ZiRLDgQyvkNlKpUoot5EKQlwYjEcmgO9fgaPtsp9nVZ2lYQooIwySKpfvz5hYWG0aNGC4OBgzp07R0xMDE5OTvj4+LBjxw5VFppXJEgS+U2n07PiSBBT//UnJU1HURtzprzqTUevp4u4ZsmtU7B2OEQGKNcNR0GbL8DcgMBLZX1/OsbRgPuYaOAVn3KMaeuBi5OKT8Ymx4KFXUaC94EZEHhQ+fzl6j7/vUKIl4pRBkk2NjYcPXqUmjVrpt8LCgri7NmznD9/ni+//DLHi8xLEiQJY3E1LJYxK3259LD/W+865fiye3XsLM2yP1hKPGz/LKP/m3M16LUEStVQccXZdzUsllk7rrDdTymyaW6qoV99V0a1rmTY7tnzpCXD99UhPkK5rtIFWn8GJaurO48QIl8YZZDUokULpkyZQuPGjVVZUH6TIEkYk5Q0HbN3XmXxgRvo9eDiZM3s13NQKuDqdtgwSgkUTMyh9efQ+N18P4LyDYlixnZ/Dl+/D4C1uSnj2ldmWLMK6k4UFQz7psG5P0GvAzRQo7eS4O2k8lxCiDxllEHS2rVrWbRoEf/88w+Ojo6qLCo/SZAkjNGJwEjG/qOUCtBo4J3mFfmgnYdhRRrj7yn90K5sUa5dG8MrC6Gom6prNsSR6/eYseMKZ4OjmN7Lm9fr5VJuY8RV2DtJqa8EYGIGXedA7TdzZz4hRK4zyiDJxESp51KsWDFeeeUVGjRogI+PD15eXlhYvHztAiRIEsYqNimVbzZdYtVppVRAtdL2zOlTiyqlDEh41uvh7O/w7ydK81gLO+g0DWr1z8jfySd6vZ79VyNoWqk4ZqbK3y+bzt0hPDaZ/g1csTJXcdfrzlmlbMCNvTD6JBSrqN7YQog8ZZRB0s2bNzl37lx68UhfX1+CgoIwMzOjSpUqnD9/XpWF5hUJkoSx+/fiXT5dd4HI+BQsTE0Y36EyQ5tWMKya9YMgWPc/CD6qXFfpAt1+ADtnVdecE8lpWlrP3M/tqERKO1jxbmsPetcth7mpAQU3M3P/xpMB0uaxYOOkVC23dlRvHiFErjHKIOnIkSPY29vj5eWVfi82NhZfX1/Onz/PqFGjcrzIvCRBkngZhMcmMWHNBXb7hwNQ392JWb1rGvZkmE4LR35UdlR0qUrF6m5zoWpnlVdtmDStjtWnbzF39zXuRCcBUL6YDWPaetC9psqtTgDuXYd5dQE9WDlCk/egwf/AwlbdeYQQqjLKIMnHx4fRo0czdOjQJ+7fuHGDEiVKUKSIirVP8oAESeJlodfrWXkyhG83XyIhRYuthSlfdqtO77rlDCtAefcCrH0bwi8p1z4DoMMUsDKO/x8kpWr583gwC/Zd515cCqC0Ovm2pxcNKxRTbyK9Hi5vhL2TIcJfuWfrDM3GQZ0hRlE6QQjxNKMMkmxsbLhw4QIVKz55lr948WI2bdrE5s2bc7TAvCZBknjZBN9PYOw/vpy6+QCAttVKMuXVGjgXMaACfmoS7P1O2VlCr7T2eGUhuDVVd9E5EJ+cxoojQSzef4OYpDTWjGhEnfIGPu33PDotXFgN+yYrx5KgFOR84w8oUzDaMAlRkBhlkFSqVCk2b95M3bpPFma7dOkSzZs35969ezlaYF6TIEm8jLQ6PUsOBjB7x1VStDqcbC2Y/IoXHb1KGzbgzSNKrlLUTUADjUZB64lGtYsSnZjKzkthvFanXPq9P48H41bchsYVi6s3kTZVSXLfPx3SkuD9c0azuyaEyGCUQdLgwYNJSkpi5cqVT9z39/enfv36xMTE5GiBeU2CJPEyuxwawwd/++J/NxaAV33K8mX36ultQLIlORa2f6r0QgNwrgqvLDLaXZTwmCSaz9hLUqqOJpWKMbZdFeqUV7FXXWqScvxWppZyrdcrx5NVu0C17mCiYiK5ECLbjDJICgkJoX79+jRu3JivvvqKGjVqkJSUxIgRI7h27RqHDh1SZaF5RYIk8bJLTtMyZ9c1Fu+/gU4PpR2smPFaTZp6GLi7cuVf2PguxIcr9YSaf6jk55gaEHjlovtxyfyw+xp/nQgmVav8tda6agnGtquMV1kH9Sf03wIr+ym/LlUDWn0GlTvmewkFIQorowySQCkDMGLECP79918sLS1JS0vDwcGBTZs20ahRIzXWmWckSBIFxembkYz75xxB9xMAGNioPJ90qoqNhQFtTeLvw5YPMoovlvGBVxaDcxUVV6yOWw8S+HH3dVafuYVWp/z11rF6KT7rUk3dvnBJ0XB0PhxdACnKzh1l6yjBUsXWEiwJkceMNkh6JDg4GF9fX8zNzWnQoAFOTrmQTJnLJEgSBUlCShpTtvrz27GbALgVs2HW6zUNS3TW65VE5q3jlADBzEppFNtghFEeNQXei+eHXVfZcO4O5qYmHPiwFaUcciGnKiESDv8AJ36CVCUgxbUx9PkNbFXMjRJCPJfRB0kFgQRJoiA6cDWCj1af525MEiYaeDsnbU1i7sCG0XBjt3Jdvgn0mA9O7uouWiVXw2K5cCuaXo8leC87FEjbaiVxLabizlJcOBz6Hk7+DMU94J2DRhk8ClFQGU2QFBwcjKura5Zff/v2bcqWLZvdafKFBEmioIpOTOXrTX6sPXMbgColizDr9ZqG5evo9XB6BWz/DFLjwdwWOkxS6ggZ+THT2eAHvLLgCGYmGnrXLcfo1h6UdbRWb4Lo25BwD0rXVK5T4pVeeY1GQdna6s0jhHhCbvz8NuifOfXq1eOdd97h5MmTmb4mOjqaJUuW4OXlxZo1awxeoBBCHQ7W5sx+vRaL36xDMVsLroTF0nP+YX7YdY1UrS57g2k0UHcIjDis7CSlxsPmD+D3V5UgwYjZWJjRvLIzaTo9f50IodWMfXyx4SJhMUnqTOBQNiNAAjixBC6uhiWt4K++EPpytWoSojAzaCfp/v37fPfddyxbtgwrKyvq1KlDmTJlsLKy4sGDB1y6dAk/Pz9q167NxIkT6dzZONobZIXsJInC4H5cMp+tu8i/fncBqFHWgVmv16RySQMq5Ot0cHwh7PoatMlg6QCdpkLNvka9q3QyKJLZO65yNOA+ABZmJgxoUJ4P2nlQxErFJ/fu31BqLF34B/QPg9Fq3aHVp1CimnrzCFHIGc1x2yOJiYls2bKFQ4cOcfPmTRITEylevDg+Pj506NDhiX5uLwsJkkRhodfr2XjuDl9s8CM6MRULUxPGtq/M8GYGNsuNuArr/we3TyvXlTspzXKLlFR34So7cuMes3dc5dTNB5R2sGLv+JZYmRuQq/UiEVdh/1S4uBbQAxqo8ZrylKBJLswnRCFjdEFSQSRBkihswmKSmLD2AnseNsut7erIzN41qeBsl/3BtGlweA7sm6o0y7UuCl1mgVcvdRetMr1ez6Hr90hM0dK+eilAaay79FAgfeq6UNTWQr3Jwi7BvilKfzjPnvD6L+qNLUQhJkFSHpAgSRRGer2eVadv8e2mS8Qmp2FpZsJHHasypLEbJobsKoX5KW1N7j7Mv/HsqQRLL9Ej8WvP3GLsP+ewszTjrSZuDG1aAQcbFY/hQs+DhS0Ue9j38kEQ7J8Bzccb7ZOCQhgzCZLygARJojC7HZXIJ2vOc/Ca0nOxvpsTM3p7U76YbfYH06bCgZlwcCbo0sCmOHSdDZ49VF517jh8/R7fbbnMpVCltVIRKzPeauLOW03dDWvz8iIbRik94kzMlHyu5h9C0fLqzyNEASVBUh6QIEkUdnq9nj9PBPPdlsskpGixNjflk05VebNhecN2le74wvoREH5JufZ6DTrPABvjLzar0+nZcSmMObuupvfDs7cyY2jTCoxqVREzUxXrIN06DXu/y6g/ZWIGPgOg2XhwdFFvHiEKKAmS8oAESUIoQiIT+Gj1+fSnvxpWcGLGazUNa+2Rlgz7pynFFvU6sC0BXb+Hal1VXnXu0On0bLt4lzm7rnItPI76bk78/U5DNLnx9F7wcdg3GQL2Kdcm5tBoJLT7Rv25hChAjDJIGjRoEEOHDqV58+aqLCi/SZAkRAadTs9vx24ydZs/ialabCxMmdCpKv0bGLirdPs0rBsB964o1zV6Q6fpL8WuEoBWp2frhVDKFrWmtmtRAB7Ep/DXyWAGNnLDztKAvniZuXkE9k6GoIPQ/CNo/Zl6YwtRABllkNSzZ0+2bt1K+fLlGTJkCIMGDXppqms/iwRJQjzt5v14Plx9nhOBkQA0qlCM6a95G7arlJqkPN11ZG7GrlK3OVC1i7qLziMztvszf+8NitqYM7x5BfWDpaBDULK68qQgQMB+uLwJmn6gFK4UQgBGGiQBRERE8Ntvv/HLL79w6dIl2rZty9ChQ+nRowfm5rmQ4JiLJEgS4tl0Oj2/HA1i2r/+JKXqlF2lztXoX9/VsF2lW6eUXKV7V5XrGq9Dp2kvza7SI1svhDJz+xUC7sUDUNTGnLebV2Rgo/LYqhksgdIOZlkHCDkOppZQZ5ASLNmXUXceIV5CRhskPe7MmTMsX76cpUuXYmdnx4ABAxg5ciQeHh5qTpNrJEgS4vmC7sXz0erznAhSa1dpMhz5UdlVsiup5Cq9ZLtKaVodm87fYe7u6wQ+FiyNalWJYc0qqDtZ4AHYOwWCjyjXphZQZ7AES6LQM5rebZkJDQ1l586d7Ny5E1NTUzp37syFCxfw9PTk+++/V3MqIUQ+cStuy8q3G/JVN0+szU05GnCfDnMO8NvRIHS6bP6by9xKSUgeuhOKV4G4MFjZD9YMg4TI3PkAucDM1IRXfMqx84PmzOpdE/fitjxISOVGRJz6k7k3hyFbYeBGcG0M2hQ48RP8UBMOzVF/PiEKsRzvJKWmprJx40aWL1/Ojh078Pb2ZtiwYfTr1y89klu3bh1vvfUWDx48UGXRuUl2koTIupv3lV2l4w9zlRpWcGJaLwPrKqUmKW07Dv/wMFfJGbrMBs/uKq8696VpdWw8d4d6bk7pO2z+d2PY4x+ubs6SXq8kdj/aWXp1KXj3VmdsIV4yRnncVrx4cXQ6HX379mX48OHUqlXrqddERUXh4+NDYGBgTqbKExIkCZE9Op2e348rT8A9qqv0UccqDGpkYLXuW6dhw0iI8Feuq78CnWe+VNW6n2XE76fZdvEujjbmDG9WgYGNyqvXSFevh+Cj4NIgow/cqWVK5fOmH4BDOXXmEcKIGWWQ9Ntvv9G7d2+srKxUWVB+kyBJCMME30/g4zUZdZXqli/K9Ne8DesBl5qk1FU6/APotWBTTClAWf1VyI3aRHlg/dnbzN19LT3B29HGnGFN3RnU2E29YOmRtBT4wRtiQ5WcJZ8B0HSsFKUUBZpRBknBwcG4uLg8VVRNr9cTEhKCq6trjhaY1yRIEsJwOp1SrXvK1svEp2ixNDNhXPvKDG1aAVOD6iqdgQ2jIdxPua7aVTmCK1JS3YXnEa1Oz6Zzd5i75xoBEUqwZG9lxth2lRncROV+bYEHlUAz6KBybWIOPv2VYEnanYgCyCgTt93d3YmIiHjqfmRkJO7uhv+ffuHChXh7e2Nvb4+9vT2NGjVi27Ztmb5+xYoVaDSaJ74Kyu6WEC8LExMNAxqWZ8fYFjTzKE5ymo7JW/3ptfAI18Jisz9g2drw9j5o8bHSpsN/MyxoAOf+Vo6YXjKmJhp6+pRl5wct+OGNWlQqYUdMUhpp2U14zwr3ZjB4MwzeqiR761Lh9Ar4sTacXKr+fEIUQDkOkvR6/TNL88fFxeUoSClXrhxTp07l9OnTnDp1itatW9OjRw/8/PwyfY+9vT2hoaHpXzdv3jR4fiGE4co6WvPrW/WZ3subIlZm+IZE0WXuIebtuUaqVpe9wcwsoNWnMHwvlPKGxAew7m34sw9E386dD5DLTE009KhVlu1jmjO/X236N8jY2dl5KYxZO67wID5FncncmsCgTTDkX6jQUmk2XLZOxvdfwmBTiLxi8HHb2LFjAfjhhx8YPnw4NjYZNVK0Wi3Hjx/H1NSUw4cPq7NSwMnJiRkzZjB06NCnvrdixQrGjBlDVFRUjuaQ4zYh1HU3OonP1l1gt384AJ6l7ZnR25vqZRyyP5g2FQ7Pgf3TlUffLe2h/bdQe9BLm6v0OJ1OT6cfDnIlLBZbC1MGNXZjWLMKONlaqDdJuD+UqJpxvfUjSIqG5uOh+MtRz06IZzGq47azZ89y9uxZ9Ho9Fy5cSL8+e/Ys/v7+1KxZkxUrVqiySK1Wy8qVK4mPj6dRo0aZvi4uLo7y5cvj4uLywl0nIUTeKOVgxdJBdZnTpxaONuZcCo2hx7zDzNx+heQ0bfYGMzWH5h/COwehbF1IjoFN78OvPeBBUK6sP6990M6DaqXtiU/RsmDfDZpO28OUrZeJiE1WZ4LHA6SESOUI7vxKmF8fVg9VgighBKBC4vaQIUP44YcfcmXX5cKFCzRq1IikpCTs7Oz4888/6dy58zNfe/ToUa5du4a3tzfR0dHMnDmTAwcO4OfnR7lymT/+mpycTHJyxl8+MTExuLi4yE6SELkgIjaZLzdeZOuFuwBUKmHHtF7e1ClfNPuD6bRwbCHsmQRpiWBuA22+gPpvZzwG/5LS6/XsuhzO3N3XuHA7GgArcxM+7VyNgY3c1J3s9hk4MAOubH14QwOePZRgtJSXunMJkYuM8um23JSSkkJwcDDR0dGsXr2apUuXsn//fjw9PV/43tTUVKpVq0bfvn359ttvM33dV199xddff/3UfQmShMg92y6EMnGDH/fiktFoYHBjNz7sUAUbCwOKLN6/ARvfg5uHlOty9aHHPHCuou6i84Fer2fflQh+2H0N35Aolg2uS+uqufRkX+g5JVi6vCnjXs+FUKtf7swnhMqMJkgaO3Ys3377Lba2tum5SZmZPXu2wYv7r7Zt21KxYkUWL16cpdf37t0bMzMz/vrrr0xfIztJQuSPqIQUvtl8ibVnlORrFydrpr7qTZNKBhSN1OngzArY8QWkxCq1gVp8BE3GKEd0Lzm9Xs+pmw+oW75o+oMyC/fdIDgynhEtKuFazIC+eZkJ84MDM+HaDnjPF+yclfspCWCh4jxCqCw3giSDauOfPXuW1NTU9F/nFZ1O90RA8zxarZYLFy5kejz3iKWlJZaWlmosTwiRDY42Fsx+vRbdapbhs7UXCIlMpP/S4/Sp68KnXarhYJ2N4MbEBOq+BR7tYfMHyg/4PZPAb4Oyq1SmVq59jryg0Wio5+aUfp2YomXR/htEJ6byz6lb9KxVllGtKhpWuPO/SlaH3suVfCWbjDn5qw9oTKD5R8oTc0IUAkZ73DZhwgQ6deqEq6srsbGx/Pnnn0ybNo3t27fTrl07Bg4cSNmyZZkyZQoA33zzDQ0bNqRSpUpERUUxY8YM1q9fz+nTp7N0PPeIPN0mRN6LS05j+r/+/HpUKdtRoogl3/b0okP1UtkfTK+HC6tg20dKuQCNKTQeDS0ngLm1yivPP6eCIpm75zoHrip16kw00NW7DKNbV6JyySLqThYZCPPqKuUDAMo3UXKWKrQsEE8VioLBqI7bsjS4RsOsWbOyvSiAoUOHsnv3bkJDQ3FwcMDb25uPP/6Ydu3aAdCyZUvc3NzSn6D74IMPWLt2LXfv3qVo0aLUqVOHSZMm4ePjk615JUgSIv+cCIzkkzXn01t3dKlRmq+6V8e5iAG7vXER8O/HcHGNcu1UEbrPBbemKq44//mGRDFvzzV2XQ5Pv/d19+oMauym7kQPbirlF87+rpRfAOUJwxYfKTt4EiyJfGY0QVKrVq2yNrhGw549e7K9qPwkQZIQ+SspVcvc3ddYfCAArU6Pg7U5n3epxmt1yj2zcO0L+W+FLWOVPmYAdYZAu6/ByoA6TUbs4u1o5u+9zo5LYez8oHn60VtKmg4LsxzXDc4QfRuOzFVKB6QlKfd6/wLVe6o3hxAGMJogqSCTIEkI43DxdjQfrzmP350YAJpWKs7kV2oYlqScFA07v1B+sAMUKQNdZkHV5+csvozCYpIoaZ/R7eD9lWe5H5fC6NaVaODuZFig+Sxx4XDkR7i+C945kJEgf/8GOJYHU4NSXoUwmARJeUCCJCGMR5pWx9JDgXy/8yrJaTqszU0Z174yQ5q4G9YwN/AgbHoPIgOU6+qvQKfpYFdC3YUbicj4FBpO2U1KmtIKpm75ooxuXYkWlZ3VC5Z0OiVxHpSK6HNrK3Wqmo0F7zeUtjJC5AGjCZLyqwRAXpAgSQjjE3gvnglrz3MsIBKAmuUcmPKqN55lDPj/aGoi7Juq7ILotWDlCB2+g1r9C2Reza0HCSzeH8Dfp0LSg6UaZR0Y1aoS7T1LYmJIsJmZMD9Y0RUSlT8n7MtBk/eh9psFKmleGCejCZJatWrFunXrcHR0fG5+kuQkCSHUotPp+ftUCJO3XiY2KQ0zEw1vN6/Ae208sDI3oMJ26DnY+K7yvwDuLaDbHHCqoOq6jUV4TBJLDgbw+7FgElOVdjDf9vTizYblX/DObEqJh1PLlbyluDDlnm0J5QnDum+BpcpP3gnxkNEESQWZBElCGLewmCS+3ODHv35KaxP34rZMebUGDSsUy/5g2jQ4Og/2TVGSkM2soeUn0Gh0gc2puR+XzPLDQaz3vc2295tRxErJJQqJTKCkvZV6Sd6pSeD7Oxz6AaKDlXtDd4JLfXXGF+I/jD5IejSUamfd+UCCJCFeDv9eDOWLDX6EP2z8+kY9FyZ0qoaDjQEVtiMDYNMYCNyvXJfyhu4/vvRFKJ9Hq9On53Xp9Xq6zzvMvbhkhjerQN/6rlhbqNT/TpsK5/+BkGPK7+kjV7ZBmdpQJJfarIhCJzd+fqvyT4aff/4ZLy8vrKyssLKywsvLi6VLl6oxtBBCPFNHr9LsHNuCfg1cAVh5MoS23+9ny/lQsv1vP6cKMHAD9Fig5CjdPQ9LWsH2z5TjowLo8cT30OgkwmKSCI1O4pvNl2gybQ/z914nJilVhYnMwaf/kwFSXASsGgI/eMOW8RAVkvN5hMgFOd5J+uKLL5g9ezbvvvsujRo1AuDo0aPMmzePDz74gG+++UaVheYV2UkS4uVzPOA+E9ZdICBCCWjaVivBNz28KONoQLJwXDj8+0lGEUpHV+j6PVRqq+KKjU9ympbVp2+xaP8NQiITAShiZcbARuV5q4k7xexUbN8U7g8bR8Otk8q1iZnyJFzTMVDcQ715RKFilMdtzs7OzJ07l759+z5x/6+//uLdd9/l3r17OVpgXpMgSYiXU3Kalvl7b7Bw33VStXpsLUz5qGNVBjQsb1i5gKvbYcs4iH64y1HjdegwOaPhawGVptWx6fwdFuy9wbXwOAAWv1nHsBYxz6PXQ+ABODhT+V8ANODZA9p9A0VVTigXBZ5RBkmOjo6cPHkSD48no/+rV69Sv359oqKicjJ8npMgSYiX27WwWD5Ze4HTNx8AUMvFkSmv1qBaaQP+/5wcB3u/g+OLQK8D66LQ/juo1a9Algt4nE6nZ8elMLZdDOX712ullwrYeyUct2K2uBe3VW+yW6fg4Gy4sgVMLWDMBSiiclAmCjyjDJLeffddzM3Nn6qHNH78eBITE5k/f36OFpjXJEgS4uWn0+n540Qw07f5E5uslAsY3rwC7xtaLuD2adj4HoRdVK7dmkG3H6BYRXUXbuQSU7Q0nbaHBwkpdKpRmpEtK1K9jIrtXcIuwZ2zSg7TIzu/VPrtVWpb4ANTkTNGEyQ9XkAyLS2NFStW4OrqSsOGDQE4fvw4wcHBDBw4kB9//DGzYYySBElCFBxhMUl8tdGPbReVcgHli9nwXc8aNPUonv3BtKlwdL5SiDItEUwtocWH0Pj9QlNV+m50Ep+tu8Bu/4xmui2rODOyZSXquzupP+EdX/iphfLrUjWg6Qfg2VOp6C3EfxhNkCQNboUQL5Mdfnf5YoMfd2OUhqyv+JTl8y7VDEtGjgyEzR9AwF7l2rmaUoTStaF6CzZyl0NjWLjvBpvP30H38CdIPbeifNmtOl5lVdxZig1TilKeWg6pD58ydKqgVPGu2RfMVEwmFy89owmSCjIJkoQomOKS05i5/Qq/HA1CrwdHG3M+7VyN3nXKZb+2m14PF1YpT8El3Ffu1RkCbb8Ca0e1l260gu7Fs/hAAGtO3yJFq2PHB82pXDIXKmonRMLxxXBiMSQquWYUKQ0D1kJJT/XnEy8lCZLygARJQhRsviFRTFh7gcuhMQA0cHdi8qs1qOhsl/3BEiJh50Q4+7tybVsCOk2F6q8WqvyZsJgk9l+N4PW6Lun3Zu24QikHK3rVLmdYHtizJMfBmV/gyDxAD++fy9hNerzRriiUjDZIioqK4ueff+by5csAeHp6MnToUBwcVNx2zSMSJAlR8KVpdSw7HMj3O6+RmKrFwtSEES0rMqJlRcN+oAcdUip237+mXFdqB11mQlE3NZf90rgdlUiL6XtJ0+lxLmLJ0Kbu9G/gmt4CJcfSkuH+jYxdJG0a/NQS3JtBo1HgUE6decRLxSiDpFOnTtGhQwesra2pX1/pyXPy5EkSExPZsWMHtWvXVmWheUWCJCEKj5DIBCZuuMi+KxEAVChuy6RXvGhc0YDE7rRkOPQ9HJwF2pSHfeA+ftgHTqXg4CWRkJLGyhMhLDkYQGi0kgf2qDDlkCbuFFezMCUoNa3+fF35tYkZePdR8pacq6g7jzBqRhkkNWvWjEqVKrFkyRLMzJSGkGlpaQwbNoyAgAAOHDjwghGMiwRJQhQuer2eLRdC+XrTJSIe9oF7tXZZPutsYGL3vWtKYnfQQeW6hKdSLqAQNnZNSdOx8dwdFu2/wfWHhSktzUxY/GYdWlYpod5Eej3c2KMEqY9+3wGqdlWeiCtXV725hNEyyiDJ2tqas2fPUrVq1SfuX7p0ibp165KQkJCjBeY1CZKEKJxiklKZ8e8Vfj9+Mz2xe0KnqvSu45JeSDHL9Ho4txK2fwqJkcq9OkOg7ZdKQcpCRqfTs/NyGAv23eB6WCxHPmmT3og4KVWrXs4SKIUpD30P/psz7r1zEEp7qzeHMEpGGSSVLFmS3377jfbt2z9xf/v27QwcOJCwsLAcLTCvSZAkROF2NvgBE9ZewP9uLKA82v7dKzUMe2or/j7s/AJ8HyV2OyutTWr0LlSJ3Y/o9XpuPUjExckm/brXwiPYW5szokVF6rs7Zf9Jw8xEXIHDc+FBEAzenPH7HXpe2d0zNVNnHmE0jDJIeu+991i3bh0zZ86kcePGABw+fJgPP/yQXr16MWfOHDXWmWckSBJCpGl1LD8cxOydV0lM1WJmouHt5hV4t7UH1hYGJnZv/gDuXVWuK7SELrMLXcXu/7oeHkv77w+k11rycXXkfy0q0q5ayezv3mVGp80oPpkQCd97gW1xaPIe1OoP5gY0QRZGySiDpJSUFD788EMWLVpEWloaer0eCwsLRowYwdSpU7G0fLmKfUmQJIR45HZUIl9u8GPXZWVH3MXJmm+6e9GqqgH5NGnJSmHEAzMhLUmp2N1sHDQdU6iLIt68H89PBwJYdfoWKWk6ACo62/JO84r08CmDpZmKR3E3j8DfAzJqW9k6Q4N3oN6wQnkMWtAYZZD0SEJCAjdu3ACgYsWK2NjYqDFsnpMgSQjxX9v97vLVRr/0J7U61yjFF12rU8rBKvuDRQbAlnFKojFAsUrQZZayu1SIRcQms+JIIL8evUlsUhoAiwbUpqNXaXUnSklQ6lod+RGig5V7FnZQZzA0GQN2zurOJ/KMUQVJb731VpZet2zZMkOGzzcSJAkhniU+OY05u66y7HAQWp0eWwtTxravwqBG5TEzzWYRQ70eLq5RErvjHuZt1ugN7b+DIiXVX/xLJDYplb9OBLPHP5w/hjXE9OGx27GA+1RwtqVEEQMC02fRpoLfejj8A4RdABNzpTilQ1l1xhd5zqiCJBMTE8qXL4+Pjw/PG2LdunUGLy4/SJAkhHiey6ExfLbuAmeCowDwLG3Pd6944eNqwHFNUjTs+Q5OLgG9DiwdoM1EqPuWNHF9THKalqbT9hKdkEqvOmUZ3qwCFQypkP4sej3c2A3hl6Hxuxn3908Ht6bg2qhQJtm/jIwqSBo1ahR//fUX5cuXZ8iQIQwYMAAnp1zoAp3HJEgSQryITqfn71MhTN3mT3RiKhoN9K3vyscdqqY/2p4td84qid13zirXZXyUxO6yL1cx3txy60EC76/05fRNpW+bRgPtPUvyvxYVDQtOXyTMDxYqDyJRrp5SmLJKF2l7YuSMKkgCSE5OZu3atSxbtowjR47QpUsXhg4dSvv27dV7jDOPSZAkhMiqe3HJTNnqz5oztwAoZmvBhM7V6FW7bPb/DtRp4dQy2P0tJEcDGiWhuPXnhapp7vOcCopk0f6A9ER6gPpuTkzs6kmNciq2wYoKUSqn+/4JWqXAKMUqKdXTa/YFc5WO/ISqjC5IetzNmzdZsWIFv/76K2lpafj5+WFnp9J2aB6SIEkIkV3HA+7z+fqLXHtYVbq+uxOTenoZVlspNgx2fA4X/lGubUs8rK30mhz7PHQ9PJbF+wNY73ubVK2ere81w7NMLvx9HRcOxxfByaXK0Sgofx4D1khxSiNk1EFSSEgIy5cvZ8WKFaSkpODv7y9BkhCi0EhJ0/HzoUDm7r6WXltpaDN33mvtga2lAYULA/YrT8E9aprr1kx5Ck76kaW7G53E3ivh9K3vmn5v+r/+FLEyp18DVxysVeqZlxwLZ36Do/OVnaUxFzN2k9JSwMxCnXlEjhhdkPT4cduhQ4fo2rUrQ4YMoWPHjpi8pGe3EiQJIXLi1oMEvtl0iR2XlCOh0g5WfNnNkw7VS2X/CC4tWXlU/cAMpbaSiTk0Hg3NPwQL21xY/cstLCaJZtP2kqLVYWdpRt/6Lgxp4k4ZR5UKRmpT4f51KFFNudbpYGEjKOmlFKcsXVOdeYRBjCpIGjlyJCtXrsTFxYW33nqL/v37U7y4AZ2zjYwESUIINey+HMaXG/249SARgJZVnPmqW3XcihsQ3DwIgm2fwNVtyrWDC3ScClW7yBHcY1LSdGzwvc2SgwFcDVOOPs1MNHSvWYbhzStQrbTKf6ffPALLO2Vcu7dQgqWKbeTPJR8YVZBkYmKCq6srPj4+z/3X0dq1aw1eXH6QIEkIoZbEFC0L9l1n8f4AUrQ6LMxM+F+LioxsWdGwpq7+W2HbxxlFED3aQ6dp4FRB3YW/5PR6PfuuRLD4wA2OBUSm35/9ek1erV1O3cnu+CqV1P3Wg16r3CvppZQT8OoFpiod+YkXMqogafDgwVnaOl6+fLkhw+cbCZKEEGoLiIjjy41+HLx2DwBXJxu+6u5J66oGFI5MSVCO3478CLrUh+1NxirVouWpq6ecC4nipwMB7L8awYGPWuFkq+QP3Y1OopidBebZLQSamQc34dhCOPMrpMYr9wZvBbcm6owvXsiogqSCSoIkIURu0Ov1bL1wl283X+JujNLepJ1nSb7o6omLkwFtnO5dg63jIWCfcl3UDTrNgMrtVVtzQRKdmPpEIvfri45y60ECbzV1p089F4pYqbTjkxAJp5dDyEno+1fGsduVf6GUFziovJMl0kmQlAckSBJC5Ka45DTm7r7GskOBpOn0WJmbMLpVJYY3r5D9Zq56PfitU9qbxIYq96p2VUoGFC2v/uILiHtxyXScc5B7cUoNpCKWZvRr4MrgJm6UdlApyftxSdEwuzqkJSpHcI1GSwmBXCBBUh6QIEkIkReuhsXyxYaL6TkzbsVs+Kp7dVpWKZH9wZJjYd9UpaaPLg3MrKDZeCUvRo7gnikpVcsG39v8dCCAGxHK8ZiZiYZuNcswomVFw2pcZeb+Ddj0PgQdzLhXoSU0ehcqSZK3WiRIygMSJAkh8oper2fjuTt8t+Uy4bHKrkaH6iWZ2NWTckUNOIILvwxbP8z4YexUATpNB492Kq66YNHp9Oy7Gs5PBwLSA9a5fX3oXrOM+pPdPgNH5z2Z5F3CE7r/COXqqj9fISNBUh6QIEkIkddik1L5Ydc1lh8JQvvwCG5US+UILttPwen1cHENbP8M4u4q9+QILkvO34pi1albfNnNE7OHCd3rzt4iNU1PD58y2T8OzUxUMBxbBGd+gdREeN8XHB8WxNTrZWfJQBIk5QEJkoQQ+eXKXeUI7nigsqNRvpgNX3WrTquqBhzBJcXA/mlPHsE1Has0a5UjuCxJ1epoPn0vodFJFLezZFCj8gxoWJ6itipV2E6MUmotVe2ccW/1ULAuCg1HQLGK6sxTSEiQlAckSBJC5KdnHcG1rVaCL7pWx7WYCkdwRd2g4zSo0lG9RRdQSalafj0axPLDQYRGK08kWpmb8FqdcgxtWgF3QwqDPk9kIMz1AfSARikW2mg0uDaU3aUskCApD0iQJIQwBv99Cs7CzIQRLSoywpBClHo9+K2F7Z9D7B3lnkcH6DhFdiuyIFWrY8v5UJYcDMDvTgygxCyfda7GsGYqFvLU6yHwgJK3dG1Hxv0ytZV2NNV6gKkBfQALCQmS8oAESUIIY3ItLJYvN/px5MZ9AMoVtWZiV0/ae5bMfi+45Dg4MB2OLnhYiNICGr+nFKOUXnAvpNfrORpwn6UHA9njH87G0U3wLucIKHWYbCxM1StOGe4Px+bDub+VprqgJHjXHqjO+AWQBEl5QIIkIYSx0ev1bLt4l0mbL3Hn4bFP88rOfNnNk4rOdtkfMOIq/Psx3NijXNuXgw7fgWcPOdbJopDIhCeKgH667gJ7/cMZ1NiNvvVccbBRqThlXASc+hkuroW394HFwzlDToJdCUnGf4wESXlAgiQhhLFKSEljwd4b/HRA6QVnbqrhrSbuvNvGAzvLbB7D6PXgvwX+nZDRC869uVIy4FGXe5ElqVodrWbuS29mbGNhyut1XRjSxI3yxVTaoXv8qTe9HhY0hHtXoVp3JW/JpZ4687zEJEjKAxIkCSGMXdC9eL7ZfIk9/uEAlChiyYTOVelZq2z2j+BSEuDwHDg0RznW0ZhCg3eg5Sdg5aD62guqpFQtG8/d4eeDgVwJiwWUmKa9Z0neaVGR2q5F1ZssIRJWvwUBezPulasHjUZB1W6FNm9JgqQ8IEGSEOJlsftyGN9svsTN+wkA1C1flK+6V8errAHBzYMgpbaS/2bl2tYZ2n4FNfuBiUp5NoWAXq/n0PV7LD0YyP6rEQC817oSY9tXUX+yMD8lv+zCP6BNUe45uELHyVCtm/rzGTkJkvKABElCiJdJUqqWnw8FMm/PdRJTtWg00Le+K+PbV0nveJ8t13fDto/h/jXlumwdpXFuuTrqLrwQuBYWy7LDQXzQzoMSRZTaVEeu38P3VhT96rviaKNSvaXYMDi5VMldSrgPA9Yq7U6gUBWnlCApD0iQJIR4Gd2JSmTKNn82nVMe8XewNmdc+8r0q++aXj06y9JSlCKU+6dBSpxyr1Z/aPMlFCmp8soLl/5Lj3H4+n2szU3pVacsQ5q4G5Z8/yypiUqemVevjMBo97cQ4Q8NR0L5xgU6YJIgKQ9IkCSEeJkdD7jPlxv98L+r5MVULVWEL7tVp1HFYtkfLPYu7Poazv2pXFsUgZYfQ/13wEylXZBCRK/Xs+bMbX4+FMjl0Jj0+62qODO0aQWaVCqW/Zyy50lLhllVIPGBcl26JjQcBdVfKZB/fhIk5QEJkoQQL7s0rY6/ToYwa8cVohJSAehcoxSfdq5mWOPckJOw7UO4c1a5LuahFKKUxrkGeVRvadmhQHb7h/Pop3C3mmX4sa+PupOF+8OxBXD+b0hTykdgVwrqD4M6b4GtAcGzkZIgKQ9IkCSEKCgexKfw/a6r/H7sJjo9WJqZ8E6LioxoURFri2xW7dbpwPcP2P01xCsJyVTuqDTOlardBgu8F8+Kw4GsOn2Lb3p48VqdcgDEJ6cRn5xGCXuV+uzF34dTy5TcpUeNjxv8DzpNU2d8IyBBUh6QIEkIUdBcDo3h601+HAtQGueWcbBiQudqdPUunf3jnaRo2D89o3GuiTk0GgnNPwTLIrmw+sIhOjEVK3MTLM2U4HX54UAmb71MN+8yDGniTo1yKpVjSEuBS+vh2ELotTQjwL17EWJuQ6V2L+3TjBIk5QEJkoQQBZFer2frhbtM3nqZ21FK0cP6bk580c3TsJIBEVdh+wS4vku5tiupJHbX7PvS/pA1JmNWnmW9753063puRXmriTvtPEtmPxE/K/4ZpARPThWh4Qjlz9FSpYTyPCJBUh6QIEkIUZAlpmj56UAAC/dfJylVh0YDb9RzZXz7yhSzs8zeYHo9XN2uBEuRAcq9MrWVqt1SATrHzoVEsfxwIJvPh5KmU35Ul3W0ZkgTN/Ub6+76Ck4th+Ro5Z6lA9R+E+oPh6Ju6s2ViyRIygMSJAkhCoPbUYlM2XqZzedDAShiZcb7bTwY2MgNC7PslgxIflgyYAakKE/V4d1HKUZpX0bdhRdCYTFJ/H7sJn8cDyYyPoVOXqVYOCAX6lYlx8G5v5SjuMgbyj2NifI0Y6ep6s+nMgmS8oAESUKIwuREYCRfb/LD747ySHqF4rZM7OpJq6olsj9YbBjs+QbO/gHowdwGmo6FxqPB3FrdhRdCSalaNvjeplppe7zLOQJKi5ovN/oxuIkbLTycMTFRoYSATgfXdyrBUsBe6DBFyTsD0KaCTgvmKiWUq0iCpDwgQZIQorDR6vSsOhXCzB1XuBentLdoUdmZiV2rUamEAcnYt8/Av59AyHHl2sEV2n2t1OcpwMUM88PXm/xYfjgIUALcQY3d6FWnXPYbHmcm3F/ZDbR6+PPw3EqlfU3dIVB3KNiXVmceFUiQlAckSBJCFFYxSanM23Od5YcDSdXqMTXR8GbD8oxp65H9Fhp6PVxcAzu/UJ6aAnBtrNRXKlNL9bUXVsH3E1hxJIhVp0KITU4DoIilGa/Xc2FQIzdcixlQF+t5/uoLV7YqvzYxA8+eSikBI8hBkyApD0iQJIQo7ALvxfPdlsvsuhwGgKONOR+0rUz/Bga0OElJgCNz4dAcSEsENODTH1p/IS1OVBSXnMaa07dYcSSIwHvxABS1Mef4p22zn2P2PNo0pQny8UUQfDTjftk6SrBUo3e+7RZKkJQHJEgSQgjFwWsRfLv5ElfDlP5tHiXs+LyrJy0qO2d/sOhbyhNUF1Yp1xZ20Gys0ibDCPNbXlY6nZ791yJYfjiIaqWKMKFzNUApAbHB9w7tq5fExkKlo7g7vnB8MVxcDdoUcG8OgzapM7YBJEjKAxIkCSFEhkctTmbvuMKDhy1OWlctwaedq1GphAF1dEJOKPlKt08r146u0O5b8Owh+Uoq0+n06Ynch6/fo//S49hbmdGnngsDG7nh4qTSUVxcBJxeAWVrQ6U2yr3YMOWotcHbyi5THpAgKQ9IkCSEEE+LTkzlx93XWHEkiDSdHjMTDQMMzVfS6ZQdpV1fQezDgomujaHjZCijcu8yAcDuy2F8s/kSN+8nAEo82rZaSYY0dqNRRZUb6wLsmwr7pii/LltXOYrz7JGrjXUlSMoDEiQJIUTmAiLimLzVPz1fycHanDFtPRjQsDzm2c5XiofDP8DhuRn5SjX7QpsvjOqpqYJCp9Oz72o4yw8HcfDavfT7HiXs+GNYA/X6xIFyFHdsoZK8r1N2ILErCXWGKE/GFSml3lwPSZCUByRIEkKIFzt8/R7fbr6E/12leGSF4rZ82rkabaqVyP6uRPQt2P2N0qkelPpKTcZA43fBQuWnswQA18Pj+PVoEKtP36K0gxW7xrZI/3OLTUqliJW5OhPFhStHcSd/zmisa2kP46+qXjtLgqQ8IEGSEEJkjVan5++TIczacYX78Up9pSaVivF5F0+qlTbg789bp5V8pVsnlGv7sko/uBq9pR9cLolJSuVWZCKeZZQ/r8QULU2m7aGWiyODGrvRrFJxdQpUpqXA5Y1w4icoXhl6zMv43pVtUKFVjhP4c+Pnt9H+V7dw4UK8vb2xt7fH3t6eRo0asW3btue+Z9WqVVStWhUrKytq1KjB1q1b82i1QghR+JiaaOjXwJW9H7bknRYVsDA14fD1+3SZe5BP1pwnIjY5ewOWqwNDd8Bry5QClDG3Yd3bsLQN3Dz64veLbLO3Mk8PkACOBdwnMj6FPf7hDFp2graz97P8cCCxSak5m8jMAmq8pvz5dpmdcf/OWfjrDfjeU9lNjL6Vs3lUZrQ7SZs2bcLU1BQPDw/0ej2//PILM2bM4OzZs1SvXv2p1x85coTmzZszZcoUunbtyp9//sm0adM4c+YMXl5eWZ5XdpKEEMIwIZEJTN3mz5YLSj84WwtTRraqxNCm7liZm2ZvsNQkOLYADs7O6Afn2VPpB+fkruq6xZMCIuL47dhNVp+6lV6g0tbClFdrl2NEy4qUcVTxmOzqdtg8FmIeBkcaU6jaWekX59Y0W088FvrjNicnJ2bMmMHQoUOf+l6fPn2Ij49n8+bN6fcaNmxIrVq1WLRoUZbnkCBJCCFy5lRQJN9uvsS5W0pH+TIOVnzcqSrdvMtk/+gmLhz2ToYzv4BeB6YW0OAdaDYerB3VX7xIF5ecxrqzt/n1SBDXwpVaWXvHt8S9uK26E2nTlCreJ36CoIMZ952rQb+VUNQtS8MUquO2x2m1WlauXEl8fDyNGjV65muOHj1K27Ztn7jXoUMHjh6VLVohhMhLdd2cWDeyCXP61KKMgxV3opN4f6Uvryw4zMmgyOwNZlcCus2B/x1S8la0KXDkR5jrA8d/UhquilxhZ2nGmw3Ls+OD5vwxrAHj2lV+IkD6epMf8/de535cNo9V/8vUDDy7w+DNMOKo8gScuQ0kRSt5aY8kx+ZsHgMY9U7ShQsXaNSoEUlJSdjZ2fHnn3/SuXPnZ77WwsKCX375hb59+6bfW7BgAV9//TVhYWGZzpGcnExycsYfcExMDC4uLrKTJIQQKkhK1fLzoUAW7L1OfIoWgI7VS/FJp6q4ZXdHQq+H67tgx+cQ4a/cK+YB7b6BKp2kGGUeuhOVSLPpe9Hq9FiYmtC1ZmkGNnKjloujOhMkRsH9G0qeGii7TXNrKUnf9YeDR3swefIIt9DtJFWpUgVfX1+OHz/OiBEjGDRoEJcuXVJ1jilTpuDg4JD+5eLiour4QghRmFmZmzKqVSX2fdiKvvVdMdHAv353aff9fr7ZdImohJSsD6bRgEc7+N9hJfnXpjjcvwYr+8Iv3ZQkYJEnnGwtmNbLm5rlHEjR6lh75jY95x+mx7xDrD59i6RUbc4msHbMCJAAbp9Skrpv7FYSvefWUvoBJmRzZzKbjHon6b/atm1LxYoVWbx48VPfc3V1ZezYsYwZMyb93pdffsn69es5d+5cpmPKTpIQQuSdK3djmbz1MvuvRgBgb2XGe208eLNReSzNspncnRSt/KA8Oh+0D/8e934D2kwEh3LqLlxkyjckil+PBrH5XCgpWh0A3/SozsBGbupOFBkIp36GM79BUpRyz9QSvHpB8/HEmDsX7sTt1q1b4+rqyooVK576Xp8+fUhISGDTpozmeo0bN8bb21sSt4UQwsgcuBrB5K2X04tRujrZ8HHHqnSuUSr7xSijQpTHxy/8o1ybWUGjUUpBSiv5ezyv3I9LZuXJENafvc2akY2xf1iQ8vD1e6RqdTT3cFan5lJKglLJ++QSCH24CTJ8LzFFKhWeIGnChAl06tQJV1dXYmNj0x/p3759O+3atWPgwIGULVuWKVOU3jBHjhyhRYsWTJ06lS5durBy5UomT54sJQCEEMJIaXV6Vp8OYdaOq4Q/rKlU29WRz7pUo055p+wPePuMkq9087BybVMcWn4CdQaDqUoVpMUL6fX6JwLd7vMOcf5WNG7FbBjQsDy967jgYKPCn4deD7dOwfWd0OrTwlUCYOjQoezevZvQ0FAcHBzw9vbm448/pl27dgC0bNkSNze3J3aVVq1axeeff05QUBAeHh5Mnz4900TvzEiQJIQQeSs+OY0lBwNYvD+AxIe5LJ1rlOKjDgYmd1/ZqnSgv39duVfMA9p9DVU6S3J3HktJ0zFl22VWn75FbJJSc8nK3ITuNcvwZkM3apRzUG2uQhUk5RcJkoQQIn+ExyQxe+dV/jkVgk4P5qYa+jcoz3ttPHCyzWb3eG2q0jNs3xRIuK/cK98E2n37ZEKwyBMJKWmsP3uHX48GpR+xAgxp4saX3Z4uEG0ICZLygARJQgiRv/zvxjBlq396cncRKzNGtqzEkCZu2a/c/Si5+9gCSEtS7nn1gjZfZLlIoVCPXq/n9M0H/Hr0JtsuhjK/X23aVy8FQGR8CnFJabgWM6ypsQRJeUCCJCGEMA6Hrt1j8tbLXAqNAZTK3eM7VKFnrbLZTwCOvgV7voNzfwF6pXJ3/beh2TiwMSD/SeRYRGwyRW3MMTNVqhF9v/Mqc/dco0VlZwY0KE+rqiUwzcafswRJeUCCJCGEMB46nZ51Z28zc8cVQqOVnSDP0vZM6FyVZh7O2R8w9DzsnAgB+5RrKwclUKr/To670IucGffPOdacyWhwW9bRmn4NXHm9rgvORSxf+H4JkvKABElCCGF8klK1LD8cxIK919Obrjav7MwnHas+0cU+S/R6uL5bSe4O91PuObhA68+hxutgYtR1lgu0oHvx/HkimH9OhRCVoLScMf9/e3caXlV5tn38v5OQAU0CGDMAYUjCIPMcCQKBIrS2iLV9UbBUqoJC4HnEOqDUYsVKVCoqIlRA0IrmsVXUKqLMEAahQCwCEkIgAU1QhgwQEjLc74clQXCDWWFnkeH8HUc+7Ju11r42N2Gfxxqu29vFb7o1JfE3nS65r0KSAxSSRESqr+OnzvDyqjT+sfkgxaUGlwt+3bUJfxzchiZ2V6cvK4UvkmDVU5D/jTUW3hEG/QVifub54qXCCotL+fi/WfxjcwYph3K4vWfkeSHpVFEJV/n5nLePQpIDFJJERKq/zGMFPPvpV3z03ywAfH28GB3XgoT4GPs9eIpPw+Y5kDwTiqz7n4iKt9aEi+js2cLFti+/ziXQ34fm11jtIL44lMOIeZsZ1qUxd8Q2p0MTq42AQpIDFJJERGqOLw7lMP2TPWxOt9bwCvL3IWFADHfGVeJJuFPHYN1zsHU+lFmXeug43LoM17C5hyuXynp22Ve8smZ/+esukQ24I7YZ/VteTVhII4WkqqSQJCJSsxhjWLP3OxI/+Yq9R6wePI2D/XlgcBt+3bWJrSekAGuNsFVPwZf/sl57+0LPMdDvQT0JVw0YY9hy4Dhvfp7Jsi+zKC61YsyEGxrz0NBuCklVSSFJRKRmKi0zvLv9MDOXp5Y/Cdc2PJBHft6W+DbX2l8T7psdsHwqHFhrvfYLghvuh9hx4Fu5Xj7iWUdPFvHOfw7xz/8cZv7t7YiJDFNIqkoKSSIiNVthcSmLNlpPwuV9vxTG9VGNmPyL6+gS2cDewYyB/atgxVTI3mmNBUZYa8J1+R14+1x6f3GEMYb8/Hzdk1TVFJJERGqHnIIzvLJmP4s2HuRMSRkAv+gQzoND2hB97dX2DlZWZl1+WzUNcjKtsZDWVufutr/SmnDVgG7cdoBCkohI7fJ1zmleWJ7Ku9sPU2bA28vF8B6R3D+oFWFBNhtIlhTB1gXWDd6nrZvFadrTahvQoo/ni5cKU0hygEKSiEjttDc7n+c+/YoVe74FrNXo/9CnJff1jyY4wGbbgMJc2DgLNs2G4gJrrNVg+NlUCO/g4cqlIhSSHKCQJCJSu209eJzET75iW8YJAIID6jE+PrpybQPys2Hts7D9dSgrAVzQaTgMeEwL6DpMIckBCkkiIrWfMYYVe77luU+/IvXISQAigv25f1ArftOtafmiqxV2bL91v9KuJdZrr3rQ4y7o9xBcXYk15sQ2hSQHKCSJiNQdpWWG975vG/DN920Doq69iocGt+HnHcIr1zZgxV8gfbX1ut5VEDcBek8Af32nVCWFJAcoJImI1D2FxaW8uTmD2avTOPH9wqqdmgbzyM/b0icmxP4B09fAiies0AQQ0Aj6/hF63gP1bN4sLhWikOQAhSQRkborv7CYeesPMH99OgVnSgHoE3MNDw9pS+fK9Fja8yGsnAbH9lljQU0h/hHoPFI9ljxMIckBCkkiInL0ZBEvr0pj8ecZ5cteDGkfxoOD29AqLNDewUpL4Iu3YE0i5H1tjV3TyloTrt0w9VjyEIUkBygkiYjIWYeOFzBzRSpLdnyNMeDlglu7NeX+Qa1o2tDm0iTFhbB1Hqx//lyPpYguVkPK6IEKS5dJIckBCkkiInKh1CP5zPh0L5/tPgKAr7cXI2ObkTAghmsD/ewdrDAPNr1s9Vg6Yz1ZR4u+VliK7OXhyusOhSQHKCSJiMjFpBzK4blPv2JD2jEAAup5c9cNLRjbrxINKU8dhfV/g63zofSMNdb6F9ZlODWktE0hyQEKSSIi8lM2pB3l2U/38sWhHACC/H24t380f+jTgvq+Nm/IzjkEa5+BlMVgygAXdPwtxD8K10R7vPbaSiHJAQpJIiJSEcYYlu8+wozP9pY3pAy52o8JA6IZEdsMPx+b3buP7oPVfz3XkNLlDV1/B/0fhuCmHq6+9lFIcoBCkoiI2FFaZvgg5WteWLGPzOPWOm5NGgTwvz9rxa3dmtjv3p31Bax6CvZ9Zr329oUed1t9ltS9+6IUkhygkCQiIpVRXFrGO/85xEsr93EkrwiAqJCruP/G1vyqYwReXjafXsvcbPVYyki2Xte7Cq6/D+ImQkBDD1df8ykkOUAhSURELsfZ7t2vrNnP8VPWDdltwwN54MbW3NguzN5SJ8ZYS5ysnAbfbLfG/IOtoBR7H/jZ7NlUiykkOUAhSUREPOFkUQkLkw/w6vp08gtLAOjcNJg/Dm5D31Yh9sPS3qXWZbhvd1tj9a+BGx6AnndDvYAq+AQ1i0KSAxSSRETEk3IKzvDqunQWbjjI6WJrqZNeLRrxx8GtiY26xt7Byspg13uw+mk4vt8auzoc+j0I3X4PPjZ7NtUiCkkOUEgSEZGqcPRkEa+s3s+bn2dwpqQMgL6tQnjgxtZ0bWbzHqPSEvjibat1QO4hayy4GfR/CDqPAG+bPZtqAYUkBygkiYhIVcrKPc3s1Wn839ZD5evCDboulEk3tqZ942B7Byspgu1vwLoZcDLbGmsUBf0nW72WvGy2IajBFJIcoJAkIiJOOHS8gJdW7uPd7Ycp+/6b+Bcdwpl0Y2ta211Et/g0bF0AyTOh4Kg1FtIG4idDu1vAy2YbghpIIckBCkkiIuKk9O9O8uLKfXz4xTcYY61zO7RTY/53UCuir73a3sGKTsKWv8OGl6AwxxoL62B17277y1q9iK5CkgMUkkRE5EpIPZLPCytSWbrTumzm5YJbujbhfwa2okXIVfYOVpgLm+dYi+gW5VljEV1gwBRodWOtDEsKSQ5QSBIRkStp1ze5zFy+jxV7jgDg7eXit92aMmFgDJGN6ts7WMFx2PQybJ4LxaessSY9YMBjED2wVoUlhSQHKCSJiEh18MWhHGauSGXN3u8A8PFyMbxnJBMGxNC4gc2+SKeOwoYXYcs8KDltjUVeb4Wllv1qRVhSSHKAQpKIiFQn2zJO8MKKVNbvs27Iruft4vaezRg/IJqIYJth6eS3kPwC/GcBlBRaY837WPcstezr2cIdppDkAIUkERGpjrYcOM7zy/eyOf04AL7eXozoFcn4ATGEBfnbO1helvUk3LaFUGotnUKLvlZYatHHw5U7QyHJAQpJIiJSnW3af4yZK1LZcuD7sOTjxchezRgfH02o3bCUexjWP2/1WiortsZa9rfCUvPeHq68aikkOUAhSUREqjtjTHlY2nrwBAB+Pl7cEduc++KjCA20GZZyDsH6v8GON8+Fpah4iH8MmsV6tvgqopDkAIUkERGpKYwxbEizwtK2jHNh6XfXN+fe/pUJS5lW9+6UxVBmLcpL9EDrzFJkLw9X71kKSQ5QSBIRkZrGGMP6fUeZuSKVHZk5wGWGpRMZsH4GpLxVY8KSQpIDFJJERKSmMsawbt9RZi5PJeVQDnC5YemgdRnuh2EpaoAVlqrZZTiFJAcoJImISE13Niy9cMGZpZGxzRjXvxI3eLsNS/Hfh6XrPVl6pSkkOUAhSUREaouLhaURvZoxLj7afusAd2GpZT/oP/mKtw5QSHKAQpKIiNQ2Z+9ZenHlvvIbvH19vBjRM5L74ivRlPJExvdh6Qc3eLfoC/0fuWJNKRWSHKCQJCIitdXZp+FeXHmudYCvtxfDezZlXHwMTewud5KTafVZ+mHrgOZ9oP/DVr8lB5c7UUhygEKSiIjUdsYYNqUf48UV+/j8+6aU9bxd/LZ7U8bHV2Ih3ZxDVgfvHf8418E7MtYKS9E/cyQsKSQ5QCFJRETqks3px3hp5T427j8GgLeXi1u7NiFhQAwtQq6yd7Dcr62FdLctgtIia6xJd+syXKvBVRqWFJIcoJAkIiJ10daDx3lp5b7yhXS9XDCsixWWYkKvtnew/GzY8BL85zUoOW2NRXSGfg9Dm5vAy8vD1SskOUIhSURE6rLtmSeYtXIfq/d+B1gnf27qGMHEgTG0Dbf5vXjyO9j4EmxdAMWnrLHQ9tDvQWg3DLy8PVa3QpIDFJJERERg5+FcZq3ax2e7j5SPDW4XxsSBrejYNNjewU4dg82vwJZXoSjPGgtpDX0fhA6/AW+fy65XIckBCkkiIiLn7MnK4+VVaSz9MouziWFAm2uZMLAV3Zs3tHew0yfg879bgakw1xpr2BL6PgCdbgcf30rXqZDkAIUkERGRH0v7Np/Zq/fzQcrXlH2fHOKir2HCwBh6R12Dy85N2YV5sHU+bHoZCqwbxglqCjfcD11HQT2bTS5RSHKEQpKIiMjFHTx6ijlr9vPu9sOUfJ+WujdvyISBMcS3vtZeWDpzynoSbsNLcDLbGrs6DOImQvc/gF/FbxhXSHKAQpKIiMhPO3yigFfXpZO09RBnSsoA6NAkiAkDYhjcLhwvLxthqbjQ6rGU/ALkHbbGAhpB7/HQcwwENPjJQygkOUAhSUREpOK+zStk3vp03tycyeniUgBahV5NwoAYftUpAh9vG4/7l5yB//6fteTJiQPWmF8Q9BoD14+Hq0IuuqtCkgMUkkREROw7fuoMC5LTeWNjBvlF1npuzRrVZ1x8NLd2a4Kfj43H/UtLYNcSWD8DvvvKGqtXH7qPti7FBTX+0S4KSQ5QSBIREam83NPF/GPTQRYkH+BEgbWeW3iQP2P6RTGiVyT1fW087l9WBns/hnUzICvFGvP2hS4joc/90Khl+aYKSQ5QSBIREbl8BWdKeOvzTOatT+dInrVESaOrfLmrTwtG9W5BcEC9ih/MGNi/Etb9DTI3WmMuL+jwW7hhEoS1U0hygkKSiIiI5xSVlPLutq+Zu3Y/mccLAAj08+F3vZtzV5+WXBvoZ++AGRute5bSVpwba/sr8jqPJbhdvEJSVVJIEhER8byS0jI+3pnF7NVppB45CYCfjxe394xkTL8omjasb++A36RA8vOw+0PAkFdkCE7MV0iqSgpJIiIiVaeszLB8zxFeWbOfLw7lAODj5WJYlyaMi48iJjTQ3gG/S4UNL5C37V2Cn/pWIakqKSSJiIhUPWMMm/YfY/aaNDakWV23XS5rfbjx8TF0jmxg63h5RzIJDm+ukFSVFJJERESclXIoh1dWp523mG6fmGsYHx9DXHTFljypiu9vGx2enDV9+nR69uxJYGAgoaGh3HLLLezdu/eS+yxatAiXy3Xej7+//fVfRERExDldIhvw6u97sHxSP27t1gQfLxcb0o5xx/zPuWX2BpZ9mUVZmfPndKptSFq7di0JCQls3ryZ5cuXU1xczODBgzl16tQl9wsKCiIrK6v8JyMjw6GKRURE5HK0Cgvk+eFdWPNQPKPjWuBfz4svDudy35vbGTRzLe/8YAkUJ9SYy23fffcdoaGhrF27ln79+rndZtGiRdx///3k5ORU+n10uU1ERKR6OHayiEUbD/L6xoPkFVpdvMOD/Lmnb0tu79WMq/3ONaasU5fbLpSbmwtAo0aNLrndyZMnad68OZGRkQwbNoxdu3ZdcvuioiLy8vLO+xEREZEr75qr/fjj4DZsfPRnTLnpOsKC/MjOK+Spj/cQN30lf/tsL0dPFlXZ+9eIM0llZWXcfPPN5OTkkJycfNHtNm3axL59++jUqRO5ubnMmDGDdevWsWvXLpo2bep2nyeeeIK//OUvPxrXmSQREZHqpaiklPd3fM3f16aTftS6/cbPx4vhPSIZ0SWE9i0j6t7TbePGjeOTTz4hOTn5omHHneLiYq677jpGjBjBtGnT3G5TVFREUdG5FJqXl0dkZKRCkoiISDVVWmZYvjubOWvTy3stuYpPc/D5/+fR728bq8xdGRMmTOCjjz5i3bp1tgISQL169ejatStpaWkX3cbPzw8/P5st0UVEROSK8fZy8fMOEQxpH86m9GPMXZvOui89/6BWtb0nyRjDhAkTWLJkCatWraJly5Y/vdMFSktL2blzJxEREVVQoYiIiFxJLpeLuOgQ3rirF0v/p6/Hj19tzyQlJCTw1ltv8cEHHxAYGEh2djYAwcHBBAQEAPD73/+eJk2aMH36dACefPJJrr/+emJiYsjJyeG5554jIyODe+6554p9DhEREal6TRvZXPutAqptSJozZw4A8fHx540vXLiQ0aNHA5CZmYmX17mTYSdOnGDMmDFkZ2fTsGFDunfvzsaNG2nXrp1TZYuIiEgtUSNu3HaS+iSJiIjUPHW6T5KIiIiIkxSSRERERNxQSBIRERFxQyFJRERExA2FJBERERE3FJJERERE3FBIEhEREXFDIUlERETEDYUkERERETcUkkRERETcUEgSERERcaPaLnB7pZxdyi4vL+8KVyIiIiIVdfZ725NL0iokXeDYsWMAREZGXuFKRERExK5jx44RHBzskWMpJF2gUaNGAGRmZnrsL1kqJy8vj8jISA4dOuSxFZ2lcjQX1YfmonrRfFQfubm5NGvWrPx73BMUki7g5WXdphUcHKx/8NVEUFCQ5qKa0FxUH5qL6kXzUX2c/R73yLE8diQRERGRWkQhSURERMQNhaQL+Pn5MXXqVPz8/K50KXWe5qL60FxUH5qL6kXzUX1UxVy4jCeflRMRERGpJXQmSURERMQNhSQRERERNxSSRERERNyokyFp9uzZtGjRAn9/f2JjY9myZcslt//nP/9J27Zt8ff3p2PHjixdutShSms/O3Mxb948+vbtS8OGDWnYsCGDBg36ybmTirP7e3FWUlISLpeLW265pWoLrEPszkVOTg4JCQlERETg5+dH69at9f+Uh9idixdeeIE2bdoQEBBAZGQkkyZNorCw0KFqa69169YxdOhQGjdujMvl4v333//JfdasWUO3bt3w8/MjJiaGRYsW2X9jU8ckJSUZX19f89prr5ldu3aZMWPGmAYNGpgjR4643X7Dhg3G29vbPPvss2b37t3mT3/6k6lXr57ZuXOnw5XXPnbnYuTIkWb27Nlmx44dZs+ePWb06NEmODjYHD582OHKax+7c3HWgQMHTJMmTUzfvn3NsGHDnCm2lrM7F0VFRaZHjx7mpptuMsnJyebAgQNmzZo1JiUlxeHKax+7c7F48WLj5+dnFi9ebA4cOGA+/fRTExERYSZNmuRw5bXP0qVLzZQpU8x7771nALNkyZJLbp+enm7q169vHnjgAbN7924za9Ys4+3tbZYtW2brfetcSOrVq5dJSEgof11aWmoaN25spk+f7nb74cOHm1/+8pfnjcXGxpp77723SuusC+zOxYVKSkpMYGCgef3116uqxDqjMnNRUlJi4uLizPz5882dd96pkOQhdudizpw5Jioqypw5c8apEusMu3ORkJBgBg4ceN7YAw88YPr06VOlddY1FQlJDz/8sGnfvv15Y7fddpsZMmSIrfeqU5fbzpw5w7Zt2xg0aFD5mJeXF4MGDWLTpk1u99m0adN52wMMGTLkottLxVRmLi5UUFBAcXGxR9fpqYsqOxdPPvkkoaGh3H333U6UWSdUZi4+/PBDevfuTUJCAmFhYXTo0IGnn36a0tJSp8qulSozF3FxcWzbtq38klx6ejpLly7lpptucqRmOcdT3911au22o0ePUlpaSlhY2HnjYWFhfPXVV273yc7Odrt9dnZ2ldVZF1RmLi70yCOP0Lhx4x/9Iog9lZmL5ORkFixYQEpKigMV1h2VmYv09HRWrVrFHXfcwdKlS0lLS2P8+PEUFxczdepUJ8qulSozFyNHjuTo0aPccMMNGGMoKSnhvvvu47HHHnOiZPmBi3135+Xlcfr0aQICAip0nDp1Jklqj8TERJKSkliyZAn+/v5Xupw6JT8/n1GjRjFv3jxCQkKudDl1XllZGaGhobz66qt0796d2267jSlTpjB37twrXVqds2bNGp5++mleeeUVtm/fznvvvcfHH3/MtGnTrnRpUkl16kxSSEgI3t7eHDly5LzxI0eOEB4e7naf8PBwW9tLxVRmLs6aMWMGiYmJrFixgk6dOlVlmXWC3bnYv38/Bw8eZOjQoeVjZWVlAPj4+LB3716io6OrtuhaqjK/FxEREdSrVw9vb+/yseuuu47s7GzOnDmDr69vldZcW1VmLh5//HFGjRrFPffcA0DHjh05deoUY8eOZcqUKR5dnV4u7WLf3UFBQRU+iwR17EySr68v3bt3Z+XKleVjZWVlrFy5kt69e7vdp3fv3udtD7B8+fKLbi8VU5m5AHj22WeZNm0ay5Yto0ePHk6UWuvZnYu2bduyc+dOUlJSyn9uvvlmBgwYQEpKCpGRkU6WX6tU5veiT58+pKWllQdVgNTUVCIiIhSQLkNl5qKgoOBHQehseDVaAcxRHvvutndPec2XlJRk/Pz8zKJFi8zu3bvN2LFjTYMGDUx2drYxxphRo0aZyZMnl2+/YcMG4+PjY2bMmGH27Nljpk6dqhYAHmJ3LhITE42vr6/517/+ZbKyssp/8vPzr9RHqDXszsWF9HSb59idi8zMTBMYGGgmTJhg9u7daz766CMTGhpqnnrqqSv1EWoNu3MxdepUExgYaN5++22Tnp5uPvvsMxMdHW2GDx9+pT5CrZGfn2927NhhduzYYQDz/PPPmx07dpiMjAxjjDGTJ082o0aNKt/+bAuAhx56yOzZs8fMnj1bLQAqatasWaZZs2bG19fX9OrVy2zevLn8z/r372/uvPPO87Z/5513TOvWrY2vr69p3769+fjjjx2uuPayMxfNmzc3wI9+pk6d6nzhtZDd34sfUkjyLLtzsXHjRhMbG2v8/PxMVFSU+etf/2pKSkocrrp2sjMXxcXF5oknnjDR0dHG39/fREZGmvHjx5sTJ044X3gts3r1arf//5/9+7/zzjtN//79f7RPly5djK+vr4mKijILFy60/b4uY3QOUERERORCdeqeJBEREZGKUkgSERERcUMhSURERMQNhSQRERERNxSSRERERNxQSBIRERFxQyFJRERExA2FJBERERE3FJJERERE3FBIEpFa6fHHH2fs2LG291u0aBENGjQofz137lyGDh3qwcpEpKZQSBKRGqO0tJS4uDhuvfXW88Zzc3OJjIxkypQpAGRnZ/Piiy+WvwYYPXo0LpeLxMTE8/Z9//33cblc5a9vu+02UlNTy1/fddddbN++nfXr11fFRxKRakwhSURqDG9vbxYtWsSyZctYvHhx+fjEiRNp1KgRU6dOBWD+/PnExcXRvHnz8/b39/fnmWee4cSJExd9j4CAAEJDQ8tf+/r6MnLkSF566SUPfxoRqe4UkkSkRmndujWJiYlMnDiRrKwsPvjgA5KSknjjjTfw9fUFICkpye0lskGDBhEeHs706dMvevwLL7cBDB06lA8//JDTp0979LOISPWmkCQiNc7EiRPp3Lkzo0aNYuzYsfz5z3+mc+fOABw/fpzdu3fTo0ePH+3n7e3N008/zaxZszh8+HCF369Hjx6UlJTw+eefe+wziEj1p5AkIjWOy+Vizpw5rFy5krCwMCZPnlz+Z5mZmRhjaNy4sdt9f/3rX9OlS5fyS3MVUb9+fYKDg8nIyLjs2kWk5lBIEpEa6bXXXqN+/focOHDgvLNCZy+J+fv7X3TfZ555htdff509e/ZU+P0CAgIoKCiofMEiUuMoJIlIjbNx40ZmzpzJRx99RK9evbj77rsxxgAQEhICcMmbs/v168eQIUN49NFHK/yex48f59prr728wkWkRlFIEpEapaCggNGjRzNu3DgGDBjAggUL2LJlC3PnzgUgOjqaoKAgdu/efcnjJCYm8u9//5tNmzb95Hvu37+fwsJCunbt6pHPICI1g0KSiNQojz76KMaY8n5HLVq0YMaMGTz88MMcPHgQLy8vBg0aRHJy8iWP07FjR+64444KPdq/fv16oqKiiI6O9shnEJGaQSFJRGqMtWvXMnv2bBYuXEj9+vXLx++9917i4uLKL7vdc889JCUlUVZWdsnjPfnkkz+5DcDbb7/NmDFjLrt+EalZXObshXwRkVrCGENsbCyTJk1ixIgRl3WsXbt2MXDgQFJTUwkODvZQhSJSE+hMkojUOi6Xi1dffZWSkpLLPlZWVhZvvPGGApJIHaQzSSIiIiJu6EySiIiIiBsKSSIiIiJuKCSJiIiIuKGQJCIiIuKGQpKIiIiIGwpJIiIiIm4oJImIiIi4oZAkIiIi4oZCkoiIiIgb/x8KWDdTax5/UQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -286,7 +285,7 @@ "colors = {'CU': 'C0', 'NI': 'C1'}\n", "conds = {v.T: 2000, v.P: 101325, v.X('NI'): (1e-3, 1-1e-3, 0.01)}\n", "\n", - "# The SiteFractionGenerator object creates the sitefractions corresponding to \n", + "# The SiteFractionGenerator object creates the sitefractions corresponding to\n", "# a (phase, components, conditions) input. Since we have thermodynamic information\n", "# of the Cu-Ni system, we could use the EquilibriumSiteFractionGenerator\n", "eqgen = EquilibriumSiteFractionGenerator(dbf)\n", @@ -299,7 +298,7 @@ "for s, template in su_templates.items():\n", " x, y, var = template.evaluate(template.mobility_function, {}, eqgen, conds)\n", " ax.plot(x, 1000*y, color=colors[s], linestyle='--', label=f'Su {s}')\n", - " \n", + "\n", "ax.set_ylabel(r'Mobility ($cm^2/s$)')\n", "ax.set_xlim([0, 1])\n", "ax.set_xlabel('X(Ni)')\n", @@ -320,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -336,7 +335,7 @@ "constituents = [['CU', 'NI'], ['VA']]\n", "diffusing_species = 'CU'\n", "\n", - "# Create mobility templates. We'll do three options here: \n", + "# Create mobility templates. We'll do three options here:\n", "# a) no mixing term, b) 1st order mixing, c) 1st and 2nd order mixing\n", "t0 = MobilityTemplate(phase, diffusing_species, sublattice_model, constituents)\n", "\n", @@ -377,7 +376,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -429,7 +428,7 @@ ], "metadata": { "kernelspec": { - "display_name": "calphad_312", + "display_name": "calphad_313 (3.13.12)", "language": "python", "name": "python3" }, @@ -443,7 +442,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.8" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/examples/mobility_fitting/02_mcmc_optimization.ipynb b/examples/mobility_fitting/02_mcmc_optimization.ipynb index 2adcbb1..2642be2 100644 --- a/examples/mobility_fitting/02_mcmc_optimization.ipynb +++ b/examples/mobility_fitting/02_mcmc_optimization.ipynb @@ -35,7 +35,7 @@ "\n", "input_settings = {\n", " 'system': {\n", - " 'phase_models': 'phase_models.json', \n", + " 'phase_models': 'phase_models.json',\n", " 'datasets': 'datasets'\n", " },\n", " 'mcmc': {\n", @@ -49,8 +49,8 @@ " },\n", " 'output': {\n", " 'output_db': dbf_output,\n", - " 'tracefile': 'output/CuNi_trace.npy',\n", - " 'probfile': 'output/CuNi_prob.npy',\n", + " 'tracefile': 'CuNi_trace.npy',\n", + " 'probfile': 'CuNi_prob.npy',\n", " 'verbosity': 1\n", " }\n", "}" @@ -79,7 +79,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -94,7 +94,7 @@ "\n", "fig, ax = plt.subplots()\n", "\n", - "trace = np.load('output/CuNi_prob.npy')\n", + "trace = np.load('CuNi_prob.npy')\n", "ax.plot(trace.T)\n", "ax.set_xlabel('Iterations')\n", "ax.set_xlim([0, 1000])\n", @@ -119,7 +119,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -141,7 +141,7 @@ "def plot_interdiffusivity_datasets(ax, components, reference, scale=1, *args, **kwargs):\n", " datasets = load_datasets(sorted(recursive_glob('datasets', '*.json')))\n", " query = (\n", - " (where('components').test(lambda x: set(x).issubset(components + ['VA']))) & \n", + " (where('components').test(lambda x: set(x).issubset(components + ['VA']))) &\n", " (where('output').test(lambda x: x == 'INTER_DIFF')) &\n", " (where('reference').test(lambda x: x == reference))\n", " )\n", @@ -152,7 +152,7 @@ " T = d['conditions']['T']\n", " values = np.array(d['values']).flatten()\n", " ref = d['reference']\n", - " \n", + "\n", " # Plot Ni composition\n", " x_ni = 1-x_cu\n", " ax.scatter(x_ni, scale*np.array(values), label=f'{ref} ({int(T)}K)', *args, **kwargs)\n", @@ -193,7 +193,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -306,7 +306,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAGwCAYAAAB8crvUAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhU1JREFUeJzt3Qd4lGXWBuAnvffeQ0LvVZpIERR1LWDHZe1lF13UX127a9fVVdHFsliwFxBR0cVC7x1EKQHSe+89mf86L37jzGQmfZJM8tzXNSbzzZeZSUYyJ+c97zl2Op1OByIiIiKyGnvr3TURERERMeAiIiIi6gLMcBERERFZGQMuIiIiIitjwEVERERkZQy4iIiIiKyMARcRERGRlTla+wH6qsbGRmRmZsLLywt2dnbd/XSIiIioFaQ9aVlZGcLDw2Fv33l5KQZcViLBVlRUlLXunoiIiKwoLS0NkZGRnXZ/DLisRDJb2gvm7e1trYchIiKiTlRaWqoSJtr7eGdhwGUl2jKiBFsMuIiIiGxLZ5cDsWieiIiIyMoYcBERERFZGQMuIiIiIitjDRcRkQ22namtre3up0Fks5ycnODg4NClj8mAi4jIhkiglZSUpIIuImo/X19fhIaGdlmvTAZcREQ21JAxKytL/WUu29Y7sykjUV/6d1RZWYnc3Fx1PSwsrEselwEXEZGNqK+vV28U0gHb3d29u58Okc1yc3NTHyXoCg4O7pLlRf551IwXX3wRw4YNw/Dhw/HRRx9Z/cUgImpOQ0OD+ujs7MwfFFEHaX+01NXVoSsww2XB4cOH8cknn2Dfvn0q/Thz5kz86U9/Umu+RETdifNZiWzv3xEzXBYcPXoUkydPhqurq0o9jho1CmvXrkVPUFJSgvT0dLO3yXG5nYiIiHoOmw24Nm/ejAsvvFDVMkiUunr16ibnLF26FLGxsSpomjhxInbv3t3q+5dlxI0bN6K4uBhFRUXq84yMDHQ3Cabmzp2L6dOnqzmNhuS6HJfbGXQRERH1HDYbcFVUVKiskwRV5nz++ee4++678dhjj2H//v3q3HPPPVe/K0GMHj1aBVaml8zMTAwdOhR///vfMWvWLMyfPx+TJk1qtqiupqZGDbw0vFhDWVmZ+h4SExMxY8YMfdAlH+W6HJfb5TwiIqK2On78uGqXYKvvI0eOHEFkZKSKE3oUXS8g38ZXX31ldOyMM87QLVq0SH+9oaFBFx4ernv22Wfb9Rg33nijbs2aNRZvf+yxx9TzML2UlJToOltqaqouLi5O3b983LZtm9F1uZ2Iep+qqirdkSNH1MeOqK+v123YsEH3ySefqI9y3ZquvfZa3cUXX9zkuDy2/N4qKirS9RWZmZm6q6++WjdgwACdnZ2dbvHixU3Oqa2t1T3++OPq97mLi4tu5MiRuv/9739G58TExJh9z/nb3/6mbi8oKNDdfvvtuoEDB+pcXV11UVFRujvuuENXXFzc4nOcN2+e7qmnntJfl//f5DUcPny4zsHBwexr+eWXX+pmz56tCwwM1Hl5eekmTZqkW7t2bZues7jlllvU9y3PWe7roosu0h09elSnSUpKUl9z4MAB/bHS0lLdjBkzdEOGDNGlpaWpY5deeqnuiSee0LXn35O8b1vj/dtmM1wtNQaUYvfZs2frj0m/Grm+Y8eOVt+Plg2TaF+WIyVDZskDDzyglvG0i+lyX2eS/juyxBkXF6cyWlOnTlUf5bocl9uJiMxZtWqVKrWQjUALFixQH+W6HCfrk9WQoKAgPPzww2rlxRy57a233sJrr72msjW33XYb5s2bhwMHDujP2bNnj+rJpl1++ukndfzyyy9XH2WlRi6y2/7XX3/F8uXLVR3yjTfe2OzzS01NxZo1a3DdddcZ7Y6VWmZZ9TF8XzUt85kzZw6+//579f4r/19J2U9bnrMYN24c3nvvPVVH/cMPP6hNa+ecc45+h66pvLw89ViSzdqyZYvKbInrr78eb7zxhmql0mPoemGGKyMjQx3bvn270Xn33nuvyny1lkToEjGPHz9et3fv3jY9Jy1CPnAqQ2ctktky/CtBrhNR79XRDJdkISSrYpphkGNykdu7O8O1ZcsW3ZlnnqkyHJGRkSorU15e3uyKho+Pj+69994zyoB8/vnn+vuR3+HHjx/X7d69Wzdu3Didh4eHbu7cubrc3Fz9fchtkqEJCAjQeXt768466yzdvn37jB5H7nfZsmW6Sy65ROfm5qbr37+/7uuvv27y/fz888/qceScyZMn644dO2b25zJ9+nSzGa6wsDDdf/7zH6Nj8+fP111zzTUWf8ZyP/Hx8brGxkaL53zxxRc6Z2dnXV1dncVzXnjhBfXzautrac7QoUNVpq4jz/nQoUPqZ3ry5MkmGS5ZzRk0aJBu1qxZurKyMqOvq6mpUdlBeS0sYYarB5FsmPx1IVG5RN3tcTSzFFklVZ3+3CSDtnDhQqNjct2amTUisl2SIVi8eLHKGJjSjt15550WMwld4dSpU2rTz6WXXopffvlF1eJu3boVt99+e5vvS+p3JVMkNbyOjo4qm3ffffdhyZIlKhNy8uRJPProo/rzpV7p2muvVY+3c+dODBgwAOeff36TOqbHH38cV1xxhXp+cvs111yDwsJCo3Meeugh/Pvf/8bevXvVY99www1tzoLJZi9DkmGS52ZpVUd6RcrjNNfqQFZfvL291XOyRH4248ePR0fJ6Cn52fn7+7f7OVdUVKhsV79+/Zqs3MjKk6zuSL21ZNU8PT2NbpdedVKnLd9Pj6HrBUz/4pHIVtaZTf8K+stf/qLWg7uCluH6ZMtR3beHMnRFFTWddt+s4SLqmzqS4dKyLy1d5LzOJlkR+Z0smSXDi2SfDDNcUisrNTyGJONlb2+v/55bm+F6++239bd/+umn6ti6dev0x6SeV7Ijlkjdr9Qiffvtt/pjch8PP/yw/rpk3uSYVl9lmOHSfPfdd+qYudfMUoZLarwkO5SQkKCex48//qiyZZKdMkeyefLzldUdS/Ly8nTR0dG6Bx98UNecUaNGNVv71NoM1/PPP6/z8/PT5eTktPk5L126VP3/IT83eY207Jbh6ys/i5kzZzZbfyi1aNddd53F25nh6gQS2UpGat26dUbRtlyX3lpdraFRh52Jhaio6fhasvTZ0nYjajVbU6ZMMarpktst9ekior5JamY687y2kjqbgwcPGl3efvtto3MOHTqkao0kW6FdpHZWfn/LwO62GDlypP7zkJAQ9XHEiBFGxwx3refk5ODmm29WmS0fHx+VCSovL1c1TZbu18PDQ51neD+m52hz+kzPaY5k4eR5DB48WL2fSYZPapIszc585513cN5556k2SebIrvkLLrhAZYP++c9/NvvYVVVVTbJrbSVNwyUT+MUXX6ixOW19ztdcc42q/dq0aRMGDhyoMorV1dVG51x00UUqe9Vc7aFkBWUUVk9hs53m5R+CpIQ18o9R/gFL+jI6Olq1hJD0sKRGzzjjDLzyyisqPSn/03aHmvoG7EoqwJn9g+Ds2P69Cl5eXvr/gQ0L5LVCegm25HY5j4hI09oBvdYa5CvBSf/+/Y2Omf5hKL/Xb731VlWcbUp+rwtZfjJdFjU3msXJyUn/ubZkZXpMAjmNvF8UFBSoYCcmJgYuLi7qD3RZ+rJ0v+bux9Jjm57THCmql96SEmTIc5Kg5P7771d/VJtKSUnBzz//bDHwkGU9WaaV94SvvvqqyfM3FRgYqHpPttdnn32Gm266CStWrLBYYJ/SwnOWgFcuEnRKSyY/Pz/13K+++mqjZVsJbGWpWP5/kKDMlCz1xsfHo6ew2YBL1sblLyaNBFjaPxr5C+nKK69UuxdkjT47O1ut5coODe0vne5QVl2PPcmFmBwXAHv79o0UkP8J5fuQf0TabgyNBF3yF4H8w5LztDV7c+dqv+wMzyWi3mvatGnq94A0cDZXxyWBgdwu53WXsWPHqrpZ08DMNBgxzMKdOHGiU7IY27Ztw+uvv67qsoTUw+bn56M7SaYpIiJCBZRffvml2aBCapzkj2zJYJnLbEmGUILHb775plWZqzFjxqjXoD0+/fRTVZMlQZe559Oa52xK/l+Vi9S1mXrkkUdU1k8yYnKOvO8bkt2Zl112GXoKmw24JJNj7peGIUnDtqfYsiOkEatcLBWe5pfXYH9qEcbF+LV7jpMW/ZtjGFhpXekllW3aLkJrlCr/00sAx6CLqHeTxs2SvZE3INMskfa7SFYCmmvwbG3/+Mc/VEZDfm9LlkSyYvLmL+0D/vOf/6hzpBm1fC7ZJ/k9K1/TUtamNSSb8uGHH6pVEQlU7r33XrUkZQ2yGqNl9CQxINdl6VCW/MSuXbtUYCyJAvkoy4CSIZOif0NyTIIXSTSYFsLL9yDtFCQYleJ0w4bcErRaep0lQJOfvfxsDc+R10GyfZI1kj/ite9BnqO2jCjPQ/4fk8kukugQ8jM0fH9pbOY5S0mMbJSQ5y3PUZICzz33nLoPLRA2JZkueZ4SdMl9a1mw5ORk9bOzlGXrFi1WvlGHi+ZXH0hvcvklreXmcx0lDeDMNUQ1LbrXGsURUe9vfCqtH6TdgmGhvDTFtFZLiLa2hZD2DHPmzNF5enqqwmlp+vn000/rb5ci63POOUfdJs1Dv//+e7NF84aNMc09jpwvX6fZv3+/aocghfxyvytWrFCNOl9++WX9OS0V7Jt7HHkeckyel+H9mF7ksTQbN25ULYmkrYG0qVi4cKHZ4vIffvhBfa20vLD0szV3MXwupqRlhDQJb23TUsMNAOZul9e+tc85IyNDd9555+mCg4N1Tk5O6v/TBQsWGLXVMPf6akX6UoT/8ccfq+vPPPOM7txzz9U1p6uL5u3kP90d9PVG8peERPWfbDkKd0/z9VRDw7wxIMS6tVaGI39k/V/+gpP2EWyUSmR7pKZH6lVlm3xHCpsleyEFx7I0JzVbsozYnZkt6llklUaWIKXxqC2qra1VGUvJuknriLb+e9Lev7U2GujrS4q9wZGsUrg4OiA6wN1qj2FYTK91pRfsSk/Ud0lwJb8TiMyRjQvFxcVq6dAWN2ClpqbiwQcfbDbY6g4MuLrZwfRitWsx1Kdj23BbCroks2X4P59c5wggIiIyJbVVUhtlq/r379/sxovu0itnKdoSWdHdm1KIgvKmOzA6C7vSExERdS8GXD2ANEbdlVSIksqmvWQ6u4ZLtj4bNkjlKCAiIiLrY8DVQ9Q1NGJHYj7Kqjsv6GJXeiIiop6BAVcPUlPfiO2nClBZ2/ERQIZd6U0L5LVCejnOrvRERETWx6L5Lm582pLqugZsP1mAMwcEwtWpY9u029qVnoiIiKyDGa5OtmjRItWRd8+ePer6ml8y0djYtlZnFbX12HGqALX1rZ+9ZYkEU+bG+gg5zmCLiIjI+hhwWdnWkwV4Z2sSauralvEqra5Tw67rGzoedBER9SSyYefOO++0eD02NlaNGSLgnXfeUaNubNWbb76JCy+8sLufRo/AgMvKrpsSixO55Viy7gQKK4ynzrdEzt+TXNTmDBkRUU9y3XXX4ZJLLtFfX7VqFZ588kmL12WF4JZbbrH685LHlWAmICBAzZPU5gMaOnXqFObNm6dm+0nXcRkgnZOTY3ROQkICLr74YgQGBqpzzjzzTGzYsEF/+6FDh9SMPynlkLmAQ4YMUTMHWyKd0GVA82OPPaY/9ttvv+HSSy9VQak8Z3OB6bPPPosJEybo63jlZ3/8+HH97TJnUL7W3GXFihXqnIKCAjWLNzw8XA2/lucuMy61eYxi+fLl8PX1NXrso0ePqnMvv/xy1fFdhlnv379fTTbo6xhwWdngUC/cOXsAquoa8dJPCUgpqGjT1+eWVeNAWnGLg7qJiFoio0pk97I5clxu7wr+/v5GHcxNr0tw4+5uvQkcmoqKChUcPf/88xZvl4BMApH169ertjoSREjGRgYla/70pz+hvr5enbNv3z6MGjVKHdMGOMsxCXxkiLQETNJU9IEHHtAP5LZk5cqVKoAzbFotw6hlw5MMdQ4NDTX7dVKfK+UtO3fuVIO/6+rq1Pch34+QgEjGOhleHn/8cXh6euK8885T59jb26sgUkb8SEApwdXPP/+M2267zeLzlUBZxkRJoCZDqGUgt1wWLFiAV199tdnvtU/o1MmMZHF49Yc7knQzXtig6//gd7rHvj5sdqB1c5fD6dYfdk1EvXd4dXFxsW7SpElGg+w12kB7uV3Os/bwahl0vHjxYovXzQ2NfvPNN3UXXHCBzs3NTTd48GDd9u3bdSdOnFBf6+7urps8ebLu5MmT+q+Rzy+66CI1CFkGXctg6p9++sns87M0EFkGLdvb2xsNMZafj52dnf6+8vLy1Ndu3rxZf05paak6ZunxxN/+9jfdzJkzm/25yfd7zz33WLzd9OdkSW5urno+mzZtsnjO6NGjdTfccEOz97NkyRI1UNrcAPB169apgeP33Xdfk6+Tx3V2dtZVVlbqepKuHl7NDFcX8XJ1wqKZ8RgZ6Yvl21Pw42/ZbcpancorR0JOmVWfIxH1XrJbOTc3t0nTY8PmyHK7nNcTyZLjX/7yF7XsN3jwYJU1kZl/kinau3ev+n0qS16a8vJynH/++Vi3bh0OHDigsi6SmZI5e61VU1OjsluypKaRIceS/dm6dau6LsuRgwYNwgcffKAySJLpeuutt1RGa9y4cRbvW7KJktlrjjzG+PHjW/18m3ssYenxJAMnP9cbb7zR4n1kZmaqJdjp06c3ue2rr77CBRdcgIcffthstlC+h/r6euzatQt9GQOuLuTkYI+Fk6Jx3vBQfHc4Gx/vSm1TUfzRrFIk57dtSZKISNuVrPXf04Ku7du3G02ikNst7Wrubtdff72qnxo4cCD+8Y9/qDqka665Bueee66qiVq8eLF6/hpZ1pOAbPjw4RgwYIAK2OLj49USWWtNmjQJHh4e6vFkKU8CqnvuuUe1/ZFlOCEBmSy1SVAny6ISkL300kuqJY+fn5/Z+5Wfuyy5NVenJsOjJVCSGqqOkKVP2ZAgy5Lys7BUmC8/wylTpjS5TWrPZHk3IiJCLW++/fbbRrdLYCv1Wvfee6/6OZkjX+/j44OUlBT0ZQy4upj845w7PBQLJ8Vgf2oxXt94ChU1rW90+ktGCTKLq6z6HImodzJseixBlrwJGwZbPXmg/ciRI/Wfh4SEqI8jRowwOiZF5lpRtwQCEhxJICGF3VKfJAXdbclwSS2ZFJF/++236uslaJBAaOzYsSrLJSSzJvVSktGSwvDdu3erInXJpmlBmaFff/1V1UZJIXxzuw+rqk7/npcAriPkucljfvbZZxYf55NPPrGY3Xr55ZdV0fvXX3+tNhDcfffdRrfLJoA5c+Zg2bJl6udriZubmwpa+zIGXN1kfKwfbp8Zj+zSalVMn1ta3aqvk3/c+1KKkFdmvWHXRNR7SVD14YcfGh2T6z052BJOTk5Gf7haOqYVs0uwJUtdzzzzjAqEZMlMAjQpem8LCYok0JDl1vz8fPWzysjIUEGqkEL5NWvWqIBGAlgJxl5//XUVYLz//vtG9yU9Gs8++2yV2ZLlt+ZoOyeLiorQXrLEKs9NdkxaylxKYb4EQrJca44U5ssS7kUXXaSWSt944w2jQNLBwQGrV69W3/fMmTMtBl2FhYUqgO3LGHB1MukyP3ToULUltyVxQZ64e85AONjb4eWfT+BkbnmrHqNRp8PupEIUV7btFwcRkdRsLVy40OgHIdd72yB72VEo7SikpYMEWhI4yDJke0nLB8mUSYAlwZcEIELL2mgZL41cN9zJKLsTJSC59tpr8fTTT7f4eLK7T95LJEhrK62eTQJOeb79+vWzeK4sJ8r30ppgSPt+pLbNkNS4SX2XvO/J92j6nCVgra6uxpgxY9CXMeCycqf5lgR6uqi2EZF+bmp5UQKp1qhvbMTOxIJOHXZNRL2bYYG8ZGgkKDGs6epNQZfUbUkQIJkt6YMlRfaGAZCWdZHbtQBBelXJda2dg3jvvfdUewUJGqStg9Qr3XXXXapQXkyePFnVakkgJY8jLRSknikpKUkVkgtZ0pNARLJlsiQn9y+XvLy8Zr8HqU/TivM1kqGT5ygX+VyybfL5yZMnjd6H5LnKUqHUlWmPpy1TauRrNm/ejJtuuqnJY3///ffqe5fnLoHqd999p1pCSBZPeoCZkqDryy+/xMSJE9X3KgGmRjKMcXFxqoauL2PA1QO4OzvitunxmBDrpwrpv/slS2WxWjPsWkYAVdW2b24jEfUd0mfLtEBeiqRNC+kt9emyNVK4LoGQfI9STyXBiyx7GZICesm6aIHRVVddpa5Ld3SNBGFSkyW1YE888YTqofXiiy8aZb6kQF5qxmbNmqV25EmQJDVPUrivLdtJcCVBUFhYmP7S0kqI1FVJ4GPYH012C8pzlIss7clzkc8NgyZZ9pOvkdfT8PGkUN/Qu+++q5YazdWSyZKo1GVJnzL53iXIlEyYLFE2l5WT71V+5hJ0SbAmPv30U9x8883o6+ykN0R3P4neSAo3pcDyky1H4e75R0O/5shLsf5YLr45lIUx0b64ZmK02tnYEi9XR0ztHwgXx44Nuyaink2WZSRzIktEbS2mljdgaY0gy2GmBfJa5ksKvyV46OoZq5Ilktqmp556qksf1xZIRk0CRWl/YYsk0yWBaEJCQo+b3Wvp35P2/i3/ZmRnZmdhhqsHkQLJs4eE4Pqpsfg1owT/WX8S5dUt72Asq67HzsRC1HHuIhFZIG8gEkxJF3LTAnm5Lse7OtiSWiDpoSVvysOGDeuyx7UlL7zwgtohaaskCyc9ynx6WLDVHZjh6kEZLkMyAui/m5Pg4miPW6fHIcTbtVX1YJPiAlQRPhH1Ph3JcPVEsrtNdsfJUpXUCxnuOiSyNma4SIkJ8MDdcwaoJcWXfzqBE63oMp9fXoO9yYWcu0hENkFqo+SPU6ltYrBFvR2XFHuwAE8XLJ7dH1H+bnhjU2KrdjBKXy8OuyYiIupZGHDZ4A7GlvY5pBVW4pf0EovnSSGgpZ1IctxwRwwR9Tzc60Rke/+OGHDZAKnJumpCFP40Mgw/HsnBhztbnsGYXFChgi5LO5VkAKlpzx25LsfldgZdRD2PdPUWbe2WTkRNaU1ru2o527FLHoU6ZQfjnKEhCPR0xkc7U1WX+RvP7AcPF8dmgy6ZdjEy0ld/rKysTG0L13ruaNvDDRsiaudxVwlRz+Lo6KgGAUtPJ3mTMO1uTkSty2xJsCXvhTI9QPtDxtq4S9HKuxQ/23oMrh6du6U3Kb8CyzYnqmDrlrPiEOTl0uz5cYGeGBHpY7HbtMwGk9EetjLElqgvk+yW7FQ07ZpORG0jwZaMfNLmcFq7DxcDLivMUpRLQ0ODavSWnVeI3Gp7pBRWoKGx89aLZXj1fzcnoqK2HjdPi0O/QI92B136c9oRbMn/kJINMzcYVerBZKwEM2VEnUuCLS4rErWfZIgtZbYYcNkY0xesuq5BDaeWZb7OCrwqaurxztYkpBRU4s+TYlR3+ubEB3lieMQfQdf27dvVXCyNzFWTkQy9oXM1ERFRe7DTvI1zdXJQwY7UYUmPrc4gS4p/mxGPUVG+WL49GeuO5jS76+JUXjmOZJbqAyJZRjQk19syvNa0Hkz7WsPsmdwu5xEREfVlrLjsYjLvcHSULybHBcDNqeOFeo4O9lg4KRrnDA1RMxhX7EtvNoN2IrcMG/YdMarhksyW4fDa1gZdsoxoOvhWsmamA3LNLTcSERH1Jazh6saUpMw+lIyTLDN2hp2JBfh8TxoGhXrhuimxKqtmKj8nEw/ddDly0lOMarZMC+llrlprA6XOqgcjIiLqblxS7IVkbI8sB06JD4RnM+0dWkvmKEqTVNnF+Oq6E6p1hCk3d0/4+gUgJDIGy1eu0QdE8lHLVkndlRS7t5Z8rex0NCTXGWwRERGdxgxXD4mQGxt1KtN1PLsMtS00NW1JZnEV3tqcCOiAW6bHIcLXzej2irJSVFWWIzAkHEPDvDEgxKtDOwuZ4SIiot6i1EptIVjD1UPY29shLsgTZw8JUbsJTfuCtEW4rxvunjMQnq6OWPLzCRzLOl0or/Hw8lbBljiSVYqjBrfLMmJ7g62O1IMRERH1Zgy4ehhnR3u1m3HmoCAVOLWXj5sT/j6rvwreJNu141SBxXMTcspwuJnZi5ZINsy0QF7aSpgW0lua20hERNRXMODqobxcnTAh1h8zBgYj1Nu1Xffh4uSAm6b1w+T4AHy2J63ZwdeJ+eU4mFbcpqBLlh6l3su0QL4j9WBERES9EWu4bGQNuKiiFkezS1WH+baSIGr9sTx8cygT42L8sOCMKNVOwhyp9xob7aeWOFuDneaJiKg3KeVon973gsn4ny1btiArKwthYWGYNm1ai0M0s0uqcSi9WHWub6sDqUVq8HVsgDtunNYP7s7md0YGebpgfKy/Wt4kIiLqS0pZNN+7rFq1CrGxsZg5cyYWLFigPsp1Od6cUB9XzBocjNh2dKsfE+2HRTPjkVVSjVd+PoGCcvPZsrzyGmw7mY/K2np0Fgk8LdVyyXG5nYiIqLdiCqOTyeDqoUOHYsKECRbPkaDqsssuaxKAZGRkqOMtBV1a/66p/dvev0t2Qt45Z6DqRv/STyfUHEZzSqvrsDkh32wvr7bSZi5Onz69ya5FuS7H5XYGXURE1FuxhquLU5KyjCiZLEvZHmkHIa0ZkpKSWlxeVPfXqFNtHWROYluUV9dj2ZZEZBZX4y9TYjDCYKi1IQd7O4yP8VeZtfaS71WCKsPdjB3tbk9ERGQNXFLsJaRmq7k2CVLgLoGInNcaEhBJG4kz25jtkh5di2b2x+AwL7yzNQlbTuRZDOh2JxcipQPjhzhzkYiI+jouKXYxKZBv73mSHZPs0Keffqo+ynVNgKcLZgwKVn23WkuK4q+fEovpA4Owcl8GVh/IQKOZthASBErLiJO5ZWgvw1YRktGaOnVqk4wXERFRb8WAq4vJbsT2nNeaInst2yW1XR4WdiCakvYP88ZEYP7YCGw8nof3tyejtt78aKHfMkvxW2b7i9s5c5GIiPoq1nB1Uw2XFMibazJqroZLK7I3PV8b/7Ny5UrMnz+/w7Vdv6QX44MdKYj0c1cNUy0tUUb7u2N0lG+bxw9x5iIREfV0rOHqJSSIWrJkifrcNGDRrr/yyiv6YEsCtMWLF5sNzrRjd955p9HyomG2a9qAIHi5ti7bNTLSF7fP6q+aq0rbiHwLTVZTCyuxJ7lIBXWtxZmLRETUl3FJsRtINkqyUhEREUbHJbNlmq3qaJG9v4ezGg80MMSrVRkp6e911+wB6vOXfz6BZAvF8lklVWo+o6XlR0OcuUhERH0dA65uIkFVcnIyNmzYgE8++UR9lGVE06XBjhTZG9ZpDQnzxuS4ALi0ont8oJeLCrqCvFzwn/Un1VKjOQUVpxukVtU23/WeMxeJiKivYw1XD18Dlh18UiDfEgnYpKdVS6R7/O6kQpRU1bV4bl1DoxoFdCitWBXVnzUwyOx5rk4OmBQXAB83J4v3xZmLRERkCzhLsY++YO0psm/xPhtPt3lILzLfZd6QtIn49lCmGn49Y1AQLh4dDnszS5PS/X5CrL/KihEREdmqUs5S7JvaWmTfqvu0t8O4GD9VVG8ueDIkt188OgKXjo3Apt/bRkjmy5Qc25lYgIziqlY/DyIior6CNVy9rMi+Lc1SpUnq9EFBCPRsOSsly4k3ntlP9eJauuEUKmrqzWbD9qUUdagrPRERUW/EGi4bSklKsCS7EaVAXhqjTps2rdnMlvTvkpYShrscJUiTjJlpkJZWWKmamta0sOtQdi0u25wEN2cH3HZWnCqwN2domDcGhHi1+XskIiLqTqzhsjHWesFaqz3NUmvqG3A0q6zFDJX053pzc6LanXjLWf0QE+Bh9rz+wZ4YFm5+KDYREVFPxIDLxnRnwKUV2lvq39VSoX1uWTUOpBajus5yu4fymnq8vSVJFd5fOyUWIyLMB1YSjI2K9GlzV3oiIqLuwKJ5arWONksN9nLFzEHBiPB1s3gfMvbnbzPi1dLhO1uTsOVEvtnzJFu2I7FAZc/MkYDU0nOV43I7ERGRrWPRfCdbunQphg4digkTJqC7dEazVGdHe4yP9cfYaD/V8sHSOddNjcX0gUFYuS8d3xzMVIXzpmRU0JaE/Ca9vySYmjt3LqZPn64CQENyXY7L7Qy6iIjI1jHg6mSLFi3CkSNHsGfPHnQXKajvrPOi/N1V/y1vC01NpW3EvDER6rL+WK4afm2ubURFbT22nshHpkHbiLKyMuTm5iIxMVE1bdWCLsO5i3K7nEdERGTLGHD1QrJ7UWq0LNVNyfGoqCh1Xmu4OztianygmstoiQRl10+Nxa8ZJXhjo/m2EfWNjdiTXIijWaVqWVOeo7SqiIuL0wdd27dv1wdbclxul/OIiIhsGQOuXsgazVJl+VBmMTbXSX5UlC8WzeyP7JJqLFl3AgXlNWbPS8gpw96UItXxXgI/w6Br6tSpRsGW3E5ERGTrGHD1Uh1plmqJo4M9JvULQHgzxfT9Aj1w5+wBqG/Q4ZWfT6j+XubI0uLWk/lqJ6QEVR9++KHR7XKdwRYREfUWbHzaS/twtbdZamu+RpYDZRZjqoVgSpRV16kGqVml1bh+SiyGhpv/Gbg5OSDCuRIXzZ2jMlsaZriIiKg7sC0EtYsESlITdfXVV6uPLQVb0jBVenjNnDkTCxYsUB/luhw3XJYcHeWLAcGWO8l7uTrh9ln9MTDEE8u2JGL7qQKz56WmpWH2rFn6ZcRt27YZ1XSZ7l4kIiKyRVxSpCbd6U37YmVkZKjjpkGXZK1GRfpaLM6Xuq8bp/bD1P6B+HxPGr77Jcuo831+TiYevvlyZKenICQyBstXfocpU6Y0KaRvrqcYERGRLWDARfplRJm7aDoKSGjH7rzzTqPh1yI20AOT+vnD0d78/0r29na4dGwELhoVjh+P5ODjXamo/71thJu7J3z9AlSw9dSyFSi081JLlRERf+xeDA4OhpcXZzISEZFtYw1XL6/hai0JcGT5sCUbNmxQWSdTJZV12JlU0Ow4oP0pRfhoVyrigzxww9R+agB2RVkpqirLERgSrj8v0NMF42P9kJedpYIt+TkSERF1BdZwUY/uTu/j7oSzBgTB29V8g1QxNsZPjQNKK6xSbSOKK2vh4eVtFGyJ/PLTnel9AkMYbBERUa/AJUXqtO70krGSeq0gT8u9uvoHe6q2ETV1DXjppxPIMOg8b9qZXuYzFlbU8hUiIiKbx4CLOrU7vRTKT4oLUCOBLAn1ccWdcwbCy9URr647gePZ5kf3yIignYkFKhNGRERkyxhwUad3p5dCeRl6PSjUcrG7j5sT/j6rv2qU+uamU9idVGgx6NpxqkDViBEREdkqBlxkte70g0O9Vb8uS1kzFycH3DwtDmf081e7F3/4LdvsLsnahkZsP5WPkioGXUREZJu4S9FKbG2XYke70zcnt6wae5OLVLbKHAmypGXE94ezMTnOH5ePj4KDfdMgzcXRHlP6BzZbmE9ERNQT378ZcFmJLQdc1lBaXYedpwpQ1UzbCFlW/HR3qlqKlHFAkgEThq0jXBwdMDk+QC1JCmmKytYRRETUWdgWgmyaZKXOGhgEX3dni+fI0uKt0+ORmFeBV9efRGlVnQq2nlj0Zzx00+XIy85ETX0Dtp7IR05ptRr7M336dMydO1cFtkRERD0Va7ioy7g6OWBqfADCfNwsnjM41AuLZw9AWXU9Xv4pAal5xSguKkBOeooaAyRBV31jI9bsOIwzp01X439yc3NRVmZ+pyMREVFPwICLupSjgz0mxDa/gzHC1w13zxmglhQ/OFiCm1/4WI3/0YKuYwf3qoxXakoSIqNjVfd7KewnIiLqqVjDZSWs4WpdMb2M+6mpN19MX1XbgHe2JiExvwIXDfbCpw8tVEGXRpvBOGxAnBoF5OTAvx+IiKhjWMNlI5YuXYqhQ4diwoQJ3f1UerxgL1fMGBSMAA8Xi53rb5sehzFRvvjqSClm3vmq0e13PbkEQaHhKnDbnJDHthFERNRjMcNlJcxwtb7lhL29PY5mleFEbpnFthErdpzAttRKlO77FkXrlgG6Rn2GS4IuIa0kRkX6NtvlnoiIqDnMcJHNW7VqFWJjYzFz5kwsWLBAfZTrX331FYaGe2NivwA4m1kWzM/Jwrpnr0fB2tfgNeZ8TH9iNUJi+hsV0ouGRh32pxbhUFqx+pyIiKinYNELdVmwddlll6m+WYYyMjLUcbldZixOH2TcOiI/J1MFVRJceRQcw9Wj/JFZ5Yj4m/+DkPhh+qBLztMkF1Rg68l8VNTU89UlIqIegQEXdcky4uLFi82O7dGO3Xnnneo8d2dHTOsfiLhAT3Xczd0Tvn4B+uXDycP64Y6z+6OkFgj784sIHTJe3S7nGZKB15sS8nAsJbtJkKeR4+zfRUREXYE1XFbCGq4/bNy4US0ftkTaO8yYMUN/PaO4CgdTi1FSUqzvNK8pKK/Bm5sSUV5di79MCMOQ6OAm96c1Ta0oKcTWzZsQExOtv02apspjBQcHY+3atWoqABERUamVJsUww0VWJwXy7TlP+nFN7R8Afz8/o2BLBHi64M7ZAxDq4453dmXhUHpxk/uTIE2apqanJmPKtLNw7GSSUbDFpqlERNRVGHCR1cluxPaeJ/Vc0wYEwtPFscltHi6O+NvMeAwL98F7W5NVawhDEqTJMqQsR2ampags2zc/btAHW3FxcSr7xqapRERkbVxStBIuKf5BarNkN6IUyJur47Kzs1NBT1JSEhwcTg+sNiUzFGW4dWFFbZPbGnU6fHMwExuO52HGoCBcPDoc9nZ2+ttlF6NWeK/Rgq2oqKgOv9ZERNR7lHJJkWyVBFFLlizRB1eGtOuvvPKKxWBLuDg6YEp8oNk5jBJcXTImApeOjcCm43l4f3sK6hr+6F4vfbqkSaqhB/+1FGHhER3+3oiIiFqDS4rUJebPn4+VK1ciIsI4yJHMlhyX21sijU1lDmNsgIfZ288aGIQbzozFb5kleH3DKX1bCMlwvfzIYqNzH7rzNny5+RBbRxARUZfgkqKVcEmx9Z3mm8tsWXIsuxTHs813pk/Or8B/tyTCw9kRlw/1xL//fpVaTpRaLsl0SfClXf/Xuytx3qQRCPIyP16IiIj6llIrLSky4LISBlzWl5RfgV/M7E4UeWU1eH19AgoKi5D9xaPwc6zTjwEyrOmSoOuZd1bi7HFDEGMhc0ZERH1HKWu4iIz1C/TA+Fh/owJ5jWSsbpsaCfvqEoRe8zyuffYj/cxF+ajtXpSmqa5uHjiYVoxfM0rMFvUTERF1FDNcVsIMV9eRbJbsYKxv/KNQXlNUXIxP92YhoaAGl4+LxNT+gfrbZByQdKj38PojZRzq7YpxMX5wNDPTkYiIer9SZriIzJNs1uT4ADiZCZL8fH1x26zBqpfXF3vT8e2hTNVGQuvTZRhsiezSamw5mY+q2gb+uImIqNPwz3jqFfw9nDE1PhAujk3/l7a3t8OlYyNxyZhwrDuaiw93pKDeoG2EqdKqOjWHUcYHERERdQYGXNRr+Lg7YUp/CbrM73qcOSgY102NxS/pJXhj4ylU1p5uG2Gp0er2UwVILai04jMmIqK+ggEX9Srerk5q/qKrk/mga3SULxbNjEdmSTVe+fmE2c71mrLSEvy09zezxfTp6elqyzAREVFrMOCiXsfL1Qln9g+Eu3PT+YsiLsgTd80egPoGHV7+KQFphU2zWBVlpXhi0Z/x0E2XY+fhBOxMLERtfaN++PX06dMxd+5cBl1ERNQqDLioV5LB1hJ0mRt6LYK9XXHXnAHwc3fGq+tP4rfMUqPbqyrLUVxUoHp1Sc+u304kYuvJPBw7maQffp2bm4uyMvPNV4mIiAwx4KJey83ZQbWBkGVGS5mwRbPiMTDEE8u2JGL7yXz9bbKDUevVpQVde3buxMyZM1WwpQ2/ltFERERELWEfLithH66eQwrgd5wqQElVndnbGxt1WHUgA1tO5GP2kGBcMDJM30zVsCu9JjQyBl+u+QFTRg3qsu+BiIi6BvtwEbWT7FqcEh+olg/NOd02IgIXjw7HzyZtI6QrvcxfNHTnk0uQp/PE4XR2piciotbhkiL1Cc6O9qo5aoCH+SHVdnZ2mDU4GNdNOd024vXf20ZIhkuGXRuS63I8Mb9cFdPXNdPTi4iISDDgoj5DOtFL0CWd6S0ZE326bURWSTX+vfYoHrnzVv2Q6+feW21U0yVBV25ZNbaeyEdFjeWeXkRERAy4qE9xsLfDpH4BCPNxs3iOtI24bowPcnOy4Tj7boSOnKYK6AePHt+kkF7mMZZW12HLCXamJyIiyxhwUZ8jNVvjY/wQ6Wc56IoM9IXbrndhV10Mzwv+gZwGD31NlxZ0+foFqOHXoqa+UXWmN9fTi4iIiLsUrYS7FLtXQ0MDtmzZgqysLISFhWHatGlwcDDuPi/d4w+llyCloMLsfUjz09KyMnyfWIvDGSW4bGwkzhwQqG6TzJYEW6bDr8WgUC8MDm16nIiI+u77t/mukEQ2bNWqVVi8eLEav6ORfllLlizB/PnzjQrlR0X6wNHeDqfyypvcjwRTcrk+VIfVBzOwYl86CipqcOGocNWny5Lj2WWqpmtMlJ/KphEREXFJkXpdsHXZZZcZBVsiIyNDHZfbDUnQNTzCB0PDLP8VI0HT/LGRmDcmAhuO5eH97Skt7kxML6pSS4zSA4yIiIhLip1s6dKl6iJLWgkJCZ2ekiTL5GceGxvbJNgyDK4k05WUlNRkeVHI0qIsMZoOqjZ0KL1Y9emK9HPHzdP6qRFCzZHRQhPjAiyOGCIior6xpMiAy0pYw9X1ZNSOjN5pyYYNG9Q8RHMyi6uwL6UIjc0EXckFFVi2OUmNDrr1rLhm20wIZwd7FXT5e5hvvEpERD0HO80TtUAK5Dt6XrivGybFBaieXZbEBnjgrtkDINVZL/+cgKR880X3mtoG2cGYj5zS6lY9PyIi6n1Yw0W9huxG7IzzJGMlQ6/dnJouO2oCvVxw5+wBCPFyxdINJ3EwrbjZ+2xo1GFXUiHbRhAR9VEMuKjXkNYPUqMltVrmyPGoqCh1Xkt83Jxw1sAgeLs5WTxH6rf+NjMeIyJ8sHxbMr7dc9Js/Ze0kJAWE3Lb/tQinMwta+N3RkREto4BF/UaUggvrR+EadClXX/llVfMFsyb4+rkgDP7ByLYy9XiObL0OH+4H+xPbsbPp8rx0ZYElc3SyPifh266HE8s+rMKusRvmaX4NYODr4mI+hIGXNSrSJ+tlStXIiIiwui4ZL7kuGEfrtaQgGpSnL+q27KkpqoCFbs+R8Ha17AnvRxvrDuKmroGFWzJ+B8ZA1RcVICqyj96fUnfr/2pxWg0CM6IiKj36pRdinV1dcjOzkZlZSWCgoLg7++Pvo67FHt+p/m2OpFThiNZp7NUprTgqsQpAMHzHkCQpyvSP3kQOScPqzFAMg5IxgKZkuzZhFg/ODZTpE9ERH24LURZWRk++ugjfPbZZ9i9ezdqa2tVjYrW6+icc87BLbfcggkTJqAvYsDVO8msxANpxWZrtbSgq7DGHsGXPwboGtGw+b948sVXzQZbGmkXMbFfAJwdGXQREXW3HtUW4qWXXlINJt977z3Mnj0bq1evxsGDB1Wjzx07duCxxx5DfX29Crrmzp2LEydOdNoTJupOUf7uaonRXNsICaruenIJ6vKSkP3B/6GxqgxeFz2EQng1e5+FFbXYdjIfVbXsSk9E1Fu1K8N19dVX4+GHH8awYcOaPa+mpkYFZc7OzrjhhhvQlzDD1buVVNVhZ2IBquv+CJIMa7aEnbMbIq74J5wih+HKCVGqv1dzpA3F5PgAeLla3hlJRER9bEmRmseAq/eTjJQEXaXVdUbBltRsSabr5UcWIycjDRHz7oXjgGk4Z2gIzh8RarFthXBxtMeQAEc4NNSopXlTMrbIy8tL/TIgIqJevqRIRFCjfaRBqq6swCjYkgL5waPHq48hEVHIWPU86vZ/hR+P5OCDHc0Pvi4sKsa5c8/DmdPOQlpamtFtcn369OlqmV5+ERARke3ocMAlS4XLly/XX09JScH//vc/viFQnyCF7tOHRyM4KKjJbkT5qIKuyBh4ZR/A1WODcTijBK9vOIXymnqz9yetI4oL85GSnIRpZ03XB13yUeY/JiYmIjc3V21aISIi29HhJcXQ0FBVND9p0iQUFxejf//+6s0gMDAQ69evx6BBg9AXcUmxb5GM04FTmSix9zbbad7N3RMeXt5q7uLbW5Lg6mSPW6fHI9jM4GvD5cno2H749OOPsHDhQhVsxcXFqSHd0jGfiIj60JKiPCGtyeSXX36pAjB5sldeeSUeeOCBzniORD2e/OOcMXYIRkf5NqnRCgwJV8GW6BfogbvmDIC9nR1e+SlBNUA1ZZgZS01OwtSpUxlsERHZuA4HXPKXdlJSkvp8xYoVuO666+Di4oLbbrsN27Zt64znSGQzYgI8MDU+AC6OzQy+9jw9+DrMRwZfn8K+lCKLLSYMffDBB8xsERH11YBLAqy///3veOSRR7Bu3Tpccskl6nhjYyPKy5v+9U7U2wV4umDGoCAEeDRdLjQcfP3XGfEYG+2rCul//C3bqJmqLCvKLkdDVy74M1JSUq363ImIqIcGXLJsePnll2Pz5s147rnnVA2X2LNnD6KjozvjORL1yNFBUkv16aefqo9y3XTw9ZT4AMQHeVq8Dxnnc83EaJw3PBTfHc7GJ7vTUN/Q2KTFxHPvrVYfM1KTMfWs6Uhm0EVE1HeK5h999FFcfPHFGDdunNnbX3jhBVRXV6vMV1/Eovnea9WqVVi8eLHqiaWRnllLliwxOxw7vagSB9OK0dDMoOo9yYX4dHcaorwdcWzZYuQkHjPa9WgYhIVHxWLL5k2Ii+UfNEREvb7xqbSDWLNmjeoif+GFF6rga9asWeo6MeDqzcHWZZdd1mSWolYov3LlSrNBlzRH3ZtciLJq8+0gxMnccry9JRHVRTmoXvcannz5TaMZjFrQ5esXgBfe/RxzRvVTmTQiIurFAZdWpyWF8d9++y2+/vprZGVlYc6cOSr4+tOf/gR/f3/0Vcxw9T6ybCgzRA0zW4a0we2yicTBoWkgJA1PD6UVI6O4yuJj5JbV4M0NJ1BV14BbpvdXuxottZjwcHZUo4CkHoyIiHpxwGXq6NGj+uBr3759OOOMM3DRRRep2Yta64i+ggFX7yO1WjNnzmzxvA0bNqgmpZYk5pXj18zSJlkyTUVNPd7ZmoSUgkpV4zU2xs/ifcluSAm6fNw4f5GIqFf34TI0ZMgQ3HfffSrrJZ2xr732WmzZskUVFhPZOsngdsZ5cUGeOLN/oBpWbY5krP42I1719Hp/Rwp+MNnBaKimvgHbT+ajoLymVc+NiIi6h9XWIoKCgnDjjTeqC1FvEBYW1mnn+Xs4Y/qgIOxPKUZuWbXZHYx/nhSNIC8XfH84G3llNbhqQpQ6bqq2oRE7EgtwRqw/gr1dW/ndEBFRV2pzhquqqgoZGRlNjv/222+d9ZyIeqRp06apGi3TTvIaOS6NgOW81pDlwElx/hgS5m32PuXY3OGh+MvkGOxPLcbrG0+p5UZzZAfkzqRCtSOSiIhsPOCSHVgDBgzABRdcgJEjR2LXrl3622TWG1FvJoXw0vpBmAZI2vVXXnnFbMG8JfJ1A0O8MDnOcnf6cTF+uH1mPLJLq/HSTwnILW2aEROy7Chd62VeIxER2XDA9dRTT6li+IMHD+K9995Ty4WffPKJuq0Ta++Jeixp+SB/eJhuApHMl6WWEK0hS4fSnd7P3dli3dfdcwbCwd4OL/98QrWQ0FSUlardi5pf0otxPLtMfS47KqXwk4iIulebdikOGzbMaOmwsLAQ8+bNw9lnn43Vq1dj//791nqeNoe7FHt/iwjZECIF8lKzJcuIbclsWbzfRh0OphUhvch864jK2nq8ty0Zp/IqcOX4SAwPcsITi/6M4qICfZNUjXttMW67+iIEBwdj7dq1atcNERHZwC5F+cX9yy+/6K9Ln62ffvpJtYMwPE7U20lwJa0fpOWJfOyMYEvdr70dxsX4Y3Co+X/k7s6OuG16vCqQl1FAaw5no7ioUHWgl6ao0hxVyMeFl16AxMRE5ObmoqzsdMaLiIhsIMMlyxOOjo4IDQ1tcpu0gpg6dWpnPz+bxQwXdZQUwB9ILUajmX+i8s92w/E8fHMwE4MCXXDwP39FTspJNQ7orieXqMHX2izG1z/5Gn+aPALOjp3aBYaIqFcqtYXGp/QHBlzUGYoqarErqVD12zLncHoJPtiRggA3eyR9cB9yTvyRaTacxejl6ohJcQEqQ0ZERDYYcMkTkwL67Oxs9OvXD6NGjcKIESPg7u6OvowBF3UWaQWxM7EA5RZaQkgm7L+bk1BfV4sTyxajLjdRHX/uvdUYPHq8cVf6uAD4uLMrPRGRzQVcs2fPxqFDhzBhwgSkpqbi+PHj6nh8fLwKvj7//HP0RQy4qDNJhmt3UiEKK2rN3p6YkoaX1+wHvEKQv+ZFVJ3YaZTh0jja22NCPz8Ee7FBKhFRjy2aN2fHjh34/vvv1eXXX39FeXm5OnbPPfeoInsi6jjJTk2JD0SYj1uT26RA/vnbr0L68ruhyz6K4PkPIfycG5sU0ov6xkbsTCxEWiEbpBIRdaUOF3RIA1QppNe4uLhg/Pjx6kJEnUd2ME6I9cOvGQ5IzD/dh0v6b0lQpRXIP7rwHOzOs8dPmIcI71BkrHpe3f702ysQGHI60yVJ7f2pRaiua8CAEC++REREXaDDGa5//etfePTRR1FTw+G5RNYmnelHRPpgeMTpnlpu7p7w9QvQLx8Gh0XgTyPD8OeJ0XDpPxlRf3kBPsFR6jxTR7JKVZNU7pshIrKBDFdsbKxa7xw6dCiuvPJKTJo0CWPGjFEz5YjIOuKDPOHm5ID9qXZ4dOlHqKos12ewxIR+/gjwdMayzXZw7fcwyhqd4WHmfmQMUHVdoxofJBk0IiKyjg4XzZ9xxhnIycnB9OnTVdG8FNBLACZNUSXw+vHHH9EXsWieuoIU0e9OKkBNfaPZ2wvKa7BsSxKKKmtx3ZRYNSjbHB83J5zRz59tI4iozyu1UtF8hzNcUigvRfKyI1GTnJyMAwcOsPs8kZX5ezjjzAFB2GWhbUSApwvunD0A7+9IwVubEzF/TASmDQhsMny7pKoOmxPyVJd7metIRESdq8MBl7SDqKioaLLMKBeZs0hE1p3b6OniiDMHBGJPUhEKKprWUro6OeDmM/vh60OZ+HJ/BrJKqnHZuMgmS4iSJduRWIBh4d5qyZKIiHpQ0fzixYvxz3/+E8XFxZ3zjIhIb9WqVeqPl5kzZ2LBggXqo1yX403bRgQg0q9p2whhb2+HeWMicNWEKNW5/o2Np1RDVU1FWana8SgVBr9mlGBfSpEapK2N9JLUOhERdWMNl7396ZgtICBAZbQmTpyoareGDx8OZ2dn9FWs4aKOkqDqsssua7KLUFsOXLlyJebPn9/k645ll+J4tuVh1Sdzy/Hu1iS4OTvg5mlx8LKvxROL/oziogKjRqlS1xXmUIHzz52teuqtXbtW1TUQEfVmpT218WlSUhJWr16NO+64AwUFBXjmmWfUMqOXl5fq0UVE7VtGlOyxub+HtGN33nmnOs/U4FBvjI32g71JnZamf7An/u+cgXB0sMfLPyfgcFqBCrZMG6WeTErBjJkzkZiYiNzcXJSVWQ7iiIioG4ZXyy/mgwcPqqL5RYsWoS9ihos6YuPGjWr5sCUbNmzAjBkzzN6WX16DPUmFqG0wv4NRGp9KMf3RrFLMjvPEt09cq2+geteTS/DyI4v11z9b/T9MHzu4SbE9EVFvU9pTM1zbt29XOxUNSXZLCnv7arBF1FFSIN/R8wI9XXDWwCB4u5ofVq0V088cFIyfTpVj4v+9g5DoeBVk3X/9JfpgS5YZSxy81SzHOgvBGxERWTngkqBq165dTY6fOnXKZpYgpPbMz89P1cuYWrNmDQYNGoQBAwbg7bff7pbnR32P7EbsjPM8XBxVG4hwX8vF9BePDsc1E6Pxa24NYm94BfbuvvrbJdOl1XRll1Zjy4k8s+0niIjIygHX8ePHzS5p/Pzzz7j66qthC6RW5oMPPmhyvL6+HnfffTfWr1+v+oq98MILqk6NyNokQxwZGWlxCU+OyzQHOa8lUqs1PsZP1XZZIk1PF47yRVZhGcKufQlOwf3UcVlWNBx+XVZdr/p15ZZWt+v7IiLqqzoccMn6ZlFRUZPj8kawc+dO2AIJGGUZ1NTu3bsxbNgwREREwNPTE+edd16f7ZxPXUv6bC1ZskR9bhp0addfeeUVo35czZGvGRTqpQIrJ4em/+wlqHrzngXIeO8O2NdVI/qGVxE2+eImhfRClhV3JhWq3Y5ERNRFAdfcuXPx4osvNr1je3vU1tZ29O6xefNmXHjhhQgPD1dvGrIj0tTSpUtVbyJXV1fVlkICpc6QmZmpgi2NfJ6RkdEp903UEmn5IK0fDP8fFJL5stQSoiVhPm6n67rc/qjrkv5bElRJcBXo44kHLhmHEVF+cD7rZkSc91fkpKeq2+U8jey1+S3TuF8XERFZsdP8k08+qeYpXnrppaoB6ogRI1BdXY3nn3++U9pCSBd7GRt0ww03mH2D+fzzz9Wy35tvvqmCLfmr/9xzz1VLndI7SIwePVotD5qSbJUEcp2hpqZGXQx3ORB1lPw/f/HFFzfbab6tpDP9WQOCcCi9GGmFlXBz94SvX4C6TevDdW24DuE+bvgOFyDSNwLuR9eo80ylF1WirLoOE/sFqL5eRERkpYBL6khk6fCvf/2rCoxcXFxUcCNbKr/99tuO3r1axpOLJS+99BJuvvlmXH/99eq6BF7fffcd3n33Xdx///3qmLSoaA8JxgwzWvK5BJfmPPvss3j88cfb9ThEzZHgylLrh/aSsT7SqyvAwxm/pNvh0aUfoaqyHIEhp/8AkWzyOcNCEO7rive328Fv2BmotnOBh5n7kjmMmxJyOYeRiMiaS4oiJiYG33//vRpaLRmnb775BgkJCZg8eTKsSZYs9+3bh9mzZxstZcp1GajdURJcScsLCbTKy8vxv//9T2XPzHnggQdUzw7tkpaW1uHHJ7K2mAAPle0KDvDXB1uGhkf44O5zBqJeB/z7xwScyDG/81ibw3gqj3VdRESdluFKTU1FdHR0k+NyzNxxCVhM61A6Q35+vuq0HRISYnRcrh87dqzV9yMB2qFDh9TypdTHrFixQgWLjo6O+Pe//60aUDY2NuK+++5TI4zMkcyeXIhsjY+7k6rrOphWjKySKrN1X3fPGYjl25Px+sZTaiajtJowLebX5jAWV9ZhdJRvk+HYRER9WbsyXDK659Zbb8WePXssniNZnmXLlqmZil9++SV6MmlhkZeXh8rKSjWo1zAzd9FFF6ls3cmTJ3HLLbd06/MkshZnR3u1g3FYuI/ZVhTSz+u26fEqMPtyfwY+3Z2GegtNUKWuS/p1VdayXxcRUYcyXEeOHMHTTz+NOXPmqJ2B48aNU/VO8rm0iJDbf/vtN4wdOxb/+te/cP7558MaAgMDVX1LTk6O0XG5HhoaapXHJOptJEtsWJQ/eexE7E8rUaN/DEnGSrJbEb5u+HxPGnJKq3HDmf3UkGtzdV3Sr2t8rL/qeE9E1Ne1K8Mly2pSrC6/oP/zn/+oLuyyvHfixAl1+zXXXKNqq6SOylrBlnB2dlbB3rp16/THZOlPrlu7foyoN1i1apVqqSLL5gsWLFAfxw4biOIjWxHkZT5QkkzY388egKLKOrz4w3Ek51dYrOvafqoAiazrIiKyzvDqziTF6rKcJ8aMGaMCPXlT8Pf3V/ViUqR/7bXX4q233lJF7tIW4osvvlA1XKa1XV2Jw6vJFoItGWdl+itAW1KUWsbhU8/BsWzzLU5Kq+rw7rZkpBZW4vJxkZgcb76+UUT7u2NkJOu6iKjns9b7d48PuDZu3KgCLFMSZC1fvlx9Llk2GbuTnZ2tem69+uqrqidXd2LART19GVEyW1KzaI4EXbKBJCkpCQWVddifUqQyVqakjktquiSTNbV/AOaPiVCjhMyRZqsyYsjLwjBtIqKeoM8GXLZGut7LRd7QpNi+s18wImv+IWNqw4YNqgdYVW0D9qYUorDC/PQICbhW7ktXmawbpsYadbI3rQMbEeGj2lEQEfWlgKtT+nDRHxYtWqQ2DTS3g5Oou0n9ZVvOky7yU+MDLQZKU+IDcMes/igor8GLPyYgucB8XZeMAZL2E3uTC9VMRiKivoIBF1EfJLsR23qevb2d6q8lrSPM6RfogXvOHQR/D2e8uu6kynpZklFchU3H8yxmzIiIehsGXER9kMxjlBotcz23hByXsV1ynqn+wZ4Y7O+AorymWTJpEXH1MHeMi/RUrSM+a6ZfV0VtPbaezFfd61nZQES9XacHXC+//LL6KH24pI6JiHoe6V+3ZMkS9blp0KVdlx2/5oZkS13DdVfOw+O3Xomy/Gyj2/KyM/HoLVfglzfvwvyRgdiTXKiyXcWV5jNZEmgdySrFjlMFTfp+ERH1Jp0ecMkuQfHggw9i6NCh6rr05XruueewZs2azn44Imqn+fPnY+XKlU3GbknmS47L7eaUlZUhNzcXyUmJKriqK8nTB1sP33w5ctJTUFxUgGEB9qpfV0l1HV74IQEncy3PWcwrr8HG47nILqnm60lEvZLVdylKHy3Jdh0+fFhdtL+qezu2hSBb7TQvy4jmMluGZDi77F5MTExEXFwc/vnvN3DvHbeoYCskMgZPLVuBoNDTw7DLquuwfHuKaoB60ehwzBgYZHEpUwwI9sKQMK9mzyEiQl9vCyHNRgcOHIgRI0aoOYraRz8/P/QlDLiotzMMujShkTF40iDYMtyduOaXTKw/locxUb64+owouDhZDupCvF0xLsYPThZ6ehERoa8HXPLX8vHjx/Hrr7+qi2S1pE1CVVUVhg0bhv/973/oCxhwUV+wfft2TJ06VX/9p/WbYB82CGXV5gdXS0uIT3alws/dGTecGasCK1MVZaWoqixHv5hoTIj1N2qUKo1avby81C9DIqI+HXCZknmKEmR99dVXarh1b+9Pxcan1JczXLK8+PO69Si080J6UZXZr5M6rXe3JaG4sg7XTIzGqChfo2DriUV/VjVgsiwZHhGpMl0SmGmPFxwcjLVr1zLoIqLe3/j0qquuwjPPPINvvvlGjf4wJEOsP/74YzUId8iQISoAkSXG9evX9/pgS7DxKfUFpjVc27ZtUx/l+uyzZyHYvkLNTrQ3U4cV6uOKu+cMVHVaMovx64MZaslRSGZLgi2pBZMC/MyMdOxMLMDPe37TP54U7EvhPhGRLWlXhkuyVrJUKEuGe/fuVUuGsiNRlhek2HbUqFG45557cOWVV7ZYfNtbcUmReitZ1ps+fbo+2JIxQdKzyzQI27RpE9z9glVX+SozLR/kV8/GhDx8czBTNU29dkqs6uNluNtRCvDvenIJXn5ksboe268fNm/apB6PiKjPLSnKX7c//PADnnjiCbz00ktqV6IEY8nJyeoXoxTNa5e5c+eiL2DARb2V/BKSf8eSadKCLY25Zb+a+gbsSylCXlmN2fs7lVuO5duT1ecSdEljVcOgS6Ptfpw4/HR2zNKQbCKiXhNwyZMwLVq97rrrsHz58ibnypKjVkAvgdhHH32EvoABF/Vm8jtAlvWkZ5cpc4Xt8mvmaFYZTuSaXwosrarD+ztOt47408hwzBochOOH9uH+6y/Rn/Pce6sxePR49bmHsyPGRPsiwNPFGt8eEfVhpT0p4Bo3bpx6QgMGDFBZK3liX375Jfbv3686zd91110quBo8eDCXFDv5BSOyZTJD8UBqkb5my5Ac++5wFtYdzcXAAGf88ubfkZN4TH+7aX8v6dM1MMQTg0LYs4uIemnApbV/SEhIUJmrwsJCnHfeeYiOjsaGDRswc+ZMXHzxxTh27Bjc3NxUOwitH9ef/vQn9AXMcBGZb67q5R8Ep/ChqG4w/6tn269J+HxfFhqqStGwYznuvOsefQ2XadAlZFi27GR0d3bkj5yIekfA9eGHH6qlgb/85S+tfgB2mmeGi/q2VatWYfHixWqpURMRGYm/PfAkhk2ZY3Rufk4mHrrpcuSXViH8isfgFBiDeWMjMcizBo/ccoU+6Hr67RUIDPkj6JIGqSMjfRDp596l3xsR9T6lVgq42vQn4b///W+VwTIlbSDq6+tx7bXXWuw0P3HixE570kRkO8HWZZddpv5QM5SZkYGHb78Bryz7ADHjZuqPu7l7wtcvAEABHpw3HtuydFi5Lx1jo33xyBuf48m/Xqlul/MM1TU06gvzR0T4sKCeiHqcNmW4xo4dq+q0TEnxrMxfO3jwIDvN/45LitTXyTJibGysUWbLkNRgSdH9rkNHcTC9FLUNjUad5rUM1v7UIny2Ow3ebk64ZJA7+oX4wcPL8l+dXq6OGBfjr1pMEBHZZONTe3t7FBUVNTkuO5K0uE36bklPriuuuEK1ibjvvvtUPy558tIUtbeTRq/y/U+YMKG7nwpRt5KaLUvBlpDfGdJG4vihPZgxKFjVYgkJpgyXC8dG++GecwfB2cEO7+0vxsGc2iYZM0MyVmhzQh6S8yvM3i6/RC09LzkutxMRdbY2BVy333475s2bh5ycHKPjUjSvYaf5RaoRbF/oqk/UHCmQb+15bs4OmBofiPgg46VCTbCXC+6aMxAT4/zxxd50fLAjBdVmmqlqGnU6HEovxp7kQtTWn86cGfYQk8atEuwZkutyXG5n0EVEna1NNVzSa6umpkbVZc2aNQujR49GY2MjPvnkE9x9993qHKnh0jrNS5F9X+00T9TXhYWFtek8e3s7DI/wQYCnMw6mFuuXGA0L468YH4X+QZ74bE8aXvwxAddNiWm2UD6zuAqFFbUqSxbk5aLKH6Rhq3TDlwat5rrkCzmPA7KJqDO1qy1EcXGxGkYtLSE8PDxUS4jJkyer29hp/jTWcFFfp9VwZWRkmF0C1Gq4pDmy6R9mlbX1qghegiVzcstq8P72ZGSVVOOS0eGYEueHowd3oygvF35BwRg6ZmKT+5Ts2ZAwbzWf0XAEkfxhuHDhwiajioiobyrtCW0h2oOd5tkWgvoubZeiMPxVI8GWWLlyJebPn2/2axsbdTiaXYqTueVmb69vaMTXhzKxOSEf9SkHkLX6eTRWnz43ICQMN937OCaffb7R13i7OqlsV2lBtlFGSzDYIqIeUzRvat26dZg0aRJcXV1V4bwUij///PMqHa/p168fLrzwQjzwwAN9ZqwPEZ0mwZQEVREREUY/EslsNRdsaUuMw8J9MDkuAM5m5ibKLMXwol+Qu+op2AX3R9h1r8IlYoi6rSA3G8/feyt2rPve6GtKq+uw+UQealx88cEHHxjdJpkuZraIyFraneHatWuXagUhS4lz5syBs7Mzjh8/jm+++Qbu7u749ttvMXLkSPRVXFIkMt9pXmq25HdHW+o7K2rqsTupUAVMhvd5ywWTUJCTBQevIARedA9cwgejZNunKNnxheTUEBgchre+29HksWQ49mO3XIHMtNNDswUzXETUI5cUL730UtUmYsWKFUbHKysrceutt6o6iMOHD8PX1xd9EQMuos4lzU33pxQhu7RaXT+8dzseufmKP06ws4fP1KvgM/lK1KQfQf6aF9FQVoAnl32BEeOnGAVbD998uepaHxoZg9eXvYt7Ft3MGi4i6plLijt27FBtIkxJduv9999XSwZvvvlmR58fEZF+l+IZ/fwxINhLXZcCeSO6RpRs/QQ5nz0ER99QhF3/GtwGTDI6T0YHacGWjAh6ctkK2IcOwpIPV6NfXJx+92Jz/cOIiLo04MrLy1P1WWbv1N5ezU777rvv2nv3RERNSLH90HBvVfgeGBxi9idUk/Yrst67AzWpvyJ4/sP4TReh78WljQ4yHYLd4O6PJ976AjGx/RAcHKxqUomIOlO7lxQlqMrOzla/nMw5ceIEpk6dqnre9EVcUiSyrqKKagzqH4e8nGzZAtn0BDs7hE67Ep5nLlRd7P8y+XTPLtPRQYYkAzY4KhgTB0VxHiNRH1Xa05YUhezykeL56urTNRWG5ElKv66+hqN9iLqGn4crXn/tNagGE7+3mdD7/fq1F83CPecMgqO9PV766QTWH8uFm6eX2WBLyPH8WkdsSshDkYUeYEREXZrhkhEYMqxaWkA4Ojpi0KBBGDdunBpwLR+l47wck51EfREzXERd1+vr9jv+jqzMDKPA6cZ7/6nvwyU9u747nIX1x/IwMMQT10yMhq/76dmNzS1fxgd5YHCoNxzsTQI6Iuq1SnvaLkXDpcN9+/Zh//79+otktrTGhgy42PiUyNrk98xP6zdi56+n4OjlZ7bTvDieXYaPd6WqHY9XTojC6KiWd1F7ODtiZJQPgr1crfPkiahH6bEBl6Xu8nv37sWBAwfwzDPPoC9ihouo68mvM+lMfyy7TA2wttTT64u9aTiYVoIJsX64dGykGp7dEqn/Gh7hDRdHzocl6s1KbSngIgZcRN2ppKoO+1OLUFr1R6NUQ/Jrb09yEVbuS4eHswOumRSD/sGezWbQjhzYhfLCPIwdHIdLL5jTpsatRGQ7GHDZGGa4iLpXS7MYRUF5jVpiTMyrwMzBwTh/RKjq92VIxgO9/cJjqqO9RtpJvPzyy7jmKoPGq0TUK5Qyw2VbGHAR9Qy5ZdXYn1KMmvoGi4HZhuO5+O5wNoK8XHDZiAD4OdWpwnsJtmQmY5O2E7/XqC5Z9gEWXX8Ni+qJepFSBly2hQEXUc9RXdeglhjzymosnpNZXIUPtichq7gKdYe/xyOLrsXDN11qlNkyYmenZjV+9NMejIn1Z1E9US9R2hP7cBER2QJXJwdMjgvA0DBv/Q5qU+G+brh+jA/qj/wIxxHn4+mv9qKkrplfkTqdapS6Z9c27DhVgENpxWr3oznyi9vSuCA5LrcTUe/GgIuI+gQJtAaEeGFqfADcnMwXvIeEReCft1+L2h9fQqO9M8KuexVeE+apwdiWaLMakwsqsOFYrlrCNCTB1Ny5c1XvwrS0NKPb5Locl9sZdBH1bgy4iKhPCfB0wYxBwQj1Nt9XSwrin3zuBVSteRrlB/8Hv5nXI2TBc3D0M9+d3i/oj/FmVXUNKtt10CDbJc2hZcSZNhhbC7rko1yX43K7nEdEvRcDLiLqc5wd7TExLgDDI3xgb2aJUYKue55+BUXr30bOx/fDwd0XYde/Bq/xF/+R7ZIarpBw1WTVVEpBhRojlF1SjcjISGzcuBFxcXH6oGv79u36YEuOy+1yHhH1XuzDZSUsmieyDcWVtdibXISK2nr9sbzsTDx88+XISU9R1+0cXeA7/S/wHn8xqtOPoGDta6gvTMc/XnhLPz7Ikkg/NxXY5WZl6oMsjRZsRUVFWfE7JKK24C5FG8OAi8h2yPLfrxklSC2sNAq2QiJjMPuSq/DpGy+isaEBLpHDEHDeYjj6BGG0dxWuvWBaq1pCuDjaq6Ar9ehBTJ06VX9827ZtmDJlipW/OyJqC+5StBFLly7F0KFDMWHChO5+KkTUStLsdEy0H6Kcq/CIQbD11LIVuPzGO/DG11vhFxSCmvTfUPXtk5gc441fKr3x8k8JyCiuavH+a+obsXbXb7j8qmuMji9cuLBJIT0R9U6s4epkixYtwpEjR7Bnz57OvmsisrL4iCDERIQiIjpWBVtSyyVCIqLwrw++VUFYcFAQLhoVhrtmD0Bdow4v/nAc3x/OQr2FlhBCy5plpiUjNDIGn377k1FNF4Muot6PNVxWwiVFItsk7Rlkx6C9ZwB+SZcO9X8EUtJ3y83dEx5ep5shSpD145Ec/Hw0F4GezrhqQhTigoxnMsrXPHSTcdZMArmqohw8cONlSE5KUsHXpk2bEBYWhi1btiArK0t9Pm3aNM5sJOpiXFIkIuoC0mFadgxKI1SZryhF7xrZlagFW8LRwR7njwjDPecMVL29lqw7iS/2pqGq9o8xQhKg+foFGAVb6rhfCB56/XOVTQsIDMKGDRsQGxuLmTNnYsGCBeqjXF+1ahVfd6JegBkuK2GGi6j3yCqpwqG0EovzGLWZjFtP5mPNL1mqs/1l4yIwMtJX3VZRVoqqynIVsJmSDNive7bjlUfvajKzUeuKv3LlSsyfP7/Tvy8iaoq7FG0MAy6i3kWCrV8zSpFeVNnseUUVtVixLx2/ZZZieIQ3Lh0bCX8PZ4vnNzQ04JYLJlmc2ShBl2TckpKSuLxI1AW4pEhE1I1cHB0wLsYPE/tZHg0k/DyccfO0frh+aizSCqvw7P+OqZE/DY3G2SvNkQO7LA/IViMbdaqoXmq7iMh2OXb3EyAisiWhPq4I8AzG0axSJOVXWMxKjY7yxeBQL3z3Sxa+PpiJPclFuHJCJGICPMzOYmyJFNITke1iWwgionb07ZL6rDP7B8LL1fLfrVLLdem4SNx9zkCZBISXfzqBz/ekoaKm3uwsxuYUwwOl1XV8rYhsFAMuIqIODMKePjAYg0K9zM5k1ET7u+PuOQMxf2wE9qcW4envj2JnYgEadTo1izEgJEzNZjTr95mNIQNHq6XJfSlFRgGbYTuL9PR0s3chx+V2Iuo+DLiIiDpARvsMDvXGjEFBCPR0afa8swYG4aHzh6jzP92dhlfXnUR2aS1uuvfx0yeZBl2/X7/x3n/qC+alaF8GY0uPsOq607smJZiaO3cupk+f3qSJqlyX43I7gy6i7sOAi4ioE3i5OmFq/0CMifKDs4PlX63ebk74y+QY3D4zXvXreuHH48jwHYk7n/8vAoJDjc4NDA4zOyBbMmNSP7buaC6OZ5ehuKQUubm5TTrXy0dtYLbcLg1diah7sA+XlbAtBFHfbiFxJLNUDcO2RHpzlZeX4UiJE/73azYc7e1w/ohQeBWfQPqp4wgOj8LYqTNb1QpCasV8GkpxzbzzVHAlnes//PBDNatRu75x40ZERUV18ndK1PuUlpaqBsiSEfb2/qPRcUcx4LISBlxEVFBeg18ySlBaVdck2Hpi0Z9RXFSgus+7+ATh20OZ2J1chFBPR6R8+ZwKoB5d+pFRZ/uW1BTn4r7rL0VKcpL+GIMtorZhHy4iIhssqp8xMAgjInzUzkaNdJ2XYEvmK8pQ65qSPFwzKQbXjfFDZsopuJx7DyqGXojswrYVurv4BuOvj71sdEwyXeYyW9JwVbJen376qfoo14nIeljDRURkRdKTSwZaz1JzGd3VMdl1KJktma+oBV3HDu7Fm/csQNrbt6Nux4fwGTgRb+wuxPeHs5odKWQoLzsTLz+y2OjYn/+8sEkhvcxn5NxGoq7FJUUr4ZIiEbW0zCgBkgRbEnRptCHXXgEh+OlIDjYcz4OniyMuHBWmOt1baj9heF9yH3c9uUQFX3I9MjoW69avx8D4firYuuyyy1QHe0Oc20h0Gmu4bMTSpUvVRdLzCQkJnV50R0S2T4Kd5IJKHMsqxS/7duP+6y/R3/bce6sxePR4/fX88hp8czATh9JLEOXnhkvGRKB/sGeTAdgP3fRHsCUBW1BouFEQFhoZg2Wff4NbrzgfmRkZZp8X5zYSgTVctmLRokU4cuQI9uzZ091PhYh6KAls+gV6oL9HDV577E6j2yQrJYGSRnp73XBmP/x9Vn/1da+tP4m3tyQip7Raf46buyd8/QKMgi0hH7WlSx+/AOzce8BisCU4t5HIeljDRUTUDaSuau6cs5GRmozYfv3w6iffGtV0GQZdIj7YE3fNGaB6eGUUVeG5/x3Dir3patyP7GSUHY1Pv/1HsKWR63Jcbq+qKG/Vc+PcRqLOx+HVRERdTEbtaA1JtbYNERGRGDkoHlddfB6yfw+6JFCSAnuN1G9JHdfISB9sTshTNV67kwsxa1AQZg4ORqCFFhLafbR2bmNYWFgnfadEpGHARUTUxby8vBAcfDr4MWxIOn3sEGzcsAGzZs2Cl6+/Wio0R1pMnD0kBJPiAvDz0Rz8fDQXW08WYO7wEEyOC4CjhU732tzGgtxsWT9seoKdHcLDI3DmmWd25rdLRNylaD3cpUhEzZENNTJqJzIy0mwGrKLREanldqisbTqo2lRhRa3qVr8nqRD+Hs44b0QoxkX7wd6+6Y7GHeu+x/P33nr6imHQ9fvuRxkldO4FF2NgqBfCfVz1uxeJ+opSdpq3LQy4iKijGhp1SMgpw8nccjU/sSWZxVWqb9fhjFKE+rjighGhqumqadAkQdfbLzyGgpwso2VHGZJtOLfR29UJA0I8EeHrxsCL+oxSBly2hQEXEXWW8pp6/JpRYrQzsTnJBRX47pcsJOSUI8bfHeePDMOgEE+joEla1xw5sAtFebmqtkuWGy3NbZQ+YANDvBDpx8CLer9SBly2hQEXEXU2Cbgk8JIArDWOZ5fhu8NZSCmoRFygB2bGeyPcvcGoEN+wl5fUjDU3u9HD2VFlvKL83M0uV0oQt2XLFrXLUQrvp02b1qrh20Q9CQMuG8OAi4isobFRh8T8CrXUWNfQ2OL50lvrSFYZvjuUjoySWjTmJODac8/A+MGx+nO0BqnSy6s1A7PdnBxUmwrJnmkF+tLBfvHixar+TCP1aUuWLMH8+fM79D0TdSUOryYiIpVZkk7zMpsx2v/0bMbmyDLisHBvXD/GB7Ub30Q9HPDhwWK8tPY3nMgpQ25Whr4bvQzUlsHaLamqa1CZNtkhKYHfFytWqnFBhsGWyMjIUMclGCPq6zhL0UqY4SKirlBUUYvDGSUoqqxt8Vwtk1XqFo7AGX+BvX8UGnNPIm/9e/BpKDbqUt9asox46wWTkG9QgG+I44LI1pRaqYaLneaJiGyYn4czpg0IxNhoP7g4Nl8vpY368a7KRNqyvyJ35eOoq29EyFVPI/6vbyG30aPJUOuWSOG9pWBLcFwQ0WkMuIiIbJxkkaL83XH2kGDEBxnvRjQXdN315BL1edWpPcj+8G5cENkAZ2cX/HdzEl744Tj2pxSpWrHWkF2OrcFxQdTXMeAiIuolpAP98AgfzBgUhCBPF4vLijIg29CXz/8dC4a5445Z/eHl6oT3d6Tg6e+PYvvJfNS3UJjPcUFErcOAi4iol5GGpVP6B2J8rD9cnRya1HBJgbwMyn7uvdX6gdmP3HIFfBpL8dcZ8bjnnIGq59YXe9Px+LdH1MxGSx3vtXFBWqf6JuzsVBuK+uBBSCusbHXmjKi3YdG8lbBonoh6AslQSQPUXb8m4IEbL9MHW1qBvGkQZjgwW/p+bTiWi93JRXC0t8Pk+ADMGBik6sbaOi5I62AvdWYSzMUEuKtsGlFPwz5cNoYBFxH1JJm5BTh37lzk5eU12Y3YUh+ukqo6bE7Iw7aTBaipb8CYaD/MHBSk6sbaOi7IkMx9jPH3QLivq8WB20RdjQGXjWHARUQ9jWxzT87KR6GdF0qr6trcab66rgE7EwuwKSFfDcyOD/JQ9WL9vO1QU1UBv8CQJuOCivJzWrxfR3t7FXRJABfg4cy5jdStGHDZGAZcRNRTSauG9KIqnMgtQ1l168YEmQ7Vlt5fG4/nISm/AnYVBag9uh4P3vlX1V2+vR3shYezowq8ZNnRw8Wxzc+NqKe+f/P/ZiKiPtpGQoKazJJq1S3eNOPVHAd7O4yO8lWXQydSsOzLvXAcMw//2pCOCTEVOGd0DOwrC/W1YUI62Lcm4Kqorcex7FJ1CfR0Uc8x3NdN7cBsL3njLCsrMwoGNdId38vLS73BElkTi+Y72dKlS9VFui8nJCR0eoRMRGQN2SXVOJ5ThuJWdKw3pTJZf78J1SEj4DPuT7Bz9UJD5hEUbF8J79pcPPXfL9rcwd40wAvzcUWYjxuCvFzaFHzJ7+C5c+ciNzcXGzduRFRUlP62tLQ0zJgxA8HBwVi7di2DLlK4pGhjuKRIRLZIdiYezy5r1aggQ/rdjlkZ8Bg8DV7jLoRL2ED4uNhj2qAQTIrz75RdiZKd83d3Roi3C4K9XOHj3vx9SgZr+vTpSExMRFxcnD7o0oIt7fimTZvMZsCo7ym10pIiM1xWwoCLiGxZrgReOWWqOL61jh3ci/uvv0R//e7XVyPNPhgHUosg7bdkCXJqfADigjw6rTBe2kxI1ivYy0V9NOw7pjENrj788EMsXLiwSRBGJBhw2RgGXETUG+SWnc54tRR4Gfbz0mj9vtz9grE7qRBbT+Yjv7xWZaemxAdgQqx/pxfGe7s5IcTLFaE+rvBzd9IHdoZBl4bBFpnDgMvGMOAior4SeJk2T5VZjTI+yLTJaqNOhxM55dhxqgC/ZJRAQqFRUb4q+IpvZ9ZL6mVNW1E4OJzOcrk42iPY2xWh3q4I8XbFrp07MHXqVP3Xbtu2DVOmTOngT4Z6m1IuKdoWBlxE1FuXGk/kliO/vEbfv+uhmy5vUwd7UVZdh91JRdh+6nTWK9DTGZPiJOvlB1934072lphrtipjhm669/EmzVaL87Lw8E2XIz01WX+MGS7qyvdvtvYlIqJWk4zR1P6BmDEwGJF+7nD38FJ9tgyDLSEf5bocl9ul+akhKaA/e0gwHr5giBqa3S/QAz/8lo1/fnsEb21OxMG04mYHZ2vjhAyDLVGQm62Oy+0aCf7+ccNlKtiS5/OfT9cgOrafWl6UZUZZbiSyNhbNWwkzXETUF0j3+UOnMpGQlgvvoNAmt7emg72mqrZBFdjvTCxESmEl3J0dMC7GT9V6Rfu76ZccZRnxlgsmNQm2jAZmB4fhre92qE73ljJwj9x8ObLTUxDbrx+2bN7MXYqksPEpERH1OLIrcOLgKIwfGIm0wkok5pcbda83XEZsiZuzA6b0D1QX6Qu2O7kQe5OLsOVEvqrDmtDPD+Oi/ZB+dK/lYEvodCrQk9quuEHDVYZNmGbgnly2Qi17unj64UB2NWpdylXWztmRiz/U+ZjhshJmuIior44Nyiurwam8ClVo31GNjTrVnkJ2Oco4ofoGHQIdqnD02/+i8vg26GorLX7t3c/8B2eddwkqykpVp3tzwZ9pBs7ezk7tcIzyc1e7KTurfQXZDhbN2xgGXETU15XX1CM5v0Jlvmqbqcdq0/JlWjE2Hk5GRqUd0FCPypO7UXF0E6pO7QUajMcTPbnsC4wYP6VDPb600UKGLSaodyvlLkXbwoCLiOiPYdcZRVVILqhocwd7c6SG69bL56I2aAjch5wFl9D+aKypQGXCDlQc3YzqlEMIDApRNVxai4iOcnawV41Vpb2EpQar1DuUMuCyLQy4iIjM/G6srkN6YRUyiqtQWftHrVdbabsUhaNfODyGTIfHkLPgFBCJhsoSDPR3xHmTRyI+yBP29p2fmfJxc1LDtYO9XRDg4aLmPVLvUMqAy7Yw4CIial5BeY0KvCT71Z4lR3N9uIKHTMKYKxcj1z5ANWn1cnXEqEhfjIn2RVygh1WCL6n7CvBwRqCMF/J0gS+XH21aKQMu28KAi4io9UuOWSVVSC2oRN7vDVU72mleivdTCytxILUYB9KKUVxZB08XR4yM9FEzHfsHe1otK+XkYK+yX9LMVZYfO2NoN3UdBlw2hgEXEVH7Cu0l8Dqako3i0pJW7SxsSePvwdehtBJVdF9QUat6fI2I8FEB2KBQLxUkWYvUe0kAJtkvCcCk/QX1XAy4bAwDLiKi9pGRKnPnzkVWdg7+8/HX0HkEqKBJaCODpLfWo0s/anXQpZHMV3pRlepkL20mckprVN+toWFeGBHhi2Hh3kYBUXOzGtvLw9kR/p7OCPRwUR8l80Y9BxufEhFRn1BWVobc3FykJCdh8cJL8OPP62HvFYh9R07o5zMK6a3V1oBLWjtE+bury4WjwlWD1V/SS/BLRjE+3Jmilhn7B3liRKQ3apL24dOXHmnVrMa2qKitR0VhvWqXIRztgLSj+1BVnI+4mEjMPXsmXJy5DNnbsPGplTDDRUTUfjLfUOYcyrxDGTL94YcfYuHChep6VEwsnn/3S7j7h3Tqj7iooha/ZpaoAOxEThl0sENN9klUndyNqpO7UJtzSo0NEv944a0OBV0tDeC+46GnMW/ePAR4yi5IZ7ah6EJcUrQxDLiIiDov6NJI8LVx40ZERUWhuLJWLQ9mlVR3qMWEKTWr8ZKZqPKKhHv/iXCLGwd7V0/UlxWg6tRuVJ3aA4/KXLz1zaYOLS/qW1v8vlyqZyaok2VHCb6kAau0pJBCfLaisA4GXDaGARcRUcdt374dU6dO1V/ftm0bpkxp2j1egq/M4mpkFlepJbuOOLx3Ox65+Yo/Dtg7wCVy6OngK/4MOPmHo7GuBtE+jpg0JBpDw7xVMNQWbRnAbS6ok6VRLxdHeLudDsC0QMzRisX/fUWpldpCsFKPiIh6bIZLlhENyXUtw2XI191ZXYaGe6Osuk7Nc5SL7Eisa2OPLymQN9LYgJrUw+pStP5tOPpHqMArZM4CrNqfgZW6DDVce2i4F4aEeat+X+YCH8OZjlKI39oB3ObGE0nxvzSRVY1ki4yDMOkDJj8LCcK8XZ2s0nuM2o4BFxER2VQNlxw3F3RpZLlNLnFBnmr4tYwTyi2rQXZpNUqrjOctmiO7EZtTX5iBssKvcPEtV6P/yBFquPZvmaXYm1yE9cfy4OJoj4Ehnir4kou/h7MKtp5Y9GcUFxXgqWUrmgZ1FrT2PNMgTNpgaE1ZT2fAJCB1gp8Hd0V2FwZcRETUo6SnpxsFW1pwJR+14/Jx06ZNiIyMbPa+JLujCs89XVTwU1FTj5zSarU7Mb+iVgUppqT1gxSuF+RmN62vMlju01pESCNVuUjrClnSPJJZhqNZpVi5Lx2NOiDE2wWx3vYodQ1Gbvavaqflwjv+0aqfRUvBX0vkOUnAaTjDUgLC0xkwZxWMebo6wsPZgcO5rYy7FK2ENVxERB3rwyWtIUwzWVrmKzg4GGvXrlW1Nu1VW9+ogi8JkiQDpvX6Mp3VaBR0tWGXohTyJ+SU41hWKY5ml6lu97r6WlSn/QrHwiRUJu5HceKhdtVwtVZr+4hJJkxXWwG7umr0i4lWvcjcnBzU7kj5KMubUs/UkZ+3rWDRvI1hwEVE1LGgS/pxmctgSQbMy8urU9/8pc5LLTuWVKvar5r6BrMtG6T+6sZ7/9nmlhCSSZMmq3sT0rF2yy7YBcXD3skV9eWFqE4+iOrkA+pjQ0VRp7WesNRywlwfMdMlz6DQPzr8S7PZR26+HH4BgXhl+RcICfCHh4ujPig7HZjZ95oMWSlnKdoWBlxERLbpdC1UPfLKqpFVVIktW7agIC+n0zrNHzu4F/ffdDlcI4fCNXYMPPpPgGNgjLqtNi8ZdrkncfbkMfjTnBlwcXKwessJIRmsh2463VQ2JDJGH3Rpnf2140+/vcLsuCUJtmSpUkYmycXNyfH05y5y3RHuTg42U7zPgMvGMOAiIuodZOlRMl8ZxVVquLa5uq/WMgxgNCER0bj89geRU+OCYkc/5Na7obiqTvXZig1wx8AQLzXvMdrfvVW9t9rbcsI0uLrrySV4+ZHFTYKw9rCzs1OZMKkVc3dxVH3FvN0c1S5KWbbsSRhw2RgGXEREvW95U4KvrJIq1fMrv7wGudkZrR6k3dqARgI6Wd5MyCnD8exynMwtQ1Vdo8ogxQd7qh2QEoSF+biq2qsW+4hZ8OSyL5q0nDAbEHYw2GqJi6ODPviSIn7pLSbtLborI8Y+XERERD2ggD8mwENdTiWl4PZLroS3XwAefu1DuHp4WbwfWbIzDLa0AEY+asflo7ZkF+Ltqi7TBgShoVEGbleq4OtEbhnWHMpCfWOmyhINCPbEgBC5eCHI01llkjrSckKekwSC919/if6YXLdWsCWkXi6vTC410KieYq6nM2GqTky/VHm6kN/Jwd7mOu2zLUQnW7p0qbpISpeIiHrHIG3T/l+yW/Kc2bOQmpyEOHs7TIx0h7OPv9rxKMXx9Y3GzVYlC+brF6A+N8wWGQZdcrucZ0oCCy3IO2dYiCrwT86vUDsgJQumtZ/wdrHHoDAfuLmEwcE7CA2leW1uOSEZLsm6GZLr1sxwWayjq6prtm+aZPck8HJ2PP1RuzjLx9+PyefOjr8fd7RXWUL5vDuwLYSVcEmRiKj3N2E17BOmkYxUbtnpdhPZJX8EX4ad5s1lwFq7NGmqsKgYzzz1JKo8whB5xlzklNdDqszqirNRk/oLqlN+QXXqYTSUF3RbDVdPIkGYq2TMnE4X9Ls4aUGaBGN2qKmoQHRYYKeP9mHAZSUMuIiI+s4gbUsk+JJeX1JwL4X3hr2+OovpDsMHX/8cuw8n4Pv1W+EaMxLOQbHqvLrCDBV4Vacdxk3XLsSsc+Z22i7F3qSyvAwLpg1hwGUrGHAREfXNQdqWyFKgtttRiuI7stvRlLns1HP33ITignzYu/vANWo4XKNHwiNuDOx9TwdMwV4uqv6rf7Anwt10ePn/rrPYh0tb8nx06UftysLZEgZcNoYBFxFR79HeDFdzheJZxdVIL6pCQcUfxeIdYanlxMK/34/GhkZ9H7GK2kaczCvHiRzZAVmugj8R5OGEaB9HDI8NRv8gT7VbsLVLntZaLu0ODLhsDAMuIqK+WcPVVlW1DSrrJTVfhjMP291U1WCH4XPvrcbg0eOb/ZqSqjqcypUdkMYBmMyAlOyXBF/y0TAAa0uXelvLjlVaaUmRuxSJiIi6YJC2JdLyQAU2wZ5q/qL0+JIArLiNwVd7dxhK76uxMX7qYhiASRZMArBtJwv0S5Da85SLfJ2QzJYEW1prC3P1X9p5thBwWQuL5q2EGS4iItvXVYO0LS07FpTXqkt+RU2zLRKsucNQHlcLvuQibS9EkARgv2e//OzK8a/br+oVOxwrWTRvWxhwERH1Dl09SNsS6XIvo4VO9/qqVjsgu2OHYWn17xmw3AoVgGWXVqvjfm4OyDu8GcVHd6idkA1lBTYXbAkuKRIREXUDCaYsBVTtXUZsD2ncGeHrpi5auwkZM1Rb6d3upqrtISN4xkT7qYsoq67DiZwy7D5yCtX9RsGx/+mdnHVFmRgRG4rkKlc4VtTCz8MZfRmXFK2EGS4iIuoKjY06nMrIRWJWPnTu/qipb+zSXYI71n2Pt194TD8s297NW7WhcIkeAc/4sbD3jVDHAzyc1fKjjCNSy5A9NADjkqKNYcBFRERdTXp7FVTUqnYTGUVVTUYMWSPYev7eW+WBLZ4TEj8Uf37sTeTWOqudkFkl1cYBmMyCDPaEr3vPCMAYcNkYBlxERNSdpNGqBF0phZVt3vHYGjIz+JYLJukzW+bYOzigsaHBqIasvKb+9xqwcqMALNDTWZ/9kmHc2i7IrsYaLiIiImo1GdIcG+ihLhJwJRdUIr2oUl9s31FHDuxqNtgSEmz5BYUY1ZB5ujhiVJSvuojy6nr9LkgJwHYkFup3QUoApoKwEE9VO2bL2IeLiIiol5PlutHuzhgW7q2WG5PzK9Ruw44oystt1XmX3XA7ZlxwqcUaMk9XR4yO8lUXrQhfdkCeyC1TQdj2U6f7gIV6u6rlx7hAdzRkH0NVYa6+e77hEO6eigEXERFRH8p69Qv0UJeC8hqV9ZI2E+0Zqi3BTmtE9x/UpoJ9L7UL0lddtEasKvuVU44DidnYcsIROp0r6nIbUP3TD3B68x38+crLcNac89CTMeAiIiLqgwI8XdRlRIQP0ooqkVpQ2aasl2SWAkLCUJCbbb5o3s4OgcFh6ryOkFqucTF+qD25A589eyscPAPUIG7XmJFwHzwVjt7BWJnXgI0rd2PswCgMDPFUAaUElz0J20JYCYvmiYjI1hRWSK1XhSq2b03WS79LURieb2enPvzjhbcw+ezzrVqg7+gbBtfYUfAZOBE+gyahorYBjvZ2KugaGOKFQaGeiPJzh7396efUEu5StDEMuIiIyFZJV3vJekmtl+wqbEsfLiG7EW+895+dEmyJw3u345Gbr0BLnvjvFwgYMAYJOWVIyClXuyGlL5mbk73a/Xg6APNScyHtfg8KTXGXIhEREXVZV/v4IE91ySurQUpBBTJLqlWfL1MSVJ0x41y1a1EK6a1RyF7UygL94vxcjJxwuhv/zEHBakdmamElErLLcDynDKsPZqpjvm5OGBjqhUEhnupjV+yAZA0XERERWSTtGeRSXdegghfJelXVNRidI8HViPFTrPZT9Gtlgb7peQ6/Ly3K5dzhoWog+KncChV8SRZsd9LpFhThvq4Y9Hv2K8ytc9pmmGLARURERC1ydXJQS3LSFyuntAZJ+RXILTvdtNTahnZSgb6LowOGhnuri5BNAgnZ5TieXYr9qcXYcDwP9nVVVvkeGHARERFRq0ntU6iPq7pIfZdkvNIKK1HbYL0xQg4ODrjp3sdPF+hL7ZWZAn2pGWvrMqYsJY6P9VMXWS6VQPJQYhbe6OxvQLruW+E+iYiIqA+QrvHDI3xwzrBQjI32g58V5yFOPvt8tesxIDjU6LhktjpjN6QWSE4bENjBZ2rh/nXmKuCow7hLkYiI+iIZIyTLjRnFVZ02Rsi0RYQ1C/S5S5GIiIhsYozQmGgZI+SjL7KvqG2+tURbWLtA31pYw0VERERWaS0hva/igzxUa4nE/ArklHZNkX1PxICLiIiIrEZqo4K9XdVFK7KXzFedFYvseyIGXERERNSlRfaDQ72QVlSFpPxylFV33nJjT8aAi4iIiLo2+HCw1zcklV5eSXkVyO7ly40MuIiIiKjbBHu5qossN0rgJTMce+NyIwMuIiIi6hHLjSMifTA4zEvVeEnw1Zm7G7sbAy4iIiLqMZwcTg/Ojgv0UJ3fE/PKkVdeA1vHgIuIiIh69Aihkqo6FXilF1Wh0Ub7tTPgIiIioh7Nx80JY6L9MCTMGykFlaqTfU19A2wJAy4iIiKyCa5ODhgU6qUaqmYUVeFUfjlKq+pgCxhwERERkU1xsLdDdIC7ukhbiVO5FepjT8aAi4iIiGy+rURptdR5VSCtsLJH1nkx4CIiIiKb5+3qhNFRvqqLfXJBhRohVFPfc/p5MeAiIiKiXlXnNTjUGwOCT/fzOpVb3iP6eTHgIiIiol5Z59Uv0AOxAe7IKqnGydxyFFXWdtvzYcBFREREvbqfV7ivm7rkl9fgRE55txTYM+AiIiKiPiHQ00VdpJGqZLwyiqug66ICe/sueRQiIiKiHtRIdVyMH2YPCUZsgIfKglkbAy4iIiLqk9ydHTEqyhdnDw5GlL+7VQMvLikSERFRn+bh4oix0X4YEOyJfSesU1jPDBcRERERAC9XJ4yN8WfAZS3z5s2Dn58fLrvssjbdRkRERNQazHABWLx4MT744IM230ZERETUGgy4AMyYMQNeXl5tvo2IiIioVwRcmzdvxoUXXojw8HC1e2D16tVNzlm6dCliY2Ph6uqKiRMnYvfu3d3yXImIiIhscpdiRUUFRo0ahRtuuAHz589vcvvnn3+Ou+++G2+++aYKtl555RWce+65OH78OIKDg9U5o0ePRn190zlKP/74owrkOkNNTY26aEpLSzvlfomIiMj29fiA67zzzlMXS1566SXcfPPNuP7669V1Cby+++47vPvuu7j//vvVsYMHD1r9eT777LN4/PHHrf44REREZHt6/JJic2pra7Fv3z7Mnj1bf8ze3l5d37FjR5c+lwceeAAlJSX6S1paWpc+PhEREfVcPT7D1Zz8/Hw0NDQgJCTE6LhcP3bsWKvvRwK0Q4cOqeXLyMhIrFixApMnT27xNkMuLi7qQkRERNSrAq7O8vPPP7frNiIiIqJev6QYGBgIBwcH5OTkGB2X66Ghod32vIiIiIh6TcDl7OyMcePGYd26dfpjjY2N6rq5ZT8iIiKi7tDjlxTLy8tx8uRJ/fWkpCS169Df3x/R0dGqJcS1116L8ePH44wzzlBtIaTeStu1SERERNTdenzAtXfvXsycOVN/XQIsIUHW8uXLceWVVyIvLw+PPvoosrOzVc+ttWvXNimkJyIiIuoudjqdTtdtj94LSdd7ucjuyYSEBNUiwtvbu7ufFhEREbWCNC738fHp9PdvBlw29oIRERGR7b1/9/glRVulJQ454oeIiMh2aO/bnb0AyIDLSgoKCtTHqKgoaz0EERERWfF9XDJdnYUBl5XILkqRmpraqS8Ytf8vFgl+ZeQSl3i7F1+LnoOvRc/B16LnkKVE6YKgvY93FgZcViIzHYUEW3yD7znkteDr0TPwteg5+Fr0HHwtet77eKfdX6feGxERERE1wYCLiIiIyMoYcFmJi4sLHnvsMfWRuh9fj56Dr0XPwdei5+Br0ftfC/bhIiIiIrIyZriIiIiIrIwBFxEREZGVMeAiIiIisjIGXERERERWxoCrA5YuXYrY2Fi4urpi4sSJ2L17d7Pnr1ixAoMHD1bnjxgxAt9//31HHp468HosW7YM06ZNg5+fn7rMnj27xdePrPdvQ/PZZ5/Bzs4Ol1xyCX/c3fRaFBcXY9GiRQgLC1O7tAYOHMjfVd30WrzyyisYNGgQ3Nzc1KSMu+66C9XV1Z31dPqszZs348ILL0R4eLj6fbN69eoWv2bjxo0YO3as+jfRv39/LF++vO0PrKN2+eyzz3TOzs66d999V/fbb7/pbr75Zp2vr68uJyfH7Pnbtm3TOTg46P71r3/pjhw5onv44Yd1Tk5OusOHD/MV6IbXY8GCBbqlS5fqDhw4oDt69Kjuuuuu0/n4+OjS09P5enTxa6FJSkrSRURE6KZNm6a7+OKL+Tp0w2tRU1OjGz9+vO7888/Xbd26Vb0mGzdu1B08eJCvRxe/Fh9//LHOxcVFfZTX4YcfftCFhYXp7rrrLr4WHfT999/rHnroId2qVatkOrXuq6++avb8xMREnbu7u+7uu+9W79+vvfaaej9fu3Ztmx6XAVc7nXHGGbpFixbprzc0NOjCw8N1zz77rNnzr7jiCt0FF1xgdGzixIm6W2+9tb1PgTrwepiqr6/XeXl56d5//33+XLvhtZCf/5QpU3Rvv/227tprr2XA1U2vxRtvvKGLi4vT1dbWdtZToHa+FnLurFmzjI7JG/7UqVP5M+1ErQm47rvvPt2wYcOMjl155ZW6c889t02PxSXFdqitrcW+ffvUMpThzCW5vmPHDrNfI8cNzxfnnnuuxfPJuq+HqcrKStTV1XX6sNK+pr2vxRNPPIHg4GDceOONXfRMe7/2vBbffPMNJk+erJYUQ0JCMHz4cDzzzDNoaGjowmfe+7TntZgyZYr6Gm3ZMTExUS3tnn/++V32vKlz3785vLod8vPz1S8g+YVkSK4fO3bM7NdkZ2ebPV+OU9e/Hqb+8Y9/qPV8039UZP3XYuvWrXjnnXdw8OBB/ri7+bWQN/X169fjmmuuUW/uJ0+exN/+9jf1x4h03qauey0WLFigvu7MM8+UlSjU19fjtttuw4MPPsiXoYtZev8uLS1FVVWVqrFrDWa4qM977rnnVLH2V199pYpZqeuUlZVh4cKFahNDYGAgf/TdrLGxUWUa//vf/2LcuHG48sor8dBDD+HNN9/s7qfW50iRtmQXX3/9dezfvx+rVq3Cd999hyeffLK7nxq1EzNc7SBvDA4ODsjJyTE6LtdDQ0PNfo0cb8v5ZN3XQ/Piiy+qgOvnn3/GyJEj+WPv4tfi1KlTSE5OVjuGDN/0haOjI44fP474+Hi+Ll3wWgjZmejk5KS+TjNkyBD1F74sizk7O/O16KLX4pFHHlF/jNx0003quuxsr6iowC233KKCYFmSpK5h6f3b29u71dktwVesHeSXjvz1t27dOqM3Cbku9Q/myHHD88VPP/1k8Xyy7ush/vWvf6m/FteuXYvx48fzR94Nr4W0STl8+LBaTtQuF110EWbOnKk+l63w1DWvhZg6dapaRtSCXpGQkKACMQZbXftaSF2paVClBcKna72pq3Ta+3e7yvpJbfGVLbvLly9X20RvueUWtcU3Oztb/XQWLlyou//++43aQjg6OupefPFF1YbgscceY1uIbnw9nnvuObVFe+XKlbqsrCz9paysjP93d/FrYYq7FLvvtUhNTVW7dW+//Xbd8ePHdWvWrNEFBwfrnnrqqU58Vn1TW18LeY+Q1+LTTz9VbQl+/PFHXXx8vNrxTh0jv+elJZBcJAx66aWX1OcpKSnqdnkd5PUwbQtx7733qvdvaSnEthBdTHpxREdHqzdu2fK7c+dO/W3Tp09XbxyGvvjiC93AgQPV+bLF9Lvvvuvqp9yrteX1iImJUf/QTC/yS4669rUwxYCre1+L7du3q5Y1EhxIi4inn35ate2grn0t6urqdP/85z9VkOXq6qqLiorS/e1vf9MVFRXxpeigDRs2mP39r/385aO8HqZfM3r0aPXayb+L9957r82Payf/6dzkGxEREREZYg0XERERkZUx4CIiIiKyMgZcRERERFbGgIuIiIjIyhhwEREREVkZAy4iIiIiK2PARURERGRlDLiIiIiIrIwBFxFRC2SQsAwNbqvly5fD19dXf/3NN980GtRNRH0HAy4i6pMaGhowZcoUzJ8/3+h4SUmJGpr90EMPqevZ2dlYsmSJ/rq47rrrYGdnh+eee87oa1evXq2Oa6688ko1/Flzww03YP/+/diyZYsVvzMi6okYcBFRn+Tg4KAyUGvXrsXHH3+sP37HHXfA398fjz32mLr+9ttvq8AsJibG6OtdXV3x/PPPo6ioyOJjuLm5ITg4WH/d2dkZCxYswKuvvmqV74mIei4GXETUZw0cOFBlqSTIysrKwtdff43PPvsMH3zwgQqOhFw3tww4e/ZshIaG4tlnn231kqKQ+/rmm29QVVVlhe+IiHoqBlxE1KdJsDVq1CgsXLhQ1Wk9+uij6rooLCzEkSNHMH78eLMZsmeeeQavvfYa0tPTW/14cl/19fXYtWtXp34fRNSzMeAioj5Naq7eeOMNrFu3DiEhIbj//vv1t6WmpkKn0yE8PNzs186bNw+jR4/WLz+2hru7O3x8fJCSktIpz5+IbAMDLiLq8959910VCCUlJRllq7RlP6nXskTquN5//30cPXq01T9Hqe2qrKzs8z93or6EARcR9Wnbt2/Hyy+/jDVr1uCMM87AjTfeqLJaIjAwUH1srjD+rLPOwrnnnosHHnig1Y8pS5VBQUGd8OyJyFYw4CKiPkuyTNLi4a9//StmzpyJd955B7t371b9skR8fDy8vb1VHVdzpPD+22+/xY4dO1p8zFOnTqG6uhpjxozptO+DiHo+BlxE1GdJVkqyWVo/rdjYWLz44ou47777kJycDHt7e7UbcevWrc3ez4gRI3DNNde0qt2D9OCKi4tTwRwR9R0MuIioT9q0aROWLl2K9957T9VvaW699VbVd0tbWrzppptUa4jGxsZm7++JJ55o8Rzx6aef4uabb+6U74GIbIedTitWICKiJuRX5MSJE3HXXXfh6quv7tBP6LfffsOsWbNU93nZqUhEfQczXERELbSN+O9//6t6Z3WUNFeVpqoMtoj6Hma4iIiIiKyMGS4iIiIiK2PARURERGRlDLiIiIiIrIwBFxEREZGVMeAiIiIisjIGXERERERWxoCLiIiIyMoYcBERERFZGQMuIiIiIljX/wMFU1bx277ueQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -329,7 +329,7 @@ "plot_interdiffusivity_datasets(ax, components, 'Iijima1982', scale=1e4, marker='x', color='k')\n", "\n", "# Remove first 75 parameters from trace and reshape to (N, params)\n", - "trace = np.load('output/CuNi_trace.npy')\n", + "trace = np.load('CuNi_trace.npy')\n", "trace = trace[:,500:]\n", "trace = trace.reshape(-1, trace.shape[-1])\n", "\n", @@ -369,7 +369,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -378,19 +378,19 @@ "text": [ "Iteration\tSim Time (h)\tRun time (s)\n", "0\t\t0.000e+00\t\t0.0\n", - "100\t\t2.050e+01\t\t5.5\n", - "200\t\t4.100e+01\t\t8.9\n", - "300\t\t6.150e+01\t\t11.3\n", - "400\t\t8.200e+01\t\t13.2\n", - "500\t\t1.025e+02\t\t14.9\n", - "600\t\t1.230e+02\t\t16.5\n", - "700\t\t1.436e+02\t\t17.7\n", - "731\t\t1.500e+02\t\t18.1\n" + "100\t\t2.107e+01\t\t4.7\n", + "200\t\t4.214e+01\t\t8.3\n", + "300\t\t6.321e+01\t\t10.8\n", + "400\t\t8.428e+01\t\t12.8\n", + "500\t\t1.054e+02\t\t14.5\n", + "600\t\t1.265e+02\t\t16.0\n", + "700\t\t1.476e+02\t\t17.3\n", + "712\t\t1.500e+02\t\t17.4\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -463,7 +463,7 @@ ], "metadata": { "kernelspec": { - "display_name": "calphad_312", + "display_name": "calphad_313 (3.13.12)", "language": "python", "name": "python3" }, @@ -477,7 +477,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.8" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/examples/mobility_fitting/databases/CuNi_manual_fit.tdb b/examples/mobility_fitting/databases/CuNi_manual_fit.tdb index 592364a..fbcac0b 100644 --- a/examples/mobility_fitting/databases/CuNi_manual_fit.tdb +++ b/examples/mobility_fitting/databases/CuNi_manual_fit.tdb @@ -1,8 +1,8 @@ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ -$ Date: 2025-07-22 16:52 +$ Date: 2026-06-02 08:36 $ Components: CU, NI, VA $ Phases: FCC_A1, LIQUID -$ Generated by ury3 (pycalphad 0.11.1.dev45+gdde29e02) +$ Generated by ury3 (pycalphad 0.11.2.dev33+g4a81c89c3) $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ ELEMENT CU FCC_A1 63.546 5004.1 33.15 ! diff --git a/examples/mobility_fitting/databases/CuNi_mcmc.tdb b/examples/mobility_fitting/databases/CuNi_mcmc.tdb index 9ab9db3..5a4799d 100644 --- a/examples/mobility_fitting/databases/CuNi_mcmc.tdb +++ b/examples/mobility_fitting/databases/CuNi_mcmc.tdb @@ -1,8 +1,8 @@ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ -$ Date: 2025-02-21 16:11 +$ Date: 2026-06-02 08:48 $ Components: CU, NI, VA $ Phases: FCC_A1, LIQUID -$ Generated by ury3 (pycalphad 0.11.1.dev27+g2e830294) +$ Generated by ury3 (pycalphad 0.11.2.dev33+g4a81c89c3) $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ ELEMENT CU FCC_A1 63.546 5004.1 33.15 ! @@ -25,18 +25,18 @@ FUNCTION GLIQCU 298.15 12964.735-9.511904*T-5.8489E-21*T**(7)+GHSERCU; 1357.77 Y -46.545+173.881484*T-31.38*T*LOG(T); 3200.0 N ! FUNCTION GLIQNI 298.15 16414.686-9.397*T-3.82318E-21*T**(7)+GHSERNI; 1728.0 Y -9549.817+268.597977*T-43.1*T*LOG(T); 3000.0 N ! -FUNCTION VV0000 1 -91.4920573062081; 10000 N ! -FUNCTION VV0001 1 -202921.189415445; 10000 N ! -FUNCTION VV0002 1 -87.0602560306477; 10000 N ! -FUNCTION VV0003 1 -201732.971510536; 10000 N ! -FUNCTION VV0004 1 -59.8942795283338; 10000 N ! -FUNCTION VV0005 1 -305030.362438795; 10000 N ! -FUNCTION VV0006 1 -75.9323138428472; 10000 N ! -FUNCTION VV0007 1 -263795.147024709; 10000 N ! -FUNCTION VV0008 1 17.2258916644087; 10000 N ! -FUNCTION VV0009 1 -9602.55757245648; 10000 N ! -FUNCTION VV0010 1 23.3771617222535; 10000 N ! -FUNCTION VV0011 1 -21866.3156442164; 10000 N ! +FUNCTION VV0000 1 -86.3575650786372; 10000 N ! +FUNCTION VV0001 1 -204074.61614708; 10000 N ! +FUNCTION VV0002 1 -91.6611880293118; 10000 N ! +FUNCTION VV0003 1 -202997.26331184; 10000 N ! +FUNCTION VV0004 1 -75.2480431996386; 10000 N ! +FUNCTION VV0005 1 -265395.222357188; 10000 N ! +FUNCTION VV0006 1 -59.60248683333; 10000 N ! +FUNCTION VV0007 1 -302412.096213174; 10000 N ! +FUNCTION VV0008 1 20.5879221981189; 10000 N ! +FUNCTION VV0009 1 -16067.8974985215; 10000 N ! +FUNCTION VV0010 1 18.3375873480011; 10000 N ! +FUNCTION VV0011 1 -11699.6155945424; 10000 N ! TYPE_DEFINITION % SEQ * ! DEFINE_SYSTEM_DEFAULT ELEMENT 2 ! @@ -56,8 +56,9 @@ $ CU $ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ PARAMETER G(FCC_A1,CU:VA;0) 298.15 GHSERCU; 3200.0 N ! -PARAMETER MQ(FCC_A1&CU,CU:VA;0) 1.0 T*VV0002+VV0003; 10000.0 N ! +PARAMETER MQ(FCC_A1&CU,CU:VA;0) 1.0 T*VV0000+VV0001; 10000.0 N ! PARAMETER G(LIQUID,CU;0) 298.15 GLIQCU; 3200.0 N ! +PARAMETER MQ(LIQUID&CU,CU;0) 1.0 -36468.03076-137.186121545147*T; 10000.0 N ! $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ @@ -66,9 +67,10 @@ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ PARAMETER BMAGN(FCC_A1,NI:VA;0) 298.15 0.52; 3000.0 N ! PARAMETER G(FCC_A1,NI:VA;0) 298.15 GHSERNI; 3000.0 N ! -PARAMETER MQ(FCC_A1&NI,NI:VA;0) 1.0 T*VV0004+VV0005; 10000.0 N ! +PARAMETER MQ(FCC_A1&NI,NI:VA;0) 1.0 T*VV0006+VV0007; 10000.0 N ! PARAMETER TC(FCC_A1,NI:VA;0) 298.15 633.0; 3000.0 N ! PARAMETER G(LIQUID,NI;0) 298.15 GLIQNI; 3000.0 N ! +PARAMETER MQ(LIQUID&NI,NI;0) 1.0 -46404.09216-137.097138674486*T; 10000.0 N ! $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ @@ -79,13 +81,13 @@ PARAMETER BMAGN(FCC_A1,CU,NI:VA;0) 298.15 -0.732; 3000.0 N ! PARAMETER BMAGN(FCC_A1,CU,NI:VA;1) 298.15 -0.317; 3000.0 N ! PARAMETER G(FCC_A1,CU,NI:VA;0) 298.15 8047.72+3.42217*T; 6000.0 N ! PARAMETER G(FCC_A1,CU,NI:VA;1) 298.15 -2041.3+0.99714*T; 6000.0 N ! -PARAMETER MQ(FCC_A1&NI,CU:VA;0) 1.0 T*VV0000+VV0001; 10000.0 N ! -PARAMETER MQ(FCC_A1&CU,NI:VA;0) 1.0 T*VV0006+VV0007; 10000.0 N ! -PARAMETER MQ(FCC_A1&CU,CU,NI:VA;0) 1.0 T*VV0010+VV0011; 10000.0 N ! -PARAMETER MQ(FCC_A1&NI,CU,NI:VA;0) 1.0 T*VV0008+VV0009; 10000.0 N ! +PARAMETER MQ(FCC_A1&NI,CU:VA;0) 1.0 T*VV0002+VV0003; 10000.0 N ! +PARAMETER MQ(FCC_A1&CU,NI:VA;0) 1.0 T*VV0004+VV0005; 10000.0 N ! +PARAMETER MQ(FCC_A1&CU,CU,NI:VA;0) 1.0 T*VV0008+VV0009; 10000.0 N ! +PARAMETER MQ(FCC_A1&NI,CU,NI:VA;0) 1.0 T*VV0010+VV0011; 10000.0 N ! PARAMETER TC(FCC_A1,CU,NI:VA;0) 298.15 -935.5; 3000.0 N ! PARAMETER TC(FCC_A1,CU,NI:VA;1) 298.15 -594.9; 3000.0 N ! PARAMETER G(LIQUID,CU,NI;0) 298.15 12048.61+1.29093*T; 6000.0 N ! PARAMETER G(LIQUID,CU,NI;1) 298.15 -1861.61+0.94201*T; 6000.0 N ! -PARAMETER MQ(LIQUID&NI,CU;0) 1 -36468.03076-136.988159811907*T; 10000 N ! -PARAMETER MQ(LIQUID&CU,NI;0) 1 -46404.09216-137.295100407725*T; 10000 N ! +PARAMETER MQ(LIQUID&NI,CU;0) 1.0 -36468.03076-136.988159811907*T; 10000.0 N ! +PARAMETER MQ(LIQUID&CU,NI;0) 1.0 -46404.09216-137.295100407725*T; 10000.0 N ! diff --git a/examples/mobility_fitting/databases/CuNi_mob_gen.tdb b/examples/mobility_fitting/databases/CuNi_mob_gen.tdb index eda5612..808c833 100644 --- a/examples/mobility_fitting/databases/CuNi_mob_gen.tdb +++ b/examples/mobility_fitting/databases/CuNi_mob_gen.tdb @@ -1,8 +1,8 @@ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ -$ Date: 2025-07-22 16:52 +$ Date: 2026-06-02 08:36 $ Components: CU, NI, VA $ Phases: FCC_A1, LIQUID -$ Generated by ury3 (pycalphad 0.11.1.dev45+gdde29e02) +$ Generated by ury3 (pycalphad 0.11.2.dev33+g4a81c89c3) $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ ELEMENT CU FCC_A1 63.546 5004.1 33.15 ! diff --git a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py index 714bdca..1cb79c3 100644 --- a/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/equilibrium_mobility_error.py @@ -68,7 +68,7 @@ def __init__(self, dbf, data, parameters = None, data_weight_dict = None): if 'X_' not in c: self.conditions[getattr(v,c)] = condList self.conditions['composition'] = rav_comp_conds - + self.values = np.array(data['values']) self._compute_cached_equilibrium(dbf) @@ -134,16 +134,16 @@ def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], dat (tinydb.where('components').test(lambda x: set(x).issubset(comps))) & (tinydb.where('phases').test(lambda x: len(set(phases).intersection(x)) > 0)) & (~tinydb.where('solver').exists())) - + mod_data = [] for data in desired_data: - mod_data.append(EquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) - return mod_data + mod_data.append(EquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) + return mod_data def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray): diffs, wts = [], [] paramDict = {data.parameter_keys[i] : parameters[i] for i in range(len(data.parameter_keys))} - + #Update phase record parameters param_keys, param_values = extract_parameters(paramDict) for p in data.phases: @@ -163,7 +163,7 @@ def calc_mob_differences(data : EquilibriumMobilityData, parameters : np.ndarray mob_from_CS = mobility_from_dof_phase_record(cs_data.dof, data.mob_phase_records, data.phases[0], cs_data.elements, paramDict) else: mob_from_CS = mobility_from_dof_phase_record(cs_data.dof, data.mob_phase_records, data.phases[0], [data.refComp[0]], paramDict) - + #NOTE: for interdiffusivity, tracer diffusivity and prefactor, we multiply by the sign of the value # This is for cases if the computed and desired values are of different signs # and taking the log of the absolute value will remove this possible difference @@ -213,7 +213,7 @@ def calculate_mob_probability(mob_data : Sequence[EquilibriumMobilityData], para diffs, wts = calc_mob_differences(data, parameters) if np.any(np.isinf(diffs) | np.isnan(diffs)): return -np.inf - prob_error += norm(loc=0.0, scale=wts).logpdf(diffs) + prob_error += np.sum(norm(loc=0.0, scale=wts).logpdf(diffs)) return prob_error class EquilibriumMobilityResidual(ResidualFunction): diff --git a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py index 8e30630..09e670d 100644 --- a/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py +++ b/kawin/mobility_fitting/error_functions/non_equilibrium_mobility_error.py @@ -67,13 +67,13 @@ def _processConditions(self, data): values = np.array(data['values']) self.values = values.flatten() self.P, self.T = ravel_conditions(values, P, T) - + sub_conf = data['solver']['sublattice_configurations'] sub_occ = data['solver']['sublattice_occupancies'] phase_cons = [[c.name for c in sorted(s)] for s in self.models[self.phases[0]].constituents] single_points = np.array([calculate_points_array(phase_cons, conf, occ) for conf, occ in zip(sub_conf, sub_occ)]) self.points = np.tile(single_points, (values.shape[0]*values.shape[1], 1)) - + def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], datasets: PickleableTinyDB, parameters: Dict[str, float], data_weight_dict: Optional[Dict[str, float]] = None): ''' Return the ZPF data used in the calculation of ZPF error @@ -108,16 +108,16 @@ def get_mob_data(dbf: Database, comps: Sequence[str], phases: Sequence[str], dat (tinydb.where('components').test(lambda x: set(x).issubset(comps))) & (tinydb.where('phases').test(lambda x: len(set(phases).intersection(x)) > 0)) & (tinydb.where('solver').exists())) - + mob_data = [] for data in desired_data: - mob_data.append(NonEquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) - return mob_data + mob_data.append(NonEquilibriumMobilityData(dbf, data, parameters, data_weight_dict)) + return mob_data def calc_mob_differences(data : NonEquilibriumMobilityData, parameters : np.ndarray): diffs, wts = [], [] paramDict = {data.parameter_keys[i] : parameters[i] for i in range(len(data.parameter_keys))} - + #Update phase record parameters param_keys, param_values = extract_parameters(paramDict) for p in data.phases: @@ -166,7 +166,7 @@ def calculate_mob_probability(mob_data : Sequence[NonEquilibriumMobilityData], p diffs, wts = calc_mob_differences(data, parameters) if np.any(np.isinf(diffs) | np.isnan(diffs)): return -np.inf - prob_error += norm(loc=0.0, scale=wts).logpdf(diffs) + prob_error += np.sum(norm(loc=0.0, scale=wts).logpdf(diffs)) return prob_error class NonEquilibriumMobilityResidual(ResidualFunction): @@ -203,7 +203,7 @@ def get_residuals(self, parameters) -> tuple[list[float], list[float]]: residuals.append(diffs) weights.append(wts) return np.concatenate(residuals, axis=0), np.concatenate(weights, axis=0) - + def get_likelihood(self, parameters) -> float: likelihood = calculate_mob_probability(self.mob_data, parameters) return likelihood diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py index d18a589..4a27d55 100644 --- a/kawin/thermo/Mobility.py +++ b/kawin/thermo/Mobility.py @@ -53,18 +53,18 @@ def x_to_u_frac(x_frac, elements, interstitial_list, return_usum = False): return np.squeeze(u_frac), Usum else: return np.squeeze(u_frac) - + def u_to_x_frac(u_frac, elements, interstitial_list): u_frac = np.atleast_2d(u_frac) # a_ij = (\delta_ij - u_i) if j is substitutional - # a_ij = \delta_ij if j is interstitial + # a_ij = \delta_ij if j is interstitial a = np.eye(len(elements))[np.newaxis,:,:] - u_frac[:,:,np.newaxis] for i, e in enumerate(elements): if e in interstitial_list: a[:,:,i] = 0 a[:,i,i] = 1 - + b = np.zeros((*u_frac.shape, 1)) # Summation constraint (sum(x) = 1) # We can replace first row of a here @@ -193,7 +193,7 @@ def _mobility_validity(self, constituent_array): if not (set(param_sublattice).issubset(model_sublattice) or (param_sublattice[0] == v.Species('*'))): return False return True - + def build_mobility(self, dbe): ''' Builds mobility/diffusivity models as abstract syntax tree @@ -265,7 +265,7 @@ def build_mobility(self, dbe): setattr(self, 'DQ_'+str(c.name).upper(), dqsum) return mob, diff - + def checkOrderingContribution(self, dbe): ''' Checks if phase is an ordered part of a order-disorder model @@ -283,12 +283,12 @@ def checkOrderingContribution(self, dbe): #If not order-disorder model, then return as unchanged if phase.name != ordered_phase_name: return - + ordered_phase = dbe.phases[ordered_phase_name] constituents = [sorted(set(c).intersection(self.components)) for c in ordered_phase.constituents] disordered_phase = dbe.phases[disordered_phase_name] disordered_model = self.__class__(dbe, sorted(self.components), disordered_phase_name) - + #If diffusing species are different, then set diffusing species for disordered model if set(self.components).symmetric_difference(self.diffusing_species) != 0: disordered_model.set_diffusing_species(dbe, self.diffusing_species) @@ -310,7 +310,7 @@ def checkOrderingContribution(self, dbe): f'({num_ordered_interstitial_subls}) do not match. Got ' f'substitutional sublattice indices of {substitutional_sublattice_idxs}.' ) - + for c in self.mob_models['MF']: ordered_mobQ = Add(self.mob_models['MQ'][c]) ordered_mobF = Add(self.mob_models['MF'][c]) @@ -349,14 +349,14 @@ def checkOrderingContribution(self, dbe): shifted_subl_index = atom.sublattice_index + num_substitutional_sublattice_idxs - 1 variable_rename_dict[atom] = \ v.SiteFraction(ordered_phase_name, shifted_subl_index, atom.species) - + self.mob_models['MQ'][c] = self._partitioned_expr(disordered_model.mob_models['MQ'][c], ordered_mobQ, variable_rename_dict, molefraction_dict) self.mob_models['MF'][c] = self._partitioned_expr(disordered_model.mob_models['MF'][c], ordered_mobF, variable_rename_dict, molefraction_dict) self.mob_models['DQ'][c] = self._partitioned_expr(disordered_model.mob_models['DQ'][c], ordered_diffQ, variable_rename_dict, molefraction_dict) self.mob_models['DF'][c] = self._partitioned_expr(disordered_model.mob_models['DF'][c], ordered_diffF, variable_rename_dict, molefraction_dict) return - + def _get_mobility_arguments(cs_dof, parameters): param_keys, param_values = extract_parameters(parameters) if len(param_values) > 0: @@ -407,15 +407,15 @@ def compute_phase_record_func_from_dof(dof, prf, phase, symbol, parameters={}): return prop.func(callableInput) def mobility_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): - return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MOB_{e}', parameters) for e in elements], + return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MOB_{e}', parameters) for e in elements], dtype=np.float64) def activation_energy_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): - return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MQa_{e}', parameters) for e in elements], + return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'MQa_{e}', parameters) for e in elements], dtype=np.float64) def prefactor_from_dof_phase_record(dof, prf, phase, elements, parameters = {}): - return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'lnM0_{e}', parameters) for e in elements], + return np.array([compute_phase_record_func_from_dof(dof, prf, phase, f'lnM0_{e}', parameters) for e in elements], dtype=np.float64) def compute_phase_record_func_from_composition_set(composition_set, prf, phase, symbol, parameters={}): @@ -542,16 +542,16 @@ def mobility_matrix_from_dof(dof, composition, elements, mob_values, phase_recor - Substitutional and interstitial components are modeled differently based off the following assumptions: 1. Substitutional components contribute to the volume of the alloy while interstitials have zero volume 2. Vacancy fraction in substitutional sublattice is near 0 while vacancy fraction in interstitial sublattice is near 1 - + - Assumption 1 is accounted by considering u-fraction of other components for substitutional and accounting for reference element when computing interdiffusivity. Interstitials do not account for this since they do not contribute to the volume - Assumption 2 is accounted for by multiplying the vacancy site fraction on interstitial mobility - - Mobility is defined in terms of a kinetic parameter (\Omega) that describes the rate of exchange for a component given that + - Mobility is defined in terms of a kinetic parameter (omega) that describes the rate of exchange for a component given that it is near a vacancy - - For substitutionals, we define mobility M = y_VA * \Omega, so the mobility term itself includes the vacancy fraction + - For substitutionals, we define mobility M = y_VA * omega, so the mobility term itself includes the vacancy fraction since in practice, the vacancy fraction is near 0 - - For interstitials, we define mobility M = \Omega, so it does not factor in the vacancy fraction. Thus we have to + - For interstitials, we define mobility M = omega, so it does not factor in the vacancy fraction. Thus we have to include the vacancy fraction to represent the probability that the component is near a vacancy - We can override this assumption for interstitials using the vacancy_poor_interstitial_sublattice parameter. This can be useful for compounds like carbides, where the interstitial sublattice is mostly carbon and the vacancy fraction is near 0 @@ -631,16 +631,16 @@ def mobility_matrix(composition_set, mobility_callables = None, mobility_correct - Substitutional and interstitial components are modeled differently based off the following assumptions: 1. Substitutional components contribute to the volume of the alloy while interstitials have zero volume 2. Vacancy fraction in substitutional sublattice is near 0 while vacancy fraction in interstitial sublattice is near 1 - + - Assumption 1 is accounted by considering u-fraction of other components for substitutional and accounting for reference element when computing interdiffusivity. Interstitials do not account for this since they do not contribute to the volume - Assumption 2 is accounted for by multiplying the vacancy site fraction on interstitial mobility - - Mobility is defined in terms of a kinetic parameter (\Omega) that describes the rate of exchange for a component given that + - Mobility is defined in terms of a kinetic parameter (omega) that describes the rate of exchange for a component given that it is near a vacancy - - For substitutionals, we define mobility M = y_VA * \Omega, so the mobility term itself includes the vacancy fraction + - For substitutionals, we define mobility M = y_VA * omega, so the mobility term itself includes the vacancy fraction since in practice, the vacancy fraction is near 0 - - For interstitials, we define mobility M = \Omega, so it does not factor in the vacancy fraction. Thus we have to + - For interstitials, we define mobility M = omega, so it does not factor in the vacancy fraction. Thus we have to include the vacancy fraction to represent the probability that the component is near a vacancy - We can override this assumption for interstitials using the vacancy_poor_interstitial_sublattice parameter. This can be useful for compounds like carbides, where the interstitial sublattice is mostly carbon and the vacancy fraction is near 0 @@ -688,10 +688,10 @@ def chemical_diffusivity(chemical_potentials, composition_set, mobility_callable free energy hessian will be None if returnHessian is False ''' dmudx = partialdMudX(chemical_potentials, composition_set) - mobMatrix = mobility_matrix(composition_set=composition_set, - mobility_callables=mobility_callables, - mobility_correction=mobility_correction, - vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, + mobMatrix = mobility_matrix(composition_set=composition_set, + mobility_callables=mobility_callables, + mobility_correction=mobility_correction, + vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, parameters=parameters) return chemical_diffusivity_from_mob(dmudx, mobMatrix, returnHessian) @@ -713,7 +713,7 @@ def interdiffusivity_from_Dkj(Dkj, hessian, elements, refElement): d += 1 c += 1 d = 0 - + return Dnkj, hessian def interdiffusivity(chemical_potentials, composition_set, refElement, mobility_callables = None, mobility_correction = None, returnHessian = False, vacancy_poor_interstitial_sublattice = False, parameters = {}): @@ -739,23 +739,23 @@ def interdiffusivity(chemical_potentials, composition_set, refElement, mobility_ Returns ------- (matrix of floats, free energy hessian) - Each index along an axis correspond to elements in + Each index along an axis correspond to elements in alphabetical order excluding reference element free energy hessian will be None if returnHessian is False ''' - Dkj, hessian = chemical_diffusivity(chemical_potentials=chemical_potentials, - composition_set=composition_set, - mobility_callables=mobility_callables, - mobility_correction=mobility_correction, - returnHessian=True, - vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, + Dkj, hessian = chemical_diffusivity(chemical_potentials=chemical_potentials, + composition_set=composition_set, + mobility_callables=mobility_callables, + mobility_correction=mobility_correction, + returnHessian=True, + vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, parameters=parameters) elements = list(composition_set.phase_record.nonvacant_elements) return interdiffusivity_from_Dkj(Dkj, hessian, elements, refElement) def inverseMobility(chemical_potentials, composition_set, refElement, mobility_callables, mobility_correction = None, returnOther = True, vacancy_poor_interstitial_sublattice = False, parameters = {}): ''' - Inverse mobility matrix for determining interfacial composition from + Inverse mobility matrix for determining interfacial composition from Philippe and P. W. Voorhees, Acta Materialia 61 (2013) p. 4237 M^-1 = (free energy hessian) * Dnkj^-1 @@ -778,20 +778,20 @@ def inverseMobility(chemical_potentials, composition_set, refElement, mobility_c (interdiffusivity, hessian, inverse mobility) Interdiffusivity and hessian will be None if returnOther is False ''' - Dnkj, _ = interdiffusivity(chemical_potentials=chemical_potentials, - composition_set=composition_set, - refElement=refElement, - mobility_callables=mobility_callables, - mobility_correction=mobility_correction, - returnHessian=False, - vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, + Dnkj, _ = interdiffusivity(chemical_potentials=chemical_potentials, + composition_set=composition_set, + refElement=refElement, + mobility_callables=mobility_callables, + mobility_correction=mobility_correction, + returnHessian=False, + vacancy_poor_interstitial_sublattice=vacancy_poor_interstitial_sublattice, parameters=parameters) totalH = dMudX(chemical_potentials, composition_set, refElement) if returnOther: return Dnkj, totalH, np.matmul(totalH, np.linalg.inv(Dnkj)) else: return None, None, np.matmul(totalH, np.linalg.inv(Dnkj)) - + def tracer_diffusivity_from_diff(composition_set, diffusivity_callables = None, diffusivity_correction = None, parameters = {}): ''' Tracer diffusivity from diffusivity callables @@ -847,7 +847,7 @@ def interdiffusivity_from_diff(composition_set, refElement, diffusivity_callable Returns ------- matrix of floats - Each index along an axis correspond to elements in + Each index along an axis correspond to elements in alphabetical order excluding reference element ''' elements = list(composition_set.phase_record.nonvacant_elements) @@ -865,7 +865,7 @@ def interdiffusivity_from_diff(composition_set, refElement, diffusivity_callable for a in range(len(elements) - 1): if elements[eleIndex] == refElement: eleIndex += 1 - + Daa = diffusivity_correction[elements[eleIndex]] * diffusivity_callables[elements[eleIndex]](callableInput) Dnkj[a, a] = Daa eleIndex += 1 @@ -896,10 +896,10 @@ def inverseMobility_from_diffusivity(chemical_potentials, composition_set, refEl (interdiffusivity, hessian, inverse mobility) Interdiffusivity and hessian will be None if returnOther is False ''' - Dnkj = interdiffusivity_from_diff(composition_set=composition_set, - refElement=refElement, - diffusivity_callables=diffusivity_callables, - diffusivity_correction=diffusivity_correction, + Dnkj = interdiffusivity_from_diff(composition_set=composition_set, + refElement=refElement, + diffusivity_callables=diffusivity_callables, + diffusivity_correction=diffusivity_correction, parameters=parameters) totalH = dMudX(chemical_potentials, composition_set, refElement) From dc4f461b7be6801269a5d3865af5ee1f0928c2dd Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 14:40:32 -0700 Subject: [PATCH 26/53] add espei to dependency --- examples/mobility_fitting/02_mcmc_optimization.ipynb | 4 ++-- pyproject.toml | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/mobility_fitting/02_mcmc_optimization.ipynb b/examples/mobility_fitting/02_mcmc_optimization.ipynb index 2642be2..226c09b 100644 --- a/examples/mobility_fitting/02_mcmc_optimization.ipynb +++ b/examples/mobility_fitting/02_mcmc_optimization.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -114,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [ { diff --git a/pyproject.toml b/pyproject.toml index 4212906..fa86317 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,6 +28,7 @@ dependencies = [ "matplotlib>=3.3", "numpy>=2.0", "pycalphad>=0.11", + "espei", "scipy", "setuptools_scm[toml]>=6.0", ] From 73cc0c62dbb0ef36b2d95c97a85efdc74ffb0fab Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 15:08:16 -0700 Subject: [PATCH 27/53] add setuptools_scm to build system --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index fa86317..015ae1e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,7 @@ [build-system] requires = [ "setuptools>=42", + "setuptools_scm[toml]>=6.0", "wheel" ] From 37d0d8e7b5640da0d547bc8cc7d25d8341b76e21 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 15:38:52 -0700 Subject: [PATCH 28/53] no build isolation on pycalphad and espei installation in CI --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 3dc2287..740b355 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -25,10 +25,10 @@ jobs: - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop + run: python -m pip install --no-build-isolation git+https://github.com/pycalphad/pycalphad.git@develop - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master + run: python -m pip install --no-build-isolation git+https://github.com/PhasesResearchLab/ESPEI.git@master - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 3df265d78d1bb2acb5b3ffa51cf973949bae80a8 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 15:44:43 -0700 Subject: [PATCH 29/53] remove no build isolation --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 740b355..3dc2287 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -25,10 +25,10 @@ jobs: - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: python -m pip install --no-build-isolation git+https://github.com/pycalphad/pycalphad.git@develop + run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install --no-build-isolation git+https://github.com/PhasesResearchLab/ESPEI.git@master + run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 662a68bbe99bafb22776d0f277453d17e6b6ab0a Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 16:09:45 -0700 Subject: [PATCH 30/53] add #egg=proj to espei and pycalphad install in CI --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 3dc2287..9560bfb 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -25,10 +25,10 @@ jobs: - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop + run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=proj - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master + run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=proj - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From b1b5bd86c0fdd6ded71acf0815664d537d38827d Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 16:11:34 -0700 Subject: [PATCH 31/53] fix proj names --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 9560bfb..69a5715 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -25,10 +25,10 @@ jobs: - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=proj + run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=proj + run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From b3b5cae24876577c2394d0b01883d923f39200a1 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 16:29:13 -0700 Subject: [PATCH 32/53] add pretend version for dev packages --- .github/workflows/pytest.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 69a5715..43e3644 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -24,9 +24,11 @@ jobs: python-version: ${{ matrix.python-version }} - run: python -m pip install -U pip setuptools - name: Install pycalphad development version + run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD=1.0.0 if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version + run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0 if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei - name: Save pycalphad version From 80033197bf729d819febbbdc5867bdef0a2771c3 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 16:30:08 -0700 Subject: [PATCH 33/53] fix yaml --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 43e3644..41b6cc2 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -24,11 +24,11 @@ jobs: python-version: ${{ matrix.python-version }} - run: python -m pip install -U pip setuptools - name: Install pycalphad development version - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD=1.0.0 + - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD=1.0.0 if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0 + - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0 if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei - name: Save pycalphad version From 4f37b30c9d8460ffb0e1d5bbc0390cf89eeaa76f Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 16:30:47 -0700 Subject: [PATCH 34/53] fix yaml 2 --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 41b6cc2..11121de 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -23,12 +23,12 @@ jobs: with: python-version: ${{ matrix.python-version }} - run: python -m pip install -U pip setuptools - - name: Install pycalphad development version - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD=1.0.0 + - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0 + - name: Install pycalphad development version if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version - - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0 if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei - name: Save pycalphad version From 8329d3d56b138708156cc5e43392be6aca094e45 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Tue, 2 Jun 2026 16:41:53 -0700 Subject: [PATCH 35/53] update setuptools version --- .github/workflows/pytest.yaml | 2 -- pyproject.toml | 6 +++--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 11121de..69a5715 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -23,8 +23,6 @@ jobs: with: python-version: ${{ matrix.python-version }} - run: python -m pip install -U pip setuptools - - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD=1.0.0 - - run: export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0 - name: Install pycalphad development version if: matrix.pycalphad_develop_version run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad diff --git a/pyproject.toml b/pyproject.toml index 015ae1e..de167e3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [build-system] requires = [ - "setuptools>=42", - "setuptools_scm[toml]>=6.0", + "setuptools>=61", + "setuptools_scm[toml]>=8.0", "wheel" ] @@ -31,7 +31,7 @@ dependencies = [ "pycalphad>=0.11", "espei", "scipy", - "setuptools_scm[toml]>=6.0", + "setuptools_scm[toml]>=8.0", ] [project.urls] From 2a151426a65c442c16f0cd0fd401fe8baad46a3d Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 08:53:52 -0700 Subject: [PATCH 36/53] attempt to switch to uv --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 69a5715..9c2c6a9 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -25,10 +25,10 @@ jobs: - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad + run: uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei + run: uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From b0e6ea31e5b4bd20368b266345af3f2c0bbb22ef Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 08:55:15 -0700 Subject: [PATCH 37/53] add uv setup --- .github/workflows/pytest.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 9c2c6a9..45bf7b0 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -22,6 +22,7 @@ jobs: uses: actions/setup-python@v6 with: python-version: ${{ matrix.python-version }} + - uses: astral-sh/setup-uv@v7 - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version From a66990770bdb8908d4eb8dfa564cc0c76e8d9446 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 09:23:33 -0700 Subject: [PATCH 38/53] try cloning git repos for install --- .github/workflows/pytest.yaml | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 45bf7b0..06b3409 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -26,10 +26,23 @@ jobs: - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" + uses: actions/checkout@v5 + with: + repository: pycalphad/pycalphad + ref: develop + path: pycalphad + run: pip install ./pycalphad + #run: uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - name: Install espei development version if: matrix.pycalphad_develop_version - run: uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" + if: matrix.pycalphad_develop_version + uses: actions/checkout@v5 + with: + repository: PhasesResearchLab/ESPEI + ref: master + path: espei + run: pip install ./espei + #run: uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 800feb5a94435ed5bbc61c4fb893a273c2b6767f Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 09:26:54 -0700 Subject: [PATCH 39/53] fix issue --- .github/workflows/pytest.yaml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 06b3409..e9a0d12 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -31,16 +31,17 @@ jobs: repository: pycalphad/pycalphad ref: develop path: pycalphad + if: matrix.pycalphad_develop_version run: pip install ./pycalphad #run: uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - name: Install espei development version - if: matrix.pycalphad_develop_version if: matrix.pycalphad_develop_version uses: actions/checkout@v5 with: repository: PhasesResearchLab/ESPEI ref: master path: espei + if: matrix.pycalphad_develop_version run: pip install ./espei #run: uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" - name: Save pycalphad version From 82cc1a110702e8b6593bb5aa09e221f962118af3 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 09:27:32 -0700 Subject: [PATCH 40/53] fix issue 2 --- .github/workflows/pytest.yaml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index e9a0d12..bb416b5 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -31,7 +31,6 @@ jobs: repository: pycalphad/pycalphad ref: develop path: pycalphad - if: matrix.pycalphad_develop_version run: pip install ./pycalphad #run: uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - name: Install espei development version @@ -41,7 +40,6 @@ jobs: repository: PhasesResearchLab/ESPEI ref: master path: espei - if: matrix.pycalphad_develop_version run: pip install ./espei #run: uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" - name: Save pycalphad version From 72647c680da5cd369387aaa79f23e841d394a3d6 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 09:29:15 -0700 Subject: [PATCH 41/53] fix issue 3 --- .github/workflows/pytest.yaml | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index bb416b5..dbd56e6 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -24,22 +24,26 @@ jobs: python-version: ${{ matrix.python-version }} - uses: astral-sh/setup-uv@v7 - run: python -m pip install -U pip setuptools - - name: Install pycalphad development version + - name: Clone pycalphad development version if: matrix.pycalphad_develop_version uses: actions/checkout@v5 with: repository: pycalphad/pycalphad ref: develop path: pycalphad + - name: Install pycalphad developent version + if: matrix.pycalphad_develop_version run: pip install ./pycalphad #run: uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - - name: Install espei development version + - name: Clone espei development version if: matrix.pycalphad_develop_version uses: actions/checkout@v5 with: repository: PhasesResearchLab/ESPEI ref: master path: espei + - name: Install espei development version + if: matrix.pycalphad_develop_version run: pip install ./espei #run: uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" - name: Save pycalphad version From 452f26ab5a8633e0a5a28f67804341f1cd3f4ac9 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 09:34:13 -0700 Subject: [PATCH 42/53] fix issue 4 --- .github/workflows/pytest.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index dbd56e6..4342728 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -30,7 +30,7 @@ jobs: with: repository: pycalphad/pycalphad ref: develop - path: pycalphad + path: ./pycalphad - name: Install pycalphad developent version if: matrix.pycalphad_develop_version run: pip install ./pycalphad @@ -41,7 +41,7 @@ jobs: with: repository: PhasesResearchLab/ESPEI ref: master - path: espei + path: ./espei - name: Install espei development version if: matrix.pycalphad_develop_version run: pip install ./espei From e67c786a0c1ab1da7c65558b35b9fe9a9ca87f86 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 09:38:21 -0700 Subject: [PATCH 43/53] uv sync with setuptools pretend version --- .github/workflows/pytest.yaml | 20 ++------------------ 1 file changed, 2 insertions(+), 18 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 4342728..2e03b2d 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -24,28 +24,12 @@ jobs: python-version: ${{ matrix.python-version }} - uses: astral-sh/setup-uv@v7 - run: python -m pip install -U pip setuptools - - name: Clone pycalphad development version - if: matrix.pycalphad_develop_version - uses: actions/checkout@v5 - with: - repository: pycalphad/pycalphad - ref: develop - path: ./pycalphad - name: Install pycalphad developent version if: matrix.pycalphad_develop_version - run: pip install ./pycalphad - #run: uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - - name: Clone espei development version - if: matrix.pycalphad_develop_version - uses: actions/checkout@v5 - with: - repository: PhasesResearchLab/ESPEI - ref: master - path: ./espei + run: SETUPTOOLS_SCM_PRETEND_VERSION="1.0.0" uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - name: Install espei development version if: matrix.pycalphad_develop_version - run: pip install ./espei - #run: uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" + run: SETUPTOOLS_SCM_PRETEND_VERSION="1.0.0" uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 48a8be99bb9594e5c91b984700457d3d25d028e3 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 09:51:27 -0700 Subject: [PATCH 44/53] uv sync with setuptools pretend version 2 --- .github/workflows/pytest.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 2e03b2d..d720543 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -24,12 +24,12 @@ jobs: python-version: ${{ matrix.python-version }} - uses: astral-sh/setup-uv@v7 - run: python -m pip install -U pip setuptools - - name: Install pycalphad developent version + - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: SETUPTOOLS_SCM_PRETEND_VERSION="1.0.0" uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" + run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD="1.0.0" uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" - name: Install espei development version if: matrix.pycalphad_develop_version - run: SETUPTOOLS_SCM_PRETEND_VERSION="1.0.0" uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" + run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI="1.0.0" uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 7f8e3b1743e20b42d3aa076ec4a215a66d30eacc Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 10:05:20 -0700 Subject: [PATCH 45/53] switch back to pip install --- .github/workflows/pytest.yaml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index d720543..c00a0b7 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -22,14 +22,13 @@ jobs: uses: actions/setup-python@v6 with: python-version: ${{ matrix.python-version }} - - uses: astral-sh/setup-uv@v7 - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD="1.0.0" uv sync --dev -P "pycalphad @ git+https://github.com/pycalphad/pycalphad.git@develop" + run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD="1.0.0" python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version if: matrix.pycalphad_develop_version - run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI="1.0.0" uv sync --dev -P "espei @ git+https://github.com/PhasesResearchLab/ESPEI.git@master" + run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI="1.0.0" python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 15e9f99ea782e5da23317cba200e4fd9ca278b3f Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 10:23:20 -0700 Subject: [PATCH 46/53] move env variables --- .github/workflows/pytest.yaml | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index c00a0b7..9cf9635 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -15,6 +15,11 @@ jobs: pycalphad_develop_version: [true, false] steps: + - name: Set env variables + if: matrix.pycalphad_develop_version + env: + SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD: "1.0.0" + SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI: "1.0.0" - uses: actions/checkout@v5 with: fetch-depth: 0 # fetch the entire repo history, required to guarantee setuptools_scm will pick up tags @@ -25,10 +30,10 @@ jobs: - run: python -m pip install -U pip setuptools - name: Install pycalphad development version if: matrix.pycalphad_develop_version - run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD="1.0.0" python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad + run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version if: matrix.pycalphad_develop_version - run: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI="1.0.0" python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei + run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 5635c01b33da2da0566ffb85fdd76e4338ca39d8 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 10:31:01 -0700 Subject: [PATCH 47/53] move env variables down --- .github/workflows/pytest.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 9cf9635..ad72fc5 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -15,14 +15,14 @@ jobs: pycalphad_develop_version: [true, false] steps: + - uses: actions/checkout@v5 + with: + fetch-depth: 0 # fetch the entire repo history, required to guarantee setuptools_scm will pick up tags - name: Set env variables if: matrix.pycalphad_develop_version env: SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD: "1.0.0" SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI: "1.0.0" - - uses: actions/checkout@v5 - with: - fetch-depth: 0 # fetch the entire repo history, required to guarantee setuptools_scm will pick up tags - name: Set up Python uses: actions/setup-python@v6 with: From 37b27fc680c49f901c5685481995233f49de7a99 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 10:38:02 -0700 Subject: [PATCH 48/53] set env variables through run --- .github/workflows/pytest.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index ad72fc5..bed72f4 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -20,9 +20,9 @@ jobs: fetch-depth: 0 # fetch the entire repo history, required to guarantee setuptools_scm will pick up tags - name: Set env variables if: matrix.pycalphad_develop_version - env: - SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD: "1.0.0" - SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI: "1.0.0" + run: | + echo "SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD=1.0.0" >> $GITHUB_ENV + echo "SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0" >> $GITHUB_ENV - name: Set up Python uses: actions/setup-python@v6 with: From 713f193405e4e63e8c179cc045de88d785cfa4bc Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 15:04:36 -0700 Subject: [PATCH 49/53] test espei ci branch --- .github/workflows/pytest.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index bed72f4..f6e67bb 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -33,7 +33,7 @@ jobs: run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei + run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@260603-test#egg=espei - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 100fe713c94379c15d57b71befa149493fef6c3d Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 15:05:25 -0700 Subject: [PATCH 50/53] remove env variables --- .github/workflows/pytest.yaml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index f6e67bb..518b0c1 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -18,11 +18,6 @@ jobs: - uses: actions/checkout@v5 with: fetch-depth: 0 # fetch the entire repo history, required to guarantee setuptools_scm will pick up tags - - name: Set env variables - if: matrix.pycalphad_develop_version - run: | - echo "SETUPTOOLS_SCM_PRETEND_VERSION_FOR_PYCALPHAD=1.0.0" >> $GITHUB_ENV - echo "SETUPTOOLS_SCM_PRETEND_VERSION_FOR_ESPEI=1.0.0" >> $GITHUB_ENV - name: Set up Python uses: actions/setup-python@v6 with: From 31f15f48ac07ff080a9706e4640aa8122f47d5e6 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 15:10:33 -0700 Subject: [PATCH 51/53] use correct branch --- .github/workflows/pytest.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index 518b0c1..a307e96 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -28,7 +28,7 @@ jobs: run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@260603-test#egg=espei + run: python -m pip install git+https://github.com/bocklund/ESPEI.git@260603-test#egg=espei - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 784f76baafd9f3d23613368b49d6f041ce9fb405 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Wed, 3 Jun 2026 15:36:38 -0700 Subject: [PATCH 52/53] switch espei branch to master --- .github/workflows/pytest.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index a307e96..69a5715 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -28,7 +28,7 @@ jobs: run: python -m pip install git+https://github.com/pycalphad/pycalphad.git@develop#egg=pycalphad - name: Install espei development version if: matrix.pycalphad_develop_version - run: python -m pip install git+https://github.com/bocklund/ESPEI.git@260603-test#egg=espei + run: python -m pip install git+https://github.com/PhasesResearchLab/ESPEI.git@master#egg=espei - name: Save pycalphad version run: | echo "PYCALPHAD_VERSION=$(python -c "from importlib.metadata import version;print(version('pycalphad'))")" >> $GITHUB_ENV From 5374d7700d9b6b0718712edb1eef54776a8c2238 Mon Sep 17 00:00:00 2001 From: Nicholas Ury Date: Fri, 5 Jun 2026 09:02:04 -0700 Subject: [PATCH 53/53] update version for merge --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index de167e3..fdb14e2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta" [project] name = "kawin" -version = "0.4.0" +version = "0.5.0" authors = [ {name = "Nicholas Ury", email = "nury12n@gmail.com"}, ]