Fixes #2760 Add validation of Nan and Inf parameters at t=0 (#2761)

* Fixes #2760 Add validation of Nan and Inf parameters at t=0

* refactory names and id's in tests

* modify requirement for braces in all loops/conditionals

* pr feedback

* change the object type resolver call

* update xml doc

Author: rwmcintosh

CLAUDE.md

@@ -90,7 +90,7 @@ public class When_running_population : concern_for_PopulationRunner
 
 **Style:**
 - 3 spaces indentation (no tabs)
-- Always use braces for loops/conditionals
+- Always use braces for loops/conditionals, except when only a single line is nested
 - No Hungarian notation
 - English comments only
 - Use constants for magic numbers/strings

OSPSuite.Core.sln

@@ -9,6 +9,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		.github\workflows\build-and-publish_12.3.yml = .github\workflows\build-and-publish_12.3.yml
 		.github\workflows\build-and-test.yml = .github\workflows\build-and-test.yml
+		CLAUDE.md = CLAUDE.md
 		.github\workflows\coverage.yml = .github\workflows\coverage.yml
 		dotcover.xml = dotcover.xml
 		logo.png = logo.png

src/OSPSuite.Assets/UIConstants.cs

@@ -1064,8 +1064,8 @@ public static string ParameterIdentificationFinished(string parameterIdentificat
 
          public static string SensitivityCalculationFailed(string parameterIdentificationName, IReadOnlyList<string> errorMessages, string duration = null)
          {
-            return string.IsNullOrEmpty(duration) ? 
-               $"Parameter identification '{parameterIdentificationName}' finished but sensitivity calculation failed.\n\n {string.Join("\n\n", errorMessages)}" : 
+            return string.IsNullOrEmpty(duration) ?
+               $"Parameter identification '{parameterIdentificationName}' finished but sensitivity calculation failed.\n\n {string.Join("\n\n", errorMessages)}" :
                $"Parameter identification '{parameterIdentificationName}' finished in {duration} but sensitivity calculation failed.\n\n {string.Join("\n\n", errorMessages)}";
          }
 
@@ -1268,13 +1268,13 @@ private static string buildNestedList(IReadOnlyList<string> failedPKParameterCal
          {
             var sb = new StringBuilder();
             sb.AppendLine();
-            
+
             failedPKParameterCalculations.Each(x =>
             {
                sb.Append(" - ");
                sb.AppendLine(x);
             });
-            
+
             return sb.ToString();
          }
 
@@ -1341,7 +1341,7 @@ public static string SensitivityAnalysisErrorMessage(IReadOnlyList<string> error
                stringBuilder.AppendLine();
                stringBuilder.AppendLine();
             });
-            
+
             return stringBuilder.ToString();
          }
       }
@@ -1432,7 +1432,7 @@ public static class GroupRowFormat
             public static string Time = "Time";
             public static string Observation = "Observation";
             public static string DeviationLine = "Deviation Lines";
-            public static string Undefined = "Undefined"; 
+            public static string Undefined = "Undefined";
          }
 
          public static class DeviationLines
@@ -1450,9 +1450,9 @@ public static class DeviationLines
       private static string projectNameAndVersionAsString(string versionDisplay, int version) => $"V{versionDisplay} {numberDisplay(version)}";
 
       public static string ProjectVersionCannotBeLoaded(
-         int projectVersion, 
-         string oldestSupportedDisplayVersion, 
-         int oldestSupportedVersion, 
+         int projectVersion,
+         string oldestSupportedDisplayVersion,
+         int oldestSupportedVersion,
          string currentSupportedDisplayVersion,
          int currentSupportedVersion,
          string downloadUrl)
@@ -1505,10 +1505,10 @@ public static class Error
       public static readonly string FoldValueMustBeGreaterThanOne = "Fold value must be a number greater than one.";
       public static readonly string ImporterEmptyFile = "The file you are trying to load is empty.";
 
