diff --git a/nbs/04_hierarchy.ipynb b/nbs/04_hierarchy.ipynb
index ef14d917..9e2b99c3 100644
--- a/nbs/04_hierarchy.ipynb
+++ b/nbs/04_hierarchy.ipynb
@@ -1272,6 +1272,95 @@
     "        return plots_list\n",
     "\n",
     "    \n",
+    "\n",
+    "\n",
+    "                    \n",
+    "    ## run_from_file\n",
+    "    @classmethod\n",
+    "    def run_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, history=False, move=None, plots=None, hpct_verbose= False, \n",
+    "                    runs=None, plots_dir=None, early_termination = None, draw_file=None, experiment=None, log_experiment_figure=False, suffixes=False,\n",
+    "                    enhanced_environment_properties=None, title_prefix=\"\"):\n",
+    "        \n",
+    "        prp = PCTRunProperties()\n",
+    "        prp.load_db(filename)\n",
+    "        if experiment:\n",
+    "            config = prp.db.pop('config')\n",
+    "            experiment.log_parameters(prp.db)\n",
+    "            prp.db['config'] = config\n",
+    "            if 'environment_properties' in prp.db:\n",
+    "                if 'history' in  prp.db['environment_properties']:\n",
+    "                    ep = eval(prp.db['environment_properties'])\n",
+    "                    experiment.log_metric('history', ep['history'])\n",
+    "\n",
+    "        error_collector_type = prp.db['error_collector_type'].strip()\n",
+    "        error_response_type = prp.db['error_response_type']\n",
+    "        error_limit = eval(prp.db['error_limit'])\n",
+    "        if env_props is None:\n",
+    "            environment_properties = eval(prp.db['environment_properties'])\n",
+    "        else:\n",
+    "            environment_properties = env_props    \n",
+    "        error_properties = prp.get_error_properties()\n",
+    "\n",
+    "        if enhanced_environment_properties is not None:\n",
+    "            environment_properties = environment_properties | enhanced_environment_properties \n",
+    "            if environment_properties['dataset'] == 'test':\n",
+    "                error_properties[1][1] = environment_properties['initial']\n",
+    "        # print(environment_properties)\n",
+    "        if runs==None:\n",
+    "            runs = eval(prp.db['runs'])\n",
+    "        config = eval(prp.db['config'])\n",
+    "        if seed is None:\n",
+    "            seed = eval(prp.db['seed'])\n",
+    "        # print(f'Seed={seed}')\n",
+    "        if early_termination is None:\n",
+    "            early_termination = eval(prp.db['early_termination'])\n",
+    "\n",
+    "        hierarchy, score = cls.run_from_config(config, min=min, render=render,  error_collector_type=error_collector_type, error_response_type=error_response_type, \n",
+    "                                                error_properties=error_properties, error_limit=error_limit, steps=runs, hpct_verbose=hpct_verbose, history=history, \n",
+    "                                                environment_properties=environment_properties, seed=seed, early_termination=early_termination, move=move, plots=plots, \n",
+    "                                                suffixes=suffixes, plots_dir=plots_dir, draw_file=draw_file, experiment=experiment, log_experiment_figure=log_experiment_figure, \n",
+    "                                                title_prefix = title_prefix)\n",
+    "        \n",
+    "        return hierarchy, score \n",
+    "\n",
+    "    def run_hierarchy(self, render=False, steps=500, hpct_verbose=False):\n",
+    "        env = self.get_preprocessor()[0]\n",
+    "        env.set_render(render)\n",
+    "        if hpct_verbose:\n",
+    "            self.summary()\n",
+    "            print(self.formatted_config())\n",
+    "        self.run(steps, hpct_verbose)\n",
+    "        env.close()\n",
+    "\n",
+    "        score = self.get_environment_score() if self.get_environment_score() is not None else self.get_error_collector().error()\n",
+    "\n",
+    "        return score    \n",
+    " \n",
+    "    def draw_hierarchy(self,  draw_file=False, move=None, with_edge_labels=True, font_size=6, node_size=100, experiment=None, log_experiment_figure=False):\n",
+    "        # draw network file\n",
+    "        move = {} if move == None else move\n",
+    "        if experiment or draw_file:\n",
+    "            if log_experiment_figure:\n",
+    "                self.draw(file=draw_file, move=move, with_edge_labels=with_edge_labels, font_size=font_size, node_size=node_size, experiment=experiment)\n",
+    "            else:\n",
+    "                self.draw(file=draw_file, move=move, with_edge_labels=with_edge_labels, font_size=font_size, node_size=node_size)\n",
+    "            if draw_file:\n",
+    "                print(draw_file)\n",
+    "\n",
+    "    def plot_hierarchy(self, plots=None,\n",
+    "        history=False, plots_figsize=(15,4), plots_dir=None, experiment=None, title_prefix=\"\"):\n",
+    "        if history:\n",
+    "            if plots:\n",
+    "                plots = self.get_plots_config(plots, title_prefix)\n",
+    "                \n",
+    "                for plot in plots:\n",
+    "                    plotfile=None\n",
+    "                    if plots_dir:\n",
+    "                        plotfile = plots_dir + sep + plot['title'] + '-' + str(self.get_namespace()) + '.png'\n",
+    "                    fig = self.hierarchy_plots(title=plot['title'], plot_items=plot['plot_items'], figsize=plots_figsize, file=plotfile, experiment=experiment)\n",
+    "                    import matplotlib.pyplot as plt\n",
+    "                    plt.close(fig)  # Close the figure here\n",
+    "\n",
     "    @classmethod\n",
     "    def run_from_config(cls, config, min=None, render=False,  error_collector_type=None, error_response_type=None, \n",
     "        error_properties=None, error_limit=100, steps=500, hpct_verbose=False, early_termination=False, \n",
