From 50ccefc45e27c6291e0297b4ed3df7d6dacb54d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Iraz=C3=A1bal=20Gonz=C3=A1lez?=
 <jirazabal@cimne.upc.edu>
Date: Tue, 3 Nov 2026 08:29:18 +0100
Subject: [PATCH 1/6] Add initial-state save/load processes and validation to
 Dam interface

- Implement initial-state save/load functionality in writeProjectParameters.tcl
- Introduce new XML procedures for handling initial-state file values
- Enhance process validation to prevent conflicts between initial-state and legacy mappings
- Update UI elements in Procs.spd and Utilities.spd for initial-state options
---
 kratos.gid/apps/Dam/python/MainKratos.py      |  44 +++
 .../apps/Dam/write/writeProjectParameters.tcl | 292 +++++++++++++++++-
 kratos.gid/apps/Dam/xml/Procs.spd             |   6 +
 kratos.gid/apps/Dam/xml/Utilities.spd         |  43 ++-
 kratos.gid/apps/Dam/xml/XmlController.tcl     |  26 ++
 5 files changed, 403 insertions(+), 8 deletions(-)

diff --git a/kratos.gid/apps/Dam/python/MainKratos.py b/kratos.gid/apps/Dam/python/MainKratos.py
index 713c571ca..fa7c333dd 100644
--- a/kratos.gid/apps/Dam/python/MainKratos.py
+++ b/kratos.gid/apps/Dam/python/MainKratos.py
@@ -165,6 +165,50 @@ def Initialize(self):
         self.list_of_processes += KratosMultiphysics.process_factory.KratosProcessFactory(self.model).ConstructListOfProcesses( self.ProjectParameters["temperature_by_device_list"] )
         self.list_of_processes += KratosMultiphysics.process_factory.KratosProcessFactory(self.model).ConstructListOfProcesses( self.ProjectParameters["output_device_list"] )
 
+        # The initial-state import must be the only mechanism that assigns each
+        # imported field. These checks reproduce the DamAnalysis guards (and
+        # also reject any legacy mapping combined with a new initial-state
+        # import) so that projects launched from GiD fail early and clearly.
+        for attribute in ("transfers_initial_stress",
+                          "transfers_initial_temperature",
+                          "transfers_reference_temperature"):
+            transferring_processes = [
+                process for process in self.list_of_processes
+                if getattr(process, attribute, False)]
+            if len(transferring_processes) > 1:
+                raise RuntimeError(
+                    "More than one process transfers the same initial-state field "
+                    "('{}'). Use only one initial-state processor per field.".format(
+                        attribute))
+
+        if any(getattr(process, "transfers_reference_temperature", False)
+               for process in self.list_of_processes):
+            reference_process_classes = (
+                "ImposeNodalReferenceTemperatureProcess",
+                "ImposeGroutingReferenceTemperatureProcess")
+            reference_processes = [
+                process for process in self.list_of_processes
+                if (getattr(process, "assigns_reference_temperature", False) or
+                    isinstance(
+                        process,
+                        KratosDam.DamNodalReferenceTemperatureProcess) or
+                    type(process).__name__ in reference_process_classes)]
+            if reference_processes:
+                raise RuntimeError(
+                    "Cannot import NODAL_REFERENCE_TEMPERATURE while a process "
+                    "that assigns it is active. Remove or disable the "
+                    "reference-temperature process for this analysis.")
+
+        if self.add_previous_results and any(
+                getattr(process, "transfers_initial_stress", False) or
+                getattr(process, "transfers_initial_temperature", False) or
+                getattr(process, "transfers_reference_temperature", False)
+                for process in self.list_of_processes):
+            raise RuntimeError(
+                "An initial-state transfer process cannot be combined with "
+                "'transfer_results_process.add_previous_results'. Use only one "
+                "initial-state transfer mechanism per analysis.")
+
         # Print list of constructed processes
         if(self.echo_level>1):
             for self.process in self.list_of_processes:
diff --git a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
index 4ecbe9fa1..227aec4fa 100644
--- a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
+++ b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
@@ -32,7 +32,11 @@ proc ::Dam::write::getParametersDict { } {
     ### Load processes
     set mechanical_load_process_list [::write::getConditionsParametersDict DamLoads]
     set thermal_load_process_list [::write::getConditionsParametersDict DamThermalLoads]
-    dict set projectParametersDict loads_process_list [Dam::write::ChangeFileNameforTableid [concat $mechanical_load_process_list $thermal_load_process_list]]
+    set condition_load_process_list [Dam::write::ChangeFileNameforTableid [concat $mechanical_load_process_list $thermal_load_process_list]]
+    # Initial-state save/load processes are global (not condition-based), so they
+    # are appended after the table-id conversion applied to condition processes.
+    set initial_state_process_list [Dam::write::GetInitialStateProcessList]
+    dict set projectParametersDict loads_process_list [concat $condition_load_process_list $initial_state_process_list]
 
     ### Construction processes
     dict set projectParametersDict construction_process [Dam::write::GetConstructionDomainProcessDict]
@@ -919,6 +923,292 @@ proc ::Dam::write::GetConstructionDomainProcessDict { } {
     return $construction_dict
 }
 
+# Returns the Kratos model-part name for a Dam part group. The sub-model-part
+# catalog is already populated when ProjectParameters is written (the .mdpa is
+# written first), so the resolved identifier is used whenever available.
+proc ::Dam::write::GetInitialStateModelPartName { group } {
+    if {$group eq ""} {return ""}
+
+    # Match the name used when the part sub-model-part was written.
+    set group [write::GetWriteGroupName $group]
+
+    set subModelPartId 0
+    catch {set subModelPartId [write::getSubModelPartId "Parts" $group]}
+    if {$subModelPartId eq "" || $subModelPartId eq 0} {
+        set subModelPartId "Parts_[write::transformGroupName $group]"
+    }
+    return [write::GetModelPartNameWithParent $subModelPartId]
+}
+
+# File-handler values use "- No file - ..." as the empty selection.
+proc ::Dam::write::IsNoInitialStateFile { value } {
+    set value [string trim $value]
+    return [expr {$value eq "" || [string match "- No file*" $value]}]
+}
+
+# Resolves a user-provided initial-state path for local validation. Relative
+# paths are interpreted from the GiD project directory, which is the working
+# directory used when Kratos is launched from GiD.
+proc ::Dam::write::ResolveInitialStatePath { value } {
+    set value [string trim $value]
+    if {[Dam::write::IsNoInitialStateFile $value]} {return ""}
+
+    if {[file pathtype $value] eq "absolute"} {return $value}
+
+    set baseDir ""
+    catch {set baseDir [write::GetConfigurationAttribute dir]}
+    if {$baseDir eq ""} {return $value}
+    return [file join $baseDir $value]
+}
+
+proc ::Dam::write::GetSaveInitialStateProcessDict { } {
+    if {![write::isBooleanTrue [write::getValue DamSaveInitialState]]} {return ""}
+
+    set group [write::getValue DamSaveInitialStatePart]
+    set saveStresses [write::isBooleanTrue [write::getValue DamSaveInitialStresses]]
+    set saveTemperature [write::isBooleanTrue [write::getValue DamSaveInitialTemperature]]
+    set saveReferenceTemperature [write::isBooleanTrue [write::getValue DamSaveInitialReferenceTemperature]]
+    set stressSource [write::getValue DamInitialStateStressSource]
+    if {$stressSource eq ""} {set stressSource "current_cauchy"}
+    set outputFile [string trim [write::getValue DamInitialStateOutputFile]]
+
+    set parametersDict [dict create]
+    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName $group]
+    if {$saveStresses} {
+        dict set parametersDict save_initial_stresses true
+    } else {
+        dict set parametersDict save_initial_stresses false
+    }
+    if {$saveTemperature} {
+        dict set parametersDict save_initial_temperature true
+    } else {
+        dict set parametersDict save_initial_temperature false
+    }
+    if {$saveReferenceTemperature} {
+        dict set parametersDict save_reference_temperature true
+    } else {
+        dict set parametersDict save_reference_temperature false
+    }
+    dict set parametersDict stress_source $stressSource
+    dict set parametersDict output_file_name $outputFile
+
+    set processDict [dict create]
+    dict set processDict python_module "save_dam_initial_state_process"
+    dict set processDict kratos_module "KratosMultiphysics.DamApplication"
+    dict set processDict Parameters $parametersDict
+    return $processDict
+}
+
+proc ::Dam::write::GetLoadInitialStateProcessDict { } {
+    if {![write::isBooleanTrue [write::getValue DamLoadInitialState]]} {return ""}
+
+    set group [write::getValue DamLoadInitialStatePart]
+    set inputFile [string trim [write::getValue DamLoadInitialStateFile]]
+    set transferStresses [write::isBooleanTrue [write::getValue DamTransferInitialStresses]]
+    set transferTemperature [write::isBooleanTrue [write::getValue DamTransferInitialTemperature]]
+    set transferReferenceTemperature [write::isBooleanTrue [write::getValue DamTransferInitialReferenceTemperature]]
+    set referencePolicy [write::getValue DamReferenceTemperaturePolicy]
+    if {$referencePolicy eq ""} {set referencePolicy "preserve"}
+
+    set parametersDict [dict create]
+    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName $group]
+    dict set parametersDict input_file_name $inputFile
+    if {$transferStresses} {
+        dict set parametersDict transfer_initial_stresses true
+    } else {
+        dict set parametersDict transfer_initial_stresses false
+    }
+    if {$transferTemperature} {
+        dict set parametersDict transfer_initial_temperature true
+    } else {
+        dict set parametersDict transfer_initial_temperature false
+    }
+    if {$transferReferenceTemperature} {
+        dict set parametersDict transfer_reference_temperature true
+    } else {
+        dict set parametersDict transfer_reference_temperature false
+    }
+    dict set parametersDict reference_temperature_policy $referencePolicy
+
+    set processDict [dict create]
+    dict set processDict python_module "load_dam_initial_state_process"
+    dict set processDict kratos_module "KratosMultiphysics.DamApplication"
+    dict set processDict Parameters $parametersDict
+    return $processDict
+}
+
+# The load process runs before the first solution step and the save process at
+# finalization, so both can coexist in the same calculation. Keep the load
+# process first for a predictable lifecycle order.
+proc ::Dam::write::GetInitialStateProcessList { } {
+    set processList [list]
+    set loadProcess [Dam::write::GetLoadInitialStateProcessDict]
+    if {$loadProcess ne ""} {lappend processList $loadProcess}
+    set saveProcess [Dam::write::GetSaveInitialStateProcessDict]
+    if {$saveProcess ne ""} {lappend processList $saveProcess}
+    return $processList
+}
+
+# Returns the active Dam conditions that assign NODAL_REFERENCE_TEMPERATURE.
+# Both the explicit nodal reference-temperature condition and the construction
+# grouting-reference condition are reported.
+proc ::Dam::write::GetActiveReferenceTemperatureConditions { } {
+    set conditionList [list]
+    set thermalLoadsRoute [spdAux::getRoute DamThermalLoads]
+    if {$thermalLoadsRoute eq ""} {return $conditionList}
+
+    set root [customlib::GetBaseRoot]
+    foreach conditionId [list NodalReferenceTemperature2D NodalReferenceTemperature3D GroutingTime2D GroutingTime3D] {
+        set groups [$root selectNodes "$thermalLoadsRoute/condition\[@n='$conditionId'\]/group"]
+        if {$groups ne ""} {lappend conditionList $conditionId}
+    }
+    return $conditionList
+}
+
+# Application-level validation. Returning a nonzero first element aborts the
+# write and displays every message in the GiD warning window.
+proc ::Dam::write::writeValidateEvent { } {
+    set problem 0
+    set messages [list]
+    set legacyMapping [write::isBooleanTrue [write::getValue DamPreviousResults AddPreviousResults]]
+    set damTypeofProblem [write::getValue DamTypeofProblem]
+    set hasThermalFields [expr {$damTypeofProblem in [list "Thermo-Mechanical" "UP_Thermo-Mechanical"]}]
+
+    set saveEnabled [write::isBooleanTrue [write::getValue DamSaveInitialState]]
+    if {$saveEnabled} {
+        set saveStresses [write::isBooleanTrue [write::getValue DamSaveInitialStresses]]
+        set saveTemperature [write::isBooleanTrue [write::getValue DamSaveInitialTemperature]]
+        set saveReferenceTemperature [write::isBooleanTrue [write::getValue DamSaveInitialReferenceTemperature]]
+
+        if {!$saveStresses && !$saveTemperature && !$saveReferenceTemperature} {
+            incr problem
+            lappend messages "Save initial state: select at least one field to save (initial stresses, initial temperature or reference temperature)."
+        }
+
+        set group [write::getValue DamSaveInitialStatePart]
+        if {$group eq ""} {
+            incr problem
+            lappend messages "Save initial state: select the target part."
+        }
+
+        if {$saveStresses} {
+            set stressSource [write::getValue DamInitialStateStressSource]
+            if {$stressSource ni [list "current_cauchy" "stored_initial_stress"]} {
+                incr problem
+                lappend messages "Save initial state: unsupported stress source '$stressSource'. Select 'Current Cauchy stress' or 'Stored initial stress'."
+            } elseif {$legacyMapping && $stressSource eq "stored_initial_stress"} {
+                incr problem
+                lappend messages "Save initial state: 'Stored initial stress' cannot be combined with the legacy result mapping ('Add previous results'), because the legacy mapping does not populate the constitutive InitialState. Use 'Current Cauchy stress' or disable the legacy mapping."
+            }
+        }
+
+        if {!$hasThermalFields} {
+            if {$saveTemperature} {
+                incr problem
+                lappend messages "Save initial state: the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Save initial temperature' or use a thermo-mechanical analysis."
+            }
+            if {$saveReferenceTemperature} {
+                incr problem
+                lappend messages "Save initial state: the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Save reference temperature' or use a thermo-mechanical analysis."
+            }
+        }
+
+        set outputFile [string trim [write::getValue DamInitialStateOutputFile]]
+        if {$outputFile eq ""} {
+            incr problem
+            lappend messages "Save initial state: the output file is empty."
+        } elseif {![regexp {\.json(\.gz)?$} $outputFile]} {
+            incr problem
+            lappend messages "Save initial state: the output file '$outputFile' must end with '.json' or '.json.gz'."
+        } elseif {[file isdirectory [Dam::write::ResolveInitialStatePath $outputFile]]} {
+            incr problem
+            lappend messages "Save initial state: the output path '$outputFile' is an existing directory; provide a file name."
+        }
+    }
+
+    set loadEnabled [write::isBooleanTrue [write::getValue DamLoadInitialState]]
+    if {$loadEnabled} {
+        set transferStresses [write::isBooleanTrue [write::getValue DamTransferInitialStresses]]
+        set transferTemperature [write::isBooleanTrue [write::getValue DamTransferInitialTemperature]]
+        set transferReferenceTemperature [write::isBooleanTrue [write::getValue DamTransferInitialReferenceTemperature]]
+        set referencePolicy [write::getValue DamReferenceTemperaturePolicy]
+        if {$referencePolicy eq ""} {set referencePolicy "preserve"}
+
+        if {!$transferStresses && !$transferTemperature && !$transferReferenceTemperature} {
+            incr problem
+            lappend messages "Load initial state: select at least one field to transfer (initial stresses, initial temperature or reference temperature)."
+        }
+
+        if {!$hasThermalFields} {
+            if {$transferTemperature} {
+                incr problem
+                lappend messages "Load initial state: the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Transfer initial temperature' or use a thermo-mechanical analysis."
+            }
+            if {$transferReferenceTemperature} {
+                incr problem
+                lappend messages "Load initial state: the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Transfer reference temperature' or use a thermo-mechanical analysis."
+            }
+        }
+
+        set group [write::getValue DamLoadInitialStatePart]
+        if {$group eq ""} {
+            incr problem
+            lappend messages "Load initial state: select the target part."
+        }
+
+        set inputFile [string trim [write::getValue DamLoadInitialStateFile]]
+        if {[Dam::write::IsNoInitialStateFile $inputFile]} {
+            incr problem
+            lappend messages "Load initial state: select an input .json or .json.gz file."
+        } else {
+            set resolvedInput [Dam::write::ResolveInitialStatePath $inputFile]
+            if {![file isfile $resolvedInput]} {
+                incr problem
+                lappend messages "Load initial state: the input file '$inputFile' does not exist (resolved to '$resolvedInput'). Select it with the File handler toolbar or use a valid path."
+            } elseif {![regexp {\.json(\.gz)?$} $resolvedInput]} {
+                incr problem
+                lappend messages "Load initial state: the input file '$inputFile' must end with '.json' or '.json.gz'."
+            }
+        }
+
+        if {$referencePolicy ni [list "preserve" "initial_temperature"]} {
+            incr problem
+            lappend messages "Load initial state: unsupported reference temperature policy '$referencePolicy'."
+        }
+
+        if {$referencePolicy eq "initial_temperature"} {
+            if {!$transferTemperature} {
+                incr problem
+                lappend messages "Load initial state: the policy 'Use initial temperature as reference' requires transferring the initial temperature."
+            }
+            if {$transferReferenceTemperature} {
+                incr problem
+                lappend messages "Load initial state: 'Transfer reference temperature' and the policy 'Use initial temperature as reference' cannot be enabled at the same time. Disable one of them."
+            }
+        }
+
+        if {$transferReferenceTemperature || $referencePolicy eq "initial_temperature"} {
+            set referenceConditions [Dam::write::GetActiveReferenceTemperatureConditions]
+            if {[llength $referenceConditions] > 0} {
+                if {$referencePolicy eq "initial_temperature"} {
+                    set conflictAction "Disable or remove those conditions, or do not use the 'Use initial temperature as reference' policy."
+                } else {
+                    set conflictAction "Disable or remove those conditions, or disable 'Transfer reference temperature'."
+                }
+                incr problem
+                lappend messages "Load initial state: the imported NODAL_REFERENCE_TEMPERATURE would be overwritten by the active reference-temperature condition(s): [join $referenceConditions {, }]. $conflictAction The interface does not remove them automatically."
+            }
+        }
+
+        if {$legacyMapping} {
+            incr problem
+            lappend messages "Load initial state: the legacy result mapping ('Add previous results') cannot be combined with 'Load initial state'. Disable one of the two mechanisms. The legacy mapping transfers nodal fields and is not equivalent to the constitutive initial-state transfer."
+        }
+    }
+
+    return [list $problem $messages]
+}
+
 # This process write the transfer results process in case is selected
 proc ::Dam::write::GetTransferResultsDict { } {
     set transfer_results_dict [dict create]
diff --git a/kratos.gid/apps/Dam/xml/Procs.spd b/kratos.gid/apps/Dam/xml/Procs.spd
index 2310d31b5..33c7eaad7 100644
--- a/kratos.gid/apps/Dam/xml/Procs.spd
+++ b/kratos.gid/apps/Dam/xml/Procs.spd
@@ -81,4 +81,10 @@
 	  ]]>
 	</proc>
 
+	<proc n='GetInitialStateFileValues' args='args'>
+	  <![CDATA[
+	  return [Dam::xml::ProcGetInitialStateFileValues $domNode $args]
+	  ]]>
+	</proc>
+
 </container>
