Commit 62528cd3 authored by Nguyen, Thien Minh's avatar Nguyen, Thien Minh
Browse files

Fixed typo: Quatum -> Quantum 



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

lib/qsim/base/qcor_qsim.cpp

+8 −8
Original line number Diff line number Diff line
@@ -10,18 +10,18 @@ bool CostFunctionEvaluator::initialize(Observable *observable, 
  return target_operator != nullptr;

}



QuatumSimulationModel

QuantumSimulationModel

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

                          const HeterogeneousMap &params) {

  QuatumSimulationModel model;

  QuantumSimulationModel model;

  model.observable = obs;

  model.hamiltonian = td_ham;

  return model;

}



QuatumSimulationModel

QuantumSimulationModel

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

  QuatumSimulationModel model;

  QuantumSimulationModel model;

  model.observable = obs;

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

    return *(static_cast<PauliOperator *>(obs));
@@ -29,17 +29,17 @@ ModelBuilder::createModel(Observable *obs, const HeterogeneousMap &params) { 
  return model;

}



QuatumSimulationModel

QuantumSimulationModel

ModelBuilder::createModel(const std::string &format, const std::string &data,

                          const HeterogeneousMap &params) {

  QuatumSimulationModel model;

  QuantumSimulationModel model;

  // TODO:

  return model;

}



std::shared_ptr<QuatumSimulationWorkflow>

std::shared_ptr<QuantumSimulationWorkflow>