@@ -1326,59 +1415,8 @@
     "        return hierarchy, score    \n",
     "    \n",
     "\n",
-    "\n",
-    "                    \n",
-    "    ## run_from_file\n",
-    "    @classmethod\n",
-    "    def run_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, history=False, move=None, plots=None, hpct_verbose= False, \n",
-    "                    runs=None, plots_dir=None, early_termination = None, draw_file=None, experiment=None, log_experiment_figure=False, suffixes=False,\n",
-    "                    enhanced_environment_properties=None, title_prefix=\"\"):\n",
-    "        \n",
-    "        prp = PCTRunProperties()\n",
-    "        prp.load_db(filename)\n",
-    "        if experiment:\n",
-    "            config = prp.db.pop('config')\n",
-    "            experiment.log_parameters(prp.db)\n",
-    "            prp.db['config'] = config\n",
-    "            if 'environment_properties' in prp.db:\n",
-    "                if 'history' in  prp.db['environment_properties']:\n",
-    "                    ep = eval(prp.db['environment_properties'])\n",
-    "                    experiment.log_metric('history', ep['history'])\n",
-    "\n",
-    "        error_collector_type = prp.db['error_collector_type'].strip()\n",
-    "        error_response_type = prp.db['error_response_type']\n",
-    "        error_limit = eval(prp.db['error_limit'])\n",
-    "        if env_props is None:\n",
-    "            environment_properties = eval(prp.db['environment_properties'])\n",
-    "        else:\n",
-    "            environment_properties = env_props    \n",
-    "        error_properties = prp.get_error_properties()\n",
-    "\n",
-    "        if enhanced_environment_properties is not None:\n",
-    "            environment_properties = environment_properties | enhanced_environment_properties \n",
-    "            if environment_properties['dataset'] == 'test':\n",
-    "                error_properties[1][1] = environment_properties['initial']\n",
-    "        # print(environment_properties)\n",
-    "        if runs==None:\n",
-    "            runs = eval(prp.db['runs'])\n",
-    "        config = eval(prp.db['config'])\n",
-    "        if seed is None:\n",
-    "            seed = eval(prp.db['seed'])\n",
-    "        # print(f'Seed={seed}')\n",
-    "        if early_termination is None:\n",
-    "            early_termination = eval(prp.db['early_termination'])\n",
-    "\n",
-    "        hierarchy, score = cls.run_from_config(config, min=min, render=render,  error_collector_type=error_collector_type, error_response_type=error_response_type, \n",
-    "                                                error_properties=error_properties, error_limit=error_limit, steps=runs, hpct_verbose=hpct_verbose, history=history, \n",
-    "                                                environment_properties=environment_properties, seed=seed, early_termination=early_termination, move=move, plots=plots, \n",
-    "                                                suffixes=suffixes, plots_dir=plots_dir, draw_file=draw_file, experiment=experiment, log_experiment_figure=log_experiment_figure, \n",
-    "                                                title_prefix = title_prefix)\n",
-    "        \n",
-    "        return hierarchy, score \n",
-    "\n",
-    "\n",
     "    @classmethod\n",
-    "    def load_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, runs=None, early_termination = False, experiment=None,  hpct_verbose= False, history=False):\n",
+    "    def load_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, runs=None, early_termination = False, experiment=None,  hpct_verbose= False, history=False, additional_props=None):\n",
     "        \n",
     "        prp = PCTRunProperties()\n",
     "        prp.load_db(filename)\n",
@@ -1399,7 +1437,8 @@
     "        else:\n",
     "            environment_properties = env_props    \n",
     "        error_properties = prp.get_error_properties()\n",
-    "\n",
+    "        if additional_props:\n",
+    "            environment_properties.update(additional_props)\n",
     "        if runs==None:\n",
     "            runs = eval(prp.db['runs'])\n",
     "        config = eval(prp.db['config'])\n",
@@ -1413,7 +1452,7 @@
     "                                                error_properties=error_properties, error_limit=error_limit, hpct_verbose=hpct_verbose,  history=history,\n",
     "                                                environment_properties=environment_properties, seed=seed, early_termination=early_termination)\n",
     "        \n",