diff --git a/kratos.gid/apps/Dam/xml/Utilities.spd b/kratos.gid/apps/Dam/xml/Utilities.spd
index db4954348..288768021 100644
--- a/kratos.gid/apps/Dam/xml/Utilities.spd
+++ b/kratos.gid/apps/Dam/xml/Utilities.spd
@@ -43,22 +43,51 @@
         </container>
     </container>
 
-    <container n="TransferResults" pn="Transfer results" un="DamTransferResults" icon="transfer_results" actualize_tree="1" open_window="0">
-        <container n="SaveResults" pn="Save results" un="DamSaveResults" help="" actualize_tree="1" open_window="0">
+    <container n="TransferResults" pn="Transfer results" un="DamTransferResults" icon="transfer_results" actualize_tree="1" open_window="0"
+        help="Transfer the initial state between Dam calculations. Save/Load initial state read and write exact constitutive initial-state files (Gauss-point initial stresses plus nodal temperatures). Legacy result transfer maps nodal fields from previously saved .mdpa result files and is not equivalent to the exact constitutive-state transfer.">
+
+        <container n="SaveInitialState" pn="Save initial state" un="DamSaveInitialStateContainer" help="Write a Dam initial-state file at the end of the analysis with the selected Gauss-point stresses and nodal temperatures. It can be enabled together with 'Load initial state'." actualize_tree="1" open_window="0">
+            <value n="SaveInitialState" pn="Save initial state" un="DamSaveInitialState" v="No" values="Yes,No" actualize_tree="1" help="Write the selected initial-state fields when the analysis finishes"/>
+            <container n="SaveInitialStateOptions" pn="Initial state to save" un="DamSaveInitialStateOptions" state="[HideIfUniqueName DamSaveInitialState No]" actualize_tree="1" open_window="0">
+                <value n="Part" pn="Target part" un="DamSaveInitialStatePart" v="" values="[GetParts]" help="Structural part whose constitutive initial state is written. Only one Dam part is stored per initial-state file."/>
+                <value n="SaveInitialStresses" pn="Save initial stresses" un="DamSaveInitialStresses" v="Yes" values="Yes,No" actualize_tree="1" help="Save the initial stress state at the element Gauss points"/>
+                <container n="InitialStressesOptions" pn="Initial stresses" un="DamSaveInitialStressesOptions" state="[HideIfUniqueName DamSaveInitialStresses No]" actualize_tree="1" open_window="0">
+                    <value n="StressSource" pn="Stress source" un="DamInitialStateStressSource" v="current_cauchy" values="current_cauchy,stored_initial_stress" dict="current_cauchy,Current Cauchy stress,stored_initial_stress,Stored initial stress" help="Current Cauchy stress exports the current total Gauss-point Cauchy stresses (they may include gravity, thermal and other contributions). Stored initial stress exports the constitutive initial stresses currently stored in InitialState, which preserves previously imported stresses independently of later loading."/>
+                </container>
+                <value n="SaveInitialTemperature" pn="Save initial temperature" un="DamSaveInitialTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Save the nodal TEMPERATURE field"/>
+                <value n="SaveReferenceTemperature" pn="Save reference temperature" un="DamSaveInitialReferenceTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Save the nodal NODAL_REFERENCE_TEMPERATURE field"/>
+                <value n="OutputFile" pn="Output file" un="DamInitialStateOutputFile" v="initial_state.json.gz" help="Output path for the initial-state file. Use an absolute path, a path relative to the GiD project directory, or a filename. Supported extensions are .json and .json.gz. Parent folders are created automatically."/>
+            </container>
+        </container>
+
+        <container n="LoadInitialState" pn="Load initial state" un="DamLoadInitialStateContainer" help="Read selected fields from a Dam initial-state file before the first solution step. It can be enabled together with 'Save initial state'." actualize_tree="1" open_window="0">
+            <value n="LoadInitialState" pn="Load initial state" un="DamLoadInitialState" v="No" values="Yes,No" actualize_tree="1" help="Apply the selected initial-state fields before the first solution step"/>
+            <container n="LoadInitialStateOptions" pn="Initial state to load" un="DamLoadInitialStateOptions" state="[HideIfUniqueName DamLoadInitialState No]" actualize_tree="1" open_window="0">
+                <value n="InputFile" pn="Input file" un="DamLoadInitialStateFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetInitialStateFileValues]" update_proc="AddFile" help="Initial-state file to read. Use the File handler toolbar to select an existing .json or .json.gz file, including files from other GiD projects. Selected files are copied into this project directory. An absolute path or a path relative to the GiD project directory can also be typed directly."/>
+                <value n="Part" pn="Target part" un="DamLoadInitialStatePart" v="" values="[GetParts]" help="Structural part that receives the initial state. Its mesh, elements and materials must match the source file."/>
+                <value n="TransferInitialStresses" pn="Transfer initial stresses" un="DamTransferInitialStresses" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the Gauss-point constitutive initial stresses stored in the file"/>
+                <value n="TransferInitialTemperature" pn="Transfer initial temperature" un="DamTransferInitialTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the nodal TEMPERATURE field stored in the file"/>
+                <value n="TransferReferenceTemperature" pn="Transfer reference temperature" un="DamTransferInitialReferenceTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the nodal NODAL_REFERENCE_TEMPERATURE field stored in the file. Cannot be combined with a reference-temperature condition that would overwrite it."/>
+                <value n="ReferenceTemperaturePolicy" pn="Reference temperature policy" un="DamReferenceTemperaturePolicy" v="preserve" values="preserve,initial_temperature" dict="preserve,Preserve,initial_temperature,Use initial temperature as reference" help="Preserve keeps the imported TEMPERATURE and NODAL_REFERENCE_TEMPERATURE independent, which is recommended for staged construction and supports TEMPERATURE different from NODAL_REFERENCE_TEMPERATURE. Use initial temperature as reference explicitly resets NODAL_REFERENCE_TEMPERATURE to the imported TEMPERATURE; it requires transferring the initial temperature and cannot be combined with transferring the stored reference temperature."/>
+            </container>
+        </container>
+
+        <container n="SaveResults" pn="Save results (legacy .mdpa)" un="DamSaveResults" help="Legacy workflow: write auxiliary .mdpa files with nodal displacement, nodal Cauchy stress, temperature and reference temperature. These files are consumed by the legacy mapping transfer and cannot be converted into an exact constitutive initial-state file." actualize_tree="1" open_window="0">
             <value n="SaveIntermediateResults" pn="Save Intermediate Results" un="DamSaveIntermediateResults" v="No" values="Yes,No" help="" actualize_tree="1"/>
             <value n="SaveIntermediateStep" pn="Step" un="DamSaveIntermediateStep" state="[checkStateByUniqueName DamSaveIntermediateResults Yes]" v="0" help="" actualize_tree="1"/>
             <value n="SaveFinalResults" pn="Save Final Results" un="DamSaveFinalResults" v="No" values="Yes,No" help="" actualize_tree="1"/>
         </container>
-        <container n="PreviousResults" pn="Previous results" un="DamPreviousResults" help="" actualize_tree="1" open_window="0">
-            <value n="AddPreviousResults" pn="Add previous results" un="DamAddPreviousResults" v="No" values="Yes,No" help="" actualize_tree="1"/>
+
+        <container n="PreviousResults" pn="Legacy result transfer (mapping)" un="DamPreviousResults" help="Legacy mapping from previously calculated Dam projects. It reads the .mdpa result files written by 'Save results (legacy .mdpa)', maps nodal DISPLACEMENT, nodal NODAL_CAUCHY_STRESS_TENSOR, TEMPERATURE and NODAL_REFERENCE_TEMPERATURE, and supports different meshes. It does not transfer the constitutive Gauss-point InitialState, so it is not equivalent to 'Load initial state'. It cannot be combined with 'Load initial state'." actualize_tree="1" open_window="0">
+            <value n="AddPreviousResults" pn="Add previous results" un="DamAddPreviousResults" v="No" values="Yes,No" help="Enable the legacy nodal-field mapping from previous .mdpa result files" actualize_tree="1"/>
             <value n="TypeResults" pn="Type of results" un="DamTypeResults" v="Thermo-Mechanical" values="Mechanical,Thermal,Thermo-Mechanical" state="[HideIfUniqueName DamAddPreviousResults No]" help="" actualize_tree="1"/>
             <container n="AddResultsData" pn="Add data" un="DamAddResultsData" state="[addResultsState]" actualize_tree="1" open_window="0">
                 <value n="DisplacementResults" pn="Displacement results" un="DamDisplacementResults" state="[HideIfUniqueName DamTypeResults Thermal]" v="No" values="Yes,No" help="" actualize_tree="1"/>
-                <value n="StressResults" pn="Nodal cauchy stress results" un="DamStressResults" state="[HideIfUniqueName DamTypeResults Thermal]" v="No" values="Yes,No" help="" actualize_tree="1"/>
-                <value n="FileNameMechanical" pn="File name for mechanical results" un="DamFileMech" v="- No File -" state="[HideIfUniqueName DamTypeResults Thermal]" help="" actualize_tree="1"/>
+                <value n="StressResults" pn="Nodal cauchy stress results" un="DamStressResults" state="[HideIfUniqueName DamTypeResults Thermal]" v="No" values="Yes,No" help="Maps the nodal NODAL_CAUCHY_STRESS_TENSOR field. This is not the Gauss-point constitutive initial stress." actualize_tree="1"/>
+                <value n="FileNameMechanical" pn="File name for mechanical results" un="DamFileMech" v="- No File -" state="[HideIfUniqueName DamTypeResults Thermal]" help="Legacy .mdpa file written by 'Save results (legacy .mdpa)'" actualize_tree="1"/>
                 <value n="TemperatureResults" pn="Initial temperature results" un="DamInitialTempResults" state="[HideIfUniqueName DamTypeResults Mechanical]" v="No" values="Yes,No" help="" actualize_tree="1"/>
                 <value n="RefTemperatureResults" pn="Nodal reference temperature results" un="DamRefTempResults" state="[HideIfUniqueName DamTypeResults Mechanical]" v="No" values="Yes,No" help="" actualize_tree="1"/>
-                <value n="FileNameThermal" pn="File name for thermal results" un="DamFileTherm" v="- No File -" state="[HideIfUniqueName DamTypeResults Mechanical]" help="" actualize_tree="1"/>
+                <value n="FileNameThermal" pn="File name for thermal results" un="DamFileTherm" v="- No File -" state="[HideIfUniqueName DamTypeResults Mechanical]" help="Legacy .mdpa file written by 'Save results (legacy .mdpa)'" actualize_tree="1"/>
             </container>
         </container>
     </container>
diff --git a/kratos.gid/apps/Dam/xml/XmlController.tcl b/kratos.gid/apps/Dam/xml/XmlController.tcl
index a814a28f1..84071b029 100644
--- a/kratos.gid/apps/Dam/xml/XmlController.tcl
+++ b/kratos.gid/apps/Dam/xml/XmlController.tcl
@@ -427,3 +427,29 @@ proc ::Dam::xml::ProcAddResultsState {domNode args} {
     if {$ActivateAddResults} {set state normal}
     return $state
 }
+
+# File-handler list for the initial-state input. In addition to the files added
+# through the File handler toolbar, a user-provided path is kept in the list so
+# absolute paths and paths relative to the GiD project directory can be typed
+# directly. Values that do not look like a path fall back to the empty entry.
+proc ::Dam::xml::ProcGetInitialStateFileValues {domNode args} {
+    customlib::UpdateDocument
+    spdAux::LoadModelFiles
+
+    set values [list $::spdAux::no_file_string]
+    lappend values {*}[FileSelector::GetAllFiles]
+
+    set current [get_domnode_attribute $domNode v]
+    if {$current ni $values} {
+        set looksLikePath [expr {
+            [string first "/" $current] >= 0 ||
+            [string first "\\" $current] >= 0 ||
+            [regexp {\.json(\.gz)?$} $current]}]
+        if {$looksLikePath} {
+            lappend values $current
+        } else {
+            $domNode setAttribute v [lindex $values 0]
+        }
+    }
+    return [join $values ","]
+}

From 36c39d4ccff3f2239f50fda56df74fb5d5caaa37 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Iraz=C3=A1bal=20Gonz=C3=A1lez?=
 <jirazabal@cimne.upc.edu>
Date: Tue, 3 Nov 2026 10:40:52 +0100
Subject: [PATCH 2/6] Enhance initial-state transfer mechanisms and file
 handling

- Implement checks in the Solution class to ensure only one initial-state transfer process is active at a time.
- Update write.tcl to assign a default thickness for 2D solid parts when initial-state transfer is enabled.
- Modify writeProjectParameters.tcl to include initial-state processes in the project parameters.
- Add new procedures in Procs.spd and Utilities.spd for handling initial-state file transfers and validations.
- Extend XmlController.tcl to manage file paths for transfer input files, allowing user-defined paths.
---
 kratos.gid/apps/Dam/write/write.tcl           |  14 ++
 .../apps/Dam/write/writeProjectParameters.tcl | 235 +++++++++++++++---
 kratos.gid/apps/Dam/xml/Procs.spd             |   4 +-
 kratos.gid/apps/Dam/xml/Utilities.spd         |  11 +-
 kratos.gid/apps/Dam/xml/XmlController.tcl     |  13 +-
 5 files changed, 234 insertions(+), 43 deletions(-)

diff --git a/kratos.gid/apps/Dam/write/write.tcl b/kratos.gid/apps/Dam/write/write.tcl
index bced35d02..d1c54bcb9 100644
--- a/kratos.gid/apps/Dam/write/write.tcl
+++ b/kratos.gid/apps/Dam/write/write.tcl
@@ -95,6 +95,20 @@ proc ::Dam::write::UpdateMaterials { } {
 
         dict set matdict $mat CONSTITUTIVE_LAW_NAME $newconstlaw
     }
+
+    # The Dam initial-state file format and the restart-based selective stress
+    # utility require THICKNESS on 2D solid parts. Plane-strain laws do not
+    # define it themselves, so provide the standard unit thickness only when an
+    # initial-state transfer is enabled. This keeps unrelated analyses unchanged.
+    if {[Dam::write::IsInitialStateTransferEnabled] &&
+            [string match "2D*" [write::getValue nDim]]} {
+        foreach mat [dict keys $matdict] {
+            if {![dict exists $matdict $mat THICKNESS]} {
+                dict set matdict $mat THICKNESS 1.0
+            }
+        }
+    }
+
     write::setMatDict $matdict
 }
 
diff --git a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
index 227aec4fa..f8c3ed34b 100644
--- a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
+++ b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
@@ -923,10 +923,10 @@ proc ::Dam::write::GetConstructionDomainProcessDict { } {
     return $construction_dict
 }
 
-# Returns the Kratos model-part name for a Dam part group. The sub-model-part
+# Returns the sub-model-part name for a Dam part group. The sub-model-part
 # catalog is already populated when ProjectParameters is written (the .mdpa is
 # written first), so the resolved identifier is used whenever available.
-proc ::Dam::write::GetInitialStateModelPartName { group } {
+proc ::Dam::write::GetInitialStateSubModelPartName { group } {
     if {$group eq ""} {return ""}
 
     # Match the name used when the part sub-model-part was written.
@@ -937,9 +937,32 @@ proc ::Dam::write::GetInitialStateModelPartName { group } {
     if {$subModelPartId eq "" || $subModelPartId eq 0} {
         set subModelPartId "Parts_[write::transformGroupName $group]"
     }
+    return $subModelPartId
+}
+
+# Returns the full Kratos model-part name for a Dam part group.
+proc ::Dam::write::GetInitialStateModelPartName { group } {
+    set subModelPartId [Dam::write::GetInitialStateSubModelPartName $group]
+    if {$subModelPartId eq ""} {return ""}
     return [write::GetModelPartNameWithParent $subModelPartId]
 }
 
+# Safe getter for the new initial-state values. Old projects may not contain the
+# new tree nodes until the interface updates their tree; missing nodes must be
+# treated as disabled instead of breaking legacy configurations.
+proc ::Dam::write::GetInitialStateValue { name { it "" } } {
+    if {[spdAux::getRoute $name] eq ""} {return ""}
+    return [write::getValue $name $it]
+}
+
+# True when any of the initial-state transfer mechanisms is enabled.
+proc ::Dam::write::IsInitialStateTransferEnabled { } {
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {return 1}
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {return 1}
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]} {return 1}
+    return 0
+}
+
 # File-handler values use "- No file - ..." as the empty selection.
 proc ::Dam::write::IsNoInitialStateFile { value } {
     set value [string trim $value]
@@ -962,15 +985,15 @@ proc ::Dam::write::ResolveInitialStatePath { value } {
 }
 
 proc ::Dam::write::GetSaveInitialStateProcessDict { } {
-    if {![write::isBooleanTrue [write::getValue DamSaveInitialState]]} {return ""}
+    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {return ""}
 
-    set group [write::getValue DamSaveInitialStatePart]
-    set saveStresses [write::isBooleanTrue [write::getValue DamSaveInitialStresses]]
-    set saveTemperature [write::isBooleanTrue [write::getValue DamSaveInitialTemperature]]
-    set saveReferenceTemperature [write::isBooleanTrue [write::getValue DamSaveInitialReferenceTemperature]]
-    set stressSource [write::getValue DamInitialStateStressSource]
+    set group [Dam::write::GetInitialStateValue DamSaveInitialStatePart]
+    set saveStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialStresses]]
+    set saveTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialTemperature]]
+    set saveReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialReferenceTemperature]]
+    set stressSource [Dam::write::GetInitialStateValue DamInitialStateStressSource]
     if {$stressSource eq ""} {set stressSource "current_cauchy"}
-    set outputFile [string trim [write::getValue DamInitialStateOutputFile]]
+    set outputFile [string trim [Dam::write::GetInitialStateValue DamInitialStateOutputFile]]
 
     set parametersDict [dict create]
     dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName $group]
@@ -1000,14 +1023,14 @@ proc ::Dam::write::GetSaveInitialStateProcessDict { } {
 }
 
 proc ::Dam::write::GetLoadInitialStateProcessDict { } {
-    if {![write::isBooleanTrue [write::getValue DamLoadInitialState]]} {return ""}
-
-    set group [write::getValue DamLoadInitialStatePart]
-    set inputFile [string trim [write::getValue DamLoadInitialStateFile]]
-    set transferStresses [write::isBooleanTrue [write::getValue DamTransferInitialStresses]]
-    set transferTemperature [write::isBooleanTrue [write::getValue DamTransferInitialTemperature]]
-    set transferReferenceTemperature [write::isBooleanTrue [write::getValue DamTransferInitialReferenceTemperature]]
-    set referencePolicy [write::getValue DamReferenceTemperaturePolicy]
+    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {return ""}
+
+    set group [Dam::write::GetInitialStateValue DamLoadInitialStatePart]
+    set inputFile [string trim [Dam::write::GetInitialStateValue DamLoadInitialStateFile]]
+    set transferStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialStresses]]
+    set transferTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialTemperature]]
+    set transferReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialReferenceTemperature]]
+    set referencePolicy [Dam::write::GetInitialStateValue DamReferenceTemperaturePolicy]
     if {$referencePolicy eq ""} {set referencePolicy "preserve"}
 
     set parametersDict [dict create]
@@ -1037,13 +1060,72 @@ proc ::Dam::write::GetLoadInitialStateProcessDict { } {
     return $processDict
 }
 
