private Action GetResetDependenciesRevealedAction(GroundedFunctionPredicate totalCostFunctionPredicate) { Action resetDependenciesRevealed = new Action(resetDependenciesActionName); CompoundFormula preconditions = new CompoundFormula("and"); CompoundFormula effects = new CompoundFormula("and"); foreach (Constant agent in agentsConstants) { GroundedPredicate revealedSomething = new GroundedPredicate("revealed-something"); revealedSomething.AddConstant(agent); Predicate notRevealedSomething = revealedSomething.Negate(); preconditions.AddOperand(revealedSomething); effects.AddOperand(notRevealedSomething); } effects.AddOperand(GetIncreaseTotalCostFunction(totalCostFunctionPredicate, revealedDependencyCost)); resetDependenciesRevealed.Preconditions = preconditions; resetDependenciesRevealed.SetEffects(effects); return(resetDependenciesRevealed); }
private List <Action> GetDependenciesActions(GroundedFunctionPredicate totalCostFunctionPredicate, List <Agent> m_agents) { List <Action> dependenciesActions = new List <Action>(); dependenciesActions.Add(GetRevealedDependencyParameterizedAction()); dependenciesActions.AddRange(GetRevealedDummyDependencyActions(m_agents)); dependenciesActions.Add(GetResetDependenciesRevealedAction(totalCostFunctionPredicate)); return(dependenciesActions); }
/* * private List<GroundedFunctionPredicate> GetInitAmountOfDependenciesRevealedToZeroPredicates(List<Agent> m_agents) * { * List<GroundedFunctionPredicate> predicates = new List<GroundedFunctionPredicate>(); * foreach(Agent agent in m_agents) * { * predicates.Add(GetInitAmountOfDependenciesRevealedToZeroForAgentPredicate(agent)); * } * return predicates; * } * * private GroundedFunctionPredicate GetInitAmountOfDependenciesRevealedToZeroForAgentPredicate(Agent agent) * { * GroundedFunctionPredicate initAmountOfDependenciesRevealedToZero = new GroundedFunctionPredicate("="); * Constant a = mapAgentToConstant[agent]; * GroundedFunctionPredicate amountOfDepRevGrounded = GetAmountOfDependenciesRevealedGrounded(a); * FunctionConstant functionConstant = new FunctionConstant(amountOfDepRevGrounded); * initAmountOfDependenciesRevealedToZero.AddFunction(functionConstant); * initAmountOfDependenciesRevealedToZero.AddNumber(0); * * return initAmountOfDependenciesRevealedToZero; * } */ private GroundedFunctionPredicate GetInitTotalCostToZeroPredicate(GroundedFunctionPredicate totalCostFunctionPredicate) { GroundedFunctionPredicate initTotalCostToZeroPredicate = new GroundedFunctionPredicate("="); FunctionConstant functionConstant = new FunctionConstant(totalCostFunctionPredicate); initTotalCostToZeroPredicate.AddFunction(functionConstant); initTotalCostToZeroPredicate.AddNumber(0); return(initTotalCostToZeroPredicate); }
/* * private ParameterizedFunctionPredicate GetIncreaseAmountOfDependenciesRevealedParameterized(ParameterizedFunctionPredicate amountOfDependenciesRevealedParameterized) * { * ParameterizedFunctionPredicate increaseAmountOfDepRev = new ParameterizedFunctionPredicate("increase"); * FunctionParameter functionParameterAmountOfDepRev = new FunctionParameter(amountOfDependenciesRevealedParameterized); * increaseAmountOfDepRev.AddFunction(functionParameterAmountOfDepRev); * increaseAmountOfDepRev.AddNumber(1); //increase by 1. * return increaseAmountOfDepRev; * } * * private GroundedFunctionPredicate GetIncreaseAmountOfDependenciesRevealedGrounded(GroundedFunctionPredicate amountOfDepRevGrounded) * { * GroundedFunctionPredicate increaseAmountOfDepRev = new GroundedFunctionPredicate("increase"); * FunctionConstant functionParameterAmountOfDepRev = new FunctionConstant(amountOfDepRevGrounded); * increaseAmountOfDepRev.AddFunction(functionParameterAmountOfDepRev); * increaseAmountOfDepRev.AddNumber(1); //increase by 1. * return increaseAmountOfDepRev; * } * * private ParameterizedFunctionPredicate GetEqualsToMax(ParameterizedFunctionPredicate amountOfDependenciesRevealedParameterized) * { * ParameterizedFunctionPredicate equalsToMax = new ParameterizedFunctionPredicate("="); * FunctionParameter functionParameterAmountOfDepRev = new FunctionParameter(amountOfDependenciesRevealedParameterized); * equalsToMax.AddFunction(functionParameterAmountOfDepRev); * equalsToMax.AddNumber(maxAmountOfDependencies); * return equalsToMax; * } * * private GroundedFunctionPredicate GetEqualsToMaxGrounded(GroundedFunctionPredicate amountOfDepRevGrounded) * { * GroundedFunctionPredicate equalsToMax = new GroundedFunctionPredicate("="); * FunctionConstant functionConstantAmountOfDepRev = new FunctionConstant(amountOfDepRevGrounded); * equalsToMax.AddFunction(functionConstantAmountOfDepRev); * equalsToMax.AddNumber(maxAmountOfDependencies); * return equalsToMax; * } * * private ParameterizedFunctionPredicate GetAmountOfDependenciesRevealedParameterized() * { * ParameterizedFunctionPredicate amountOfDependenciesRevealed = new ParameterizedFunctionPredicate("amount-of-dependencies-revealed"); * Parameter agentParameter = GetAgentParameter(); * amountOfDependenciesRevealed.AddParameter(agentParameter); * return amountOfDependenciesRevealed; * } * * private GroundedFunctionPredicate GetAmountOfDependenciesRevealedGrounded(Constant agent) * { * GroundedFunctionPredicate amountOfDependenciesRevealed = new GroundedFunctionPredicate("amount-of-dependencies-revealed"); * amountOfDependenciesRevealed.AddConstant(agent); * * return amountOfDependenciesRevealed; * } */ private GroundedFunctionPredicate GetIncreaseTotalCostFunction(GroundedFunctionPredicate totalCostFunctionPredicate, int cost) { GroundedFunctionPredicate increaseFP = new GroundedFunctionPredicate("increase"); FunctionConstant functionConstant = new FunctionConstant(totalCostFunctionPredicate); increaseFP.AddFunction(functionConstant); increaseFP.AddNumber(cost); return(increaseFP); }
private GroundedFunctionPredicate GetTotalCostFunction() { GroundedFunctionPredicate totalCostFunction = new GroundedFunctionPredicate("total-cost"); return(totalCostFunction); }
private void UpdateDependenciesIntoDomainsAndProblems(List <Agent> m_agents) { GroundedFunctionPredicate totalCostFunctionPredicate = GetTotalCostFunction(); Domain dJoined = new Domain("JoinedDomain", ""); Problem pJoined = new Problem("JoinedProblem", dJoined); State publicStartState = new State(pJoined); HashSet <GroundedPredicate> allGoals = new HashSet <GroundedPredicate>(); List <Action> allActions = new List <Action>(); foreach (Agent agent in m_agents) { foreach (Action action in agent.m_actions) { List <Dependency> dependenciesForAction = new List <Dependency>(); List <Predicate> regularEffects = new List <Predicate>(); foreach (Predicate p in action.HashEffects) { Dependency dependency = new Dependency(action, p); if (mapDependencyToConstant.ContainsKey(dependency)) { //Then this is a dependency dependent action, which means we need to duplicate it several times so that we have the action with the dependency revealed and without it dependenciesForAction.Add(dependency); /* * Constant d = mapDependencyToConstant[dependency]; * GroundedPredicate revealedD = new GroundedPredicate("revealed"); * revealedD.AddConstant(d); * * CompoundFormula cfCondition = new CompoundFormula("when"); * cfCondition.AddOperand(revealedD); //condition * cfCondition.AddOperand(p); //result = the predicate we want to reveal. * * editedEffects.AddOperand(cfCondition); */ } else { regularEffects.Add(p); //editedEffects.AddOperand(p); //it is not a dependency, so just reveal it regularly... } } List <List <Dependency> > allPermutations = GetAllCombos(dependenciesForAction); foreach (List <Dependency> currentPermutation in allPermutations) { //foreach permutation, create a corresponding action string name = action.Name; CompoundFormula editedEffects = new CompoundFormula("and"); CompoundFormula editedPreconditions = new CompoundFormula("and"); foreach (Predicate p in action.HashPrecondition) { editedPreconditions.AddOperand(p); } foreach (Predicate p in regularEffects) { editedEffects.AddOperand(p); } if (currentPermutation.Count > 0) { name += "_with_dependencies"; } foreach (Dependency dependency in currentPermutation) { Constant d = mapDependencyToConstant[dependency]; GroundedPredicate revealedD = new GroundedPredicate("revealed"); revealedD.AddConstant(d); name += "_" + d.Name; editedPreconditions.AddOperand(revealedD); editedEffects.AddOperand(dependency.predicate); } editedEffects.AddOperand(GetIncreaseTotalCostFunction(totalCostFunctionPredicate, regularActionCost)); Action editedAction = action.Clone(); editedAction.Name = name; editedAction.Preconditions = editedPreconditions; editedAction.SetEffects(editedEffects); allActions.Add(editedAction); } } } List <ParametrizedPredicate> parametrizedPredicates = GetParametrizedPredicates(); //Add these predeicated to the joined domain. These predicates are general ones that are part of our transformation to a different problem. List <GroundedPredicate> belongsToPredicates = GetBelongsToGroundedPredicates(); //List<GroundedPredicate> revealedSomethingPredicates = GetRevealedSomethingGroundedPredicates(); //List<GroundedFunctionPredicate> amountOfDepRevPredicates = GetInitAmountOfDependenciesRevealedToZeroPredicates(m_agents); GroundedFunctionPredicate initTotalCostToZeroPredicate = GetInitTotalCostToZeroPredicate(totalCostFunctionPredicate); List <Action> dependenciesActions = GetDependenciesActions(); allActions.AddRange(dependenciesActions); List <string> myNewTypes = GetMyNewTypes(); dJoined.AddFunction(totalCostFunctionPredicate.ToString()); dJoined.Actions = allActions; foreach (Agent agent in m_agents) { Domain d = agent.domain; foreach (ParametrizedPredicate pp in d.Predicates) { dJoined.Predicates.Add(pp); } foreach (string sType in d.Types) { if (!dJoined.Types.Contains(sType)) { dJoined.Types.Add(sType); } } foreach (KeyValuePair <string, string> pair in d.TypeHierarchy) { dJoined.TypeHierarchy[pair.Key] = pair.Value; } foreach (Constant c in d.Constants) { dJoined.Constants.Add(c); } foreach (GroundedPredicate pgp in agent.startState.Predicates) { publicStartState.AddPredicate(pgp); } foreach (GroundedPredicate goalP in agent.goal) { allGoals.Add(goalP); } } foreach (ParametrizedPredicate pp in parametrizedPredicates) { if (dJoined.Predicates.Contains(pp)) { throw new Exception("The dependencies predicates must be unique, and cannot be in another domain."); } dJoined.Predicates.Add(pp); } foreach (string type in myNewTypes) { if (dJoined.Types.Contains(type)) { throw new Exception("The dependency and agent types must be unique, and cannot be in another domain."); } dJoined.Types.Add(type); dJoined.TypeHierarchy[type] = objectType; } foreach (Constant d in dependenciesConstants) { if (dJoined.Constants.Contains(d)) { throw new Exception("The dependencies constant names must be unique, and cannot be in another domain."); } dJoined.Constants.Add(d); } foreach (Constant a in agentsConstants) { if (dJoined.Constants.Contains(a)) { throw new Exception("The agents constant names must be unique, and cannot be in another domain."); } dJoined.Constants.Add(a); } foreach (Constant n in numberConstants) { if (dJoined.Constants.Contains(n)) { throw new Exception("The numbers constant names must be unique, and cannot be in another domain."); } dJoined.Constants.Add(n); } //private List<GroundedPredicate> nextPredicates; //private List<GroundedPredicate> revealedNumberOfDependenciesPredicates; //Add to start state: foreach (GroundedPredicate gp in belongsToPredicates) { if (dJoined.Predicates.Contains(gp)) { throw new Exception("The belongs-to predicates must be unique, and cannot be in another domain."); } publicStartState.AddPredicate(gp); } /* * foreach (GroundedPredicate gp in revealedSomethingPredicates) * { * if (dJoined.Predicates.Contains(gp)) * throw new Exception("The revealed-something predicates must be unique, and cannot be in another domain."); * publicStartState.AddPredicate(gp); * } */ /* * foreach(GroundedFunctionPredicate gfp in amountOfDepRevPredicates) * { * if (dJoined.Predicates.Contains(gfp)) * throw new Exception("The amount-of-dependencies-revealed predicates must be unique, and cannot be in another domain."); * publicStartState.AddPredicate(gfp); * } */ foreach (GroundedPredicate gp in nextPredicates) { if (dJoined.Predicates.Contains(gp)) { throw new Exception("The next predicates must be unique, and cannot be in another domain."); } publicStartState.AddPredicate(gp); } foreach (GroundedPredicate gp in revealedNumberOfDependenciesPredicates) { if (dJoined.Predicates.Contains(gp)) { throw new Exception("The revealed-number-of-dependencies predicates must be unique, and cannot be in another domain."); } publicStartState.AddPredicate(gp); } if (dJoined.Predicates.Contains(initTotalCostToZeroPredicate)) { throw new Exception("The initialization of total cost predicate must be unique, and cannot be in another domain."); } publicStartState.AddPredicate(initTotalCostToZeroPredicate); foreach (Predicate pInit in publicStartState.Predicates) { pJoined.AddKnown(pInit); } CompoundFormula goalf = new CompoundFormula("and"); foreach (GroundedPredicate goalP in allGoals) { goalf.AddOperand(goalP); } pJoined.Goal = goalf; pJoined.AddMetric("(:metric " + "minimize " + totalCostFunctionPredicate.ToString() + ")"); joinedDomain = dJoined; joinedProblem = pJoined; joinedStartState = publicStartState; }