-    "        return hierarchy, env \n",
+    "        return hierarchy, env, environment_properties\n",
     "\n",
     "\n",
     "    @classmethod\n",
diff --git a/nbs/12_yaw_module.ipynb b/nbs/12_yaw_module.ipynb
index cf2c1eb2..08690e11 100644
--- a/nbs/12_yaw_module.ipynb
+++ b/nbs/12_yaw_module.ipynb
@@ -750,8 +750,10 @@
     "                                                      runs=None, plots_dir=outdir, early_termination=early, draw_file=draw_file, experiment=experiment, \n",
     "                                                      log_experiment_figure=log_experiment_figure, min=min)\n",
     "    else:\n",
-    "        hierarchy.run(steps=None, verbose=verbose)\n",
-    "        score = hierarchy.get_error_collector().error()\n",
+    "        score = hierarchy.run_hierarchy(render=False, hpct_verbose=verbose, steps=1000)\n",
+    "\n",
+    "        # hierarchy.run(steps=None, verbose=verbose)\n",
+    "        # score = hierarchy.get_error_collector().error()\n",
     "    \n",
     "    env = hierarchy.get_preprocessor()[0].env\n",
     "\n",
diff --git a/nbs/16_environment_processing.ipynb b/nbs/16_environment_processing.ipynb
index 333e553a..61ddd6b3 100644
--- a/nbs/16_environment_processing.ipynb
+++ b/nbs/16_environment_processing.ipynb
@@ -356,7 +356,7 @@
     "        else:\n",
     "            experiment = None\n",
     "\n",
-    "        self.start = printtime('Start')\n",
+    "\n",
     "        return experiment, None\n",
     "\n",
     "    def get_experiment_name(self):\n",
@@ -418,7 +418,8 @@
     "    def results(self, filepath=None, experiment=None, environment_properties=None, hierarchy=None):\n",
     "        plots=None\n",
     "        early=None\n",
-    "\n",
+    "        self.start = printtime('Start')\n",
+    "        \n",
     "        if 'log_testing_to_experiment' in self.args:\n",
     "            log_testing_to_experiment =  self.args['log_testing_to_experiment']\n",
     "        else:\n",