getWorkflow(const std::string &name, const HeterogeneousMap &init_params) {

  auto qsim_workflow = xacc::getService<QuatumSimulationWorkflow>(name);

  auto qsim_workflow = xacc::getService<QuantumSimulationWorkflow>(name);

  if (qsim_workflow && qsim_workflow->initialize(init_params)) {

    return qsim_workflow;

  }

lib/qsim/base/qcor_qsim.hpp

+16 −16
Original line number Diff line number Diff line
@@ -60,8 +60,8 @@ using TdObservable = std::function<PauliOperator(double)>; 
// Capture a quantum chemistry problem.

// TODO: generalize this to capture all potential use cases.



struct QuatumSimulationModel {

  QuatumSimulationModel() : observable(nullptr) {}

struct QuantumSimulationModel {

  QuantumSimulationModel() : observable(nullptr) {}

  // Model name.

  std::string name;
@@ -72,7 +72,7 @@ struct QuatumSimulationModel { 
  // This can be the same or different from the observable operator.

  TdObservable hamiltonian;



  // QuatumSimulationModel also support a user-defined (fixed) ansatz.

  // QuantumSimulationModel also support a user-defined (fixed) ansatz.

  std::shared_ptr<KernelFunctor> user_defined_ansatz;

};
@@ -84,16 +84,16 @@ public: 
  // Strongly-typed parameters/argument.

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

  // the observable of interest.

  static QuatumSimulationModel createModel(Observable *obs,

  static QuantumSimulationModel createModel(Observable *obs,

                                           const HeterogeneousMap &params = {});

  // Build a time-dependent problem model:

  //  -  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 QuatumSimulationModel createModel(Observable *obs, TdObservable td_ham,

  static QuantumSimulationModel createModel(Observable *obs, TdObservable td_ham,

                                           const HeterogeneousMap &params = {});

  // Pauli operator overload:

  static QuatumSimulationModel

  static QuantumSimulationModel

  createModel(PauliOperator &obs, TdObservable td_ham,

              const HeterogeneousMap &params = {}) {

    return createModel(&obs, td_ham, params);
@@ -108,28 +108,28 @@ public: 
  //  - params: extra parameters to pass to the parser/generator,

  //            e.g. any transformations required in order to generate the

  //            Observable.

  static QuatumSimulationModel createModel(const std::string &format,

  static QuantumSimulationModel createModel(const std::string &format,

                                           const std::string &data,

                                           const HeterogeneousMap &params = {});



  // ========== QuatumSimulationModel with a fixed (pre-defined) ansatz ========

  // ========== QuantumSimulationModel with a fixed (pre-defined) ansatz ========

  // The ansatz is provided as a QCOR kernel.

  template <typename... Args>

  static inline QuatumSimulationModel createModel(

  static inline QuantumSimulationModel createModel(

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

                                     Args...),

      Observable *obs, size_t nbQubits, size_t nbParams) {

    auto kernel_functor =

        createKernelFunctor(quantum_kernel_functor, nbQubits, nbParams);



    QuatumSimulationModel model;

    QuantumSimulationModel model;

    model.observable = obs;

    model.user_defined_ansatz = kernel_functor;

    return model;

  }



  template <typename... Args>

  static inline QuatumSimulationModel createModel(

  static inline QuantumSimulationModel createModel(

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

                                     Args...),

      PauliOperator &obs, size_t nbQubits, size_t nbParams) {
@@ -141,20 +141,20 @@ public: 
// This can handle both variational workflow (optimization loop)

// as well as simple Trotter evolution workflow.

// Result is stored in a HetMap

using QuatumSimulationResult = HeterogeneousMap;

using QuantumSimulationResult = HeterogeneousMap;

// Abstract workflow:

class QuatumSimulationWorkflow : public Identifiable {

class QuantumSimulationWorkflow : public Identifiable {

public:

  virtual bool initialize(const HeterogeneousMap &params) = 0;

  virtual QuatumSimulationResult

  execute(const QuatumSimulationModel &model) = 0;

  virtual QuantumSimulationResult

  execute(const QuantumSimulationModel &model) = 0;



protected:

  std::shared_ptr<CostFunctionEvaluator> evaluator;

};



// Get workflow by name:

std::shared_ptr<QuatumSimulationWorkflow>

std::shared_ptr<QuantumSimulationWorkflow>

getWorkflow(const std::string &name, const HeterogeneousMap &init_params);



// Get the Obj (cost) function evaluator:

lib/qsim/impls/qsim_impl.cpp

+16 −16
Original line number Diff line number Diff line
@@ -41,9 +41,9 @@ bool TimeDependentWorkflow::initialize(const HeterogeneousMap &params) { 
  return true;

}



QuatumSimulationResult

TimeDependentWorkflow::execute(const QuatumSimulationModel &model) {

  QuatumSimulationResult result;

QuantumSimulationResult

TimeDependentWorkflow::execute(const QuantumSimulationModel &model) {

  QuantumSimulationResult result;

  evaluator = getObjEvaluator(model.observable);

  auto ham_func = model.hamiltonian;

  // A TD workflow: stepping through Trotter steps,
@@ -95,8 +95,8 @@ bool VqeWorkflow::initialize(const HeterogeneousMap &params) { 
  return (optimizer != nullptr);

}



QuatumSimulationResult

VqeWorkflow::execute(const QuatumSimulationModel &model) {

QuantumSimulationResult

VqeWorkflow::execute(const QuantumSimulationModel &model) {

  // If the model includes a concrete variational ansatz:

  if (model.user_defined_ansatz) {

    auto nParams = model.user_defined_ansatz->nParams();
@@ -135,7 +135,7 @@ bool IterativeQpeWorkflow::initialize(const HeterogeneousMap &params) { 
}



std::shared_ptr<CompositeInstruction>

IterativeQpeWorkflow::constructQpeCircuit(const QuatumSimulationModel &model,

IterativeQpeWorkflow::constructQpeCircuit(const QuantumSimulationModel &model,

                                          int k, double omega,

                                          bool measure) const {

  auto provider = xacc::getIRProvider("quantum");
@@ -184,8 +184,8 @@ IterativeQpeWorkflow::constructQpeCircuit(const QuatumSimulationModel &model, 
  return kernel;

}



QuatumSimulationResult

IterativeQpeWorkflow::execute(const QuatumSimulationModel &model) {

QuantumSimulationResult

IterativeQpeWorkflow::execute(const QuantumSimulationModel &model) {

  auto provider = xacc::getIRProvider("quantum");

  // Iterative Quantum Phase Estimation:

  // We're using XACC IR construction API here, since using QCOR kernels here
@@ -241,9 +241,9 @@ IterativeQpeWorkflow::execute(const QuatumSimulationModel &model) { 
  return { {"phase", omega_coef}};

}



std::shared_ptr<QuatumSimulationWorkflow>

std::shared_ptr<QuantumSimulationWorkflow>

getWorkflow(const std::string &name, const HeterogeneousMap &init_params) {

  auto qsim_workflow = xacc::getService<QuatumSimulationWorkflow>(name);

  auto qsim_workflow = xacc::getService<QuantumSimulationWorkflow>(name);

  if (qsim_workflow && qsim_workflow->initialize(init_params)) {

    return qsim_workflow;

  }
@@ -271,18 +271,18 @@ DefaultObjFuncEval::evaluate(std::shared_ptr<CompositeInstruction> state_prep) { 
#include "cppmicroservices/ServiceProperties.h"

namespace {

using namespace cppmicroservices;

class US_ABI_LOCAL QuatumSimulationActivator : public BundleActivator {

class US_ABI_LOCAL QuantumSimulationActivator : public BundleActivator {



public:

  QuatumSimulationActivator() {}

  QuantumSimulationActivator() {}



  void Start(BundleContext context) {

    using namespace qcor;

    context.RegisterService<qsim::QuatumSimulationWorkflow>(

    context.RegisterService<qsim::QuantumSimulationWorkflow>(

        std::make_shared<qsim::TimeDependentWorkflow>());

    context.RegisterService<qsim::QuatumSimulationWorkflow>(

    context.RegisterService<qsim::QuantumSimulationWorkflow>(

        std::make_shared<qsim::VqeWorkflow>());

    context.RegisterService<qsim::QuatumSimulationWorkflow>(

    context.RegisterService<qsim::QuantumSimulationWorkflow>(

        std::make_shared<qsim::IterativeQpeWorkflow>());

    context.RegisterService<qsim::CostFunctionEvaluator>(

        std::make_shared<qsim::DefaultObjFuncEval>());
@@ -292,4 +292,4 @@ public: 
};

} // namespace



CPPMICROSERVICES_EXPORT_BUNDLE_ACTIVATOR(QuatumSimulationActivator)
 
 No newline at end of file
 
CPPMICROSERVICES_EXPORT_BUNDLE_ACTIVATOR(QuantumSimulationActivator)
 
 No newline at end of file

lib/qsim/impls/qsim_impl.hpp

+10 −10
Original line number Diff line number Diff line
@@ -42,11 +42,11 @@ private: 
};



// VQE-type workflow which involves an optimization loop, i.e. an Optimizer.

class VqeWorkflow : public QuatumSimulationWorkflow {

class VqeWorkflow : public QuantumSimulationWorkflow {

public:

  virtual bool initialize(const HeterogeneousMap &params) override;

  virtual QuatumSimulationResult

  execute(const QuatumSimulationModel &model) override;

  virtual QuantumSimulationResult

  execute(const QuantumSimulationModel &model) override;



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

  virtual const std::string description() const override { return ""; }
@@ -57,11 +57,11 @@ private: 


// Time-dependent evolution workflow which can handle

// time-dependent Hamiltonian operator.

class TimeDependentWorkflow : public QuatumSimulationWorkflow {

class TimeDependentWorkflow : public QuantumSimulationWorkflow {

public:

  virtual bool initialize(const HeterogeneousMap &params) override;

  virtual QuatumSimulationResult

  execute(const QuatumSimulationModel &model) override;

  virtual QuantumSimulationResult

  execute(const QuantumSimulationModel &model) override;

  virtual const std::string name() const override { return "td-evolution"; }

  virtual const std::string description() const override { return ""; }
@@ -75,17 +75,17 @@ private: 
// Iterative QPE workflow to estimate the energy of a Hamiltonian operator.

// For the first pass, we implement this as a workflow.

// This can be integrated as a CostFuncEvaluator if needed.

class IterativeQpeWorkflow : public QuatumSimulationWorkflow {

class IterativeQpeWorkflow : public QuantumSimulationWorkflow {

public:

  virtual bool initialize(const HeterogeneousMap &params) override;

  virtual QuatumSimulationResult

  execute(const QuatumSimulationModel &model) override;

  virtual QuantumSimulationResult

  execute(const QuantumSimulationModel &model) override;

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

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



private:

  std::shared_ptr<CompositeInstruction>

  constructQpeCircuit(const QuatumSimulationModel &model, int k, double omega,

  constructQpeCircuit(const QuantumSimulationModel &model, int k, double omega,

                      bool measure = true) const;



private: