Unverified Commit 7bc50bf3 authored by Mccaskey, Alex's avatar Mccaskey, Alex Committed by GitHub
Browse files

Merge pull request #173 from tnguyen-ornl/tnguyen/runtime_pimpl 

Update QuaSiMo to use new QCOR pimpl types
parents 5f64ace4 9422e143

examples/quasimo/AdaptVqeWorkflow.cpp

+1 −2
Original line number Diff line number Diff line
@@ -30,8 +30,7 @@ int main(int argc, char **argv) { 
      "(-0.120200490713,-0)  0^ 1^ 0 1 + (-0.120200490713,-0)  1^ 0^ 1 0 + "

      "(0.7080240981,0)");



  FermionOperator H_vqe;

  H_vqe.fromString(str);

  Operator H_vqe("fermion", str);

  auto problemModel = QuaSiMo::ModelFactory::createModel(&H_vqe);

  auto optimizer = createOptimizer("nlopt", {{"nlopt-optimizer", "l-bfgs"}});

  const int nElectrons = 2;

examples/quasimo/VqeWithAnsatzCircuit.cpp

+1 −0
Original line number Diff line number Diff line
@@ -31,5 +31,6 @@ int main(int argc, char **argv) { 


  const auto energy = result.get<double>("energy");

  std::cout << "Ground-state energy = " << energy << "\n";

  qcor_expect(std::abs(energy + 1.7487) < 0.1);

  return 0;

}
 
 No newline at end of file

lib/CMakeLists.txt

+1 −1
Original line number Diff line number Diff line 
#add_subdirectory(quasimo)

add_subdirectory(quasimo)



# Install QCOR standard library header

file(GLOB LIB_HEADERS qcor_*)

lib/impl/hadamard_test.hpp

+1 −1
Original line number Diff line number Diff line
@@ -38,7 +38,7 @@ double hadamard_test(StatePrep state_prep, Unitary unitary, 
  // if not, grab exp-val-z key in buffer

  auto counts = q.counts();

  if (counts.empty()) {

    return q.results()->getExpectationValueZ();

    return q.exp_val_z();

  }

 

  // We have counts, so use that

lib/quasimo/base/qcor_qsim.cpp

+14 −13
Original line number Diff line number Diff line 
#include "qcor_qsim.hpp"

#include "xacc_service.hpp"

#include "IRProvider.hpp"



namespace qcor {

namespace QuaSiMo {

bool CostFunctionEvaluator::initialize(Observable *observable,

bool CostFunctionEvaluator::initialize(Operator *observable,

                                       const HeterogeneousMap &params) {

  target_operator = observable;

  hyperParams = params;
@@ -18,7 +19,7 @@ void executePassManager( 
}



QuantumSimulationModel

ModelFactory::createModel(Observable *obs, TdObservable td_ham,

ModelFactory::createModel(Operator *obs, TdObservable td_ham,

                          const HeterogeneousMap &params) {

  QuantumSimulationModel model;

  model.observable = obs;
@@ -27,11 +28,11 @@ ModelFactory::createModel(Observable *obs, TdObservable td_ham, 
}



QuantumSimulationModel

ModelFactory::createModel(Observable *obs, const HeterogeneousMap &params) {

ModelFactory::createModel(Operator *obs, const HeterogeneousMap &params) {

  QuantumSimulationModel model;

  model.observable = obs;

  model.hamiltonian = [&](double t) {

    return *(static_cast<PauliOperator *>(obs));

    return *(static_cast<Operator *>(obs));

  };

  return model;

}
@@ -52,15 +53,15 @@ ModelFactory::createModel(ModelType type, const HeterogeneousMap &params) { 
    QuantumSimulationModel model;



    // Handle custom observable:

    qcor::Observable *model_observable = nullptr;

    qcor::Operator *model_observable = nullptr;

    // Get QCOR Pauli Op first (if any)

    if (params.keyExists<qcor::PauliOperator>("observable")) {

      static auto cached_pauli = params.get<qcor::PauliOperator>("observable");

    if (params.keyExists<qcor::Operator>("observable")) {

      static auto cached_pauli = params.get<qcor::Operator>("observable");

      model_observable = &cached_pauli;

    }

    // Generic qcor::Observable

    else if (params.pointerLikeExists<qcor::Observable>("observable")) {

      model_observable = params.getPointerLike<qcor::Observable>("observable");

    // Generic qcor::Operator

    else if (params.pointerLikeExists<qcor::Operator>("observable")) {

      model_observable = params.getPointerLike<qcor::Operator>("observable");

    }

    else {

      const std::vector<std::string> SUPPORTED_OBS{"average_magnetization",
@@ -74,7 +75,7 @@ ModelFactory::createModel(ModelType type, const HeterogeneousMap &params) { 
        qcor::error("Unknown observable type: " + observable_type);

      }



      auto observable = new qcor::PauliOperator;

      auto observable = new qcor::Operator("pauli", "0.0");

      if (observable_type == "average_magnetization") {

        for (int i = 0; i < hs_model->num_spins; ++i) {

          (*observable) += ((1.0 / hs_model->num_spins) * Z(i));
@@ -95,7 +96,7 @@ ModelFactory::createModel(ModelType type, const HeterogeneousMap &params) { 
    assert(model_observable);

    model.observable = model_observable;

    QuaSiMo::TdObservable H = [&](double t) {

      qcor::PauliOperator tdOp;

      qcor::Operator tdOp("pauli", "0.0");

      for (int i = 0; i < hs_model->num_spins - 1; ++i) {

        if (hs_model->Jx != 0.0) {

          tdOp += ((hs_model->Jx / hs_model->H_BAR) * (X(i) * X(i + 1)));
@@ -172,7 +173,7 @@ getWorkflow(const std::string &name, const HeterogeneousMap &init_params) { 
}



std::shared_ptr<CostFunctionEvaluator>

getObjEvaluator(Observable *observable, const std::string &name,

getObjEvaluator(Operator *observable, const std::string &name,

                const HeterogeneousMap &init_params) {

  auto evaluator = xacc::getService<CostFunctionEvaluator>(name);

  if (evaluator && evaluator->initialize(observable, init_params)) {