add new setf/shiftf/setp/shiftp command to pulse object

Author: flatslm

quantum/plugins/ibm/accelerator/IBMAccelerator.cpp

@@ -599,13 +599,10 @@ void IBMAccelerator::execute(
   if (qobj_type == "pulse") {
     // if we need to use pulse mode, contribute the pulse library of the
     // backend (if any)
-    if (!defaults_response.empty()) {
-      // Make sure we only contribute pulse cmd-def once
-      static bool contributed;
-      if (!contributed) {
-        contributed = true;
-        contributeInstructions();
-      }
+    // And make sure we only contribute pulse cmd-def once
+    if (!defaults_response.empty() && !contributed) {
+      contributed = true;
+      contributeInstructions();
     }
   }
   // Get the correct QObject Generator
@@ -1090,6 +1087,7 @@ void IBMAccelerator::contributeInstructions(
 
     xacc::info("Contributing " + tmpName + " pulse composite.");
     xacc::contributeService(tmpName, cmd_def);
+    contributed = true;
   }
 }
 

quantum/plugins/ibm/accelerator/IBMAccelerator.hpp

@@ -195,6 +195,7 @@ class IBMAccelerator : public Accelerator {
   std::map<std::string, nlohmann::json> backendProperties;
   std::string getBackendPropsResponse = "{}";
   std::string defaults_response = "{}";
+  bool contributed = false;
   std::string mode = "qasm";
   int requested_n_qubits = 0;
   bool filterByJobsLimit = false;

quantum/plugins/ibm/accelerator/OpenPulseVisitor.hpp

@@ -90,7 +90,8 @@ class OpenPulseVisitor : public BaseInstructionVisitor,
         inst.set_phase(i.getParameter(0).as<double>());
         inst.set_t0(i.start());
 
-        std::vector<std::string> builtIns {"fc", "acquire", "parametric_pulse", "delay" };
+        std::vector<std::string> builtIns {"fc", "acquire", "parametric_pulse", "delay", 
+                                           "setf","shiftf", "setp", "shiftp" };
         if (std::find(builtIns.begin(), builtIns.end(), i.name()) == std::end(builtIns)) {
             // add to default libr
             xacc::ibm_pulse::PulseLibrary lib;
@@ -122,6 +123,10 @@ class OpenPulseVisitor : public BaseInstructionVisitor,
           inst.set_pulse_params(pulseParameters.getString("parameters_json"));
         }
 
+        if (i.name() == "setf" || i.name() == "shiftf") {
+            inst.set_frequency(i.getParameter(0).as<double>());
+        }
+
         instructions.push_back(inst);
 
 	}

quantum/plugins/ibm/accelerator/json/PulseQObject.hpp

@@ -195,6 +195,7 @@ class Instruction {
   std::string name;
   int64_t t0;
   double phase;
+  double frequency;
   std::vector<int64_t> memory_slot;
   int64_t duration;
   std::vector<int64_t> qubits;
@@ -215,6 +216,9 @@ class Instruction {
   double get_phase() const { return phase; }
   void set_phase(double value) { this->phase = value; }
 
+  double get_frequency() const { return frequency; }
+  void set_frequency(double value) { this->frequency = value; }
+
   std::vector<int64_t> get_memory_slot() const { return memory_slot; }
   void set_memory_slot(std::vector<int64_t> value) {
     this->memory_slot = value;
@@ -459,7 +463,7 @@ inline void to_json(json &j, const xacc::ibm_pulse::Instruction &x) {
 
   j["name"] = x.get_name();
   j["t0"] = x.get_t0();
-  if (x.get_name() == "fc") {
+  if (x.get_name() == "fc" || x.get_name() == "setp" || x.get_name() == "shiftp") {
     j["phase"] = x.get_phase();
   }
   if (x.get_name() == "acquire") {
@@ -477,6 +481,9 @@ inline void to_json(json &j, const xacc::ibm_pulse::Instruction &x) {
   if (x.get_name() == "delay") {
     j["duration"] = x.get_duration();
   }
+  if (x.get_name() == "setf" || x.get_name() == "shiftf") {
+    j["frequency"] = x.get_frequency();
+  }
 }
 
 inline void from_json(const json &j, xacc::ibm_pulse::Experiment &x) {

quantum/plugins/ibm/tests/IBMPulseRemoteTester.cpp

@@ -126,10 +126,12 @@ TEST(IBMPulseRemoteTester, checkCnotPulse) {
 }
 #endif
 
-// Check manipulations with frequency
-TEST(IBMPulseRemoteTester, checkFrequencyHandle) {
+// Check manipulations with phase and frequency
+TEST(IBMPulseRemoteTester, sendPhaseFrequencyPulse) {
   xacc::set_verbose(true);
   auto acc = xacc::getAccelerator("ibm:ibmq_armonk", {{"mode", "pulse"}});
+  auto buffer = xacc::qalloc(1);
+  auto provider = xacc::getService<xacc::IRProvider>("quantum");
   std::string jjson("{"
                     "\"pulse_library\": ["
                      "{\"name\": \"pulse1\", \"samples\": [[0,0],[0,0],[0,0]]},"
@@ -138,32 +140,50 @@ TEST(IBMPulseRemoteTester, checkFrequencyHandle) {
                                         "]"
                     ","
                     "\"cmd_def\":["
-                    "{\"name\":\"test_freq\",\"qubits\":[0],\"sequence\":["
-                              "{\"name\":\"setf\",\"ch\":\"d0\",\"t0\":0,\"frequency\":5}"
-                              ","
-                              "{\"name\":\"shiftf\",\"ch\":\"d0\",\"t0\":0,\"frequency\":-0.1}"
-                              ","
-                              "{\"name\":\"setp\",\"ch\":\"d0\",\"t0\":0,\"phase\":-1.57}"
+                    "{\"name\":\"test_phase\",\"qubits\":[0],\"sequence\":["
+                              "{\"name\":\"setp\",\"ch\":\"d0\",\"t0\":0,\"phase\":1.57}"
                               ","
                               "{\"name\":\"shiftp\",\"ch\":\"d0\",\"t0\":0,\"phase\":0.1}"
                     "]}"
                     ","
+                    "{\"name\":\"test_freq\",\"qubits\":[0],\"sequence\":["
+                              "{\"name\":\"setf\",\"ch\":\"d0\",\"t0\":0,\"frequency\":5.1}"
+                              ","
+                              "{\"name\":\"shiftf\",\"ch\":\"d0\",\"t0\":0,\"frequency\":-0.21}"
+                    "]}"
+                    ","
                     "{\"name\":\"id2\",\"qubits\":[0],\"sequence\":[{\"name\":\"setf\",\"ch\":\"d0\",\"t0\":0,\"frequency\":5}]}"
                      "] "
                     "}");
 
   acc->contributeInstructions(jjson);
-  auto cr = xacc::getContributedService<xacc::Instruction>("pulse::test_freq_0");
-  auto cr_comp =
-      std::dynamic_pointer_cast<xacc::CompositeInstruction>(cr);
+  {
+    // ibmq_armonk does not support setp/shiftp pulse operations.
+    // test only contributeInstructions()
+      auto cr = xacc::getContributedService<xacc::Instruction>("pulse::test_phase_0");
+      auto cr_comp = std::dynamic_pointer_cast<xacc::CompositeInstruction>(cr);
 
-  EXPECT_EQ(cr_comp->getInstructions().size(), 4);
+      EXPECT_EQ(cr_comp->getInstructions().size(), 2);
+      std::string checkNames[] = {"setp", "shiftp"};
+      for( int nI = 0; nI < 2; ++nI ) {
+          EXPECT_EQ(cr_comp->getInstruction(nI)->name(), checkNames[nI] );
+      }
+  }
 
-  std::string checkNames[] = {"setf", "shiftf", "setp", "shiftp"};
+  auto cr = xacc::getContributedService<xacc::Instruction>("pulse::test_freq_0");
+  auto cr_comp = std::dynamic_pointer_cast<xacc::CompositeInstruction>(cr);
 
-  for( int nI = 0; nI < 4; ++nI ) {
+  EXPECT_EQ(cr_comp->getInstructions().size(), 2);
+  std::string checkNames[] = {"setf", "shiftf"};
+  for( int nI = 0; nI < 2; ++nI ) {
       EXPECT_EQ(cr_comp->getInstruction(nI)->name(), checkNames[nI] );
   }
+
+  auto f = provider->createComposite("tmp");
+  auto m0 = provider->createInstruction("Measure", {0});
+  f->addInstructions({ cr_comp, m0 });
+  acc->execute(buffer, f);
+  buffer->print();
 }
 
 int main(int argc, char **argv) {