Field.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 __Field_hpp__
#define __Field_hpp__
 
 
#include "types.hpp"
#include "VectorSingle.hpp"
#include "wordVectorHost.hpp"
#include "Vector.hpp"
#include "streams.hpp"
 
namespace pFlow
{
 
 
template<class T, class MemorySpace = void>
class Field
:
    public VectorSingle<T, MemorySpace>
{
public:
 
    using VectorType        = VectorSingle<T,MemorySpace>;
 
    using FieldType         = Field<T, MemorySpace>;
 
    using FieldTypeHost     = Field<T, HostSpace>;
 
    using memory_space      = typename VectorType::memory_space;
 
    using execution_space   = typename VectorType::execution_space;
 
    using iterator          = typename VectorType::iterator;
 
    using const_iterator    = typename VectorType::const_iterator;
 
    using reference         = typename VectorType::reference;
    
    using const_reference   = typename VectorType::const_reference;
 
    using value_type        = typename VectorType::value_type;
    
    using pointer           = typename VectorType::pointer;
    
    using const_pointer     = typename VectorType::const_pointer;
    
 
private:
    
    static const inline word FKey = "value";
 
    const word fieldKey_ = FKey;
 
public:
 
    TypeInfoTemplateNV111("Field", T, VectorType::memoerySpaceName());
 
 
        Field()
        :
            VectorType()
        {}
 
        Field(const word& name)
        :
            VectorType(name)
        {}
 
        Field(const word& name, const word& fieldKey)
        :
            VectorType(name),
            fieldKey_(fieldKey)
        {}
        
        Field(const word& name, const word& fieldKey, size_t len)
        :
            VectorType(name, len),
            fieldKey_(fieldKey)
        {}
 
        
        Field(const word& name, const word& fieldKey, size_t len, const T& val)
        :
            VectorType(name, len, val),
            fieldKey_(fieldKey)
        {}
 
        Field(const word& name, const word& fieldKey, size_t capacity, size_t len, const T& val)
        :
            VectorType(name, len, len, RESERVE()),
            fieldKey_(fieldKey)
        {
            VectorType::fill(val);
        }
 
        Field(const word& name, const word& fieldKey, size_t capacity, size_t len, RESERVE)
        :
            VectorType(name, capacity, len, RESERVE()),
            fieldKey_(fieldKey)
        {}
 
        Field(const word& fieldKey, const Vector<T>& vec)
        :
            VectorType(vec.name(), vec.vectorField()),
            fieldKey_(fieldKey)
        {}
 
        Field(const word& name, const word& fieldKey, const Vector<T>& vec)
        :
            VectorType(name, vec.vectorField()),
            fieldKey_(fieldKey)
        {}
 
        Field(const word& name, const word& fieldKey, const std::vector<T>& vec)
        :
            VectorType(name, vec),
            fieldKey_(fieldKey)
        {}
 
        Field(const word& name, const word& fieldKey, const FieldType& src):
            VectorType(name, src),
            fieldKey_(fieldKey)
        {}
 
        Field(const FieldType&) = default;
 
        FieldType& operator = (const FieldType& rhs)
        {
            if(&rhs == this) return *this;
            VectorType::operator=(rhs);
            return *this;
        }
 
        Field(FieldType&&) = default;
 
        FieldType& operator = (FieldType&&) = default;
 
 
        word fieldKey()const
        {
            return fieldKey_;
        }
 
        word name()const
        {
            return VectorType::name();
        }
 
 
        void fillField(rangeU32 span, const T& val)
        {
            this->fill(span, val);
        }
 
        void fillField(const T& val)
        {
            this->fill(val);
        }
        
        
        bool read(iIstream& is);
        
        bool write(iOstream& os)const;          
 
 
        bool read(iIstream& is, const IOPattern& iop, bool resume = false);
        
 
        bool write(iOstream& os, const IOPattern& iop )const;           
 
};
 
 
template<class T, class MemorySpace>
inline iIstream& operator >> (iIstream & is, Field<T, MemorySpace> & ifld )
{
    if( !ifld.read(is, IOPattern::MasterProcessorOnly) )
    {
        ioErrorInFile (is.name(), is.lineNumber());
        fatalExit;
    }
    return is;
}
 
template<typename T, typename MemorySpace>
inline iOstream& operator << (iOstream& os, const Field<T, MemorySpace>& ofld )
{
    
    if( !ofld.write(os, IOPattern::AllProcessorsDifferent) )
    {
        ioErrorInFile(os.name(), os.lineNumber());
        fatalExit;
    }
 
    return os; 
}
 
 
}
 
#include "Field.cpp"
 
 
#endif  //__Field_hpp__