Grid.hpp

#ifndef __FIBER_GRID_HPP
#define __FIBER_GRID_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "GridAPI.h"
#include <fiber/field/Field.hpp>
#include <memcore/TypeInfo.hpp>
 
#include <unordered_set>
 
#include "FieldID.hpp"
#include "FiberSpace.hpp"
#include "Transformation.hpp"
#include "Representation.hpp"
#include "Chart.hpp"
#include "Skeleton.hpp"
#include "GridContainer.hpp"
#include "SkeletonMap.hpp"
 
namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;
 
 
class   GRID_API Timestep : public Interface<Timestep>
{
public: 
        long    timestep;
};
 
 
typedef std::pair<SkeletonID, RefPtr<Skeleton> > SkeletonInfo;
 
 
class   GRID_API Grid : public SkeletonMap
                      , public Ownable<Grid>
                      , public Intercube
                      , public SaveableAttributes
{
        WeakPtr<GridContainer>  myContainer;
        RefPtr<Atlas>           myAtlas;
 
        Grid(const Grid&) = delete;
 
        void operator=(const Grid&) = delete;
 
        Grid() = delete;
 
public:
        typedef Fiber::SkeletonInfo SkeletonInfo;
 
 
        Grid (const OwnerOf<Grid>&GridOwner,
              const WeakPtr<GridContainer>&GC, const RefPtr<GlobalCharts>&GAtlas);
 
        Grid (const WeakPtr<GridContainer>&GC, const RefPtr<GlobalCharts>&GAtlas);
 
        ~Grid();
 
        const RefPtr<Atlas>&MyAtlas() const
        {
                return myAtlas;
        }
 
        const Atlas::Atlas_t&getCharts() const;
 
        Atlas::Atlas_t getCharts(const type_info&ChartType) const;
 
        Atlas::Atlas_t getCartesianCharts3D() const;
 
        const RefPtr<Chart>     getUniqueCartesianChart3D() const;
 
        string  getUniqueCartesianChart3DName() const;
 
static  string getChartName(const type_info&ChartType, const string&name);
 
        RefPtr<Chart> findChart(const RefPtr<ChartID>&id) const;
 
        RefPtr<Chart> findChart(const type_info&ChartType, const string&name = string()) const;
 
        RefPtr<Chart> makeChart(const type_info&ChartType, const string&name = {}, uint16_t epsg_code = 0);
 
        RefPtr<Chart>   findChart(uint16_t epsg_code) const;
        RefPtr<ChartID> findChartID(uint16_t epsg_code) const;
 
        bool    insertSharedChart(const RefPtr<Chart>&ExistingChart)
        {
                Assert( myAtlas );
                return myAtlas->insertSharedChart(ExistingChart);
        }
 
        RefPtr<Chart> makeCartesianChart(const string&name = {}, uint16_t epsg_code = 0);
 
        RefPtr<Chart> findCartesianChart(const string&name = {}) const;
 
        RefPtr<Representation> getCartesianRepresentation(const Skeleton&Skel, const string&ChartName = {} ) const;
 
        RefPtr<Representation> getCartesianRepresentation(const string&ChartName = {} ) const;
 
        RefPtr<Representation> operator()() const
        {
                return getCartesianRepresentation();
        }
 
 
        RefPtr<Representation> getTimePolar2DRepresentation(const Skeleton&Skel) const;
 
        RefPtr<Representation> getTimePolar2DRepresentation() const
        {
        RefPtr<Skeleton> S = findVertices();
                if (!S)
                {
                        puts("Grid::getTimePolar2DRepresentation(): no Vertex Skeleton found!");fflush(stdout);
                        return NullPtr();
                }
                return  getTimePolar2DRepresentation(*S);
        }
 
 
        Representation&makeCartesianRepresentation(int Dims, const string&name = {}, uint16_t epsg_code = 0);
 
        Representation&operator[](int Dims)
        {
                return makeCartesianRepresentation(Dims);
        }
 
        RefPtr<Field> operator()(const string&fieldname, const string&ChartName = string() ) const;
        RefPtr<Field> operator()(const string&fieldname, const RefPtr<Chart>&theChart) const;
 
        FieldProxy operator[](const string&fieldname);
 
        RefPtr<Field> CartesianPositions() const;
 
        RefPtr<Field> TimePolar2DPositions() const;
 
        RefPtr<Field> getCartesianPositions() const
        {
                return CartesianPositions();
        }
 
        void    setCartesianPositions(const MemCore::RefPtr<MemBase>&Coordinates,
                                      const string&ChartName = {}, uint16_t epsg_code = 0)
        {
                if (!Coordinates) return;
        auto    D = Coordinates->getSize();
        Representation&R = makeCartesianRepresentation(D.dimensionality(), ChartName, epsg_code);
                R.setPositions(Coordinates);
        }
 
        Representation&
                setCartesianPositions(const MemBase&Coordinates,
                                      const string&ChartName = {}, uint16_t epsg_code = 0)
        {
        auto    D = Coordinates.getSize();
        Representation&R = makeCartesianRepresentation(D.dimensionality(), ChartName, epsg_code);
                R.setPositions(Coordinates.self() );
                return R;
        }
 
        using SkeletonMap::operator[];
        using SkeletonMap::operator();
 
        typedef SkeletonIterator Iterator;
 
        template <class SkeletonFunctor>
        int     iterate_skeletons(const SkeletonFunctor&F) const
        {
                return this->SkeletonMap::iterate(F);
        }
        using SkeletonMap::iterate;
 
        using SkeletonMap::iterate_all;
 
        RefPtr<Field> getField(const RefPtr<ChartID>&theChartID,
                               const string&fieldname, const RefPtr<Skeleton>&theSkeleton) const;
 
        RefPtr<Field> getField(const RefPtr<Chart>&theChart,
                               const string&fieldname, const RefPtr<Skeleton>&theSkeleton) const
        {
                if (!theChart) return nullptr;
                return getField(theChart->ID(), fieldname, theSkeleton);
        }
 
        RefPtr<Field> getField(const RefPtr<ChartID>&theChartID,
                               const string&fieldname) const
        {
                return getField(theChartID, fieldname, findVertices() );
        }
 
        RefPtr<Field> getField(const RefPtr<Chart>&theChart,
                               const string&fieldname) const
        {
                if (!theChart) return nullptr;
                return getField(theChart->ID(), fieldname, findVertices() );
        }
 
        RefPtr<Field> getPositions(const RefPtr<ChartID>&theChartID,
                                   const RefPtr<Skeleton>&theSkeleton) const;
 
 
        RefPtr<Field> getPositions(const string&ChartName = {} ) const
        {
        RefPtr<Representation> R = getCartesianRepresentation(ChartName);
                if (R)
                        return R->getPositions();
 
                return nullptr;
        }
 
        RefPtr<Field> getVertexPositions(const RefPtr<ChartID>&theChartID) const;
 
 
        RefPtr<Representation> getRepresentation(const RefPtr<ChartID>&theChartID,
                                                 const RefPtr<Skeleton>&theSkeleton) const;
 
 
static  RefPtr<Representation> getRepresentation(const RefPtr<Chart>&theChart,
                                                 const RefPtr<Skeleton>&theSkeleton);
 
        RefPtr<Representation> getRepresentation(const RefPtr<Chart>&theChart,
                                                 const SkeletonID&theSkeletonID) const;
 
        RefPtr<Representation> getRepresentation(const RefPtr<ChartID>&theChartID,
                                                 const SkeletonID&theSkeletonID) const;
 
        RefPtr<Representation> getVertexRepresentation(const RefPtr<ChartID>&theChartID) const
        {
                return getRepresentation(theChartID, findVertices() );
        }
 
        using SkeletonMap::findMaxHomogenousRefinement;
 
        RefPtr<Skeleton> findHighestHomogenousRefinement(int MaxLevel, int IndexDepth, int Dimensionality) const;
 
        RefPtr<Skeleton> findHighestHomogenousVertexRefinement(int MaxLevel) const;
 
 
        template <is_field_identifier... FieldIdentifiers>
        std::array<RefPtr<Field>, sizeof...(FieldIdentifiers)>
                getVertexFields(const RefPtr<Chart> &chart,
                                FieldIdentifiers... theFieldIdentifiers) const
        {
                if (!chart) return {};
 
                if (RefPtr<Skeleton> S = findVertices() )
                        return S->getFields( chart, theFieldIdentifiers...);
 
                return {};
        }
 
        template <is_field_identifier... FieldIdentifiers>
        auto    getVertexFields(uint16_t epsg_code,
                                FieldIdentifiers... theFieldIdentifiers) const
        {
        RefPtr<Chart>   chart = findChart(epsg_code);
                return  getVertexfields( chart, theFieldIdentifiers...);
        }
 
        template <is_field_identifier... FieldIdentifiers>
        auto    getVertexFields(const type_info&ChartType, const string&ChartName,
                                FieldIdentifiers... theFieldIdentifiers) const
        {
        RefPtr<Chart>   chart = findChart(ChartType, ChartName);
                return  getVertexFields( chart, theFieldIdentifiers...);
        }
 
        template <is_field_identifier... FieldIdentifiers>
        auto    getCartesianVertexFields(const string&ChartName,
                                         FieldIdentifiers... theFieldIdentifiers) const
        {
        RefPtr<Chart>   chart = findCartesianChart(ChartName);
                return  getVertexFields( chart, theFieldIdentifiers...);
        }
 
 
 
 
        template <is_field_identifier... FieldIdentifiers>
        auto    getVertexFieldCreators(const RefPtr<FragmentID>&fID, const RefPtr<Chart> &chart,
                                       FieldIdentifiers... theFieldIdentifiers) const
        {
        const auto&F = getVertexFields(chart, theFieldIdentifiers...);
                return  getCreators(F, fID);
        }
 
 
        template <is_field_identifier... FieldIdentifiers>
        auto    getVertexFieldCreators(const RefPtr<FragmentID>&fID, uint16_t epsg_code,
                                       FieldIdentifiers... theFieldIdentifiers) const
        {
        const auto&F = getVertexFields(epsg_code, theFieldIdentifiers...);
                return  getCreators(F, fID);
        }
 
        template <is_field_identifier... FieldIdentifiers>
        auto    getVertexFieldCreators(const RefPtr<FragmentID>&fID, const type_info&ChartType, const string&ChartName,
                                       FieldIdentifiers... theFieldIdentifiers) const
        {
        const auto&F = getVertexFields(ChartType, ChartName, theFieldIdentifiers...);
                return  getCreators(F, fID);
        }
 
        template <is_field_identifier... FieldIdentifiers>
        auto    getCartesianVertexFieldCreators(const RefPtr<FragmentID>&fID, const string&ChartName,
                                                FieldIdentifiers... theFieldIdentifiers) const
        {
        const auto&F = getCartesianVertexFields(ChartName, theFieldIdentifiers...);
                return  getCreators(F, fID);
        }
 
 
 
 
 
 
 
#if 0
        RefPtr<Chart> getGlobalChart(const type_info&t, const string&id) const;
 
        RefPtr<Chart> getGlobalChart(const vector<char*>&component_names,
                                     const type_info&element_type,
                                     const string&id) const;
 
#endif
 
        string  xml() const;
 
        [[deprecated("Avoid using this slow function.")]]
        RefPtr<Skeleton> findSkeleton(const RefPtr<FragmentID>&fID);
 
 
 
        template <class index_type>
        using   filter = std::function<bool(Chunk<index_type>&indirection, const RefPtr<FragmentID>&fid, CreativeArrayBase&CAB)>;
 
        using   metafilter = FragmentMetaIndirector::MetaInfoProvider_t;
 
        template <class index_type>
        struct  FragmentFilter
        {
                filter<index_type>      dataFilter = {};
                metafilter              metaFilter = {};
        };
 
 
        template <class index_type>
        using   SkeletonFilter = std::function<FragmentFilter<index_type>(Skeleton&SourceVertices, const Representer&theRepresenter, const Representation&R)>;
 
        void    establishSkeletonFilter(Skeleton&TargetVertices, Skeleton&SourceVertices, SkeletonFilter<uint32_t> SF);
 
        void    establishVertexFilter(const Grid&SourceGrid, SkeletonFilter<uint32_t> SF);
};
 
 
template <>
class   Iterator<Skeleton> : public Grid::Iterator
{
};
 
template <>
class   Iterator<SkeletonID> : public Grid::Iterator
{
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRID_HPP */