2586 parameters not common for all species

src/Db/Diff/PKSimDB_diff.txt

@@ -1 +1 @@
-UPDATE tab_container_parameter_values SET default_value=124000.0 WHERE parameter_value_version='InVitroClearance_PKSim' AND species='Cattle' AND container_id=159 AND container_type='ORGAN' AND container_name='Liver' AND parameter_name='Number of cells/g tissue';
+

src/Db/Dump/PKSimDB_dump.txt

@@ -91937,4 +91937,62 @@ CREATE VIEW VIEW_KNOWN_TRANSPORTER_CONTAINERS AS SELECT
         t.CONTAINER_NAME AS ContainerName,
         t.MEMBRANE AS MembraneLocation
 FROM tab_known_transporters_containers t;
+CREATE VIEW [ContainerParameters_Species]
+AS
+SELECT DISTINCT 
+                [cpc].[container_id], 
+                [cpc].[container_type], 
+                [cpc].[container_name], 
+                [cpc].[parameter_name], 
+                [species]
+FROM   [tab_container_parameter_curves] AS [cpc],
+       [tab_container_parameters] AS [cp]
+WHERE  [cpc].[container_id] = [cp].[container_id]
+         AND [cpc].[parameter_name] = [cp].[parameter_name]
+         AND [building_block_type] = "INDIVIDUAL"
+UNION
+SELECT DISTINCT 
+                [cpv].[container_id], 
+                [cpv].[container_type], 
+                [cpv].[container_name], 
+                [cpv].[parameter_name], 
+                [species]
+FROM   [tab_container_parameter_values] AS [cpv],
+       [tab_container_parameters] AS [cp]
+WHERE  [cpv].[container_id] = [cp].[container_id]
+         AND [cpv].[parameter_name] = [cp].[parameter_name]
+         AND [building_block_type] = "INDIVIDUAL"
+UNION
+SELECT DISTINCT 
+                [cpr].[container_id], 
+                [cpr].[container_type], 
+                [cpr].[container_name], 
+                [cpr].[parameter_name], 
+                [species]
+FROM   [tab_container_parameter_rates] AS [cpr],
+       [tab_species_calculation_methods] AS [scm],
+       [tab_container_parameters] AS [cp]
+WHERE  [cpr].[calculation_method] = [scm].[calculation_method]
+         AND [cpr].[container_id] = [cp].[container_id]
+         AND [cpr].[parameter_name] = [cp].[parameter_name]
+         AND [building_block_type] = "INDIVIDUAL";
+CREATE VIEW [VIEW_CONTAINER_PARAMETER_NOT_FOR_ALL_SPECIES]
+AS
+SELECT DISTINCT 
+                [ContainerParameters_Species].[container_id] AS [ContainerId], 
+                [ContainerParameters_Species].[container_type] AS [ContainerType], 
+                [ContainerParameters_Species].[container_name] AS [ContainerName], 
+                [ContainerParameters_Species].[parameter_name] AS [ParameterName], 
+                COUNT ([ContainerParameters_Species].[species]) AS [SpeciesCount]
+FROM   [ContainerParameters_Species]
+GROUP  BY
+          [container_id], 
+          [container_type], 
+          [container_name], 
+          [parameter_name]
+HAVING COUNT ([species]) < (SELECT COUNT ([species])
+       FROM   [tab_species])
+ORDER  BY
+          [container_id],
+          [parameter_name];
 COMMIT;

src/PKSim.Core/CoreConstants.cs

@@ -776,6 +776,7 @@ public static class ORM
          public const string VIEW_DISEASE_STATES = "VIEW_DISEASE_STATES";
          public const string VIEW_POPULATION_DISEASE_STATES = "VIEW_POPULATION_DISEASE_STATES";
          public const string VIEW_CONTAINER_PARAMETER_DESCRIPTOR_CONDITIONS = "VIEW_CONTAINER_PARAMETER_DESCRIPTOR_CONDITIONS";
+         public const string VIEW_CONTAINER_PARAMETER_NOT_FOR_ALL_SPECIES = "VIEW_CONTAINER_PARAMETER_NOT_FOR_ALL_SPECIES";
       }
 
       public static class Organ

src/PKSim.Core/Model/ContainerParameterBySpecies.cs

@@ -0,0 +1,9 @@
+namespace PKSim.Core.Model
+{
+   public class ContainerParameterBySpecies
+   {
+      public string ContainerPath { get; set; }
+      public string ParameterName { get; set; }
+      public int SpeciesCount { get; set; }
+   }
+}

src/PKSim.Core/Repositories/IContainerParametersNotCommonForAllSpeciesRepository.cs

@@ -0,0 +1,13 @@
+using System;
+using OSPSuite.Utility.Collections;
+using PKSim.Core.Model;
+
+namespace PKSim.Core.Repositories
+{
+   public interface IContainerParametersNotCommonForAllSpeciesRepository : IStartableRepository<ContainerParameterBySpecies>
+   {
+      bool UsedForAllSpecies(string containerPath, string parameterName);
+
+      bool UsedForAllSpecies(string parameterFullPath);
+   }
+}

