/// <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)); }