[issue1208] Remove old task transformation code

src/search/CMakeLists.txt

@@ -97,6 +97,7 @@ create_fast_downward_library(
         evaluation_context
         evaluation_result
         evaluator
+        evaluator_call
         evaluator_cache
         heuristic
         open_list
@@ -348,13 +349,32 @@ create_fast_downward_library(
     DEPENDENCY_ONLY
 )
 
+create_fast_downward_library(
+    NAME state_forwarding_evaluator
+    HELP "Evaluator that uses a transformed task with the same set of states"
+    SOURCES
+        evaluators/state_forwarding_evaluator
+)
+
+create_fast_downward_library(
+    NAME axiom_handling_evaluator
+    HELP "Evaluator modifying axioms to handle negative values"
+    SOURCES
+        evaluators/axiom_handling_evaluator
+    DEPENDS
+        default_value_axioms_task
+        state_forwarding_evaluator
+        task_properties
+)
+
 create_fast_downward_library(
     NAME modify_costs_evaluator
     HELP "Evaluator modifying the costs"
     SOURCES
         evaluators/modify_costs_evaluator
     DEPENDS
         core_tasks
+        state_forwarding_evaluator
         task_properties
 )
 
@@ -731,7 +751,7 @@ create_fast_downward_library(
     SOURCES
         tasks/cost_adapted_task
         tasks/delegating_task
-        tasks/root_task
+        tasks/explicit_task
     CORE_LIBRARY
 )
 

src/search/cartesian_abstractions/additive_cartesian_heuristic.cc

@@ -44,8 +44,7 @@ AdditiveCartesianHeuristic::AdditiveCartesianHeuristic(
           use_general_costs, random_seed, log)) {
 }
 