-# The load process runs before the first solution step and the save process at
-# finalization, so both can coexist in the same calculation. Keep the load
-# process first for a predictable lifecycle order.
+# Splits a restart file name such as MainModelPart_1.0.rest into the base path
+# expected by RestartUtility and the file label. Returns an empty pair when the
+# name does not follow the <model_part>_<label>.rest convention.
+proc ::Dam::write::ParseRestartCheckpoint { value } {
+    set value [string trim $value]
+    if {[Dam::write::IsNoInitialStateFile $value]} {return [list "" ""]}
+
+    if {[string tolower [file extension $value]] ne ".rest"} {return [list "" ""]}
+
+    set stem [string range $value 0 end-5]
+    set dir [file dirname $stem]
+    set name [file tail $stem]
+    set separator [string last "_" $name]
+    if {$separator <= 0 || $separator >= [expr {[string length $name] - 1}]} {
+        return [list "" ""]
+    }
+
+    set baseName [string range $name 0 [expr {$separator - 1}]]
+    set label [string range $name [expr {$separator + 1}] end]
+    return [list [file join $dir $baseName] $label]
+}
+
+# Exposes the existing validated selective_initial_stress_process. This route
+# transfers Gauss-point stresses only; it never transfers temperature fields.
+proc ::Dam::write::GetRestartInitialStressProcessDict { } {
+    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]} {return ""}
+
+    set group [Dam::write::GetInitialStateValue DamRestartInitialStressPart]
+    set checkpoint [string trim [Dam::write::GetInitialStateValue DamRestartInitialStressFile]]
+    lassign [Dam::write::ParseRestartCheckpoint $checkpoint] inputBase fileLabel
+    set sourcePart [string trim [Dam::write::GetInitialStateValue DamRestartInitialStressSourcePart]]
+    if {$sourcePart eq ""} {
+        set sourcePart [Dam::write::GetInitialStateSubModelPartName $group]
+    }
+
+    set restartSettings [dict create]
+    dict set restartSettings input_filename $inputBase
+    # Do not write "input_output_path" as an empty string: the GiD JSON writer
+    # encodes empty strings as [], while RestartUtility expects a string. The
+    # key is unnecessary when load_restart_files_from_folder is false.
+    dict set restartSettings restart_load_file_label $fileLabel
+    dict set restartSettings load_restart_files_from_folder false
+
+    set parametersDict [dict create]
+    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName $group]
+    dict set parametersDict source_model_part_name $sourcePart
+    dict set parametersDict source_root_model_part_name "MainModelPart"
+    dict set parametersDict restart_settings $restartSettings
+
+    set processDict [dict create]
+    dict set processDict python_module "selective_initial_stress_process"
+    dict set processDict kratos_module "KratosMultiphysics.DamApplication"
+    dict set processDict Parameters $parametersDict
+    return $processDict
+}
+
+# The load processes run before the first solution step and the save process at
+# finalization, so they can coexist in the same calculation. The JSON load runs
+# before the restart import so that temperature/reference fields imported from a
+# JSON file are available when the restart process checks T == T_ref.
 proc ::Dam::write::GetInitialStateProcessList { } {
     set processList [list]
     set loadProcess [Dam::write::GetLoadInitialStateProcessDict]
     if {$loadProcess ne ""} {lappend processList $loadProcess}
+    set restartProcess [Dam::write::GetRestartInitialStressProcessDict]
+    if {$restartProcess ne ""} {lappend processList $restartProcess}
     set saveProcess [Dam::write::GetSaveInitialStateProcessDict]
     if {$saveProcess ne ""} {lappend processList $saveProcess}
     return $processList
@@ -1067,32 +1149,48 @@ proc ::Dam::write::GetActiveReferenceTemperatureConditions { } {
 
 # Application-level validation. Returning a nonzero first element aborts the
 # write and displays every message in the GiD warning window.
+# Returns the constitutive law selected for a Dam part group, or an empty
+# string when the part/law cannot be resolved.
+proc ::Dam::write::GetPartConstitutiveLaw { group } {
+    if {$group eq ""} {return ""}
+    set root [customlib::GetBaseRoot]
+    foreach node [$root selectNodes "[spdAux::getRoute DamParts]/group"] {
+        if {[$node @n] eq $group} {
+            set lawNode [$node selectNodes "./value\[@n='ConstitutiveLaw'\]"]
+            if {$lawNode ne ""} {return [get_domnode_attribute $lawNode v]}
+            return ""
+        }
+    }
+    return ""
+}
+
 proc ::Dam::write::writeValidateEvent { } {
     set problem 0
     set messages [list]
     set legacyMapping [write::isBooleanTrue [write::getValue DamPreviousResults AddPreviousResults]]
     set damTypeofProblem [write::getValue DamTypeofProblem]
     set hasThermalFields [expr {$damTypeofProblem in [list "Thermo-Mechanical" "UP_Thermo-Mechanical"]}]
+    set restartEnabled [write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]
 
-    set saveEnabled [write::isBooleanTrue [write::getValue DamSaveInitialState]]
+    set saveEnabled [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]
     if {$saveEnabled} {
-        set saveStresses [write::isBooleanTrue [write::getValue DamSaveInitialStresses]]
-        set saveTemperature [write::isBooleanTrue [write::getValue DamSaveInitialTemperature]]
-        set saveReferenceTemperature [write::isBooleanTrue [write::getValue DamSaveInitialReferenceTemperature]]
+        set saveStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialStresses]]
+        set saveTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialTemperature]]
+        set saveReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialReferenceTemperature]]
 
         if {!$saveStresses && !$saveTemperature && !$saveReferenceTemperature} {
             incr problem
             lappend messages "Save initial state: select at least one field to save (initial stresses, initial temperature or reference temperature)."
         }
 
-        set group [write::getValue DamSaveInitialStatePart]
+        set group [Dam::write::GetInitialStateValue DamSaveInitialStatePart]
         if {$group eq ""} {
             incr problem
             lappend messages "Save initial state: select the target part."
         }
 
         if {$saveStresses} {
-            set stressSource [write::getValue DamInitialStateStressSource]
+            set stressSource [Dam::write::GetInitialStateValue DamInitialStateStressSource]
             if {$stressSource ni [list "current_cauchy" "stored_initial_stress"]} {
                 incr problem
                 lappend messages "Save initial state: unsupported stress source '$stressSource'. Select 'Current Cauchy stress' or 'Stored initial stress'."
@@ -1113,7 +1211,7 @@ proc ::Dam::write::writeValidateEvent { } {
             }
         }
 
-        set outputFile [string trim [write::getValue DamInitialStateOutputFile]]
+        set outputFile [string trim [Dam::write::GetInitialStateValue DamInitialStateOutputFile]]
         if {$outputFile eq ""} {
             incr problem
             lappend messages "Save initial state: the output file is empty."
@@ -1126,12 +1224,12 @@ proc ::Dam::write::writeValidateEvent { } {
         }
     }
 
-    set loadEnabled [write::isBooleanTrue [write::getValue DamLoadInitialState]]
+    set loadEnabled [write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]
     if {$loadEnabled} {
-        set transferStresses [write::isBooleanTrue [write::getValue DamTransferInitialStresses]]
-        set transferTemperature [write::isBooleanTrue [write::getValue DamTransferInitialTemperature]]
-        set transferReferenceTemperature [write::isBooleanTrue [write::getValue DamTransferInitialReferenceTemperature]]
-        set referencePolicy [write::getValue DamReferenceTemperaturePolicy]
+        set transferStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialStresses]]
+        set transferTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialTemperature]]
+        set transferReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialReferenceTemperature]]
+        set referencePolicy [Dam::write::GetInitialStateValue DamReferenceTemperaturePolicy]
         if {$referencePolicy eq ""} {set referencePolicy "preserve"}
 
         if {!$transferStresses && !$transferTemperature && !$transferReferenceTemperature} {
@@ -1139,6 +1237,11 @@ proc ::Dam::write::writeValidateEvent { } {
             lappend messages "Load initial state: select at least one field to transfer (initial stresses, initial temperature or reference temperature)."
         }
 
+        if {$transferStresses && $restartEnabled} {
+            incr problem
+            lappend messages "Load initial state: both 'Transfer initial stresses' and the restart checkpoint stress transfer are enabled. Only one mechanism can assign the Gauss-point initial stress. Disable one of them."
+        }
+
         if {!$hasThermalFields} {
             if {$transferTemperature} {
                 incr problem
@@ -1150,13 +1253,13 @@ proc ::Dam::write::writeValidateEvent { } {
             }
         }
 
-        set group [write::getValue DamLoadInitialStatePart]
+        set group [Dam::write::GetInitialStateValue DamLoadInitialStatePart]
         if {$group eq ""} {
             incr problem
             lappend messages "Load initial state: select the target part."
         }
 
-        set inputFile [string trim [write::getValue DamLoadInitialStateFile]]
+        set inputFile [string trim [Dam::write::GetInitialStateValue DamLoadInitialStateFile]]
         if {[Dam::write::IsNoInitialStateFile $inputFile]} {
             incr problem
             lappend messages "Load initial state: select an input .json or .json.gz file."
@@ -1206,6 +1309,70 @@ proc ::Dam::write::writeValidateEvent { } {
         }
     }
 
+    if {$restartEnabled} {
+        set group [Dam::write::GetInitialStateValue DamRestartInitialStressPart]
+        if {$group eq ""} {
+            incr problem
+            lappend messages "Restart initial stresses: select the target part."
+        }
+
+        set checkpoint [string trim [Dam::write::GetInitialStateValue DamRestartInitialStressFile]]
+        if {[Dam::write::IsNoInitialStateFile $checkpoint]} {
+            incr problem
+            lappend messages "Restart initial stresses: select a .rest checkpoint file."
+        } else {
+            set resolvedCheckpoint [Dam::write::ResolveInitialStatePath $checkpoint]
+            if {![file isfile $resolvedCheckpoint]} {
+                incr problem
+                lappend messages "Restart initial stresses: the checkpoint file '$checkpoint' does not exist (resolved to '$resolvedCheckpoint'). Select it with the File handler toolbar or use a valid path."
+            } elseif {[string tolower [file extension $resolvedCheckpoint]] ne ".rest"} {
+                incr problem
+                lappend messages "Restart initial stresses: the checkpoint file '$checkpoint' must end with '.rest'."
+            } else {
+                lassign [Dam::write::ParseRestartCheckpoint $checkpoint] inputBase fileLabel
+                if {$inputBase eq "" || $fileLabel eq ""} {
+                    incr problem
+                    lappend messages "Restart initial stresses: the checkpoint file '$checkpoint' does not follow the required <model_part>_<label>.rest naming convention (for example MainModelPart_1.0.rest)."
+                }
+            }
+        }
+
+        if {$legacyMapping} {
+            incr problem
+            lappend messages "Restart initial stresses: the legacy result mapping ('Add previous results') cannot be combined with the restart stress transfer. DamAnalysis rejects this combination. Disable one of the two mechanisms."
+        }
+
+        set law [Dam::write::GetPartConstitutiveLaw $group]
+        if {$law ne ""} {
+            set supportedRestartLaws [list \
+                "LinearElasticPlaneStrain2DLaw" \
+                "LinearElasticPlaneStress2DLaw" \
+                "LinearElastic3DLaw" \
+                "ThermalLinearElastic2DPlaneStrain" \
+                "ThermalLinearElastic2DPlaneStress" \
+                "ThermalLinearElastic3DLaw" \
+                "ThermalLinearElastic2DPlaneStrainNodal" \
+                "ThermalLinearElastic2DPlaneStressNodal" \
+                "ThermalLinearElastic3DLawNodal"]
+            set thermalRestartLaws [list \
+                "ThermalLinearElastic2DPlaneStrain" \
+                "ThermalLinearElastic2DPlaneStress" \
+                "ThermalLinearElastic3DLaw" \
+                "ThermalLinearElastic2DPlaneStrainNodal" \
+                "ThermalLinearElastic2DPlaneStressNodal" \
+                "ThermalLinearElastic3DLawNodal"]
+            if {$law ni $supportedRestartLaws} {
+                incr problem
+                lappend messages "Restart initial stresses: the constitutive law '$law' is not supported by the validated selective_initial_stress_process. Supported laws are the linear elastic plane strain/stress/3D laws and the Dam thermal linear elastic laws. Damage, plasticity, history-dependent and mechanical nodal laws are rejected."
+            } elseif {$law in $thermalRestartLaws} {
+                set referenceConditions [Dam::write::GetActiveReferenceTemperatureConditions]
+                if {[llength $referenceConditions] == 0} {
+                    W "Restart initial stresses: the selected part uses thermoelastic law '$law'. The selective initial-stress process requires T == T_ref at import. Make sure an active reference-temperature condition (or another mechanism) sets the reference field to match the current temperature before the transfer."
+                }
+            }
+        }
+    }
+
     return [list $problem $messages]
 }
 
diff --git a/kratos.gid/apps/Dam/xml/Procs.spd b/kratos.gid/apps/Dam/xml/Procs.spd
index 33c7eaad7..93d9fa50d 100644
--- a/kratos.gid/apps/Dam/xml/Procs.spd
+++ b/kratos.gid/apps/Dam/xml/Procs.spd
@@ -81,9 +81,9 @@
 	  ]]>
 	</proc>
 
-	<proc n='GetInitialStateFileValues' args='args'>
+	<proc n='GetTransferFileValues' args='args'>
 	  <![CDATA[
-	  return [Dam::xml::ProcGetInitialStateFileValues $domNode $args]
+	  return [Dam::xml::ProcGetTransferFileValues $domNode $args]
 	  ]]>
 	</proc>
 
diff --git a/kratos.gid/apps/Dam/xml/Utilities.spd b/kratos.gid/apps/Dam/xml/Utilities.spd
index 288768021..a555cf769 100644
--- a/kratos.gid/apps/Dam/xml/Utilities.spd
+++ b/kratos.gid/apps/Dam/xml/Utilities.spd
@@ -63,7 +63,7 @@
         <container n="LoadInitialState" pn="Load initial state" un="DamLoadInitialStateContainer" help="Read selected fields from a Dam initial-state file before the first solution step. It can be enabled together with 'Save initial state'." actualize_tree="1" open_window="0">
             <value n="LoadInitialState" pn="Load initial state" un="DamLoadInitialState" v="No" values="Yes,No" actualize_tree="1" help="Apply the selected initial-state fields before the first solution step"/>
             <container n="LoadInitialStateOptions" pn="Initial state to load" un="DamLoadInitialStateOptions" state="[HideIfUniqueName DamLoadInitialState No]" actualize_tree="1" open_window="0">
-                <value n="InputFile" pn="Input file" un="DamLoadInitialStateFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetInitialStateFileValues]" update_proc="AddFile" help="Initial-state file to read. Use the File handler toolbar to select an existing .json or .json.gz file, including files from other GiD projects. Selected files are copied into this project directory. An absolute path or a path relative to the GiD project directory can also be typed directly."/>
+                <value n="InputFile" pn="Input file" un="DamLoadInitialStateFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Initial-state file to read. Use the File handler toolbar to select an existing .json or .json.gz file, including files from other GiD projects. Selected files are copied into this project directory. An absolute path or a path relative to the GiD project directory can also be typed directly."/>
                 <value n="Part" pn="Target part" un="DamLoadInitialStatePart" v="" values="[GetParts]" help="Structural part that receives the initial state. Its mesh, elements and materials must match the source file."/>
                 <value n="TransferInitialStresses" pn="Transfer initial stresses" un="DamTransferInitialStresses" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the Gauss-point constitutive initial stresses stored in the file"/>
                 <value n="TransferInitialTemperature" pn="Transfer initial temperature" un="DamTransferInitialTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the nodal TEMPERATURE field stored in the file"/>
@@ -72,6 +72,15 @@
             </container>
         </container>
 
+        <container n="RestartInitialStresses" pn="Restart initial stresses (checkpoint)" un="DamRestartInitialStressesContainer" help="Transfer Gauss-point initial stresses from a previous Kratos restart checkpoint (.rest) with the existing selective_initial_stress_process. This route transfers stresses only: it never transfers displacements, time, step counters, loads, TEMPERATURE or NODAL_REFERENCE_TEMPERATURE. Source and destination must use the same mesh, integration rule and validated constitutive laws. For thermoelastic laws, T must equal T_ref at the moment of import, so the reference field must already be assigned (for example by an active Nodal Reference Temperature condition)." actualize_tree="1" open_window="0">
+            <value n="RestartInitialStresses" pn="Transfer stresses from restart checkpoint" un="DamRestartInitialStresses" v="No" values="Yes,No" actualize_tree="1" help="Enable the stress-only transfer from an existing Kratos .rest checkpoint"/>
+            <container n="RestartInitialStressesOptions" pn="Restart stress transfer options" un="DamRestartInitialStressesOptions" state="[HideIfUniqueName DamRestartInitialStresses No]" actualize_tree="1" open_window="0">
+                <value n="CheckpointFile" pn="Checkpoint file (.rest)" un="DamRestartInitialStressFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Select a Kratos restart file named &lt;model_part&gt;_&lt;label&gt;.rest, for example MainModelPart_1.0.rest. The file label is read from the file name. Files from other GiD projects can be selected with the File handler toolbar or referenced by an absolute/relative path."/>
+                <value n="Part" pn="Target part" un="DamRestartInitialStressPart" v="" values="[GetParts]" help="Structural part that receives the checkpoint stresses. The source checkpoint must contain a matching part with the same mesh, integration rule and material."/>
+                <value n="SourcePart" pn="Source part name" un="DamRestartInitialStressSourcePart" v="" help="Optional sub-model-part name inside the checkpoint (for example Parts_Concrete). Leave empty to use the target part name. The checkpoint root model part is expected to be MainModelPart."/>
+            </container>
+        </container>
+
         <container n="SaveResults" pn="Save results (legacy .mdpa)" un="DamSaveResults" help="Legacy workflow: write auxiliary .mdpa files with nodal displacement, nodal Cauchy stress, temperature and reference temperature. These files are consumed by the legacy mapping transfer and cannot be converted into an exact constitutive initial-state file." actualize_tree="1" open_window="0">
             <value n="SaveIntermediateResults" pn="Save Intermediate Results" un="DamSaveIntermediateResults" v="No" values="Yes,No" help="" actualize_tree="1"/>
             <value n="SaveIntermediateStep" pn="Step" un="DamSaveIntermediateStep" state="[checkStateByUniqueName DamSaveIntermediateResults Yes]" v="0" help="" actualize_tree="1"/>
diff --git a/kratos.gid/apps/Dam/xml/XmlController.tcl b/kratos.gid/apps/Dam/xml/XmlController.tcl
index 84071b029..0f14ddd59 100644
--- a/kratos.gid/apps/Dam/xml/XmlController.tcl
+++ b/kratos.gid/apps/Dam/xml/XmlController.tcl
@@ -428,11 +428,12 @@ proc ::Dam::xml::ProcAddResultsState {domNode args} {
     return $state
 }
 
