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

fiqus/data/DataFiQuSPancake3D.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Annotated
+from typing import Literal, Optional, Annotated, Union
 from contextvars import ContextVar
 import logging
 import math
@@ -26,9 +26,9 @@ logger = logging.getLogger(__name__)
 # ======================================================================================
 # Available materials: =================================================================
 NormalMaterialName = Literal[
-    "Copper", "Hastelloy", "Silver", "Indium", "Stainless Steel"
+    "Copper", "Hastelloy", "Silver", "Indium", "Stainless Steel", "Kapton", "G10"
 ]
-SuperconductingMaterialName = Literal["HTSSuperPower", "HTSFujikura"]
+SuperconductingMaterialName = Literal["HTSSuperPower", "HTSFujikura", "HTSSucci"]
 # ======================================================================================
 # ======================================================================================
 
@@ -47,6 +47,8 @@ thermalConductivityMacroNames = {
     "Silver": "MATERIAL_ThermalConductivity_Silver_T",
     "Indium": "MATERIAL_ThermalConductivity_Indium_T",
     "Stainless Steel": "MATERIAL_ThermalConductivity_SSteel_T",
+    "Kapton": "MATERIAL_ThermalConductivity_Kapton_T",
+    "G10": "MATERIAL_ThermalConductivity_G10_T",
 }
 heatCapacityMacroNames = {
     "Copper": "MATERIAL_SpecificHeatCapacity_Copper_T",
@@ -54,30 +56,29 @@ heatCapacityMacroNames = {
     "Silver": "MATERIAL_SpecificHeatCapacity_Silver_T",
     "Indium": "MATERIAL_SpecificHeatCapacity_Indium_T",
     "Stainless Steel": "MATERIAL_SpecificHeatCapacity_SSteel_T",
+    "Kapton": "MATERIAL_SpecificHeatCapacity_Kapton_T",
+    "G10": "MATERIAL_SpecificHeatCapacity_G10_T",
 }
-getdpTSAOnlyResistivityFunctions = {
-    "Indium": "TSA_CFUN_rhoIn_T_constantThickness_fct_only",
-    "Stainless Steel": None,
-}
-getdpTSAMassResistivityFunctions = {
-    "Indium": "TSA_CFUN_rhoIn_T_constantThickness_mass",
-    "Stainless Steel": None,
+getdpTSAStiffnessThermalConductivityMacroNames = {
+    "Indium": "MATERIAL_ThermalConductivity_Indium_TSAStiffness_T",
+    "Stainless Steel": "MATERIAL_ThermalConductivity_SSteel_TSAStiffness_T",
+    "Kapton": "MATERIAL_ThermalConductivity_Kapton_TSAStiffness_T",
+    "G10": "MATERIAL_ThermalConductivity_G10_TSAStiffness_T",
+    "Copper": "MATERIAL_ThermalConductivity_Copper_TSAStiffness_T",
 }
-getdpTSAStiffnessResistivityFunctions = {
-    "Indium": "TSA_CFUN_rhoIn_T_constantThickness_stiffness",
-    "Stainless Steel": None,
-}
-getdpTSAMassThermalConductivityFunctions = {
-    "Indium": "TSA_CFUN_kIn_constantThickness_mass",
-    "Stainless Steel": "TSA_CFUN_kSteel_T_constantThickness_mass",
-}
-getdpTSAStiffnessThermalConductivityFunctions = {
-    "Indium": "TSA_CFUN_kIn_constantThickness_stiffness",
-    "Stainless Steel": "TSA_CFUN_kSteel_T_constantThickness_stiffness",
+getdpTSAMassThermalConductivityMacroNames = {
+    "Indium": "MATERIAL_ThermalConductivity_Indium_TSAMass_T",
+    "Stainless Steel": "MATERIAL_ThermalConductivity_SSteel_TSAMass_T",
+    "Kapton": "MATERIAL_ThermalConductivity_Kapton_TSAMass_T",
+    "G10": "MATERIAL_ThermalConductivity_G10_TSAMass_T",
+    "Copper": "MATERIAL_ThermalConductivity_Copper_TSAMass_T",
 }
-getdpTSAMassHeatCapacityFunctions = {
-    "Indium": "TSA_CFUN_CvIn_constantThickness_mass",
-    "Stainless Steel": "TSA_CFUN_CvSteel_T_constantThickness_mass",
+getdpTSAMassHeatCapacityMacroNames = {
+    "Indium": "MATERIAL_SpecificHeatCapacity_Indium_TSAMass_T",
+    "Stainless Steel": "MATERIAL_SpecificHeatCapacity_SSteel_TSAMass_T",
+    "Kapton": "MATERIAL_SpecificHeatCapacity_Kapton_TSAMass_T",
+    "G10": "MATERIAL_SpecificHeatCapacity_G10_TSAMass_T",
+    "Copper": "MATERIAL_SpecificHeatCapacity_Copper_TSAMass_T",
 }
 getdpTSARHSFunctions = {
     "Indium": "TSA_CFUN_rhoIn_T_constantThickness_rhs",
@@ -87,9 +88,33 @@ getdpTSATripleFunctions = {
     "Indium": "TSA_CFUN_rhoIn_T_constantThickness_triple",
     "Stainless Steel": None,
 }
+getdpTSAOnlyResistivityFunctions = {
+    "Indium": "TSA_CFUN_rhoIn_T_constantThickness_fct_only",
+    "Stainless Steel": None,
+}
+getdpTSAMassResistivityMacroNames = {
+    "Indium": "MATERIAL_Resistivity_Indium_TSAMass_T",
+    "Stainless Steel": None,
+    "Copper": "MATERIAL_Resistivity_Copper_TSAMass_T",
+}
+getdpTSAStiffnessResistivityMacroNames = {
+    "Indium": "MATERIAL_Resistivity_Indium_TSAStiffness_T",
+    "Stainless Steel": None,
+    "Copper": "MATERIAL_Resistivity_Copper_TSAStiffness_T",
+}
 getdpCriticalCurrentDensityFunctions = {
     "HTSSuperPower": "CFUN_HTS_JcFit_SUPERPOWER_T_B_theta",
     "HTSFujikura": "CFUN_HTS_JcFit_Fujikura_T_B_theta",
+    "HTSSucci": "CFUN_HTS_JcFit_Succi_T_B",
+}
+getdpNormalMaterialNames = {
+    "Copper": "Copper",
+    "Hastelloy": "Hastelloy",
+    "Silver": "Silver",
+    "Indium": "Indium",
+    "Stainless Steel": "StainlessSteel",
+    "Kapton": "Kapton",
+    "G10": "G10",
 }
 # ======================================================================================
 # ======================================================================================
@@ -112,6 +137,10 @@ PositionRequiredQuantityName = Literal[
     "criticalCurrent",
     "axialComponentOfTheMagneticField",
     "debug",
+    "jHTS",
+    "currentSharingIndex",
+    "arcLength",
+    "turnNumber"
 ]
 PositionNotRequiredQuantityName = Literal[
     "currentThroughCoil",
@@ -120,7 +149,9 @@ PositionNotRequiredQuantityName = Literal[
     "timeConstant",
     "totalResistiveHeating",
     "magneticEnergy",
-    "maximumTemperature"
+    "maximumTemperature",
+    "cryocoolerAveragePower",
+    "cryocoolerAverageTemperature"
 ]
 # ======================================================================================
 # ======================================================================================
@@ -145,6 +176,10 @@ EMQuantities = [
     "totalResistiveHeating",
     "magneticEnergy",
     "axialComponentOfTheMagneticField",
+    "jHTS",
+    "currentSharingIndex",
+    "arcLength",
+    "turnNumber"
 ]
 ThermalQuantities = [
     "temperature",
@@ -153,6 +188,8 @@ ThermalQuantities = [
     "specificHeatCapacity",
     "maximumTemperature",
     "debug",
+    "cryocoolerAveragePower",
+    "cryocoolerAverageTemperature"
 ]
 quantityProperNames = {
     "magneticField": "Magnetic Field",
@@ -177,6 +214,12 @@ quantityProperNames = {
     "timeConstant": "Time Constant",
     "axialComponentOfTheMagneticField": "Axial Component of the Magnetic Field",
     "maximumTemperature": "Maximum Temperature",
+    "jHTS": "Current Density in HTS Layer",
+    "currentSharingIndex": "Current Sharing Index",
+    "cryocoolerAveragePower": "Cryocooler Average Power",
+    "arcLength": "Arc Length",
+    "turnNumber": "Turn Number",
+    "cryocoolerAverageTemperature": "Cryocooler Average Temperature"
 }
 
 quantityUnits = {
@@ -195,13 +238,19 @@ quantityUnits = {
     "resistivity": "Ohm*m",
     "thermalConductivity": "W/m*K",
     "specificHeatCapacity": "J/kg*K",
-    "jHTSOverjCritical": "A/A",
+    "jHTSOverjCritical": "-",
     "criticalCurrent": "A",
     "debug": "1",
     "inductance": "H",
     "timeConstant": "s",
     "axialComponentOfTheMagneticField": "T",
     "maximumTemperature": "K",
+    "jHTS": "A/m^2",
+    "currentSharingIndex": "-",
+    "cryocoolerAveragePower": "W",
+    "arcLength": "m",
+    "turnNumber": "-",
+    "cryocoolerAverageTemperature": "K"
 }
 
 getdpQuantityNames = {
@@ -227,6 +276,12 @@ getdpQuantityNames = {
     "timeConstant": "RESULT_timeConstant",
     "axialComponentOfTheMagneticField": "RESULT_axialComponentOfTheMagneticField",
     "maximumTemperature": "RESULT_maximumTemperature",
+    "jHTS": "RESULT_jHTS",
+    "currentSharingIndex": "RESULT_currentSharingIndex",
+    "cryocoolerAveragePower": "RESULT_cryocoolerAveragePower",
+    "arcLength": "RESULT_arcLength",
+    "turnNumber": "RESULT_turnNumber",
+    "cryocoolerAverageTemperature": "RESULT_cryocoolerAverageTemperature"
 }
 
 getdpPostOperationNames = {
@@ -252,6 +307,12 @@ getdpPostOperationNames = {
     "timeConstant": "POSTOP_timeConstant",
     "axialComponentOfTheMagneticField": "POSTOP_axialComponentOfTheMagneticField",
     "maximumTemperature": "POSTOP_maximumTemperature",
+    "jHTS": "POSTOP_jHTS",
+    "currentSharingIndex": "POSTOP_currentSharingIndex",
+    "cryocoolerAveragePower": "POSTOP_cryocoolerAveragePower",
+    "arcLength": "POSTOP_arcLength",
+    "turnNumber": "POSTOP_turnNumber",
+    "cryocoolerAverageTemperature": "POSTOP_cryocoolerAverageTemperature"
 }
 
 # ======================================================================================
@@ -541,24 +602,20 @@ Pancake3DPosition = Pancake3DPositionInCoordinates | Pancake3DPositionInTurnNumb
 # ======================================================================================
 class Pancake3DGeometryWinding(BaseModel):
     # Mandatory:
-    r_i: PositiveFloat = Field(
-        alias="innerRadius",
+    innerRadius: PositiveFloat = Field(
         title="Inner Radius",
         description="Inner radius of the winding.",
     )
-    t: PositiveFloat = Field(
-        alias="thickness",
+    thickness: PositiveFloat = Field(
         title="Winding Thickness",
         description="Thickness of the winding.",
     )
-    N: float = Field(
-        alias="numberOfTurns",
+    numberOfTurns: float = Field(
         ge=3,
         title="Number of Turns",
         description="Number of turns of the winding.",
     )
-    h: PositiveFloat = Field(
-        alias="height",
+    height: PositiveFloat = Field(
         title="Winding Height",
         description="Height/width of the winding.",
     )
@@ -570,41 +627,40 @@ class Pancake3DGeometryWinding(BaseModel):
         description="The The name to be used in the mesh..",
         examples=["winding", "myWinding"],
     )
-    NofVolPerTurn: int = Field(
+    numberOfVolumesPerTurn: int = Field(
         default=2,
         validate_default=True,
-        alias="numberOfVolumesPerTurn",
         ge=2,
         title="Number of Volumes Per Turn (Advanced Input)",
         description="The number of volumes per turn (CAD related, not physical).",
     )
 
-    @field_validator("NofVolPerTurn")
+    @field_validator("numberOfVolumesPerTurn")
     @classmethod
-    def check_NofVolPerTurn(cls, NofVolPerTurn):
+    def check_numberOfVolumesPerTurn(cls, numberOfVolumesPerTurn):
         geometry = geometry_input.get()
         mesh = mesh_input.get()
 
-        # Check if the NofVolPerTurn is compatible swith the azimuthal number of
+        # Check if the numberOfVolumesPerTurn is compatible swith the azimuthal number of
         # elements per turn:
         for i, ane in enumerate(mesh["winding"]["azimuthalNumberOfElementsPerTurn"]):
-            if ane % NofVolPerTurn != 0:
+            if ane % numberOfVolumesPerTurn != 0:
                 raise ValueError(
                     "The azimuthal number of elements per turn for the pancake coil"
                     f" number {i+1} is ({ane}), but it must be divisible by the number"
-                    f" of volumes per turn ({geometry['winding']['NofVolPerTurn']})!"
+                    f" of volumes per turn ({geometry['winding']['numberOfVolumesPerTurn']})!"
                     " So it needs to be rounded to"
-                    f" {math.ceil(ane/NofVolPerTurn)*NofVolPerTurn:.5f} or"
-                    f" {math.floor(ane/NofVolPerTurn)*NofVolPerTurn:.5f}."
+                    f" {math.ceil(ane/numberOfVolumesPerTurn)*numberOfVolumesPerTurn:.5f} or"
+                    f" {math.floor(ane/numberOfVolumesPerTurn)*numberOfVolumesPerTurn:.5f}."
                 )
 
         structured = checkIfAirOrTerminalMeshIsStructured()
 
         if structured:
             # If the mesh is structured, the number of volumes per turn must be 4:
-            NofVolPerTurn = 4
+            numberOfVolumesPerTurn = 4
 
-        return NofVolPerTurn
+        return numberOfVolumesPerTurn
 
     @computed_field
     @cached_property
@@ -720,8 +776,7 @@ class Pancake3DGeometryWinding(BaseModel):
 
 class Pancake3DGeometryContactLayer(BaseModel):
     # Mandatory:
-    tsa: bool = Field(
-        alias="thinShellApproximation",
+    thinShellApproximation: bool = Field(
         title="Use Thin Shell Approximation",
         description=(
             "If True, the contact layer will be modeled with 2D shell elements (thin"
@@ -729,10 +784,13 @@ class Pancake3DGeometryContactLayer(BaseModel):
             " with 3D elements."
         ),
     )
-    t: PositiveFloat = Field(
-        alias="thickness",
+    thickness: PositiveFloat = Field(
         title="Contact Layer Thickness",
-        description="Thickness of the contact layer.",
+        description=("Thickness of the contact layer."
+                     "It is the total thickness of the contact or insulation layer."
+                     "In particular, for perfect insulation this would be the sum of the insulation layer of the two adjacent CC with an insulation layer of "
+                     "thickness t/2 on each side."
+        ),
     )
 
     # Optionals:
@@ -746,24 +804,23 @@ class Pancake3DGeometryContactLayer(BaseModel):
 
 class Pancake3DGeometryTerminalBase(BaseModel):
     # Mandatory:
-    t: PositiveFloat = Field(
-        alias="thickness",
+    thickness: PositiveFloat = Field(
         title="Terminal Thickness",
         description="Thickness of the terminal's tube.",
     )  # thickness
 
-    @field_validator("t")
+    @field_validator("thickness")
     @classmethod
-    def check_t(cls, t):
+    def check_t(cls, thickness):
         geometry = geometry_input.get()
 
-        if t < geometry["winding"]["thickness"] / 2:
+        if thickness < geometry["winding"]["thickness"] / 2:
             raise ValueError(
                 "Terminal's thickness is smaller than half of the winding's thickness!"
                 " Please increase the terminal's thickness."
             )
 
-        return t
+        return thickness
 
 
 class Pancake3DGeometryInnerTerminal(Pancake3DGeometryTerminalBase):
@@ -780,7 +837,7 @@ class Pancake3DGeometryInnerTerminal(Pancake3DGeometryTerminalBase):
         """Return inner radius of the inner terminal."""
         geometry = geometry_input.get()
 
-        innerRadius = geometry["winding"]["innerRadius"] - 2 * self.t
+        innerRadius = geometry["winding"]["innerRadius"] - 2 * self.thickness
         if innerRadius < 0:
             raise ValueError(
                 "Inner terminal's radius is smaller than 0! Please decrease the inner"
@@ -802,15 +859,15 @@ class Pancake3DGeometryOuterTerminal(Pancake3DGeometryTerminalBase):
     @cached_property
     def r(self) -> float:
         """Return outer radius of the outer terminal."""
-        outerRadius = getWindingOuterRadius() + 2 * self.t
+        outerRadius = getWindingOuterRadius() + 2 * self.thickness
 
         return outerRadius
 
 
 class Pancake3DGeometryTerminals(BaseModel):
     # 1) User inputs:
-    i: Pancake3DGeometryInnerTerminal = Field(alias="inner")
-    o: Pancake3DGeometryOuterTerminal = Field(alias="outer")
+    inner: Pancake3DGeometryInnerTerminal = Field()
+    outer: Pancake3DGeometryOuterTerminal = Field()
 
     # Optionals:
     firstName: str = Field(
@@ -829,8 +886,7 @@ class Pancake3DGeometryTerminals(BaseModel):
 
 class Pancake3DGeometryAirBase(BaseModel):
     # Mandatory:
-    margin: PositiveFloat = Field(
-        alias="axialMargin",
+    axialMargin: PositiveFloat = Field(
         title="Axial Margin of the Air",
         description=(
             "Axial margin between the ends of the air and first/last pancake coils."
@@ -846,7 +902,6 @@ class Pancake3DGeometryAirBase(BaseModel):
     )
     shellTransformation: bool = Field(
         default=False,
-        alias="shellTransformation",
         title="Use Shell Transformation",
         description=(
             "Generate outer shell air to apply shell transformation if True (GetDP"
@@ -856,7 +911,6 @@ class Pancake3DGeometryAirBase(BaseModel):
     shellTransformationMultiplier: float = Field(
         default=1.2,
         gt=1.1,
-        alias="shellTransformationMultiplier",
         title="Shell Transformation Multiplier (Advanced Input)",
         description=(
             "multiply the air's outer dimension by this value to get the shell's outer"
@@ -875,9 +929,8 @@ class Pancake3DGeometryAirBase(BaseModel):
         description="name of the shell volume to be used in the mesh",
         examples=["air-Shell", "myAirShell"],
     )
-    fragment: bool = Field(
+    generateGapAirWithFragment: bool = Field(
         default=False,
-        alias="generateGapAirWithFragment",
         title="Generate Gap Air with Fragment (Advanced Input)",
         description=(
             "generate the gap air with gmsh/model/occ/fragment if true (CAD related,"
@@ -885,19 +938,19 @@ class Pancake3DGeometryAirBase(BaseModel):
         ),
     )
 
-    @field_validator("margin")
+    @field_validator("axialMargin")
     @classmethod
-    def check_margin(cls, margin):
+    def check_axialMargin(cls, axialMargin):
         geometry = geometry_input.get()
         windingHeight = geometry["winding"]["height"]
 
-        if margin < windingHeight / 2:
+        if axialMargin < windingHeight / 2:
             raise ValueError(
                 "Axial margin is smaller than half of the winding's height! Please"
                 " increase the axial margin."
             )
 
-        return margin
+        return axialMargin
 
     @computed_field
     @cached_property
@@ -910,69 +963,67 @@ class Pancake3DGeometryAirBase(BaseModel):
 
 class Pancake3DGeometryAirCylinder(Pancake3DGeometryAirBase):
     type: Literal["cylinder"] = Field(default="cylinder", title="Air Type")
-    r: PositiveFloat = Field(
+    radius: PositiveFloat = Field(
         default=None,
-        alias="radius",
         title="Air Radius",
         description="Radius of the air (for cylinder type air).",
     )
 
-    @field_validator("r")
+    @field_validator("radius")
     @classmethod
-    def check_r(cls, r):
+    def check_r(cls, radius):
         geometry = geometry_input.get()
         outerTerminalOuterRadius = (
             getWindingOuterRadius() + 2 * geometry["terminals"]["outer"]["thickness"]
         )
 
-        if r < outerTerminalOuterRadius * 1.5:
+        if radius < outerTerminalOuterRadius * 1.5:
             raise ValueError(
                 "Radius of the air must be at least 1.5 times the outer radius of the"
                 " winding! Please increase the radius of the air."
             )
 
-        return r
+        return radius
 
     @computed_field
     @cached_property
     def shellOuterRadius(self) -> float:
         """Return outer radius of the air."""
-        shellOuterRadius = self.shellTransformationMultiplier * self.r
+        shellOuterRadius = self.shellTransformationMultiplier * self.radius
 
         return shellOuterRadius
 
 
 class Pancake3DGeometryAirCuboid(Pancake3DGeometryAirBase):
     type: Literal["cuboid"] = Field(default="cuboid", title="Air Type")
-    a: PositiveFloat = Field(
+    sideLength: PositiveFloat = Field(
         default=None,
-        alias="sideLength",
         title="Air Side Length",
         description="Side length of the air (for cuboid type air).",
     )
 
-    @field_validator("a")
+    @field_validator("sideLength")
     @classmethod
-    def check_a(cls, a):
+    def check_a(cls, sideLength):
         geometry = geometry_input.get()
         outerTerminalOuterRadius = (
             getWindingOuterRadius() + 2 * geometry["terminals"]["outer"]["thickness"]
         )
 
-        if a / 2 < outerTerminalOuterRadius * 1.5:
+        if sideLength / 2 < outerTerminalOuterRadius * 1.5:
             raise ValueError(
                 "Half of the side length of the air must be at least 1.5 times the"
                 " outer radius of the winding! Please increase the side length of the"
                 " air."
             )
 
-        return a
+        return sideLength
 
     @computed_field
     @cached_property
     def shellSideLength(self) -> float:
         """Return outer radius of the air."""
-        shellSideLength = self.shellTransformationMultiplier * self.a
+        shellSideLength = self.shellTransformationMultiplier * self.sideLength
 
         return shellSideLength
 
@@ -991,8 +1042,7 @@ Pancake3DGeometryAir = Annotated[
 # ======================================================================================
 class Pancake3DMeshWinding(BaseModel):
     # Mandatory:
-    axne: list[PositiveInt] | PositiveInt = Field(
-        alias="axialNumberOfElements",
+    axialNumberOfElements: list[PositiveInt] | PositiveInt = Field(
         title="Axial Number of Elements",
         description=(
             "The number of axial elements for the whole height of the coil. It can be"
@@ -1001,8 +1051,7 @@ class Pancake3DMeshWinding(BaseModel):
         ),
     )
 
-    ane: list[PositiveInt] | PositiveInt = Field(
-        alias="azimuthalNumberOfElementsPerTurn",
+    azimuthalNumberOfElementsPerTurn: list[PositiveInt] | PositiveInt = Field(
         title="Azimuthal Number of Elements Per Turn",
         description=(
             "The number of azimuthal elements per turn of the coil. It can be either a"
@@ -1011,8 +1060,7 @@ class Pancake3DMeshWinding(BaseModel):
         ),
     )
 
-    rne: list[PositiveInt] | PositiveInt = Field(
-        alias="radialNumberOfElementsPerTurn",
+    radialNumberOfElementsPerTurn: list[PositiveInt] | PositiveInt = Field(
         title="Winding Radial Number of Elements Per Turn",
         description=(
             "The number of radial elements per tape of the winding. It can be either a"
@@ -1022,9 +1070,8 @@ class Pancake3DMeshWinding(BaseModel):
     )
 
     # Optionals:
-    axbc: list[PositiveFloat] | PositiveFloat = Field(
+    axialDistributionCoefficient: list[PositiveFloat] | PositiveFloat = Field(
         default=[1],
-        alias="axialDistributionCoefficient",
         title="Axial Bump Coefficients",
         description=(
             "If 1, it won't affect anything. If smaller than 1, elements will get finer"
@@ -1049,7 +1096,7 @@ class Pancake3DMeshWinding(BaseModel):
         ),
     )
 
-    @field_validator("axne", "ane", "rne", "axbc", "elementType")
+    @field_validator("axialNumberOfElements", "azimuthalNumberOfElementsPerTurn", "radialNumberOfElementsPerTurn", "axialDistributionCoefficient", "elementType")
     @classmethod
     def check_inputs(cls, value, info: ValidationInfo):
         geometry = geometry_input.get()
@@ -1101,8 +1148,7 @@ class Pancake3DMeshWinding(BaseModel):
 
 class Pancake3DMeshContactLayer(BaseModel):
     # Mandatory:
-    rne: list[PositiveInt] = Field(
-        alias="radialNumberOfElementsPerTurn",
+    radialNumberOfElementsPerTurn: list[PositiveInt] = Field(
         title="Contact Layer Radial Number of Elements Per Turn",
         description=(
             "The number of radial elements per tape of the contact layer. It can be"
@@ -1111,7 +1157,7 @@ class Pancake3DMeshContactLayer(BaseModel):
         ),
     )
 
-    @field_validator("rne")
+    @field_validator("radialNumberOfElementsPerTurn")
     @classmethod
     def check_inputs(cls, value):
         geometry = geometry_input.get()
@@ -1179,7 +1225,7 @@ class Pancake3DSolveAir(BaseModel):
     )
 
 
-class Pancake3DSolveIcVsLength(BaseModel):
+class Pancake3DSolveIcVsLengthList(BaseModel):
     lengthValues: list[float] = Field(
         title="Tape Length Values",
         description="Tape length values that corresponds to criticalCurrentValues.",
@@ -1188,15 +1234,39 @@ class Pancake3DSolveIcVsLength(BaseModel):
         title="Critical Current Values",
         description="Critical current values that corresponds to lengthValues.",
     )
+    lengthUnit: str = Field(
+        title="Unit",
+        description=(
+            "Unit of the critical current values. "
+            "It can be either the arc length in meter or "
+            "the number of turns."
+        ),
+        examples=["meter", "turnNumber"],
+    )
+
+class Pancake3DSolveIcVsLengthCSV(BaseModel):
+    csvFile: str = Field(
+        title="CSV File",
+        description="The path of the CSV file that contains the critical current values.",
+    )
+
+    lengthUnit: str = Field(
+        title="Unit",
+        description=(
+            "Unit of the critical current values. "
+            "It can be either the arc length in meter or "
+            "the number of turns."
+        ),
+        examples=["meter", "turnNumber"],
+    )
 
 
 class Pancake3DSolveMaterialBase(BaseModel):
     name: str
 
     # Optionals:
-    rrr: PositiveFloat = Field(
+    RRR: PositiveFloat = Field(
         default=100,
-        alias="residualResistanceRatio",
         title="Residual Resistance Ratio",
         description=(
             "Residual-resistivity ratio (also known as Residual-resistance ratio or"
@@ -1204,9 +1274,8 @@ class Pancake3DSolveMaterialBase(BaseModel):
             " temperature and at 0 K."
         ),
     )
-    rrrRefT: PositiveFloat = Field(
+    RRRRefTemp: PositiveFloat = Field(
         default=295,
-        alias="residualResistanceRatioReferenceTemperature",
         title="Residual Resistance Ratio Reference Temperature",
         description="Reference temperature for residual resistance ratio",
     )
@@ -1249,48 +1318,48 @@ class Pancake3DSolveMaterialBase(BaseModel):
 
     @computed_field
     @cached_property
-    def getdpTSAMassResistivityFunction(self) -> str:
+    def getdpTSAMassResistivityMacroName(self) -> str:
         """Return the GetDP function name of the material's mass resistivity."""
-        if self.name not in getdpTSAMassResistivityFunctions:
+        if self.name not in getdpTSAMassResistivityMacroNames:
             return "NOT_DEFINED_IN_DATA_FIQUS_PANCAKE3D"
 
-        return getdpTSAMassResistivityFunctions[self.name]
+        return getdpTSAMassResistivityMacroNames[self.name]
 
     @computed_field
     @cached_property
-    def getdpTSAStiffnessResistivityFunction(self) -> str:
+    def getdpTSAStiffnessResistivityMacroName(self) -> str:
         """Return the GetDP function name of the material's stiffness resistivity."""
-        if self.name not in getdpTSAStiffnessResistivityFunctions:
+        if self.name not in getdpTSAStiffnessResistivityMacroNames:
             return "NOT_DEFINED_IN_DATA_FIQUS_PANCAKE3D"
 
-        return getdpTSAStiffnessResistivityFunctions[self.name]
+        return getdpTSAStiffnessResistivityMacroNames[self.name]
 
     @computed_field
     @cached_property
-    def getdpTSAMassThermalConductivityFunction(self) -> str:
+    def getdpTSAMassThermalConductivityMacroName(self) -> str:
         """Return the GetDP function name of the material's mass thermal conductivity."""
-        if self.name not in getdpTSAMassThermalConductivityFunctions:
+        if self.name not in getdpTSAMassThermalConductivityMacroNames:
             return "NOT_DEFINED_IN_DATA_FIQUS_PANCAKE3D"
 
-        return getdpTSAMassThermalConductivityFunctions[self.name]
+        return getdpTSAMassThermalConductivityMacroNames[self.name]
 
     @computed_field
     @cached_property
-    def getdpTSAStiffnessThermalConductivityFunction(self) -> str:
+    def getdpTSAStiffnessThermalConductivityMacroName(self) -> str:
         """Return the GetDP function name of the material's stiffness thermal conductivity."""
-        if self.name not in getdpTSAStiffnessThermalConductivityFunctions:
+        if self.name not in getdpTSAStiffnessThermalConductivityMacroNames:
             return "NOT_DEFINED_IN_DATA_FIQUS_PANCAKE3D"
 
-        return getdpTSAStiffnessThermalConductivityFunctions[self.name]
+        return getdpTSAStiffnessThermalConductivityMacroNames[self.name]
 
     @computed_field
     @cached_property
-    def getdpTSAMassHeatCapacityFunction(self) -> str:
+    def getdpTSAMassHeatCapacityMacroName(self) -> str:
         """Return the GetDP function name of the material's mass heat capacity."""
-        if self.name not in getdpTSAMassHeatCapacityFunctions:
+        if self.name not in getdpTSAMassHeatCapacityMacroNames:
             return "NOT_DEFINED_IN_DATA_FIQUS_PANCAKE3D"
 
-        return getdpTSAMassHeatCapacityFunctions[self.name]
+        return getdpTSAMassHeatCapacityMacroNames[self.name]
 
     @computed_field
     @cached_property
@@ -1317,33 +1386,43 @@ class Pancake3DSolveNormalMaterial(Pancake3DSolveMaterialBase):
         title="Material Name",
     )
 
+    @computed_field
+    @cached_property
+    def getdpNormalMaterialGetDPName(self) -> str:
+        """Return the GetDP material name of the normal conducting material. To make names with spaces like 'Stainless Steel' more robust."""
+        if self.name not in getdpNormalMaterialNames:
+            raise ValueError(
+                f"Normal conducting material '{self.name}' is not defined"
+                " in FiQuS!"
+            )
+
+        return getdpNormalMaterialNames[self.name]
+
 
 class Pancake3DSolveSuperconductingMaterial(Pancake3DSolveMaterialBase):
     # Mandatory:
     name: SuperconductingMaterialName = Field(
-        title="Superconduncting Material Name",
+        title="Superconducting Material Name",
     )
     nValue: PositiveFloat = Field(
         default=30,
-        alias="N-Value for E-J Power Law",
         description="N-value for E-J power law.",
     )
-    IcAtTAndBref: PositiveFloat | str | Pancake3DSolveIcVsLength = Field(
-        alias="criticalCurrentAtReferenceTemperatureAndField",
-        title="Critical Current at Reference Temperature and Field",
+    IcAtTAndBref: PositiveFloat | Pancake3DSolveIcVsLengthCSV | Pancake3DSolveIcVsLengthList = Field(
+        title="Critical Current at Reference Temperature and Field in A",
         description=(
-            "Critical current at reference temperature and magnetic field."
+            "Critical current in A at reference temperature and magnetic field."
             "The critical current value will"
-            " change with temperature depending on the superconductor material.\nEither"
+            " change with temperature depending on the superconductor material.Either"
             " the same critical current for the whole tape or the critical current with"
             " respect to the tape length can be specified. To specify the same critical"
             " current for the entire tape, just use a scalar. To specify critical"
             " current with respect to the tape length: a CSV file can be used, or"
             " lengthValues and criticalCurrentValues can be given as lists. The data"
-            " will be linearly interpolated.\nIf a CSV file is to be used, the input"
+            " will be linearly interpolated.If a CSV file is to be used, the input"
             " should be the name of a CSV file (which is in the same folder as the"
             " input file) instead of a scalar. The first column of the CSV file will be"
-            " the tape length, and the second column will be the critical current."
+            " the tape length in m, and the second column will be the critical current in A. "
         ),
         examples=[230, "IcVSlength.csv"],
     )
@@ -1367,40 +1446,21 @@ class Pancake3DSolveSuperconductingMaterial(Pancake3DSolveMaterialBase):
             " A factor of 1 means no scaling such that the HTS layer is isotropic."
         ),
     )
-    minimumPossibleResistivity: NonNegativeFloat = Field(
-        default=0,
-        title="Minimum Possible Resistivity",
-        description=(
-            "The resistivity of the winding won't be lower than this value, no matter"
-            " what."
-        ),
-    )
-    maximumPossibleResistivity: PositiveFloat = Field(
-        default=1,
-        title="Maximum Possible Resistivity",
-        description=(
-            "The resistivity of the winding won't be higher than this value, no matter"
-            " what."
-        ),
-    )
 
     IcReferenceTemperature: PositiveFloat = Field(
         default=77,
-        alias="criticalCurrentReferenceTemperature",
         title="Critical Current Reference Temperature",
         description="Critical current reference temperature in Kelvin.",
     )
 
     IcReferenceBmagnitude: NonNegativeFloat = Field(
         default=0.0,
-        alias="criticalCurrentReferenceFieldMagnitude",
         title="Critical Current Reference Magnetic Field Magnitude",
         description="Critical current reference magnetic field magnitude in Tesla.",
     )
 
     IcReferenceBangle: NonNegativeFloat = Field(
         default=90.0,
-        alias="criticalCurrentReferenceFieldAngle",
         title="Critical Current Reference Magnetic Field Angle",
         description= (
             "Critical current reference magnetic field angle in degrees."
@@ -1416,8 +1476,8 @@ class Pancake3DSolveSuperconductingMaterial(Pancake3DSolveMaterialBase):
         """Return the critical current values of the material."""
         if hasattr(self.IcAtTAndBref, "criticalCurrentValues"):
             return self.IcAtTAndBref.criticalCurrentValues
-        elif isinstance(self.IcAtTAndBref, str):
-            csv_file_path = pathlib.Path(input_file_path.get()).parent / self.IcAtTAndBref
+        elif hasattr(self.IcAtTAndBref, "csvFile"):
+            csv_file_path = pathlib.Path(input_file_path.get()).parent / self.IcAtTAndBref.csvFile
             # return the second column:
             IcValues = list(pd.read_csv(csv_file_path, header=None).iloc[:, 1])
             for Ic in IcValues:
@@ -1435,8 +1495,8 @@ class Pancake3DSolveSuperconductingMaterial(Pancake3DSolveMaterialBase):
         """Return the length values of the material."""
         if hasattr(self.IcAtTAndBref, "lengthValues"):
             return self.IcAtTAndBref.lengthValues
-        elif isinstance(self.IcAtTAndBref, str):
-            csv_file_path = pathlib.Path(input_file_path.get()).parent / self.IcAtTAndBref
+        elif hasattr(self.IcAtTAndBref, "csvFile"):
+            csv_file_path = pathlib.Path(input_file_path.get()).parent / self.IcAtTAndBref.csvFile
             # return the first column:
             lengthValues = list(pd.read_csv(csv_file_path, header=None).iloc[:, 0])
             for length in lengthValues:
@@ -1445,6 +1505,21 @@ class Pancake3DSolveSuperconductingMaterial(Pancake3DSolveMaterialBase):
             return lengthValues
         else:
             return [1]
+        
+    @computed_field
+    @cached_property
+    def IcInArcLength(self) -> int:
+        """Return 1 if Ic is given as a function of arc length in meters.
+           Return 0 if Ic is given as a function of number of turns.
+           Return -1 if Ic is given as a scalar value.
+        """
+        if hasattr(self.IcAtTAndBref, "lengthUnit"):
+            if self.IcAtTAndBref.lengthUnit == "meter":
+                return 1
+            else:
+                return 0
+        else:
+            return -1
 
     @computed_field
     @cached_property
@@ -1457,8 +1532,7 @@ class Pancake3DSolveSuperconductingMaterial(Pancake3DSolveMaterialBase):
             )
 
         return getdpCriticalCurrentDensityFunctions[self.name]
-
-
+    
 class Pancake3DSolveHTSMaterialBase(BaseModel):
     relativeThickness: float = Field(
         le=1,
@@ -1466,7 +1540,7 @@ class Pancake3DSolveHTSMaterialBase(BaseModel):
         description=(
             "Winding tapes generally consist of more than one material. Therefore, when"
             " materials are given as a list in winding, their relative thickness,"
-            " (thickness of the material) / (thickness of the winding), should be"
+            " (thickness of the material) / (thickness of the bare conductor), should be"
             " specified."
         ),
     )
@@ -1622,6 +1696,33 @@ class Pancake3DSolveWindingMaterial(Pancake3DSolveMaterial):
         description="Material properties of the shunt layer.",
     )
 
+    isotropic: Optional[bool] = Field(
+        default=False,
+        title="Isotropic Material",
+        description=(
+            "If True, resistivity and thermal conductivity are isotropic. If False, they are anisotropic. "
+            "The default is anisotropic material."
+        ),
+    )
+
+    minimumPossibleResistivity: NonNegativeFloat = Field(
+        default=1e-20,
+        title="Minimum Possible Resistivity",
+        description=(
+            "The resistivity of the winding won't be lower than this value, no matter"
+            " what."
+        ),
+    )
+    
+    maximumPossibleResistivity: PositiveFloat = Field(
+        default=0.01,
+        title="Maximum Possible Resistivity",
+        description=(
+            "The resistivity of the winding won't be higher than this value, no matter"
+            " what."
+        ),
+    )
+
     @field_validator("material")
     @classmethod
     def checkIfRelativeThicknessesSumToOne(cls, material):
@@ -1698,6 +1799,58 @@ class Pancake3DSolveWindingMaterial(Pancake3DSolveMaterial):
                     "There should be only one superconductor in the winding!"
                 )
 
+class Pancake3DTerminalCryocoolerLumpedMass(Pancake3DSolveMaterial):
+
+    material: Optional[Pancake3DSolveNormalMaterial] = Field(
+        default=Pancake3DSolveNormalMaterial(name="Copper", RRR=295),
+        title="Material",
+        description="Material from STEAM material library.",
+    )
+
+    volume: NonNegativeFloat = Field(
+        default=0,
+        title="Cryocooler Lumped Block Volume",
+        description=(
+        "Volume of the lumped thermal mass between second stage of the cryocooler and pancake coil in m^3. "
+        "A zero value effectively disables the lumped thermal mass between second stage of the cryocooler and pancake coil."
+        )
+    )
+
+    numberOfThinShellElements: PositiveInt = Field(
+        default=1,
+        title="Number of Thin Shell Elements for Cryocooler Lumped Mass",
+        description=(
+            "Number of thin shell elements in the FE formulation (GetDP related, not"
+            " physical and only used when TSA is set to True)"
+        ),
+    )
+    
+class Pancake3DTerminalCryocoolerBoundaryCondition(BaseModel):
+
+    coolingPowerMultiplier: NonNegativeFloat = Field(
+        default=1,
+        title="Cooling Power Multiplier",
+        description=(
+            "Multiplier for the cooling power. It can be used to scale"
+            " the cooling power given by the coldhead capacity map by a non-negative float factor."
+        ),
+    )
+
+    staticHeatLoadPower: NonNegativeFloat = Field(
+        default=0,
+        title="Static Heat Load Power",
+        description=(
+            "Static heat load power in W. It can be used to add a static heat load"
+            " to the cryocooler, i.e., decrease the power available for cooling. "
+            " The actual cooling power is P(t) = P_cryocooler(T) - P_staticLoad."
+        ),
+    )
+    
+    lumpedMass: Pancake3DTerminalCryocoolerLumpedMass = Field(
+        default = Pancake3DTerminalCryocoolerLumpedMass(),
+        title="Cryocooler Lumped Mass",
+        description="Thermal lumped mass between second stage of the cryocooler and pancake coil modeled via TSA.",
+    )
 
 class Pancake3DSolveTerminalMaterialAndBoundaryCondition(Pancake3DSolveMaterial):
     cooling: Literal["adiabatic", "fixedTemperature", "cryocooler"] = Field(
@@ -1708,6 +1861,13 @@ class Pancake3DSolveTerminalMaterialAndBoundaryCondition(Pancake3DSolveMaterial)
             " temperature, or cryocooler."
         ),
     )
+
+    cryocoolerOptions: Optional[Pancake3DTerminalCryocoolerBoundaryCondition] = Field(
+        default=Pancake3DTerminalCryocoolerBoundaryCondition(),
+        title="Cryocooler Boundary Condition",
+        description="Additional inputs for the cryocooler boundary condition.",
+    )
+
     transitionNotch: Pancake3DSolveMaterial = Field(
         title="Transition Notch Properties",
         description="Material properties of the transition notch volume.",
@@ -1736,7 +1896,6 @@ class Pancake3DSolveToleranceBase(BaseModel):
     normType: Literal["L1Norm", "MeanL1Norm", "L2Norm", "MeanL2Norm", "LinfNorm"] = (
         Field(
             default="L2Norm",
-            alias="normType",
             title="Norm Type",
             description=(
                 "Sometimes, tolerances return a vector instead of a scalar (ex,"
@@ -1799,7 +1958,7 @@ class Pancake3DSolveSettingsWithTolerances(BaseModel):
             if "SolutionVector" not in tolerance.quantity
         ]
         return tolerances
-
+    
 
     @computed_field
     @cached_property
@@ -1811,17 +1970,15 @@ class Pancake3DSolveSettingsWithTolerances(BaseModel):
             if "SolutionVector" in tolerance.quantity
         ]
         return tolerances
-
+    
 
 class Pancake3DSolveAdaptiveTimeLoopSettings(Pancake3DSolveSettingsWithTolerances):
     # Mandatory:
     initialStep: PositiveFloat = Field(
-        alias="initialStep",
         title="Initial Step for Adaptive Time Stepping",
         description="Initial step for adaptive time stepping",
     )
     minimumStep: PositiveFloat = Field(
-        alias="minimumStep",
         title="Minimum Step for Adaptive Time Stepping",
         description=(
             "The simulation will be aborted if a finer time step is required than this"
@@ -1829,7 +1986,6 @@ class Pancake3DSolveAdaptiveTimeLoopSettings(Pancake3DSolveSettingsWithTolerance
         ),
     )
     maximumStep: PositiveFloat = Field(
-        alias="maximumStep",
         description="Bigger steps than this won't be allowed",
     )
 
@@ -1838,13 +1994,11 @@ class Pancake3DSolveAdaptiveTimeLoopSettings(Pancake3DSolveSettingsWithTolerance
         "Euler", "Gear_2", "Gear_3", "Gear_4", "Gear_5", "Gear_6"
     ] = Field(
         default="Euler",
-        alias="integrationMethod",
         title="Integration Method",
         description="Integration method for transient analysis",
     )
     breakPoints_input: list[float] = Field(
         default=[0],
-        alias="breakPoints",
         title="Break Points for Adaptive Time Stepping",
         description="Make sure to solve the system for these times.",
     )
@@ -1951,7 +2105,6 @@ class Pancake3DSolveTimeBase(BaseModel):
     # Optionals:
     extrapolationOrder: Literal[0, 1, 2, 3] = Field(
         default=1,
-        alias="extrapolationOrder",
         title="Extrapolation Order",
         description=(
             "Before solving for the next time steps, the previous solutions can be"
@@ -1974,8 +2127,7 @@ class Pancake3DSolveTimeBase(BaseModel):
 
 class Pancake3DSolveTimeAdaptive(Pancake3DSolveTimeBase):
     timeSteppingType: Literal["adaptive"] = "adaptive"
-    adaptive: Pancake3DSolveAdaptiveTimeLoopSettings = Field(
-        alias="adaptiveSteppingSettings",
+    adaptiveSteppingSettings: Pancake3DSolveAdaptiveTimeLoopSettings = Field(
         title="Adaptive Time Loop Settings",
         description=(
             "Adaptive time loop settings (only used if stepping type is adaptive)."
@@ -1988,7 +2140,7 @@ class Pancake3DSolveTimeAdaptive(Pancake3DSolveTimeBase):
         """
         Checks if the time steps are consistent.
         """
-        if model.adaptive.initialStep > model.end:
+        if model.adaptiveSteppingSettings.initialStep > model.end:
             raise ValueError("Initial time step cannot be greater than the end time!")
 
         return model
@@ -1996,10 +2148,9 @@ class Pancake3DSolveTimeAdaptive(Pancake3DSolveTimeBase):
 
 class Pancake3DSolveTimeFixed(Pancake3DSolveTimeBase):
     timeSteppingType: Literal["fixed"] = "fixed"
-    fixed: (
+    fixedSteppingSettings: (
         list[Pancake3DSolveFixedLoopInterval] | Pancake3DSolveFixedTimeLoopSettings
     ) = Field(
-        alias="fixedSteppingSettings",
         title="Fixed Time Loop Settings",
         description="Fixed time loop settings (only used if stepping type is fixed).",
     )
@@ -2007,27 +2158,27 @@ class Pancake3DSolveTimeFixed(Pancake3DSolveTimeBase):
     @model_validator(mode="after")
     @classmethod
     def check_time_steps(cls, model: "Pancake3DSolveTimeFixed"):
-        if isinstance(model.fixed, list):
-            for i in range(len(model.fixed) - 1):
-                if model.fixed[i].endTime != model.fixed[i + 1].startTime:
+        if isinstance(model.fixedSteppingSettings, list):
+            for i in range(len(model.fixedSteppingSettings) - 1):
+                if model.fixedSteppingSettings[i].endTime != model.fixedSteppingSettings[i + 1].startTime:
                     raise ValueError(
                         "End time of the previous interval must be equal to the start"
                         " time of the next interval!"
                     )
 
-            if model.fixed[0].startTime != model.start:
+            if model.fixedSteppingSettings[0].startTime != model.start:
                 raise ValueError(
                     "Start time of the first interval must be equal to the start time"
                     " of the simulation!"
                 )
 
         else:
-            if model.fixed.step > model.end:
+            if model.fixedSteppingSettings.step > model.end:
                 raise ValueError("Time step cannot be greater than the end time!")
 
             if not (
                 math.isclose(
-                    (model.end - model.start) % model.fixed.step, 0, abs_tol=1e-8
+                    (model.end - model.start) % model.fixedSteppingSettings.step, 0, abs_tol=1e-8
                 )
             ):
                 raise ValueError("Time interval must be a multiple of the time step!")
@@ -2041,16 +2192,14 @@ Pancake3DSolveTime = Annotated[
 
 class Pancake3DSolveNonlinearSolverSettings(Pancake3DSolveSettingsWithTolerances):
     # Optionals:
-    maxIter: PositiveInt = Field(
+    maximumNumberOfIterations: PositiveInt = Field(
         default=100,
-        alias="maximumNumberOfIterations",
         title="Maximum Number of Iterations",
         description="Maximum number of iterations allowed for the nonlinear solver.",
     )
     relaxationFactor: float = Field(
         default=0.7,
         gt=0,
-        alias="relaxationFactor",
         title="Relaxation Factor",
         description=(
             "Calculated step changes of the solution vector will be multiplied with"
@@ -2063,33 +2212,34 @@ class Pancake3DSolveInitialConditions(BaseModel):
     # 1) User inputs:
 
     # Mandatory:
-    T: PositiveFloat = Field(
-        alias="temperature",
+    temperature: PositiveFloat = Field(
         title="Initial Temperature",
         description="Initial temperature of the pancake coils.",
     )
 
+class Pancake3DSolveImposedField(BaseModel):
+
+    imposedAxialField: float = Field(
+        title="Imposed Axial Magnetic Field",
+        description="Imposed axial magnetic field in Tesla. Only constant, purely axial magnetic fields are supported at the moment.",
+)
 
 class Pancake3DSolveLocalDefect(BaseModel):
     # Mandatory:
     value: NonNegativeFloat = Field(
-        alias="value",
         title="Value",
         description="Value of the local defect.",
     )
     startTurn: NonNegativeFloat = Field(
-        alias="startTurn",
         title="Start Turn",
         description="Start turn of the local defect.",
     )
     endTurn: PositiveFloat = Field(
-        alias="endTurn",
         title="End Turn",
         description="End turn of the local defect.",
     )
 
     startTime: NonNegativeFloat = Field(
-        alias="startTime",
         title="Start Time",
         description="Start time of the local defect.",
     )
@@ -2161,7 +2311,7 @@ class Pancake3DSolveLocalDefect(BaseModel):
                     "whickPancakeCoil (pancake coil number) should be given if there"
                     " are more than one pancake coil!"
                 )
-
+        
         return whichPancakeCoil
 
     @computed_field
@@ -2194,17 +2344,16 @@ class Pancake3DSolveLocalDefect(BaseModel):
 class Pancake3DSolveLocalDefects(BaseModel):
     # 1) User inputs:
 
-    jCritical: Optional[Pancake3DSolveLocalDefect] = Field(
+    criticalCurrentDensity: Optional[Pancake3DSolveLocalDefect] = Field(
         default=None,
-        alias="criticalCurrentDensity",
         title="Local Defect for Critical Current Density",
         description="Set critical current density locally.",
     )
 
-    @field_validator("jCritical")
+    @field_validator("criticalCurrentDensity")
     @classmethod
-    def check_jCritical_local_defect(cls, jCritical):
-        if jCritical is not None:
+    def check_criticalCurrentDensity_local_defect(cls, criticalCurrentDensity):
+        if criticalCurrentDensity is not None:
             solve = solve_input.get()
 
             if "material" in solve["winding"]:
@@ -2214,15 +2363,164 @@ class Pancake3DSolveLocalDefects(BaseModel):
             else:
                 windingMaterials = []
 
-            superconducting_material_is_used = "HTSSuperPower" in windingMaterials or "HTSFujikura" in windingMaterials
+            superconducting_material_is_used = "HTSSuperPower" in windingMaterials or "HTSFujikura" in windingMaterials or "HTSSucci" in windingMaterials
 
             if not superconducting_material_is_used:
                 raise ValueError(
                     "Local defects can only be set if superconducting material is used!"
                 )
             
-        return jCritical
+        return criticalCurrentDensity
+    
+
+class Pancake3DSolveConvectiveCooling(BaseModel):
+
+    heatTransferCoefficient: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Heat Transfer Coefficient",
+        description=(
+            "The heat transfer coefficient for the heat transfer between the winding and the air. "
+            "If zero, no heat transfer to the air is considered."
+            "This feature is only implemented for the thin shell approximation."
+            "At the moment, only constant values are supported."
+        ),
+    )
+
+    exteriorBathTemperature: Optional[NonNegativeFloat] = Field(
+        default=4.2,
+        title="Exterior Bath Temperature",
+        description=(
+            "The temperature of the exterior bath for convective cooling boundary condition. "
+        ),
+    )
+
+class Pancake3DSolveEECircuit(BaseModel):
+
+    inductanceInSeriesWithPancakeCoil: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Inductance in Series with Pancake Coil",
+        description=(
+            "A lumped inductance in series with the pancake coil to model a bigger coil. "
+        ),
+    )
 
+    enable: bool = Field(
+        default=False,
+        title="Enable Detection Circuit",
+        description=(
+            "Enable the detection circuit for the pancake coil. "
+        ),
+    )
+
+    ResistanceEnergyExtractionOpenSwitch: Optional[NonNegativeFloat] = Field(
+        default=1E6,
+        title="Resistance of Energy Extraction Open Switch",
+        description=(
+            "The resistance of the energy extraction switch when modeled as open. "
+        ),
+    )
+
+    ResistanceEnergyExtractionClosedSwitch: Optional[NonNegativeFloat] = Field(
+        default=1E-6,
+        title="Resistance of Energy Extraction Closed Switch",
+        description=(
+            "The resistance of the energy extraction switch when modeled as closed. "
+        ),
+    )
+
+    ResistanceCrowbarOpenSwitch: Optional[NonNegativeFloat] = Field(
+        default=1E6,
+        title="Resistance of Crowbar Open Switch",
+        description=(
+            "The resistance of the crowbar switch when modeled as open. "
+        ),
+    )
+
+    ResistanceCrowbarClosedSwitch: Optional[NonNegativeFloat] = Field(
+        default=1E-6,
+        title="Resistance of Crowbar Closed Switch",
+        description=(
+            "The resistance of the crowbar switch when modeled as closed. "
+        ),
+    )
+
+    stopSimulationAtCurrent: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Stop Simulation at Current",
+        description=(
+            "If a quench is detected and the current reaches this value, the simulation will be stopped after. "
+            "stopSimulationWaitingTime seconds."
+        ),
+    )
+
+    stopSimulationWaitingTime: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Stop Simulation Waiting Time",
+        description=(
+            "The time to wait after a quench is detected and the current reaches stopSimulationAtCurrent before stopping the simulation."
+        ),
+    )
+
+    # or use t_off from power supply? I don't like it since it's used as time value to turn off and not time interval.
+    TurnOffDeltaTimePowerSupply: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Time Interval Between Quench Detection and Power Supply Turn Off",
+        description=(
+            "The time it takes for the power supply to be turned off after quench detection. "
+            "A linear ramp-down is assumed between the time of quench detection and the time of power supply turn off."
+        ),
+    )
+
+class Pancake3DSolvePowerDensity(BaseModel):
+    power: Optional[NonNegativeFloat] = Field(
+            default=0,
+            title="Power Density",
+            description=(
+                "The power in W for an imposed power density in the winding. "
+                "'startTime', 'endTime', 'startTurn', and 'endTurn' "
+                "are also required to be set."
+            ),
+        )
+
+    startTime: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Power Density Start Time",
+        description=(
+            "The start time for the imposed power density in the winding. "
+            "'power', 'endTime', 'startTurn', and 'endTurn' "
+            "are also required to be set."
+        ),
+    )
+
+    endTime: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Power Density End Time",
+        description=(
+            "The end time for the imposed power density in the winding. "
+            "'power', 'startTime', 'startTurn', and 'endTurn' "
+            "are also required to be set."
+        ),
+    )
+
+    startArcLength: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Power Density Start Arc Length",
+        description=(
+            "The start arc length in m for the imposed power density in the winding. "
+            "'power', 'startTime', 'endTime', and 'endArcLength' "
+            "are also required to be set."
+        ),
+    )
+
+    endArcLength: Optional[NonNegativeFloat] = Field(
+        default=0,
+        title="Power Density End Arc Length",
+        description=(
+            "The end arc length in m for the imposed power density in the winding. "
+            "'power', 'startTime', 'endTime', and 'startArcLength' "
+            "are also required to be set."
+        ),
+    )
 
 class Pancake3DSolveQuantityBase(BaseModel):
     # Mandatory:
@@ -2252,7 +2550,7 @@ class Pancake3DSolveQuantityBase(BaseModel):
 
 class Pancake3DSolveSaveQuantity(Pancake3DSolveQuantityBase):
     # Optionals:
-    timesToBeSaved: list[float] = Field(
+    timesToBeSaved: Union[list[float], None] = Field(
         default=None,
         title="Times to be Saved",
         description=(
@@ -2264,7 +2562,8 @@ class Pancake3DSolveSaveQuantity(Pancake3DSolveQuantityBase):
     @field_validator("timesToBeSaved")
     @classmethod
     def updateGlobalBreakPointsList(cls, timesToBeSaved):
-        all_break_points.extend(timesToBeSaved)
+        if timesToBeSaved is not None:
+            all_break_points.extend(timesToBeSaved)
         return timesToBeSaved
 
     @field_validator("timesToBeSaved")
@@ -2274,11 +2573,12 @@ class Pancake3DSolveSaveQuantity(Pancake3DSolveQuantityBase):
         start_time = solve["time"]["start"]
         end_time = solve["time"]["end"]
 
-        for time in timesToBeSaved:
-            if time < start_time or time > end_time:
-                raise ValueError(
-                    "Times to be saved should be between the start and end times!"
-                )
+        if timesToBeSaved is not None:
+            for time in timesToBeSaved:
+                if time < start_time or time > end_time:
+                    raise ValueError(
+                        "Times to be saved should be between the start and end times!"
+                    )
 
 
 # ======================================================================================
@@ -2352,11 +2652,11 @@ class Pancake3DPostprocessTimeSeriesPlotPositionNotRequired(
     )
 
 
-Pancake3DPostprocessTimeSeriesPlot = Annotated[
+Pancake3DPostprocessTimeSeriesPlot = Optional[Annotated[
     Pancake3DPostprocessTimeSeriesPlotPositionRequired
     | Pancake3DPostprocessTimeSeriesPlotPositionNotRequired,
     Field(discriminator="quantity"),
-]
+]]
 
 
 class Pancake3DPostprocessMagneticFieldOnPlane(BaseModel):
@@ -2379,12 +2679,12 @@ class Pancake3DPostprocessMagneticFieldOnPlane(BaseModel):
         default="linear",
         title="Interpolation Method",
         description=(
-            "Interpolation type for the plot.\nBecause of the FEM basis function"
+            "Interpolation type for the plot.Because of the FEM basis function"
             " selections of FiQuS, each mesh element has a constant magnetic field"
             " vector. Therefore, for smooth 2D plots, interpolation can be"
-            " used.\nTypes:\nnearest: it will plot the nearest magnetic field value to"
-            " the plotting point.\nlinear: it will do linear interpolation to the"
-            " magnetic field values.\ncubic: it will do cubic interpolation to the"
+            " used.Types:nearest: it will plot the nearest magnetic field value to"
+            " the plotting point.linear: it will do linear interpolation to the"
+            " magnetic field values.cubic: it will do cubic interpolation to the"
             " magnetic field values."
         ),
     )
@@ -2616,48 +2916,40 @@ class Pancake3DGeometry(BaseModel):
     )
 
     # Mandatory:
-    N: PositiveInt = Field(
+    numberOfPancakes: PositiveInt = Field(
         ge=1,
-        alias="numberOfPancakes",
         title="Number of Pancakes",
         description="Number of pancake coils stacked on top of each other.",
     )
 
-    gap: PositiveFloat = Field(
-        alias="gapBetweenPancakes",
+    gapBetweenPancakes: PositiveFloat = Field(
         title="Gap Between Pancakes",
         description="Gap distance between the pancake coils.",
     )
 
-    wi: Pancake3DGeometryWinding = Field(
-        alias="winding",
+    winding: Pancake3DGeometryWinding = Field(
         title="Winding Geometry",
         description="This dictionary contains the winding geometry information.",
     )
 
-    ii: Pancake3DGeometryContactLayer = Field(
-        alias="contactLayer",
+    contactLayer: Pancake3DGeometryContactLayer = Field(
         title="Contact Layer Geometry",
         description="This dictionary contains the contact layer geometry information.",
     )
 
-    ti: Pancake3DGeometryTerminals = Field(
-        alias="terminals",
+    terminals: Pancake3DGeometryTerminals = Field(
         title="Terminals Geometry",
         description="This dictionary contains the terminals geometry information.",
     )
 
-    ai: Pancake3DGeometryAir = Field(
-        alias="air",
+    air: Pancake3DGeometryAir = Field(
         title="Air Geometry",
         description="This dictionary contains the air geometry information.",
     )
 
     # Optionals:
-    dimTol: PositiveFloat = Field(
+    dimensionTolerance: PositiveFloat = Field(
         default=1e-8,
-        gt=1e-5,
-        alias="dimensionTolerance",
         description="dimension tolerance (CAD related, not physical)",
     )
     pancakeBoundaryName: str = Field(
@@ -2677,34 +2969,41 @@ class Pancake3DGeometry(BaseModel):
 
 class Pancake3DMesh(BaseModel):
     # Mandatory:
-    wi: Pancake3DMeshWinding = Field(
-        alias="winding",
+    winding: Pancake3DMeshWinding = Field(
         title="Winding Mesh",
         description="This dictionary contains the winding mesh information.",
     )
-    ii: Pancake3DMeshContactLayer = Field(
-        alias="contactLayer",
+    contactLayer: Pancake3DMeshContactLayer = Field(
         title="Contact Layer Mesh",
         description="This dictionary contains the contact layer mesh information.",
     )
 
     # Optionals:
-    ti: Pancake3DMeshAirAndTerminals = Field(
+    terminals: Pancake3DMeshAirAndTerminals = Field(
         default=Pancake3DMeshAirAndTerminals(),
-        alias="terminals",
         title="Terminal Mesh",
         description="This dictionary contains the terminal mesh information.",
     )
-    ai: Pancake3DMeshAirAndTerminals = Field(
+    air: Pancake3DMeshAirAndTerminals = Field(
         default=Pancake3DMeshAirAndTerminals(),
-        alias="air",
         title="Air Mesh",
         description="This dictionary contains the air mesh information.",
     )
 
+    computeCohomologyForInsulating: bool = Field(
+        default=True,
+        title="Compute Cohomology for Insulating",
+        description=(
+            "Expert option only. "
+            "If False, the cohomology regions needed for simulating an insulating coil"
+            "will not be computed. This will reduce the time spent for the meshing "
+            "or more accurately the cohomology computing phase. BEWARE: The simulation " 
+            "will fail if set to False and a perfectlyInsulating coil is simulated."
+        ),
+    )
+
     # Mandatory:
-    relSizeMin: PositiveFloat = Field(
-        alias="minimumElementSize",
+    minimumElementSize: PositiveFloat = Field(
         title="Minimum Element Size",
         description=(
             "The minimum mesh element size in terms of the largest mesh size in the"
@@ -2713,8 +3012,7 @@ class Pancake3DMesh(BaseModel):
             " size as it gets away from the winding."
         ),
     )
-    relSizeMax: PositiveFloat = Field(
-        alias="maximumElementSize",
+    maximumElementSize: PositiveFloat = Field(
         title="Maximum Element Size",
         description=(
             "The maximum mesh element size in terms of the largest mesh size in the"
@@ -2724,16 +3022,16 @@ class Pancake3DMesh(BaseModel):
         ),
     )
 
-    @field_validator("relSizeMax")
+    @field_validator("maximumElementSize")
     @classmethod
-    def check_rel_size_max(cls, relSizeMax, info: ValidationInfo):
-        if relSizeMax < info.data["relSizeMin"]:
+    def check_rel_size_max(cls, maximumElementSize, info: ValidationInfo):
+        if maximumElementSize < info.data["minimumElementSize"]:
             raise ValueError(
                 "Maximum mesh element size (maximumElementSize) cannot be smaller than"
                 " the minimum mesh element size (minimumElementSize)!"
             )
 
-        return relSizeMax
+        return maximumElementSize
 
     @computed_field
     @cached_property
@@ -2744,7 +3042,7 @@ class Pancake3DMesh(BaseModel):
         meshLengthsPerElement = []
 
         # azimuthal elements:
-        for numberOfElements in self.wi.ane:
+        for numberOfElements in self.winding.azimuthalNumberOfElementsPerTurn:
             terminalOuterRadius = (
                 getWindingOuterRadius()
                 + 2 * geometry["terminals"]["outer"]["thickness"]
@@ -2754,25 +3052,25 @@ class Pancake3DMesh(BaseModel):
             )
 
         # radial elements:
-        for numberOfElements in self.wi.rne:
+        for numberOfElements in self.winding.radialNumberOfElementsPerTurn:
             meshLengthsPerElement.append(
                 geometry["winding"]["thickness"] / numberOfElements
             )
 
         if not geometry["contactLayer"]["thinShellApproximation"]:
             # radial elements:
-            for numberOfElements in self.ii.rne:
+            for numberOfElements in self.contactLayer.radialNumberOfElementsPerTurn:
                 meshLengthsPerElement.append(
                     geometry["contactLayer"]["thickness"] / numberOfElements
                 )
 
         # axial elements:
-        for numberOfElements in self.wi.axne:
+        for numberOfElements in self.winding.axialNumberOfElements:
             meshLengthsPerElement.append(
                 geometry["winding"]["height"] / numberOfElements
             )
 
-        return max(meshLengthsPerElement) * self.relSizeMin
+        return max(meshLengthsPerElement) * self.minimumElementSize
 
     @computed_field
     @cached_property
@@ -2783,7 +3081,7 @@ class Pancake3DMesh(BaseModel):
         meshLengthsPerElement = []
 
         # azimuthal elements:
-        for numberOfElements in self.wi.ane:
+        for numberOfElements in self.winding.azimuthalNumberOfElementsPerTurn:
             terminalOuterRadius = (
                 getWindingOuterRadius()
                 + 2 * geometry["terminals"]["outer"]["thickness"]
@@ -2793,25 +3091,25 @@ class Pancake3DMesh(BaseModel):
             )
 
         # radial elements:
-        for numberOfElements in self.wi.rne:
+        for numberOfElements in self.winding.radialNumberOfElementsPerTurn:
             meshLengthsPerElement.append(
                 geometry["winding"]["thickness"] / numberOfElements
             )
 
         if not geometry["contactLayer"]["thinShellApproximation"]:
             # radial elements:
-            for numberOfElements in self.ii.rne:
+            for numberOfElements in self.contactLayer.radialNumberOfElementsPerTurn:
                 meshLengthsPerElement.append(
                     geometry["contactLayer"]["thickness"] / numberOfElements
                 )
 
         # axial elements:
-        for numberOfElements in self.wi.axne:
+        for numberOfElements in self.winding.axialNumberOfElements:
             meshLengthsPerElement.append(
                 geometry["winding"]["height"] / numberOfElements
             )
 
-        return max(meshLengthsPerElement) * self.relSizeMax
+        return max(meshLengthsPerElement) * self.maximumElementSize
 
     @computed_field
     @cached_property
@@ -2849,50 +3147,48 @@ class Pancake3DMesh(BaseModel):
 
 class Pancake3DSolve(BaseModel):
     # 1) User inputs:
-    t: Pancake3DSolveTime = Field(
-        alias="time",
+    time: Pancake3DSolveTime = Field(
         title="Time Settings",
         description="All the time related settings for transient analysis.",
     )
 
-    nls: Optional[Pancake3DSolveNonlinearSolverSettings] = Field(
-        alias="nonlinearSolver",
+    nonlinearSolver: Optional[Pancake3DSolveNonlinearSolverSettings] = Field(
         title="Nonlinear Solver Settings",
         description="All the nonlinear solver related settings.",
     )
 
-    wi: Pancake3DSolveWindingMaterial = Field(
-        alias="winding",
+    winding: Pancake3DSolveWindingMaterial = Field(
         title="Winding Properties",
         description="This dictionary contains the winding material properties.",
     )
-    ii: Pancake3DSolveContactLayerMaterial = Field(
-        alias="contactLayer",
+    contactLayer: Pancake3DSolveContactLayerMaterial = Field(
         title="Contact Layer Properties",
         description="This dictionary contains the contact layer material properties.",
     )
-    ti: Pancake3DSolveTerminalMaterialAndBoundaryCondition = Field(
-        alias="terminals",
+    terminals: Pancake3DSolveTerminalMaterialAndBoundaryCondition = Field(
         title="Terminals Properties",
         description=(
             "This dictionary contains the terminals material properties and cooling"
             " condition."
         ),
     )
-    ai: Pancake3DSolveAir = Field(
-        alias="air",
+    air: Pancake3DSolveAir = Field(
         title="Air Properties",
         description="This dictionary contains the air material properties.",
     )
 
-    ic: Pancake3DSolveInitialConditions = Field(
-        alias="initialConditions",
+    initialConditions: Pancake3DSolveInitialConditions = Field(
         title="Initial Conditions",
         description="Initial conditions of the problem.",
     )
 
-    save: list[Pancake3DSolveSaveQuantity] = Field(
-        alias="quantitiesToBeSaved",
+    boundaryConditions: Union[Literal["vanishingTangentialElectricField"], Pancake3DSolveImposedField] = Field(
+        default="vanishingTangentialElectricField",
+        title="Boundary Conditions",
+        description="Boundary conditions of the problem.",
+    )
+
+    quantitiesToBeSaved: list[Pancake3DSolveSaveQuantity] = Field(
         default=None,
         title="Quantities to be Saved",
         description="List of quantities to be saved.",
@@ -2903,7 +3199,7 @@ class Pancake3DSolve(BaseModel):
         Field(
             title="Simulation Type",
             description=(
-                "FiQuS/Pancake3D can solve only electromagnetics and thermal or"
+                "FiQuS/Pancake3D can solve only electromagnetic and thermal or"
                 " electromagnetic and thermal coupled. In the weaklyCoupled setting,"
                 " thermal and electromagnetics systems will be put into different"
                 " matrices, whereas in the stronglyCoupled setting, they all will be"
@@ -2920,7 +3216,6 @@ class Pancake3DSolve(BaseModel):
 
     localDefects: Pancake3DSolveLocalDefects = Field(
         default=Pancake3DSolveLocalDefects(),
-        alias="localDefects",
         title="Local Defects",
         description=(
             "Local defects (like making a small part of the winding normal conductor at"
@@ -2934,7 +3229,9 @@ class Pancake3DSolve(BaseModel):
         description=(
             "The simulation is continued from an existing .res file.  The .res file is"
             " from a previous computation on the same geometry and mesh. The .res file"
-            " is taken from the folder Solution_<<initFromPrevious>>"
+            " is taken from the folder Solution_<<initFromPrevious>>."
+            " IMPORTANT: When the option is used, the start time should be identical to the last "
+            " time value for the <<initFromPrevious>> simulation."
         ),
     )
 
@@ -2948,15 +3245,101 @@ class Pancake3DSolve(BaseModel):
         ),
     )
 
+    voltageTapPositions: Optional[list[Pancake3DPosition]] = Field(
+        default=[],
+        title="Voltage Tap Positions",
+        description=(
+            "List of voltage tap positions. The "
+            "position can be given in the form of a list of [x, y, z] coordinates or "
+            "as turnNumber and number of pancake coil."
+        ),
+    )
+
+    EECircuit: Optional[Pancake3DSolveEECircuit] = Field(
+        default = Pancake3DSolveEECircuit(),
+        title="Detection Circuit",
+        description=(
+            "This dictionary contains the detection circuit settings."
+        ),
+    )
+
+    noOfMPITasks: Optional[Union[bool, int]] = Field(
+        default=False,
+        title="No. of tasks for MPI parallel run of GetDP",
+        description=(
+            "If integer, GetDP will be run in parallel using MPI. This is only valid"
+            " if MPI is installed on the system and an MPI-enabled GetDP is used." 
+            " If False, GetDP will be run in serial without invoking mpiexec."
+        ),
+    )
+
+    resistiveHeatingTerminals: bool = Field(
+        default=True,
+        title="Resistive Heating in Terminals",
+        description=(
+            "If True, terminals are subject to Joule heating. If False, terminal regions are"
+            " not subject to Joule heating. In both cases, heat conduction through the terminal is "
+            " considered."
+        ),
+    )
+
+    heatFlowBetweenTurns: bool = Field(
+        default=True,
+        title="Heat Equation Between Turns",
+        description=(
+            "If True, heat flow between turns is considered. If False, it is not considered. "
+            "In the latter case, heat conduction is only considered to the middle of the winding in the thin shell approximation "
+            "in order to keep the thermal mass of the insulation included. In the middle between the turns, an adiabatic condition is applied. "            
+            "Between the turns refers to the region between the winding turns, NOT to the region between terminals "
+            "and the first and last turn. "
+            "This feature is only implemented for the thin shell approximation."
+        ),
+    )
+
+    convectiveCooling: Optional[Pancake3DSolveConvectiveCooling] = Field(
+        default=Pancake3DSolveConvectiveCooling(),
+        title="Convective Cooling",
+        description=(
+            "This dictionary contains the convective cooling settings."
+        ),
+    )
+
+    imposedPowerDensity: Optional[Pancake3DSolvePowerDensity] = Field(
+        default=None,
+        title="Power Density",
+        description=(
+            "The power density for an imposed power density in the winding."
+        ),
+    )
+
+    materialParametersUseCoilField: bool = Field(
+        default=True,
+        title="Use Coil Field for Critical Current",
+        description=(
+            "If True, the total field (i.e., coil field plus potentially imposed field)"
+             "will be used for the material (default)."
+            "If False, only the imposed field (can be zero) will be used."
+        ),
+    )
+
+    stopWhenTemperatureReaches: Optional[float] = Field(
+        default=0,
+        title="Stop When Temperature Reaches",
+        description=(
+            "If the maximum temperature reaches this value, the simulation will"
+            " be stopped."
+        ),
+    )
+
     @computed_field
     @cached_property
     def systemsOfEquationsType(self) -> str:
 
-        windingMaterialIsGiven = self.wi.material is not None
-        contactLayerMaterialIsGiven = self.ii.material is not None
-        terminalMaterialIsGiven = self.ti.material is not None
-        notchMaterialIsGiven = self.ti.transitionNotch.material is not None
-        terminalContactLayerMaterialIsGiven = self.ti.terminalContactLayer.material is not None
+        windingMaterialIsGiven = self.winding.material is not None
+        contactLayerMaterialIsGiven = self.contactLayer.material is not None
+        terminalMaterialIsGiven = self.terminals.material is not None
+        notchMaterialIsGiven = self.terminals.transitionNotch.material is not None
+        terminalContactLayerMaterialIsGiven = self.terminals.terminalContactLayer.material is not None
 
         if (
             windingMaterialIsGiven
@@ -2970,14 +3353,14 @@ class Pancake3DSolve(BaseModel):
             systemsOfEquationsType = "linear"
 
         return systemsOfEquationsType
-
+    
     @model_validator(mode="before")
     @classmethod
     def check_nls_system_tolerances(cls, model: "Pancake3DSolve"):
-
+        
         if not "nonlinearSolver" in model or not "tolerances" in model["nonlinearSolver"]:
             return model
-
+        
         all_tolerances = model["nonlinearSolver"]["tolerances"]
 
         for tolerance in all_tolerances:
@@ -2988,7 +3371,7 @@ class Pancake3DSolve(BaseModel):
                         "The 'electromagneticSolutionVector' tolerance can be used only"
                         " in 'electromagnetic' or 'weaklyCoupled' simulations."
                     )
-
+            
             if tolerance["quantity"] == "thermalSolutionVector":
                 if model["type"] == "electromagnetic" or model["type"] == "stronglyCoupled":
                     raise ValueError(
@@ -2996,7 +3379,7 @@ class Pancake3DSolve(BaseModel):
                         "The 'thermalSolutionVector' tolerance can be used only"
                         " in 'thermal' or 'weaklyCoupled' simulations."
                     )
-
+                
             if tolerance["quantity"] == "coupledSolutionVector":
                 if model["type"] == "electromagnetic" or model["type"] == "thermal" or model["type"] == "weaklyCoupled":
                     raise ValueError(
@@ -3005,11 +3388,11 @@ class Pancake3DSolve(BaseModel):
                         " in 'stronglyCoupled' simulations."
                     )
         return model
-
+    
     @model_validator(mode="before")
     @classmethod
     def check_adaptive_system_tolerances(cls, model: "Pancake3DSolve"):
-
+        
         if model["time"]["timeSteppingType"] == "fixed":
             return model
 
@@ -3023,7 +3406,7 @@ class Pancake3DSolve(BaseModel):
                         "The 'electromagneticSolutionVector' tolerance can be used only"
                         " in 'electromagnetic' or 'weaklyCoupled' simulations."
                     )
-
+            
             if tolerance["quantity"] == "thermalSolutionVector":
                 if model["type"] == "electromagnetic" or model["type"] == "stronglyCoupled":
                     raise ValueError(
@@ -3031,7 +3414,7 @@ class Pancake3DSolve(BaseModel):
                         "The 'thermalSolutionVector' tolerance can be used only"
                         " in 'thermal' or 'weaklyCoupled' simulations."
                     )
-
+                
             if tolerance["quantity"] == "coupledSolutionVector":
                 if model["type"] == "electromagnetic" or model["type"] == "thermal" or model["type"] == "weaklyCoupled":
                     raise ValueError(
@@ -3040,7 +3423,83 @@ class Pancake3DSolve(BaseModel):
                         " in 'stronglyCoupled' simulations."
                     )
         return model
+    
+    @model_validator(mode="before")
+    @classmethod
+    def check_convective_cooling(cls, model: "Pancake3DSolve"):
+        if "convectiveCooling" in model:
+
+            convectiveCooling = model["convectiveCooling"]
+        
+            if not "heatTransferCoefficient" in convectiveCooling or not "exteriorBathTemperature" in convectiveCooling:
+                raise ValueError(
+                    "If convective cooling is turned on, the heatTransferCoefficient and exteriorBathTemperature must be provided."
+                )
 
+        return model
+    
+    @model_validator(mode="before")
+    @classmethod
+    def check_power_density(cls, model: "Pancake3DSolve"):
+        if "imposedPowerDensity" in model:
+
+            powerDensity = model["imposedPowerDensity"]
+        
+            if powerDensity:
+                if not "startTime" in powerDensity or not "endTime" in powerDensity or not "startArcLength" in powerDensity or not "endArcLength" in powerDensity or not "power" in powerDensity:
+                    raise ValueError(
+                        "If the power density provided, the power, startTime, endTime, startTurn, and endTurn must be provided."
+                    )
+
+        return model
+    
+    @model_validator(mode="before")
+    @classmethod
+    def check_heat_equation_between_turns(cls, model: "Pancake3DSolve"):
+        if "heatFlowBetweenTurns" in model and not model["heatFlowBetweenTurns"]:
+        
+            geometry = geometry_input.get()
+
+            if not geometry["contactLayer"]["thinShellApproximation"]:
+                raise ValueError(
+                    "The heat equation between turns can only be turned off in the thin shell approximation."
+                )
+            
+            if not model["contactLayer"]["resistivity"] == "perfectlyInsulating":
+                raise ValueError(
+                    "The heat equation between turns can only be turned off for perfectly insulated coils. That is, coils with contactLayer resistivity set to 'perfectlyInsulating'."
+                )
+
+        return model
+    
+    @model_validator(mode="before")
+    @classmethod
+    def check_voltage_taps(cls, model: "Pancake3DSolve"):
+        
+        if "voltageTapPositions" in model:
+            if len(model['voltageTapPositions'])>0:
+                if model["type"] == "thermal":
+                    raise ValueError(
+                        "Voltage taps can only be used in electromagnetic simulations."
+                    )
+
+                if not model["contactLayer"]["resistivity"] == "perfectlyInsulating":
+                    raise ValueError(
+                        "For now, voltage taps can only be used for perfectly insulated coils. That is, coils with contactLayer resistivity set to 'perfectlyInsulating'."
+                    )
+
+                geometry = geometry_input.get()
+
+                if not geometry["contactLayer"]["thinShellApproximation"]:
+                    raise ValueError(
+                        "Voltage taps are only available in the thin shell approximation for now."
+                    )
+
+
+        return model
+    
+    # TODO: add model_validator to check if MPI is installed on the system and an MPI-enabled GetDP is used if useMPI is True
+    
     # TODO: add model_validator to check postprocess quantities are available for this solve type (e.g. thermal quantities cannot be chosen for electromagnetic solve)
 
     # TODO: add model_validator to check convergence quantities are available for this solve type (e.g. thermal quantities cannot be chosen for electromagnetic solve)
@@ -3051,13 +3510,13 @@ class Pancake3DPostprocess(BaseModel):
     """
 
     # 1) User inputs:
-    timeSeriesPlots: list[Pancake3DPostprocessTimeSeriesPlot] = Field(
+    timeSeriesPlots: Optional[list[Pancake3DPostprocessTimeSeriesPlot]] = Field(
         default=None,
         title="Time Series Plots",
         description="Values can be plotted with respect to time.",
     )
 
-    magneticFieldOnCutPlane: Pancake3DPostprocessMagneticFieldOnPlane = Field(
+    magneticFieldOnCutPlane: Optional[Pancake3DPostprocessMagneticFieldOnPlane] = Field(
         default=None,
         title="Magnetic Field on a Cut Plane",
         description=(
@@ -3089,7 +3548,7 @@ class Pancake3D(BaseModel):
         description="This dictionary contains the solve information.",
     )
     postproc: Pancake3DPostprocess = Field(
-        default=None,
+        default=Pancake3DPostprocess(),
         title="Postprocess",
         description="This dictionary contains the postprocess information.",
     )