fiqus 2024.5.2__py3-none-any.whl → 2024.7.0__py3-none-any.whl

fiqus/post_processors/PostProcessConductorAC.py

@@ -0,0 +1,49 @@
+import os
+import numpy as np
+import re
+import matplotlib.pyplot as plt
+import matplotlib.pylab as pl
+from matplotlib.animation import FuncAnimation
+import pandas as pd
+from scipy import integrate, interpolate
+from typing import (List, Literal, Callable)
+from pydantic import BaseModel
+
+from fiqus.utils.Utils import FilesAndFolders as Util
+from fiqus.data.DataFiQuSConductorAC_Strand import CACStrandSolve, CACStrandPostproc, CACStrandMesh, CACStrandGeometry
+from fiqus.plotters.PlotPythonConductorAC import PlotPython, SimulationData
+
+
+class PostProcess:
+    """
+    This class loads and stores the data from a simulation and can apply various postprocessing operations on the data. 
+    The simulation data is saved as a SimulationData object.
+    """
+    def __init__(self, fdm, model_data_output_path) -> None:
+        self.fdm = fdm
+        self.model_data_output_path = model_data_output_path
+        self.geometry_name = f"Geometry_{self.fdm.run.geometry}"
+        self.mesh_name = f"Mesh_{self.fdm.run.mesh}"
+        self.solution_name = f"Solution_{self.fdm.run.solution}"
+
+        self.simulation_data = SimulationData(model_data_output_path, self.geometry_name, self.mesh_name, self.solution_name)
+
+    def plot_instantaneous_loss(self):
+        print("Total loss: ", self.simulation_data.cumulative_power["TotalLoss"].iloc[-1])
+        print("Total filament loss: ", self.simulation_data.cumulative_power["FilamentLoss"].iloc[-1])
+        print("Total coupling loss: ", self.simulation_data.cumulative_power["CouplingLoss"].iloc[-1])
+        print("Total eddy loss: ", self.simulation_data.cumulative_power["EddyLoss"].iloc[-1])
+        plot_options = self.fdm.magnet.postproc.plot_instantaneous_power
+        self.simulation_data.plot_instantaneous_power(
+            show=plot_options.show, 
+            title=plot_options.title, 
+            save_plot=plot_options.save, 
+            save_folder_path=os.path.join(self.model_data_output_path, self.geometry_name, self.mesh_name, self.solution_name),
+            save_file_name=plot_options.save_file_name,
+            overwrite=self.fdm.run.overwrite
+            )
+
+
+
+
+

fiqus/pro_assemblers/ProAssembler.py

@@ -16,7 +16,7 @@ class ASS_PRO:
         else:
             self.naming_conv = naming_conv
 
-    def assemble_combined_pro(self, template, rm, dm, rc=None, mf=None, ps=None, ed=None, BH_curves_path: str = ''):
+    def assemble_combined_pro(self, template, rm, dm, rc=None, mf=None, ps=None, ed=None, mp=None, BH_curves_path: str = ''):
         """
         Generates model .pro file from .pro template and regions model (rm)
         :param BH_curves_path: path of the BH curves pro file
@@ -27,14 +27,15 @@ class ASS_PRO:
         :param mf: full path to mesh file to be used in solution
         :param ps: previous solution folder (this is used by CWS for co-simulation run)
         :param ed: excitation dictionary with lists (e.g. times and currents) to be used in a pro file (e.g. transient simulation)
+        :param mp: material properties data structure (for CAC with Geometry YAML)
         :return: None. Generates .pro file and saves it on disk in the model folder under model_name.pro
         """
         loader = FileSystemLoader(combined.__path__)
         env = Environment(loader=loader, variable_start_string='<<', variable_end_string='>>',
                           trim_blocks=True, lstrip_blocks=True)
-        env.globals.update(set=set, str=str, int=int, zip=zip, enumerate=enumerate, list=list, len=len, arange=np.arange, Pi=np.pi)  # this is to pass python zip function to the template, as normally it is not available. It should work for passing any python function that is not available in .pro template.
+        env.globals.update(set=set, str=str, int=int, float=float, zip=zip, enumerate=enumerate, list=list, len=len, isinstance=isinstance, arange=np.arange, Pi=np.pi)  # this is to pass python zip function to the template, as normally it is not available. It should work for passing any python function that is not available in .pro template.
         pro_template = env.get_template(template)
