public override List <TmsConstraint> GetTmsConstraints(ConfigurationConstraint constraint, Edge edge)
{
List <TmsConstraint> result = new List <TmsConstraint>();
RelationFamily relFamily = constraint.AllowedRelations[0].RelationFamily;
if (!(edge is MetricEdge))
{
edge.Network.SturcturalReasonerLog.AddItem(LogType.Warning, string.Format("Edge {0} is not a metric edge. The requested TMS constraints will not be added.", edge.GetUId()));
}
else if (!edge.Constraints.Contains(constraint))
{
edge.Network.SturcturalReasonerLog.AddItem(LogType.Warning, string.Format("The constraint {0} is not found in the edge {1}. The requested TMS constraints will not be added.", constraint.DomainConstraint.Name, edge.GetUId()));
}
else if (relFamily != StructuralRelationsManager.GetRelationFamily(RelationFamilyNames.MetricRelationsName))
{
edge.Network.SturcturalReasonerLog.AddItem(LogType.Warning, string.Format("The constraint {0} is qualitative while the needed relation for edge {1} is metric. The requested TMS constraints will not be added.", constraint.DomainConstraint.Name, edge.GetUId()));
}
else
{
string dVarA = edge.EndNode.GetDVarName();
string dVarMetric = (constraint.RelationParts[1] as MetricRelationPart).GetDVarName();
TmsConstraint tmsConstraint = new TmsConstraint();
tmsConstraint.ConstraintType = TmsManager.CTNameGreaterThan;
tmsConstraint.VariableTuple = new List <string>()
{
dVarA, dVarMetric, constraint.GetSatDVarName()
};
result.Add(tmsConstraint);
}
return(result);
}
/// <summary>
/// Finds the index of the set which includes a set of relations from a calculus
/// </summary>
/// <param name="calculus">The calculus</param>
/// <param name="relations">The set of relations included in the set</param>
/// <returns>The index of the set of relations in the powerset<returns>
public static int GetPowersetIndex(this RelationFamily calculus, List <BinaryRelation> relations)
{
int setIx = 0;
foreach (var rel in relations)
{
// The IdInCalculus bit specifies whether the relation is included in the constraint
setIx += (int)Math.Pow(2, rel.IdInCalculus);
}
return(setIx);
}
/// <summary>
/// Creates a domain constraint restricting that the self edge of a node is restricted to use the equals relation of the family
/// </summary>
/// <returns></returns>
public static DomainConstraint SelfEqualsConstraint(RelationFamily calculus)
{
DomainConstraint equalsConstraint = new DomainConstraint("Self equals", calculus.EqualsRelation, false);
equalsConstraint.DomainRelationParts.Add(new ComponentDomainRelationPart(new ComponentFilter()));
equalsConstraint.DomainRelationParts.Add(new ComponentDomainRelationPart(new ComponentFilter()
{
SameAsDomainRelationPartNr = 1
}));
return(equalsConstraint);
}
public static string GetTmsCompositionConstraintName(this RelationFamily calculus)
{
return(string.Format("{0}_{1}", calculus.Name, TmsManager.CTNamePostfixCalculusComposition));
}
public static string GetTmsRelationsDomainName(this RelationFamily calculus)
{
return(string.Format("{0}_{1}", calculus.Name, TmsManager.DomainNameCalculusPostfix));
}
/// <summary>
/// Finds the name of the constraint type which includes information for the powerset of the calculus
/// </summary>
/// <param name="calculus">The current calculus</param>
/// <returns>The TMS name of the constraint type</returns>
public static string GetPwSetCTName(this RelationFamily calculus)
{
return(string.Format("Calculus_{0}-Powerset", calculus.Name));
}
public string PerformEvaluation(RelationFamily relFamily, bool includeSoftConstraints, bool allowZeroIntervals, int combinationConstraintsPercentage, int maxCombinationParts)
{
RandomProblemGenerator problemGenerator = new RandomProblemGenerator();
StructuralReasoner reasoner = new StructuralReasoner();
string scenario;
string result;
long configuringTmsTime;
long solvingTime;
Stopwatch stopwatch = new Stopwatch();
List <List <string> > reportData = new List <List <string> >();
List <string> reportDataRow;
problemGenerator.AllowZeroIntervals = allowZeroIntervals;
problemGenerator.CombinationConstraintsPercentage = combinationConstraintsPercentage;
problemGenerator.ConstraintsToComponentsRatio = ConstraintsToComponentsRatio;
problemGenerator.MaxCombinationParts = maxCombinationParts;
problemGenerator.SoftConstraintsEnabled = includeSoftConstraints;
problemGenerator.RelationFamily = relFamily;
// Setting the scenario text
scenario = string.Format("Scenarion: {0} relation family | Allow zero-length intervals: {1} | Min number of components: {2} | Maximum number of components: {3} | Constraints to components ratio: {4} | Iterations per component level: {5} | Soft constraints enabled: {6} | Maximum branches in combination constraint: {7} | Combination constraint percentage: {8} ", problemGenerator.RelationFamily.Name, problemGenerator.AllowZeroIntervals, ComponentsMinCount, ComponentsMaxCount, problemGenerator.ConstraintsToComponentsRatio, IterationsPerComponentLevel, problemGenerator.SoftConstraintsEnabled, problemGenerator.MaxCombinationParts, problemGenerator.CombinationConstraintsPercentage);
stopwatch.Start();
// The maximum maetric value that will be reached is equal to the maximum number of components that will be generated
reasoner.Options.MaxMetricValue = ComponentsMaxCount;
// The TMS has to be initially configured
reasoner.ConfigureTms();
stopwatch.Stop();
configuringTmsTime = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
// Setting the headers row in the report data
reportDataRow = new List <string>()
{
"Number of components", "(Expected) All constraints count", "(Actual) All constraints count", "(Expected) Combination constraints count", "(Actual) Combination constraints count", "Number of networks", "Error occurred", "Solution found", "Solving time in ms"
};
reportData.Add(reportDataRow);
//try
//{
// For each component level...
for (int i = ComponentsMinCount; i < ComponentsMaxCount + 1; i++)
{
problemGenerator.NumberOfComponents = i;
// Solve the specified number of problems
for (int j = 1; j < IterationsPerComponentLevel + 1; j++)
{
ConfigurationStructure solution;
reportDataRow = new List <string>();
problemGenerator.GenerateProblem();
solution = reasoner.Solve(problemGenerator.GeneratedProblem);
// Log the qualitative case
reportDataRow.Add(problemGenerator.NumberOfComponents.ToString());
reportDataRow.Add(problemGenerator.NumberOfConstraints.ToString());
reportDataRow.Add(problemGenerator.NumberOfActualConstraints.ToString());
reportDataRow.Add(problemGenerator.NumberOfCombinationConstraints.ToString());
reportDataRow.Add(problemGenerator.NumberOfActualCombinationConstraints.ToString());
if (problemGenerator.RelationFamily != StructuralRelationsManager.MetricRelationsFamily)
{
reportDataRow.Add(solution.QualitativeStructure.Count.ToString());
reportDataRow.Add(solution.QualitativeStructure.Any(x => x.SolutionData.ErrorOccurred).ToString());
reportDataRow.Add(solution.QualitativeStructure.All(x => x.SolutionData.SolutionFound).ToString());
reportDataRow.Add(solution.QualitativeStructure.Sum(x => (x.SolutionData.EndTime - x.SolutionData.StartTime).Milliseconds).ToString());
}
else
{
reportDataRow.Add(solution.MetricStructure.SolutionsData.Count.ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.Any(x => x.ErrorOccurred).ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.All(x => x.SolutionFound).ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.Sum(x => (x.EndTime - x.StartTime).Milliseconds).ToString());
}
reportData.Add(reportDataRow);
}
}
result = "No exceptions";
//}
//catch (Exception ex)
//{
// result = "Exception: " + ex.ToString();
//}
stopwatch.Stop();
solvingTime = stopwatch.ElapsedMilliseconds;
return(WriteToFile(scenario, result, configuringTmsTime, solvingTime, reportData));
}
public string PerformTemporalQualitativeToMetricEvaluation(RelationFamily temporalFamily, bool includeSoftConstraints, bool includeTCSP)
{
RandomProblemGenerator problemGenerator = new RandomProblemGenerator();
StructuralReasoner reasoner = new StructuralReasoner();
string scenario;
string result;
long configuringTmsTime;
long solvingTime;
Stopwatch stopwatch = new Stopwatch();
List <List <string> > reportData = new List <List <string> >();
List <string> reportDataRow;
if (temporalFamily != StructuralRelationsManager.IntervalAlgebra && temporalFamily != StructuralRelationsManager.PointAlgebra)
{
throw new ArgumentException("The relation family can be only IA or PA");
}
// TCSP can be solved only for hard constraints
if (includeSoftConstraints)
{
includeTCSP = false;
}
// The IA intervals have non-zero length
problemGenerator.AllowZeroIntervals = false;
// No combination constraints are generated
problemGenerator.CombinationConstraintsPercentage = 0;
// The number of constraints is based on the ratio specified by the property of this instance
problemGenerator.ConstraintsToComponentsRatio = ConstraintsToComponentsRatio;
// Not really relevant
problemGenerator.MaxCombinationParts = 2;
// Soft constraints are enabled/disabled based on the used argument
problemGenerator.SoftConstraintsEnabled = includeSoftConstraints;
// Setting the scenario text
scenario = string.Format("Scenarion: {0} to metric evaluation | Allow zero-length intervals: {1} | Min number of components: {2} | Maximum number of components: {3} | Constraints to components ratio: {4} | Iterations per component level: {5} | Soft constraints enabled: {6} | Solve as TCSP: {7}", problemGenerator.RelationFamily.Name, problemGenerator.AllowZeroIntervals, ComponentsMinCount, ComponentsMaxCount, problemGenerator.ConstraintsToComponentsRatio, IterationsPerComponentLevel, problemGenerator.SoftConstraintsEnabled, includeTCSP);
stopwatch.Start();
// The maximum maetric value that will be reached is equal to the maximum number of components that will be generated
reasoner.Options.MaxMetricValue = ComponentsMaxCount;
// The TMS has to be initially configured
reasoner.ConfigureTms();
stopwatch.Stop();
configuringTmsTime = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
// Setting the headers row in the report data
reportDataRow = new List <string>()
{
"Number of components", "(Qual) All constraints count", "(Qual) Combination constraints count", "(Qual) Number of networks", "(Qual) Error occurred", "(Qual) Solution found", "(Qual) Solving time in ms", "(Metric) All constraints count", "(Metric) Combination constraints count", "(CDA*) Number of networks", "(CDA*) Error occurred", "(CDA*) Solution found", "(CDA*) Solving time in ms"
};
if (includeTCSP)
{
reportDataRow.AddRange(new List <string>()
{
"(TCSP) Number of networks", "(TCSP) Error occurred", "(TCSP) Solution found", "(TCSP) Solving time in ms"
});
}
reportData.Add(reportDataRow);
//try
//{
// For each component level...
for (int i = ComponentsMinCount; i < ComponentsMaxCount + 1; i++)
{
problemGenerator.NumberOfComponents = i;
// Solve the specified number of problems
for (int j = 1; j < IterationsPerComponentLevel + 1; j++)
{
ConfigurationStructure solution;
reportDataRow = new List <string>();
// Generate and solve the IA problem
// No combination constraints should be generated
problemGenerator.CombinationConstraintsPercentage = 0;
// The problem family is set
problemGenerator.RelationFamily = temporalFamily;
problemGenerator.GenerateProblem();
solution = reasoner.Solve(problemGenerator.GeneratedProblem);
// Log the qualitative case
reportDataRow.Add(problemGenerator.NumberOfComponents.ToString());
reportDataRow.Add(problemGenerator.NumberOfActualConstraints.ToString());
reportDataRow.Add(problemGenerator.NumberOfActualCombinationConstraints.ToString());
reportDataRow.Add(solution.QualitativeStructure.Count.ToString());
reportDataRow.Add(solution.QualitativeStructure.Any(x => x.SolutionData.ErrorOccurred).ToString());
reportDataRow.Add(solution.QualitativeStructure.All(x => x.SolutionData.SolutionFound).ToString());
reportDataRow.Add(solution.QualitativeStructure.Sum(x => (x.SolutionData.EndTime - x.SolutionData.StartTime).Milliseconds).ToString());
// Generate and solve the equal metric problem with CDA*
problemGenerator.TransformToMetric();
reasoner.Options.MetricReasoningAlgorithm = MetricReasoningAlgorithm.CdaStar;
solution = reasoner.Solve(problemGenerator.GeneratedProblem);
// Lof the metric case
reportDataRow.Add(problemGenerator.NumberOfActualConstraints.ToString());
reportDataRow.Add(problemGenerator.NumberOfActualCombinationConstraints.ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.Count.ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.Any(x => x.ErrorOccurred).ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.All(x => x.SolutionFound).ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.Sum(x => (x.EndTime - x.StartTime).Milliseconds).ToString());
if (includeTCSP)
{
// Solve the metric problem as TCSP
reasoner.Options.MetricReasoningAlgorithm = MetricReasoningAlgorithm.Tcsp;
solution = reasoner.Solve(problemGenerator.GeneratedProblem);
// Log the TCSP case
reportDataRow.Add(solution.MetricStructure.SolutionsData.Count.ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.Any(x => x.ErrorOccurred).ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.All(x => x.SolutionFound).ToString());
reportDataRow.Add(solution.MetricStructure.SolutionsData.Sum(x => (x.EndTime - x.StartTime).Milliseconds).ToString());
}
reportData.Add(reportDataRow);
}
}
result = "No exceptions";
//}
//catch (Exception ex)
//{
// result = "Exception: " + ex.ToString();
//}
stopwatch.Stop();
solvingTime = stopwatch.ElapsedMilliseconds;
return(WriteToFile(scenario, result, configuringTmsTime, solvingTime, reportData));
}
public QualitativeSolution GetQualitativeSolution(GKOStructuringContext structuredComponent, RelationFamily calculus)
{
return(QualitativeStructure.SingleOrDefault(x => x.StructuredComponent.Id == structuredComponent.Id && x.StructuringCalculus.Name == calculus.Name));
}
/// <summary>
///
/// </summary>
/// <param name="uId">The unique identifier of the network</param>
internal ConstraintNetwork(RelationFamily relFamily, string uId, Log sturcturalReasonerLog)
: this(relFamily, sturcturalReasonerLog)
{
this.UId = uId;
}
/// <summary>
/// Use with caution. The UId should always be assigned in the end
/// </summary>
/// <param name="relFamily">The relation family for which is the network</param>
private ConstraintNetwork(RelationFamily relFamily, Log sturcturalReasonerLog)
{
Nodes = new List <Node>();
Edges = new Dictionary <Tuple <Node, Node>, Edge>();
this.RelationFamily = relFamily;
}
internal static ConstraintNetwork GenerateQualitativeConstraintNetwork(GKOStructuringContext strContext, RelationFamily calculus, Log log)
{
ConstraintNetwork resultNetwork = new ConstraintNetwork(calculus, strContext.Id + "_" + calculus.Name, log);
List <ConfigurationConstraintTree> constraintTrees = strContext.StructuralConstraints.Where(x => x.RelationFamily == calculus).ToList();
// Creating the constraints restricting that self edges should be labeled with the Equals relation from the calculus
DomainConstraint equalsDomainConstraint = DomainConstraint.SelfEqualsConstraint(calculus);
ConfigurationConstraintTree equalsConstraint = new ConfigurationConstraintTree(null, equalsDomainConstraint, strContext.Components.Where(x => x.Active).ToList(), log);
// Adding the constraints restricting that self edges should be labeled with the Equals relation from the calculus
constraintTrees.Add(equalsConstraint);
resultNetwork.Context = strContext;
// Adding all components as nodes in the constraint network
strContext.Components.Where(x => x.Active).ToList().ForEach(x => resultNetwork.Nodes.Add(new Node(x)));
// Creating all edges in the constraint network, so it is a complete graph
foreach (var startNode in resultNetwork.Nodes)
{
foreach (var endNode in resultNetwork.Nodes)
{
QualitativeEdge edge = new QualitativeEdge(resultNetwork, startNode, endNode);
resultNetwork.Edges.Add(new Tuple <Node, Node>(startNode, endNode), edge);
}
}
// Each constraint tree has a number of configuration constraints
foreach (var constraintTree in constraintTrees)
{
List <ConfigurationConstraint> constraints = constraintTree.GetAllConfigurationConstraints();
// ToDo: Add check for equal constraints to avoid redundancy
// Adding all constraints as edges in the networks
constraints.ForEach(x =>
{
// Hack: this uses the fact that each constraint has at least one allowed relation and all have the same signature and logic (i.e. start and end node)
Node startNode = x.AllowedRelations[0].GetStartNode(x);
Node endNode = x.AllowedRelations[0].GetEndNode(x);
Tuple <Node, Node> edgeKey = new Tuple <Node, Node>(startNode, endNode);
QualitativeEdge edge = resultNetwork.Edges[edgeKey] as QualitativeEdge;
// Adding the constraint to the edge
edge.Constraints.Add(x);
});
}
return(resultNetwork);
}
/// <summary>
/// Solves the current problem given the configuration and the domain constraints
/// </summary>
/// <param name="configuration">The configuration to be structured</param>
/// <param name="constraintsSource">The source for the domain constraints</param>
/// <returns>The best found configuration structure given the constraints</returns>
public ConfigurationStructure Solve(GKOConfiguration configuration, DomainConstraintsSource constraintsSource)
{
ConfigurationStructure structure = new ConfigurationStructure();
List <GKOStructuringContext> metricStructuredComponents;
List <GKOStructuringContext> qualitativeStructuredComponents;
List <ConstraintNetwork> problemNetworks = new List <ConstraintNetwork>();
RelationFamily metricRelations = StructuralRelationsManager.MetricRelationsFamily;
Stopwatch totalTime = new Stopwatch();
Stopwatch stopwatch = new Stopwatch();
if (!this.Options.TmsConfigured)
{
throw new NotSupportedException("The TMS has to be configured before a structuring operation!");
}
if (configuration == null)
{
throw new InvalidOperationException("The configuration must be set before the solving process can start!");
}
if (constraintsSource == null)
{
throw new InvalidOperationException("The domain constraints source must be set before the solving process can start!");
}
constraintsSource.LoadDomainConstraints();
totalTime.Start();
stopwatch.Start();
GenerateConfigurationConstraints(configuration, constraintsSource);
stopwatch.Stop();
ProcessLog.AddItem(LogType.Info, String.Format("Generating configuration constraints finished ({0} ms)", stopwatch.ElapsedMilliseconds));
// Finding all structured conmponents which include metric reasoning...
metricStructuredComponents = configuration.StructuringContexts.Where(x => x.Active && x.IncludedRelationFamilies.Contains(metricRelations)).ToList();
// ... and qualitative reasoning
qualitativeStructuredComponents = configuration.StructuringContexts.Where(x => x.Active && x.IncludedRelationFamilies.Any(y => y != metricRelations)).ToList();
// Generating the metric constraint networks
if (metricStructuredComponents.Count != 0)
{
List <ConstraintNetwork> metricNetworks = new List <ConstraintNetwork>();
ProcessLog.AddItem(LogType.Info, String.Format("Generating metric constraint networks out of composite components starting"));
stopwatch.Restart();
metricNetworks = ConstraintNetwork.GenerateMetricConstraintNetworks(metricStructuredComponents, this.tms, this.Options, this.ProcessLog);
problemNetworks.AddRange(metricNetworks);
stopwatch.Stop();
ProcessLog.AddItem(LogType.Info, String.Format("{0} metric constraint networks generated out of {1} composite components ({2} ms)", metricNetworks.Count, metricStructuredComponents.Count, stopwatch.ElapsedMilliseconds));
}
// Generating the qualitative constraint networks
if (qualitativeStructuredComponents.Count != 0)
{
ProcessLog.AddItem(LogType.Info, String.Format("Generating qualitative constraint networks for the composite components starting"));
stopwatch.Restart();
foreach (var strComponent in qualitativeStructuredComponents)
{
// Generating a new constraint network foreach qualitative calculus in a StructuredComponent
foreach (var calculus in strComponent.IncludedRelationFamilies.Where(x => x != metricRelations))
{
problemNetworks.Add(ConstraintNetwork.GenerateQualitativeConstraintNetwork(strComponent, calculus, this.ProcessLog));
}
}
stopwatch.Stop();
ProcessLog.AddItem(LogType.Info, String.Format("Generating qualitative constraint networks for the composite components finished ({0} ms)", stopwatch.ElapsedMilliseconds));
}
foreach (var network in problemNetworks)
{
ProcessLog.AddItem(LogType.Info, String.Format("Starting structuring of constraint network {0}", network.UId));
stopwatch.Restart();
structure.AddSolutionInformation(network.Solve(this.Options, tms));
stopwatch.Stop();
ProcessLog.AddItem(LogType.Info, String.Format("Structuring of constraint network {0} finished ({1} ms)", network.UId, stopwatch.ElapsedMilliseconds));
}
totalTime.Stop();
ProcessLog.AddItem(LogType.Info, String.Format("Structuring configuration finished - {0} constraint networks processed ({1} ms)", problemNetworks.Count, totalTime.ElapsedMilliseconds));
return(structure);
}
