Gradient.hpp

#ifndef __FIBER_BASEOP_GRADIENT_HPP
#define __FIBER_BASEOP_GRADIENT_HPP
 
#include "gridopDllApi.h"
#include <grid/Representation.hpp>
#include <field/Derivative.hpp>
 
namespace Fiber
{
 
extern gridop_API RefPtr<MemBase>
        PartialDerivative(const RefPtr<MemBase>&SourceData);
 
extern gridop_API RefPtr<CreativeArrayBase> 
        PartialDerivative(const RefPtr<CreativeArrayBase>&CAB,
                          string&FailureDescription,
                          const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache() );
 
 
extern gridop_API
bool    isPartialDerivable(const RefPtr<CreativeArrayBase>&CAB);
 
extern gridop_API RefPtr<Field>
        PartialDerivative(Field&F, const string&GradientFieldname, 
                          Representation&CurrentRepresentation, Representation&FieldIDSource,
                          string&FailureDescription,
                          const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache() );
 
 
 
struct  gridop_API PartialDerivatorBase : ReferenceBase<PartialDerivatorBase>
{
        PartialDerivatorBase();
 
        virtual ~PartialDerivatorBase() = 0; 
 
        virtual bool isPartialDerivable(const MemArrayProperties&MAP) const = 0; 
 
        virtual RefPtr<MemBase> doPartialDerivative(const RefPtr<MemBase>&SourceData) const = 0;
 
};
 
 
 
template <class SourceArrayType, class DerivationType>
struct  PartialDerivator : public PartialDerivatorBase
{
        typedef typename SourceArrayType::value_type  source_value_type;
        enum { Dims = SourceArrayType::Dims };
 
 
        RefPtr<MemBase> doPartialDerivative(const RefPtr<MemBase>&SourceData) const override
        {
                if (RefPtr<SourceArrayType> MA = SourceData)
                        return Derivative<DerivationType>::compute( *MA );
 
                return NullPtr();
        }
 
        bool isPartialDerivable(const MemArrayProperties&MAP) const override
        {
                if (MAP.myElementType() == typeid(source_value_type) )
                {
                        if (MAP.rank == Dims)
                                return true;
                } 
                return false;
        }
};
 
 
 
 
#if      0
 
extern  RefPtr<MemBase> gridop_API ComputeDerivativeArray(const RefPtr<MemBase>&Source, const MemBase::Creator_t&Crec);
 
extern gridop_API RefPtr<Field> ComputeDerivative(Representation&Rep, const string&Fieldname,
                                                  const RefPtr<Representation>&FieldIDSource = NullPtr(),
                                                  const MemBase::Creator_t&Crec = NullPtr() );
 
#endif
 
 
} // namespace Fiber
 
#endif // __FIBER_BASEOP_GRADIENT_HPP