-      public static string CannotFindParentContainerWithPath(string parentPath, string containerName, string buildingBlockName, string moduleName) => 
+      public static string CannotFindParentContainerWithPath(string parentPath, string containerName, string buildingBlockName, string moduleName) =>
          $"Cannot find parent container '{parentPath}' defined as target of container '{containerName}' in building block '{buildingBlockName}' in module '{moduleName}'";
 
-      public static  string NoUnitColumnValues(string mappingName) => $"No values for the unit were found in the excel column mapped for '{mappingName}' \n";
+      public static string NoUnitColumnValues(string mappingName) => $"No values for the unit were found in the excel column mapped for '{mappingName}' \n";
 
       public static string ParseErrorMessage(string errors) => $"There were errors while parsing your data: {errors}";
 
@@ -1587,7 +1587,7 @@ public static string NameAlreadyExists(string name)
 
       public static string NameAlreadyExistsInContainerType(string name, string containerType)
       {
-         if(string.IsNullOrEmpty(containerType))
+         if (string.IsNullOrEmpty(containerType))
             return NameAlreadyExists(name);
 
          return $"'{name}' already exists in {containerType}.";
@@ -1896,11 +1896,11 @@ public static string TimeArrayValuesDoesNotMatchFirstIndividual(int id, int inde
 
       public static string UnitIsNotDefinedInDimension(string unit, string dimension) => $"Unit '{unit}' is not defined in dimension '{dimension}'.";
 
-      public static string CouldNotFindNeighborhoodBetween(string container1, string container2, string formulaName, string usingFormulaPath) => 
+      public static string CouldNotFindNeighborhoodBetween(string container1, string container2, string formulaName, string usingFormulaPath) =>
          $"Could not find neighborhood between '{container1}' and '{container2}' referenced by formula '{formulaName}' used by '{usingFormulaPath}'";
 
       public static string FirstNeighborNotDefinedFor(string neighborhoodName) => $"First neighbor is undefined for neighborhood '{neighborhoodName}'";
-      
+
       public static string SecondNeighborNotDefinedFor(string neighborhoodName) => $"Second neighbor is undefined for neighborhood '{neighborhoodName}'";
 
       public const string InParentTagCanOnlyBeUsedWithAndOperator = "IN PARENT tag can only be used with AND operator";
@@ -2208,6 +2208,10 @@ public static string LargeNumberOfOutputPoints(int numberOfPoints) =>
       public static string NeighborhoodWasNotFoundInModel(string neighborhoodName, string buildingBlockName) => $"The neighborhood '{neighborhoodName}' from building block '{buildingBlockName}' was not added to the simulation";
 
       public static string ExpressionMoleculeNotFoundInSimulation(string moleculeName) => $"The molecule '{moleculeName}' is not part of the simulation structure";
+
+      public static string RemovedParameterDueToNanAtTimeZero(string pathForRemovedParameter) => $"The parameter '{pathForRemovedParameter}' was removed because it evaluates to NaN at time t=0";
+      public static string QuantityIsNanAtTimeZero(string pathForNanQuantity, string quantityType) => $"The {quantityType} with path '{pathForNanQuantity}' is NaN at time t=0";
+      public static string QuantityIsInfinityAtTimeZero(string pathForInfinityQuantity, string quantityType) => $"The {quantityType} with path '{pathForInfinityQuantity}' is infinite at time t=0";
    }
 
    public static class RibbonCategories

src/OSPSuite.Core/Domain/CreationResult.cs

@@ -3,18 +3,9 @@
 
 namespace OSPSuite.Core.Domain
 {
-   public class CreationResult
+   public class WithValidationResult
    {
-      public virtual IModel Model { get; }
-      public SimulationBuilder SimulationBuilder { get; }
-      public virtual ValidationResult ValidationResult { get; private set; }
-
-      public CreationResult(IModel model, SimulationBuilder simulationBuilder)
-      {
-         Model = model;
-         SimulationBuilder = simulationBuilder;
-         ValidationResult = new ValidationResult();
-      }
+      public virtual ValidationResult ValidationResult { get; private set; } = new ValidationResult();
 
       public virtual ValidationState State => ValidationResult.ValidationState;
 
@@ -24,11 +15,28 @@ public virtual void Add(ValidationResult validationResult)
       {
          ValidationResult = new ValidationResult(validationResult.Messages.Union(ValidationResult.Messages));
       }
+   }
+
+   public class CreationResult : WithValidationResult
+   {
+      public virtual IModel Model { get; }
+      public SimulationBuilder SimulationBuilder { get; }
+
+      public CreationResult(IModel model, SimulationBuilder simulationBuilder)
+      {
+         Model = model;
+         SimulationBuilder = simulationBuilder;
+      }
 
       public void Deconstruct(out IModel model, out ValidationResult validationResult)
       {
          model = Model;
          validationResult = ValidationResult;
       }
    }
+
+   public class RunValidationResult : WithValidationResult
+   {
+
+   }
 }

src/OSPSuite.Core/Domain/Services/ModelConstructor.cs

@@ -36,6 +36,7 @@ internal class ModelConstructor : IModelConstructor
       private readonly ISpatialStructureMerger _spatialStructureMerger;
       private readonly IEventBuilderTask _eventBuilderTask;
       private readonly IEntitySourcePathUpdater _entitySourcePathUpdater;
+      private readonly ISimulationQuantityValueWarningTask _simulationQuantityValueWarningTask;
 
       public ModelConstructor(
          IObjectBaseFactory objectBaseFactory,
@@ -56,8 +57,9 @@ public ModelConstructor(
          IModelCircularReferenceChecker circularReferenceChecker,
          ISpatialStructureMerger spatialStructureMerger,
          IEventBuilderTask eventBuilderTask,
-         IEntitySourcePathUpdater entitySourcePathUpdater
-         )
+         IEntitySourcePathUpdater entitySourcePathUpdater,
+         ISimulationQuantityValueWarningTask simulationQuantityValueWarningTask
+      )
       {
          _objectBaseFactory = objectBaseFactory;
          _simulationConfigurationValidator = simulationConfigurationValidator;
@@ -78,6 +80,7 @@ IEntitySourcePathUpdater entitySourcePathUpdater
          _calculationMethodTask = calculationMethodTask;
          _eventBuilderTask = eventBuilderTask;
          _entitySourcePathUpdater = entitySourcePathUpdater;
+         _simulationQuantityValueWarningTask = simulationQuantityValueWarningTask;
       }
 
       public CreationResult CreateModelFrom(SimulationConfiguration simulationConfiguration, string modelName)
@@ -108,38 +111,43 @@ public CreationResult CreateModelFrom(SimulationConfiguration simulationConfigur
          if (creationResult.State == ValidationState.Invalid)
             return creationResult;
 
-         finalizeModel(model, simulationBuilder);
+         finalizeModel(model, simulationBuilder, creationResult);
 
          return creationResult;
       }
 
-      private void finalizeModel(IModel model, SimulationBuilder simulationBuilder)
+      private void finalizeModel(IModel model, SimulationBuilder simulationBuilder, CreationResult creationResult)
       {
          _formulaTask.CheckFormulaOriginIn(model);
 
          _formulaTask.ExpandDynamicFormulaIn(model);
 
-         //now we should be able to resolve all references
+         // now we should be able to resolve all references
          _referencesResolver.ResolveReferencesIn(model);
 
-         //This should be done after reference were resolved to ensure that we do not remove formula parameter that could not be evaluated
-         removeUndefinedLocalMoleculeParametersIn(model);
+         // This should be done after reference were resolved to ensure that we do not remove formula parameter that could not be evaluated
+         removeUndefinedLocalMoleculeParametersIn(model, creationResult);
 
-         //now that we have removed potential nan parameters, let's make sure that no formula was actually using them
+         // now that we have removed potential nan parameters, let's make sure that no formula was actually using them
          _referencesResolver.ResolveReferencesIn(model);
 
-         //last, we need to update the path of entity in the EntitySource
+         // We need to update the path of entity in the EntitySource
          _entitySourcePathUpdater.UpdateEntityPaths(model, simulationBuilder);
+
+         // Warn for non-finite (NaN and +/- Infinity) parameter values at t=0
+         _simulationQuantityValueWarningTask.WarnForNonFiniteQuantities(model, creationResult);
       }
 
-      private void removeUndefinedLocalMoleculeParametersIn(IModel model)
+      private void removeUndefinedLocalMoleculeParametersIn(IModel model, CreationResult creationResult)
       {
          var allNaNParametersFromMolecules = model.Root.GetAllChildren<IContainer>()
             .Where(c => c.ContainerType == ContainerType.Molecule)
             .SelectMany(c => c.AllParameters(p => double.IsNaN(p.Value)))
             .Where(x => x.BuildMode == ParameterBuildMode.Local)
             .ToList();
 
+         _simulationQuantityValueWarningTask.WarnForOptimizedLocalMoleculeParameters(allNaNParametersFromMolecules, creationResult);
+
          allNaNParametersFromMolecules.Each(x => x.ParentContainer.RemoveChild(x));
       }
 
@@ -148,7 +156,7 @@ private ValidationResult validateModel(ModelConfiguration modelConfiguration)
          if (!modelConfiguration.ShouldValidate)
             return new ValidationResult();
 
-         //Validation needs to happen at the very end of the process
+         // Validation needs to happen at the very end of the process
          var reactionAndTransportValidation = validate<ValidatorForReactionsAndTransports>(modelConfiguration);
          var observersAndEventsValidation = validate<ValidatorForObserversAndEvents>(modelConfiguration);
          var modelValidation = validate<ValidatorForQuantities>(modelConfiguration);
@@ -450,11 +458,11 @@ private static IEnumerable<InitialConditionAndContainer> allPresentMoleculesInCo
          var (model, simulationConfiguration) = modelConfiguration;
          var root = model.Root;
          return from initialCondition in simulationConfiguration.AllPresentMoleculeValues()
-            select new InitialConditionAndContainer
-            {
-               InitialCondition = initialCondition,
-               Container = initialCondition.ContainerPath.Resolve<IContainer>(root)
-            };
+                select new InitialConditionAndContainer
+                {
+                   InitialCondition = initialCondition,
+                   Container = initialCondition.ContainerPath.Resolve<IContainer>(root)
+                };
       }
 
       private class InitialConditionAndContainer

