/************************************************************************
* Strathclyde Planning Group,
* Department of Computer and Information Sciences,
* University of Strathclyde, Glasgow, UK
* http://planning.cis.strath.ac.uk/
*
* Copyright 2007, Keith Halsey
* Copyright 2008, Andrew Coles and Amanda Smith
*
* (Questions/bug reports now to be sent to Andrew Coles)
*
* This file is part of JavaFF.
*
* JavaFF is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* JavaFF is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with JavaFF. If not, see <http://www.gnu.org/licenses/>.
*
************************************************************************/
package javaff.scheduling;
import javaff.data.TotalOrderPlan;
import javaff.data.PartialOrderPlan;
import javaff.data.TimeStampedPlan;
import javaff.data.GroundProblem;
import javaff.data.Action;
import javaff.data.Metric;
import javaff.data.metric.BinaryComparator;
import javaff.data.metric.ResourceOperator;
import javaff.data.metric.NumberFunction;
import javaff.data.metric.NamedFunction;
import javaff.data.metric.MetricSymbolStore;
import javaff.data.metric.TotalTimeFunction;
import javaff.data.temporal.StartInstantAction;
import javaff.planning.TemporalMetricState;
import java.util.Iterator;
import java.util.List;
import java.util.HashSet;
import java.util.Map;
import java.util.Hashtable;
import java.math.BigDecimal;
public class JavaFFScheduler implements Scheduler
{
protected GroundProblem problem;
public JavaFFScheduler(GroundProblem p)
{
problem = p;
}
public TimeStampedPlan schedule(TotalOrderPlan top)
{
PartialOrderPlan pop = GreedyPartialOrderLifter.lift(top, problem);
MatrixSTN stn = new MatrixSTN(top);
stn.addConstraints(pop.getTemporalConstraints());
//Sort out the Durations
Map states = new Hashtable(); //Maps (Actions => states (which the actions are applied in))
Iterator ait = top.getActions().iterator();
TemporalMetricState state = problem.getTemporalMetricInitialState();
while (ait.hasNext())
{
Action a = (Action) ait.next();
if (a instanceof StartInstantAction)
{
StartInstantAction sia = (StartInstantAction) a;
List l = TemporalConstraint.getBounds(sia, sia.getSibling(), sia.parent.getMaxDuration(state), sia.parent.getMinDuration(state));
stn.addConstraints(new HashSet(l));
}
states.put(a, state);
state = (TemporalMetricState) state.apply(a);
}
stn.consistent();
// sort out the resources
Map graphs = new Hashtable(); //Maps (NamedResources => PrecedenceGraphs)
ait = top.getActions().iterator();
while (ait.hasNext())
{
Action a = (Action) ait.next();
Iterator bcit = a.getComparators().iterator();
while (bcit.hasNext())
{
//WARNING WARNING WARNING - assumes comparators are of the form (NamedFunction </>/<=/>= StaticFunction)
BinaryComparator bc = (BinaryComparator) bcit.next();
NamedFunction res = (NamedFunction) bc.first;
PrecedenceResourceGraph prg = (PrecedenceResourceGraph) graphs.get(res);
if (prg == null)
{
prg = new PrecedenceResourceGraph(stn);
graphs.put(res,prg);
}
state = (TemporalMetricState) states.get(a);
BigDecimal d = bc.second.getValue(state);
prg.addCondition(new BinaryComparator( bc.type, res, new NumberFunction(d)), a);
}
Iterator roit = a.getOperators().iterator();
while (roit.hasNext())
{
ResourceOperator ro = (ResourceOperator) roit.next();
NamedFunction res = (NamedFunction) ro.resource;
PrecedenceResourceGraph prg = (PrecedenceResourceGraph) graphs.get(res);
if (prg == null)
{
prg = new PrecedenceResourceGraph(stn);
graphs.put(res,prg);
}
prg.addOperator(new ResourceOperator( ro.type, res, ro.change.makeOnlyDurationDependent(state)), a);
}
}
Iterator git = graphs.keySet().iterator();
while (git.hasNext())
{
NamedFunction nf = (NamedFunction) git.next();
PrecedenceResourceGraph prg = (PrecedenceResourceGraph) graphs.get(nf);
prg.addOperator(new ResourceOperator(MetricSymbolStore.INCREASE, nf, new NumberFunction(nf.getValue(problem.getTemporalMetricInitialState()))), stn.START);
boolean changesMade = true;
while (changesMade)
{
changesMade = prg.meetConditions();
stn.constrain();
}
changesMade = true;
while (changesMade)
{
changesMade = prg.limitBounds();
stn.constrain();
}
}
Metric m = problem.metric;
if (m != null && m.func instanceof NamedFunction && !(m.func instanceof TotalTimeFunction))
{
PrecedenceResourceGraph prg = (PrecedenceResourceGraph) graphs.get((NamedFunction) m.func);
if (m.type == Metric.MAXIMIZE) prg.maximize();
else if (m.type == Metric.MINIMIZE) prg.minimize();
}
stn.constrain();
stn.minimizeTime();
stn.minimizeDuration();
stn.constrain();
TimeStampedPlan p = stn.getTimes();
return p;
}
}