Skeleton.hpp

#ifndef __FIBER_GRID_SKELETON_HPP
#define __FIBER_GRID_SKELETON_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 "BaseSpace.hpp"
#include "FiberSpace.hpp"
#include "Transformation.hpp"
#include "Representation.hpp"
#include "Chart.hpp"
#include "Atlas.hpp"
#include "GridContainer.hpp"

namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;


class   GRID_API FieldRef;

class   GRID_API Skeleton : public BaseSpace, public RepresentationMap
{
        WeakPtr<GridContainer>  myContainer;

public: 

        Skeleton (const WeakPtr<GridContainer>&C); 

        ~Skeleton(); 

        using RepresentationMap::operator[]; 
        using RepresentationMap::makeRepresentation; 
        using RepresentationMap::operator(); 
        using RepresentationMap::size; 
        using RepresentationMap::Iterator;
        using RepresentationMap::iterate; 


/*
        RefPtr<Representation> makeRepresentation(const Representer&D);

        Representation&operator[](const Representer&D);

        Representation&operator[](const BaseSpace&D)
        {
        Representer R = D.self(); 
                return (*this)[R];
        }

        RefPtr<Representation> operator()(const Representer&D) const;

        int size() const; 
*/

//      RefPtr<Representation> CartesianRepresentation() const;

        RefPtr<Representation> UniqueRepresentation() const; 

        RefPtr<Representation> FirstRepresentation() const; 

        override int Dims() const; 

        RefPtr<SizeInterface> getSize() const;

//      FieldRef operator[](const string&fieldname);
//      FieldRef operator[](const FieldID&fieldname);
/*
        **
           Base class for callback iterators;
        *
        class   GRID_API Iterator
        {
        public:
                virtual ~Iterator();
                
                virtual bool apply(const Representer&d, const Representation&R) = 0;
        };

        int iterate(Iterator&) const;
*/
};

typedef Skeleton Topology;

typedef RefPtr<Skeleton> pSkeleton;

typedef WeakPtr<Skeleton> wSkeleton;

/*
template <class CoordinateSystem>
        struct SkeletonRepresentation
{
static  Representation&makeDefaultRepresentation(const RefPtr<Skeleton>&SkelPtr, const RefPtr<GridAtlas>&GA)
        {
                if (!SkelPtr) puts("ERROR: No SkelPtr!"); 
                if (!GA)      puts("ERROR: No GridAtlas!"); 

        RefPtr<Chart> C = GridAtlas::CreateChart<CoordinateSystem>::global( (*GA) ); 
                if (!C) puts("ERROR: Cannot create global chart"); 

        Representation&Rep = (*SkelPtr)[C]; 

                return Rep;
        }
};
*/

class   GRID_API FieldRef
{
        RefPtr<Skeleton>        SkelPtr;
        RefPtr<FieldID>         Id;
        RefPtr<Atlas>           myGridAtlas;
        string                  fieldname;

public:
        FieldRef(const RefPtr<Skeleton>&S, const RefPtr<FieldID>&fid, const RefPtr<Atlas>&GA)
        : SkelPtr(S), Id(fid), myGridAtlas(GA)
        {}

        FieldRef(const RefPtr<Skeleton>&S, const string&fname, const RefPtr<Atlas>&GA)
        : SkelPtr(S), myGridAtlas(GA), fieldname(fname)
        {}

        ~FieldRef();

/*
        template <class CoordinateSystem, class TensorType>
                void operator=(const Tensor<CoordinateSystem, TensorType>&Value)
        {
        typedef Tensor<CoordinateSystem, TensorType> value_type;
        typedef MemArrayStorage<1, value_type, vector<value_type> > array_type;

        array_type*Data = new array_type(1);
                Data->myArray()[0] = Value;

        RefPtr<Field> myField = new Field();
                myField->setCreator( new MemCreativeArray(Data) ); 

//      RefPtr<Chart> C = CreateChart<CoordinateSystem>::global( (*myGridAtlas) ); 
//      Representation&Rep = (*SkelPtr)[C];

        Representation&Rep = SkeletonRepresentation<CoordinateSystem>::makeDefaultRepresentation(SkelPtr, myGridAtlas);
                if (!Id)
                {
                FieldID&Fid = Rep[fieldname];
                        Id = &Fid;
                }

                Rep[ Id ] = myField;
        }
*/

#if 0

        bool operator=(const double&Value)
        {
        typedef double value_type;
        typedef MemArrayStorage<1, value_type, vector<value_type> > array_type;

        array_type*Data = new array_type( MIndex(1) );
                Data->myArray()[0] = Value;

        RefPtr<Representation> Rep = SkelPtr->DefaultRepresentation();
                if (!Rep)
                        return false;

        RefPtr<Field> myField = new Field();
                myField->setCreator( new MemCreativeArray(Data) );

                if (!Id)
                {
                FieldID&Fid = (*Rep)[fieldname];
                        Id = &Fid;
                }

                (*Rep)[ Id ] = myField;

                return true;
        }
#endif


/*
        template <class CoordinateSystem, class real>
        void operator=(const Point<CoordinateSystem, real>&Vertex)
        {
        typedef Point<CoordinateSystem, real> value_type;
        typedef MemArrayStorage<1, value_type, vector<value_type> > array_type; 

//      RefPtr<Chart> C = CreateChart<CoordinateSystem>::global( (*myGridAtlas) ); 

//              printf("Got chart named '%s' for storing points as %s (of %s)...\n", C->ID().c_str(), typeid(real).name(), typeid(Vertex).name() );

//      Representation&Rep = (*SkelPtr)[C]; 

        Representation&Rep = SkeletonRepresentation<CoordinateSystem>::makeDefaultRepresentation(SkelPtr, myGridAtlas);

        array_type*Data = new array_type( MIndex(1) );
                Data->myArray()[0] = Vertex;

        RefPtr<Field> myField = new Field();
                myField->setCreator( new MemCreativeArray(Data) );

                if (!Id)
                {
                FieldID&Fid = Rep[fieldname];
                        Id = &Fid;
                }

                Rep[ Id ] = myField;
        }
*/
};

} /* namespace Fiber */ 

#endif /* __FIBER_GRID_SKELETON_HPP */