GenericInput.tpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
 
namespace mimmo{
 
namespace inputCSVStream{
 
template <typename T>
std::fstream&
ifstreamcsv(std::fstream &in, T &x){
 
    T                   dummy{};
    char                delim;
    if ((in.good())) {
        if (in >> dummy && in >> delim && !in.bad()) { x = dummy;}
    }
    return(in);
}
 
template <typename T>
std::fstream&  ifstreamcsvend(std::fstream &in, T &x){
 
    T                   dummy{};
    if ((in.good())) {
        if (in >> dummy && !in.bad()) { x = dummy;}
    }
    return(in);
}
 
template <typename T>
std::fstream&  ifstreamcsv(std::fstream &in, std::vector< T > &x){
 
    T       dummy;
 
    while (in.good()) {
        if (ifstreamcsv(in,dummy) && !in.bad()) { x.push_back(dummy); }
    }
    return(in);
}
 
template <typename T>
std::fstream&  ifstreamcsvend(std::fstream &in, std::vector< T > &x){
        return ifstreamcsv(in, x);
}
 
template <typename T, size_t d>
std::fstream&  ifstreamcsv(std::fstream &in, std::array< T, d> &x){
    T       dummy{};
    size_t     i;
 
    i = 0;
    while ((in.good()) && (i < d-1)) {
        if (ifstreamcsv(in,dummy) && !in.bad()) {
            x[i] = dummy;
        }
        i++;
    } //next i
    if (ifstreamcsvend(in,dummy) && !in.bad()) {
        x[i] = dummy;
    }
    return(in);
};
 
template <typename T, size_t d>
std::fstream&  ifstreamcsvend(std::fstream &in, std::array< T, d> &x){
    return ifstreamcsv(in,x);
};
 
template <typename T>
std::fstream&  ifstreamcsv(std::fstream &in, MimmoPiercedVector< T > &x){
 
    T       dummy;
    long    id;
    std::string name;
    int     location;
    long    sizeData = 0, readSizeData;
 
    if(ifstreamcsvend(in, name) && !in.bad()){
        x.setName(name);
    }
    if(ifstreamcsvend(in, location) && !in.bad()){
        if(x.intIsValidLocation(location)) x.setDataLocation(static_cast<MPVLocation>(location));
    }
    if(ifstreamcsvend(in, readSizeData) && !in.bad()){
        sizeData = long(readSizeData);
    }
    x.reserve(sizeData);
    for(long count = 0; count<sizeData; ++count){
        ifstreamcsv(in,id) ;
        ifstreamcsvend(in,dummy);
        x.insert(id,dummy);
    }
    return(in);
}
 
template<typename T, size_t d >
std::fstream&  ifstreamcsv(std::fstream &in, MimmoPiercedVector< std::array< T,d > > &x){
 
    std::array<T,d>  dummy;
    long    id;
    std::string name;
    int     location;
    long    sizeData = 0, readSizeData;
 
    if(ifstreamcsvend(in, name) && !in.bad()){
        x.setName(name);
    }
    if(ifstreamcsvend(in, location) && !in.bad()){
        if(x.intIsValidLocation(location)) x.setDataLocation(static_cast<MPVLocation>(location));
    }
    if(ifstreamcsvend(in, readSizeData) && !in.bad()){
        if (readSizeData < std::numeric_limits<long>::max())
            sizeData = long(readSizeData);
        else
            sizeData = 0;
    }
    x.reserve(sizeData);
    for(long count = 0; count<sizeData; ++count){
        ifstreamcsv(in,id) ;
        ifstreamcsvend(in,dummy);
 
        x.insert(id,dummy);
    }
    return(in);
}
 
 
}
 
 
template<typename T>
void
GenericInput::setInput(T* data){
    _setInput(data);
    _setResult(data);
}
 
template<typename T>
void
GenericInput::setInput(T& data){
    _setInput(data);
    _setResult(data);
}
 
template<typename T>
T*
GenericInput::getInput(){
    return(static_cast<IODataT<T>*>(m_input.get())->getData());
}
 
template<typename T>
void
GenericInput::setResult(T* data){
    m_result = std::move(std::unique_ptr<IOData>(new IODataT<T>(*data)));
}
 
template<typename T>
void
GenericInput::setResult(T& data){
    m_result = std::move(std::unique_ptr<IOData>(new IODataT<T>(data)));
}
 
template<typename T>
void
GenericInput::_setInput(T* data){
    m_input = std::move(std::unique_ptr<IOData>(new IODataT<T>(*data)));
}
 
template<typename T>
void
GenericInput::_setInput(T& data){
    m_input = std::move(std::unique_ptr<IOData>(new IODataT<T>(data)));
}
 
template<typename T>
T*
GenericInput::_getInput(){
    return(static_cast<IODataT<T>*>(m_input.get())->getData());
}
 
template<typename T>
void
GenericInput::_setResult(T* data){
    m_result = std::move(std::unique_ptr<IOData> (new IODataT<T>(*data)));
}
 
template<typename T>
void
GenericInput::_setResult(T& data){
    m_result = std::move(std::unique_ptr<IOData> (new IODataT<T>(data)));
}
 
template<typename T>
T*
GenericInput::_getResult(){
    return(static_cast<IODataT<T>*>(m_result.get())->getData());
}
 
template<typename T>
T
GenericInput::getResult(){
    if (m_readFromFile){
        T data;
#if MIMMO_ENABLE_MPI
        if(getRank() == 0)
# endif
        {
            std::fstream file;
            file.open(m_dir+"/"+m_filename, std::fstream::in);
            if (file.is_open()){
                if (m_csv){
                    inputCSVStream::ifstreamcsv(file, data);
                }
                else{
                    file >> data;
                }
                file.close();
            }else{
                (*m_log) << "Error GenericInput: file not open --> exit" << std::endl;
                throw std::runtime_error (m_name + " : cannot open " + m_filename + " requested");
            }
 
        }
 
#if MIMMO_ENABLE_MPI
        // 0 read something, let's share with all its friends.
        if(m_nprocs > 1)    sendReadDataToAllProcs(data);
#endif
        //finally store it in result slot.
        _setResult(data);
    }
 
    //ready to return the data.
    return  *static_cast<IODataT<T>*>(m_result.get())->getData();
}
 
#if MIMMO_ENABLE_MPI
 
template<typename T>
void
GenericInput::sendReadDataToAllProcs(T & dataTC){
 
    if(getRank() == 0){
 
        //create char output data buffer and reverse data into it.
        mimmo::OBinaryStream dataBuffer;
        dataBuffer << dataTC;
        long dataBufferSize = dataBuffer.getSize();
        //Send data to all other procs
        for (int sendRank=1; sendRank<m_nprocs; sendRank++){
           MPI_Send(&dataBufferSize, 1, MPI_LONG, sendRank, 100, m_communicator);
           MPI_Send(dataBuffer.data(), dataBuffer.getSize(), MPI_CHAR, sendRank, 110, m_communicator);
        }
        //hey 0, your job is done.
    }else{
 
        long dataBufferSize;
        MPI_Recv(&dataBufferSize, 1, MPI_LONG, 0, 100, m_communicator, MPI_STATUS_IGNORE);
        mimmo::IBinaryStream dataBuffer(dataBufferSize);
        MPI_Recv(dataBuffer.data(), dataBuffer.getSize(), MPI_CHAR, 0, 110, m_communicator, MPI_STATUS_IGNORE);
 
        dataBuffer >> dataTC;
    }
}
 
#endif
 
 
//GENERICINPUTMPVDATA/////////////////////////////////////////////////////
 
 
template < typename T>
MimmoPiercedVector< T > *
GenericInputMPVData::getResult(){
    return _getResult< T >() ;
}
 
template<typename T>
void
GenericInputMPVData::_setResult(MimmoPiercedVector< T > * data){
    m_result = std::move(std::unique_ptr<IOData> (new IODataT<MimmoPiercedVector< T > >(*data)));
}
 
template<typename T>
void
GenericInputMPVData::_setResult(MimmoPiercedVector< T > & data){
    m_result = std::move(std::unique_ptr<IOData> (new IODataT<MimmoPiercedVector < T > >(data)));
}
 
template<typename T>
MimmoPiercedVector< T >*
GenericInputMPVData::_getResult(){
 
    MimmoPiercedVector< T > data;
    MimmoSharedPointer<MimmoObject> refgeo = getGeometry();
 
#if MIMMO_ENABLE_MPI
    if(getRank() == 0)
#endif
    {
        std::string name;
        int n_loc;
        long nSize = 0, readNSize;
        long id;
        T data_T;
 
        if(m_csv)   m_binary = false;
 
        std::fstream file;
        file.open(m_dir+"/"+m_filename, std::fstream::in);
        if (file.is_open()){
            if (m_binary){
                std::size_t length;
                bitpit::genericIO::absorbBINARY(file, length);
                std::vector<char> namevector(length);
                for (std::size_t i=0; i<length; i++){
                    bitpit::genericIO::absorbBINARY(file, namevector[i]);
                }
                name = std::string(name.begin(), name.end());
                bitpit::genericIO::absorbBINARY(file, n_loc);
                bitpit::genericIO::absorbBINARY(file, nSize);
                data.reserve(nSize);
                for(int i=0; i<nSize; ++i){
                    bitpit::genericIO::absorbBINARY(file, id);
                    bitpit::genericIO::absorbBINARY(file, data_T);
                    data.insert(id,data_T);
                }
                data.setDataLocation(n_loc);
                data.setName(name);
            }
            else if (m_csv){
                inputCSVStream::ifstreamcsv(file, data);
            }else{
                bitpit::genericIO::absorbASCII(file, name);
                bitpit::genericIO::absorbASCII(file, n_loc);
                bitpit::genericIO::absorbASCII(file, readNSize);
                if(file.good())  nSize = long(readNSize);
                data.reserve(nSize);
                for(long i=0; i<nSize; ++i){
                    bitpit::genericIO::absorbASCII(file, id);
                    bitpit::genericIO::absorbASCII(file, data_T);
                    data.insert(id,data_T);
                }
                data.setDataLocation(n_loc);
                data.setName(name);
            }
            file.close();
        }else{
            (*m_log) << "file not open --> exit" << std::endl;
            throw std::runtime_error (m_name + " : cannot open " + m_filename + " requested");
        }
    }
 
#if MIMMO_ENABLE_MPI
    //if there are any other procs send data to them.
    if(m_nprocs > 1)    sendReadDataToAllProcs(data);
#endif
 
    if(refgeo == nullptr){
        _setResult(data);
    }else{
        data.setGeometry(refgeo);
        MimmoPiercedVector<T> data2 = data.resizeToCoherentDataIds();
        _setResult(data2);
    }
 
    return static_cast<IODataT<MimmoPiercedVector< T > >*>(m_result.get())->getData();
}
 
 
#if MIMMO_ENABLE_MPI
 
template<typename T>
void
GenericInputMPVData::sendReadDataToAllProcs(MimmoPiercedVector<T> & dataTC){
 
    if(getRank() == 0){
 
        mimmo::OBinaryStream dataBuffer;
        //create char output data buffer and reverse data into it.
        dataBuffer << dataTC;
        long dataBufferSize = dataBuffer.getSize();
 
        //Send data to all other procs
        for (int sendRank=1; sendRank<m_nprocs; sendRank++){
           MPI_Send(&dataBufferSize, 1, MPI_LONG, sendRank, 100, m_communicator);
           MPI_Send(dataBuffer.data(), dataBuffer.getSize(), MPI_CHAR, sendRank, 110, m_communicator);
        }
        //hey 0, your job is done.
    }else{
 
        long dataBufferSize;
        MPI_Recv(&dataBufferSize, 1, MPI_LONG, 0, 100, m_communicator, MPI_STATUS_IGNORE);
 
        mimmo::IBinaryStream dataBuffer(dataBufferSize);
        MPI_Recv(dataBuffer.data(), dataBuffer.getSize(), MPI_CHAR, 0, 110, m_communicator, MPI_STATUS_IGNORE);
 
        dataBuffer >> dataTC;
    }
}
 
#endif
 
}