solve method

  1. @override
int solve(
  1. double dt,
  2. World world
)
override

Solve the subsystems @return number of iterations performed

Implementation

@override
int solve(double dt, World world) {
  //List<SplitSolverNode> nodes = splitSolverSolveNodes;
  List<SplitSolverNode> nodePool = this.nodePool;
  List<Body> bodies = world.bodies;
  List<Equation> equations = this.equations;
  final neq = equations.length;
  final nbodies = bodies.length;
  final subsolver = this.subsolver;
  List<SplitSolverNode> nodes = List.filled(nbodies,SplitSolverNode(),growable: true);
  nodes.replaceRange(0,splitSolverSolveNodes.length,splitSolverSolveNodes);
  // Create needed nodes, reuse if possible
  while (nodePool.length < nbodies) {
    nodePool.add(createNode());
  }

  //nodes.length = nbodies;
  for (int i = 0; i < nbodies; i++) {
    nodes[i] = nodePool[i];
  }

  // Reset node values
  for (int i = 0; i != nbodies; i++) {
    final node = nodes[i];
    node.body = bodies[i];
    node.children.clear();
    node.eqs.clear();
    node.visited = false;
  }
  for (int k = 0; k != neq; k++) {
    final eq = equations[k];
    final i = bodies.indexOf(eq.bi);
    final j = bodies.indexOf(eq.bj);
    final ni = nodes[i];
    final nj = nodes[j];
    ni.children.add(nj);
    ni.eqs.add(eq);
    nj.children.add(ni);
    nj.eqs.add(eq);
  }

  //:  | false;
  int n = 0;
  List<Equation> eqs = splitSolverSolveEqs;

  subsolver.tolerance = tolerance;
  subsolver.iterations = iterations;

  final dummyBodies= splitSolverSolveDummyWorld;
  while(true) {
    SplitSolverNode? child = getUnvisitedNode(nodes);
    if(child == null) break;
    eqs.clear();
    dummyBodies.clear();
    bfs(child, visitFunc, dummyBodies, eqs);

    final neqs = eqs.length;

    //eqs = eqs.sort(sortById);
    eqs.sort(sortById);

    for (int i = 0; i != neqs; i++) {
      subsolver.addEquation(eqs[i]);
    }
    final dummyWorld = World()..bodies=dummyBodies;
    subsolver.solve(dt, dummyWorld);
    subsolver.removeAllEquations();
    n++;
  }

  return n;
}