Custom Operator Registry Support

CMakeLists.txt

@@ -373,6 +373,9 @@ set(SeQuant_src
         SeQuant/domain/mbpt/convention.hpp
         SeQuant/domain/mbpt/models/cc.cpp
         SeQuant/domain/mbpt/models/cc.hpp
+        SeQuant/domain/mbpt/reserved.hpp
+        SeQuant/domain/mbpt/op_registry.hpp
+        SeQuant/domain/mbpt/op_registry.cpp
         SeQuant/domain/mbpt/op.cpp
         SeQuant/domain/mbpt/op.hpp
         SeQuant/domain/mbpt/op.ipp

SeQuant/domain/mbpt/context.cpp

@@ -2,10 +2,52 @@
 
 namespace sequant::mbpt {
 
-Context::Context(CSV csv) noexcept : csv_(csv) {}
+/// forward declaration of OpClass
+enum class OpClass;
+
+Context::Context(Options options)
+    : csv_(options.csv),
+      op_registry_(options.op_registry_ptr
+                       ? std::move(options.op_registry_ptr)
+                       : (options.op_registry
+                              ? std::make_shared<OpRegistry>(
+                                    std::move(options.op_registry.value()))
+                              : nullptr)) {}
+
+Context Context::clone() const {
+  Context ctx(*this);
+  ctx.op_registry_ = std::make_shared<OpRegistry>(op_registry_->clone());
+  return ctx;
+}
+
+CSV Context::csv() const { return csv_; }
+
+std::shared_ptr<const OpRegistry> Context::op_registry() const {
+  return op_registry_;
+}
+
+std::shared_ptr<OpRegistry> Context::mutable_op_registry() {
+  return op_registry_;
+}
+
+Context& Context::set(const OpRegistry& op_registry) {
+  op_registry_ = std::make_shared<OpRegistry>(op_registry);
+  return *this;
+}
+
+Context& Context::set(std::shared_ptr<OpRegistry> op_registry) {
+  op_registry_ = std::move(op_registry);
+  return *this;
+}
+
+Context& Context::set(CSV csv) {
+  csv_ = csv;
+  return *this;
+}
 
 bool operator==(Context const& left, Context const& right) {
-  return left.csv() == right.csv();
+  return left.csv() == right.csv() &&
+         *(left.op_registry()) == *(right.op_registry());
 }
 
 bool operator!=(Context const& left, Context const& right) {
@@ -20,6 +62,10 @@ void set_default_mbpt_context(const Context& ctx) {
   sequant::detail::set_implicit_context(ctx);
 }
 
+void set_default_mbpt_context(const Context::Options& options) {
+  return set_default_mbpt_context(Context(options));
+}
+
 void reset_default_mbpt_context() {
   sequant::detail::reset_implicit_context<Context>();
 }
@@ -29,4 +75,49 @@ set_scoped_default_mbpt_context(const Context& f) {
   return sequant::detail::set_scoped_implicit_context(f);
 }
 
+[[nodiscard]] sequant::detail::ImplicitContextResetter<Context>
+set_scoped_default_mbpt_context(const Context::Options& f) {
+  return sequant::detail::set_scoped_implicit_context(Context(f));
+}
+
+std::shared_ptr<OpRegistry> make_minimal_registry() {
+  auto registry = std::make_shared<OpRegistry>();
+
+  registry
+      ->add(L"h", OpClass::gen)   /// 1-body Hamiltonian
+      .add(L"g", OpClass::gen)    /// 2-body Coulomb
+      .add(L"f", OpClass::gen)    /// Fock operator
+      .add(L"θ", OpClass::gen)    /// general fock space operator
+      .add(L"t", OpClass::ex)     /// cluster operator
+      .add(L"λ", OpClass::deex)   /// deexcitation cluster operator
+      .add(L"R", OpClass::ex)     /// right-hand eigenstate
+      .add(L"L", OpClass::deex);  /// left-hand eigenstate
+
+  return registry;
+}
+
+std::shared_ptr<OpRegistry> make_legacy_registry() {
+  auto registry = std::make_shared<OpRegistry>();
+
+  registry->add(L"h", OpClass::gen)
+      .add(L"f", OpClass::gen)
+      /// closed Fock operator (i.e. Fock operator due to fully-occupied
+      /// orbitals)
+      .add(L"f̃", OpClass::gen)
+      .add(L"g", OpClass::gen)
+      .add(L"θ", OpClass::gen)
+      .add(L"t", OpClass::ex)
+      .add(L"λ", OpClass::deex)
+      .add(L"R", OpClass::ex)
+      .add(L"L", OpClass::deex)
+      /// R12
+      .add(L"F", OpClass::gen)
+      .add(L"GR", OpClass::gen)
+      .add(L"C", OpClass::gen)
+      /// RDM and RDM Cumulant
+      .add(L"γ", OpClass::gen)
+      .add(L"κ", OpClass::gen);
+
+  return registry;
+}
 }  // namespace sequant::mbpt

SeQuant/domain/mbpt/context.hpp

@@ -5,6 +5,7 @@
 #include <SeQuant/domain/mbpt/fwd.hpp>
 
 #include <SeQuant/core/utility/context.hpp>
+#include <SeQuant/domain/mbpt/op_registry.hpp>
 
 namespace sequant::mbpt {
 
@@ -20,13 +21,61 @@ class Context {
     constexpr static auto csv = CSV::No;
   };
 
-  /// @brief Construct a Formalism object
-  explicit Context(CSV csv_formalism = Defaults::csv) noexcept;
+  struct Options {
+    /// whether to use cluster-specific virtuals
+    CSV csv = Defaults::csv;
+    /// shared pointer to operator registry
+    std::shared_ptr<OpRegistry> op_registry_ptr = nullptr;
+    /// optional operator registry, use if no shared pointer is provided
+    std::optional<OpRegistry> op_registry = std::nullopt;
+  };
+
+  /// @brief makes default options for mbpt::Context
+  static Options make_default_options() { return Options{}; }
+
+  /// @brief Construct a Context object, uses default options if none are given
+  Context(Options options = make_default_options());
+
+  /// @brief destructor
+  ~Context() = default;
+
+  /// @brief move constructor
+  Context(Context&&) = default;
+
+  /// @brief copy constructor
+  Context(Context const& other) = default;
+
+  /// @brief copy assignment
+  Context& operator=(Context const& other) = default;
+
+  /// @brief clones this object and its OpRegistry
+  Context clone() const;
+
+  /// @return the value of CSV in this context
+  CSV csv() const;
 
-  CSV csv() const { return csv_; }
+  /// @return a constant pointer to the OpRegistry for this context
+  /// @warning can be null when user did not provide one to Context (i.e., it
+  /// was default constructed)
+  std::shared_ptr<const OpRegistry> op_registry() const;
+
+  /// @return a pointer to the OpRegistry for this context
+  /// @warning can be null when user did not provide one to Context (i.e., it
+  /// was default constructed)
+  std::shared_ptr<OpRegistry> mutable_op_registry();
+
+  /// @brief sets the OpRegistry for this context
+  Context& set(const OpRegistry& op_registry);
+
+  /// @brief sets the OpRegistry for this context
+  Context& set(std::shared_ptr<OpRegistry> op_registry);
+
+  /// @brief sets whether to use cluster-specific virtuals
+  Context& set(CSV csv);
 
  private:
   CSV csv_ = Defaults::csv;
+  std::shared_ptr<OpRegistry> op_registry_;
 };
 
 bool operator==(Context const& left, Context const& right);
@@ -37,10 +86,39 @@ const Context& get_default_mbpt_context();
 
 void set_default_mbpt_context(const Context& ctx);
 
+void set_default_mbpt_context(const Context::Options& options);
+
 void reset_default_mbpt_context();
+
 [[nodiscard]] sequant::detail::ImplicitContextResetter<Context>
 set_scoped_default_mbpt_context(const Context& ctx);
 
+[[nodiscard]] sequant::detail::ImplicitContextResetter<Context>
+set_scoped_default_mbpt_context(const Context::Options& options);
+
+/// predefined operator registries
+
+/// @brief makes a minimal operator registry with only essential operators for
+/// MBPT
+std::shared_ptr<OpRegistry> make_minimal_registry();
+
+/// @brief make a legacy operator registry with SeQuant's old predefined
+/// operators set
+std::shared_ptr<OpRegistry> make_legacy_registry();
+
+/// @brief converts an operator label to its OpClass using the default MBPT
+/// context
+/// @param op the operator label
+/// @return the OpClass of the operator
+inline OpClass to_op_class(const std::wstring& op) {
+  // check reserved labels first
+  if (ranges::contains(reserved::labels(), op)) {
+    return OpClass::gen;  // all reserved labels are gen
+  } else {
+    return get_default_mbpt_context().op_registry()->to_class(op);
+  }
+}
+
 }  // namespace sequant::mbpt
 
 #endif  // SEQUANT_DOMAIN_MBPT_CONTEXT_HPP

SeQuant/domain/mbpt/models/cc.cpp

@@ -93,12 +93,12 @@ std::vector<ExprPtr> CC::λ(size_t commutator_rank) {
   auto lhbar = simplify((One + Λ(N)) * hbar);
 
   const auto op_connect = concat(default_op_connections(),
-                                 OpConnections<OpType>{{OpType::h, OpType::A},
-                                                       {OpType::f, OpType::A},
-                                                       {OpType::g, OpType::A},
-                                                       {OpType::h, OpType::S},
-                                                       {OpType::f, OpType::S},
-                                                       {OpType::g, OpType::S}});
+                                 OpConnections<std::wstring>{{L"h", L"A"},
+                                                             {L"f", L"A"},
+                                                             {L"g", L"A"},
+                                                             {L"h", L"S"},
+                                                             {L"f", L"S"},
+                                                             {L"g", L"S"}});
 
   // 2. project onto each manifold, screen, lower to tensor form and wick it
   std::vector<ExprPtr> result(N + 1);
@@ -168,10 +168,8 @@ std::vector<ExprPtr> CC::t_pt(size_t rank, size_t order,
   // connect h1 with t
   const auto op_connect =
       concat(default_op_connections(),
-             OpConnections<OpType>{{OpType::h, OpType::t_1},
-                                   {OpType::f, OpType::t_1},
-                                   {OpType::g, OpType::t_1},
-                                   {OpType::h_1, OpType::t}});
+             OpConnections<std::wstring>{
+                 {L"h", L"t¹"}, {L"f", L"t¹"}, {L"g", L"t¹"}, {L"h¹", L"t"}});
 
   std::vector<ExprPtr> result(N + 1);
   for (auto p = N; p >= 1; --p) {
@@ -218,20 +216,19 @@ std::vector<ExprPtr> CC::λ_pt(size_t rank, size_t order,
   // projectors with {h,f,g}
   // h1 with t
   // h1 with projectors
-  const auto op_connect =
-      concat(default_op_connections(),
-             OpConnections<OpType>{{OpType::h, OpType::t_1},
-                                   {OpType::f, OpType::t_1},
-                                   {OpType::g, OpType::t_1},
-                                   {OpType::h_1, OpType::t},
-                                   {OpType::h, OpType::A},
-                                   {OpType::f, OpType::A},
-                                   {OpType::g, OpType::A},
-                                   {OpType::h, OpType::S},
-                                   {OpType::f, OpType::S},
-                                   {OpType::g, OpType::S},
-                                   {OpType::h_1, OpType::A},
-                                   {OpType::h_1, OpType::S}});
+  const auto op_connect = concat(default_op_connections(),
+                                 OpConnections<std::wstring>{{L"h", L"t¹"},
+                                                             {L"f", L"t¹"},
+                                                             {L"g", L"t¹"},
+                                                             {L"h¹", L"t"},
+                                                             {L"h", L"A"},
+                                                             {L"f", L"A"},
+                                                             {L"g", L"A"},
+                                                             {L"h", L"S"},
+                                                             {L"f", L"S"},
+                                                             {L"g", L"S"},
+                                                             {L"h¹", L"A"},
+                                                             {L"h¹", L"S"}});
 
   std::vector<ExprPtr> result(N + 1);
   for (auto p = N; p >= 1; --p) {
@@ -262,10 +259,9 @@ std::vector<ExprPtr> CC::eom_r(nₚ np, nₕ nh) {
 
   // connectivity:
   // default connections + connect R with {h,f,g}
-  const auto op_connect = concat(default_op_connections(),
-                                 OpConnections<OpType>{{OpType::h, OpType::R},
-                                                       {OpType::f, OpType::R},
-                                                       {OpType::g, OpType::R}});
+  const auto op_connect = concat(
+      default_op_connections(),
+      OpConnections<std::wstring>{{L"h", L"R"}, {L"f", L"R"}, {L"g", L"R"}});
 
   // initialize result vector
   std::vector<ExprPtr> result;
@@ -305,12 +301,12 @@ std::vector<ExprPtr> CC::eom_l(nₚ np, nₕ nh) {
   // connectivity:
   // default connections + connect H with projectors
   const auto op_connect = concat(default_op_connections(),
-                                 OpConnections<OpType>{{OpType::h, OpType::A},
-                                                       {OpType::f, OpType::A},
-                                                       {OpType::g, OpType::A},
-                                                       {OpType::h, OpType::S},
-                                                       {OpType::f, OpType::S},
-                                                       {OpType::g, OpType::S}});
+                                 OpConnections<std::wstring>{{L"h", L"A"},
+                                                             {L"f", L"A"},
+                                                             {L"g", L"A"},
+                                                             {L"h", L"S"},
+                                                             {L"f", L"S"},
+                                                             {L"g", L"S"}});
 
   // initialize result vector
   std::vector<ExprPtr> result;

SeQuant/domain/mbpt/models/cc.hpp

@@ -129,7 +129,7 @@ class CC {
   /// @param[in] op_connect list of pairs of operators to be connected. Default
   /// is given by `mbpt::default_op_connections()`.
   auto ref_av(const ExprPtr& expr,
-              const OpConnections<mbpt::OpType>& op_connect =
+              const OpConnections<std::wstring>& op_connect =
                   default_op_connections()) const {
     return op::ref_av(expr, op_connect, this->use_topology(), this->screen());
   }