updated heat2d for the new ADIOS2 public API

Author: JasonRuonanWang

Tutorial/heat2d/cpp/analysis/heatAnalysis.cpp

@@ -88,27 +88,27 @@ int main(int argc, char *argv[])
         adios2::ADIOS ad(settings.configfile, mpiReaderComm, adios2::DebugON);
 
         // Define IO method for engine creation
-        adios2::IO &inIO = ad.DeclareIO("SimulationOutput");
-        adios2::IO &outIO = ad.DeclareIO("AnalysisOutput");
+        adios2::IO inIO = ad.DeclareIO("SimulationOutput");
+        adios2::IO outIO = ad.DeclareIO("AnalysisOutput");
         if (!rank)
         {
-            std::cout << "Using " << inIO.m_EngineType << " engine for input" << std::endl;
-            std::cout << "Using " << outIO.m_EngineType << " engine for output" << std::endl;
+//            std::cout << "Using " << inIO.m_EngineType << " engine for input" << std::endl;
+//            std::cout << "Using " << outIO.m_EngineType << " engine for output" << std::endl;
         }
 
 
-        adios2::Engine &reader =
+        adios2::Engine reader =
             inIO.Open(settings.inputfile, adios2::Mode::Read, mpiReaderComm);
 
         reader.FixedSchedule(); // a promise here that we don't change the read pattern over steps
 
         std::vector<double> Tin;
         std::vector<double> Tout;
         std::vector<double> dT;
-        adios2::Variable<double> *vTin = nullptr;
-        adios2::Variable<double> *vTout = nullptr;
-        adios2::Variable<double> *vdT = nullptr;
-        adios2::Engine *writer = nullptr;
+        adios2::Variable<double> vTin;
+        adios2::Variable<double> vTout;
+        adios2::Variable<double> vdT;
+        adios2::Engine writer;
         bool firstStep = true;
         int step = 0;
 
