/// <summary>
/// Constructs an empty conditions object.
/// </summary>
/// <param name="evaluationManager">Evaluation manager.</param>
/// <param name="parameters">Parameters of the lifted arguments (null if fully grounded).</param>
public Conditions(EvaluationManager evaluationManager, Parameters parameters = null)
{
EvaluationManager = evaluationManager;
ConditionsCNFBuilder = new Lazy <ConditionsCNFBuilder>(() => new ConditionsCNFBuilder(evaluationManager));
ConditionsParametersCollector = new Lazy <ConditionsParametersCollector>(() => new ConditionsParametersCollector());
Parameters = parameters;
}
/// <summary>
/// Constructs the effects backwards applier.
/// </summary>
/// <param name="operatorPreconditions">Corresponding operator preconditions.</param>
/// <param name="operatorEffects">Corresponding operator effects.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public EffectsBackwardsRelativeStateApplier(Conditions operatorPreconditions, List <IEffect> operatorEffects, EvaluationManager evaluationManager)
{
OperatorPreconditions = (operatorPreconditions != null && operatorPreconditions.Count > 0) ? operatorPreconditions : null;
EvaluationManager = evaluationManager;
GroundingManager = evaluationManager.GroundingManager;
Effects.CollectEffects(operatorEffects);
}
/// <summary>
/// Constructs an empty conditions object.
/// </summary>
/// <param name="evaluationManager">Evaluation manager.</param>
/// <param name="conditionsCNFBuilder">CNF builder.</param>
/// <param name="conditionsParametersCollector">Conditions parameters collector.</param>
/// <param name="parameters">Parameters of the lifted arguments (null if fully grounded).</param>
protected Conditions(EvaluationManager evaluationManager, Lazy <ConditionsCNFBuilder> conditionsCNFBuilder, Lazy <ConditionsParametersCollector> conditionsParametersCollector, Parameters parameters = null)
{
EvaluationManager = evaluationManager;
ConditionsCNFBuilder = conditionsCNFBuilder;
ConditionsParametersCollector = conditionsParametersCollector;
Parameters = parameters;
}
/// <summary>
/// Constructs the effects backwards applier.
/// </summary>
/// <param name="operatorPreconditions">Corresponding operator preconditions.</param>
/// <param name="operatorEffects">Corresponding operator effects.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
/// <param name="liftedApplication">Is the backward application lifted?</param>
public EffectsBackwardsConditionsApplier(Conditions operatorPreconditions, List <IEffect> operatorEffects, EvaluationManager evaluationManager, bool liftedApplication = false)
{
OperatorPreconditions = (operatorPreconditions != null && operatorPreconditions.Count > 0) ? operatorPreconditions : null;
GroundingManager = evaluationManager.GroundingManager;
EvaluationManager = evaluationManager;
IsApplicationLifted = liftedApplication;
Effects.CollectEffects(operatorEffects);
}
/// <summary>
/// Visits and handles the effect.
/// </summary>
/// <param name="effect">Effect.</param>
public void Visit(WhenEffect effect)
{
if (EvaluationManager.Evaluate(effect.Expression, Substitution, State))
{
foreach (var localEffect in effect.Effects)
{
localEffect.Accept(this);
}
}
}
/// <summary>
/// Constructs the object from the input data.
/// </summary>
/// <param name="action">PDDL action definition.</param>
/// <param name="idManager">ID manager.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public LiftedOperator(InputData.PDDL.Action action, IdManager idManager, EvaluationManager evaluationManager)
{
idManager.Variables.RegisterLocalParameters(action.Parameters);
Name = action.Name;
Parameters = new Parameters(action.Parameters, idManager);
Preconditions = new Conditions(action.Preconditions, Parameters, idManager, evaluationManager);
Effects = new Effects(action.Effects, Preconditions, idManager, evaluationManager);
IdManager = idManager;
ExtractCostFromEffects();
idManager.Variables.UnregisterLocalParameters(action.Parameters);
}
/// <summary>
/// Constructs the PDDL planning problem from the input data.
/// </summary>
/// <param name="inputData">Input data.</param>
public Problem(InputData.PDDLInputData inputData)
{
DomainName = inputData.Domain.Name;
ProblemName = inputData.Problem.Name;
OriginalInputData = inputData;
IdManager = new IdManager(inputData);
EvaluationManager = new EvaluationManager(new GroundingManager(inputData, IdManager));
Operators = new LiftedOperators(inputData.Domain.Actions, IdManager, EvaluationManager);
InitialState = new State(inputData.Problem.Init, IdManager);
GoalConditions = new Conditions(inputData.Problem.Goal, null, IdManager, EvaluationManager);
RigidRelations = new RigidRelations(InitialState, Operators);
TransitionsGenerator = new Lazy <TransitionsGenerator>(() => new TransitionsGenerator(this));
EvaluationManager.SetRigidRelations(RigidRelations);
}
/// <summary>
/// Removes rigid relations from the specified conditions.
/// </summary>
/// <param name="conditions">Conditions.</param>
/// <returns>Conditions without rigid relations.</returns>
private Conditions ClearRigidRelations(Conditions conditions)
{
Conditions newConditions = conditions.CloneEmpty();
foreach (var expression in conditions)
{
PredicateExpression predicate = expression as PredicateExpression;
if (predicate != null)
{
if (EvaluationManager.IsPredicateRigidRelation(predicate.PredicateAtom))
{
continue;
}
}
newConditions.Add(expression);
}
return(newConditions);
}
/// <summary>
/// Gets a list of atoms from the specified state that are necessary to make these conditions true.
/// </summary>
/// <param name="substitution">Variable substitution.</param>
/// <param name="predecessorState">Preceding state.</param>
/// <returns>List of satisfying atoms.</returns>
public List <IAtom> GetSatisfyingAtoms(ISubstitution substitution, IState predecessorState)
{
return(EvaluationManager.GetSatisfyingAtoms(this, substitution, predecessorState));
}
/// <summary>
/// Computes the operator label in the relaxed planning graph.
/// </summary>
/// <param name="substitution">Variable substitution.</param>
/// <param name="stateLabels">Atom labels from the predecessor layer in the graph.</param>
/// <param name="evaluationStrategy">Evaluation strategy of the planning graph.</param>
/// <returns>Computed operator label in the relaxed planning graph.</returns>
public double EvaluateOperatorPlanningGraphLabel(ISubstitution substitution, IStateLabels stateLabels, ForwardCostEvaluationStrategy evaluationStrategy)
{
return(EvaluationManager.EvaluateOperatorPlanningGraphLabel(this, substitution, (StateLabels)stateLabels, evaluationStrategy));
}
/// <summary>
/// Creates the expression CNF builder.
/// </summary>
/// <param name="evaluationManager">Evaluation manager.</param>
public ConditionsCNFBuilder(EvaluationManager evaluationManager)
{
ExpressionToCNFTransformer = new ExpressionToCNFTransformer(evaluationManager);
EvaluationManager = evaluationManager;
}
/// <summary>
/// Constructs an empty CNF expression.
/// </summary>
/// <param name="evaluationManager">Evaluation manager.</param>
/// <param name="parameters">Condition parameters.</param>
public ConditionsCNF(EvaluationManager evaluationManager, Parameters parameters)
{
EvaluationManager = evaluationManager;
Parameters = parameters;
}
/// <summary>
/// Constructs the object from the input data.
/// </summary>
/// <param name="inputData">Input data of the planning problem.</param>
/// <param name="parameters">Parameters of the lifted arguments (null if fully grounded).</param>
/// <param name="idManager">ID manager.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public Conditions(List <InputData.PDDL.Expression> inputData, Parameters parameters, IdManager idManager, EvaluationManager evaluationManager) : this(evaluationManager)
{
ExpressionsBuilder expressionsBuilder = new ExpressionsBuilder(idManager);
inputData.ForEach(inputExpression => Add(expressionsBuilder.Build(inputExpression)));
if (parameters != null)
{
Parameters = DetermineUsedParameters(parameters);
}
}
/// <summary>
/// Constructs the object from the input data.
/// </summary>
/// <param name="inputData">Operator effects input data.</param>
/// <param name="operatorPreconditions">Operator preconditions.</param>
/// <param name="idManager">ID manager.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public Effects(InputData.PDDL.Effects inputData, Conditions operatorPreconditions, IdManager idManager, EvaluationManager evaluationManager)
{
EffectsBuilder effectsBuilder = new EffectsBuilder(idManager);
inputData.ForEach(inputEffect => Add(effectsBuilder.Build(inputEffect)));
EffectsApplier = new Lazy <EffectsApplier>(() => new EffectsApplier(evaluationManager));
EffectsRelevanceConditionsEvaluator = new Lazy <EffectsRelevanceConditionsEvaluator>(() => new EffectsRelevanceConditionsEvaluator(this, evaluationManager.GroundingManager));
EffectsRelevanceRelativeStateEvaluator = new Lazy <EffectsRelevanceRelativeStateEvaluator>(() => new EffectsRelevanceRelativeStateEvaluator(this, evaluationManager.GroundingManager));
EffectsBackwardsConditionsApplier = new Lazy <EffectsBackwardsConditionsApplier>(() => new EffectsBackwardsConditionsApplier(operatorPreconditions, this, evaluationManager));
EffectsBackwardsRelativeStateApplier = new Lazy <EffectsBackwardsRelativeStateApplier>(() => new EffectsBackwardsRelativeStateApplier(operatorPreconditions, this, evaluationManager));
EffectsResultAtomsCollector = new Lazy <EffectsResultAtomsCollector>(() => new EffectsResultAtomsCollector(this, evaluationManager.GroundingManager));
}
/// <summary>
/// Constructs the object from the input data.
/// </summary>
/// <param name="actions">PDDL actions definition.</param>
/// <param name="idManager">ID manager.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public LiftedOperators(InputData.PDDL.Actions actions, IdManager idManager, EvaluationManager evaluationManager)
{
actions.ForEach(action => Add(new LiftedOperator(action, idManager, evaluationManager)));
}
/// <summary>
/// Creates the expression CNF transformer.
/// </summary>
/// <param name="evaluationManager">Evaluation manager.</param>
public ExpressionToCNFTransformer(EvaluationManager evaluationManager)
{
ExpressionToNNFTransformer = new ExpressionToNNFTransformer(evaluationManager);
}
/// <summary>
/// Constructs the object from a single grounded expression.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public Conditions(IExpression expression, EvaluationManager evaluationManager) : this(evaluationManager)
{
Add(expression);
}
/// <summary>
/// Evaluates the conditions with the given reference state and variable substitution.
/// </summary>
/// <param name="state">Reference state.</param>
/// <param name="substitution">Substitution.</param>
/// <returns>True if all conditions are met in the given state, false otherwise.</returns>
public bool Evaluate(IState state, ISubstitution substitution = null)
{
return(EvaluationManager.Evaluate(this, substitution, state));
}
/// <summary>
/// Creates the expression NNF transformer.
/// </summary>
/// <param name="evaluationManager">Evaluation manager.</param>
public ExpressionToNNFTransformer(EvaluationManager evaluationManager)
{
GroundingManager = evaluationManager.GroundingManager;
}
/// <summary>
/// Evaluates whether the conditions are in compliance with the rigid relations of the planning problem. Ignores non-rigid relations.
/// </summary>
/// <param name="substitution">Substitution.</param>
/// <returns>True if the conditions are in compliance with the rigid relations, false otherwise.</returns>
public bool EvaluateRigidRelationsCompliance(ISubstitution substitution)
{
return(EvaluationManager.EvaluateRigidRelationsCompliance(this, substitution));
}
/// <summary>
/// Constructs the CNF expression from the given conjuncts.
/// </summary>
/// <param name="conjuncts">Conjuncts.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
/// <param name="parameters">Condition parameters.</param>
public ConditionsCNF(HashSet <IConjunctCNF> conjuncts, EvaluationManager evaluationManager, Parameters parameters) : base(conjuncts)
{
EvaluationManager = evaluationManager;
Parameters = parameters;
}
/// <summary>
/// Gets the number of not accomplished condition constraints for the specified state.
/// </summary>
/// <param name="state">State to be evaluated.</param>
/// <returns>Number of not accomplished condition constraints.</returns>
public int GetNotAccomplishedConstraintsCount(IState state)
{
return(EvaluationManager.GetNotAccomplishedConstraintsCount(this, state));
}
/// <summary>
/// Constructs the effects applier.
/// </summary>
/// <param name="evaluationManager">Evaluation manager.</param>
public EffectsApplier(EvaluationManager evaluationManager)
{
GroundingManager = evaluationManager.GroundingManager;
EvaluationManager = evaluationManager;
NumericEvaluator = new Lazy <NumericExpressionEvaluator>(() => new NumericExpressionEvaluator(GroundingManager));
}
/// <summary>
/// Returns a collection of all used predicates within this conditions. Can be used for some preprocessing.
/// </summary>
/// <returns>Collection of used predicates.</returns>
public HashSet <IAtom> GetUsedPredicates()
{
return(EvaluationManager.CollectUsedPredicates(this));
}
