Print circuit and number of terms in commutator

Signed-off-by: Daniel Claudino <6d3@ornl.gov>

python/examples/adapt_vqe_h2.py

@@ -20,6 +20,6 @@ adapt = xacc.getAlgorithm('adapt-vqe', {'accelerator': qpu,
                                   'threshold': 1.0e-2,
                                   'print-threshold': 1.0e-10,
                                   'maxiter': 2,
-                                  'pool': "uccsd"})
+                                  'pool': "singlet-adapted-uccsd"})
 # execute
 adapt.execute(buffer)

quantum/plugins/algorithms/adapt_vqe/adapt_vqe.cpp

@@ -217,29 +217,34 @@ void ADAPT_VQE::execute(const std::shared_ptr<AcceleratorBuffer> buffer) const {
     for (int operatorIdx = 0; operatorIdx < commutators.size(); operatorIdx++){
 
       // only compute commutators if they aren't zero
-      if(std::dynamic_pointer_cast<PauliOperator>(commutators[operatorIdx])->getTerms().size() != 0){
-      // observe the commutators with the updated circuit ansatz
-      auto grad_vqe = xacc::getAlgorithm(
-          "vqe", {std::make_pair("observable", commutators[operatorIdx]),
-                  std::make_pair("optimizer", optimizer),
-                  std::make_pair("accelerator", accelerator),
-                  std::make_pair("ansatz", ansatzInstructions)});
-      auto tmp_buffer = xacc::qalloc(buffer->size());
-      auto commutatorValue = std::real(grad_vqe->execute(tmp_buffer, x)[0]);
-
-      if(abs(commutatorValue) > _printThreshold){
-        ss << std::setprecision(12) << "[H," << operatorIdx << "] = " << commutatorValue << "\n";
-        xacc::info(ss.str());
-        ss.str(std::string());
-      }
+      int nTermsCommutator = std::dynamic_pointer_cast<PauliOperator>(commutators[operatorIdx])->getTerms().size();
+      if(nTermsCommutator != 0){
+
+        // Print number of instructions for computing <observable>
+        xacc::info("Number of instructions for commutator calculation: " 
+                    + std::to_string(nTermsCommutator));
+        // observe the commutators with the updated circuit ansatz
+        auto grad_vqe = xacc::getAlgorithm(
+            "vqe", {std::make_pair("observable", commutators[operatorIdx]),
+                    std::make_pair("optimizer", optimizer),
+                    std::make_pair("accelerator", accelerator),
+                    std::make_pair("ansatz", ansatzInstructions)});
+        auto tmp_buffer = xacc::qalloc(buffer->size());
+        auto commutatorValue = std::real(grad_vqe->execute(tmp_buffer, x)[0]);
+
+        if(abs(commutatorValue) > _printThreshold){
+          ss << std::setprecision(12) << "[H," << operatorIdx << "] = " << commutatorValue << "\n";
+          xacc::info(ss.str());
+          ss.str(std::string());
+        }
 
-      // update maxCommutator
-      if(abs(commutatorValue) > abs(maxCommutator)){
-        maxCommutatorIdx = operatorIdx;
-        maxCommutator = commutatorValue;
-      }
+        // update maxCommutator
+        if(abs(commutatorValue) > abs(maxCommutator)){
+          maxCommutatorIdx = operatorIdx;
+          maxCommutator = commutatorValue;
+        }
 
-      gradientNorm += commutatorValue * commutatorValue;
+        gradientNorm += commutatorValue * commutatorValue;
       }
     }
     
@@ -266,6 +271,8 @@ void ADAPT_VQE::execute(const std::shared_ptr<AcceleratorBuffer> buffer) const {
       xacc::info(ss.str() + "\n");
       ss.str(std::string());
 
+      xacc::info("Final ADAPT-VQE circuit\n" + ansatzInstructions->toString());
+
       return; 
 
     } else if (iter < _maxIter) { // Add operator and reoptimize 

quantum/plugins/algorithms/adapt_vqe/operator_pools/pools.hpp

@@ -126,7 +126,7 @@ public:
     return pool;
   }
 
-  const std::string name() const override { return "uccsd"; }
+  const std::string name() const override { return "singlet-adapted-uccsd"; }
   const std::string description() const override { return ""; }
 };
 

quantum/plugins/algorithms/adapt_vqe/tests/AdaptVQETester.cpp

@@ -61,7 +61,7 @@ TEST(AdaptVQETester, checkSimple) {
   EXPECT_TRUE(adapt_vqe->initialize({std::make_pair("accelerator",acc),
                                 std::make_pair("observable", H),
                                 std::make_pair("optimizer", optimizer),
-                                std::make_pair("pool", "uccsd"),
+                                std::make_pair("pool", "singlet-adapted-uccsd"),
                                 std::make_pair("gradient-strategy", "parameter-shift-gradient"),
                                 std::make_pair("nElectrons", 2)}));