remove unnecessary lines and update examples

materialsgenomefoundation · Jul 24, 2024 · f61e4fa · f61e4fa
1 parent aaac02d
commit f61e4fa
Show file tree

Hide file tree

Showing 17 changed files with 90 additions and 172 deletions.
diff --git a/examples/01_Binary_Precipitation.ipynb b/examples/01_Binary_Precipitation.ipynb
diff --git a/examples/02_Multicomponent_Precipitation.ipynb b/examples/02_Multicomponent_Precipitation.ipynb
diff --git a/examples/03_Multiphase_Precipitation.ipynb b/examples/03_Multiphase_Precipitation.ipynb
diff --git a/examples/04_Precipitation_with_Elastic_Energy.ipynb b/examples/04_Precipitation_with_Elastic_Energy.ipynb
diff --git a/examples/05_Strength_Modeling.ipynb b/examples/05_Strength_Modeling.ipynb
diff --git a/examples/06_Single_Phase_Diffusion.ipynb b/examples/06_Single_Phase_Diffusion.ipynb
diff --git a/examples/07_Homogenization_Model.ipynb b/examples/07_Homogenization_Model.ipynb
diff --git a/examples/08_Model_Coupling.ipynb b/examples/08_Model_Coupling.ipynb
diff --git a/examples/09_Thermodynamics.ipynb b/examples/09_Thermodynamics.ipynb
diff --git a/examples/10_Surrogates.ipynb b/examples/10_Surrogates.ipynb
diff --git a/examples/11_Extra_Factors.ipynb b/examples/11_Extra_Factors.ipynb
diff --git a/examples/12_Custom_Iterators.ipynb b/examples/12_Custom_Iterators.ipynb
diff --git a/kawin/thermo/BinTherm.py b/kawin/thermo/BinTherm.py
@@ -160,9 +160,6 @@ def _interfacialCompositionFromEq(self, T, gExtra = 0, precPhase = None):
 
         #Compute equilibrium at guess composition
         cond = {v.X(self.elements[1]): self._guessComposition[precPhase], v.T: T, v.P: 101325, v.GE: gExtra}
-        #eq = equilibrium(self.db, self.elements, [self.phases[0], precPhase], cond, model=self.models,
-        #                phase_records={self.phases[0]: self.phase_records[self.phases[0]], precPhase: self.phase_records[precPhase]},
-        #                calc_opts = {'pdens': self.pDens})
         eq = equilibrium(self.db, self.elements, [self.phases[0], precPhase], cond, model=self.models,
                         phase_records=self.phase_records,
                         calc_opts = {'pdens': self.pDens})
@@ -240,9 +237,6 @@ def _interfacialCompositionFromCurvature(self, T, gExtra = 0, precPhase = None):
 
         #Compute equilibrium at guess composition
         cond = {v.X(self.elements[1]): self._guessComposition[precPhase], v.T: T, v.P: 101325, v.GE: self.gOffset, v.N: 1}
-        #eq = equilibrium(self.db, self.elements, [self.phases[0], precPhase], cond, model=self.models,
-        #                phase_records={self.phases[0]: self.phase_records[self.phases[0]], precPhase: self.phase_records[precPhase]},
-        #                calc_opts = {'pdens': self.pDens})
         eq = equilibrium(self.db, self.elements, [self.phases[0], precPhase], cond, model=self.models,
                         phase_records=self.phase_records,
                         calc_opts = {'pdens': self.pDens})

diff --git a/kawin/thermo/FreeEnergyHessian.py b/kawin/thermo/FreeEnergyHessian.py
@@ -1,8 +1,4 @@
 import numpy as np
-from pycalphad import Model, variables as v
-#from pycalphad.codegen.callables import build_callables
-
-setattr(v, 'GE', v.StateVariable('GE'))
 
 def hessian(chemical_potentials, composition_set):
     '''

diff --git a/kawin/thermo/LocalEquilibrium.py b/kawin/thermo/LocalEquilibrium.py
@@ -1,6 +1,5 @@
 from pycalphad.core.solver import Solver
 from pycalphad.core.composition_set import CompositionSet
-from pycalphad.codegen.callables import build_phase_records
 from pycalphad import calculate, variables as v
 import numpy as np
 

diff --git a/kawin/thermo/Mobility.py b/kawin/thermo/Mobility.py
@@ -6,8 +6,6 @@
 from symengine import exp, Symbol, Add
 from kawin.thermo.FreeEnergyHessian import partialdMudX, dMudX
 
-setattr(v, 'GE', v.StateVariable('GE'))
-
 #List of interstitial elements
 # When calculating interdiffusivity, we do not require reference element
 # When calculating the mobility factor, we have an additional vacancy term to multiply by

diff --git a/kawin/thermo/Thermodynamics.py b/kawin/thermo/Thermodynamics.py
@@ -1,18 +1,14 @@
 import numpy as np
 from pycalphad import Model, Database, calculate, equilibrium, variables as v
-#from pycalphad.codegen.callables import build_callables, build_phase_records
-#from pycalphad.codegen.callables import build_phase_records
 from pycalphad.codegen.phase_record_factory import PhaseRecordFactory
 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.FreeEnergyHessian import dMudX
 from kawin.thermo.LocalEquilibrium import local_equilibrium
-import matplotlib.pyplot as plt
 import copy
 from tinydb import where
 
-#setattr(v, 'GE', v.StateVariable('GE'))
 class ExtraFreeEnergyType(v.IndependentPotential):
     implementation_units = 'joules'
     display_units = 'joules'
@@ -143,11 +139,6 @@ def _buildThermoModels(self):
                                                        self.models[self.phases[0]].state_variables, 
                                                        self.models, parameters=self._parameters)
 
-        #self.phase_records = build_phase_records(self.db, self.elements, self.phases,
-        #                                         self.models[self.phases[0]].state_variables,
-        #                                         self.models, build_gradients=True, build_hessians=True,
-        #                                         parameters=self._parameters)
-
         self.OCMphase_records = {}
         for i in range(1, len(self.phases)):
             if self.orderedPhase[self.phases[i]]:
@@ -156,12 +147,6 @@ def _buildThermoModels(self):
                                                                                               include_grad=False, 
                                                                                               include_hess=False)
 
-                #self.OCMphase_records[self.phases[i]] = build_phase_records(self.db, self.elements, [self.phases[i]],
-                #                                                            self.models[self.phases[0]].state_variables,
-                #                                                            {self.phases[i]: self.models[self.phases[i]]},
-                #                                                            output='OCM', build_gradients=False, build_hessians=False, 
-                #                                                            parameters=self._parameters)
-
     def _buildMobilityModels(self):
         '''
         Builds mobility models for phases that have model parameters