-# File-handler list for the initial-state input. In addition to the files added
-# through the File handler toolbar, a user-provided path is kept in the list so
-# absolute paths and paths relative to the GiD project directory can be typed
-# directly. Values that do not look like a path fall back to the empty entry.
-proc ::Dam::xml::ProcGetInitialStateFileValues {domNode args} {
+# File-handler list for transfer input files (.json, .json.gz and .rest). In
+# addition to the files added through the File handler toolbar, a user-provided
+# path is kept in the list so absolute paths and paths relative to the GiD
+# project directory can be typed directly. Values that do not look like a file
+# path fall back to the empty entry.
+proc ::Dam::xml::ProcGetTransferFileValues {domNode args} {
     customlib::UpdateDocument
     spdAux::LoadModelFiles
 
@@ -444,7 +445,7 @@ proc ::Dam::xml::ProcGetInitialStateFileValues {domNode args} {
         set looksLikePath [expr {
             [string first "/" $current] >= 0 ||
             [string first "\\" $current] >= 0 ||
-            [regexp {\.json(\.gz)?$} $current]}]
+            [regexp {\.(json(\.gz)?|rest)$} $current]}]
         if {$looksLikePath} {
             lappend values $current
         } else {

From 669e713cb928ed222aba2761f6b6168a1b89823e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Iraz=C3=A1bal=20Gonz=C3=A1lez?=
 <jirazabal@cimne.upc.edu>
Date: Tue, 3 Nov 2026 12:05:49 +0100
Subject: [PATCH 3/6] Add support for additional save/load entries in initial
 state management

---
 kratos.gid/apps/Dam/python/MainKratos.py      |  38 +-
 .../apps/Dam/write/writeProjectParameters.tcl | 329 ++++++++++++------
 kratos.gid/apps/Dam/xml/Utilities.spd         |  34 +-
 3 files changed, 285 insertions(+), 116 deletions(-)

diff --git a/kratos.gid/apps/Dam/python/MainKratos.py b/kratos.gid/apps/Dam/python/MainKratos.py
index fa7c333dd..f335b4f08 100644
--- a/kratos.gid/apps/Dam/python/MainKratos.py
+++ b/kratos.gid/apps/Dam/python/MainKratos.py
@@ -166,20 +166,24 @@ def Initialize(self):
         self.list_of_processes += KratosMultiphysics.process_factory.KratosProcessFactory(self.model).ConstructListOfProcesses( self.ProjectParameters["output_device_list"] )
 
         # The initial-state import must be the only mechanism that assigns each
-        # imported field. These checks reproduce the DamAnalysis guards (and
-        # also reject any legacy mapping combined with a new initial-state
-        # import) so that projects launched from GiD fail early and clearly.
-        for attribute in ("transfers_initial_stress",
-                          "transfers_initial_temperature",
-                          "transfers_reference_temperature"):
-            transferring_processes = [
-                process for process in self.list_of_processes
-                if getattr(process, attribute, False)]
-            if len(transferring_processes) > 1:
-                raise RuntimeError(
-                    "More than one process transfers the same initial-state field "
-                    "('{}'). Use only one initial-state processor per field.".format(
-                        attribute))
+        # imported field. Multiple JSON imports are allowed for disjoint parts;
+        # their overlap is validated globally before any ExecuteBeforeSolutionLoop.
+        self.json_import_processes = [
+            process for process in self.list_of_processes
+            if hasattr(process, "PrevalidateInitialState")]
+        restart_stress_processes = [
+            process for process in self.list_of_processes
+            if type(process).__name__ == "SelectiveInitialStressProcess"]
+        if len(restart_stress_processes) > 1:
+            raise RuntimeError(
+                "Only one restart-checkpoint initial-stress transfer is supported.")
+        if restart_stress_processes and any(
+                getattr(process, "transfers_initial_stress", False)
+                for process in self.json_import_processes):
+            raise RuntimeError(
+                "A restart-checkpoint stress transfer cannot be combined with "
+                "a JSON initial-state stress import. Use only one stress source "
+                "per destination part.")
 
         if any(getattr(process, "transfers_reference_temperature", False)
                for process in self.list_of_processes):
@@ -284,6 +288,12 @@ def Initialize(self):
             # Execute initialize solution
             self.construction_utilities.BeforeSolutionLoop()
 
+        # Validate all configured imports before any process applies fields.
+        if self.json_import_processes:
+            from KratosMultiphysics.DamApplication import dam_initial_state_file
+            dam_initial_state_file.ValidateCombinedImports(
+                self.json_import_processes)
+
         # ExecuteBeforeSolutionLoop
         for self.process in self.list_of_processes:
             self.process.ExecuteBeforeSolutionLoop()
diff --git a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
index f8c3ed34b..b038a7ada 100644
--- a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
+++ b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
@@ -960,6 +960,8 @@ proc ::Dam::write::IsInitialStateTransferEnabled { } {
     if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {return 1}
     if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {return 1}
     if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]} {return 1}
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalSave]]} {return 1}
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalLoad]]} {return 1}
     return 0
 }
 
@@ -984,36 +986,113 @@ proc ::Dam::write::ResolveInitialStatePath { value } {
     return [file join $baseDir $value]
 }
 
-proc ::Dam::write::GetSaveInitialStateProcessDict { } {
-    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {return ""}
+# Reads a value from a repeatable blockdata entry.
+proc ::Dam::write::GetBlockValue { node name { default "" } } {
+    set valueNode [$node selectNodes "./value\[@n='$name'\]"]
+    if {$valueNode eq ""} {return $default}
+    return [write::getValueByNode $valueNode force]
+}
 
-    set group [Dam::write::GetInitialStateValue DamSaveInitialStatePart]
-    set saveStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialStresses]]
-    set saveTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialTemperature]]
-    set saveReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialReferenceTemperature]]
-    set stressSource [Dam::write::GetInitialStateValue DamInitialStateStressSource]
-    if {$stressSource eq ""} {set stressSource "current_cauchy"}
-    set outputFile [string trim [Dam::write::GetInitialStateValue DamInitialStateOutputFile]]
+proc ::Dam::write::GetAdditionalSaveInitialStateEntries { } {
+    set entries [list]
+    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalSave]]} {
+        return $entries
+    }
+    set root [customlib::GetBaseRoot]
+    set xp "[spdAux::getRoute DamAdditionalSaveEntries]/blockdata\[@n='SavePart'\]"
+    foreach node [$root selectNodes $xp] {
+        set stressSource [Dam::write::GetBlockValue $node StressSource]
+        if {$stressSource eq ""} {set stressSource "current_cauchy"}
+        lappend entries [dict create \
+            name [$node @name] \
+            group [Dam::write::GetBlockValue $node Part] \
+            stresses [write::isBooleanTrue [Dam::write::GetBlockValue $node SaveInitialStresses]] \
+            temperature [write::isBooleanTrue [Dam::write::GetBlockValue $node SaveInitialTemperature]] \
+            reference [write::isBooleanTrue [Dam::write::GetBlockValue $node SaveReferenceTemperature]] \
+            source $stressSource \
+            output [string trim [Dam::write::GetBlockValue $node OutputFile]]]
+    }
+    return $entries
+}
 
+proc ::Dam::write::GetAdditionalLoadInitialStateEntries { } {
+    set entries [list]
+    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalLoad]]} {
+        return $entries
+    }
+    set root [customlib::GetBaseRoot]
+    set xp "[spdAux::getRoute DamAdditionalLoadEntries]/blockdata\[@n='LoadPart'\]"
+    foreach node [$root selectNodes $xp] {
+        set policy [Dam::write::GetBlockValue $node ReferenceTemperaturePolicy]
+        if {$policy eq ""} {set policy "preserve"}
+        lappend entries [dict create \
+            name [$node @name] \
+            group [Dam::write::GetBlockValue $node Part] \
+            input [string trim [Dam::write::GetBlockValue $node InputFile]] \
+            stresses [write::isBooleanTrue [Dam::write::GetBlockValue $node TransferInitialStresses]] \
+            temperature [write::isBooleanTrue [Dam::write::GetBlockValue $node TransferInitialTemperature]] \
+            reference [write::isBooleanTrue [Dam::write::GetBlockValue $node TransferReferenceTemperature]] \
+            policy $policy]
+    }
+    return $entries
+}
+
+proc ::Dam::write::GetSaveInitialStateEntries { } {
+    set entries [list]
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {
+        set stressSource [Dam::write::GetInitialStateValue DamInitialStateStressSource]
+        if {$stressSource eq ""} {set stressSource "current_cauchy"}
+        lappend entries [dict create \
+            name "single save entry" \
+            group [Dam::write::GetInitialStateValue DamSaveInitialStatePart] \
+            stresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialStresses]] \
+            temperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialTemperature]] \
+            reference [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialReferenceTemperature]] \
+            source $stressSource \
+            output [string trim [Dam::write::GetInitialStateValue DamInitialStateOutputFile]]]
+    }
+    lappend entries {*}[Dam::write::GetAdditionalSaveInitialStateEntries]
+    return $entries
+}
+
+proc ::Dam::write::GetLoadInitialStateEntries { } {
+    set entries [list]
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {
+        set policy [Dam::write::GetInitialStateValue DamReferenceTemperaturePolicy]
+        if {$policy eq ""} {set policy "preserve"}
+        lappend entries [dict create \
+            name "single load entry" \
+            group [Dam::write::GetInitialStateValue DamLoadInitialStatePart] \
+            input [string trim [Dam::write::GetInitialStateValue DamLoadInitialStateFile]] \
+            stresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialStresses]] \
+            temperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialTemperature]] \
+            reference [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialReferenceTemperature]] \
+            policy $policy]
+    }
+    lappend entries {*}[Dam::write::GetAdditionalLoadInitialStateEntries]
+    return $entries
+}
+
+proc ::Dam::write::GetSaveInitialStateProcessDictFor { entry } {
     set parametersDict [dict create]
-    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName $group]
-    if {$saveStresses} {
+    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName [dict get $entry group]]
+    if {[dict get $entry stresses]} {
         dict set parametersDict save_initial_stresses true
     } else {
         dict set parametersDict save_initial_stresses false
     }
-    if {$saveTemperature} {
+    if {[dict get $entry temperature]} {
         dict set parametersDict save_initial_temperature true
     } else {
         dict set parametersDict save_initial_temperature false
     }
-    if {$saveReferenceTemperature} {
+    if {[dict get $entry reference]} {
         dict set parametersDict save_reference_temperature true
     } else {
         dict set parametersDict save_reference_temperature false
     }
-    dict set parametersDict stress_source $stressSource
-    dict set parametersDict output_file_name $outputFile
+    dict set parametersDict stress_source [dict get $entry source]
+    dict set parametersDict output_file_name [dict get $entry output]
 
     set processDict [dict create]
     dict set processDict python_module "save_dam_initial_state_process"
@@ -1022,36 +1101,26 @@ proc ::Dam::write::GetSaveInitialStateProcessDict { } {
     return $processDict
 }
 
-proc ::Dam::write::GetLoadInitialStateProcessDict { } {
-    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {return ""}
-
-    set group [Dam::write::GetInitialStateValue DamLoadInitialStatePart]
-    set inputFile [string trim [Dam::write::GetInitialStateValue DamLoadInitialStateFile]]
-    set transferStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialStresses]]
-    set transferTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialTemperature]]
-    set transferReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialReferenceTemperature]]
-    set referencePolicy [Dam::write::GetInitialStateValue DamReferenceTemperaturePolicy]
-    if {$referencePolicy eq ""} {set referencePolicy "preserve"}
-
+proc ::Dam::write::GetLoadInitialStateProcessDictFor { entry } {
     set parametersDict [dict create]
-    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName $group]
-    dict set parametersDict input_file_name $inputFile
-    if {$transferStresses} {
+    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName [dict get $entry group]]
+    dict set parametersDict input_file_name [dict get $entry input]
+    if {[dict get $entry stresses]} {
         dict set parametersDict transfer_initial_stresses true
     } else {
         dict set parametersDict transfer_initial_stresses false
     }
-    if {$transferTemperature} {
+    if {[dict get $entry temperature]} {
         dict set parametersDict transfer_initial_temperature true
     } else {
         dict set parametersDict transfer_initial_temperature false
     }
-    if {$transferReferenceTemperature} {
+    if {[dict get $entry reference]} {
         dict set parametersDict transfer_reference_temperature true
     } else {
         dict set parametersDict transfer_reference_temperature false
     }
-    dict set parametersDict reference_temperature_policy $referencePolicy
+    dict set parametersDict reference_temperature_policy [dict get $entry policy]
 
     set processDict [dict create]
     dict set processDict python_module "load_dam_initial_state_process"
@@ -1122,12 +1191,14 @@ proc ::Dam::write::GetRestartInitialStressProcessDict { } {
 # JSON file are available when the restart process checks T == T_ref.
 proc ::Dam::write::GetInitialStateProcessList { } {
     set processList [list]
-    set loadProcess [Dam::write::GetLoadInitialStateProcessDict]
-    if {$loadProcess ne ""} {lappend processList $loadProcess}
+    foreach entry [Dam::write::GetLoadInitialStateEntries] {
+        lappend processList [Dam::write::GetLoadInitialStateProcessDictFor $entry]
+    }
     set restartProcess [Dam::write::GetRestartInitialStressProcessDict]
     if {$restartProcess ne ""} {lappend processList $restartProcess}
-    set saveProcess [Dam::write::GetSaveInitialStateProcessDict]
-    if {$saveProcess ne ""} {lappend processList $saveProcess}
+    foreach entry [Dam::write::GetSaveInitialStateEntries] {
+        lappend processList [Dam::write::GetSaveInitialStateProcessDictFor $entry]
+    }
     return $processList
 }
 
@@ -1172,143 +1243,166 @@ proc ::Dam::write::writeValidateEvent { } {
     set hasThermalFields [expr {$damTypeofProblem in [list "Thermo-Mechanical" "UP_Thermo-Mechanical"]}]
     set restartEnabled [write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]
 
-    set saveEnabled [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]
-    if {$saveEnabled} {
-        set saveStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialStresses]]
-        set saveTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialTemperature]]
-        set saveReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialReferenceTemperature]]
+    set additionalSaveEntries [Dam::write::GetAdditionalSaveInitialStateEntries]
+    set additionalLoadEntries [Dam::write::GetAdditionalLoadInitialStateEntries]
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalSave]] &&
+            [llength $additionalSaveEntries] == 0} {
+        incr problem
+        lappend messages "Additional save entries: the section is enabled but no entries are defined. Add an entry or disable it."
+    }
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalLoad]] &&
+            [llength $additionalLoadEntries] == 0} {
+        incr problem
+        lappend messages "Additional load entries: the section is enabled but no entries are defined. Add an entry or disable it."
+    }
 
-        if {!$saveStresses && !$saveTemperature && !$saveReferenceTemperature} {
-            incr problem
-            lappend messages "Save initial state: select at least one field to save (initial stresses, initial temperature or reference temperature)."
-        }
+    set saveEntries [Dam::write::GetSaveInitialStateEntries]
+    set loadEntries [Dam::write::GetLoadInitialStateEntries]
+    set saveEnabled [expr {[llength $saveEntries] > 0}]
+    set loadEnabled [expr {[llength $loadEntries] > 0}]
+
+    set saveOutputs [list]
+    foreach entry $saveEntries {
+        set entryName [dict get $entry name]
+        set group [dict get $entry group]
+        set saveStresses [dict get $entry stresses]
+        set saveTemperature [dict get $entry temperature]
+        set saveReferenceTemperature [dict get $entry reference]
+        set stressSource [dict get $entry source]
+        set outputFile [string trim [dict get $entry output]]
 
-        set group [Dam::write::GetInitialStateValue DamSaveInitialStatePart]
         if {$group eq ""} {
             incr problem
-            lappend messages "Save initial state: select the target part."
+            lappend messages "Save initial state ($entryName): select the target part."
+        }
+        if {!$saveStresses && !$saveTemperature && !$saveReferenceTemperature} {
+            incr problem
+            lappend messages "Save initial state ($entryName): select at least one field to save (initial stresses, initial temperature or reference temperature)."
         }
-
         if {$saveStresses} {
-            set stressSource [Dam::write::GetInitialStateValue DamInitialStateStressSource]
             if {$stressSource ni [list "current_cauchy" "stored_initial_stress"]} {
                 incr problem
-                lappend messages "Save initial state: unsupported stress source '$stressSource'. Select 'Current Cauchy stress' or 'Stored initial stress'."
+                lappend messages "Save initial state ($entryName): unsupported stress source '$stressSource'. Select 'Current Cauchy stress' or 'Stored initial stress'."
             } elseif {$legacyMapping && $stressSource eq "stored_initial_stress"} {
                 incr problem
-                lappend messages "Save initial state: 'Stored initial stress' cannot be combined with the legacy result mapping ('Add previous results'), because the legacy mapping does not populate the constitutive InitialState. Use 'Current Cauchy stress' or disable the legacy mapping."
+                lappend messages "Save initial state ($entryName): 'Stored initial stress' cannot be combined with the legacy result mapping ('Add previous results'), because the legacy mapping does not populate the constitutive InitialState. Use 'Current Cauchy stress' or disable the legacy mapping."
             }
         }
-
         if {!$hasThermalFields} {
             if {$saveTemperature} {
                 incr problem
-                lappend messages "Save initial state: the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Save initial temperature' or use a thermo-mechanical analysis."
+                lappend messages "Save initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Save initial temperature' or use a thermo-mechanical analysis."
             }
             if {$saveReferenceTemperature} {
                 incr problem
-                lappend messages "Save initial state: the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Save reference temperature' or use a thermo-mechanical analysis."
+                lappend messages "Save initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Save reference temperature' or use a thermo-mechanical analysis."
             }
         }
 
-        set outputFile [string trim [Dam::write::GetInitialStateValue DamInitialStateOutputFile]]
         if {$outputFile eq ""} {
             incr problem
-            lappend messages "Save initial state: the output file is empty."
+            lappend messages "Save initial state ($entryName): the output file is empty."
         } elseif {![regexp {\.json(\.gz)?$} $outputFile]} {
             incr problem
-            lappend messages "Save initial state: the output file '$outputFile' must end with '.json' or '.json.gz'."
+            lappend messages "Save initial state ($entryName): the output file '$outputFile' must end with '.json' or '.json.gz'."
         } elseif {[file isdirectory [Dam::write::ResolveInitialStatePath $outputFile]]} {
             incr problem
-            lappend messages "Save initial state: the output path '$outputFile' is an existing directory; provide a file name."
+            lappend messages "Save initial state ($entryName): the output path '$outputFile' is an existing directory; provide a file name."
+        } else {
+            set resolvedOutput [Dam::write::ResolveInitialStatePath $outputFile]
+            catch {set resolvedOutput [file normalize $resolvedOutput]}
+            foreach previous $saveOutputs {
+                if {[Dam::write::PathsEqual $resolvedOutput [lindex $previous 0]]} {
+                    incr problem
+                    lappend messages "Save initial state ($entryName): the output file '$outputFile' is also used by entry '[lindex $previous 1]'. Each save entry must write a distinct file."
+                    break
+                }
+            }
+            lappend saveOutputs [list $resolvedOutput $entryName]
         }
     }
 
