Commit 9f4ce0b3 authored by Nguyen, Thien Minh's avatar Nguyen, Thien Minh
Browse files

Fixed compile errors in QuaSiMo 



Tested by: compiler

Signed-off-by: default avatarThien Nguyen <nguyentm@ornl.gov>
parent b04998ab

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/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;

      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;

      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)) {

lib/quasimo/base/qcor_qsim.hpp

+15 −16
Original line number Diff line number Diff line
@@ -9,7 +9,6 @@ 
#include "qcor_utils.hpp"

#include "qrt.hpp"

#include "quantum_kernel.hpp"

#include "taskInitiate.hpp"

#include <memory>

#include <qalloc>

#include <xacc_internal_compiler.hpp>
@@ -38,7 +37,7 @@ struct Ansatz { 
//  - QFT

class AnsatzGenerator : public Identifiable {

public:

  virtual Ansatz create_ansatz(Observable *obs = nullptr,

  virtual Ansatz create_ansatz(Operator *obs = nullptr,

                               const HeterogeneousMap &params = {}) = 0;

};
@@ -61,18 +60,18 @@ public: 
    return result;

  }

  

  virtual bool initialize(Observable *observable,

  virtual bool initialize(Operator *observable,

                          const HeterogeneousMap &params = {});



protected:

  Observable *target_operator;

  Operator *target_operator;

  HeterogeneousMap hyperParams;

};



// Trotter time-dependent simulation workflow

// Time-dependent Hamiltonian is a function mapping from time t to Observable

// operator.

using TdObservable = std::function<PauliOperator(double)>;

using TdObservable = std::function<Operator(double)>;



// Capture a quantum chemistry problem.

// TODO: generalize this to capture all potential use cases.
@@ -83,7 +82,7 @@ struct QuantumSimulationModel { 
  std::string name;



  // The Observable operator that needs to be measured/minimized.

  Observable *observable;

  Operator *observable;



  // The system Hamiltonian which can be static or dynamic (time-dependent).

  // This can be the same or different from the observable operator.
@@ -130,10 +129,10 @@ public: 
  // Strongly-typed parameters/argument.

  // Build a simple Hamiltonian-based model: static Hamiltonian which is also

  // the observable of interest.

  static QuantumSimulationModel createModel(Observable *obs,

  static QuantumSimulationModel createModel(Operator *obs,

                                           const HeterogeneousMap &params = {});

  static QuantumSimulationModel

  createModel(PauliOperator &obs, const HeterogeneousMap &params = {}) {

  createModel(Operator &obs, const HeterogeneousMap &params = {}) {

    return createModel(&obs, params);

  }
@@ -141,11 +140,11 @@ public: 
  //  -  obs: observable operator to measure.

  //  -  td_ham: time-dependent Hamiltonian to evolve the system.

  //     e.g. a function to map from time to Hamiltonian operator.

  static QuantumSimulationModel createModel(Observable *obs, TdObservable td_ham,

  static QuantumSimulationModel createModel(Operator *obs, TdObservable td_ham,

                                           const HeterogeneousMap &params = {});

  // Pauli operator overload:

  static QuantumSimulationModel

  createModel(PauliOperator &obs, TdObservable td_ham,

  createModel(Operator &obs, TdObservable td_ham,

              const HeterogeneousMap &params = {}) {

    return createModel(&obs, td_ham, params);

  }
@@ -172,7 +171,7 @@ public: 
  static inline QuantumSimulationModel createModel(

      void (*quantum_kernel_functor)(std::shared_ptr<CompositeInstruction>,

                                     Args...),

      Observable *obs, size_t nbQubits, size_t nbParams) {

      Operator *obs, size_t nbQubits, size_t nbParams) {

    auto kernel_functor =

        createKernelFunctor(quantum_kernel_functor, nbQubits, nbParams);
@@ -186,14 +185,14 @@ public: 
  static inline QuantumSimulationModel createModel(

      void (*quantum_kernel_functor)(std::shared_ptr<CompositeInstruction>,

                                     Args...),

      PauliOperator &obs, size_t nbQubits, size_t nbParams) {

      Operator &obs, size_t nbQubits, size_t nbParams) {

    return createModel(quantum_kernel_functor, &obs, nbQubits, nbParams);

  }



  // Passing the state-preparation ansatz as a CompositeInstruction

  static inline QuantumSimulationModel

  createModel(std::shared_ptr<CompositeInstruction> composite,

              Observable *obs) {

              Operator *obs) {

    QuantumSimulationModel model;

    model.observable = obs;

    model.user_defined_ansatz = createKernelFunctor(composite);
@@ -202,7 +201,7 @@ public: 


  static inline QuantumSimulationModel

  createModel(std::shared_ptr<CompositeInstruction> composite,

              PauliOperator &obs) {

              Operator &obs) {

    return createModel(composite, &obs);

  }

};
@@ -229,10 +228,10 @@ getWorkflow(const std::string &name, const HeterogeneousMap &init_params); 


// Get the Obj (cost) function evaluator:

std::shared_ptr<CostFunctionEvaluator>

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

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

                const HeterogeneousMap &init_params = {});

inline std::shared_ptr<CostFunctionEvaluator>

getObjEvaluator(PauliOperator &obs, const std::string &name = "default",

getObjEvaluator(Operator &obs, const std::string &name = "default",

                const HeterogeneousMap &init_params = {}) {

  return getObjEvaluator(&obs, name, init_params);

}

lib/quasimo/impls/ansatz_generator/trotter.cpp

+3 −2
Original line number Diff line number Diff line
@@ -4,7 +4,7 @@ 


namespace qcor {

namespace QuaSiMo {

Ansatz TrotterEvolution::create_ansatz(Observable *obs,

Ansatz TrotterEvolution::create_ansatz(Operator *obs,

                                       const HeterogeneousMap &params) {

  Ansatz result;

  // This ansatz generator requires an observable.
@@ -23,7 +23,8 @@ Ansatz TrotterEvolution::create_ansatz(Observable *obs, 
      xacc::getService<xacc::Instruction>("exp_i_theta"));

  expCirc->expand({{"pauli", obs->toString()},

                   {"__internal_compute_action_uncompute_opt__", cau_opt}});

  result.circuit = expCirc->operator()({dt});

  result.circuit =

      std::make_shared<qcor::CompositeInstruction>(expCirc->operator()({dt}));

  result.nb_qubits = expCirc->nRequiredBits();



  return result;

lib/quasimo/impls/ansatz_generator/trotter.hpp

+1 −1
Original line number Diff line number Diff line
@@ -6,7 +6,7 @@ namespace QuaSiMo { 
// 1st-order Trotterization

class TrotterEvolution : public AnsatzGenerator {

public:

  Ansatz create_ansatz(Observable *obs,

  Ansatz create_ansatz(Operator *obs,

                       const HeterogeneousMap &params) override;

  virtual const std::string name() const override { return "trotter"; }

  virtual const std::string description() const override { return ""; }