@@ -205,45 +190,6 @@ def _buildMobilityModels(self):
             if len(phase_diff_params[p]) > 0:
                 self.diffCallables[p] = {c: self.mob_phase_records.get_phase_property(p, 'DIFF_'+c, include_grad=False, include_hess=False).func for c in self.phase_records[p].nonvacant_elements}
 
-        # for p in self.phases:
-        #     #Get mobility/diffusivity of phase p if exists
-        #     param_search = self.db.search
-        #     param_query_mob = (
-        #         (where('phase_name') == p) & \
-        #         (where('parameter_type') == 'MQ') | \
-        #         (where('parameter_type') == 'MF')
-        #     )
-
-        #     param_query_diff = (
-        #         (where('phase_name') == p) & \
-        #         (where('parameter_type') == 'DQ') | \
-        #         (where('parameter_type') == 'DF')
-        #     )
-
-        #     pMob = param_search(param_query_mob)
-        #     pDiff = param_search(param_query_diff)
-
-        #     if len(pMob) > 0 or len(pDiff) > 0:
-        #         self.mobModels[p] = MobilityModel(self.db, self.elements, p, parameters=param_keys)
-        #         if len(pMob) > 0:
-        #             self.mobCallables[p] = {}
-        #             for c in self.phase_records[p].nonvacant_elements:
-        #                 #bcp = build_callables(self.db, self.elements, [p], {p: self.mobModels[p]},
-        #                 #                    parameter_symbols=self._parameters, output='MOB_'+c, build_gradients=False, build_hessians=False,
-        #                 #                    additional_statevars=[v.T, v.P, v.N, v.GE])
-        #                 #self.mobCallables[p][c] = bcp['MOB_'+c]['callables'][p]
-
-        #                 self.mobCallables[p][c] = self.phase_records.get_phase_property(p, 'MOB_'+c, include_grad=False, include_hess=False)
-        #         else:
-        #             self.diffCallables[p] = {}
-        #             for c in self.phase_records[p].nonvacant_elements:
-        #                 #bcp = build_callables(self.db, self.elements, [p], {p: self.mobModels[p]},
-        #                 #                    parameter_symbols=self._parameters, output='DIFF_'+c, build_gradients=False, build_hessians=False,
-        #                 #                    additional_statevars=[v.T, v.P, v.N, v.GE])
-        #                 #self.diffCallables[p][c] = bcp['DIFF_'+c]['callables'][p]
-
-        #                 self.diffCallables[p][c] = self.phase_records.get_phase_property(p, 'DIFF_'+c, include_grad=False, include_hess=False)
-
         #This applies to all phases since this is typically reflective of quenched-in vacancies
         self.mobility_correction = {A: 1 for A in self.elements}
 
@@ -477,7 +423,6 @@ def getEq(self, x, T, gExtra = 0, precPhase = None):
                 phases.append(precPhase)
             else:
                 phases = [p for p in precPhase]
-        phaseRec = {p: self.phase_records[p] for p in phases}
 
         if not hasattr(x, '__len__'):
             x = [x]
@@ -487,23 +432,10 @@ def getEq(self, x, T, gExtra = 0, precPhase = None):
             x = x[1:]
 
         cond = self._getConditions(x, T, gExtra+self.gOffset)
-
-        #eq = equilibrium(self.db, self.elements, phases, cond, model=self.models, 
-        #                 phase_records=phaseRec, 
-        #                 calc_opts={'pdens': self.pDens})
-
-        #print(phases, {p: self.models[p] for p in phases})
-        #sub_models = {p: self.models[p] for p in phases}
-        #sub_phase_records = PhaseRecordFactory(self.db, self.elements, 
-        #                                               sub_models[phases[0]].state_variables, 
-        #                                               sub_models, parameters=self._parameters)
-        #eq = equilibrium(self.db, self.elements, phases, cond, model=sub_models, 
-        #                 phase_records=sub_phase_records, 
-        #                 calc_opts={'pdens': self.pDens})
 
         # Phases, models and phase records should match in the list of phases
         # Here, I create a model dictionary of the relevant phases
-        # Then, I hijack the models in the phase records with this sublist
+        # Then, I replace the models in the phase records with this sublist
         # After equilibrium, restore the original model list
         sub_models = {p: self.models[p] for p in phases}
         self.phase_records.models = sub_models