GridSelector.hpp

#ifndef __FIBER_GRIDSELECTOR_HPP
#define __FIBER_GRIDSELECTOR_HPP

#include "BundleAPI.h"
#include "Bundle.hpp"

namespace Fiber
{

struct  BUNDLE_API GridSelector
{
public:
        BundlePtr               theSourceBundle;

        string                  theGridname; 

        const string&getGridname() const { return theGridname; }

        GridSelector();

        GridSelector(const string&gridname, const Fiber::BundlePtr&Source = Fiber::BundlePtr(NullPtr() ) )
        : theSourceBundle(Source)
        , theGridname(gridname)
        {}

        GridSelector(const Fiber::BundlePtr&Source, const string&gridname)
        : theSourceBundle(Source)
        , theGridname(gridname)
        {}

        ~GridSelector();

        friend bool operator==(const GridSelector&L, const GridSelector&R)
        {
                return  L.theSourceBundle == R.theSourceBundle &&
                        L.theGridname == R.theGridname;
        } 

        friend bool operator!=(const GridSelector&L, const GridSelector&R)
        {
                return  !(L==R);
        }

        const string&Gridname() const
        {
                return theGridname;
        }

        const Fiber::BundlePtr&BundleSource() const
        {
                return theSourceBundle;
        }

        const Fiber::BundlePtr&getBundle() const
        {
                return theSourceBundle;
        }

        bool selectGrid(const string&name)
        {
                theGridname = name;
                return true;

                /*
                if (!theSpacetime)
                        return false;

                theGridID = (*theSpacetime)[ name ];
                return theGridID.valid();
                */
        }

        Info<Grid> findMostRecentGrid(const Fiber::BundlePtr&theSpacetime, double time) const
        {
                if (!theSpacetime)
                        return Info<Grid>();

                return  theSpacetime->findMostRecentGrid(time, theGridname);
        } 

        Info<Grid>      findMostRecentGrid(double time, 
                                           const Fiber::BundlePtr&theSpacetime = Fiber::BundlePtr(NullPtr() ) ) const
        {
                if (!theSpacetime)
                {
                        if (!theSourceBundle)
                                return Info<Grid>();
                        else
                                return theSourceBundle->findMostRecentGrid(time, theGridname);
                }

                return  theSpacetime->findMostRecentGrid(time, theGridname);
        } 

        Info<Skeleton> getRefinementLevel(double time,
                                          int Level, int IndexDepth,
                                          const BundlePtr&SpaceTime = BundlePtr(NullPtr() ) );

        Info<Grid> findPrev(double time, const BundlePtr&theSpacetime = BundlePtr(NullPtr()) ) const
        {
                if (!theSpacetime)
                {
                        if (!theSourceBundle)
                                return Info<Grid>();
                        else
                                theSourceBundle->findPrev(time, theGridname);
                }

                return theSpacetime->findPrev(time, theGridname);
        } 

        Info<Grid> findNext(double time, const BundlePtr&theSpacetime = BundlePtr(NullPtr() ) ) const
        {
                if (!theSpacetime)
                {
                        if (!theSourceBundle)
                                return Info<Grid>();
                        else
                                theSourceBundle->findNext(time, theGridname);
                }

                return theSpacetime->findNext(time, theGridname);
        }

        Fiber::Grid&operator[](double time)
        {
                return theSourceBundle[time][ Gridname() ];
        } 

        RefPtr<Fiber::Grid> operator()(double time, 
                                       const Fiber::BundlePtr&theSpacetime = Fiber::BundlePtr(NullPtr() )) const
        {
        Fiber::Bundle::GridInfo_t G = findMostRecentGrid(time, theSpacetime); 
                return G.getGrid();
        } 

        RefPtr<Fiber::Grid> operator()(double time, const GridSelector&GS)
        {
        Fiber::Bundle::GridInfo_t G = findMostRecentGrid(time, GS.theSourceBundle); 
                return G.getGrid();
        }
};


} /* namespace Fiber */ 

#endif /* __FIBER_GRIDSELECTOR_HPP */