ModulesAndNodes/MacroNodes.py at main · Sriram2631/ModulesAndNodes · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
import pyiron_workflow as pwf
from DataClassNode import DataInputs, WorkflowState
from typing import Union, Optional, Any

@pwf.as_macro_node
def SurfaceEnergyForStrainValue(
    self,
    IdataClass: Union[DataInputs.dataclass,WorkflowState.dataclass],
    strain_value,
):
    from CalculationNodes import ForceMinimization
    from FormattingNodes import Strain_to_name, OutputDecider
    from ArithmeticNodes import compute_gamma
    from StructureManipulationNodes import apply_strain, add_vacuum

    self.comm = Strain_to_name(strain=strain_value)

    self.StrainingStructure = apply_strain(I=IdataClass,
                                           strain=strain_value,
                                           deformation_axis=0
                                          )

    self.PeriodicCellMinimization = ForceMinimization(I = self.StrainingStructure,
                                                      Structure_variable_name='StrainedStructure',
                                                      poisson_relaxation=False,
                                                      return_as_dataclass=True,
                                                      comment=self.comm)

    self.OpeningSurfaces = add_vacuum(self.PeriodicCellMinimization,
                                      Structure_variable_name="Structure_Minimized",
                                      override_vacuum=True)

    self.MinimizationWithSurfaces = ForceMinimization(I = self.OpeningSurfaces,
                                                      Structure_variable_name="Structure_w_vacuum",
                                                      poisson_relaxation=False,
                                                      return_as_dataclass=True,
                                                      comment=self.comm)

    self.gamma_area = compute_gamma(I_Periodic = self.PeriodicCellMinimization,
                                    I_Surfaces = self.MinimizationWithSurfaces,
                                    verbose = IdataClass.verbose)

    self.gamma = self.gamma_area.outputs.gamma
    self.area = self.gamma_area.outputs.area

    self.WrappedResults = OutputDecider(
        strain=strain_value,
        gamma=self.gamma,
        area=self.area,
        PressureTensor=self.MinimizationWithSurfaces.outputs.Output.Pressures, #_Minimization,
        FinalCell=self.MinimizationWithSurfaces.outputs.Output.Cell, #_Minimization,
        ForceMax_w_surfaces=self.MinimizationWithSurfaces.outputs.Output.ForceMax #_Minimization
    )

    return self.WrappedResults

@pwf.as_macro_node
def MinimizationAtDifferentStrains(
    self,
    IdataClass: Union[DataInputs.dataclass,WorkflowState.dataclass],
    strain_value,
):
    from CalculationNodes import ForceMinimization
    from FormattingNodes import Strain_to_name
    from ArithmeticNodes import compute_gamma
    from StructureManipulationNodes import apply_strain, add_vacuum

    self.comm = Strain_to_name(strain=strain_value)

    self.StrainingStructure = apply_strain(
        IdataClass, strain_value
    )

    self.PeriodicCellMinimization = ForceMinimization(self.StrainingStructure,
                                                      Structure_variable_name='StrainedStructure',
                                                      comment=self.comm, poisson_relaxation=True,
                                                      return_as_dataclass=False)

    return self.PeriodicCellMinimization


@pwf.as_macro_node
def WrappedForLoop(self,IdataClass, strain_list):

    self.df = pwf.Workflow.create.for_node(
        body_node_class=MinimizationAtDifferentStrains,
        iter_on="strain_value",
        IdataClass = IdataClass,
        strain_value= strain_list
    )

    return self.df


@pwf.as_macro_node
def FaultEnergiesAtDifferentDeformations(self, fraction: float, I: Union[DataInputs.dataclass, WorkflowState.dataclass]):
    from StructureManipulationNodes import DeformStructure
    from CalculationNodes import ForceMinimization
    from FormattingNodes import Strain_to_name
    from ArithmeticNodes import compute_gamma

    self.comm = Strain_to_name(strain=fraction)

    self.SlippingStructure = DeformStructure(I=I,
                                             Mode=I.DeformationMode,
                                             fraction=fraction
                                             )
    self.SetSelectiveDynamics = set_selective_dynamics(self.SlippingStructure,
                                                       Structure_variable_name='DeformedStructure')

    self.PeriodicCellMinimization = ForceMinimization(I=self.SetSelectiveDynamics.outputs.I_out,
                                                      Structure_variable_name=self.SetSelectiveDynamics.outputs.AlteredStructureName,
                                                      # 'DeformedStructure_seldyn',  # Structure variable name needs to be added with a _seldyn
                                                      comment=self.comm,
                                                      poisson_relaxation=False,
                                                      return_as_dataclass=True
                                                      )
    self.gamma_area = compute_gamma(I_Periodic=I,
                                    I_Surfaces=self.PeriodicCellMinimization,
                                    verbose=False)

    self.gamma = self.gamma_area.outputs.gamma
    self.DeformedStructure_final = self.PeriodicCellMinimization.outputs.Output.Structure_Minimized

    return self.gamma, self.DeformedStructure_final