-        output_from_parsed_template = pro_template.render(BHcurves=BH_curves_path, rm=rm, rc=rc, dm=dm, mf=mf, nc=self.naming_conv, ps=ps, ed=ed)
+        output_from_parsed_template = pro_template.render(BHcurves=BH_curves_path, rm=rm, rc=rc, dm=dm, mf=mf, nc=self.naming_conv, ps=ps, ed=ed, mp=mp)
         with open(f"{self.file_base_path}.pro", "w") as tf:
             tf.write(output_from_parsed_template)
 

fiqus/pro_templates/combined/CCT_template.pro

@@ -1,51 +1,51 @@
 Group {
-{% for name, number in zip(rm.powered.vol.names, rm.powered.vol.numbers) %}
+{% for name, number in zip(rm.powered['cct'].vol.names, rm.powered['cct'].vol.numbers) %}
   <<name>> = Region[{<<number>>}];
 {% endfor %}
-{% for name, number in zip(rm.powered.surf_in.names, rm.powered.surf_in.numbers) %}
+{% for name, number in zip(rm.powered['cct'].surf_in.names, rm.powered['cct'].surf_in.numbers) %}
   <<name>> = Region[{<<number>>}];
 {% endfor %}
-{% for name, number in zip(rm.powered.surf_out.names, rm.powered.surf_out.numbers) %}
+{% for name, number in zip(rm.powered['cct'].surf_out.names, rm.powered['cct'].surf_out.numbers) %}
   <<name>> = Region[{<<number>>}];
 {% endfor %}
-{% for name, number in zip(rm.induced.vol.names, rm.induced.vol.numbers) %}
+{% for name, number in zip(rm.induced['cct'].vol.names, rm.induced['cct'].vol.numbers) %}
   <<name>> = Region[{<<number>>}];
 {% endfor %}
-  <<nc.omega>><<nc.cond>> = Region[{<<(rm.powered.vol.numbers+rm.induced.vol.numbers)|join(', ')>>}];
+  <<nc.omega>><<nc.cond>> = Region[{<<(rm.powered['cct'].vol.numbers+rm.induced['cct'].vol.numbers)|join(', ')>>}];
   //<<nc.line>><<nc.air>> = Region[{<<rm.air.line.number>>}];
   //<<nc.omega>><<nc.air>> = Region[{<<([rm.air.vol.number]+[rm.air.line.number])|join(', ')>>}];
   <<nc.omega>><<nc.air>> = Region[{<<rm.air.vol.number>>}];
-  <<nc.omega>> = Region[{<<(rm.powered.vol.numbers+rm.induced.vol.numbers+[rm.air.vol.number])|join(', ')>>}];
-  <<nc.terms>> = Region[{<<rm.powered.surf_in.numbers|join(', ')>>, <<rm.powered.surf_out.numbers|join(', ')>>}];
-  <<nc.bd>><<nc.omega>> = Region[{<< rm.air.surf.number>>, << rm.powered.surf_in.numbers|join(', ')>>, << rm.powered.surf_out.numbers|join(', ')>>}];
-  <<nc.omega>><<nc.powered>> = Region[{<<rm.powered.vol.numbers|join(', ')>>}];
+  <<nc.omega>> = Region[{<<(rm.powered['cct'].vol.numbers+rm.induced['cct'].vol.numbers+[rm.air.vol.number])|join(', ')>>}];
+  <<nc.terms>> = Region[{<<rm.powered['cct'].surf_in.numbers|join(', ')>>, <<rm.powered['cct'].surf_out.numbers|join(', ')>>}];
+  <<nc.bd>><<nc.omega>> = Region[{<< rm.air.surf.number>>, << rm.powered['cct'].surf_in.numbers|join(', ')>>, << rm.powered['cct'].surf_out.numbers|join(', ')>>}];
+  <<nc.omega>><<nc.powered>> = Region[{<<rm.powered['cct'].vol.numbers|join(', ')>>}];
   
 
-  {% for name, number in zip(rm.powered.cochain.names, rm.powered.cochain.numbers) %}
+  {% for name, number in zip(rm.powered['cct'].cochain.names, rm.powered['cct'].cochain.numbers) %}
   DefineConstant[ <<name>> = {<<number>>, Min 1, Step 1, Closed 1,
       Name "Cohomology/<<name>>"} ];
   <<name>> = Region[{<<name>>}];
   {% endfor %}
-  Cuts<<nc.powered>> = Region[ {<<rm.powered.cochain.names|join(', ')>>} ];
-  {% for name, number in zip(rm.induced.cochain.names, rm.induced.cochain.numbers) %}
+  Cuts<<nc.powered>> = Region[ {<<rm.powered['cct'].cochain.names|join(', ')>>} ];
+  {% for name, number in zip(rm.induced['cct'].cochain.names, rm.induced['cct'].cochain.numbers) %}
   DefineConstant[ <<name>> = {<<number>>, Min 1, Step 1,
       Name "Cohomology/<<name>>"} ];
   <<name>> = Region[{<<name>>}];
   {% endfor %}
-  Cuts<<nc.induced>> = Region[ {<<rm.induced.cochain.names|join(', ')>>} ];
+  Cuts<<nc.induced>> = Region[ {<<rm.induced['cct'].cochain.names|join(', ')>>} ];
   DomainDummy = Region[ 12345 ] ; // Dummy region number for postpro with functions
 }
 Function {
   DefineConstant
   [
-	{% for vol_name, current in zip(rm.powered.vol.names, rm.powered.vol.currents) %}
+	{% for vol_name, current in zip(rm.powered['cct'].vol.names, rm.powered['cct'].vol.currents) %}
     I_<<vol_name>> = {<<current>>, Step 1, Name "Powering/<<vol_name>>_Current [A]"},
 	{% endfor %}
-	{% for vol_name, sigma, mu_r in zip(rm.powered.vol.names, rm.powered.vol.sigmas, rm.powered.vol.mu_rs) %}
+	{% for vol_name, sigma, mu_r in zip(rm.powered['cct'].vol.names, rm.powered['cct'].vol.sigmas, rm.powered['cct'].vol.mu_rs) %}
     <<vol_name>>_Conductivity  = {<<sigma>>, Min 0, Step 1e6, Name "Materials/<<vol_name>> Cond. [S per m]"},
 	<<vol_name>>_Permeability  = {<<mu_r>>, Min 0, Step 1e1, Name "Materials/<<vol_name>> Rel. Perm. [-]"},
 	{% endfor %}
-	{% for vol_name, sigma, mu_r in zip(rm.induced.vol.names, rm.induced.vol.sigmas, rm.induced.vol.mu_rs) %}
+	{% for vol_name, sigma, mu_r in zip(rm.induced['cct'].vol.names, rm.induced['cct'].vol.sigmas, rm.induced['cct'].vol.mu_rs) %}
     <<vol_name>>_Conductivity  = {<<sigma>>, Min 0, Step 1e6, Name "Materials/<<vol_name>> Cond. [S per m]"},
 	<<vol_name>>_Permeability  = {<<mu_r>>, Min 0, Step 1e1, Name "Materials/<<vol_name>> Rel. Perm. [-]"},
 	{% endfor %}
@@ -54,12 +54,12 @@ Function {
   ];
   mu0 = 4*Pi*1e-7; 				// Vacuum permeability
   nu []  = 1./mu0;
-{% for vol_name in rm.powered.vol.names %}
+{% for vol_name in rm.powered['cct'].vol.names %}
   I_<<vol_name>>[] = I_<<vol_name>>;
   sigma[<<vol_name>>] = <<vol_name>>_Conductivity;
   mu[<<vol_name>>] = mu0*<<vol_name>>_Permeability;
 {% endfor %}
-{% for vol_name in rm.induced.vol.names %}
+{% for vol_name in rm.induced['cct'].vol.names %}
   sigma[<<vol_name>>] = <<vol_name>>_Conductivity;
   mu[<<vol_name>>] = mu0*<<vol_name>>_Permeability;
 {% endfor %}
@@ -111,14 +111,14 @@ Constraint {
   }
   { Name VoltageAV ;
     Case {
-      {% for cut_name in rm.induced.cochain.names %}
+      {% for cut_name in rm.induced['cct'].cochain.names %}
 	  { Region <<cut_name>>; Value 0. ; }
 	  {% endfor %}
     }
   }
   { Name CurrentAV ;
     Case {
-	  {% for cut_name, vol_name in zip(rm.powered.cochain.names, rm.powered.vol.names) %}
+	  {% for cut_name, vol_name in zip(rm.powered['cct'].cochain.names, rm.powered['cct'].vol.names) %}
       { Region <<cut_name>>; Value I_<<vol_name>>[] ; }
 	  {% endfor %}
     }
@@ -187,9 +187,9 @@ Formulation {
         In <<nc.omega>><<nc.cond>>; Integration Int; Jacobian Vol;  }
 		GlobalTerm { [ - Dof{I<<nc.powered>>} , {V<<nc.powered>>} ] ; In Cuts<<nc.powered>>; }
 		GlobalTerm { [ - Dof{I<<nc.induced>>} , {V<<nc.induced>>} ] ; In Cuts<<nc.induced>>; }
-	{% for cut_name in rm.powered.cochain.names %}
+	{% for cut_name in rm.powered['cct'].cochain.names %}
 	{% endfor %}
-	{% for cut_name in rm.induced.cochain.names %}
+	{% for cut_name in rm.induced['cct'].cochain.names %}
 	{% endfor %}
     }
   }
@@ -225,7 +225,7 @@ PostProcessing {
           In <<nc.omega>><<nc.cond>>; Jacobian Vol; } } }
       { Name h; Value{ Local{ [ 1./mu[]*({d a}) ] ;
             In <<nc.omega>>; Jacobian Vol; } } }
