VectorSingle.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow       
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------  
Licence:
  This file is part of phasicFlow code. It is a free software for simulating 
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions. 
 
  phasicFlow is distributed to help others in their research in the field of 
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
#ifndef __VectorSingle_hpp__
#define __VectorSingle_hpp__
 
#include <vector>
 
#include "globalSettings.hpp"
#include "phasicFlowKokkos.hpp"
#include "stdVectorHelper.hpp"
#include "error.hpp"
#include "indexContainer.hpp"
#include "streams.hpp"
 
 
 
#ifndef __RESERVE__
#define __RESERVE__
    struct RESERVE{};
#endif
 
namespace pFlow
{
 
 
template<typename T, typename MemorySpace=void>
class VectorSingle
{
public:
    
    //- typedefs for accessing data
 
        using VectorType        = VectorSingle<T, MemorySpace>;
 
        using VectorTypeHost    = VectorSingle<T, HostSpace>;       
 
        using iterator        = T*;
 
        using const_iterator   = const T*;
        
        using reference       = T&;
        
        using const_reference  = const T&;
 
        using value_type       = T;
        
        using pointer         = T*;
        
        using const_pointer    = const T*;
    
    //- typedefs related to memory management 
 
        using viewType          = ViewType1D<T, MemorySpace>;
 
        using device_type       = typename viewType::device_type;
 
        using memory_space      = typename viewType::memory_space;
 
        using execution_space   = typename viewType::execution_space;
 
private:
    
    // - Data members
 
        uint32          size_ = 0;
 
        viewType        view_;
 
    // - protected members and methods      
 
        static constexpr 
        bool  isHostAccessible_ = isHostAccessible<execution_space>();
 
        static constexpr
        bool isDeviceAccessible_ = isDeviceAccessible<execution_space>();
 
        static constexpr
        bool isTriviallyCopyable_ = std::is_trivially_copyable_v<T>;
 
        static_assert(isTriviallyCopyable_, "This type is not trivially copyable");
 
        static INLINE_FUNCTION_H uint32 evalCapacity(uint32 n)
        {
            return static_cast<uint32>(n*pFlow::gSettings::vectorGrowthFactor__+1);
        }
 
    INLINE_FUNCTION_H 
    uint32 changeSize(uint32 n, bool withInit= false);
 
    INLINE_FUNCTION_H
    uint32 changeCapacitySize(uint32 actualCap, uint32 n, bool withInit= false);
    
    INLINE_FUNCTION_H
    void changeCapacity(uint32 actualCap, bool withInit= false);
    
    INLINE_FUNCTION_H
    uint32 reallocateCapacitySize(uint32 cap, uint32 s);
    
    INLINE_FUNCTION_H 
    uint32 setSize(uint32 n);
    
public:
 
    TypeInfoTemplateNV111("VectorSingle", T, memoerySpaceName());
 
 
        VectorSingle();
        
        explicit VectorSingle(const word& name);
        
        VectorSingle(const word& name, uint32 n);
        
        VectorSingle(const word& name, uint32 n, const T& val);
 
        VectorSingle(const word& name, uint32 cap, uint32 n, RESERVE );
        
        VectorSingle(const word& name, const std::vector<T> & src); 
 
        VectorSingle(const word& name, const std::vector<T> & src, uint32 cap);
        
        VectorSingle(const VectorSingle& src);
        
        VectorSingle(const word& name, const VectorSingle& src);
 
        VectorSingle(const word& name, const ViewType1D<T, MemorySpace>& src);
        
        VectorSingle& operator = (const VectorSingle& rhs) ;
        
        VectorSingle(VectorSingle&&) = default;   
 
        VectorSingle& operator= (VectorSingle&&) = default; 
 
        ~VectorSingle();
 
        INLINE_FUNCTION_H 
        uniquePtr<VectorSingle> clone() const;
 
            
 
        INLINE_FUNCTION_H
        VectorType& VectorField();
 
        INLINE_FUNCTION_H
        const VectorType& VectorField()const;
 
