diff --git a/create_multiple_bechmarks.sh b/create_multiple_bechmarks.sh
new file mode 100755
index 00000000..091ae302
--- /dev/null
+++ b/create_multiple_bechmarks.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+cd ~/MotionPlanningExplorerGUI/build
+
+make -j$(nproc) planner_standalone
+
+for filename in ../data/experiments/IJRR2020_FINAL/*.xml; do
+  ./planner_standalone $filename
+done
\ No newline at end of file
diff --git a/scripts/benchmarks/average_benchmark_to_pdf.py b/scripts/benchmarks/average_benchmark_to_pdf.py
new file mode 100644
index 00000000..8adf6a66
--- /dev/null
+++ b/scripts/benchmarks/average_benchmark_to_pdf.py
@@ -0,0 +1,187 @@
+import numpy as np
+import sys
+import re
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 30})
+plt.rcParams.update({'font.family': 'cmr'})
+
+from matplotlib.backends.backend_pdf import PdfPages
+from xml.dom.minidom import parse
+import os
+import glob
+
+def createBenchmark(folderName):
+  files = glob.glob(folderName + "/*.xml")
+
+  fname_pdf = folderName + "/average.pdf"
+  
+  meandData = None
+  runcount = 0
+  timelimit = 0
+  vnames = []
+  b_names = []
+  for file in files:
+    print(file)
+    benchmark_name, runcount, timelimit, vnames, vtimes = readXML(file)
+
+    b_names.append(benchmark_name)
+    #print("vtimes", vtimes)
+    #print(vtimes.shape)
+
+    if vtimes.shape[0]<=1:
+      vtimes = np.vstack((vtimes,vtimes))
+
+    means = np.mean(vtimes,axis=0)
+
+    #print("vtimes", vtimes)
+    #print("means", means)
+
+    if meandData is None:
+      meandData = np.zeros(means.shape)
+    meandData = meandData + means
+  
+  print("runcount", runcount)
+  print("timelimit", timelimit)
+  print("vnames",vnames)
+
+  #print("meandData", meandData)
+  meandData = meandData / len(files)
+  #print("meandData2" , meandData)
+  
+  timelimit = 1.25 * meandData.max()
+
+  #vnames = [w.replace('_', '\n') for w in vnames]
+
+  plotBenchmarks(fname_pdf, runcount, timelimit, vnames, meandData, b_names)
+
+###################################################################################
+#GET DATA
+###################################################################################
+def readXML(fname):
+  doc = parse(fname)
+  name = doc.getElementsByTagName("name")[0]
+
+  benchmark_name = name.firstChild.data
+  print("benchmark name", benchmark_name)
+
+  planners = doc.getElementsByTagName("planner")
+  nr_planners = int(doc.getElementsByTagName("number_of_planners")[0].firstChild.data)
+  runcount = int(doc.getElementsByTagName("run_count")[0].firstChild.data)
+  timelimit = float(doc.getElementsByTagName("max_time")[0].firstChild.data)
+  print ("planners:",nr_planners," runs:",runcount)
+
+  vtimes = np.zeros((runcount,nr_planners))
+  vnodes = np.zeros((runcount,nr_planners))
+  vsuccess = np.zeros((runcount,nr_planners))
+  vnames = []
+
+  p_ctr = 0
+  for planner in planners:
+    name = planner.getElementsByTagName("name")[0].firstChild.data
+
+    name = re.sub("([Ss]tar)", '*', name)
+
+    vnames.append(name)
+    runs = planner.getElementsByTagName("run")
+    c_ctr = 0
+    runtimes = []
+    for run in runs:
+      sid = run.getAttribute("number")
+      time = run.getElementsByTagName("time")[0].firstChild.data
+      nodes = run.getElementsByTagName("nodes")[0].firstChild.data
+      success = int(run.getElementsByTagName("success")[0].firstChild.data)
+      #print "run ",sid," time ",time," nodes ", nodes, " success ","No" if success==0 else "Yes"
+      vtimes[c_ctr,p_ctr] = time
+      vnodes[c_ctr,p_ctr] = nodes
+      vsuccess[c_ctr,p_ctr] = success
+      c_ctr=c_ctr+1
+    #print ("name:", name,  " time: ", np.mean(vtimes[:,p_ctr]), "+/-", np.std(vtimes[:,p_ctr]))
+    p_ctr=p_ctr+1
+  
+  return benchmark_name, runcount, timelimit, vnames, vtimes
+
+
+
+###################################################################################
+#PLOTTING
+###################################################################################
+
+
+def plotBenchmarks(fname_pdf, runcount, timelimit, vnames, means, benchmark_name):
+  pp = PdfPages(fname_pdf)
+  # fig = plt.figure(0)
+  fig = plt.figure(figsize=(20,10))
+  ax = fig.gca()
+  fig.patch.set_facecolor('white')
+  # ax.set_xlabel('Algorithm')
+  ax.set_ylim([0,timelimit+0.15*timelimit])
+  ax.set_ylabel('Time (s)')
+
+  #if vtimes.shape[0]<=1:
+    #vtimes = np.vstack((vtimes,vtimes))
+
+  #means = np.mean(vtimes,axis=0)
+
+  #if histogram:
+    #plt.boxplot(vtimes, notch=0, sym='k+', vert=1, whis=1.5)
+  #else:
+  print(means)
+  plt.bar(vnames, means)
+    # plt.boxplot(vtimes, notch=0, sym='k+', vert=1, whis=1.5)
+
+  plannerLabelRotation=85
+  xtickNames = plt.setp(ax,xticklabels=vnames)
+  plt.setp(xtickNames, rotation=plannerLabelRotation)
+
+  ###################################################################################
+  #max lowest mean value be visualized as bold
+  ###################################################################################
+  bestTimeIdx = means.argmin() # np.mean(vtimes,axis=0).argmin()
+  bestTime = means.min() # np.mean(vtimes,axis=0).min()
+  ##only if bestTime is unique
+  if bestTime < timelimit:
+    ctr = 0
+    for ticklabel in plt.gca().get_xticklabels():
+      if ctr == bestTimeIdx:
+        ticklabel.set_fontweight('extra bold')
+      ctr=ctr+1
+
+  ###################################################################################
+  #visualize timelimit and runcount in upper right corner
+  ###################################################################################
+  # txt = "runcount=%3.0d"%runcount
+  # ax.text(0.65, 0.96, txt, horizontalalignment='left', verticalalignment='center', transform = ax.transAxes)
+  # if timelimit < 1:
+  #   txt = "timelimit=%3.1f"%timelimit+"s"
+  # else:
+  #   txt = "timelimit=%3.0f"%timelimit+"s"
+  # ax.text(0.65, 0.9, txt, horizontalalignment='left', verticalalignment='center', transform = ax.transAxes)
+  ax.axhline(timelimit,color='k',linestyle='--')
+  txt = "[%3.0d run average]"%runcount
+  ax.text(0.65, 0.93, txt, horizontalalignment='left', verticalalignment='center', transform = ax.transAxes)
+  
+  benchmark_name_txt = ', '.join(benchmark_name)
+  plt.title(benchmark_name_txt)
+  ###################################################################################
+
+  plt.tight_layout()
+  pp.savefig(plt.gcf(), pad_inches=0.0, bbox_inches='tight')
+  pp.close()
+  plt.show()
+
+  cmd = "apvlv "+fname_pdf
+  os.system(cmd)
+
+
+
+
+
+
+
+
+
+
+if __name__ == '__main__':
+  folderName = "../../data/benchmarks/average_all"
+  createBenchmark(folderName)
+
diff --git a/scripts/benchmarks/benchmark_to_pdf.py b/scripts/benchmarks/benchmark_to_pdf.py
index 745994a6..36ca9244 100644
--- a/scripts/benchmarks/benchmark_to_pdf.py
+++ b/scripts/benchmarks/benchmark_to_pdf.py
@@ -2,12 +2,13 @@
 import sys
 import re
 import matplotlib.pyplot as plt
-plt.rcParams.update({'font.size': 30})
-plt.rcParams.update({'font.family': 'cmr'})
+plt.rcParams.update({'font.size': 22})
+#plt.rcParams.update({'font.family': 'cmr'})
 
 from matplotlib.backends.backend_pdf import PdfPages
 from xml.dom.minidom import parse
 import os
+import sys
 
 def XMLtoPDF(fname, histogram=False):
   fname_base, fname_ext = os.path.splitext(fname)
@@ -115,10 +116,11 @@ def XMLtoPDF(fname, histogram=False):
   plt.tight_layout()
   pp.savefig(plt.gcf(), pad_inches=0.0, bbox_inches='tight')
   pp.close()
-  plt.show()
+  #plt.show()
 
   cmd = "apvlv "+fname_pdf
-  os.system(cmd)
+  #os.system(cmd)
+  sys.exit(1)
 
 if __name__ == '__main__':
   Nargs = len(sys.argv)
@@ -128,12 +130,12 @@ def XMLtoPDF(fname, histogram=False):
       XMLtoPDF(fname)
   else:
     fname = "../../data/benchmarks/last.xml"
-    fname = "../../data/benchmarks/54D_octopus_2020_05_25_13:54:57.xml"
-    fname = "../../data/benchmarks/48D_SE3C_drones_2020_05_25_14:09:49.xml"
-    fname = "../../data/benchmarks/72D_SE2RN_R2_mobile_manipulators_2020_05_25_14:17:14.xml"
-    fname = "../../data/benchmarks/30D_airport_2020_05_25_14:37:03.xml"
-    fname = "../../data/benchmarks/24D_crossing_cars_2020_05_25_14:48:27.xml"
-    fname = "../../data/benchmarks/21D_box_folding_2020_05_25_14:56:05.xml"
-    fname = "../../data/benchmarks/37D_shadowhand_pregrasp_2020_05_25_15:13:32.xml"
+    #fname = "../../data/benchmarks/54D_octopus_2020_05_25_13:54:57.xml"
+    #fname = "../../data/benchmarks/48D_SE3C_drones_2020_05_25_14:09:49.xml"
+    #fname = "../../data/benchmarks/72D_SE2RN_R2_mobile_manipulators_2020_05_25_14:17:14.xml"
+    #fname = "../../data/benchmarks/30D_airport_2020_05_25_14:37:03.xml"
+    #fname = "../../data/benchmarks/24D_crossing_cars_2020_05_25_14:48:27.xml"
+    #fname = "../../data/benchmarks/21D_box_folding_2020_05_25_14:56:05.xml"
+    #fname = "../../data/benchmarks/37D_shadowhand_pregrasp_2020_05_25_15:13:32.xml"
     XMLtoPDF(fname)
 
diff --git a/src/planner/benchmark/benchmark_output.cpp b/src/planner/benchmark/benchmark_output.cpp
index 5844f275..812de64b 100644
--- a/src/planner/benchmark/benchmark_output.cpp
+++ b/src/planner/benchmark/benchmark_output.cpp
@@ -3,6 +3,7 @@
 #include <fstream>
 #include <boost/lexical_cast.hpp>
 #include <boost/filesystem.hpp>
+#include <stdlib.h>
 
 // struct CompleteExperiment
 // {
@@ -84,7 +85,7 @@ void BenchmarkOutput::PrintPDF()
     std::cout << "Cannot print PDF. No XML file loaded" << std::endl;
     return;
   }
-  std::string cmd = std::string("python ../scripts/benchmarks/benchmark_to_pdf.py ")+file;
+  std::string cmd = std::string("python3 ../scripts/benchmarks/benchmark_to_pdf.py ")+file;
   int rvalue = std::system(cmd.c_str());
 
   if(rvalue){
@@ -92,6 +93,7 @@ void BenchmarkOutput::PrintPDF()
   }else{
       std::cout << "### [ERROR] Benchmark to PDF failed" << std::endl;
   }
+  exit(0);
 }
 
 bool BenchmarkOutput::Save(TiXmlElement *node)
diff --git a/src/planner/strategy/strategy_geometric.cpp b/src/planner/strategy/strategy_geometric.cpp
index 38a58dca..625763e1 100644
--- a/src/planner/strategy/strategy_geometric.cpp
+++ b/src/planner/strategy/strategy_geometric.cpp
@@ -355,26 +355,341 @@ void StrategyGeometricMultiLevel::RunBenchmark(const StrategyInput& input)
 
         }
 
-        ob::PlannerPtr planner_k_i = GetPlanner(binput.algorithms.at(k), stratifications.at(i));
+        if(util::StartsWith(name_algorithm, "hierarchy:qmpk")){
 
-        std::string name_algorithm_strat = planner_k_i->getName()+"_(";
+          for ( unsigned int knn = 3; knn <= 19; knn += 2)
+          {
 
-        std::vector<ob::SpaceInformationPtr> si_vec_k = stratifications.at(i)->si_vec;
-        for(uint j = 0; j < si_vec_k.size(); j++){
-          if(j>=si_vec_k.size()-1 && shortStratification) break;
-          uint Nj = si_vec_k.at(j)->getStateDimension();
-          name_algorithm_strat += std::to_string(Nj);
-          if(j < si_vec_k.size()-1) name_algorithm_strat += "|";
+            ob::PlannerPtr planner_k_i = GetPlanner("hierarchy:qmp", stratifications.at(i));
+            planner_k_i->params().setParam("knn", std::to_string( knn ));
+
+            planner_k_i->as<og::QMP>()->setK(knn);
+
+            std::string name_algorithm_strat = planner_k_i->getName()+"_(";
+
+            std::vector<ob::SpaceInformationPtr> si_vec_k = stratifications.at(i)->si_vec;
+            for(uint j = 0; j < si_vec_k.size(); j++){
+              if(j>=si_vec_k.size()-1 && shortStratification) break;
+              uint Nj = si_vec_k.at(j)->getStateDimension();
+              name_algorithm_strat += std::to_string(Nj);
+              if(j < si_vec_k.size()-1) name_algorithm_strat += "|";
+            }
+            name_algorithm_strat += ")";
+
+            name_algorithm_strat += "(k_" + std::to_string( knn );
+            name_algorithm_strat += ")";
+
+            //if(stratifications.size() > 1)
+            {
+              planner_k_i->setName(name_algorithm_strat);
+            }
+            std::cout << "adding planner with ambient space " << si_vec_k.back()->getStateDimension() << std::endl;
+            benchmark.addPlanner(planner_k_i);
+            planner_ctr++;
+          }
+          
+        }
+        else if(util::StartsWith(name_algorithm, "hierarchy:metric")){
+
+          std::string algo_name = name_algorithm.replace(9,7,"");
+
+          std::cout << "distance metric benchmark algorithm  :  " << algo_name << std::endl;
+
+          
+          ob::PlannerPtr planner_k_geodesic = GetPlanner(algo_name, stratifications.at(i));
+
+          ob::PlannerPtr planner_k_shortestpath = GetPlanner(algo_name, stratifications.at(i));
+
+
+          if(name_algorithm.find("qrrt") != std::string::npos){
+            planner_k_geodesic->as<og::QRRT>()->setMetric("geodesic");
+            planner_k_shortestpath->as<og::QRRT>()->setMetric("shortestpath");
+          }
+          else if(name_algorithm.find("qrrtstar") != std::string::npos){
+            planner_k_geodesic->as<og::QRRTStar>()->setMetric("geodesic");
+            planner_k_shortestpath->as<og::QRRTStar>()->setMetric("shortestpath");
+          }
+          else if(name_algorithm.find("qmp") != std::string::npos){
+            planner_k_geodesic->as<og::QMP>()->setMetric("geodesic");
+            planner_k_shortestpath->as<og::QMP>()->setMetric("shortestpath");
+          }
+          else if(name_algorithm.find("qmpstar") != std::string::npos){
+            planner_k_geodesic->as<og::QMPStar>()->setMetric("geodesic");
+            planner_k_shortestpath->as<og::QMPStar>()->setMetric("shortestpath");
+          }
+          else if(name_algorithm.find("spqr") != std::string::npos){
+            planner_k_geodesic->as<og::SPQR>()->setMetric("geodesic");
+            planner_k_shortestpath->as<og::SPQR>()->setMetric("shortestpath");
+          }
+          
+          
+          std::string name_algorithm_strat = planner_k_geodesic->getName() ;//+ "_(";
+
+          std::vector<ob::SpaceInformationPtr> si_vec_k = stratifications.at(i)->si_vec;
+          /*for (uint j = 0; j < si_vec_k.size(); j++)
+          {
+            if (j >= si_vec_k.size() - 1 && shortStratification)
+              break;
+            uint Nj = si_vec_k.at(j)->getStateDimension();
+            name_algorithm_strat += std::to_string(Nj);
+            if (j < si_vec_k.size() - 1)
+              name_algorithm_strat += "|";
+          }
+          name_algorithm_strat += ")";*/
+
+          std::string name_algorithm_1 = name_algorithm_strat + "(intrinsic)";
+          std::string name_algorithm_2 = name_algorithm_strat + "(QS metric)";
+
+          planner_k_geodesic->setName(name_algorithm_1);
+          planner_k_shortestpath->setName(name_algorithm_2);
+          
+          std::cout << "adding planner with ambient space " << si_vec_k.back()->getStateDimension() << std::endl;
+          
+          
+          benchmark.addPlanner(planner_k_geodesic);
+          planner_ctr++;
+
+          benchmark.addPlanner(planner_k_shortestpath);
+          planner_ctr++;
+        }
+        else if(util::StartsWith(name_algorithm, "hierarchy:importance")){
+
+          std::string algo_name = name_algorithm.replace(9,11,"");
+
+          std::cout << "importance benchmark algorithm  :  " << algo_name << std::endl;
+
+          
+          ob::PlannerPtr planner_k_uniform = GetPlanner(algo_name, stratifications.at(i));
+
+          ob::PlannerPtr planner_k_greedy = GetPlanner(algo_name, stratifications.at(i));
+
+          ob::PlannerPtr planner_k_exponential = GetPlanner(algo_name, stratifications.at(i));
+
+
+          if(name_algorithm.find("qrrt") != std::string::npos){
+            planner_k_uniform->as<og::QRRT>()->setImportance("uniform");
+            planner_k_greedy->as<og::QRRT>()->setImportance("greedy");
+            planner_k_exponential->as<og::QRRT>()->setImportance("exponential");
+          }
+          else if(name_algorithm.find("qrrtstar") != std::string::npos){
+            planner_k_uniform->as<og::QRRTStar>()->setImportance("uniform");
+            planner_k_greedy->as<og::QRRTStar>()->setImportance("greedy");
+            planner_k_exponential->as<og::QRRTStar>()->setImportance("exponential");
+          }
+          else if(name_algorithm.find("qmp") != std::string::npos){
+            planner_k_uniform->as<og::QMP>()->setImportance("uniform");
+            planner_k_greedy->as<og::QMP>()->setImportance("greedy");
+            planner_k_exponential->as<og::QMP>()->setImportance("exponential");
+          }
+          else if(name_algorithm.find("qmpstar") != std::string::npos){
+            planner_k_uniform->as<og::QMPStar>()->setImportance("uniform");
+            planner_k_greedy->as<og::QMPStar>()->setImportance("greedy");
+            planner_k_exponential->as<og::QMPStar>()->setImportance("exponential");
+          }
+          else if(name_algorithm.find("spqr") != std::string::npos){
+            planner_k_uniform->as<og::SPQR>()->setImportance("uniform");
+            planner_k_greedy->as<og::SPQR>()->setImportance("greedy");
+            planner_k_exponential->as<og::SPQR>()->setImportance("exponential");
+          }
+          
+          
+          std::string name_algorithm_strat = planner_k_uniform->getName() ;//;//;//+ "_(";
+
+          std::vector<ob::SpaceInformationPtr> si_vec_k = stratifications.at(i)->si_vec;
+          /*for (uint j = 0; j < si_vec_k.size(); j++)
+          {
+            if (j >= si_vec_k.size() - 1 && shortStratification)
+              break;
+            uint Nj = si_vec_k.at(j)->getStateDimension();
+            name_algorithm_strat += std::to_string(Nj);
+            if (j < si_vec_k.size() - 1)
+              name_algorithm_strat += "|";
+          }
+          name_algorithm_strat += ")";*/
+
+          std::string name_algorithm_1 = name_algorithm_strat + "(uniform)";
+          std::string name_algorithm_2 = name_algorithm_strat + "(greedy)";
+          std::string name_algorithm_3 = name_algorithm_strat + "(exponential)";
+
+          planner_k_uniform->setName(name_algorithm_1);
+          planner_k_greedy->setName(name_algorithm_2);
+          planner_k_exponential->setName(name_algorithm_3);
+          
+          std::cout << "adding planner with ambient space " << si_vec_k.back()->getStateDimension() << std::endl;
+          
+          
+          benchmark.addPlanner(planner_k_uniform);
+          planner_ctr++;
+
+          benchmark.addPlanner(planner_k_greedy);
+          planner_ctr++;
+
+          benchmark.addPlanner(planner_k_exponential);
+          planner_ctr++;
         }