src/OSPSuite.Core/Domain/Services/SimulationQuantityValueWarningTask.cs

@@ -0,0 +1,96 @@
+using System.Collections.Generic;
+using System.Linq;
+using OSPSuite.Assets;
+using OSPSuite.Core.Domain.Builder;
+using OSPSuite.Core.Extensions;
+
+namespace OSPSuite.Core.Domain.Services
+{
+   public interface ISimulationQuantityValueWarningTask
+   {
+      /// <summary>
+      ///    Adds warnings during simulation creation for all <paramref name="optimizedParameters" /> to the
+      ///    <paramref name="creationResult" />
+      /// </summary>
+      void WarnForOptimizedLocalMoleculeParameters(IReadOnlyList<IParameter> optimizedParameters, CreationResult creationResult);
+
+      /// <summary>
+      ///    Adds warnings during simulation creation for all non-finite (NaN or Infinity) parameters in the
+      ///    <paramref name="model" /> to the <paramref name="creationResult" />
+      ///    if the <see cref="ICoreUserSettings" /> indicate enable warnings for non-finite parameters
+      /// </summary>
+      void WarnForNonFiniteQuantities(IModel model, CreationResult creationResult);
+
+      /// <summary>
+      ///    Adds warnings before simulation starts for all non-finite (NaN or Infinity) parameters in the
+      ///    <paramref name="model" /> to the <paramref name="runValidationResult" />
+      ///    if the <see cref="ICoreUserSettings" /> indicate enable warnings for non-finite parameters
+      /// </summary>
+      void WarnForNonFiniteQuantities(IModel model, RunValidationResult runValidationResult);
+   }
+
+   public class SimulationQuantityValueWarningTask : ISimulationQuantityValueWarningTask
+   {
+      private readonly ICoreUserSettings _userSettings;
+      private readonly IObjectTypeResolver _objectTypeResolver;
+
+      public SimulationQuantityValueWarningTask(ICoreUserSettings userSettings, IObjectTypeResolver objectTypeResolver)
+      {
+         _userSettings = userSettings;
+         _objectTypeResolver = objectTypeResolver;
+      }
+
+      public void WarnForOptimizedLocalMoleculeParameters(IReadOnlyList<IParameter> optimizedParameters, CreationResult creationResult)
+      {
+         creationResult.Add(new ValidationResult(optimizedParameters.Select(x =>
+         {
+            var (builder, buildingBlock) = builderAndBuildingBlockFor(x, creationResult.SimulationBuilder);
+            return new ValidationMessage(NotificationType.Warning, Warning.RemovedParameterDueToNanAtTimeZero(x.EntityPath()), builder, buildingBlock);
+         })));
+      }
+
+      public void WarnForNonFiniteQuantities(IModel model, CreationResult creationResult)
+      {
+         var simulationBuilder = creationResult.SimulationBuilder;
+
+         warnForNonFiniteQuantities(model, creationResult, simulationBuilder);
+      }
+
+      private void warnForNonFiniteQuantities(IModel model, WithValidationResult creationResult, SimulationBuilder simulationBuilder = null)
+      {
+         if (!_userSettings.WarnForNonFiniteQuantities)
+            return;
+
+         creationResult.Add(new ValidationResult(allNanQuantities<IQuantity>(model).Select(x => createValidationMessageForNan(x, simulationBuilder))));
+         creationResult.Add(new ValidationResult(allInfiniteQuantities<IQuantity>(model).Select(x => createValidationMessageForInf(x, simulationBuilder))));
+      }
+
+      public void WarnForNonFiniteQuantities(IModel model, RunValidationResult runValidationResult) => warnForNonFiniteQuantities(model, runValidationResult);
+
+      private static IEnumerable<T> allInfiniteQuantities<T>(IModel model) where T : class, IQuantity => model.Root.GetAllChildren<T>().Where(x => double.IsInfinity(x.Value));
+
+      private static IEnumerable<T> allNanQuantities<T>(IModel model) where T : class, IQuantity => model.Root.GetAllChildren<T>().Where(x => double.IsNaN(x.Value));
+
+      private ValidationMessage createValidationMessageForNan<T>(T quantity, SimulationBuilder simulationBuilder) where T : class, IQuantity
+      {
+         var (builder, buildingBlock) = builderAndBuildingBlockFor(quantity, simulationBuilder);
+         return new ValidationMessage(NotificationType.Warning, Warning.QuantityIsNanAtTimeZero(quantity.EntityPath(), _objectTypeResolver.TypeFor(quantity).SplitToUpperCase()), builder, buildingBlock);
+      }
+
+      private ValidationMessage createValidationMessageForInf<T>(T quantity, SimulationBuilder simulationBuilder) where T : class, IQuantity
+      {
+         var (builder, buildingBlock) = builderAndBuildingBlockFor(quantity, simulationBuilder);
+         return new ValidationMessage(NotificationType.Warning, Warning.QuantityIsInfinityAtTimeZero(quantity.EntityPath(), _objectTypeResolver.TypeFor(quantity).SplitToUpperCase()), builder, buildingBlock);
+      }
+
+      private (IEntity builder, IBuildingBlock buildingBlock) builderAndBuildingBlockFor(IQuantity quantity, SimulationBuilder simulationBuilder)
+      {
+         if (simulationBuilder == null)
+            return (quantity, null);
+
+         var builder = simulationBuilder.BuilderFor(quantity);
+         var buildingBlock = builder == null ? null : simulationBuilder.BuilderSourceFor(builder).BuildingBlock;
+         return (builder, buildingBlock);
+      }
+   }
+}

src/OSPSuite.Core/ICoreUserSettings.cs

@@ -16,5 +16,10 @@ public interface ICoreUserSettings
       /// Number of individuals per bin
       /// </summary>
       int NumberOfIndividualsPerBin { get; set; }
+
+      /// <summary>
+      /// Generate warnings when constructing or running a simulation with non-finite parameter values (NaN, +/- Infinity)
+      /// </summary>
+      bool WarnForNonFiniteQuantities { get; set; }
    }
 }