sphereShape.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 __sphereShape_hpp__
#define __sphereShape_hpp__
 
#include "Vectors.hpp"
#include "hashMap.hpp"
 
namespace pFlow
{
 
class dictionary;
 
class sphereShape
{
protected:
    
    // - diameter of spheres
    realVector          diameters_;
    
    // - property name of spheres
    wordVector          materials_;
 
    // - hashed list of spheres names
    wordHashMap<uint32> names_;
 
    size_t              numShapes_;
 
 
    bool insertNames(const wordVector& names);
 
    bool readDictionary(const dictionary& dict);
 
    bool writeDictionary(dictionary& dict)const;
 
public:
 
    // - type info
    TypeInfoNV("sphereShape");
 
 
        sphereShape(){}
 
        sphereShape(
            const realVector& diameter,
            const wordVector& property,
            const wordVector& name
            );
 
        sphereShape(const sphereShape&) = default;
 
        sphereShape(sphereShape&&) = default;
 
        sphereShape& operator=(const sphereShape&) = default;
 
        sphereShape& operator=(sphereShape&&) = default;
 
        auto clone()const
        {
            return makeUnique<sphereShape>(*this);
        }
 
        sphereShape* clonePtr()const
        {
            return new sphereShape(*this);
        }
 
        ~sphereShape() = default;
 
        const auto& names()const{
            return names_;
        }
 
        const auto& diameters()const{
            return diameters_;
        }
 
        const auto& materials()const{
            return materials_;
        }
 
        const auto diameter(label i)const{
            return diameters_[i];
        }
 
        const auto material(label i)const{
            return materials_[i];
        }
 
 
        // name to index
        bool nameToIndex(const word& name, uint32& index)const
        {
            if(auto[iter, found] = names_.findIf(name); found )
            {
                index = iter->second;
                return true;
            }
            else
            {
                index = 0;
                return false;
            }
        }
 
        uint32 nameToIndex(const word& name)const
        {
            return names_.at(name);
        }
 
        bool indexToName(uint32 i, word& name)const
        {
            for(auto& nm: names_)
            {
                if(nm.second == i)
                {
                    name = nm.first;
                    return true;
                }
            }
            name = "";
            return false;
        }
 
        bool shapeToDiameter(wordVector& names, realVector& diams)const;
 
        void diameterMinMax(real& minD, real& maxD)const
        {
            minD = min(diameters_);
            maxD = max(diameters_);
        }
 
 
        // - read from stream/file
        bool read(iIstream& is);
 
        // - write to stream/file
        bool write(iOstream& os)const;
 
        // - read from dictionary 
        bool read(const dictionary& dict)
        {
            return readDictionary(dict);
        }
 
        // - write to dictionary 
        bool write(dictionary& dict)const
        {
            return writeDictionary(dict);
        }
 
 
};
 
} // pFlow
 
#endif //__sphereShape_hpp__