-	  {% for cut_name, vol_name in zip(rm.powered.cochain.names, rm.powered.vol.names) %}
+	  {% for cut_name, vol_name in zip(rm.powered['cct'].cochain.names, rm.powered['cct'].vol.names) %}
       { Name I_<<vol_name>> ; Value { Term { [ {I_p} ] ; In <<cut_name>> ; } } }
       { Name V_<<vol_name>> ; Value { Term { [ {V_p} ] ; In <<cut_name>> ; } } }
       { Name Z_<<vol_name>> ; Value { Term { [ {V_p}/{I_p} ] ; In <<cut_name>> ; } } }
@@ -236,7 +236,7 @@ PostProcessing {
       { Name imV_<<vol_name>> ; Value { Term { [ Im[{V_p}] ] ; In <<cut_name>> ; } } }
       { Name imZ_<<vol_name>> ; Value { Term { [ Im[{V_p}/{I_p}] ] ; In <<cut_name>> ; } } }
 	  {% endfor %}
-	  {% for cut_name, vol_name in zip(rm.induced.cochain.names, rm.induced.vol.names) %}
+	  {% for cut_name, vol_name in zip(rm.induced['cct'].cochain.names, rm.induced['cct'].vol.names) %}
 	    { Name I_<<vol_name>> ; Value { Term { [ {I_i} ] ; In <<cut_name>> ; } } }
       { Name V_<<vol_name>> ; Value { Term { [ {V_i} ] ; In <<cut_name>> ; } } }
       { Name reI_<<vol_name>> ; Value { Term { [ Re[{I_i}] ] ; In <<cut_name>> ; } } }
@@ -245,7 +245,7 @@ PostProcessing {
       { Name imV_<<vol_name>> ; Value { Term { [ Im[{V_i}] ] ; In <<cut_name>> ; } } }
 	  {% endfor %}
     { Name MagEnergy ;  Value { Integral { [ 1/2 * nu[{d a}]*{d a} * {d a} ] ; In <<nc.omega>><<nc.cond>> ; Jacobian Vol ; Integration Int ; } } }
-    { Name Inductance_from_MagEnergy ; Value { Term { Type Global; [ 2 * $MagEnergy /(I_<<rm.powered.vol.names[0]>>[]*I_<<rm.powered.vol.names[0]>>[]) ] ; In DomainDummy ; } } }  
+    { Name Inductance_from_MagEnergy ; Value { Term { Type Global; [ 2 * $MagEnergy /(I_<<rm.powered['cct'].vol.names[0]>>[]*I_<<rm.powered['cct'].vol.names[0]>>[]) ] ; In DomainDummy ; } } }  
     }
   }
 }