SkeletonID.hpp

 
//
// $Id: SkeletonID.hpp,v 1.4 2008/04/09 01:54:30 werner Exp $
//
#ifndef __FIBER_SKELETONID_HPP
#define __FIBER_SKELETONID_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "GridAPI.h"
#include <fiber/field/DynamicSize.hpp>
 
namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
 
class   GRID_API SkeletonID
{
        int     index_depth;
        DynamicSize domainsize;
        DynamicSize refinement;
 
public:
        explicit SkeletonID(int dimension, int index_depth=0);
 
        explicit SkeletonID(const std::nullptr_t&);
 
        SkeletonID(const DynamicSize&theDomainSize, int IndexDepth, const DynamicSize&theRefinementSize)
        : index_depth(IndexDepth)
        , domainsize( theDomainSize )
        , refinement( theRefinementSize )
        {}
 
        SkeletonID(const SkeletonID&Sid, int index_depth_increment);
 
private:
        struct  RefinementConstructorArg {};
        struct  RefinementCreationArg {};
 
        SkeletonID(const RefinementConstructorArg&, const SkeletonID&Sid, int refinement_increment);
        SkeletonID(const RefinementCreationArg&, const SkeletonID&Sid, int refinement_value);
public:
 
        ~SkeletonID();
 
        const SkeletonID&ID() const
        {
                return *this;
        }
 
static  SkeletonID nextRefinement(const SkeletonID&Sid, int refinement_increment)
        {
                return SkeletonID( RefinementConstructorArg(), Sid,  refinement_increment);
        }
 
static  SkeletonID refinedSkeleton(const SkeletonID&Sid, int refinement_value)
        {
                return SkeletonID( RefinementCreationArg(), Sid,  refinement_value);
        }
 
 
        bool operator<(const SkeletonID&S) const;
 
        int     IndexDepth() const
        {
                return index_depth;
        }
 
        const DynamicSize&DomainSize() const
        {
                return domainsize;
        }
 
        const DynamicSize&Size() const
        {
                return domainsize;
        }
 
        const DynamicSize&RefinementSize() const
        {
                return refinement;
        }
 
        const DynamicSize&getRefinementSize() const
        {
                return refinement;
        }
 
 
        template <class T>
        DynamicSize&setSize(int N, const T values[])
        {
                return domainsize.setSize(N, values);
        }
 
        template <class T>
        DynamicSize&setRefinementSize(int N, const T values[])
        {
                return refinement.setSize(N, values);
        }
 
        template <int N>
        auto    setSize(const MultiIndex<N>&I)
        {
                return domainsize.changeSize(I);
        }
 
        template <int N>
        DynamicSize&setRefinementSize(const MultiIndex<N>&I)
        {
                return refinement.setSize(I);
        }
 
        int     Dims() const
        {
                return domainsize.getRank();
        }
 
        int     getRank() const
        {
                return domainsize.getRank();
        }
 
        bool    hasCompatibleHigherDims(const DynamicSize&DS) const;
 
        int     NumberOfRefinementLevels() const
        {
                return refinement.getRank();
        }
 
        index_t Refinement(unsigned int i) const
        {
                return refinement[i];
        }
 
        bool    isIsotropicRefinementFactor(index_t F) const
        {
                for(int i=0; i<refinement.getRank(); i++)
                {
                        if (refinement[i] != F)
                                return false;
                }
                return true;
        }
 
        index_t getHomogeneousLevel() const
        {
                if (refinement.getRank()<1)
                        return 0;
 
        index_t L = refinement[0];
                for(int i=1; i<refinement.getRank(); i++)
                {
                        if (refinement[i] != L)
                                return -i;
                }
                return L;
        }
 
 
        index_t getTotalRefinement() const
        {
        index_t TotalRefinement = 1;
 
                for(int i=0; i<refinement.getRank(); i++)
                {
                        TotalRefinement *= refinement[i];
                }
                return TotalRefinement;
        }
 
        unsigned getDomainSize(unsigned i) const
        {
                return unsigned( domainsize[i] );
        }
 
        bool    setSize(unsigned i, index_t extension)
        {
                return domainsize.setSize( i, extension);
        }
 
        template <int N>
        bool    setSize(MultiIndex<N>&MI) const
        {
                return domainsize.setSize( MI );
        }
 
        bool    setSize(const DynamicSize&DS) const
        {
                return domainsize.setSize( DS, 1 );
        }
 
        const DynamicSize&setRefinementSize(const DynamicSize&DS)
        {
                return  refinement = DS;
        }
 
        bool    setRefinement(unsigned i, index_t extension)
        {
                return refinement.setSize( i, extension);
        }
 
        void    setIsotropicRefinement( index_t ref_level )
        {
                for (auto i = 0; i < Dims(); ++i)
                        setRefinement( i, ref_level );
        }
 
        bool    hasRefinement()
        {
                if( NumberOfRefinementLevels() > 1)
                        return true;
 
                if( NumberOfRefinementLevels() == 1)
                {
                        if( refinement[0] > 0  )
                                return true;
                }
                else
                        return false;
 
                return false;
        }
 
        std::string Name() const;
 
        // stream output operator
        friend std::ostream&operator<<(std::ostream&os, const SkeletonID&SID)
        {
                os << "( depth: " <<  SID.IndexDepth() << ", dims: " << SID.Dims() << ", refs: " << SID.NumberOfRefinementLevels();
 
                for(auto i = 0; i < SID.NumberOfRefinementLevels(); i++ )
                        os << ", ref[" << i << "]:" << SID.Refinement( i );
 
                os << " )";
 
                        return os;
        }
 
        friend  bool    operator==(const SkeletonID&L, const SkeletonID&R)
        {
                if (L.IndexDepth()      != R.IndexDepth())
                        return false;
 
                if (L.domainsize.getRank() != R.domainsize.getRank())
                        return false;
 
                if (L.refinement        != R.refinement)
                        return false;
 
                return true;
        }
 
        friend  bool    operator!=(const SkeletonID&L, const SkeletonID&R)
        {
                return !( L == R);
        }
 
        bool    operator!() const;
 
        operator bool() const
        {
                return !!*this;
        }
};
 
 
} /* namespace Fiber */
 
 
namespace std
{
 
inline string to_string(const Fiber::SkeletonID&SID)
{
        return "(dims=" + to_string(SID.Dims() )
        + ", depth=" +  to_string(SID.IndexDepth() )
        + ", refinement=" + to_string( SID.RefinementSize())
        + ")"
        ;
}
 
} // namespace std
 
#ifdef   __MEMCORE_VERBOSE_HPP
 
namespace MemCore
{
 
inline  VerboseStream&operator<<(VerboseStream&VS, const Fiber::SkeletonID&ID)
{
        return VS << std::to_string(ID);
}
 
} // namespace MemCore
 
#endif
 
#endif /* __FIBER_SKELETONID_HPP */