-    set loadEnabled [write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]
-    if {$loadEnabled} {
-        set transferStresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialStresses]]
-        set transferTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialTemperature]]
-        set transferReferenceTemperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialReferenceTemperature]]
-        set referencePolicy [Dam::write::GetInitialStateValue DamReferenceTemperaturePolicy]
-        if {$referencePolicy eq ""} {set referencePolicy "preserve"}
+    foreach entry $loadEntries {
+        set entryName [dict get $entry name]
+        set group [dict get $entry group]
+        set transferStresses [dict get $entry stresses]
+        set transferTemperature [dict get $entry temperature]
+        set transferReferenceTemperature [dict get $entry reference]
+        set referencePolicy [dict get $entry policy]
+        set inputFile [string trim [dict get $entry input]]
 
+        if {$group eq ""} {
+            incr problem
+            lappend messages "Load initial state ($entryName): select the target part."
+        }
         if {!$transferStresses && !$transferTemperature && !$transferReferenceTemperature} {
             incr problem
-            lappend messages "Load initial state: select at least one field to transfer (initial stresses, initial temperature or reference temperature)."
+            lappend messages "Load initial state ($entryName): select at least one field to transfer (initial stresses, initial temperature or reference temperature)."
         }
-
         if {$transferStresses && $restartEnabled} {
             incr problem
-            lappend messages "Load initial state: both 'Transfer initial stresses' and the restart checkpoint stress transfer are enabled. Only one mechanism can assign the Gauss-point initial stress. Disable one of them."
+            lappend messages "Load initial state ($entryName): both 'Transfer initial stresses' and the restart checkpoint stress transfer are enabled. Only one mechanism can assign the Gauss-point initial stress. Disable one of them."
         }
-
         if {!$hasThermalFields} {
             if {$transferTemperature} {
                 incr problem
-                lappend messages "Load initial state: the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Transfer initial temperature' or use a thermo-mechanical analysis."
+                lappend messages "Load initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Transfer initial temperature' or use a thermo-mechanical analysis."
             }
             if {$transferReferenceTemperature} {
                 incr problem
-                lappend messages "Load initial state: the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Transfer reference temperature' or use a thermo-mechanical analysis."
+                lappend messages "Load initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Transfer reference temperature' or use a thermo-mechanical analysis."
             }
         }
 
-        set group [Dam::write::GetInitialStateValue DamLoadInitialStatePart]
-        if {$group eq ""} {
-            incr problem
-            lappend messages "Load initial state: select the target part."
-        }
-
-        set inputFile [string trim [Dam::write::GetInitialStateValue DamLoadInitialStateFile]]
         if {[Dam::write::IsNoInitialStateFile $inputFile]} {
             incr problem
-            lappend messages "Load initial state: select an input .json or .json.gz file."
+            lappend messages "Load initial state ($entryName): select an input .json or .json.gz file."
         } else {
             set resolvedInput [Dam::write::ResolveInitialStatePath $inputFile]
             if {![file isfile $resolvedInput]} {
                 incr problem
-                lappend messages "Load initial state: the input file '$inputFile' does not exist (resolved to '$resolvedInput'). Select it with the File handler toolbar or use a valid path."
+                lappend messages "Load initial state ($entryName): the input file '$inputFile' does not exist (resolved to '$resolvedInput'). Select it with the File handler toolbar or use a valid path."
             } elseif {![regexp {\.json(\.gz)?$} $resolvedInput]} {
                 incr problem
-                lappend messages "Load initial state: the input file '$inputFile' must end with '.json' or '.json.gz'."
+                lappend messages "Load initial state ($entryName): the input file '$inputFile' must end with '.json' or '.json.gz'."
             }
         }
 
         if {$referencePolicy ni [list "preserve" "initial_temperature"]} {
             incr problem
-            lappend messages "Load initial state: unsupported reference temperature policy '$referencePolicy'."
+            lappend messages "Load initial state ($entryName): unsupported reference temperature policy '$referencePolicy'."
         }
-
         if {$referencePolicy eq "initial_temperature"} {
             if {!$transferTemperature} {
                 incr problem
-                lappend messages "Load initial state: the policy 'Use initial temperature as reference' requires transferring the initial temperature."
+                lappend messages "Load initial state ($entryName): the policy 'Use initial temperature as reference' requires transferring the initial temperature."
             }
             if {$transferReferenceTemperature} {
                 incr problem
-                lappend messages "Load initial state: 'Transfer reference temperature' and the policy 'Use initial temperature as reference' cannot be enabled at the same time. Disable one of them."
+                lappend messages "Load initial state ($entryName): 'Transfer reference temperature' and the policy 'Use initial temperature as reference' cannot be enabled at the same time. Disable one of them."
             }
         }
+    }
 
-        if {$transferReferenceTemperature || $referencePolicy eq "initial_temperature"} {
-            set referenceConditions [Dam::write::GetActiveReferenceTemperatureConditions]
-            if {[llength $referenceConditions] > 0} {
-                if {$referencePolicy eq "initial_temperature"} {
-                    set conflictAction "Disable or remove those conditions, or do not use the 'Use initial temperature as reference' policy."
-                } else {
-                    set conflictAction "Disable or remove those conditions, or disable 'Transfer reference temperature'."
-                }
-                incr problem
-                lappend messages "Load initial state: the imported NODAL_REFERENCE_TEMPERATURE would be overwritten by the active reference-temperature condition(s): [join $referenceConditions {, }]. $conflictAction The interface does not remove them automatically."
-            }
+    set referenceImportingEntries [list]
+    foreach entry $loadEntries {
+        if {[dict get $entry reference] || [dict get $entry policy] eq "initial_temperature"} {
+            lappend referenceImportingEntries [dict get $entry name]
         }
-
-        if {$legacyMapping} {
+    }
+    if {[llength $referenceImportingEntries] > 0} {
+        set referenceConditions [Dam::write::GetActiveReferenceTemperatureConditions]
+        if {[llength $referenceConditions] > 0} {
             incr problem
-            lappend messages "Load initial state: the legacy result mapping ('Add previous results') cannot be combined with 'Load initial state'. Disable one of the two mechanisms. The legacy mapping transfers nodal fields and is not equivalent to the constitutive initial-state transfer."
+            lappend messages "Load initial state: the imported NODAL_REFERENCE_TEMPERATURE would be overwritten by the active reference-temperature condition(s): [join $referenceConditions {, }]. Disable or remove those conditions, or disable the reference-temperature transfer/policy for entries: [join $referenceImportingEntries {, }]. The interface does not remove them automatically."
         }
     }
 
+    if {$loadEnabled && $legacyMapping} {
+        incr problem
+        lappend messages "Load initial state: the legacy result mapping ('Add previous results') cannot be combined with 'Load initial state'. Disable one of the two mechanisms. The legacy mapping transfers nodal fields and is not equivalent to the constitutive initial-state transfer."
+    }
+
     if {$restartEnabled} {
         set group [Dam::write::GetInitialStateValue DamRestartInitialStressPart]
         if {$group eq ""} {
@@ -1373,6 +1467,43 @@ proc ::Dam::write::writeValidateEvent { } {
         }
     }
 
+    # Warn when the configured entries do not cover all structural parts. Each
+    # process/file covers one part; uncovered parts keep their own state, so the
+    # global model is not necessarily equilibrated even when the covered parts
+    # are imported exactly.
+    if {$saveEnabled || $loadEnabled || $restartEnabled} {
+        set allParts [list]
+        catch {
+            set partsNode [[customlib::GetBaseRoot] selectNodes [spdAux::getRoute DamParts]]
+            foreach group [$partsNode selectNodes "group"] {
+                lappend allParts [$group @n]
+            }
+        }
+        set allParts [lsort -unique $allParts]
+        if {$loadEnabled} {
+            set covered [list]
+            foreach entry $loadEntries {lappend covered [dict get $entry group]}
+            set missing [list]
+            foreach part $allParts {
+                if {$part ni $covered} {lappend missing $part}
+            }
+            if {[llength $missing] > 0} {
+                W "Initial-state load entries do not cover structural part(s): [join $missing {, }]. Those parts keep their own stress/temperature state, so the global model may not be in initial equilibrium."
+            }
+        }
+        if {$saveEnabled} {
+            set covered [list]
+            foreach entry $saveEntries {lappend covered [dict get $entry group]}
+            set missing [list]
+            foreach part $allParts {
+                if {$part ni $covered} {lappend missing $part}
+            }
+            if {[llength $missing] > 0} {
+                W "Initial-state save entries do not cover structural part(s): [join $missing {, }]. The exported initial-state set is partial."
+            }
+        }
+    }
+
     return [list $problem $messages]
 }
 
diff --git a/kratos.gid/apps/Dam/xml/Utilities.spd b/kratos.gid/apps/Dam/xml/Utilities.spd
index a555cf769..3306ac598 100644
--- a/kratos.gid/apps/Dam/xml/Utilities.spd
+++ b/kratos.gid/apps/Dam/xml/Utilities.spd
@@ -49,7 +49,7 @@
         <container n="SaveInitialState" pn="Save initial state" un="DamSaveInitialStateContainer" help="Write a Dam initial-state file at the end of the analysis with the selected Gauss-point stresses and nodal temperatures. It can be enabled together with 'Load initial state'." actualize_tree="1" open_window="0">
             <value n="SaveInitialState" pn="Save initial state" un="DamSaveInitialState" v="No" values="Yes,No" actualize_tree="1" help="Write the selected initial-state fields when the analysis finishes"/>
             <container n="SaveInitialStateOptions" pn="Initial state to save" un="DamSaveInitialStateOptions" state="[HideIfUniqueName DamSaveInitialState No]" actualize_tree="1" open_window="0">
-                <value n="Part" pn="Target part" un="DamSaveInitialStatePart" v="" values="[GetParts]" help="Structural part whose constitutive initial state is written. Only one Dam part is stored per initial-state file."/>
+                <value n="Part" pn="Target part" un="DamSaveInitialStatePart" v="" values="[GetParts]" help="Structural part whose constitutive initial state is written. Only one Dam part is stored per initial-state file; other parts are not included."/>
                 <value n="SaveInitialStresses" pn="Save initial stresses" un="DamSaveInitialStresses" v="Yes" values="Yes,No" actualize_tree="1" help="Save the initial stress state at the element Gauss points"/>
                 <container n="InitialStressesOptions" pn="Initial stresses" un="DamSaveInitialStressesOptions" state="[HideIfUniqueName DamSaveInitialStresses No]" actualize_tree="1" open_window="0">
                     <value n="StressSource" pn="Stress source" un="DamInitialStateStressSource" v="current_cauchy" values="current_cauchy,stored_initial_stress" dict="current_cauchy,Current Cauchy stress,stored_initial_stress,Stored initial stress" help="Current Cauchy stress exports the current total Gauss-point Cauchy stresses (they may include gravity, thermal and other contributions). Stored initial stress exports the constitutive initial stresses currently stored in InitialState, which preserves previously imported stresses independently of later loading."/>
@@ -60,11 +60,25 @@
             </container>
         </container>
 
+        <container n="AdditionalSaveInitialState" pn="Additional save entries" un="DamAdditionalSaveInitialState" help="Add one entry per additional structural part. The single 'Save initial state' section above is the first part; these entries are independent and may use different fields and output files." actualize_tree="1" open_window="0">
+            <value n="Enable" pn="Define additional save entries" un="DamEnableAdditionalSave" v="No" values="Yes,No" actualize_tree="1" help="Enable repeatable save entries for additional structural parts"/>
+            <container n="Entries" pn="Save entries" un="DamAdditionalSaveEntries" state="[HideIfUniqueName DamEnableAdditionalSave No]" actualize_tree="1" open_window="0">
+                <blockdata n="SavePart" pn="Save part" name="Save part 1" sequence="1" editable_name="unique" can_delete_last_item="1">
+                    <value n="Part" pn="Target part" values="[GetParts]" v=""/>
+                    <value n="SaveInitialStresses" pn="Save initial stresses" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="StressSource" pn="Stress source" v="current_cauchy" values="current_cauchy,stored_initial_stress" dict="current_cauchy,Current Cauchy stress,stored_initial_stress,Stored initial stress" state="[getStateFromXPathValue {string(../value[@n='SaveInitialStresses']/@v)} Yes]"/>
+                    <value n="SaveInitialTemperature" pn="Save initial temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="SaveReferenceTemperature" pn="Save reference temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="OutputFile" pn="Output file" v="additional_initial_state.json.gz" help="Unique output path for this part. Use .json or .json.gz. Different entries must not share the same output file."/>
+                </blockdata>
+            </container>
+        </container>
+
         <container n="LoadInitialState" pn="Load initial state" un="DamLoadInitialStateContainer" help="Read selected fields from a Dam initial-state file before the first solution step. It can be enabled together with 'Save initial state'." actualize_tree="1" open_window="0">
             <value n="LoadInitialState" pn="Load initial state" un="DamLoadInitialState" v="No" values="Yes,No" actualize_tree="1" help="Apply the selected initial-state fields before the first solution step"/>
             <container n="LoadInitialStateOptions" pn="Initial state to load" un="DamLoadInitialStateOptions" state="[HideIfUniqueName DamLoadInitialState No]" actualize_tree="1" open_window="0">
                 <value n="InputFile" pn="Input file" un="DamLoadInitialStateFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Initial-state file to read. Use the File handler toolbar to select an existing .json or .json.gz file, including files from other GiD projects. Selected files are copied into this project directory. An absolute path or a path relative to the GiD project directory can also be typed directly."/>
-                <value n="Part" pn="Target part" un="DamLoadInitialStatePart" v="" values="[GetParts]" help="Structural part that receives the initial state. Its mesh, elements and materials must match the source file."/>
+                <value n="Part" pn="Target part" un="DamLoadInitialStatePart" v="" values="[GetParts]" help="Structural part that receives the initial state. Its mesh, elements and materials must match the source file. Only this part is imported; other structural parts keep their own stress and temperature state, so a multi-part model may not be in global initial equilibrium."/>
                 <value n="TransferInitialStresses" pn="Transfer initial stresses" un="DamTransferInitialStresses" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the Gauss-point constitutive initial stresses stored in the file"/>
                 <value n="TransferInitialTemperature" pn="Transfer initial temperature" un="DamTransferInitialTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the nodal TEMPERATURE field stored in the file"/>
                 <value n="TransferReferenceTemperature" pn="Transfer reference temperature" un="DamTransferInitialReferenceTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the nodal NODAL_REFERENCE_TEMPERATURE field stored in the file. Cannot be combined with a reference-temperature condition that would overwrite it."/>
@@ -72,11 +86,25 @@
             </container>
         </container>
 
+        <container n="AdditionalLoadInitialState" pn="Additional load entries" un="DamAdditionalLoadInitialState" help="Add one entry per additional structural part. The single 'Load initial state' section above is the first part; these entries are independent and may use different fields and input files." actualize_tree="1" open_window="0">
+            <value n="Enable" pn="Define additional load entries" un="DamEnableAdditionalLoad" v="No" values="Yes,No" actualize_tree="1" help="Enable repeatable load entries for additional structural parts"/>
+            <container n="Entries" pn="Load entries" un="DamAdditionalLoadEntries" state="[HideIfUniqueName DamEnableAdditionalLoad No]" actualize_tree="1" open_window="0">
+                <blockdata n="LoadPart" pn="Load part" name="Load part 1" sequence="1" editable_name="unique" can_delete_last_item="1">
+                    <value n="Part" pn="Target part" values="[GetParts]" v=""/>
+                    <value n="InputFile" pn="Input file" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Initial-state file for this part. Select a .json or .json.gz file with the File handler toolbar, or type an absolute/relative path."/>
+                    <value n="TransferInitialStresses" pn="Transfer initial stresses" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="TransferInitialTemperature" pn="Transfer initial temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="TransferReferenceTemperature" pn="Transfer reference temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="ReferenceTemperaturePolicy" pn="Reference temperature policy" v="preserve" values="preserve,initial_temperature" dict="preserve,Preserve,initial_temperature,Use initial temperature as reference"/>
+                </blockdata>
+            </container>
+        </container>
+
         <container n="RestartInitialStresses" pn="Restart initial stresses (checkpoint)" un="DamRestartInitialStressesContainer" help="Transfer Gauss-point initial stresses from a previous Kratos restart checkpoint (.rest) with the existing selective_initial_stress_process. This route transfers stresses only: it never transfers displacements, time, step counters, loads, TEMPERATURE or NODAL_REFERENCE_TEMPERATURE. Source and destination must use the same mesh, integration rule and validated constitutive laws. For thermoelastic laws, T must equal T_ref at the moment of import, so the reference field must already be assigned (for example by an active Nodal Reference Temperature condition)." actualize_tree="1" open_window="0">
             <value n="RestartInitialStresses" pn="Transfer stresses from restart checkpoint" un="DamRestartInitialStresses" v="No" values="Yes,No" actualize_tree="1" help="Enable the stress-only transfer from an existing Kratos .rest checkpoint"/>
             <container n="RestartInitialStressesOptions" pn="Restart stress transfer options" un="DamRestartInitialStressesOptions" state="[HideIfUniqueName DamRestartInitialStresses No]" actualize_tree="1" open_window="0">
                 <value n="CheckpointFile" pn="Checkpoint file (.rest)" un="DamRestartInitialStressFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Select a Kratos restart file named &lt;model_part&gt;_&lt;label&gt;.rest, for example MainModelPart_1.0.rest. The file label is read from the file name. Files from other GiD projects can be selected with the File handler toolbar or referenced by an absolute/relative path."/>
-                <value n="Part" pn="Target part" un="DamRestartInitialStressPart" v="" values="[GetParts]" help="Structural part that receives the checkpoint stresses. The source checkpoint must contain a matching part with the same mesh, integration rule and material."/>
+                <value n="Part" pn="Target part" un="DamRestartInitialStressPart" v="" values="[GetParts]" help="Structural part that receives the checkpoint stresses. The source checkpoint must contain a matching part with the same mesh, integration rule and material, and 2D checkpoints must define THICKNESS. Only this part is transferred; other structural parts keep their own state."/>
                 <value n="SourcePart" pn="Source part name" un="DamRestartInitialStressSourcePart" v="" help="Optional sub-model-part name inside the checkpoint (for example Parts_Concrete). Leave empty to use the target part name. The checkpoint root model part is expected to be MainModelPart."/>
             </container>
         </container>

From e03d8cd3d44922bc30cf527efeffb6ea75be995b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Iraz=C3=A1bal=20Gonz=C3=A1lez?=
 <jirazabal@cimne.upc.edu>
Date: Tue, 3 Nov 2026 13:13:04 +0100
Subject: [PATCH 4/6] Refactor initial state transfer mechanisms by removing
 deprecated restart stress processes and updating related documentation

---
 kratos.gid/apps/Dam/python/MainKratos.py      |  13 --
 kratos.gid/apps/Dam/write/write.tcl           |   8 +-
 .../apps/Dam/write/writeProjectParameters.tcl | 151 +-----------------
 kratos.gid/apps/Dam/xml/Utilities.spd         |   9 --
 4 files changed, 7 insertions(+), 174 deletions(-)

diff --git a/kratos.gid/apps/Dam/python/MainKratos.py b/kratos.gid/apps/Dam/python/MainKratos.py
index f335b4f08..7e1ce0c41 100644
--- a/kratos.gid/apps/Dam/python/MainKratos.py
+++ b/kratos.gid/apps/Dam/python/MainKratos.py
@@ -171,19 +171,6 @@ def Initialize(self):
         self.json_import_processes = [
             process for process in self.list_of_processes
             if hasattr(process, "PrevalidateInitialState")]
-        restart_stress_processes = [
-            process for process in self.list_of_processes
-            if type(process).__name__ == "SelectiveInitialStressProcess"]
-        if len(restart_stress_processes) > 1:
-            raise RuntimeError(
-                "Only one restart-checkpoint initial-stress transfer is supported.")
-        if restart_stress_processes and any(
-                getattr(process, "transfers_initial_stress", False)
-                for process in self.json_import_processes):
-            raise RuntimeError(
-                "A restart-checkpoint stress transfer cannot be combined with "
-                "a JSON initial-state stress import. Use only one stress source "
-                "per destination part.")
 
         if any(getattr(process, "transfers_reference_temperature", False)
                for process in self.list_of_processes):
diff --git a/kratos.gid/apps/Dam/write/write.tcl b/kratos.gid/apps/Dam/write/write.tcl
index d1c54bcb9..4195b1de6 100644
--- a/kratos.gid/apps/Dam/write/write.tcl
+++ b/kratos.gid/apps/Dam/write/write.tcl
@@ -96,10 +96,10 @@ proc ::Dam::write::UpdateMaterials { } {
         dict set matdict $mat CONSTITUTIVE_LAW_NAME $newconstlaw
     }
 
-    # The Dam initial-state file format and the restart-based selective stress
-    # utility require THICKNESS on 2D solid parts. Plane-strain laws do not
-    # define it themselves, so provide the standard unit thickness only when an
-    # initial-state transfer is enabled. This keeps unrelated analyses unchanged.
+    # The Dam initial-state file format requires THICKNESS on 2D solid parts.
+    # Plane-strain laws do not define it themselves, so provide the standard
+    # unit thickness only when an initial-state transfer is enabled. This keeps
+    # unrelated analyses unchanged.
     if {[Dam::write::IsInitialStateTransferEnabled] &&
             [string match "2D*" [write::getValue nDim]]} {
         foreach mat [dict keys $matdict] {
diff --git a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
index b038a7ada..a0abc2e53 100644
--- a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
+++ b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
@@ -959,7 +959,6 @@ proc ::Dam::write::GetInitialStateValue { name { it "" } } {
 proc ::Dam::write::IsInitialStateTransferEnabled { } {
     if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {return 1}
     if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {return 1}
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]} {return 1}
     if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalSave]]} {return 1}
     if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalLoad]]} {return 1}
     return 0
