/// <summary>
/// Setup the relevant data structures for a run.
/// </summary>
public virtual void Setup(ProblemInstance problemInstance, int minDepth, Run runner)
{
minCAViolations = int.MaxValue;
passed = 0;
this.generatedHL = 1;
this.expandedHL = 1;
this.generatedLL = 0;
this.expandedLL = 0;
this.totalCost = Constants.TIMEOUT_COST;
// If there exists relevant previously solved subproblems - use their solution as a lower bound
if (problemInstance.parameters.ContainsKey(CostTreeSearch.PARENT_GROUP1_KEY))
{
costA = ((AgentsGroup)(problemInstance.parameters[CostTreeSearch.PARENT_GROUP1_KEY])).solutionCost;
costB = ((AgentsGroup)(problemInstance.parameters[CostTreeSearch.PARENT_GROUP2_KEY])).solutionCost;
sizeOfA = ((AgentsGroup)(problemInstance.parameters[CostTreeSearch.PARENT_GROUP1_KEY])).Size();
}
else
{
costA = problemInstance.m_vAgents[0].h;
costB = 0;
sizeOfA = 1;
}
this.problem = problemInstance;
this.runner = runner;
closedList = new HashSet <CostTreeNode>();
openList = new LinkedList <CostTreeNode>();
int[] costs = new int[problem.GetNumOfAgents()];
AgentState temp;
for (int i = 0; i < problem.GetNumOfAgents(); i++)
{
temp = problem.m_vAgents[i];
costs[i] = Math.Max(problem.GetSingleAgentOptimalCost(temp), minDepth);
}
openList.AddFirst(new CostTreeNode(costs));
this.initialHeuristics = openList.First.Value.costs.Sum();
// Store parameters used by Trevor's Independence Detection algorithm
if (problemInstance.parameters.ContainsKey(Trevor.MAXIMUM_COST_KEY))
{
this.maxCost = (int)(problemInstance.parameters[Trevor.MAXIMUM_COST_KEY]);
}
else
{
this.maxCost = -1;
}
if (problemInstance.parameters.ContainsKey(Trevor.CONFLICT_AVOIDANCE))
{
ID_CAT = ((HashSet <TimedMove>)problemInstance.parameters[Trevor.CONFLICT_AVOIDANCE]);
}
if (problemInstance.parameters.ContainsKey(CBS_LocalConflicts.INTERNAL_CAT))
{
CBS_CAT = ((HashSet_U <TimedMove>)problemInstance.parameters[CBS_LocalConflicts.INTERNAL_CAT]);
}
}
/// <summary>
/// Setup the relevant data structures for a run.
/// </summary>
/// <param name="problemInstance"></param>
/// <param name="minDepth"></param>
/// <param name="runner"></param>
/// <param name="minCost">Not taken into account, just added to comply with ICbsSolver</param>
public virtual void Setup(ProblemInstance problemInstance, int minDepth, Run runner, int minCost = -1)
{
this.minCAViolations = int.MaxValue;
CostTreeSearchSolver.passed = 0;
this.generatedHL = 1;
this.expandedHL = 1;
this.generatedLL = 0;
this.expandedLL = 0;
this.totalCost = Constants.TIMEOUT_COST;
// If there exists relevant previously solved subproblems - use their solution as a lower bound
//if (problemInstance.parameters.ContainsKey(CostTreeSearch.PARENT_GROUP1_KEY))
//{
// costA = ((AgentsGroup)(problemInstance.parameters[CostTreeSearch.PARENT_GROUP1_KEY])).solutionCost;
// costB = ((AgentsGroup)(problemInstance.parameters[CostTreeSearch.PARENT_GROUP2_KEY])).solutionCost;
// sizeOfA = ((AgentsGroup)(problemInstance.parameters[CostTreeSearch.PARENT_GROUP1_KEY])).Size();
//}
//else
{
costA = problemInstance.GetSingleAgentOptimalCost(problemInstance.m_vAgents[0]);
costB = 0;
sizeOfA = 1;
}
this.problem = problemInstance;
this.runner = runner;
closedList = new HashSet <CostTreeNode>();
openList = new Queue <CostTreeNode>();
int[] costs = new int[problem.GetNumOfAgents()];
for (int i = 0; i < problem.GetNumOfAgents(); i++)
{
costs[i] = Math.Max(problem.GetSingleAgentOptimalCost(problem.m_vAgents[i]), minDepth);
}
openList.Enqueue(new CostTreeNode(costs)); // The root
this.initialEstimate = openList.Peek().costs.Sum();
// Store parameters used by IndependenceDetection's Independence Detection algorithm
if (problemInstance.parameters.ContainsKey(IndependenceDetection.MAXIMUM_COST_KEY))
{
this.maxCost = (int)(problemInstance.parameters[IndependenceDetection.MAXIMUM_COST_KEY]);
}
else
{
this.maxCost = -1;
}
if (problemInstance.parameters.ContainsKey(IndependenceDetection.CONFLICT_AVOIDANCE))
{
ID_CAT = ((Dictionary <TimedMove, List <int> >)problemInstance.parameters[IndependenceDetection.CONFLICT_AVOIDANCE]);
}
if (problemInstance.parameters.ContainsKey(CBS_LocalConflicts.CAT))
{
CBS_CAT = ((Dictionary <TimedMove, List <int> >)problemInstance.parameters[CBS_LocalConflicts.CAT]);
}
}
public static uint h(WorldState s, ProblemInstance instance)
{
return((uint)s.allAgentsState.Sum(state => instance.GetSingleAgentOptimalCost(state)));
}
/// <summary>
/// Calculates for each agent and each direction it can go, the effect of that move on F. Illegal moves get byte.MaxValue.
/// Also calcs maxDeltaF.
/// Implicitly uses the SIC heuristic.
/// </summary>
/// <param name="problem">For GetSingleAgentOptimalCost</param>
/// <returns></returns>
public void calcSingleAgentDeltaFs(ProblemInstance problem, ValidityChecker isValid)
{
// Init
this.singleAgentDeltaFs = new byte[allAgentsState.Length][];
for (int i = 0; i < singleAgentDeltaFs.Length; i++)
{
this.singleAgentDeltaFs[i] = new byte[Constants.NUM_ALLOWED_DIRECTIONS];
}
int hBefore, hAfter;
this.maxDeltaF = 0;
// Set values
for (int i = 0; i < allAgentsState.Length; i++)
{
hBefore = problem.GetSingleAgentOptimalCost(allAgentsState[i]); // According to SIC
int singleAgentMaxLegalDeltaF = -1;
foreach (TimedMove check in allAgentsState[i].lastMove.GetNextMoves())
{
if (isValid(check, noMoves, this.makespan + 1, i, this, this) == false)
{
singleAgentDeltaFs[i][(int)check.direction] = byte.MaxValue;
}
else
{
hAfter = problem.GetSingleAgentOptimalCost(allAgentsState[i].agent.agentNum, check); // According to SIC
if (Constants.Variant == Constants.ProblemVariant.ORIG)
{
if (hBefore != 0)
{
singleAgentDeltaFs[i][(int)check.direction] = (byte)(hAfter - hBefore + 1); // h difference + g difference in this specific domain
}
else if (hAfter != 0) // If agent moved from its goal we must count and add all the steps it was stationed at the goal, since they're now part of its g difference
{
singleAgentDeltaFs[i][(int)check.direction] = (byte)(hAfter - hBefore + makespan - allAgentsState[i].arrivalTime + 1);
}
else
{
singleAgentDeltaFs[i][(int)check.direction] = 0; // This is a WAIT move at the goal.
}
singleAgentMaxLegalDeltaF = Math.Max(singleAgentMaxLegalDeltaF, singleAgentDeltaFs[i][(int)check.direction]);
}
else if (Constants.Variant == Constants.ProblemVariant.NEW)
{
if (hBefore == 0 && hAfter == 0)
{
singleAgentDeltaFs[i][(int)check.direction] = 0; // This is a WAIT move at the goal.
}
else
{
singleAgentDeltaFs[i][(int)check.direction] = (byte)(hAfter - hBefore + 1); // h difference + g difference in this specific domain
}
singleAgentMaxLegalDeltaF = Math.Max(singleAgentMaxLegalDeltaF, singleAgentDeltaFs[i][(int)check.direction]);
}
}
}
if (singleAgentMaxLegalDeltaF == -1) // No legal action for this agent, so no legal children exist for this node
{
this.maxDeltaF = 0; // Can't make it negative without widening the field.
break;
}
this.maxDeltaF += (byte)singleAgentMaxLegalDeltaF;
}
fLookup = new sbyte[allAgentsState.Length][];
for (int i = 0; i < fLookup.Length; i++)
{
fLookup[i] = new sbyte[this.maxDeltaF + 1]; // Towards the last agents most of the row will be wasted (the last one can do delta F of 0 or 1),
// but it's easier than fiddling with array sizes
}
}