        INLINE_FUNCTION_H 
        auto& deviceViewAll();
 
        INLINE_FUNCTION_H 
        const auto& deviceViewAll() const;
 
        INLINE_FUNCTION_H 
        auto deviceView()const;
 
        INLINE_FUNCTION_H 
        auto hostViewAll()const;
        
 
        INLINE_FUNCTION_H 
        auto hostView()const;
 
        INLINE_FUNCTION_H 
        word name()const;
        
        
        INLINE_FUNCTION_H 
        uint32 size()const;
        
 
        // Capcity of the vector 
        INLINE_FUNCTION_H 
        uint32 capacity()const;
        
        INLINE_FUNCTION_H 
        bool empty()const;
        
        INLINE_FUNCTION_H 
        void reserve(uint32 cap); 
 
        INLINE_FUNCTION_H 
        void reallocate(uint32 cap); 
        
        INLINE_FUNCTION_H 
        void reallocate(uint32 cap, uint32 newSize); 
        
        INLINE_FUNCTION_H   
        void resize(uint32 n);
 
        INLINE_FUNCTION_H  
        void resize(uint32 n, const T& val);
 
        INLINE_FUNCTION_H 
        void clear();
        
        INLINE_FUNCTION_H 
        void fill(const T& val);
 
        INLINE_FUNCTION_H
        void fill(rangeU32 r,  const T& val);
        
        INLINE_FUNCTION_H
        void assign(size_t n, const T& val);
        
        INLINE_FUNCTION_H 
        void assign(const std::vector<T>& src, uint32 cap); 
        
 
        INLINE_FUNCTION_H 
        void assign(const std::vector<T>& src);
 
        INLINE_FUNCTION_H
        void assignFromHost(const VectorTypeHost& src);
 
        INLINE_FUNCTION_H
        void assign(const VectorType& src, bool srcCapacity = true);
 
        template<typename MSpace>
        INLINE_FUNCTION_H
        void assignFromDevice(const VectorSingle<T, MSpace>& src, bool srcCapacity = true);
 
        INLINE_FUNCTION_H
        void append(const ViewType1D<T,MemorySpace>& appVec);
 
        INLINE_FUNCTION_H
        void append(const std::vector<T>& appVec);
 
        INLINE_FUNCTION_H
        void append(const VectorType& appVec);
        
        INLINE_FUNCTION_H
        auto getSpan();
                
        INLINE_FUNCTION_H 
        auto getSpan()const;
        
        INLINE_FUNCTION_H
        bool insertSetElement(const uint32IndexContainer& indices, const T& val);
        
        INLINE_FUNCTION_H
        bool insertSetElement(const uint32IndexContainer& indices, const std::vector<T>& vals);
        
        INLINE_FUNCTION_H
        bool insertSetElement(
            const uint32IndexContainer& indices, 
            const ViewType1D<T, memory_space> vals);
 
        INLINE_FUNCTION_H
        bool reorderItems(const uint32IndexContainer& indices);
 
        template<bool Enable = true>
        INLINE_FUNCTION_H
        typename std::enable_if_t<isHostAccessible_ && Enable, void>
        push_back(const T& val)
        {
            auto n = changeSize(size_+1);
            data()[n] = val;    
        }
 
        INLINE_FUNCTION_H 
        pointer data(){
            return view_.data();
        }
 
        INLINE_FUNCTION_H 
        const_pointer data()const{
            return view_.data();
        }
 
        template<bool Enable = true>
        INLINE_FUNCTION_H 
        typename std::enable_if_t<isHostAccessible_ && Enable,iterator>
        begin(){
            return data();
        }
 
        template<bool Enable = true>
        INLINE_FUNCTION_H 
        typename std::enable_if_t<isHostAccessible_ && Enable,const_iterator>
        begin()const {
            return data();
        }
 
        
        template<bool Enable = true> 
        INLINE_FUNCTION_H
        typename std::enable_if_t<isHostAccessible_ && Enable,iterator>
        end(){
            return size_ > 0 ? data() + size_: data();
        }
 
        
        template<bool Enable = true>
        INLINE_FUNCTION_H
        typename std::enable_if_t<isHostAccessible_ && Enable,const_iterator>
        end()const{
            return size_ > 0 ? data() + size_: data();
        }
                