@@ -1129,73 +1128,13 @@ proc ::Dam::write::GetLoadInitialStateProcessDictFor { entry } {
     return $processDict
 }
 
-# Splits a restart file name such as MainModelPart_1.0.rest into the base path
-# expected by RestartUtility and the file label. Returns an empty pair when the
-# name does not follow the <model_part>_<label>.rest convention.
-proc ::Dam::write::ParseRestartCheckpoint { value } {
-    set value [string trim $value]
-    if {[Dam::write::IsNoInitialStateFile $value]} {return [list "" ""]}
-
-    if {[string tolower [file extension $value]] ne ".rest"} {return [list "" ""]}
-
-    set stem [string range $value 0 end-5]
-    set dir [file dirname $stem]
-    set name [file tail $stem]
-    set separator [string last "_" $name]
-    if {$separator <= 0 || $separator >= [expr {[string length $name] - 1}]} {
-        return [list "" ""]
-    }
-
-    set baseName [string range $name 0 [expr {$separator - 1}]]
-    set label [string range $name [expr {$separator + 1}] end]
-    return [list [file join $dir $baseName] $label]
-}
-
-# Exposes the existing validated selective_initial_stress_process. This route
-# transfers Gauss-point stresses only; it never transfers temperature fields.
-proc ::Dam::write::GetRestartInitialStressProcessDict { } {
-    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]} {return ""}
-
-    set group [Dam::write::GetInitialStateValue DamRestartInitialStressPart]
-    set checkpoint [string trim [Dam::write::GetInitialStateValue DamRestartInitialStressFile]]
-    lassign [Dam::write::ParseRestartCheckpoint $checkpoint] inputBase fileLabel
-    set sourcePart [string trim [Dam::write::GetInitialStateValue DamRestartInitialStressSourcePart]]
-    if {$sourcePart eq ""} {
-        set sourcePart [Dam::write::GetInitialStateSubModelPartName $group]
-    }
-
-    set restartSettings [dict create]
-    dict set restartSettings input_filename $inputBase
-    # Do not write "input_output_path" as an empty string: the GiD JSON writer
-    # encodes empty strings as [], while RestartUtility expects a string. The
-    # key is unnecessary when load_restart_files_from_folder is false.
-    dict set restartSettings restart_load_file_label $fileLabel
-    dict set restartSettings load_restart_files_from_folder false
-
-    set parametersDict [dict create]
-    dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName $group]
-    dict set parametersDict source_model_part_name $sourcePart
-    dict set parametersDict source_root_model_part_name "MainModelPart"
-    dict set parametersDict restart_settings $restartSettings
-
-    set processDict [dict create]
-    dict set processDict python_module "selective_initial_stress_process"
-    dict set processDict kratos_module "KratosMultiphysics.DamApplication"
-    dict set processDict Parameters $parametersDict
-    return $processDict
-}
-
-# The load processes run before the first solution step and the save process at
-# finalization, so they can coexist in the same calculation. The JSON load runs
-# before the restart import so that temperature/reference fields imported from a
-# JSON file are available when the restart process checks T == T_ref.
+# The load processes run before the first solution step and the save processes at
+# finalization, so they can coexist in the same calculation.
 proc ::Dam::write::GetInitialStateProcessList { } {
     set processList [list]
     foreach entry [Dam::write::GetLoadInitialStateEntries] {
         lappend processList [Dam::write::GetLoadInitialStateProcessDictFor $entry]
     }
-    set restartProcess [Dam::write::GetRestartInitialStressProcessDict]
-    if {$restartProcess ne ""} {lappend processList $restartProcess}
     foreach entry [Dam::write::GetSaveInitialStateEntries] {
         lappend processList [Dam::write::GetSaveInitialStateProcessDictFor $entry]
     }
@@ -1220,28 +1159,12 @@ proc ::Dam::write::GetActiveReferenceTemperatureConditions { } {
 
 # Application-level validation. Returning a nonzero first element aborts the
 # write and displays every message in the GiD warning window.
-# Returns the constitutive law selected for a Dam part group, or an empty
-# string when the part/law cannot be resolved.
-proc ::Dam::write::GetPartConstitutiveLaw { group } {
-    if {$group eq ""} {return ""}
-    set root [customlib::GetBaseRoot]
-    foreach node [$root selectNodes "[spdAux::getRoute DamParts]/group"] {
-        if {[$node @n] eq $group} {
-            set lawNode [$node selectNodes "./value\[@n='ConstitutiveLaw'\]"]
-            if {$lawNode ne ""} {return [get_domnode_attribute $lawNode v]}
-            return ""
-        }
-    }
-    return ""
-}
-
 proc ::Dam::write::writeValidateEvent { } {
     set problem 0
     set messages [list]
     set legacyMapping [write::isBooleanTrue [write::getValue DamPreviousResults AddPreviousResults]]
     set damTypeofProblem [write::getValue DamTypeofProblem]
     set hasThermalFields [expr {$damTypeofProblem in [list "Thermo-Mechanical" "UP_Thermo-Mechanical"]}]
-    set restartEnabled [write::isBooleanTrue [Dam::write::GetInitialStateValue DamRestartInitialStresses]]
 
     set additionalSaveEntries [Dam::write::GetAdditionalSaveInitialStateEntries]
     set additionalLoadEntries [Dam::write::GetAdditionalLoadInitialStateEntries]
@@ -1339,10 +1262,6 @@ proc ::Dam::write::writeValidateEvent { } {
             incr problem
             lappend messages "Load initial state ($entryName): select at least one field to transfer (initial stresses, initial temperature or reference temperature)."
         }
-        if {$transferStresses && $restartEnabled} {
-            incr problem
-            lappend messages "Load initial state ($entryName): both 'Transfer initial stresses' and the restart checkpoint stress transfer are enabled. Only one mechanism can assign the Gauss-point initial stress. Disable one of them."
-        }
         if {!$hasThermalFields} {
             if {$transferTemperature} {
                 incr problem
@@ -1403,75 +1322,11 @@ proc ::Dam::write::writeValidateEvent { } {
         lappend messages "Load initial state: the legacy result mapping ('Add previous results') cannot be combined with 'Load initial state'. Disable one of the two mechanisms. The legacy mapping transfers nodal fields and is not equivalent to the constitutive initial-state transfer."
     }
 
-    if {$restartEnabled} {
-        set group [Dam::write::GetInitialStateValue DamRestartInitialStressPart]
-        if {$group eq ""} {
-            incr problem
-            lappend messages "Restart initial stresses: select the target part."
-        }
-
-        set checkpoint [string trim [Dam::write::GetInitialStateValue DamRestartInitialStressFile]]
-        if {[Dam::write::IsNoInitialStateFile $checkpoint]} {
-            incr problem
-            lappend messages "Restart initial stresses: select a .rest checkpoint file."
-        } else {
-            set resolvedCheckpoint [Dam::write::ResolveInitialStatePath $checkpoint]
-            if {![file isfile $resolvedCheckpoint]} {
-                incr problem
-                lappend messages "Restart initial stresses: the checkpoint file '$checkpoint' does not exist (resolved to '$resolvedCheckpoint'). Select it with the File handler toolbar or use a valid path."
-            } elseif {[string tolower [file extension $resolvedCheckpoint]] ne ".rest"} {
-                incr problem
-                lappend messages "Restart initial stresses: the checkpoint file '$checkpoint' must end with '.rest'."
-            } else {
-                lassign [Dam::write::ParseRestartCheckpoint $checkpoint] inputBase fileLabel
-                if {$inputBase eq "" || $fileLabel eq ""} {
-                    incr problem
-                    lappend messages "Restart initial stresses: the checkpoint file '$checkpoint' does not follow the required <model_part>_<label>.rest naming convention (for example MainModelPart_1.0.rest)."
-                }
-            }
-        }
-
-        if {$legacyMapping} {
-            incr problem
-            lappend messages "Restart initial stresses: the legacy result mapping ('Add previous results') cannot be combined with the restart stress transfer. DamAnalysis rejects this combination. Disable one of the two mechanisms."
-        }
-
-        set law [Dam::write::GetPartConstitutiveLaw $group]
-        if {$law ne ""} {
-            set supportedRestartLaws [list \
-                "LinearElasticPlaneStrain2DLaw" \
-                "LinearElasticPlaneStress2DLaw" \
-                "LinearElastic3DLaw" \
-                "ThermalLinearElastic2DPlaneStrain" \
-                "ThermalLinearElastic2DPlaneStress" \
-                "ThermalLinearElastic3DLaw" \
-                "ThermalLinearElastic2DPlaneStrainNodal" \
-                "ThermalLinearElastic2DPlaneStressNodal" \
-                "ThermalLinearElastic3DLawNodal"]
-            set thermalRestartLaws [list \
-                "ThermalLinearElastic2DPlaneStrain" \
-                "ThermalLinearElastic2DPlaneStress" \
-                "ThermalLinearElastic3DLaw" \
-                "ThermalLinearElastic2DPlaneStrainNodal" \
-                "ThermalLinearElastic2DPlaneStressNodal" \
-                "ThermalLinearElastic3DLawNodal"]
-            if {$law ni $supportedRestartLaws} {
-                incr problem
-                lappend messages "Restart initial stresses: the constitutive law '$law' is not supported by the validated selective_initial_stress_process. Supported laws are the linear elastic plane strain/stress/3D laws and the Dam thermal linear elastic laws. Damage, plasticity, history-dependent and mechanical nodal laws are rejected."
-            } elseif {$law in $thermalRestartLaws} {
-                set referenceConditions [Dam::write::GetActiveReferenceTemperatureConditions]
-                if {[llength $referenceConditions] == 0} {
-                    W "Restart initial stresses: the selected part uses thermoelastic law '$law'. The selective initial-stress process requires T == T_ref at import. Make sure an active reference-temperature condition (or another mechanism) sets the reference field to match the current temperature before the transfer."
-                }
-            }
-        }
-    }
-
     # Warn when the configured entries do not cover all structural parts. Each
     # process/file covers one part; uncovered parts keep their own state, so the
     # global model is not necessarily equilibrated even when the covered parts
     # are imported exactly.
-    if {$saveEnabled || $loadEnabled || $restartEnabled} {
+    if {$saveEnabled || $loadEnabled} {
         set allParts [list]
         catch {
             set partsNode [[customlib::GetBaseRoot] selectNodes [spdAux::getRoute DamParts]]
diff --git a/kratos.gid/apps/Dam/xml/Utilities.spd b/kratos.gid/apps/Dam/xml/Utilities.spd
index 3306ac598..c779c896b 100644
--- a/kratos.gid/apps/Dam/xml/Utilities.spd
+++ b/kratos.gid/apps/Dam/xml/Utilities.spd
@@ -100,15 +100,6 @@
             </container>
         </container>
 
-        <container n="RestartInitialStresses" pn="Restart initial stresses (checkpoint)" un="DamRestartInitialStressesContainer" help="Transfer Gauss-point initial stresses from a previous Kratos restart checkpoint (.rest) with the existing selective_initial_stress_process. This route transfers stresses only: it never transfers displacements, time, step counters, loads, TEMPERATURE or NODAL_REFERENCE_TEMPERATURE. Source and destination must use the same mesh, integration rule and validated constitutive laws. For thermoelastic laws, T must equal T_ref at the moment of import, so the reference field must already be assigned (for example by an active Nodal Reference Temperature condition)." actualize_tree="1" open_window="0">
-            <value n="RestartInitialStresses" pn="Transfer stresses from restart checkpoint" un="DamRestartInitialStresses" v="No" values="Yes,No" actualize_tree="1" help="Enable the stress-only transfer from an existing Kratos .rest checkpoint"/>
-            <container n="RestartInitialStressesOptions" pn="Restart stress transfer options" un="DamRestartInitialStressesOptions" state="[HideIfUniqueName DamRestartInitialStresses No]" actualize_tree="1" open_window="0">
-                <value n="CheckpointFile" pn="Checkpoint file (.rest)" un="DamRestartInitialStressFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Select a Kratos restart file named &lt;model_part&gt;_&lt;label&gt;.rest, for example MainModelPart_1.0.rest. The file label is read from the file name. Files from other GiD projects can be selected with the File handler toolbar or referenced by an absolute/relative path."/>
-                <value n="Part" pn="Target part" un="DamRestartInitialStressPart" v="" values="[GetParts]" help="Structural part that receives the checkpoint stresses. The source checkpoint must contain a matching part with the same mesh, integration rule and material, and 2D checkpoints must define THICKNESS. Only this part is transferred; other structural parts keep their own state."/>
-                <value n="SourcePart" pn="Source part name" un="DamRestartInitialStressSourcePart" v="" help="Optional sub-model-part name inside the checkpoint (for example Parts_Concrete). Leave empty to use the target part name. The checkpoint root model part is expected to be MainModelPart."/>
-            </container>
-        </container>
-
         <container n="SaveResults" pn="Save results (legacy .mdpa)" un="DamSaveResults" help="Legacy workflow: write auxiliary .mdpa files with nodal displacement, nodal Cauchy stress, temperature and reference temperature. These files are consumed by the legacy mapping transfer and cannot be converted into an exact constitutive initial-state file." actualize_tree="1" open_window="0">
             <value n="SaveIntermediateResults" pn="Save Intermediate Results" un="DamSaveIntermediateResults" v="No" values="Yes,No" help="" actualize_tree="1"/>
             <value n="SaveIntermediateStep" pn="Step" un="DamSaveIntermediateStep" state="[checkStateByUniqueName DamSaveIntermediateResults Yes]" v="0" help="" actualize_tree="1"/>

From 1c20312fa7da742f31acdb7547ccb73abc737106 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Iraz=C3=A1bal=20Gonz=C3=A1lez?=
 <jirazabal@cimne.upc.edu>
Date: Tue, 3 Nov 2026 15:06:31 +0100
Subject: [PATCH 5/6] Update file-handler documentation and refine path
 validation for transfer input files

---
 kratos.gid/apps/Dam/xml/XmlController.tcl | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/kratos.gid/apps/Dam/xml/XmlController.tcl b/kratos.gid/apps/Dam/xml/XmlController.tcl
index 0f14ddd59..abb014384 100644
--- a/kratos.gid/apps/Dam/xml/XmlController.tcl
+++ b/kratos.gid/apps/Dam/xml/XmlController.tcl
@@ -428,11 +428,11 @@ proc ::Dam::xml::ProcAddResultsState {domNode args} {
     return $state
 }
 
-# File-handler list for transfer input files (.json, .json.gz and .rest). In
-# addition to the files added through the File handler toolbar, a user-provided
-# path is kept in the list so absolute paths and paths relative to the GiD
-# project directory can be typed directly. Values that do not look like a file
-# path fall back to the empty entry.
+# File-handler list for transfer input files (.json and .json.gz). In addition
+# to the files added through the File handler toolbar, a user-provided
+# .json/.json.gz path is kept in the list so absolute paths and paths relative
+# to the GiD project directory can be typed directly. Values without a supported
+# initial-state extension fall back to the empty entry.
 proc ::Dam::xml::ProcGetTransferFileValues {domNode args} {
     customlib::UpdateDocument
     spdAux::LoadModelFiles
@@ -442,11 +442,7 @@ proc ::Dam::xml::ProcGetTransferFileValues {domNode args} {
 
     set current [get_domnode_attribute $domNode v]
     if {$current ni $values} {
-        set looksLikePath [expr {
-            [string first "/" $current] >= 0 ||
-            [string first "\\" $current] >= 0 ||
-            [regexp {\.(json(\.gz)?|rest)$} $current]}]
-        if {$looksLikePath} {
+        if {[regexp {\.json(\.gz)?$} $current]} {
             lappend values $current
         } else {
             $domNode setAttribute v [lindex $values 0]

From 6d23bb4998c0e75c1b9b8de25cb8c425d3645428 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Iraz=C3=A1bal=20Gonz=C3=A1lez?=
 <jirazabal@cimne.upc.edu>
Date: Tue, 3 Nov 2026 17:35:46 +0100
Subject: [PATCH 6/6] Refactor initial state transfer mechanisms to enhance
 clarity and functionality, updating variable names and restructuring XML
 configuration for export and import processes.

---
 kratos.gid/apps/Dam/python/MainKratos.py      |  14 +-
 .../apps/Dam/write/writeProjectParameters.tcl | 270 +++++++-----------
 kratos.gid/apps/Dam/xml/Utilities.spd         |  67 ++---
 3 files changed, 127 insertions(+), 224 deletions(-)

diff --git a/kratos.gid/apps/Dam/python/MainKratos.py b/kratos.gid/apps/Dam/python/MainKratos.py
index 7e1ce0c41..2f13d1377 100644
--- a/kratos.gid/apps/Dam/python/MainKratos.py
+++ b/kratos.gid/apps/Dam/python/MainKratos.py
@@ -168,11 +168,11 @@ def Initialize(self):
         # The initial-state import must be the only mechanism that assigns each
         # imported field. Multiple JSON imports are allowed for disjoint parts;
         # their overlap is validated globally before any ExecuteBeforeSolutionLoop.
-        self.json_import_processes = [
+        self.initial_state_import_processes = [
             process for process in self.list_of_processes
             if hasattr(process, "PrevalidateInitialState")]
 
-        if any(getattr(process, "transfers_reference_temperature", False)
+        if any(getattr(process, "imports_reference_temperature", False)
                for process in self.list_of_processes):
             reference_process_classes = (
                 "ImposeNodalReferenceTemperatureProcess",
@@ -190,11 +190,7 @@ def Initialize(self):
                     "that assigns it is active. Remove or disable the "
                     "reference-temperature process for this analysis.")
 
-        if self.add_previous_results and any(
-                getattr(process, "transfers_initial_stress", False) or
-                getattr(process, "transfers_initial_temperature", False) or
-                getattr(process, "transfers_reference_temperature", False)
-                for process in self.list_of_processes):
+        if self.add_previous_results and self.initial_state_import_processes:
             raise RuntimeError(
                 "An initial-state transfer process cannot be combined with "
                 "'transfer_results_process.add_previous_results'. Use only one "
@@ -276,10 +272,10 @@ def Initialize(self):
             self.construction_utilities.BeforeSolutionLoop()
 
         # Validate all configured imports before any process applies fields.
-        if self.json_import_processes:
+        if self.initial_state_import_processes:
             from KratosMultiphysics.DamApplication import dam_initial_state_file
             dam_initial_state_file.ValidateCombinedImports(
-                self.json_import_processes)
+                self.initial_state_import_processes)
 
         # ExecuteBeforeSolutionLoop
         for self.process in self.list_of_processes:
diff --git a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
index a0abc2e53..68cbaa5cd 100644
--- a/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
+++ b/kratos.gid/apps/Dam/write/writeProjectParameters.tcl
@@ -957,10 +957,8 @@ proc ::Dam::write::GetInitialStateValue { name { it "" } } {
 
 # True when any of the initial-state transfer mechanisms is enabled.
 proc ::Dam::write::IsInitialStateTransferEnabled { } {
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {return 1}
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {return 1}
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalSave]]} {return 1}
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalLoad]]} {return 1}
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamExportFinalState]]} {return 1}
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamImportInitialState]]} {return 1}
     return 0
 }
 
@@ -992,35 +990,32 @@ proc ::Dam::write::GetBlockValue { node name { default "" } } {
     return [write::getValueByNode $valueNode force]
 }
 
-proc ::Dam::write::GetAdditionalSaveInitialStateEntries { } {
+proc ::Dam::write::GetExportFinalStateEntries { } {
     set entries [list]
-    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalSave]]} {
+    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamExportFinalState]]} {
         return $entries
     }
     set root [customlib::GetBaseRoot]
-    set xp "[spdAux::getRoute DamAdditionalSaveEntries]/blockdata\[@n='SavePart'\]"
+    set xp "[spdAux::getRoute DamExportFinalStateParts]/blockdata\[@n='ExportPart'\]"
     foreach node [$root selectNodes $xp] {
-        set stressSource [Dam::write::GetBlockValue $node StressSource]
-        if {$stressSource eq ""} {set stressSource "current_cauchy"}
         lappend entries [dict create \
             name [$node @name] \
             group [Dam::write::GetBlockValue $node Part] \
-            stresses [write::isBooleanTrue [Dam::write::GetBlockValue $node SaveInitialStresses]] \
-            temperature [write::isBooleanTrue [Dam::write::GetBlockValue $node SaveInitialTemperature]] \
-            reference [write::isBooleanTrue [Dam::write::GetBlockValue $node SaveReferenceTemperature]] \
-            source $stressSource \
+            stresses [write::isBooleanTrue [Dam::write::GetBlockValue $node ExportStresses]] \
+            temperature [write::isBooleanTrue [Dam::write::GetBlockValue $node ExportTemperature]] \
+            reference [write::isBooleanTrue [Dam::write::GetBlockValue $node ExportReferenceTemperature]] \
             output [string trim [Dam::write::GetBlockValue $node OutputFile]]]
     }
     return $entries
 }
 