diff --git a/nbs/19_pct_examples.ipynb b/nbs/19_pct_examples.ipynb
index 2a49e7f0..04d76317 100644
--- a/nbs/19_pct_examples.ipynb
+++ b/nbs/19_pct_examples.ipynb
@@ -16,7 +16,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -35,7 +39,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| default_exp pct_examples"
@@ -44,7 +52,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -57,11 +69,16 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
-    "from pct.hierarchy import PCTHierarchy"
+    "from pct.hierarchy import PCTHierarchy\n",
+    "from pct.environment_processing import EnvironmentProcessingFactory"
    ]
   },
   {
@@ -76,7 +93,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -90,11 +111,12 @@
     "        env (Environment): The environment associated with the PCT hierarchy.\n",
     "    \"\"\"\n",
     "\n",
-    "    def __init__(self, config_file, min=True, early_termination=False, history=False):\n",
+    "    def __init__(self, config_file, min=True, early_termination=False, history=False, additional_props=None):\n",
     "        \"\"\"\n",
     "        Initializes the PCTExamples instance by loading the hierarchy from the given configuration file.\n",
     "        \"\"\"\n",
-    "        self.hierarchy, self.env = PCTHierarchy.load_from_file(config_file, min=min, early_termination=early_termination, history=history)\n",
+    "        self.config_file = config_file\n",
+    "        self.hierarchy, self.env, self.environment_properties = PCTHierarchy.load_from_file(config_file, min=min, early_termination=early_termination, history=history, additional_props=additional_props)\n",
     "        self.history_data = None\n",
     "        self.history = history\n",
     "\n",
@@ -128,7 +150,16 @@
     "        \"\"\"\n",
     "        self.hierarchy.get_preprocessor()[0].set_render(render)\n",
     "        return self.hierarchy.run(steps, verbose)\n",
-    "    \n",
+    "\n",
+    "    def results(self, verbose=False, args=None, environment_properties=None):\n",
+    "        print(self.environment_properties)\n",
+    "        env_name = self.env.get_name()\n",
+    "        env_proc = EnvironmentProcessingFactory.createEnvironmentProcessing(f'{env_name}EnvironmentProcessing')\n",
+    "        allargs={'drive':'', 'verbosed':{'hpct_verbose':verbose}, 'max': False} | args\n",
+    "        env_proc.set_properties(allargs)\n",
+    "        env_proc.results(filepath=self.config_file, environment_properties=self.environment_properties|environment_properties, hierarchy=self.hierarchy)\n",
+    "\n",
+    "\n",
     "    def close(self):\n",
     "        \"\"\"\n",
     "        Closes the environment.\n",
@@ -213,112 +244,52 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<__main__.PCTExamples object>\n",
-      "**************************\n",
-      "pcthierarchy PCTHierarchy [1, 2, 3, 2] e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "--------------------------\n",
-      "PRE: WindTurbine WindTurbine | 0 | links  Action1sgsm \n",
-      "IYE IndexedParameter | index 1 | -0.0 | links  WindTurbine \n",
-      "IWD IndexedParameter | index 2 | 0.0 | links  WindTurbine \n",
-      "IWS IndexedParameter | index 4 | 0.0 | links  WindTurbine \n",
-      "Level 0 Cols 1\n",
-      "L0C0 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL0C0sm SmoothWeightedSum | weights [0.54, -0.3] smooth 0.38 | -0.0 | links  OL1C0sm OL1C1sm \n",
-      "PER: PL0C0sm SmoothWeightedSum | weights [-1.56, -0.12, 0.6] smooth 0.45 | 0.0 | links  IYE IWD IWS \n",
-      "COM: CL0C0 Subtract | -0.0 | links  RL0C0sm PL0C0sm \n",
-      "OUT: OL0C0sm SmoothWeightedSum | weights [-0.11] smooth 0.44 | 0.0 | links  CL0C0 \n",
-      "----------------------------\n",
-      "Level 1 Cols 2\n",
-      "L1C0 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL1C0sm SmoothWeightedSum | weights [0.03, 0.87, 0.37] smooth 0.70 | 0.0 | links  OL3C0sm OL3C1sm OL2C2sm \n",
-      "PER: PL1C0sm SmoothWeightedSum | weights [0.71] smooth 0.39 | 0.0 | links  PL0C0sm \n",
-      "COM: CL1C0 Subtract | -0.0 | links  RL1C0sm PL1C0sm \n",
-      "OUT: OL1C0sm SmoothWeightedSum | weights [-0.14] smooth 0.94 | 0.0 | links  CL1C0 \n",
-      "----------------------------\n",
-      "L1C1 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL1C1sm SmoothWeightedSum | weights [-0.82, -0.18, -0.92] smooth 0.78 | 0.0 | links  OL3C0sm OL3C1sm OL2C2sm \n",
-      "PER: PL1C1sm SmoothWeightedSum | weights [-0.56] smooth 0.34 | -0.0 | links  PL0C0sm \n",
-      "COM: CL1C1 Subtract | 0.0 | links  RL1C1sm PL1C1sm \n",
-      "OUT: OL1C1sm SmoothWeightedSum | weights [0.16] smooth 0.54 | 0.0 | links  CL1C1 \n",
-      "----------------------------\n",
-      "Level 2 Cols 3\n",
-      "L2C01 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL2C0sm SmoothWeightedSum | weights [0.78, 0.31] smooth 0.35 | 0.0 | links  OL3C0sm OL3C1sm \n",
-      "PER: PL2C0sm SmoothWeightedSum | weights [-0.26, 0.03] smooth 0.83 | -0.0 | links  PL1C0sm PL1C1sm \n",
-      "COM: CL2C0 Subtract | 0.0 | links  RL2C0sm PL2C0sm \n",
-      "OUT: OL2C0sm SmoothWeightedSum | weights [0.48] smooth 0.81 | 0.0 | links  CL2C0 \n",
-      "----------------------------\n",
-      "L2C11 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL2C1sm SmoothWeightedSum | weights [-0.46, 0.92] smooth 0.49 | 0.0 | links  OL3C0sm OL3C1sm \n",
-      "PER: PL2C1sm SmoothWeightedSum | weights [-1.41, -0.45] smooth 0.73 | -0.0 | links  PL1C0sm PL1C1sm \n",
-      "COM: CL2C1 Subtract | 0.0 | links  RL2C1sm PL2C1sm \n",
-      "OUT: OL2C1sm SmoothWeightedSum | weights [1.59] smooth 0.52 | 0.0 | links  CL2C1 \n",
-      "----------------------------\n",
-      "L2C2 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL2C2sm SmoothWeightedSum | weights [0.73, 0.46] smooth 0.27 | 0.0 | links  OL3C0sm OL3C1sm \n",
-      "PER: PL2C2sm SmoothWeightedSum | weights [0.22, -0.03] smooth 0.83 | 0.0 | links  PL1C0sm PL1C1sm \n",
-      "COM: CL2C2 Subtract | -0.0 | links  RL2C2sm PL2C2sm \n",
-      "OUT: OL2C2sm SmoothWeightedSum | weights [0.26] smooth 0.08 | -0.0 | links  CL2C2 \n",
-      "----------------------------\n",
-      "Level 3 Cols 2\n",
-      "L3C0 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL3C0v Variable | -0.2629598007970895 \n",
-      "PER: PL3C0sm SmoothWeightedSum | weights [0.01, 0.26, 0.97] smooth 0.98 | -0.0 | links  PL2C0sm PL2C1sm PL2C2sm \n",
-      "COM: CL3C0 Subtract | -0.0 | links  RL3C0v PL3C0sm \n",
-      "OUT: OL3C0sm SmoothWeightedSum | weights [0.94] smooth 0.96 | -0.0 | links  CL3C0 \n",
-      "----------------------------\n",
-      "L3C1 PCTNode e2f84dda-beb4-11ef-a277-8cf8c5b8669e\n",
-      "----------------------------\n",
-      "REF: RL3C1v Variable | 0.740559685914173 \n",
-      "PER: PL3C1sm SmoothWeightedSum | weights [-0.59, 0.13, -0.44] smooth 0.97 | -0.0 | links  PL2C0sm PL2C1sm PL2C2sm \n",
-      "COM: CL3C1 Subtract | 0.0 | links  RL3C1v PL3C1sm \n",
-      "OUT: OL3C1sm SmoothWeightedSum | weights [1.58] smooth 0.52 | 0.0 | links  CL3C1 \n",
-      "----------------------------\n",
-      "POST: Action1sgsm SigmoidSmoothWeightedSum | weights [0.32] smooth 0.56 range 3.11  slope 10.53 | 0.0 | links  OL0C0sm \n",
-      "**************************\n",
-      "['WindTurbine', 'reward', 'IYE', 'IWD', 'IWS', 'Action1sgsm', 'RL0C0sm', 'PL0C0sm', 'CL0C0', 'OL0C0sm', 'RL1C0sm', 'PL1C0sm', 'CL1C0', 'OL1C0sm', 'RL1C1sm', 'PL1C1sm', 'CL1C1', 'OL1C1sm', 'RL2C0sm', 'PL2C0sm', 'CL2C0', 'OL2C0sm', 'RL2C1sm', 'PL2C1sm', 'CL2C1', 'OL2C1sm', 'RL2C2sm', 'PL2C2sm', 'CL2C2', 'OL2C2sm', 'RL3C0v', 'PL3C0sm', 'CL3C0', 'OL3C0sm', 'RL3C1v', 'PL3C1sm', 'CL3C1', 'OL3C1sm']\n"
+      "{'series': 'steady', 'zero_threshold': 1, 'reward_type': 'power', 'keep_history': True}\n",
+      "2024-12-20 18:41:16.960079 33944 Start\n",
+      "Score=-1362.401 power=1362.401\n",
+      "{'start': 1100, 'end': 2100, 'average yaw error_baseline_logs': 6.907099999999999, 'angle covered_trad_baseline_logs': 27.30000000000004, 'yaw count_trad_baseline_logs': 5, 'time_yawing_trad_baseline_logs': 0.43004300430043}\n",
+      "{'start': 1100, 'end': 2100, 'average yaw error_baseline_simu': 6.5231, 'angle covered_trad_baseline_simu': 53.46000000000012, 'yaw count_trad_baseline_simu': 15, 'time_yawing_trad_baseline_simu': 2.0502050205020503}\n",
+      "{'start_index': 1100, 'stop_index': 2100, 'power_trad': 1360.8065024307061, 'power_no_loss': 1394.8282594711568, 'power_control': 1362.4014711179545, 'average yaw error': 5.716155999999999, 'average reward': -1362.401471117955, 'angle covered': 33.0, 'yaw count': 5, 'time_yawing': 1.1011011011011012}\n",
+      "average_yaw_error_decrease_base=17.24\n",
+      "average_yaw_error_decrease_simu=12.37\n",
+      "energy_gain = 0.12\n",
+      "net_energy_gain = 0.14\n",
+      "2024-12-20 18:41:56.219797 33944 End\n",
+      "Elapsed time: 39.26\n"
      ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
     "#| gui\n",
     "# Example of how to use the PCTExamples class\n",
-    "pct = PCTExamples('testfiles/WindTurbine/ga--1362.401-s003-4x3-m005-WT0538-bddf277b0f729cc630efacf91b9f494f.properties', history=True)\n",
-    "pct.summary()\n",
-    "pct.run(1000)\n",
-    "print(pct.get_history_keys())\n",
-    "history_data = pct.set_history_data()\n",
-    "fig = pct.plot_single(plot={'plot_items': {'IWD': 'Direction', 'Action1sgsm': 'Output'}, 'title': 'Inputs'}, history_data=history_data)\n",
+    "pct = PCTExamples('testfiles/WindTurbine/ga--1362.401-s003-4x3-m005-WT0538-bddf277b0f729cc630efacf91b9f494f.properties', history=True, additional_props={'keep_history':True})\n",
+    "pct.results(args={'comparisons':True, 'comparisons_print_plots':False}, environment_properties={'keep_history':True, 'range': 'test'})\n",
+    "# pct.summary()\n",
+    "# pct.run(1000)\n",
+    "# print(pct.get_history_keys())\n",
+    "# history_data = pct.set_history_data()\n",
+    "# fig = pct.plot_single(plot={'plot_items': {'IWD': 'Direction', 'Action1sgsm': 'Output'}, 'title': 'Inputs'}, history_data=history_data)\n",
     "                \n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| gui\n",
@@ -328,14 +299,22 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": []
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| gui\n",
@@ -352,7 +331,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -384,7 +367,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "\n",
@@ -394,14 +381,22 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": []
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| hide\n",
@@ -411,7 +406,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": []
   }