@@ -133,8 +133,8 @@ int main(int argc, char *argv[])
 
             if (firstStep)
             {
-                unsigned int gndx = vTin->m_Shape[0];
-                unsigned int gndy = vTin->m_Shape[1];
+                unsigned int gndx = vTin.Shape()[0];
+                unsigned int gndy = vTin.Shape()[1];
 
                 if (rank == 0)
                 {
@@ -148,24 +148,24 @@ int main(int argc, char *argv[])
                 dT.resize(settings.readsize[0] * settings.readsize[1]);
 
                 /* Create output variables and open output stream */
-                vTout = &outIO.DefineVariable<double>(
+                vTout = outIO.DefineVariable<double>(
                     "T", {gndx, gndy}, settings.offset, settings.readsize);
-                vdT = &outIO.DefineVariable<double>(
+                vdT = outIO.DefineVariable<double>(
                     "dT", {gndx, gndy}, settings.offset, settings.readsize);
-                writer = &outIO.Open(settings.outputfile, adios2::Mode::Write,
+                writer = outIO.Open(settings.outputfile, adios2::Mode::Write,
                                      mpiReaderComm);
-                writer->FixedSchedule(); 
+                writer.FixedSchedule();
 
                 MPI_Barrier(mpiReaderComm); // sync processes just for stdout
             }
 
             // Create a 2D selection for the subset
-            vTin->SetSelection(
+            vTin.SetSelection(
                 adios2::Box<adios2::Dims>(settings.offset, settings.readsize));
 
             // Arrays are read by scheduling one or more of them
             // and performing the reads at once
-            reader.Get<double>(*vTin, Tin.data());
+            reader.Get<double>(vTin, Tin.data());
             /*printDataStep(Tin.data(), settings.readsize.data(),
                           settings.offset.data(), rank, step); */
             reader.EndStep();
@@ -183,17 +183,16 @@ int main(int argc, char *argv[])
             Compute(Tin, Tout, dT, firstStep);
 
             /* Output Tout and dT */
-            writer->BeginStep();
-            writer->Put<double>(*vTout, Tout.data());
-            writer->Put<double>(*vdT, dT.data());
-            writer->EndStep();
+            writer.BeginStep();
+            writer.Put<double>(vTout, Tout.data());
+            writer.Put<double>(vdT, dT.data());
+            writer.EndStep();
 
             step++;
             firstStep = false;
         }
         reader.Close();
-        if (writer != nullptr)
-            writer->Close();
+        writer.Close();
     }
     catch (std::invalid_argument &e) // command-line argument errors
     {

Tutorial/heat2d/cpp/make.settings

@@ -26,7 +26,7 @@ LDFLAGS=-g  -O2
 # VTK-m settings (need separate include and libraries)
 #
 # set USE_VTKM to OFF if you don't have VTK-m 
-USE_VTKM=ON  
+USE_VTKM=ON
 override VTKM_DIR=/opt/vtk-m
 override VTKM_INC=-I${VTKM_DIR}/include/vtkm-1.1
 override VTKM_LIB=-L${VTKM_DIR}/lib -lvtkm_rendering-1.1 -lvtkm_cont-1.1

Tutorial/heat2d/cpp/simulation/IO_adios2.cpp

@@ -16,15 +16,15 @@
 #include <adios2.h>
 
 adios2::ADIOS *ad = nullptr;
-adios2::Engine *writer = nullptr;
-adios2::Variable<double> *varT = nullptr;
-adios2::Variable<unsigned int> *varGndx = nullptr;
+adios2::Engine writer;
+adios2::Variable<double> varT;
+adios2::Variable<unsigned int> varGndx;
 
 IO::IO(const Settings &s, MPI_Comm comm)
 {
     ad = new adios2::ADIOS(s.configfile, comm, adios2::DebugON);
 
-    adios2::IO &io = ad->DeclareIO("SimulationOutput");
+    adios2::IO io = ad->DeclareIO("SimulationOutput");
     if (!io.InConfigFile())
     {
         // if not defined by user, we can change the default settings
@@ -39,11 +39,11 @@ IO::IO(const Settings &s, MPI_Comm comm)
 
     if (!s.rank)
     {
-        std::cout << "Using " << io.m_EngineType << " engine for output" << std::endl;
+//        std::cout << "Using " << io.m_EngineType << " engine for output" << std::endl;
     }
 
     // define T as 2D global array
-    varT = &io.DefineVariable<double>(
+    varT = io.DefineVariable<double>(
         "T",
         // Global dimensions
         {s.gndx, s.gndy},
@@ -52,29 +52,29 @@ IO::IO(const Settings &s, MPI_Comm comm)
         // local size, could be defined later using SetSelection()
         {s.ndx, s.ndy});
 
-    writer = &io.Open(s.outputfile, adios2::Mode::Write, comm);
+    writer = io.Open(s.outputfile, adios2::Mode::Write, comm);
 
     // Some optimization:
     // we promise here that we don't change the variables over steps
     // (the list of variables, their dimensions, and their selections)
-    writer->FixedSchedule(); 
+    writer.FixedSchedule();
 }
 
 IO::~IO()
 {
-    writer->Close();
+    writer.Close();
     delete ad;
 }
 
 void IO::write(int step, const HeatTransfer &ht, const Settings &s,
                MPI_Comm comm)
 {
-    writer->BeginStep();
+    writer.BeginStep();
     // using Put() you promise the pointer to the data will be intact
     // until the end of the output step.
     // We need to have the vector object here not to destruct here until the end
     // of function.
     std::vector<double> v = ht.data_noghost();
-    writer->Put<double>(*varT, v.data());
-    writer->EndStep();
+    writer.Put<double>(varT, v.data());
+    writer.EndStep();
 }

Tutorial/heat2d/cpp/visualization/VizOutput.h

@@ -15,8 +15,8 @@
 
 #include "VizSettings.h"
 
-void OutputVariable(const adios2::VariableBase *var,
-                    const std::vector<double> data, VizSettings &settings,
+void OutputVariable(const adios2::Variable<double> &var,
+                    const std::vector<double> &data, VizSettings &settings,
                     const int step);
 
 #endif /* VIZOUTPUT_H_ */

Tutorial/heat2d/cpp/visualization/VizOutputPrint.cpp

@@ -13,16 +13,17 @@
 #include <iomanip>
 #include <iostream>
 #include <string>
+#include <numeric>
 
 #include "VizOutput.h"
 
-void OutputVariable(const adios2::VariableBase *var,
-                    const std::vector<double> data, VizSettings &settings,
+void OutputVariable(const adios2::Variable<double> &var,
+                    const std::vector<double> &data, VizSettings &settings,
                     const int step)
 {
     // void printDataStep(double *xy, T *size, T *offset, int rank, int step)
     std::ofstream myfile;
-    std::string filename = var->m_Name + ".txt";
+    std::string filename = var.Name() + ".txt";
     if (step == 0)
     {
         myfile.open(filename);
@@ -32,26 +33,26 @@ void OutputVariable(const adios2::VariableBase *var,
         myfile.open(filename, std::ios::app);
     }
     const double *buf = data.data();
-    uint64_t nelems = var->TotalSize();
-    myfile << "size=" << var->m_Shape[0] << "x" << var->m_Shape[1]
+    uint64_t nelems = std::accumulate(var.Count().begin(), var.Count().end(), var.Sizeof(), std::multiplies<size_t>());
+    myfile << "size=" << var.Shape()[0] << "x" << var.Shape()[1]
            << " step=" << step << std::endl;
 
-    myfile << " time   row   columns 0 ..." << var->m_Shape[1] - 1 << std::endl;
+    myfile << " time   row   columns 0 ..." << var.Shape()[1] - 1 << std::endl;
     myfile << "        ";
-    for (int j = 0; j < var->m_Shape[1]; j++)
+    for (int j = 0; j < var.Shape()[1]; j++)
     {
         myfile << std::setw(9) << j;
     }
     myfile << std::endl;
     myfile << "------------------------------------------------------------"
               "--\n";
-    for (int i = 0; i < var->m_Shape[0]; i++)
+    for (int i = 0; i < var.Shape()[0]; i++)
     {
         myfile << std::setw(5) << step << std::setw(5) << i;
-        for (int j = 0; j < var->m_Shape[1]; j++)
+        for (int j = 0; j < var.Shape()[1]; j++)
         {
             myfile << std::setw(9) << std::setprecision(4)
-                   << buf[i * var->m_Shape[1] + j];
+                   << buf[i * var.Shape()[1] + j];
         }
         myfile << std::endl;
     }

Tutorial/heat2d/cpp/visualization/VizOutputVtkm.cpp

@@ -70,7 +70,7 @@ void Render2D(const vtkm::cont::DataSet &ds, const std::string &fieldNm,
     view.SaveAs(settings.outputfile);
 }
 
-bool RenderVariable2D(const adios2::VariableBase *var, const void *buff,
+bool RenderVariable2D(const adios2::Variable<double> &var, const void *buff,
                       const VizSettings &settings)
 {
     /*
@@ -86,9 +86,9 @@ bool RenderVariable2D(const adios2::VariableBase *var, const void *buff,
     */
 
     // Create the dataset from the variables
-    vtkm::Vec<float, 2> origin(var->m_Start[1], var->m_Start[0]);
+    vtkm::Vec<float, 2> origin(var.Start()[1], var.Start()[0]);
     vtkm::Vec<float, 2> spacing(1, 1);
-    vtkm::Id2 dims(var->m_Count[1], var->m_Count[0]); // SET DIMS
+    vtkm::Id2 dims(var.Count()[1], var.Count()[0]); // SET DIMS
 
     vtkm::cont::DataSetBuilderUniform dsb;
     vtkm::cont::DataSet ds = dsb.Create(dims, origin, spacing);
@@ -99,19 +99,19 @@ bool RenderVariable2D(const adios2::VariableBase *var, const void *buff,
     vtkm::Id numPoints = dims[0] * dims[1];
 
     vtkm::cont::DataSetFieldAdd dsf;
-    dsf.AddPointField(ds, var->m_Name, varBuff, numPoints);
+    dsf.AddPointField(ds, var.Name(), varBuff, numPoints);
     //ds.PrintSummary(std::cout);
 
-    Render2D(ds, var->m_Name, vtkm::rendering::ColorTable("temperature"),
+    Render2D(ds, var.Name(), vtkm::rendering::ColorTable("temperature"),
              settings);
 
     return true;
 }
 
-void OutputVariable(const adios2::VariableBase *var,
-                    const std::vector<double> data, VizSettings &settings,
+void OutputVariable(const adios2::Variable<double> &var,
+                    const std::vector<double> &data, VizSettings &settings,
                     const int step)
 {
-    settings.outputfile = var->m_Name + "." + std::to_string(step) + ".pnm";
+    settings.outputfile = var.Name() + "." + std::to_string(step) + ".pnm";
     RenderVariable2D(var, data.data(), settings);
 }

Tutorial/heat2d/cpp/visualization/heatVisualization.cpp

@@ -16,6 +16,7 @@
 #include <vector>
 #include <chrono>
 #include <thread>
+#include <numeric>
 
 #include "VizOutput.h"
 #include "VizSettings.h"
@@ -65,19 +66,19 @@ int main(int argc, char *argv[])
             // Define method for engine creation
             // 1. Get method def from config file or define new one
 
-            adios2::IO &inIO = ad.DeclareIO("VizInput");
+            adios2::IO inIO = ad.DeclareIO("VizInput");
 
             if (!rank)
             {
-                std::cout << "Using " << inIO.m_EngineType << " engine for input" << std::endl;
+//                std::cout << "Using " << inIO.m_EngineType << " engine for input" << std::endl;
             }
 
-            adios2::Engine &reader = inIO.Open(
+            adios2::Engine reader = inIO.Open(
                 settings.inputfile, adios2::Mode::Read, MPI_COMM_SELF);
             reader.FixedSchedule(); // a promise here that we don't change the read pattern over steps
 
             std::vector<double> Tin;
-            adios2::Variable<double> *vTin = nullptr;
+            adios2::Variable<double> vTin;
             bool firstStep = true;
             int step = 0;
 
@@ -106,18 +107,18 @@ int main(int argc, char *argv[])
                 {
                     if (rank == 0)
                     {
-                        std::cout << "gndx       = " << vTin->m_Shape[0]
+                        std::cout << "gndx       = " << vTin.Shape()[0]
                                   << std::endl;
-                        std::cout << "gndy       = " << vTin->m_Shape[1]
+                        std::cout << "gndy       = " << vTin.Shape()[1]
                                   << std::endl;
                     }
-                    Tin.resize(vTin->TotalSize());
+                    Tin.resize(std::accumulate(vTin.Count().begin(), vTin.Count().end(), vTin.Sizeof(), std::multiplies<size_t>()));
                 }
 
                 // Create a 2D selection for the subset
-                vTin->SetSelection(
-                    adios2::Box<adios2::Dims>({0, 0}, vTin->m_Shape));
-                reader.Get<double>(*vTin, Tin.data());
+                vTin.SetSelection(
+                    adios2::Box<adios2::Dims>({0, 0}, vTin.Shape()));
+                reader.Get<double>(vTin, Tin.data());
                 reader.EndStep();
 
                 std::cout << "Visualization step " << step