-proc ::Dam::write::GetAdditionalLoadInitialStateEntries { } {
+proc ::Dam::write::GetImportInitialStateEntries { } {
     set entries [list]
-    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalLoad]]} {
+    if {![write::isBooleanTrue [Dam::write::GetInitialStateValue DamImportInitialState]]} {
         return $entries
     }
     set root [customlib::GetBaseRoot]
-    set xp "[spdAux::getRoute DamAdditionalLoadEntries]/blockdata\[@n='LoadPart'\]"
+    set xp "[spdAux::getRoute DamImportInitialStateParts]/blockdata\[@n='ImportPart'\]"
     foreach node [$root selectNodes $xp] {
         set policy [Dam::write::GetBlockValue $node ReferenceTemperaturePolicy]
         if {$policy eq ""} {set policy "preserve"}
@@ -1028,115 +1023,54 @@ proc ::Dam::write::GetAdditionalLoadInitialStateEntries { } {
             name [$node @name] \
             group [Dam::write::GetBlockValue $node Part] \
             input [string trim [Dam::write::GetBlockValue $node InputFile]] \
-            stresses [write::isBooleanTrue [Dam::write::GetBlockValue $node TransferInitialStresses]] \
-            temperature [write::isBooleanTrue [Dam::write::GetBlockValue $node TransferInitialTemperature]] \
-            reference [write::isBooleanTrue [Dam::write::GetBlockValue $node TransferReferenceTemperature]] \
+            stresses [write::isBooleanTrue [Dam::write::GetBlockValue $node ImportStresses]] \
+            temperature [write::isBooleanTrue [Dam::write::GetBlockValue $node ImportTemperature]] \
+            reference [write::isBooleanTrue [Dam::write::GetBlockValue $node ImportReferenceTemperature]] \
             policy $policy]
     }
     return $entries
 }
 
-proc ::Dam::write::GetSaveInitialStateEntries { } {
-    set entries [list]
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialState]]} {
-        set stressSource [Dam::write::GetInitialStateValue DamInitialStateStressSource]
-        if {$stressSource eq ""} {set stressSource "current_cauchy"}
-        lappend entries [dict create \
-            name "single save entry" \
-            group [Dam::write::GetInitialStateValue DamSaveInitialStatePart] \
-            stresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialStresses]] \
-            temperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialTemperature]] \
-            reference [write::isBooleanTrue [Dam::write::GetInitialStateValue DamSaveInitialReferenceTemperature]] \
-            source $stressSource \
-            output [string trim [Dam::write::GetInitialStateValue DamInitialStateOutputFile]]]
-    }
-    lappend entries {*}[Dam::write::GetAdditionalSaveInitialStateEntries]
-    return $entries
-}
-
-proc ::Dam::write::GetLoadInitialStateEntries { } {
-    set entries [list]
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamLoadInitialState]]} {
-        set policy [Dam::write::GetInitialStateValue DamReferenceTemperaturePolicy]
-        if {$policy eq ""} {set policy "preserve"}
-        lappend entries [dict create \
-            name "single load entry" \
-            group [Dam::write::GetInitialStateValue DamLoadInitialStatePart] \
-            input [string trim [Dam::write::GetInitialStateValue DamLoadInitialStateFile]] \
-            stresses [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialStresses]] \
-            temperature [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialTemperature]] \
-            reference [write::isBooleanTrue [Dam::write::GetInitialStateValue DamTransferInitialReferenceTemperature]] \
-            policy $policy]
-    }
-    lappend entries {*}[Dam::write::GetAdditionalLoadInitialStateEntries]
-    return $entries
-}
-
-proc ::Dam::write::GetSaveInitialStateProcessDictFor { entry } {
+proc ::Dam::write::GetExportFinalStateProcessDictFor { entry } {
     set parametersDict [dict create]
     dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName [dict get $entry group]]
-    if {[dict get $entry stresses]} {
-        dict set parametersDict save_initial_stresses true
-    } else {
-        dict set parametersDict save_initial_stresses false
-    }
-    if {[dict get $entry temperature]} {
-        dict set parametersDict save_initial_temperature true
-    } else {
-        dict set parametersDict save_initial_temperature false
-    }
-    if {[dict get $entry reference]} {
-        dict set parametersDict save_reference_temperature true
-    } else {
-        dict set parametersDict save_reference_temperature false
-    }
-    dict set parametersDict stress_source [dict get $entry source]
+    dict set parametersDict export_stresses [expr {[dict get $entry stresses] ? "true" : "false"}]
+    dict set parametersDict export_temperature [expr {[dict get $entry temperature] ? "true" : "false"}]
+    dict set parametersDict export_reference_temperature [expr {[dict get $entry reference] ? "true" : "false"}]
     dict set parametersDict output_file_name [dict get $entry output]
 
     set processDict [dict create]
-    dict set processDict python_module "save_dam_initial_state_process"
+    dict set processDict python_module "export_dam_final_state_process"
     dict set processDict kratos_module "KratosMultiphysics.DamApplication"
     dict set processDict Parameters $parametersDict
     return $processDict
 }
 
-proc ::Dam::write::GetLoadInitialStateProcessDictFor { entry } {
+proc ::Dam::write::GetImportInitialStateProcessDictFor { entry } {
     set parametersDict [dict create]
     dict set parametersDict model_part_name [Dam::write::GetInitialStateModelPartName [dict get $entry group]]
     dict set parametersDict input_file_name [dict get $entry input]
-    if {[dict get $entry stresses]} {
-        dict set parametersDict transfer_initial_stresses true
-    } else {
-        dict set parametersDict transfer_initial_stresses false
-    }
-    if {[dict get $entry temperature]} {
-        dict set parametersDict transfer_initial_temperature true
-    } else {
-        dict set parametersDict transfer_initial_temperature false
-    }
-    if {[dict get $entry reference]} {
-        dict set parametersDict transfer_reference_temperature true
-    } else {
-        dict set parametersDict transfer_reference_temperature false
-    }
+    dict set parametersDict import_stresses [expr {[dict get $entry stresses] ? "true" : "false"}]
+    dict set parametersDict import_temperature [expr {[dict get $entry temperature] ? "true" : "false"}]
+    dict set parametersDict import_reference_temperature [expr {[dict get $entry reference] ? "true" : "false"}]
     dict set parametersDict reference_temperature_policy [dict get $entry policy]
 
     set processDict [dict create]
-    dict set processDict python_module "load_dam_initial_state_process"
+    dict set processDict python_module "import_dam_initial_state_process"
     dict set processDict kratos_module "KratosMultiphysics.DamApplication"
     dict set processDict Parameters $parametersDict
     return $processDict
 }
 
-# The load processes run before the first solution step and the save processes at
-# finalization, so they can coexist in the same calculation.
+# Import processes run before the first solution step and export processes at
+# finalization, so both can coexist in the same calculation.
 proc ::Dam::write::GetInitialStateProcessList { } {
     set processList [list]
-    foreach entry [Dam::write::GetLoadInitialStateEntries] {
-        lappend processList [Dam::write::GetLoadInitialStateProcessDictFor $entry]
+    foreach entry [Dam::write::GetImportInitialStateEntries] {
+        lappend processList [Dam::write::GetImportInitialStateProcessDictFor $entry]
     }
-    foreach entry [Dam::write::GetSaveInitialStateEntries] {
-        lappend processList [Dam::write::GetSaveInitialStateProcessDictFor $entry]
+    foreach entry [Dam::write::GetExportFinalStateEntries] {
+        lappend processList [Dam::write::GetExportFinalStateProcessDictFor $entry]
     }
     return $processList
 }
@@ -1166,145 +1100,145 @@ proc ::Dam::write::writeValidateEvent { } {
     set damTypeofProblem [write::getValue DamTypeofProblem]
     set hasThermalFields [expr {$damTypeofProblem in [list "Thermo-Mechanical" "UP_Thermo-Mechanical"]}]
 
-    set additionalSaveEntries [Dam::write::GetAdditionalSaveInitialStateEntries]
-    set additionalLoadEntries [Dam::write::GetAdditionalLoadInitialStateEntries]
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalSave]] &&
-            [llength $additionalSaveEntries] == 0} {
+    set exportEntries [Dam::write::GetExportFinalStateEntries]
+    set importEntries [Dam::write::GetImportInitialStateEntries]
+    set exportEnabled [expr {[llength $exportEntries] > 0}]
+    set importEnabled [expr {[llength $importEntries] > 0}]
+
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamExportFinalState]] &&
+            !$exportEnabled} {
         incr problem
-        lappend messages "Additional save entries: the section is enabled but no entries are defined. Add an entry or disable it."
+        lappend messages "Export final state: the section is enabled but no parts are defined. Add a part or disable it."
     }
