reader_allsteps.cpp

/*
 * Distributed under the OSI-approved Apache License, Version 2.0.  See
 * accompanying file Copyright.txt for details.
 *
 * reader.cpp
 *
 *  Created on: Feb 13, 2017
 *      Author: pnorbert
 */

#include <iostream>
#include <vector>

#include <adios2.h>
#include <mpi.h>

int main(int argc, char *argv[])
{
    int rank, nproc;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
    const bool adiosDebug = true;

    adios::ADIOS adios(MPI_COMM_WORLD, adiosDebug);

    // Application variable
    std::vector<double> NiceArray;
    std::vector<float> RaggedArray;

    int Nparts;
    int Nwriters;
    int Nsteps;

    try
    {
        // Define method for engine creation
        // 1. Get method def from config file or define new one
        adios::Method &bpReaderSettings = adios.GetMethod("input");
        if (bpReaderSettings.undeclared())
        {
            // if not defined by user, we can change the default settings
            bpReaderSettings.SetEngine("BP"); // BP is the default engine
            // By default we see all steps available in a file, so the next line
            // is
            // not needed
            bpReaderSettings.SetParameters("Stepping", false);
        }

        // Create engine smart pointer due to polymorphism,
        // Default behavior
        // auto bpReader = adios.Open( "myNumbers.bp", "r" );
        // this would just open with a default transport, which is "BP"
        auto bpReader = adios.Open("myNumbers.bp", "r", bpReaderSettings);

        // All the above is same as default use:
        // auto bpReader = adios.Open( "myNumbers.bp", "r");

        if (bpReader == nullptr)
            throw std::ios_base::failure(
                "ERROR: failed to open ADIOS bpReader\n");

        /* Note: there is no global number of steps. Each variable has its own
         * number of steps */

        /* NX */
        /* There is a single value for each step. We can read all into a 1D
         * array
         * with a step selection.
         * We can also just conveniently get the first with a simple read
         * statement.
         * Steps are not automatically presented as an array dimension and read
         * does
         * not read it as array.
         */
        unsigned int Nx;
        bpReader->Read<unsigned int>(
            "NX",
            &Nx); // read a Global scalar which has a single value in a step

        std::shared_ptr<adios::Variable<void>> varNx =
            bpReader.InquiryVariable("Nx");
        std::vector<int> Nxs(varNx->nsteps()); // number of steps available
        // make a StepSelection to select multiple steps. Args: From, #of
        // consecutive steps
        std::unique_ptr<adios::StepSelection> stepsNx =
            adios.StepSelection(0, varNx->nsteps());
        // ? How do we make a selection for an arbitrary list of steps ?
        varNX.SetStepSelection(stepsNx);
        bpReader->Read<unsigned int>(varNx, Nxs.data());

        auto itmax = std::max_element(std::begin(Nxs), std::end(Nxs));
        auto itmin = std::min_element(std::begin(Nxs), std::end(Nxs));
        if (*itmin != *itmax)
        {
            throw std::ios_base::failure(
                "ERROR: NX is not the same at all steps!\n");
        }

        /* nproc */
        bpReader->Read<int>("nproc", &Nwriters); // also a global scalar

        /* Nparts */
        // Nparts local scalar is presented as a 1D array of Nwriters elements.
        // We can read all steps into a 2D array of nproc * Nwriters
        std::shared_ptr<adios::Variable<void>> varNparts =
            bpReader.InquiryVariable("Nparts");
        std::vector<int> partsV(Nproc * Nwriters);
        varNparts->SetStepSelection(
            adios.StepSelection(0, varNparts->nsteps()));
        bpReader->Read<int>(varNparts,
                            partsV.data()); // missing spatial selection = whole
                                            // array at each step

        /* Nice */
        // inquiry about a variable, whose name we know
        std::shared_ptr<adios::Variable<void>> varNice =
            bpReader.InquiryVariable("Nice");

        if (varNice == nullptr)
            throw std::ios_base::failure("ERROR: failed to find variable "
                                         "'myDoubles' in input file\n");

        // ? how do we know about the type? std::string varNice->m_Type
        unsigned long long int gdim =
            varMyDoubles->m_GlobalDimensions[0]; // ?member var or member func?
        unsigned long long int ldim = gdim / nproc;
        unsigned long long int offs = rank * ldim;
        if (rank == nproc - 1)
        {
            ldim = gdim - (ldim * gdim);
        }

        NiceArray.reserve(ldim);

        // Make a 1D selection to describe the local dimensions of the variable
        // we
        // READ and
        // its offsets in the global spaces
        std::unique_ptr<adios::Selection> bbsel = adios.SelectionBoundingBox(
            {ldim}, {offs}); // local dims and offsets; both as list
        bpReader->Read<double>("Nice", bbsel,
                               NiceArray.data()); // Base class Engine own the
                                                  // Read<T> that will call
        // overloaded Read from Derived

        /* Ragged */
        // inquiry about a variable, whose name we know
        std::shared_ptr<adios::Variable<void>> varRagged =
            bpReader.InquiryVariable("Ragged");
        if (varRagged->m_GlobalDimensions[1] != adios::VARYING_DIMENSION)
        {
            throw std::ios_base::failure(
                "Unexpected condition: Ragged array's fast dimension "
                "is supposed to be VARYING_DIMENSION\n");
        }
        // We have here varRagged->sum_nblocks, nsteps, nblocks[], global
        if (rank <
            varRagged->nblocks[0]) // same as rank < Nwriters in this example
        {
            // get per-writer size information
            varRagged->InquiryBlocks();
            // now we have the dimensions per block

            unsigned long long int ldim =
                varRagged->blockinfo[rank].m_Dimensions[0];
            RaggedArray.resize(ldim);

            std::unique_ptr<adios::Selection> wbsel =
                adios.SelectionWriteblock(rank);
            bpReader->Read<float>("Ragged", wbsel, RaggedArray.data());

            // We can use bounding box selection as well
            std::unique_ptr<adios::Selection> rbbsel =
                adios.SelectionBoundingBox({1, ldim}, {rank, 0});
            bpReader->Read<float>("Ragged", rbbsel, RaggedArray.data());
        }

        /* Extra help to process Ragged */
        int maxRaggedDim =
            varRagged->GetMaxGlobalDimensions(1); // contains the largest
        std::vector<int> raggedDims = varRagged->GetVaryingGlobalDimensions(
            1); // contains all individual sizes in that dimension

        // Close file/stream
        bpReader->Close();
    }
    catch (std::invalid_argument &e)
    {
        if (rank == 0)
        {
            std::cout << "Invalid argument exception, STOPPING PROGRAM\n";
            std::cout << e.what() << "\n";
        }
    }
    catch (std::ios_base::failure &e)
    {
        if (rank == 0)
        {
            std::cout << "System exception, STOPPING PROGRAM\n";
            std::cout << e.what() << "\n";
        }
    }
    catch (std::exception &e)
    {
        if (rank == 0)
        {
            std::cout << "Exception, STOPPING PROGRAM\n";
            std::cout << e.what() << "\n";
        }
    }

    MPI_Finalize();

    return 0;
}