/// <summary>
/// Constructs the grounding manager.
/// </summary>
/// <param name="inputData">Input data.</param>
/// <param name="idManager">ID manager.</param>
public GroundingManager(InputData.PDDLInputData inputData, IdManager idManager)
{
ConstantsManager = new Lazy <ConstantsManager>(() => new ConstantsManager(inputData, idManager));
AtomsManager = new Lazy <AtomsManager>(() => new AtomsManager(inputData, idManager));
SubstitutionGenerator = new Lazy <SubstitutionGenerator>(() => new SubstitutionGenerator(ConstantsManager));
Grounder = new Lazy <Grounder>(() => new Grounder(idManager));
}
/// <summary>
/// Constructs the type hierarchy of the PDDL planning problem.
/// </summary>
/// <param name="inputData">Input data.</param>
/// <param name="idManager">ID manager.</param>
public TypeHierarchy(InputData.PDDLInputData inputData, IdManager idManager)
{
IdManager = idManager;
Add(idManager.Types.GetId("object"), new TypeIdCollection());
foreach (var type in inputData.Domain.Types)
{
TypeId typeId = idManager.Types.GetId(type.TypeName);
if (!ContainsKey(typeId))
{
Add(typeId, new TypeIdCollection());
}
foreach (var baseType in type.BaseTypeNames)
{
TypeId baseTypeId = idManager.Types.GetId(baseType);
if (ContainsKey(baseTypeId))
{
this[baseTypeId].Add(typeId);
}
else
{
TypeIdCollection newChildrenSet = new TypeIdCollection {
typeId
};
Add(baseTypeId, newChildrenSet);
}
}
}
}
/// <summary>
/// Constructs the relaxed PDDL planning problem.
/// </summary>
/// <param name="inputData">Input data.</param>
public RelaxedProblem(InputData.PDDLInputData inputData) : base(inputData)
{
foreach (var liftedOperator in Operators)
{
liftedOperator.Effects.SetDeleteRelaxation();
}
}
/// <summary>
/// Constructs the constant manager.
/// </summary>
/// <param name="inputData">Input data.</param>
/// <param name="idManager">ID manager.</param>
public ConstantsManager(InputData.PDDLInputData inputData, IdManager idManager)
{
IdManager = idManager;
TypeHierarchy = new TypeHierarchy(inputData, idManager);
ConstantDefinitionTypes = new Dictionary <int, ICollection <int> >();
foreach (var type in TypeHierarchy)
{
TypeId typeId = type.Key;
Add(typeId, new ConstantIdCollection());
}
System.Action <string, List <string> > processConstantItem = (constantName, typeNames) =>
{
HashSet <TypeId> typeIDs = new HashSet <int>();
ConstantId constantId = idManager.Constants.GetId(constantName);
foreach (string type in typeNames)
{
TypeId typeId = idManager.Types.GetId(type);
this[typeId].Add(constantId);
typeIDs.Add(typeId);
}
ConstantDefinitionTypes.Add(constantId, typeIDs);
};
foreach (var constant in inputData.Domain.Constants)
{
processConstantItem(constant.ConstantName, constant.TypeNames);
}
foreach (var obj in inputData.Problem.Objects)
{
processConstantItem(obj.ObjectName, obj.TypeNames);
}
System.Action <TypeId, TypeId> fillConstantsFromChildType = null;
fillConstantsFromChildType = (typeId, outputTypeId) =>
{
this[outputTypeId].UnionWith(this[typeId]);
TypeIdCollection childrenTypes = TypeHierarchy[typeId];
foreach (TypeId childTypeId in childrenTypes)
{
fillConstantsFromChildType(childTypeId, outputTypeId);
}
};
foreach (TypeId typeId in Keys)
{
fillConstantsFromChildType(typeId, typeId);
}
}
/// <summary>
/// Constructs the atoms manager.
/// </summary>
/// <param name="inputData">Input data.</param>
/// <param name="idManager">ID manager.</param>
public AtomsManager(InputData.PDDLInputData inputData, IdManager idManager)
{
Func <int, InputData.PDDL.DefinitionTerms, Tuple <IAtom, Parameters> > processAtom = (atomId, inputTerms) =>
{
List <ITerm> terms = new List <ITerm>();
Parameters parameters = new Parameters();
int freeVarId = 0;
foreach (var term in inputTerms)
{
List <int> typeIDs = new List <int>();
foreach (var typeName in term.TypeNames)
{
typeIDs.Add(idManager.Types.GetId(typeName));
}
terms.Add(new VariableTerm(freeVarId));
parameters.Add(new Parameter(freeVarId++, typeIDs, idManager));
}
IAtom atom = new Atom(atomId, terms);
return(Tuple.Create(atom, parameters));
};
foreach (var predicate in inputData.Domain.Predicates)
{
int atomName = idManager.Predicates.GetId(predicate.Name, predicate.Terms.Count);
var processedAtom = processAtom(atomName, predicate.Terms);
LiftedPredicates.Add(processedAtom);
}
foreach (var function in inputData.Domain.Functions)
{
int atomName = idManager.Functions.GetId(function.Name, function.Terms.Count);
var processedAtom = processAtom(atomName, function.Terms);
if (function.IsNumericFunction())
{
LiftedNumericFunctions.Add(processedAtom);
}
else
{
List <int> returnTypeIds = new List <int>();
foreach (var typeName in function.ReturnValueTypes)
{
returnTypeIds.Add(idManager.Types.GetId(typeName));
}
LiftedObjectFunctions.Add(Tuple.Create(processedAtom.Item1, returnTypeIds, processedAtom.Item2));
}
}
}
/// <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>
/// Creates and initiliazes ID manager from the input data.
/// </summary>
/// <param name="inputData">Input data.</param>
public IdManager(InputData.PDDLInputData inputData)
{
Types.Register("object");
foreach (var type in inputData.Domain.Types)
{
if (!Types.IsRegistered(type.TypeName))
{
Types.Register(type.TypeName);
}
foreach (var baseType in type.BaseTypeNames)
{
if (!Types.IsRegistered(baseType))
{
Types.Register(baseType);
}
}
}
inputData.Domain.Predicates.ForEach(predicate => Predicates.Register(predicate.Name, predicate.Terms.Count));
inputData.Domain.Functions.ForEach(function => Functions.Register(function.Name, function.Terms.Count));
inputData.Domain.Constants.ForEach(constant => Constants.Register(constant.ConstantName));
inputData.Problem.Objects.ForEach(obj => Constants.Register(obj.ObjectName));
}