-    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamEnableAdditionalLoad]] &&
-            [llength $additionalLoadEntries] == 0} {
+    if {[write::isBooleanTrue [Dam::write::GetInitialStateValue DamImportInitialState]] &&
+            !$importEnabled} {
         incr problem
-        lappend messages "Additional load entries: the section is enabled but no entries are defined. Add an entry or disable it."
+        lappend messages "Import initial state: the section is enabled but no parts are defined. Add a part or disable it."
     }
 
-    set saveEntries [Dam::write::GetSaveInitialStateEntries]
-    set loadEntries [Dam::write::GetLoadInitialStateEntries]
-    set saveEnabled [expr {[llength $saveEntries] > 0}]
-    set loadEnabled [expr {[llength $loadEntries] > 0}]
-
-    set saveOutputs [list]
-    foreach entry $saveEntries {
+    set exportOutputs [list]
+    set exportParts [list]
+    foreach entry $exportEntries {
         set entryName [dict get $entry name]
         set group [dict get $entry group]
-        set saveStresses [dict get $entry stresses]
-        set saveTemperature [dict get $entry temperature]
-        set saveReferenceTemperature [dict get $entry reference]
-        set stressSource [dict get $entry source]
+        set exportStresses [dict get $entry stresses]
+        set exportTemperature [dict get $entry temperature]
+        set exportReferenceTemperature [dict get $entry reference]
         set outputFile [string trim [dict get $entry output]]
 
         if {$group eq ""} {
             incr problem
-            lappend messages "Save initial state ($entryName): select the target part."
-        }
-        if {!$saveStresses && !$saveTemperature && !$saveReferenceTemperature} {
+            lappend messages "Export final state ($entryName): select the structural part."
+        } elseif {$group in $exportParts} {
             incr problem
-            lappend messages "Save initial state ($entryName): select at least one field to save (initial stresses, initial temperature or reference temperature)."
+            lappend messages "Export final state ($entryName): structural part '$group' is selected more than once. Use one export entry per part."
+        } else {
+            lappend exportParts $group
         }
-        if {$saveStresses} {
-            if {$stressSource ni [list "current_cauchy" "stored_initial_stress"]} {
-                incr problem
-                lappend messages "Save initial state ($entryName): unsupported stress source '$stressSource'. Select 'Current Cauchy stress' or 'Stored initial stress'."
-            } elseif {$legacyMapping && $stressSource eq "stored_initial_stress"} {
-                incr problem
-                lappend messages "Save initial state ($entryName): 'Stored initial stress' cannot be combined with the legacy result mapping ('Add previous results'), because the legacy mapping does not populate the constitutive InitialState. Use 'Current Cauchy stress' or disable the legacy mapping."
-            }
+        if {!$exportStresses && !$exportTemperature && !$exportReferenceTemperature} {
+            incr problem
+            lappend messages "Export final state ($entryName): select at least one field to export."
         }
         if {!$hasThermalFields} {
-            if {$saveTemperature} {
+            if {$exportTemperature} {
                 incr problem
-                lappend messages "Save initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Save initial temperature' or use a thermo-mechanical analysis."
+                lappend messages "Export final state ($entryName): the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Export temperature' or use a thermo-mechanical analysis."
             }
-            if {$saveReferenceTemperature} {
+            if {$exportReferenceTemperature} {
                 incr problem
-                lappend messages "Save initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Save reference temperature' or use a thermo-mechanical analysis."
+                lappend messages "Export final state ($entryName): the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Export reference temperature' or use a thermo-mechanical analysis."
             }
         }
 
         if {$outputFile eq ""} {
             incr problem
-            lappend messages "Save initial state ($entryName): the output file is empty."
+            lappend messages "Export final state ($entryName): the output file is empty."
         } elseif {![regexp {\.json(\.gz)?$} $outputFile]} {
             incr problem
-            lappend messages "Save initial state ($entryName): the output file '$outputFile' must end with '.json' or '.json.gz'."
+            lappend messages "Export final state ($entryName): the output file '$outputFile' must end with '.json' or '.json.gz'."
         } elseif {[file isdirectory [Dam::write::ResolveInitialStatePath $outputFile]]} {
             incr problem
-            lappend messages "Save initial state ($entryName): the output path '$outputFile' is an existing directory; provide a file name."
+            lappend messages "Export final state ($entryName): the output path '$outputFile' is an existing directory; provide a file name."
         } else {
             set resolvedOutput [Dam::write::ResolveInitialStatePath $outputFile]
             catch {set resolvedOutput [file normalize $resolvedOutput]}
-            foreach previous $saveOutputs {
+            foreach previous $exportOutputs {
                 if {[Dam::write::PathsEqual $resolvedOutput [lindex $previous 0]]} {
                     incr problem
-                    lappend messages "Save initial state ($entryName): the output file '$outputFile' is also used by entry '[lindex $previous 1]'. Each save entry must write a distinct file."
+                    lappend messages "Export final state ($entryName): the output file '$outputFile' is also used by entry '[lindex $previous 1]'. Each export entry must write a distinct file."
                     break
                 }
             }
-            lappend saveOutputs [list $resolvedOutput $entryName]
+            lappend exportOutputs [list $resolvedOutput $entryName]
         }
     }
 
-    foreach entry $loadEntries {
+    set importParts [list]
+    foreach entry $importEntries {
         set entryName [dict get $entry name]
         set group [dict get $entry group]
-        set transferStresses [dict get $entry stresses]
-        set transferTemperature [dict get $entry temperature]
-        set transferReferenceTemperature [dict get $entry reference]
+        set importStresses [dict get $entry stresses]
+        set importTemperature [dict get $entry temperature]
+        set importReferenceTemperature [dict get $entry reference]
         set referencePolicy [dict get $entry policy]
         set inputFile [string trim [dict get $entry input]]
 
         if {$group eq ""} {
             incr problem
-            lappend messages "Load initial state ($entryName): select the target part."
+            lappend messages "Import initial state ($entryName): select the structural part."
+        } elseif {$group in $importParts} {
+            incr problem
+            lappend messages "Import initial state ($entryName): structural part '$group' is selected more than once. Use one import entry per part."
+        } else {
+            lappend importParts $group
         }
-        if {!$transferStresses && !$transferTemperature && !$transferReferenceTemperature} {
+        if {!$importStresses && !$importTemperature && !$importReferenceTemperature} {
             incr problem
-            lappend messages "Load initial state ($entryName): select at least one field to transfer (initial stresses, initial temperature or reference temperature)."
+            lappend messages "Import initial state ($entryName): select at least one field to import."
         }
         if {!$hasThermalFields} {
-            if {$transferTemperature} {
+            if {$importTemperature} {
                 incr problem
-                lappend messages "Load initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Transfer initial temperature' or use a thermo-mechanical analysis."
+                lappend messages "Import initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal TEMPERATURE. Disable 'Import temperature' or use a thermo-mechanical analysis."
             }
-            if {$transferReferenceTemperature} {
+            if {$importReferenceTemperature} {
                 incr problem
-                lappend messages "Load initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Transfer reference temperature' or use a thermo-mechanical analysis."
+                lappend messages "Import initial state ($entryName): the analysis type '$damTypeofProblem' does not define nodal NODAL_REFERENCE_TEMPERATURE. Disable 'Import reference temperature' or use a thermo-mechanical analysis."
             }
         }
 
         if {[Dam::write::IsNoInitialStateFile $inputFile]} {
             incr problem
-            lappend messages "Load initial state ($entryName): select an input .json or .json.gz file."
+            lappend messages "Import initial state ($entryName): select an input .json or .json.gz file."
         } else {
             set resolvedInput [Dam::write::ResolveInitialStatePath $inputFile]
             if {![file isfile $resolvedInput]} {
                 incr problem
-                lappend messages "Load initial state ($entryName): the input file '$inputFile' does not exist (resolved to '$resolvedInput'). Select it with the File handler toolbar or use a valid path."
+                lappend messages "Import initial state ($entryName): the input file '$inputFile' does not exist (resolved to '$resolvedInput'). Select it with the File handler toolbar or use a valid path."
             } elseif {![regexp {\.json(\.gz)?$} $resolvedInput]} {
                 incr problem
-                lappend messages "Load initial state ($entryName): the input file '$inputFile' must end with '.json' or '.json.gz'."
+                lappend messages "Import initial state ($entryName): the input file '$inputFile' must end with '.json' or '.json.gz'."
             }
         }
 
         if {$referencePolicy ni [list "preserve" "initial_temperature"]} {
             incr problem
-            lappend messages "Load initial state ($entryName): unsupported reference temperature policy '$referencePolicy'."
+            lappend messages "Import initial state ($entryName): unsupported reference temperature policy '$referencePolicy'."
         }
         if {$referencePolicy eq "initial_temperature"} {
-            if {!$transferTemperature} {
+            if {!$importTemperature} {
                 incr problem
-                lappend messages "Load initial state ($entryName): the policy 'Use initial temperature as reference' requires transferring the initial temperature."
+                lappend messages "Import initial state ($entryName): the policy 'Use initial temperature as reference' requires importing the initial temperature."
             }
-            if {$transferReferenceTemperature} {
+            if {$importReferenceTemperature} {
                 incr problem
-                lappend messages "Load initial state ($entryName): 'Transfer reference temperature' and the policy 'Use initial temperature as reference' cannot be enabled at the same time. Disable one of them."
+                lappend messages "Import initial state ($entryName): 'Import reference temperature' and the policy 'Use initial temperature as reference' cannot be enabled at the same time. Disable one of them."
             }
         }
     }
 
     set referenceImportingEntries [list]
-    foreach entry $loadEntries {
+    foreach entry $importEntries {
         if {[dict get $entry reference] || [dict get $entry policy] eq "initial_temperature"} {
             lappend referenceImportingEntries [dict get $entry name]
         }
@@ -1313,20 +1247,20 @@ proc ::Dam::write::writeValidateEvent { } {
         set referenceConditions [Dam::write::GetActiveReferenceTemperatureConditions]
         if {[llength $referenceConditions] > 0} {
             incr problem
-            lappend messages "Load initial state: the imported NODAL_REFERENCE_TEMPERATURE would be overwritten by the active reference-temperature condition(s): [join $referenceConditions {, }]. Disable or remove those conditions, or disable the reference-temperature transfer/policy for entries: [join $referenceImportingEntries {, }]. The interface does not remove them automatically."
+            lappend messages "Import initial state: the imported NODAL_REFERENCE_TEMPERATURE would be overwritten by the active reference-temperature condition(s): [join $referenceConditions {, }]. Disable or remove those conditions, or disable the reference-temperature import/policy for entries: [join $referenceImportingEntries {, }]. The interface does not remove them automatically."
         }
     }
 
-    if {$loadEnabled && $legacyMapping} {
+    if {$importEnabled && $legacyMapping} {
         incr problem
-        lappend messages "Load initial state: the legacy result mapping ('Add previous results') cannot be combined with 'Load initial state'. Disable one of the two mechanisms. The legacy mapping transfers nodal fields and is not equivalent to the constitutive initial-state transfer."
+        lappend messages "Import initial state: the legacy result mapping ('Add previous results') cannot be combined with 'Import initial state'. Disable one of the two mechanisms. The legacy mapping transfers nodal fields and is not equivalent to the constitutive initial-state transfer."
     }
 
     # Warn when the configured entries do not cover all structural parts. Each
     # process/file covers one part; uncovered parts keep their own state, so the
     # global model is not necessarily equilibrated even when the covered parts
-    # are imported exactly.
-    if {$saveEnabled || $loadEnabled} {
+    # are transferred exactly.
+    if {$exportEnabled || $importEnabled} {
         set allParts [list]
         catch {
             set partsNode [[customlib::GetBaseRoot] selectNodes [spdAux::getRoute DamParts]]
@@ -1335,26 +1269,26 @@ proc ::Dam::write::writeValidateEvent { } {
             }
         }
         set allParts [lsort -unique $allParts]
-        if {$loadEnabled} {
+        if {$importEnabled} {
             set covered [list]
-            foreach entry $loadEntries {lappend covered [dict get $entry group]}
+            foreach entry $importEntries {lappend covered [dict get $entry group]}
             set missing [list]
             foreach part $allParts {
                 if {$part ni $covered} {lappend missing $part}
             }
             if {[llength $missing] > 0} {
-                W "Initial-state load entries do not cover structural part(s): [join $missing {, }]. Those parts keep their own stress/temperature state, so the global model may not be in initial equilibrium."
+                W "Import initial state entries do not cover structural part(s): [join $missing {, }]. Those parts keep their own stress/temperature state, so the global model may not be in initial equilibrium."
             }
         }
-        if {$saveEnabled} {
+        if {$exportEnabled} {
             set covered [list]
-            foreach entry $saveEntries {lappend covered [dict get $entry group]}
+            foreach entry $exportEntries {lappend covered [dict get $entry group]}
             set missing [list]
             foreach part $allParts {
                 if {$part ni $covered} {lappend missing $part}
             }
             if {[llength $missing] > 0} {
-                W "Initial-state save entries do not cover structural part(s): [join $missing {, }]. The exported initial-state set is partial."
+                W "Export final state entries do not cover structural part(s): [join $missing {, }]. The exported state set is partial."
             }
         }
     }
diff --git a/kratos.gid/apps/Dam/xml/Utilities.spd b/kratos.gid/apps/Dam/xml/Utilities.spd
index c779c896b..296193dab 100644
--- a/kratos.gid/apps/Dam/xml/Utilities.spd
+++ b/kratos.gid/apps/Dam/xml/Utilities.spd
@@ -44,57 +44,30 @@
     </container>
 
     <container n="TransferResults" pn="Transfer results" un="DamTransferResults" icon="transfer_results" actualize_tree="1" open_window="0"
-        help="Transfer the initial state between Dam calculations. Save/Load initial state read and write exact constitutive initial-state files (Gauss-point initial stresses plus nodal temperatures). Legacy result transfer maps nodal fields from previously saved .mdpa result files and is not equivalent to the exact constitutive-state transfer.">
+        help="Transfer the initial state between Dam calculations. Export final state and Import initial state read and write exact constitutive state files (Gauss-point initial stresses plus nodal temperatures). Legacy result transfer maps nodal fields from previously saved .mdpa result files and is not equivalent to the exact constitutive-state transfer.">
 
-        <container n="SaveInitialState" pn="Save initial state" un="DamSaveInitialStateContainer" help="Write a Dam initial-state file at the end of the analysis with the selected Gauss-point stresses and nodal temperatures. It can be enabled together with 'Load initial state'." actualize_tree="1" open_window="0">
-            <value n="SaveInitialState" pn="Save initial state" un="DamSaveInitialState" v="No" values="Yes,No" actualize_tree="1" help="Write the selected initial-state fields when the analysis finishes"/>
-            <container n="SaveInitialStateOptions" pn="Initial state to save" un="DamSaveInitialStateOptions" state="[HideIfUniqueName DamSaveInitialState No]" actualize_tree="1" open_window="0">
-                <value n="Part" pn="Target part" un="DamSaveInitialStatePart" v="" values="[GetParts]" help="Structural part whose constitutive initial state is written. Only one Dam part is stored per initial-state file; other parts are not included."/>
-                <value n="SaveInitialStresses" pn="Save initial stresses" un="DamSaveInitialStresses" v="Yes" values="Yes,No" actualize_tree="1" help="Save the initial stress state at the element Gauss points"/>
-                <container n="InitialStressesOptions" pn="Initial stresses" un="DamSaveInitialStressesOptions" state="[HideIfUniqueName DamSaveInitialStresses No]" actualize_tree="1" open_window="0">
-                    <value n="StressSource" pn="Stress source" un="DamInitialStateStressSource" v="current_cauchy" values="current_cauchy,stored_initial_stress" dict="current_cauchy,Current Cauchy stress,stored_initial_stress,Stored initial stress" help="Current Cauchy stress exports the current total Gauss-point Cauchy stresses (they may include gravity, thermal and other contributions). Stored initial stress exports the constitutive initial stresses currently stored in InitialState, which preserves previously imported stresses independently of later loading."/>
-                </container>
-                <value n="SaveInitialTemperature" pn="Save initial temperature" un="DamSaveInitialTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Save the nodal TEMPERATURE field"/>
-                <value n="SaveReferenceTemperature" pn="Save reference temperature" un="DamSaveInitialReferenceTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Save the nodal NODAL_REFERENCE_TEMPERATURE field"/>
-                <value n="OutputFile" pn="Output file" un="DamInitialStateOutputFile" v="initial_state.json.gz" help="Output path for the initial-state file. Use an absolute path, a path relative to the GiD project directory, or a filename. Supported extensions are .json and .json.gz. Parent folders are created automatically."/>
-            </container>
-        </container>
-
-        <container n="AdditionalSaveInitialState" pn="Additional save entries" un="DamAdditionalSaveInitialState" help="Add one entry per additional structural part. The single 'Save initial state' section above is the first part; these entries are independent and may use different fields and output files." actualize_tree="1" open_window="0">
-            <value n="Enable" pn="Define additional save entries" un="DamEnableAdditionalSave" v="No" values="Yes,No" actualize_tree="1" help="Enable repeatable save entries for additional structural parts"/>
-            <container n="Entries" pn="Save entries" un="DamAdditionalSaveEntries" state="[HideIfUniqueName DamEnableAdditionalSave No]" actualize_tree="1" open_window="0">
-                <blockdata n="SavePart" pn="Save part" name="Save part 1" sequence="1" editable_name="unique" can_delete_last_item="1">
-                    <value n="Part" pn="Target part" values="[GetParts]" v=""/>
-                    <value n="SaveInitialStresses" pn="Save initial stresses" v="Yes" values="Yes,No" actualize_tree="1"/>
-                    <value n="StressSource" pn="Stress source" v="current_cauchy" values="current_cauchy,stored_initial_stress" dict="current_cauchy,Current Cauchy stress,stored_initial_stress,Stored initial stress" state="[getStateFromXPathValue {string(../value[@n='SaveInitialStresses']/@v)} Yes]"/>
-                    <value n="SaveInitialTemperature" pn="Save initial temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
-                    <value n="SaveReferenceTemperature" pn="Save reference temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
-                    <value n="OutputFile" pn="Output file" v="additional_initial_state.json.gz" help="Unique output path for this part. Use .json or .json.gz. Different entries must not share the same output file."/>
+        <container n="ExportFinalState" pn="Export final state" un="DamExportFinalStateContainer" help="Selected fields are exported at the end of the calculation for use in a subsequent analysis." actualize_tree="1" open_window="0">
+            <value n="Enable" pn="Enable export" un="DamExportFinalState" v="No" values="Yes,No" actualize_tree="1" help="Export the selected fields when the analysis finishes"/>
+            <container n="Parts" pn="Parts to export" un="DamExportFinalStateParts" state="[HideIfUniqueName DamExportFinalState No]" actualize_tree="1" open_window="0">
+                <blockdata n="ExportPart" pn="Part" name="Part 1" sequence="1" editable_name="unique" can_delete_last_item="1">
+                    <value n="Part" pn="Structural part" values="[GetParts]" v=""/>
+                    <value n="ExportStresses" pn="Export Cauchy stresses" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="ExportTemperature" pn="Export temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="ExportReferenceTemperature" pn="Export reference temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="OutputFile" pn="Output file" v="final_state.json.gz" help="Output file for this part. Use .json or .json.gz. Different parts must use different output files."/>
                 </blockdata>
             </container>
         </container>
 
-        <container n="LoadInitialState" pn="Load initial state" un="DamLoadInitialStateContainer" help="Read selected fields from a Dam initial-state file before the first solution step. It can be enabled together with 'Save initial state'." actualize_tree="1" open_window="0">
-            <value n="LoadInitialState" pn="Load initial state" un="DamLoadInitialState" v="No" values="Yes,No" actualize_tree="1" help="Apply the selected initial-state fields before the first solution step"/>
-            <container n="LoadInitialStateOptions" pn="Initial state to load" un="DamLoadInitialStateOptions" state="[HideIfUniqueName DamLoadInitialState No]" actualize_tree="1" open_window="0">
-                <value n="InputFile" pn="Input file" un="DamLoadInitialStateFile" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Initial-state file to read. Use the File handler toolbar to select an existing .json or .json.gz file, including files from other GiD projects. Selected files are copied into this project directory. An absolute path or a path relative to the GiD project directory can also be typed directly."/>
-                <value n="Part" pn="Target part" un="DamLoadInitialStatePart" v="" values="[GetParts]" help="Structural part that receives the initial state. Its mesh, elements and materials must match the source file. Only this part is imported; other structural parts keep their own stress and temperature state, so a multi-part model may not be in global initial equilibrium."/>
-                <value n="TransferInitialStresses" pn="Transfer initial stresses" un="DamTransferInitialStresses" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the Gauss-point constitutive initial stresses stored in the file"/>
-                <value n="TransferInitialTemperature" pn="Transfer initial temperature" un="DamTransferInitialTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the nodal TEMPERATURE field stored in the file"/>
-                <value n="TransferReferenceTemperature" pn="Transfer reference temperature" un="DamTransferInitialReferenceTemperature" v="Yes" values="Yes,No" actualize_tree="1" help="Assign the nodal NODAL_REFERENCE_TEMPERATURE field stored in the file. Cannot be combined with a reference-temperature condition that would overwrite it."/>
-                <value n="ReferenceTemperaturePolicy" pn="Reference temperature policy" un="DamReferenceTemperaturePolicy" v="preserve" values="preserve,initial_temperature" dict="preserve,Preserve,initial_temperature,Use initial temperature as reference" help="Preserve keeps the imported TEMPERATURE and NODAL_REFERENCE_TEMPERATURE independent, which is recommended for staged construction and supports TEMPERATURE different from NODAL_REFERENCE_TEMPERATURE. Use initial temperature as reference explicitly resets NODAL_REFERENCE_TEMPERATURE to the imported TEMPERATURE; it requires transferring the initial temperature and cannot be combined with transferring the stored reference temperature."/>
-            </container>
-        </container>
-
-        <container n="AdditionalLoadInitialState" pn="Additional load entries" un="DamAdditionalLoadInitialState" help="Add one entry per additional structural part. The single 'Load initial state' section above is the first part; these entries are independent and may use different fields and input files." actualize_tree="1" open_window="0">
-            <value n="Enable" pn="Define additional load entries" un="DamEnableAdditionalLoad" v="No" values="Yes,No" actualize_tree="1" help="Enable repeatable load entries for additional structural parts"/>
-            <container n="Entries" pn="Load entries" un="DamAdditionalLoadEntries" state="[HideIfUniqueName DamEnableAdditionalLoad No]" actualize_tree="1" open_window="0">
-                <blockdata n="LoadPart" pn="Load part" name="Load part 1" sequence="1" editable_name="unique" can_delete_last_item="1">
-                    <value n="Part" pn="Target part" values="[GetParts]" v=""/>
-                    <value n="InputFile" pn="Input file" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Initial-state file for this part. Select a .json or .json.gz file with the File handler toolbar, or type an absolute/relative path."/>
-                    <value n="TransferInitialStresses" pn="Transfer initial stresses" v="Yes" values="Yes,No" actualize_tree="1"/>
-                    <value n="TransferInitialTemperature" pn="Transfer initial temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
-                    <value n="TransferReferenceTemperature" pn="Transfer reference temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+        <container n="ImportInitialState" pn="Import initial state" un="DamImportInitialStateContainer" help="Selected fields are imported before the solution starts, without transferring displacements, time or solver history." actualize_tree="1" open_window="0">
+            <value n="Enable" pn="Enable import" un="DamImportInitialState" v="No" values="Yes,No" actualize_tree="1" help="Apply the selected initial-state fields before the first solution step"/>
+            <container n="Parts" pn="Parts to import" un="DamImportInitialStateParts" state="[HideIfUniqueName DamImportInitialState No]" actualize_tree="1" open_window="0">
+                <blockdata n="ImportPart" pn="Part" name="Part 1" sequence="1" editable_name="unique" can_delete_last_item="1">
+                    <value n="Part" pn="Structural part" values="[GetParts]" v=""/>
+                    <value n="InputFile" pn="Input file" type="file" v="- No file - (add files using File handler toolbar)" values="[GetTransferFileValues]" update_proc="AddFile" help="Final-state file for this part. Select an existing .json or .json.gz file, or type an absolute/relative path."/>
+                    <value n="ImportStresses" pn="Import initial stresses" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="ImportTemperature" pn="Import temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
+                    <value n="ImportReferenceTemperature" pn="Import reference temperature" v="Yes" values="Yes,No" actualize_tree="1"/>
                     <value n="ReferenceTemperaturePolicy" pn="Reference temperature policy" v="preserve" values="preserve,initial_temperature" dict="preserve,Preserve,initial_temperature,Use initial temperature as reference"/>
                 </blockdata>
             </container>
@@ -106,7 +79,7 @@
             <value n="SaveFinalResults" pn="Save Final Results" un="DamSaveFinalResults" v="No" values="Yes,No" help="" actualize_tree="1"/>
         </container>
 
-        <container n="PreviousResults" pn="Legacy result transfer (mapping)" un="DamPreviousResults" help="Legacy mapping from previously calculated Dam projects. It reads the .mdpa result files written by 'Save results (legacy .mdpa)', maps nodal DISPLACEMENT, nodal NODAL_CAUCHY_STRESS_TENSOR, TEMPERATURE and NODAL_REFERENCE_TEMPERATURE, and supports different meshes. It does not transfer the constitutive Gauss-point InitialState, so it is not equivalent to 'Load initial state'. It cannot be combined with 'Load initial state'." actualize_tree="1" open_window="0">
+        <container n="PreviousResults" pn="Legacy result transfer (mapping)" un="DamPreviousResults" help="Legacy mapping from previously calculated Dam projects. It reads the .mdpa result files written by 'Save results (legacy .mdpa)', maps nodal DISPLACEMENT, nodal NODAL_CAUCHY_STRESS_TENSOR, TEMPERATURE and NODAL_REFERENCE_TEMPERATURE, and supports different meshes. It does not transfer the constitutive Gauss-point InitialState, so it is not equivalent to 'Import initial state'. It cannot be combined with 'Import initial state'." actualize_tree="1" open_window="0">
             <value n="AddPreviousResults" pn="Add previous results" un="DamAddPreviousResults" v="No" values="Yes,No" help="Enable the legacy nodal-field mapping from previous .mdpa result files" actualize_tree="1"/>
             <value n="TypeResults" pn="Type of results" un="DamTypeResults" v="Thermo-Mechanical" values="Mechanical,Thermal,Thermo-Mechanical" state="[HideIfUniqueName DamAddPreviousResults No]" help="" actualize_tree="1"/>
             <container n="AddResultsData" pn="Add data" un="DamAddResultsData" state="[addResultsState]" actualize_tree="1" open_window="0">