-        name_algorithm_strat += ")";
+        else if(util::StartsWith(name_algorithm, "hierarchy:GraphSampler")){
+
+          std::string algo_name = name_algorithm.replace(9,13,"");
+
+          std::cout << "Graph Sampler benchmark algorithm  :  " << algo_name << std::endl;
+
+          
+          ob::PlannerPtr planner_k_randomvertex = GetPlanner(algo_name, stratifications.at(i));
+
+          ob::PlannerPtr planner_k_randomedge = GetPlanner(algo_name, stratifications.at(i));
+
+          ob::PlannerPtr planner_k_randomdegreevertex = GetPlanner(algo_name, stratifications.at(i));
+
+
+          if(name_algorithm.find("qrrt") != std::string::npos){
+            planner_k_randomvertex->as<og::QRRT>()->setGraphSampler("randomvertex");
+            planner_k_randomedge->as<og::QRRT>()->setGraphSampler("randomedge");
+            planner_k_randomdegreevertex->as<og::QRRT>()->setGraphSampler("randomdegreevertex");
+          }
+          else if(name_algorithm.find("qrrtstar") != std::string::npos){
+            planner_k_randomvertex->as<og::QRRTStar>()->setGraphSampler("randomvertex");
+            planner_k_randomedge->as<og::QRRTStar>()->setGraphSampler("randomedge");
+            planner_k_randomdegreevertex->as<og::QRRTStar>()->setGraphSampler("randomdegreevertex");
+          }
+          else if(name_algorithm.find("qmp") != std::string::npos){
+            planner_k_randomvertex->as<og::QMP>()->setGraphSampler("randomvertex");
+            planner_k_randomedge->as<og::QMP>()->setGraphSampler("randomedge");
+            planner_k_randomdegreevertex->as<og::QMP>()->setGraphSampler("randomdegreevertex");
+          }
+          else if(name_algorithm.find("qmpstar") != std::string::npos){
+            planner_k_randomvertex->as<og::QMPStar>()->setGraphSampler("randomvertex");
+            planner_k_randomedge->as<og::QMPStar>()->setGraphSampler("randomedge");
+            planner_k_randomdegreevertex->as<og::QMPStar>()->setGraphSampler("randomdegreevertex");
+          }
+          else if(name_algorithm.find("spqr") != std::string::npos){
+            planner_k_randomvertex->as<og::SPQR>()->setGraphSampler("randomvertex");
+            planner_k_randomedge->as<og::SPQR>()->setGraphSampler("randomedge");
+            planner_k_randomdegreevertex->as<og::SPQR>()->setGraphSampler("randomdegreevertex");
+          }
+          
+          
+          std::string name_algorithm_strat = planner_k_randomvertex->getName(); //;//+ "_(";
+
+          std::vector<ob::SpaceInformationPtr> si_vec_k = stratifications.at(i)->si_vec;
+          /*for (uint j = 0; j < si_vec_k.size(); j++)
+          {
+            if (j >= si_vec_k.size() - 1 && shortStratification)
+              break;
+            uint Nj = si_vec_k.at(j)->getStateDimension();
+            name_algorithm_strat += std::to_string(Nj);
+            if (j < si_vec_k.size() - 1)
+              name_algorithm_strat += "|";
+          }
+          name_algorithm_strat += ")";*/
+
+          std::string name_algorithm_1 = name_algorithm_strat + "(randomvertex)";
+          std::string name_algorithm_2 = name_algorithm_strat + "(randomedge)";
+          std::string name_algorithm_3 = name_algorithm_strat + "(degreevertex)";
+
+          planner_k_randomvertex->setName(name_algorithm_1);
+          planner_k_randomedge->setName(name_algorithm_2);
+          planner_k_randomdegreevertex->setName(name_algorithm_3);
+          
+          std::cout << "adding planner with ambient space " << si_vec_k.back()->getStateDimension() << std::endl;
+          
+          
+          benchmark.addPlanner(planner_k_randomvertex);
+          planner_ctr++;
+
+          benchmark.addPlanner(planner_k_randomedge);
+          planner_ctr++;
+
+          benchmark.addPlanner(planner_k_randomdegreevertex);
+          planner_ctr++;
+        }
+        else if(util::StartsWith(name_algorithm, "hierarchy:FeasiblePathRestriction")){
+
+          std::string algo_name = name_algorithm.replace(9,24,"");
+
+          std::cout << "distance metric benchmark algorithm  :  " << algo_name << std::endl;
+
+          
+          ob::PlannerPtr planner_k_true = GetPlanner(algo_name, stratifications.at(i));
+
+          ob::PlannerPtr planner_k_false = GetPlanner(algo_name, stratifications.at(i));
+
+
+          if(name_algorithm.find("qrrt") != std::string::npos){
+            planner_k_true->as<og::QRRT>()->setFeasiblePathRestriction(true);
+            planner_k_false->as<og::QRRT>()->setFeasiblePathRestriction(false);
+          }
+          else if(name_algorithm.find("qrrtstar") != std::string::npos){
+            planner_k_true->as<og::QRRTStar>()->setFeasiblePathRestriction(true);
+            planner_k_false->as<og::QRRTStar>()->setFeasiblePathRestriction(false);
+          }
+          else if(name_algorithm.find("qmp") != std::string::npos){
+            planner_k_true->as<og::QMP>()->setFeasiblePathRestriction(true);
+            planner_k_false->as<og::QMP>()->setFeasiblePathRestriction(false);
+          }
+          else if(name_algorithm.find("qmpstar") != std::string::npos){
+            planner_k_true->as<og::QMPStar>()->setFeasiblePathRestriction(true);
+            planner_k_false->as<og::QMPStar>()->setFeasiblePathRestriction(false);
+          }
+          else if(name_algorithm.find("spqr") != std::string::npos){
+            planner_k_true->as<og::SPQR>()->setFeasiblePathRestriction(true);
+            planner_k_false->as<og::SPQR>()->setFeasiblePathRestriction(false);
+          }
+          
+          
+          std::string name_algorithm_strat = planner_k_true->getName() ;//+ "_(";
+
+          std::vector<ob::SpaceInformationPtr> si_vec_k = stratifications.at(i)->si_vec;
+         /* for (uint j = 0; j < si_vec_k.size(); j++)
+          {
+            if (j >= si_vec_k.size() - 1 && shortStratification)
+              break;
+            uint Nj = si_vec_k.at(j)->getStateDimension();
+            name_algorithm_strat += std::to_string(Nj);
+            if (j < si_vec_k.size() - 1)
+              name_algorithm_strat += "|";
+          }
+          name_algorithm_strat += ")";*/
+
+          std::string name_algorithm_1 = name_algorithm_strat + "(Find Section)";
+          std::string name_algorithm_2 = name_algorithm_strat + "(No Find Section)";
+
+          planner_k_true->setName(name_algorithm_1);
+          planner_k_false->setName(name_algorithm_2);
+          
+          std::cout << "adding planner with ambient space " << si_vec_k.back()->getStateDimension() << std::endl;
+          
+          
+          benchmark.addPlanner(planner_k_true);
+          planner_ctr++;
+
+          benchmark.addPlanner(planner_k_false);
+          planner_ctr++;
+        }
+        else {
+          
+
+          ob::PlannerPtr planner_k_i = GetPlanner(binput.algorithms.at(k), stratifications.at(i));
+
+          std::string name_algorithm_strat = planner_k_i->getName()+"_(";
+
+          std::vector<ob::SpaceInformationPtr> si_vec_k = stratifications.at(i)->si_vec;
+          for(uint j = 0; j < si_vec_k.size(); j++){
+            if(j>=si_vec_k.size()-1 && shortStratification) break;
+            uint Nj = si_vec_k.at(j)->getStateDimension();
+            name_algorithm_strat += std::to_string(Nj);
+            if(j < si_vec_k.size()-1) name_algorithm_strat += "|";
+          }
+          name_algorithm_strat += ")";
+
+          if(stratifications.size() > 1)
+          {
+            planner_k_i->setName(name_algorithm_strat);
+          }
+          std::cout << "adding planner with ambient space " << si_vec_k.back()->getStateDimension() << std::endl;
+          benchmark.addPlanner(planner_k_i);
+          planner_ctr++;
 
-        if(stratifications.size() > 1)
-        {
-          planner_k_i->setName(name_algorithm_strat);
         }
-        std::cout << "adding planner with ambient space " << si_vec_k.back()->getStateDimension() << std::endl;
-        benchmark.addPlanner(planner_k_i);
-        planner_ctr++;
       }
     }else{
       benchmark.addPlanner(GetPlanner(binput.algorithms.at(k), stratifications.at(0)));