/// <summary> /// Creates forbidden parameter combinations. /// </summary> /// <param name="forbiddenParameterClauses"> /// Matches from <see cref="ForbiddenParameterClausePattern"/>. /// </param> /// <param name="parameterDefinitions">All parameter definitions.</param> /// <returns>The created <see cref="ForbiddenParameterCombination"/>s.</returns> private static IEnumerable <ForbiddenParameterCombination> CreateForbiddenParameterCombinations( IEnumerable <Match> forbiddenParameterClauses, List <IParameterNode> parameterDefinitions) { return(forbiddenParameterClauses .Select(clause => ParameterConfigurationSpaceConverter.CreateForbiddenParameterClause(clause, parameterDefinitions))); }
/// <summary> /// Creates a mapping from parameter identifiers to conditions determining whether they are active. /// </summary> /// <param name="conditionalParameterClauses"> /// Matches from <see cref="ConditionalParameterClausePattern"/>. /// </param> /// <param name="parameterDefinitions">All parameter definitions.</param> /// <returns>The created mapping.</returns> private static Dictionary <string, List <EqualsCondition> > CreateParameterActivityConditions( IEnumerable <Match> conditionalParameterClauses, List <IParameterNode> parameterDefinitions) { var parameterActivityConditions = new Dictionary <string, List <EqualsCondition> >(); foreach (var clause in conditionalParameterClauses) { var childIdentifier = clause.Groups[ParameterConfigurationSpaceConverter.ChildGroupName].Value; if (!parameterDefinitions.Any(definition => Equals(definition.Identifier, childIdentifier))) { throw new InvalidOperationException( $"Tried to create a condition for '{childIdentifier}', which was not defined."); } if (!parameterActivityConditions.TryGetValue(childIdentifier, out var conditions)) { conditions = new List <EqualsCondition>(); parameterActivityConditions.Add(childIdentifier, conditions); } conditions.Add(ParameterConfigurationSpaceConverter.CreateCondition(clause, parameterDefinitions)); } return(parameterActivityConditions); }
/// <summary> /// Converts a PCS file into a <see cref="ParameterConfigurationSpaceSpecification"/>. /// </summary> /// <param name="path">Path to the file.</param> /// <returns>The created <see cref="ParameterConfigurationSpaceSpecification"/>.</returns> public static ParameterConfigurationSpaceSpecification Convert(string path) { if (!File.Exists(path)) { throw new FileNotFoundException($"No file at {path}."); } var parameters = new List <IParameterNode>(); var conditionalParameterClauses = new List <Match>(); var forbiddenParameterClauses = new List <Match>(); foreach (var line in File.ReadAllLines(path)) { if (line.StartsWith("#") || string.IsNullOrEmpty(line)) { // Comment or blank line. continue; } var match = ParameterConfigurationSpaceConverter.ConditionalParameterClausePattern.Match(line); if (match.Success) { // Delay parsing of conditional clauses until all parameters are known. conditionalParameterClauses.Add(match); continue; } match = ParameterConfigurationSpaceConverter.ForbiddenParameterClausePattern.Match(line); if (match.Success) { // Delay parsing of forbidden parameter clauses until all parameters are known. forbiddenParameterClauses.Add(match); continue; } match = ParameterConfigurationSpaceConverter.CategoricalParameterClausePattern.Match(line); if (match.Success) { parameters.Add(ParameterConfigurationSpaceConverter.CreateCategoricalParameter(match)); continue; } match = ParameterConfigurationSpaceConverter.NumericalParameterClausePattern.Match(line); if (match.Success) { parameters.Add(ParameterConfigurationSpaceConverter.CreateNumericalParameter(match)); continue; } throw new FormatException($"Cannot parse '{line}'. Is the format correct?"); } return(new ParameterConfigurationSpaceSpecification( parameters, ParameterConfigurationSpaceConverter.CreateParameterActivityConditions(conditionalParameterClauses, parameters), ParameterConfigurationSpaceConverter.CreateForbiddenParameterCombinations(forbiddenParameterClauses, parameters))); }
/// <summary> /// Creates a <see cref="EqualsCondition"/>. /// </summary> /// <param name="conditionalParameterClause"> /// A match from <see cref="ConditionalParameterClausePattern"/>. /// </param> /// <param name="parameterDefinitions">All parameter definitions.</param> /// <returns>The created <see cref="EqualsCondition"/>.</returns> private static EqualsCondition CreateCondition( Match conditionalParameterClause, List <IParameterNode> parameterDefinitions) { var parentIdentifier = conditionalParameterClause.Groups[ParameterConfigurationSpaceConverter.ParentGroupName].Value; var domain = ParameterConfigurationSpaceConverter.FindParameterDomain(parameterDefinitions, parentIdentifier); var valueSpecifications = conditionalParameterClause.Groups[ParameterConfigurationSpaceConverter.ValueGroupName].Value .Split(',') .Select(value => value.Trim()); return(new EqualsCondition( parentIdentifier, valueSpecifications.Select(value => ParameterConfigurationSpaceConverter.TransformValueToAllele(domain, value)))); }
/// <summary> /// Creates a numerical parameter. /// </summary> /// <param name="numericalParameterClause">A match from <see cref="NumericalParameterClausePattern"/>.</param> /// <returns>The created <see cref="IParameterNode"/>.</returns> private static IParameterNode CreateNumericalParameter(Match numericalParameterClause) { var identifier = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.ParameterGroupName].Value; var minValue = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.MinValueGroupName].Value; var maxValue = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.MaxValueGroupName].Value; var isLogarithmic = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.LogScaleGroupName].Success || numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.AlternativeLogScaleGroupName].Success; if (numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.IntegerGroupName].Success) { return(ParameterConfigurationSpaceConverter.CreateIntegerParameter(identifier, minValue, maxValue, isLogarithmic)); } else { return(ParameterConfigurationSpaceConverter.CreateContinuousParameter(identifier, minValue, maxValue, isLogarithmic)); } }
/// <summary> /// Creates a <see cref="ForbiddenParameterCombination"/>. /// </summary> /// <param name="forbiddenParameterClause"> /// A match from <see cref="ForbiddenParameterClausePattern"/>. /// </param> /// <param name="parameterDefinitions">All parameter definitions.</param> /// <returns>The created <see cref="ForbiddenParameterCombination"/>.</returns> private static ForbiddenParameterCombination CreateForbiddenParameterClause( Match forbiddenParameterClause, List <IParameterNode> parameterDefinitions) { var completeSpecification = forbiddenParameterClause.Groups[ParameterConfigurationSpaceConverter.CombinationGroupName].Value; var assignmentMatches = ParameterConfigurationSpaceConverter.AssignmentPattern.Matches(completeSpecification); var forbiddenCombination = new Dictionary <string, IAllele>(); foreach (Match match in assignmentMatches) { var identifier = match.Groups[ParameterConfigurationSpaceConverter.ParameterGroupName].Value; var value = match.Groups[ParameterConfigurationSpaceConverter.ValueGroupName].Value; var domain = ParameterConfigurationSpaceConverter.FindParameterDomain(parameterDefinitions, identifier); forbiddenCombination[identifier] = ParameterConfigurationSpaceConverter.TransformValueToAllele(domain, value); } return(new ForbiddenParameterCombination(forbiddenCombination)); }