Grid.hpp

#ifndef __FIBER_GRID_HPP
#define __FIBER_GRID_HPP "Created 27.02.2001 21:42:27 by werner"

#include "GridAPI.h"
#include <field/Field.hpp>
#include <memcore/TypeInfo.hpp>
#include <set>
#include <list>

#include "FieldID.hpp"
#include "FiberSpace.hpp"
#include "Transformation.hpp"
#include "Representation.hpp"
#include "Chart.hpp"
#include "Skeleton.hpp"
#include "SkeletonID.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;
};

class   GRID_API Grid : public ReferenceBase<Grid>, public Intercube, public Attributes
{
        WeakPtr<GridContainer>  myContainer;
        RefPtr<Atlas>           myAtlas;

        typedef map<SkeletonID, RefPtr<Skeleton> > Skeletons_t;
        Skeletons_t *Skeletons; 

        Grid(const Grid&);

        void operator=(const Grid&);

public:
        typedef std::pair<SkeletonID, RefPtr<Skeleton> > SkeletonInfo;

        Grid (const WeakPtr<GridContainer>&GC, const RefPtr<GlobalCharts>&GAtlas);

        ~Grid(); 

        RefPtr<Skeleton> findVertices() const; 

        SkeletonInfo    getVerticesInfo() const;

        SkeletonInfo    getEdgeInfo() const; 

        SkeletonInfo    getFaceInfo() const; 

        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;

        double NumberOfHoles() const;


        const RefPtr<Atlas>&MyAtlas() const
        {
                return myAtlas;
        } 

        RefPtr<Chart> findChart(const RefPtr<ChartID>&id) const
        {
                return (*myAtlas)(id);
        } 

        RefPtr<Chart> findChart(const type_info&ChartType) const; 

        RefPtr<Chart> findChart(const type_info&ChartType, const string&name) const;

        RefPtr<Chart> makeChart(const type_info&ChartType);

        RefPtr<Chart> makeChart(const type_info&ChartType, const string&name); 

        RefPtr<Chart> makeCartesianChart(); 
        RefPtr<Chart> findCartesianChart() const;

        RefPtr<Representation> getCartesianRepresentation(const Skeleton&Skel) const; 

        RefPtr<Representation> getTimePolar2DRepresentation(const Skeleton&Skel) const;
        
        RefPtr<Representation> getCartesianRepresentation() const
        {
        RefPtr<Skeleton> S = findVertices();
                if (!S)
                        return NullPtr(); 

                return  getCartesianRepresentation(*S);
        } 

        RefPtr<Representation> getTimePolar2DRepresentation() const
        {
        RefPtr<Skeleton> S = findVertices();
                if (!S)
                {
                        puts("Grid::getTimePolar2DRepresentation(): no Vertex Skeleton found!");fflush(stdout);
                        return NullPtr(); 
                }
                return  getTimePolar2DRepresentation(*S);
        }

        Skeleton& makeVertices(int dims); 

        Representation&makeCartesianRepresentation(int Dims); 

        Representation&operator[](int Dims)
        {
                return makeCartesianRepresentation(Dims);
        }

        RefPtr<Field> operator()(const string&fieldname) const;

        RefPtr<Field>&operator[](const string&fieldname);

        RefPtr<Field> CartesianPositions() const; 

        RefPtr<Field> TimePolar2DPositions() const;

        RefPtr<Field> getCartesianPositions() const
        {
                return CartesianPositions();
        }


        Skeleton        &operator[](const SkeletonID&Sid);
        RefPtr<Skeleton> operator()(const SkeletonID&Sid) const;


        RefPtr<Representation> CellsAsVertices(int dims) const; 

        int     MinLevel(int IndexDepth=0) const;
        int     MaxLevel(int IndexDepth=0) const;

        RefPtr<Skeleton> findRefinementLevel(int Level, int IndexDepth) const; 

        typedef SkeletonIterator Iterator; 

        int iterate(SkeletonIterator&) const;

        int nSkeletons() const;

#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

/*      /// Search for a certain chart by name
        RefPtr<Chart> findChart(const string&id) const
        {
                return (*myGridAtlas)(id);
        }
*/


        void    Speak(int indent=0, int maxindent=-1) const;
};

} /* namespace Fiber */ 

#endif /* __FIBER_GRID_HPP */