        template<bool Enable = true>
        INLINE_FUNCTION_H 
        typename std::enable_if_t<isHostAccessible_ && Enable,reference>
        operator[](size_t i){
            return view_[i];
        }
 
        template<bool Enable = true>
        INLINE_FUNCTION_H 
        typename std::enable_if_t<isHostAccessible_ && Enable,const_reference>
         operator[](size_t i)const{
            return view_[i];
        }
 
 
        FUNCTION_H
        bool read(iIstream& is)
        {
            std::vector<T> vecFromFile;
            if(! readStdVector(is, vecFromFile)) return false;
 
            this->assign(vecFromFile);
 
            return true;
        }
 
        FUNCTION_H
        bool read(iIstream& is, const IOPattern& iop)
        {
            std::vector<T> vecFromFile;
            if(! readStdVector(is, vecFromFile, iop)) return false;
            this->assign(vecFromFile);
 
            return true;
        }
 
        FUNCTION_H
        bool write(iOstream& os, const IOPattern& iop)const
        {
            auto hVec = hostView();
            auto sp = span<T>( const_cast<T*>(hVec.data()), hVec.size());
            
            return writeSpan(os, sp, iop);
            
        }
 
        FUNCTION_H
        bool write(iOstream& os)const
        {
            auto hVec = hostView();
            auto sp = span<T>( const_cast<T*>(hVec.data()), hVec.size());
            
            return writeSpan(os, sp);
            
        }
 
        template<typename HostMask>
        FUNCTION_H
        bool write(iOstream& os, const IOPattern& iop, const HostMask& mask)const
        {
            auto hVec = hostView();
            
            auto numActive = mask.numActive();
            std::vector<T> finalField;
            finalField.clear();
            finalField.reserve(numActive);
            
            uint32 start    = mask.activeRange().start();
            uint32 end      = mask.activeRange().end();
            
            for(uint32 i=start; i<end; i++ )
            {
                if( mask() )
                    finalField.push_back(hVec[i]);
            }
 
            auto sp = span<T>( finalField.data(), finalField.size());
 
            return writeSpan(os, sp, iop);
 
        }
 
 
        static  
        constexpr const char* memoerySpaceName()
        {
            return memory_space::name();
        }
 
}; // class VectorSingle
 
template<typename T, typename MemorySpace>
inline iIstream& operator >> (iIstream & is, VectorSingle<T, MemorySpace> & ivec )
{
    if( !ivec.read(is) )
    {
        ioErrorInFile (is.name(), is.lineNumber());
        fatalExit;
    }
    return is;
}
 
template<typename T, typename MemorySpace>
inline iOstream& operator << (iOstream& os, const VectorSingle<T, MemorySpace>& ovec )
{
    
    if( !ovec.write(os) )
    {
        ioErrorInFile(os.name(), os.lineNumber());
        fatalExit;
    }
 
    return os; 
}
 
 
} // - pFlow
 
#include "VectorSingleAlgorithms.hpp"
#include "VectorSingle.cpp"
 
 
 
 
#endif //__VectorSingle_hpp__
 
 
/*
INLINE_FUNCTION_H
        bool append(const deviceViewType1D<T>& dVec, size_t numElems)
        {
 
            if(numElems == 0 )return true;
            auto oldSize = size_;
            auto newSize = size_ + numElems;
 
            if(this->empty() || newSize > capacity() )
            {
                resize(newSize);
            }
            else
            {
                size_ = size_+numElems;
            }
            
            auto dSubView = Kokkos::subview(view_, Kokkos::make_pair(oldSize, newSize)); 
            copy(dSubView, dVec);
 
            return true;
        }
 
        INLINE_FUNCTION_H
        bool append(const VectorSingle& Vec)
        {
            return append(Vec.deviceView(), Vec.size());
        }*/