Updated examples:

1. xacc_app: XACC application: User application depends on XACC.
2. exatn_app: ExaTN application: User application depends on ExaTN.

Author: DmitryLyakh

CMakeLists.txt

@@ -1,12 +1,11 @@
 cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
-project(integration_test VERSION 1.0.0 LANGUAGES CXX)
+project(xacc_app VERSION 1.0.0 LANGUAGES CXX)
 
 set(CMAKE_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
 
-# Find Xacc
 find_package(XACC REQUIRED)
 
-add_executable(integration_test integration_test.cpp)
-target_link_libraries(integration_test PRIVATE xacc::xacc)
+add_executable(xacc_app xacc_app.cpp)
+target_link_libraries(xacc_app PRIVATE xacc::xacc)

exatn_app.cpp

@@ -0,0 +1,47 @@
+#include "exatn.hpp"
+
+#include <vector>
+
+void exatn_simulation() {
+
+ auto tensor = std::make_shared<exatn::Tensor>("Tensor",exatn::TensorShape{2,2,2,2,2});
+ auto success = exatn::createTensor(tensor,exatn::TensorElementType::REAL64); assert(success);
+
+ std::vector<double> tensor_data(32,1.0);
+ success = exatn::initTensorData("Tensor",tensor_data); assert(success);
+
+ success = exatn::destroyTensor("Tensor"); assert(success);
+
+ exatn::sync();
+
+ return;
+}
+
+
+int main(int argc, char** argv) {
+
+ //Initialize the ExaTN runtime:
+ exatn::ParamConf exatn_parameters;
+ //Set the available CPU Host RAM size to be used by ExaTN:
+ exatn_parameters.setParameter("host_memory_buffer_size",2L*1024L*1024L*1024L);
+#ifdef MPI_ENABLED
+ int thread_provided;
+ int mpi_error = MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &thread_provided);
+ assert(mpi_error == MPI_SUCCESS);
+ assert(thread_provided == MPI_THREAD_MULTIPLE);
+ exatn::initialize(exatn::MPICommProxy(MPI_COMM_WORLD),exatn_parameters,"lazy-dag-executor");
+#else
+ exatn::initialize(exatn_parameters,"lazy-dag-executor");
+#endif
+
+ //Perform the ExaTN simulation defined above:
+ exatn_simulation();
+
+ //Finalize the ExaTN runtime:
+ exatn::finalize();
+#ifdef MPI_ENABLED
+ mpi_error = MPI_Finalize(); assert(mpi_error == MPI_SUCCESS);
+#endif
+
+ return 0;
+}

integration_test.cpp

@@ -0,0 +1,3 @@
+rm *.o *.x
+g++ `$HOME/.exatn/bin/exatn-config --cxxflags` `$HOME/.exatn/bin/exatn-config --includes` -c exatn_app.cpp -o exatn_app.o
+g++ exatn_app.o `$HOME/.exatn/bin/exatn-config --libs` -o exatn_app.x

make.sh

@@ -0,0 +1,3 @@
+rm *.o *.x
+g++ `$HOME/.exatn/bin/exatn-config --cxxflags` `$HOME/.exatn/bin/exatn-config --includes` -I $HOME/.xacc/include/xacc -c xacc_app.cpp -o xacc_app.o
+g++ xacc_app.o -Wl,-rpath,$HOME/.xacc/lib -L $HOME/.xacc/lib -lxacc `$HOME/.exatn/bin/exatn-config --libs` -o xacc_app.x

make_exatn_app.sh

@@ -0,0 +1,52 @@
+#include "xacc.hpp"
+
+void tnqvm_simulation() {
+
+ //Choose the desired quantum accelerator:
+ auto qpu = xacc::getAccelerator("tnqvm", {std::make_pair("tnqvm-visitor", "exatn")});
+
+ //Choose the desired quantum programming language:
+ auto xasmCompiler = xacc::getCompiler("xasm");
+
+ //Compile a quantum kernel into the quantum IR:
+ auto ir = xasmCompiler->compile(
+ R"(__qpu__ void ansatz(qbit q, double theta) {
+    X(q[0]);
+    Ry(q[1], theta);
+    CX(q[1], q[0]);
+    H(q[0]);
+    H(q[1]);
+    Measure(q[0]);
+    Measure(q[1]);
+ })", qpu);
+
+ //Get the generated parameterized quantum circuit:
+ auto circuit = ir->getComposite("ansatz");
+
+ //Perform hybrid quantum/classical computation:
+ auto angles = xacc::linspace(-3.1415, 3.1415, 20);
+ for (auto & a: angles) {
+  auto evaled = (*circuit)({a});
+  auto qubits = xacc::qalloc(2);
+  qpu->execute(qubits, evaled);
+  auto exp_val = qubits->getExpectationValueZ();
+  std::cout << "<X0X1>(" << a << ") = " << exp_val << "\n";
+ }
+
+ return;
+}
+
+
+int main(int argc, char** argv) {
+
+ //Initialize the XACC runtime:
+ xacc::Initialize(argc, argv);
+
+ //Perform the quantum circuit simulation defined above:
+ tnqvm_simulation();
+
+ //Finalize the XACC runtime:
+ xacc::Finalize();
+
+ return 0;
+}