Merge pull request #41 from tnguyen-ornl/tnguyen/python-bindings-wip

  add_subdirectory(examples)

endif()

# Compile and install Python binding if Python found:

find_package(Python COMPONENTS Interpreter Development)

if(Python_FOUND)

 if(${Python_VERSION} VERSION_GREATER_EQUAL 3.0.0)

   message(STATUS "Found Python version ${Python_VERSION}. Building QCOR Python API with ${Python_INCLUDE_DIRS}")

   add_subdirectory(python)

 else()

  message(STATUS "Found Python version ${Python_VERSION}. Version must be greater than 3.0.0, skipping Python API build.")

 endif()

else()

  message(STATUS "Python interpreter or development headers not found. Skipping Python API build.")

endif()

if (QCOR_CPACK_DEB_PLATFORM)

message(STATUS "CPack DEB Build Enabled.") 

set(LIBRARY_NAME _pyqcor)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")

set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -O2 -g -pipe -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wformat -fexceptions --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=native -D_GNU_SOURCE -fPIC -fwrapv")

if(APPLE)

   set(CMAKE_SHARED_LIBRARY_SUFFIX ".so")

endif(APPLE)

file(GLOB SRC *.cpp)

add_library(${LIBRARY_NAME} SHARED ${SRC})

target_include_directories(${LIBRARY_NAME} PUBLIC .

                                          ${CMAKE_SOURCE_DIR}/lib/qsim

                                          ${Python_INCLUDE_DIRS}

                                          ${XACC_ROOT}/include/pybind11/include)

set_target_properties(${LIBRARY_NAME} PROPERTIES PREFIX "")

target_link_libraries(${LIBRARY_NAME} PUBLIC qcor qcor-qsim)

if(APPLE)

   set_target_properties(${LIBRARY_NAME} PROPERTIES INSTALL_RPATH "@loader_path/lib")

   set_target_properties(${LIBRARY_NAME} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")

else()

   set_target_properties(${LIBRARY_NAME} PROPERTIES INSTALL_RPATH "$ORIGIN/lib")

   set_target_properties(${LIBRARY_NAME} PROPERTIES LINK_FLAGS "-shared")

endif()

install(FILES qcor.py DESTINATION ${CMAKE_INSTALL_PREFIX})

install(TARGETS _pyqcor DESTINATION ${CMAKE_INSTALL_PREFIX})

 No newline at end of file

import sys

from pathlib import Path

sys.path.insert(1, str(Path.home()) + '/.xacc')

from qcor import *

# Time-dependent Hamiltonian: 

# Returns the Pauli operators at a time point.

def td_hamiltonian(t):

  omega = 1.0

  print("HOWDY: Python callback")

  return X(0) + X(1) + X(2)

# This is for testing-purposes only

observable = X(0)*X(1) + Z(0) + Z(1)

print("observable = ", observable.toString())

optimizer = createOptimizer('nlopt')

model = qsim.ModelBuilder.createModel(observable, td_hamiltonian)

 No newline at end of file

#include "base/qcor_qsim.hpp"

#include <pybind11/functional.h>

#include <pybind11/pybind11.h>

namespace py = pybind11;

PYBIND11_MODULE(_pyqcor, m) {

  m.doc() = "Python bindings for QCOR.";

  // Expose QCOR API functions

  m.def(

      "createOptimizer",

      [](const std::string &name, py::dict p = {}) {

        xacc::HeterogeneousMap params;

        std::cout << "HOWDY: " << name << "\n";

        /// TODO: reuse XACC PyHetMap here

        for (auto item : p) {

          std::cout << "key=" << std::string(py::str(item.first)) << ", "

                    << "value=" << std::string(py::str(item.second)) << "\n";

        }

        return qcor::createOptimizer(name, std::move(params));

      },

      py::arg("name"), py::arg("p") = py::dict(),

      py::return_value_policy::reference,

      "Return the Optimizer with given name.");

  // qsim sub-module bindings:

  {

    py::module qsim = m.def_submodule("qsim", "QCOR's python qsim submodule");

    // QuantumSimulationModel bindings:

    py::class_<qcor::qsim::QuantumSimulationModel>(

        qsim, "QuantumSimulationModel",

        "The QuantumSimulationModel captures the quantum simulation problem "

        "description.")

        .def(py::init<>());

    // ModelBuilder bindings:

    py::class_<qcor::qsim::ModelBuilder>(

        qsim, "ModelBuilder",

        "The ModelBuilder interface provides methods to "

        "construct qsim problem models.")

        .def(py::init<>())

        .def(

            "createModel",

            [](qcor::PauliOperator &obs, qcor::qsim::TdObservable ham_func) {

              return qcor::qsim::ModelBuilder::createModel(obs, ham_func);

            },

            "Return the Model for a time-dependent problem.");

  }

}

from _pyqcor import *

# TODO: will need to selectively import XACC

import xacc

def X(idx):

  return xacc.quantum.PauliOperator({idx: 'X'}, 1.0) 

def Y(idx):

  return xacc.quantum.PauliOperator({idx: 'Y'}, 1.0) 

def Z(idx):

  return xacc.quantum.PauliOperator({idx: 'Z'}, 1.0)