src/PKSim.Infrastructure/ORM/FlatObjects/FlatContainerParametersNotCommonForAllSpecies.cs

@@ -0,0 +1,11 @@
+namespace PKSim.Infrastructure.ORM.FlatObjects
+{
+   public class FlatContainerParametersNotCommonForAllSpecies
+   {
+      public int ContainerId { get; set; }
+      public string ContainerType { get; set; }
+      public string ContainerName { get; set; }
+      public string ParameterName { get; set; }
+      public int SpeciesCount { get; set; }
+   }
+}

src/PKSim.Infrastructure/ORM/Repositories/ContainerParametersNotCommonForAllSpeciesRepository.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Linq;
+using OSPSuite.Core.Domain;
+using OSPSuite.Utility.Collections;
+using PKSim.Core.Model;
+using PKSim.Core.Repositories;
+
+namespace PKSim.Infrastructure.ORM.Repositories
+{
+   public class ContainerParametersNotCommonForAllSpeciesRepository: StartableRepository<ContainerParameterBySpecies>, IContainerParametersNotCommonForAllSpeciesRepository
+   {
+      private readonly IFlatContainerRepository _flatContainerRepository;
+      private readonly IFlatContainerParametersNotCommonForAllSpeciesRepository _flatContainerParametersNotCommonForAllSpeciesRepository;
+
+      private readonly List<ContainerParameterBySpecies> _containerParametersNotCommonForAllSpecies;
+      private readonly ICache<string, List<string>> _parametersNotCommonForAllSpeciesByContainer;
+      private readonly ICache<string, string> _parametersNotCommonForAllSpeciesByFullPath;
+
+      public ContainerParametersNotCommonForAllSpeciesRepository(
+         IFlatContainerRepository flatContainerRepository,
+         IFlatContainerParametersNotCommonForAllSpeciesRepository flatContainerParametersNotCommonForAllSpeciesRepository)
+      {
+         _flatContainerRepository = flatContainerRepository;
+         _flatContainerParametersNotCommonForAllSpeciesRepository = flatContainerParametersNotCommonForAllSpeciesRepository;
+
+         _containerParametersNotCommonForAllSpecies = new List<ContainerParameterBySpecies>();
+         _parametersNotCommonForAllSpeciesByContainer = new Cache<string, List<string>>();
+         _parametersNotCommonForAllSpeciesByFullPath = new Cache<string, string>();
+      }
+
+      protected override void DoStart()
+      {
+         var flatContainerParametersNotCommonForAllSpecies = _flatContainerParametersNotCommonForAllSpeciesRepository.All().ToList();
+
+         foreach(var containerParameter in flatContainerParametersNotCommonForAllSpecies)
+         {
+            var containerPath = _flatContainerRepository.ContainerPathFrom(containerParameter.ContainerId).ToString();
+            var containerParameterBySpecies = new ContainerParameterBySpecies()
+            {
+               ContainerPath = containerPath,
+               ParameterName = containerParameter.ParameterName,
+               SpeciesCount = containerParameter.SpeciesCount
+            };
+            _containerParametersNotCommonForAllSpecies.Add(containerParameterBySpecies);
+
+            //cache by full path
+            var fullPath = $"{containerPath}{ObjectPath.PATH_DELIMITER}{containerParameter.ParameterName}";
+            _parametersNotCommonForAllSpeciesByFullPath.Add(fullPath, fullPath);
+         }
+
+         //cache the parameters by container path
+         foreach (var containerParametersInContainer in _containerParametersNotCommonForAllSpecies.GroupBy(x => x.ContainerPath))
+         {
+            _parametersNotCommonForAllSpeciesByContainer.Add(containerParametersInContainer.Key,  containerParametersInContainer.Select(cp=>cp.ParameterName).ToList());
+         }
+      }
+
+      public override IEnumerable<ContainerParameterBySpecies> All()
+      {
+         Start();
+         return _containerParametersNotCommonForAllSpecies;
+      }
+
+      public bool UsedForAllSpecies(string containerPath, string parameterName)
+      {
+         Start();
+         var parametersUsedNotForAllSpeciesInContainer = _parametersNotCommonForAllSpeciesByContainer[containerPath];
+
+         return parametersUsedNotForAllSpeciesInContainer == null || !parametersUsedNotForAllSpeciesInContainer.Contains(parameterName);
+      }
+
+      public bool UsedForAllSpecies(string parameterFullPath)
+      {
+         Start();
+         return !_parametersNotCommonForAllSpeciesByFullPath.Contains(parameterFullPath);
+      }
+   }
+}

src/PKSim.Infrastructure/ORM/Repositories/FlatContainerParametersNotCommonForAllSpeciesRepository.cs

