并行容器

并行容器将一组阶段（stage）组合起来，以规划备选解决方案。

MTC 提供了三种可在并行容器中使用的阶段类型：

Alternatives
Fallback
Merger

备选方案（Alternatives）

备选方案容器允许添加多个可并行执行的阶段。所有子阶段的解会在最后被收集并按代价（cost）排序。示例——使用不同的代价项规划一条轨迹。

   auto pipeline{ std::make_shared<solvers::PipelinePlanner>(node) };

   auto alternatives{ std::make_unique<Alternatives>("connect") };
   {
       auto connect{ std::make_unique<stages::Connect>(
            "path length", stages::Connect::GroupPlannerVector{ { "panda_arm", pipeline } }) };
       connect->setCostTerm(std::make_unique<cost::PathLength>());
       alternatives->add(std::move(connect));
   }
   {
       auto connect{ std::make_unique<stages::Connect>(
            "trajectory duration", stages::Connect::GroupPlannerVector{ { "panda_arm", pipeline } }) };
       connect->setCostTerm(std::make_unique<cost::TrajectoryDuration>());
       alternatives->add(std::move(connect));
   }
   t.add(std::move(alternatives));

回退（Fallbacks）

回退容器按顺序执行子阶段，直到其中一个返回成功，或所有阶段都返回失败。示例——依次使用不同的求解器进行规划，直到获得成功解。

  auto cartesian = std::make_shared<solvers::CartesianPath>();
  auto ptp = std::make_shared<solvers::PipelinePlanner>(node, "pilz_industrial_motion_planner", "PTP")
  auto rrtconnect = std::make_shared<solvers::PipelinePlanner>(node, "ompl", "RRTConnectkConfigDefault")

  // fallbacks to reach target_state
  auto fallbacks = std::make_unique<Fallbacks>("move to other side");

  auto add_to_fallbacks{ [&](auto& solver, auto& name) {
       auto move_to = std::make_unique<stages::MoveTo>(name, solver);
       move_to->setGroup("panda_arm");
       move_to->setGoal(target_state);
       fallbacks->add(std::move(move_to));
   } };
  add_to_fallbacks(cartesian, "Cartesian path");
  add_to_fallbacks(ptp, "PTP path");
  add_to_fallbacks(rrtconnect, "RRT path");

合并器（Merger）

合并器容器用于组合多个不同的问题——即针对不同的规划组（planning group）进行并行规划。所有子阶段的解会被合并为单个解，以支持并行执行。示例——在将手臂移动到某个位置的同时打开夹爪。

  auto cartesian_planner = std::make_shared<solvers::CartesianPath>();
  const auto joint_interpolation_planner = std::make_shared<moveit::task_constructor::solvers::JointInterpolationPlanner>();

  auto merger = std::make_unique<Merger>("move arm and close gripper");

  auto move_relative = std::make_unique<moveit::task_constructor::stages::MoveRelative>("Approach", cartesian_planner);
   merger->add(std::move(move_relative));

  auto move_to =
     std::make_unique<moveit::task_constructor::stages::MoveTo>("close gripper", joint_interpolation_planner);

  merger->add(std::move(move_to));