-int AdditiveCartesianHeuristic::compute_heuristic(const State &ancestor_state) {
-    State state = convert_ancestor_state(ancestor_state);
+int AdditiveCartesianHeuristic::compute_heuristic(const State &state) {
     int sum_h = 0;
     for (const CartesianHeuristicFunction &function : heuristic_functions) {
         int value = function.get_value(state);

src/search/cartesian_abstractions/additive_cartesian_heuristic.h

@@ -18,7 +18,7 @@ class AdditiveCartesianHeuristic : public Heuristic {
     const std::vector<CartesianHeuristicFunction> heuristic_functions;
 
 protected:
-    virtual int compute_heuristic(const State &ancestor_state) override;
+    virtual int compute_heuristic(const State &state) override;
 
 public:
     AdditiveCartesianHeuristic(

src/search/cartesian_abstractions/split_selector.cc

@@ -19,8 +19,8 @@ SplitSelector::SplitSelector(
     : task(task), task_proxy(*task), pick(pick) {
     if (pick == PickSplit::MIN_HADD || pick == PickSplit::MAX_HADD) {
         additive_heuristic = make_unique<additive_heuristic::AdditiveHeuristic>(
-            task, tasks::AxiomHandlingType::APPROXIMATE_NEGATIVE, false,
-            "h^add within CEGAR abstractions", utils::Verbosity::SILENT);
+            task, false, "h^add within CEGAR abstractions",
+            utils::Verbosity::SILENT);
         additive_heuristic->compute_heuristic_for_cegar(
             task_proxy.get_initial_state());
     }

src/search/cartesian_abstractions/subtask_generators.cc

@@ -35,8 +35,8 @@ class SortFactsByIncreasingHaddValues {
     explicit SortFactsByIncreasingHaddValues(
         const shared_ptr<AbstractTask> &task)
         : hadd(make_unique<additive_heuristic::AdditiveHeuristic>(
-              task, tasks::AxiomHandlingType::APPROXIMATE_NEGATIVE, false,
-              "h^add within CEGAR abstractions", utils::Verbosity::SILENT)) {
+              task, false, "h^add within CEGAR abstractions",
+              utils::Verbosity::SILENT)) {
         TaskProxy task_proxy(*task);
         hadd->compute_heuristic_for_cegar(task_proxy.get_initial_state());
     }

src/search/evaluation_context.cc

@@ -2,6 +2,7 @@
 
 #include "evaluation_result.h"
 #include "evaluator.h"
+#include "evaluator_call.h"
 #include "search_statistics.h"
 
 #include <cassert>
@@ -27,6 +28,13 @@ EvaluationContext::EvaluationContext(
           calculate_preferred) {
 }
 
+EvaluationContext::EvaluationContext(
+    const EvaluationContext &other, const State &state)
+    : EvaluationContext(
+          EvaluatorCache(), state, other.g_value, other.preferred,
+          other.statistics, other.calculate_preferred) {
+}
+
 EvaluationContext::EvaluationContext(
     const State &state, int g_value, bool is_preferred,
     SearchStatistics *statistics, bool calculate_preferred)
@@ -43,21 +51,22 @@ EvaluationContext::EvaluationContext(
 }
 
 const EvaluationResult &EvaluationContext::get_result(Evaluator *evaluator) {
-    EvaluationResult &result = cache[evaluator];
-    if (result.is_uninitialized()) {
-        result = evaluator->compute_result(*this);
-        if (statistics && evaluator->is_used_for_counting_evaluations() &&
-            result.get_count_evaluation()) {
-            statistics->inc_evaluations();
-        }
-    }
-    return result;
+    EvaluatorCall call(*this, state);
+    return call[evaluator];
 }
 
 const EvaluatorCache &EvaluationContext::get_cache() const {
     return cache;
 }
 
+EvaluatorCache &EvaluationContext::get_cache() {
+    return cache;
+}
+
+SearchStatistics *EvaluationContext::get_statistics() {
+    return statistics;
+}
+
 const State &EvaluationContext::get_state() const {
     return state;
 }

src/search/evaluation_context.h

@@ -6,8 +6,6 @@
 #include "operator_id.h"
 #include "task_proxy.h"
 
-#include <unordered_map>
-
 class Evaluator;
 class SearchStatistics;
 
@@ -64,6 +62,19 @@ class EvaluationContext {
     EvaluationContext(
         const EvaluationContext &other, int g_value, bool is_preferred,
         SearchStatistics *statistics, bool calculate_preferred = false);
+    /*
+      Create new heuristic cache for caching heuristic values but copy other
+      information from the other evaluation context. This is only supposed to
+      be used by task-transforming evaluators that want to call nested
+      evaluators with a converted state, while still using the original
+      statistics. Starting from an empty cache is correct in this case:
+      all nested evaluators will use the transformed task or further
+      transformations of it while all other evaluators used outside of the
+      transforming evaluator do not have access to the transformed task. This
+      implies that cached values used in the scope of the transforming evaluator
+      are disjoint from any cached values used outside of this scope.
+     */
+    EvaluationContext(const EvaluationContext &other, const State &state);
     /*
       Create new heuristic cache for caching heuristic values. Used for example
       by eager search.
@@ -89,6 +100,8 @@ class EvaluationContext {
 
     const EvaluationResult &get_result(Evaluator *eval);
     const EvaluatorCache &get_cache() const;
+    EvaluatorCache &get_cache();
+    SearchStatistics *get_statistics();
     const State &get_state() const;
     int get_g_value() const;
     bool is_preferred() const;

src/search/evaluator.h

@@ -8,7 +8,7 @@
 
 #include <set>
 
-class EvaluationContext;
+class EvaluatorCall;
 class State;
 
 namespace plugins {
@@ -50,12 +50,17 @@ class Evaluator : public components::TaskSpecificComponent {
     virtual void get_path_dependent_evaluators(
         std::set<Evaluator *> &evals) = 0;
 
-    virtual void notify_initial_state(const State & /*initial_state*/) {
+    virtual void notify_initial_state(const State &initial_state) {
+        assert(initial_state.get_task() == TaskProxy(*task));
+        utils::unused_variable(initial_state);
     }
 
     virtual void notify_state_transition(
-        const State & /*parent_state*/, OperatorID /*op_id*/,
-        const State & /*state*/) {
+        const State &parent_state, OperatorID /*op_id*/, const State &state) {
+        assert(parent_state.get_task() == TaskProxy(*task));
+        assert(state.get_task() == TaskProxy(*task));
+        utils::unused_variable(parent_state);
+        utils::unused_variable(state);
     }
 
     /*
@@ -78,8 +83,7 @@ class Evaluator : public components::TaskSpecificComponent {
       EvaluationContext. We need to think of a clean way to achieve
       this.
     */
-    virtual EvaluationResult compute_result(
-        EvaluationContext &eval_context) = 0;
+    virtual EvaluationResult compute_result(EvaluatorCall &call) = 0;
 
     void report_value_for_initial_state(const EvaluationResult &result) const;
     void report_new_minimum_value(const EvaluationResult &result) const;

src/search/evaluator_call.cc

@@ -0,0 +1,45 @@
+#include "evaluator_call.h"
+
+#include "evaluation_context.h"
+#include "evaluation_result.h"
+#include "evaluator.h"
+#include "evaluator_cache.h"
+#include "search_statistics.h"
+#include "task_proxy.h"
+
+EvaluatorCall::EvaluatorCall(EvaluationContext &context, const State &state)
+    : context(context), state(state) {
+}
+
+const EvaluationResult &EvaluatorCall::operator[](Evaluator *evaluator) {
+    EvaluationResult &result = context.get_cache()[evaluator];
+    if (result.is_uninitialized()) {
+        SearchStatistics *statistics = context.get_statistics();
+        result = evaluator->compute_result(*this);
+        if (statistics && evaluator->is_used_for_counting_evaluations() &&
+            result.get_count_evaluation()) {
+            statistics->inc_evaluations();
+        }
+    }
+    return result;
+}
+
+EvaluatorCall EvaluatorCall::get_subcall(const State &state) const {
+    return EvaluatorCall(context, state);
+}
+
+const State &EvaluatorCall::get_state() const {
+    return state;
+}
+
+int EvaluatorCall::get_g_value() const {
+    return context.get_g_value();
+}
+
+bool EvaluatorCall::get_calculate_preferred() const {
+    return context.get_calculate_preferred();
+}
+
+bool EvaluatorCall::is_preferred() const {
+    return context.is_preferred();
+}

src/search/evaluator_call.h

@@ -0,0 +1,23 @@
+#ifndef EVALUATOR_CALL_H
+#define EVALUATOR_CALL_H
+
+class EvaluationContext;
+class EvaluationResult;
+class Evaluator;
+class State;
+
+class EvaluatorCall {
+    EvaluationContext &context;
+    const State &state;
+public:
+    EvaluatorCall(EvaluationContext &context, const State &state);
+    const EvaluationResult &operator[](Evaluator *evaluator);
+
+    EvaluatorCall get_subcall(const State &state) const;
+    const State &get_state() const;
+    int get_g_value() const;
+    bool get_calculate_preferred() const;
+    bool is_preferred() const;
+};
+
+#endif

src/search/evaluators/axiom_handling_evaluator.cc

@@ -0,0 +1,51 @@
+#include "axiom_handling_evaluator.h"
+
+#include "state_forwarding_evaluator.h"
+
+#include "../evaluation_context.h"
+
+#include "../task_utils/task_properties.h"
+
+using namespace std;
+
+namespace axiom_handling_evaluator {
+shared_ptr<Evaluator>
+TaskIndependentAxiomHandlingEvaluator::create_task_specific_component(
+    const shared_ptr<AbstractTask> &task) const {
+    TaskProxy proxy(*task);
+    if (task_properties::has_axioms(proxy)) {
+        shared_ptr<AbstractTask> axioms_task =
+            make_shared<tasks::DefaultValueAxiomsTask>(task, axioms);
+        shared_ptr<Evaluator> eval = nested->bind_task(axioms_task);
+        return make_shared<
+            state_forwarding_evaluator::StateForwardingEvaluator>(
+            task, axioms_task, eval, description, verbosity);
+    } else {
+        /*
+          If the task has no axioms, there is no need to wrap the evaluator
+          and we can bind the unmodified task to the nested evaluator directly.
+        */
+        return nested->bind_task(task);
+    }
+}
+
+TaskIndependentAxiomHandlingEvaluator::TaskIndependentAxiomHandlingEvaluator(
+    shared_ptr<TaskIndependentEvaluator> nested,
+    tasks::AxiomHandlingType axioms, const string &description,
+    utils::Verbosity verbosity)
+    : nested(move(nested)),
+      axioms(axioms),
+      description(description),
+      verbosity(verbosity) {
+}
+
+shared_ptr<TaskIndependentEvaluator> wrap_in_axiom_handling_evaluator(
+    const shared_ptr<TaskIndependentEvaluator> &eval,
+    const plugins::Options &opts) {
+    return components::make_shared_from_arg_tuples<
+        axiom_handling_evaluator::TaskIndependentAxiomHandlingEvaluator>(
+        eval, tasks::get_axioms_arguments_from_options(opts),
+        get_evaluator_arguments_from_options(opts));
+}
+
+}

src/search/evaluators/axiom_handling_evaluator.h

@@ -0,0 +1,31 @@
+#ifndef EVALUATORS_AXIOM_HANDLING_EVALUATOR_H
+#define EVALUATORS_AXIOM_HANDLING_EVALUATOR_H
+
+#include "../evaluator.h"
+
+#include "../tasks/default_value_axioms_task.h"
+
+#include <memory.h>
+
+namespace axiom_handling_evaluator {
+class TaskIndependentAxiomHandlingEvaluator : public TaskIndependentEvaluator {
+    std::shared_ptr<TaskIndependentEvaluator> nested;
+    tasks::AxiomHandlingType axioms;
+    const std::string description;
+    utils::Verbosity verbosity;
+
+    virtual std::shared_ptr<Evaluator> create_task_specific_component(
+        const std::shared_ptr<AbstractTask> &task) const override;
+public:
+    TaskIndependentAxiomHandlingEvaluator(
+        std::shared_ptr<TaskIndependentEvaluator> nested,
+        tasks::AxiomHandlingType axioms, const std::string &description,
+        utils::Verbosity verbosity);
+};
+
+std::shared_ptr<TaskIndependentEvaluator> wrap_in_axiom_handling_evaluator(
+    const std::shared_ptr<TaskIndependentEvaluator> &eval,
+    const plugins::Options &opts);
+}
+
+#endif