@@ -0,0 +1,19 @@
+using PKSim.Core;
+using PKSim.Infrastructure.ORM.Core;
+using PKSim.Infrastructure.ORM.FlatObjects;
+using PKSim.Infrastructure.ORM.Mappers;
+
+namespace PKSim.Infrastructure.ORM.Repositories
+{
+   public interface IFlatContainerParametersNotCommonForAllSpeciesRepository : IMetaDataRepository<FlatContainerParametersNotCommonForAllSpecies>
+   {
+   }
+
+   public class FlatContainerParametersNotCommonForAllSpeciesRepository : MetaDataRepository<FlatContainerParametersNotCommonForAllSpecies>, IFlatContainerParametersNotCommonForAllSpeciesRepository
+   {
+      public FlatContainerParametersNotCommonForAllSpeciesRepository(IDbGateway dbGateway, IDataTableToMetaDataMapper<FlatContainerParametersNotCommonForAllSpecies> mapper)
+         : base(dbGateway, mapper, CoreConstants.ORM.VIEW_CONTAINER_PARAMETER_NOT_FOR_ALL_SPECIES)
+      {
+      }
+   }
+}

src/PKSim.Infrastructure/Serialization/Xml/Serializers/ContainerParameterBySpeciesSerializer.cs

@@ -0,0 +1,14 @@
+using PKSim.Core.Model;
+
+namespace PKSim.Infrastructure.Serialization.Xml.Serializers
+{
+   public class ContainerParameterBySpeciesSerializer : BaseXmlSerializer<ContainerParameterBySpecies>
+   {
+      public override void PerformMapping()
+      {
+         Map(x => x.ContainerPath);
+         Map(x => x.ParameterName);
+         Map(x => x.SpeciesCount);
+      }
+   }
+}

tests/PKSim.Tests/IntegrationTests/ContainerParametersNotCommonForAllSpeciesRepositorySpecs.cs

@@ -0,0 +1,68 @@
+using System.Collections.Generic;
+using System.Linq;
+using FluentNHibernate.Utils;
+using OSPSuite.BDDHelper;
+using OSPSuite.BDDHelper.Extensions;
+using PKSim.Core.Model;
+using PKSim.Core.Repositories;
+
+namespace PKSim.IntegrationTests
+{
+   public abstract class concern_for_ContainerParametersNotCommonForAllSpeciesRepository : ContextForIntegration<IContainerParametersNotCommonForAllSpeciesRepository>
+   {
+   }
+
+   public class When_retrieving_parameters_not_common_for_all_species_from_the_repository : concern_for_ContainerParametersNotCommonForAllSpeciesRepository
+   {
+      private IEnumerable<ContainerParameterBySpecies> _result;
+
+      protected override void Because()
+      {
+         _result = sut.All();
+      }
+
+      [Observation]
+      public void should_return_at_least_one_parameter()
+      {
+         _result.Count().ShouldBeGreaterThan(0);
+      }
+
+      [Observation]
+      public void all_parameter_paths_should_start_with_organism_or_neighborhoods()
+      {
+         //because we deal here with individual parameters only: only parameters with path "Organism|..." or "Neighborhoods|..." may appear in the list
+         _result.Each(p=>
+         {
+            var containerPath = p.ContainerPath;
+            (containerPath.StartsWith("Organism")|| containerPath.StartsWith("Neighborhoods")).ShouldBeTrue($"{p.ContainerPath}|{p.ParameterName}");
+         });
+      }
+   }
+
+   public class When_testing_if_a_parameter_is_common_for_all_species : concern_for_ContainerParametersNotCommonForAllSpeciesRepository
+   {
+      [Observation]
+      public void age_parameter_should_be_defined_not_for_all_species()
+      {
+         sut.UsedForAllSpecies("Organism","Age").ShouldBeFalse();
+      }
+
+      [Observation]
+      public void weight_parameter_should_be_defined_for_all_species()
+      {
+         sut.UsedForAllSpecies("Organism", "Weight").ShouldBeTrue();
+      }
+
+      [Observation]
+      public void age_parameter_should_be_defined_not_for_all_species_when_queried_by_full_path()
+      {
+         sut.UsedForAllSpecies("Organism|Age").ShouldBeFalse();
+      }
+
+      [Observation]
+      public void weight_parameter_should_be_defined_for_all_species_when_queried_by_full_path()
+      {
+         sut.UsedForAllSpecies("Organism|Weight").ShouldBeTrue();
+      }
+   }
+}

tests/PKSim.Tests/IntegrationTests/FlatContainerParametersNotCommonForAllSpeciesRepositorySpecs.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Linq;
+using OSPSuite.BDDHelper;
+using OSPSuite.BDDHelper.Extensions;
+using PKSim.Infrastructure.ORM.FlatObjects;
+using PKSim.Infrastructure.ORM.Repositories;
+
+namespace PKSim.IntegrationTests
+{
+   public abstract class concern_for_FlatContainerParametersNotCommonForAllSpeciesRepository : ContextForIntegration<IFlatContainerParametersNotCommonForAllSpeciesRepository>
+   {
+   }
+
+   public class When_resolving_all_parameters_not_common_for_all_species_as_a_flat_table : concern_for_FlatContainerParametersNotCommonForAllSpeciesRepository
+   {
+      private IEnumerable<FlatContainerParametersNotCommonForAllSpecies> _result;
+
+      protected override void Because()
+      {
+         _result = sut.All();
+      }
+
+      [Observation]
+      public void should_retrieve_some_object_from_the_underlying_database()
+      {
+         _result.Count().ShouldBeGreaterThan(0);
+      }
+   }
+}