diff --git a/pct/_modidx.py b/pct/_modidx.py
index 461bfc44..70523e05 100644
--- a/pct/_modidx.py
+++ b/pct/_modidx.py
@@ -1064,6 +1064,8 @@
                                'pct.hierarchy.PCTHierarchy.clear_values': ('hierarchy.html#pcthierarchy.clear_values', 'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.consolidate': ('hierarchy.html#pcthierarchy.consolidate', 'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.draw': ('hierarchy.html#pcthierarchy.draw', 'pct/hierarchy.py'),
+                               'pct.hierarchy.PCTHierarchy.draw_hierarchy': ( 'hierarchy.html#pcthierarchy.draw_hierarchy',
+                                                                              'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.error': ('hierarchy.html#pcthierarchy.error', 'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.formatted_config': ( 'hierarchy.html#pcthierarchy.formatted_config',
                                                                                 'pct/hierarchy.py'),
@@ -1140,6 +1142,8 @@
                                                                                 'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.load_from_file': ( 'hierarchy.html#pcthierarchy.load_from_file',
                                                                               'pct/hierarchy.py'),
+                               'pct.hierarchy.PCTHierarchy.plot_hierarchy': ( 'hierarchy.html#pcthierarchy.plot_hierarchy',
+                                                                              'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.remove_level': ('hierarchy.html#pcthierarchy.remove_level', 'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.remove_links': ('hierarchy.html#pcthierarchy.remove_links', 'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.remove_node': ('hierarchy.html#pcthierarchy.remove_node', 'pct/hierarchy.py'),
@@ -1156,6 +1160,8 @@
                                                                                'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.run_from_file': ( 'hierarchy.html#pcthierarchy.run_from_file',
                                                                              'pct/hierarchy.py'),
+                               'pct.hierarchy.PCTHierarchy.run_hierarchy': ( 'hierarchy.html#pcthierarchy.run_hierarchy',
+                                                                             'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.save': ('hierarchy.html#pcthierarchy.save', 'pct/hierarchy.py'),
                                'pct.hierarchy.PCTHierarchy.set_error_collector': ( 'hierarchy.html#pcthierarchy.set_error_collector',
                                                                                    'pct/hierarchy.py'),
@@ -1323,6 +1329,7 @@
                                                                                  'pct/pct_examples.py'),
                                   'pct.pct_examples.PCTExamples.plot_single': ( 'pct_examples.html#pctexamples.plot_single',
                                                                                 'pct/pct_examples.py'),
+                                  'pct.pct_examples.PCTExamples.results': ('pct_examples.html#pctexamples.results', 'pct/pct_examples.py'),
                                   'pct.pct_examples.PCTExamples.run': ('pct_examples.html#pctexamples.run', 'pct/pct_examples.py'),
                                   'pct.pct_examples.PCTExamples.set_history_data': ( 'pct_examples.html#pctexamples.set_history_data',
                                                                                      'pct/pct_examples.py'),
diff --git a/pct/environment_processing.py b/pct/environment_processing.py
index 9acf5c50..01700a04 100644
--- a/pct/environment_processing.py
+++ b/pct/environment_processing.py
@@ -269,7 +269,7 @@ def get_experiment(self):
         else:
             experiment = None
 
-        self.start = printtime('Start')
+
         return experiment, None
 
     def get_experiment_name(self):
@@ -318,7 +318,8 @@ def get_workspace(self):
     def results(self, filepath=None, experiment=None, environment_properties=None, hierarchy=None):
         plots=None
         early=None
-
+        self.start = printtime('Start')
+        
         if 'log_testing_to_experiment' in self.args:
             log_testing_to_experiment =  self.args['log_testing_to_experiment']
         else:
diff --git a/pct/hierarchy.py b/pct/hierarchy.py
index 53912abf..536c4ffb 100644
--- a/pct/hierarchy.py
+++ b/pct/hierarchy.py
@@ -1202,6 +1202,95 @@ def create_plot_item(func1, func2=None, ptitle=None):
         return plots_list
 
     
+
+
+                    
+    ## run_from_file
+    @classmethod
+    def run_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, history=False, move=None, plots=None, hpct_verbose= False, 
+                    runs=None, plots_dir=None, early_termination = None, draw_file=None, experiment=None, log_experiment_figure=False, suffixes=False,
+                    enhanced_environment_properties=None, title_prefix=""):
+        
+        prp = PCTRunProperties()
+        prp.load_db(filename)
+        if experiment:
+            config = prp.db.pop('config')
+            experiment.log_parameters(prp.db)
+            prp.db['config'] = config
+            if 'environment_properties' in prp.db:
+                if 'history' in  prp.db['environment_properties']:
+                    ep = eval(prp.db['environment_properties'])
+                    experiment.log_metric('history', ep['history'])
+
+        error_collector_type = prp.db['error_collector_type'].strip()
+        error_response_type = prp.db['error_response_type']
+        error_limit = eval(prp.db['error_limit'])
+        if env_props is None:
+            environment_properties = eval(prp.db['environment_properties'])
+        else:
+            environment_properties = env_props    
+        error_properties = prp.get_error_properties()
+
+        if enhanced_environment_properties is not None:
+            environment_properties = environment_properties | enhanced_environment_properties 
+            if environment_properties['dataset'] == 'test':
+                error_properties[1][1] = environment_properties['initial']
+        # print(environment_properties)
+        if runs==None:
+            runs = eval(prp.db['runs'])
+        config = eval(prp.db['config'])
+        if seed is None:
+            seed = eval(prp.db['seed'])
+        # print(f'Seed={seed}')
+        if early_termination is None:
+            early_termination = eval(prp.db['early_termination'])
+
+        hierarchy, score = cls.run_from_config(config, min=min, render=render,  error_collector_type=error_collector_type, error_response_type=error_response_type, 
+                                                error_properties=error_properties, error_limit=error_limit, steps=runs, hpct_verbose=hpct_verbose, history=history, 
+                                                environment_properties=environment_properties, seed=seed, early_termination=early_termination, move=move, plots=plots, 
+                                                suffixes=suffixes, plots_dir=plots_dir, draw_file=draw_file, experiment=experiment, log_experiment_figure=log_experiment_figure, 
+                                                title_prefix = title_prefix)
+        
+        return hierarchy, score 
+
+    def run_hierarchy(self, render=False, steps=500, hpct_verbose=False):
+        env = self.get_preprocessor()[0]
+        env.set_render(render)
+        if hpct_verbose:
+            self.summary()
+            print(self.formatted_config())
+        self.run(steps, hpct_verbose)
+        env.close()
+
+        score = self.get_environment_score() if self.get_environment_score() is not None else self.get_error_collector().error()
+
+        return score    
+ 
+    def draw_hierarchy(self,  draw_file=False, move=None, with_edge_labels=True, font_size=6, node_size=100, experiment=None, log_experiment_figure=False):
+        # draw network file
+        move = {} if move == None else move
+        if experiment or draw_file:
+            if log_experiment_figure:
+                self.draw(file=draw_file, move=move, with_edge_labels=with_edge_labels, font_size=font_size, node_size=node_size, experiment=experiment)
+            else:
+                self.draw(file=draw_file, move=move, with_edge_labels=with_edge_labels, font_size=font_size, node_size=node_size)
+            if draw_file:
+                print(draw_file)
+
+    def plot_hierarchy(self, plots=None,
+        history=False, plots_figsize=(15,4), plots_dir=None, experiment=None, title_prefix=""):
+        if history:
+            if plots:
+                plots = self.get_plots_config(plots, title_prefix)
+                
+                for plot in plots:
+                    plotfile=None
+                    if plots_dir:
+                        plotfile = plots_dir + sep + plot['title'] + '-' + str(self.get_namespace()) + '.png'
+                    fig = self.hierarchy_plots(title=plot['title'], plot_items=plot['plot_items'], figsize=plots_figsize, file=plotfile, experiment=experiment)
+                    import matplotlib.pyplot as plt
+                    plt.close(fig)  # Close the figure here
+
     @classmethod
     def run_from_config(cls, config, min=None, render=False,  error_collector_type=None, error_response_type=None, 
         error_properties=None, error_limit=100, steps=500, hpct_verbose=False, early_termination=False, 
@@ -1256,59 +1345,8 @@ def run_from_config(cls, config, min=None, render=False,  error_collector_type=N
         return hierarchy, score    
     
 
-
-                    
-    ## run_from_file
-    @classmethod
-    def run_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, history=False, move=None, plots=None, hpct_verbose= False, 
-                    runs=None, plots_dir=None, early_termination = None, draw_file=None, experiment=None, log_experiment_figure=False, suffixes=False,
-                    enhanced_environment_properties=None, title_prefix=""):
-        
-        prp = PCTRunProperties()
-        prp.load_db(filename)
-        if experiment:
-            config = prp.db.pop('config')
-            experiment.log_parameters(prp.db)
-            prp.db['config'] = config
-            if 'environment_properties' in prp.db:
-                if 'history' in  prp.db['environment_properties']:
-                    ep = eval(prp.db['environment_properties'])
-                    experiment.log_metric('history', ep['history'])
-
-        error_collector_type = prp.db['error_collector_type'].strip()
-        error_response_type = prp.db['error_response_type']
-        error_limit = eval(prp.db['error_limit'])
-        if env_props is None:
-            environment_properties = eval(prp.db['environment_properties'])
-        else:
-            environment_properties = env_props    
-        error_properties = prp.get_error_properties()
-
-        if enhanced_environment_properties is not None:
-            environment_properties = environment_properties | enhanced_environment_properties 
-            if environment_properties['dataset'] == 'test':
-                error_properties[1][1] = environment_properties['initial']
-        # print(environment_properties)
-        if runs==None:
-            runs = eval(prp.db['runs'])
-        config = eval(prp.db['config'])
-        if seed is None:
-            seed = eval(prp.db['seed'])
-        # print(f'Seed={seed}')
-        if early_termination is None:
-            early_termination = eval(prp.db['early_termination'])
-
-        hierarchy, score = cls.run_from_config(config, min=min, render=render,  error_collector_type=error_collector_type, error_response_type=error_response_type, 
-                                                error_properties=error_properties, error_limit=error_limit, steps=runs, hpct_verbose=hpct_verbose, history=history, 
-                                                environment_properties=environment_properties, seed=seed, early_termination=early_termination, move=move, plots=plots, 
-                                                suffixes=suffixes, plots_dir=plots_dir, draw_file=draw_file, experiment=experiment, log_experiment_figure=log_experiment_figure, 
-                                                title_prefix = title_prefix)
-        
-        return hierarchy, score 
-
-
     @classmethod
-    def load_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, runs=None, early_termination = False, experiment=None,  hpct_verbose= False, history=False):
+    def load_from_file(cls, filename, min=None, env_props=None, seed=None, render=False, runs=None, early_termination = False, experiment=None,  hpct_verbose= False, history=False, additional_props=None):
         
         prp = PCTRunProperties()
         prp.load_db(filename)
@@ -1329,7 +1367,8 @@ def load_from_file(cls, filename, min=None, env_props=None, seed=None, render=Fa
         else:
             environment_properties = env_props    
         error_properties = prp.get_error_properties()
-
+        if additional_props:
+            environment_properties.update(additional_props)
         if runs==None:
             runs = eval(prp.db['runs'])
         config = eval(prp.db['config'])
@@ -1343,7 +1382,7 @@ def load_from_file(cls, filename, min=None, env_props=None, seed=None, render=Fa
                                                 error_properties=error_properties, error_limit=error_limit, hpct_verbose=hpct_verbose,  history=history,
                                                 environment_properties=environment_properties, seed=seed, early_termination=early_termination)
         
-        return hierarchy, env 
+        return hierarchy, env, environment_properties
 
 
     @classmethod
diff --git a/pct/pct_examples.py b/pct/pct_examples.py
index 97e278d1..3f2da824 100644
--- a/pct/pct_examples.py
+++ b/pct/pct_examples.py
@@ -12,6 +12,7 @@
 
 # %% ../nbs/19_pct_examples.ipynb 4
 from .hierarchy import PCTHierarchy
+from .environment_processing import EnvironmentProcessingFactory
 
 # %% ../nbs/19_pct_examples.ipynb 6
 class PCTExamples:
@@ -24,11 +25,12 @@ class PCTExamples:
         env (Environment): The environment associated with the PCT hierarchy.
     """
 
-    def __init__(self, config_file, min=True, early_termination=False, history=False):
+    def __init__(self, config_file, min=True, early_termination=False, history=False, additional_props=None):
         """
         Initializes the PCTExamples instance by loading the hierarchy from the given configuration file.
         """
-        self.hierarchy, self.env = PCTHierarchy.load_from_file(config_file, min=min, early_termination=early_termination, history=history)
+        self.config_file = config_file
+        self.hierarchy, self.env, self.environment_properties = PCTHierarchy.load_from_file(config_file, min=min, early_termination=early_termination, history=history, additional_props=additional_props)
         self.history_data = None
         self.history = history
 
@@ -62,7 +64,16 @@ def run(self, steps=1, verbose=False, render=False):
         """
         self.hierarchy.get_preprocessor()[0].set_render(render)
         return self.hierarchy.run(steps, verbose)
-    
+
+    def results(self, verbose=False, args=None, environment_properties=None):
+        print(self.environment_properties)
+        env_name = self.env.get_name()
+        env_proc = EnvironmentProcessingFactory.createEnvironmentProcessing(f'{env_name}EnvironmentProcessing')
+        allargs={'drive':'', 'verbosed':{'hpct_verbose':verbose}, 'max': False} | args
+        env_proc.set_properties(allargs)
+        env_proc.results(filepath=self.config_file, environment_properties=self.environment_properties|environment_properties, hierarchy=self.hierarchy)
+
+
     def close(self):
         """
         Closes the environment.
diff --git a/pct/yaw_module.py b/pct/yaw_module.py
index a4b6b753..13599e30 100644
--- a/pct/yaw_module.py
+++ b/pct/yaw_module.py
@@ -626,8 +626,10 @@ def test_hpct_wind(file=None,plots=None,history=None,verbose=None,outdir=None,ea
                                                       runs=None, plots_dir=outdir, early_termination=early, draw_file=draw_file, experiment=experiment, 
                                                       log_experiment_figure=log_experiment_figure, min=min)
     else:
-        hierarchy.run(steps=None, verbose=verbose)
-        score = hierarchy.get_error_collector().error()
+        score = hierarchy.run_hierarchy(render=False, hpct_verbose=verbose, steps=1000)
+
+        # hierarchy.run(steps=None, verbose=verbose)
+        # score = hierarchy.get_error_collector().error()
     
     env = hierarchy.get_preprocessor()[0].env