private static IPlanNode ChangeValue(IPlanNode n, object nodeValue)
{
var node = PlanNode.Copy(n);
node.NodeValue = nodeValue;
return(node);
}
private NextPlanNodeParameter GetNextPara(IPlanNode node)
{
// Compute verical mode.
double optCrzAlt = fuelData.OptCruiseAlt(node.GrossWt);
double heading = HeadingCalculation.Heading(node.PrevWaypoint, node);
double atcAllowedAlt = altProvider.ClosestAlt(node, heading, optCrzAlt);
double targetAlt = Min(atcAllowedAlt, maxAlt);
double altDiff = node.Alt - targetAlt;
VerticalMode mode = GetMode(altDiff);
// Time to next waypoint.
double disToNextWpt = node.Distance(node.PrevWaypoint);
double timeToNextWpt = disToNextWpt / node.Gs * 60.0;
// Time to target altitude.
// ClimbRate is positve for climbs and negative for descents.
double climbGrad = ClimbGradient(node.GrossWt, mode);
double climbRate = climbGrad * node.Ktas / 60.0 * NmFtRatio;
bool isCruising = Abs(altDiff) < AltDiffCriteria;
double timeToTargetAlt = isCruising ?
double.PositiveInfinity :
altDiff / climbRate;
double[] times = { timeToNextWpt, DeltaT, timeToTargetAlt };
int minIndex = times.MinIndex();
double stepTime = times[minIndex];
Type nodeType = minIndex == 0 ?
typeof(RouteNode) :
typeof(IntermediateNode);
return(new NextPlanNodeParameter(mode, nodeType, stepTime, climbRate));
}
private static IPlanNode GetNode(IPlanNode old, double fuelOnBoard, double grossWt)
{
var node = PlanNode.Copy(old);
node.FuelOnBoard = fuelOnBoard;
node.GrossWt = grossWt;
return(node);
}
public void AddPlanForState(TState state, IPlanNode <TState, TAction> planNode)
{
if (_children.ContainsKey(state))
{
throw new InvalidOperationException("duplicate state");
}
_children[state] = planNode;
}
public PlanNode(DomainState state, IDomainAction selectedAction, IPlanNode parent, float estimate)
{
State = state ?? throw new ArgumentNullException(nameof(state));
SelectedAction = selectedAction;
Parent = parent;
Estimate = estimate;
RunningCost = (parent?.RunningCost ?? 0) + (selectedAction?.GetCost(parent?.State) ?? 0);
Level = (parent?.Level ?? -1) + 1;
}
public Activity(ICrateManager crateManager, IAuthorization authorizationToken, ISecurityServices security, IActivityTemplate activityTemplate, IPlanNode planNode, IUpstreamDataExtractionService upstreamDataExtractionService)
{
_crateManager = crateManager;
_authorizationToken = authorizationToken;
_security = security;
_activityTemplate = activityTemplate;
_planNode = planNode;
_upstreamDataExtractionService = upstreamDataExtractionService;
}
private IPlanNode GetNode(IPlanNode old,
double alt, double grossWt, double fuelOnBoard, double timeRemain)
{
return(new PlanNode(
old.NodeValue,
old.WindTable,
old.NextRouteNode,
old.NextPlanNodeCoordinate,
alt,
grossWt,
fuelOnBoard,
timeRemain,
Kias(grossWt, alt)));
}
private IPlanNode NextPlanNode(IPlanNode prev, IPlanNode old)
{
var ff = fuelData.ClimbFuelFlow(prev.GrossWt);
var stepDis = prev.Distance(prev.NextPlanNodeCoordinate);
var stepTime = stepDis / prev.Gs * 60.0;
var stepFuel = stepTime * ff;
var climbGrad = fuelData.ClimbGradient(prev.GrossWt);
var climbRate = climbGrad * prev.Ktas / 60.0 * NmFtRatio;
var alt = Math.Min(prev.Alt + stepTime * climbRate, old.Alt);
var grossWt = prev.GrossWt - stepFuel;
var fuelOnBoard = prev.FuelOnBoard - stepFuel;
var timeRemaining = prev.TimeRemaining - stepTime;
return(GetNode(old, alt, grossWt, fuelOnBoard, timeRemaining));
}
public static PlanNode Copy(IPlanNode p)
{
return(new PlanNode(
p.NodeValue,
p.WindTable,
p.NextRouteNode,
p.NextPlanNodeCoordinate,
p.Alt,
p.GrossWt,
p.FuelOnBoard,
p.TimeRemaining,
p.Kias,
p.Ktas,
p.Gs));
}
private static Plan GetOptions(IPlanNode node, ActionSet actions, DomainState startState)
{
var goalState = node.State;
var expandedActions = new HashSet <IDomainAction>();
foreach (var(worldVar, targetValue) in goalState.GetAll())
{
if (!actions.TryGetOut(worldVar, out var matchingActions))
{
continue;
}
// TODO create path for numeric values
foreach (var(action, effectValue) in matchingActions)
{
if (expandedActions.Contains(action))
{
continue;
}
if (!Equals(effectValue, targetValue))
{
continue;
}
// Discard actions with effects that don't overlap with goal state
if (!TryApplyEffects(action, goalState, out var nextStateToFind))
{
continue;
}
// Check if precondition violates search
if (AnyPreconditionConflictsWithGoal(action.Preconditions, nextStateToFind))
{
continue;
}
// And inject new preconditions into new search state
nextStateToFind = nextStateToFind.SetRange(action.Preconditions);
// No need to expand action again
expandedActions.Add(action);
yield return(new PlanNode(nextStateToFind, action, node, nextStateToFind.DistanceTo(startState)));
}
}
}
private IPlanNode NextPlanNode(IPlanNode prev, NextPlanNodeParameter p)
{
var ff = FuelFlow(prev.GrossWt, p.ModeVertical);
var stepFuel = p.StepTime * ff;
double alt = prev.Alt - p.StepTime * p.ClimbRate;
double grossWt = prev.GrossWt + stepFuel;
double fuelOnBoard = prev.FuelOnBoard + stepFuel;
double timeRemaining = prev.TimeRemaining + p.StepTime;
double kias = Kias(prev.GrossWt, alt, p.ModeVertical);
if (p.NodeType == typeof(RouteNode))
{
var current = prev.NextRouteNode.Previous;
RouteNode val = current.Value;
LinkedListNode <RouteNode> nextRouteNode = current;
return(new PlanNode(
val,
windTable,
nextRouteNode,
prev,
alt,
grossWt,
fuelOnBoard,
timeRemaining,
kias));
}
else
{
double stepDis = p.StepTime * prev.Gs / 60.0;
var nodeCoord = GetV(prev, prev.PrevWaypoint, stepDis);
var val = new IntermediateNode(nodeCoord);
return(new PlanNode(
val,
windTable,
prev.NextRouteNode,
prev,
alt,
grossWt,
fuelOnBoard,
timeRemaining,
kias));
}
}
public TAction NextAction(TState state)
{
while (_currentNode is AndNode <TState, TAction> andNode)
{
_currentNode = andNode.GetPlan(state);
}
if (!(_currentNode is OrNode <TState, TAction> orNode))
{
throw new InvalidOperationException("current node should be 'or node'");
}
var action = orNode.Action;
_currentNode = orNode.Child;
return(action);
}
protected static Actions GetActions(IPlanNode node)
{
if (node is null)
{
return(null);
}
var queue = new Queue <IPlanNode>();
var current = node;
while (current != null)
{
queue.Enqueue(current);
current = current.Parent;
}
return(queue
.Select(n => n.SelectedAction)
.Where(action => action != null)
.ToList());
}
protected static Actions GetActionsInverted(IPlanNode node)
{
if (node is null)
{
return(null);
}
var stack = new Stack <IPlanNode>();
var current = node;
while (current != null)
{
stack.Push(current);
current = current.Parent;
}
return(stack
.Select(n => n.SelectedAction)
.Where(action => action != null)
.ToList());
}
public void GetAvailableData_ShouldReturnFields()
{
var plan = new PlanDO();
plan.Name = "sdfasdfasdf";
plan.PlanState = PlanState.Executing;
var testActionTree = FixtureData.TestActivity2Tree();
plan.ChildNodes.Add(testActionTree);
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
uow.PlanRepository.Add(plan);
uow.SaveChanges();
}
IPlanNode planNodeService = ObjectFactory.GetInstance <IPlanNode>();
var fieldsCrate = planNodeService.GetIncomingData(testActionTree.ChildNodes.Last().Id, CrateDirection.Upstream, AvailabilityType.NotSet);
Assert.NotNull(fieldsCrate);
Assert.NotNull(fieldsCrate.AvailableCrates.SelectMany(x => x.Fields).ToList());
Assert.AreEqual(33, fieldsCrate.AvailableCrates.SelectMany(x => x.Fields).ToList().Count);
}
public override void SetUp()
{
base.SetUp();
FixtureData.AddTestActivityTemplate();
_planNode = ObjectFactory.GetInstance <IPlanNode>();
}
public NonDeterministicDfsSearchSolution(IPlanNode <TState, TAction> root)
{
_currentNode = root;
}
public PlanNodesController()
{
_activity = ObjectFactory.GetInstance <IPlanNode>();
}
public TagGenerator(IPlanNode activity, IActivityCategory activityCategory)
{
_activity = activity;
_activityCategory = activityCategory;
}
