EigenValues.hpp

//
// $Id: EigenValues.hpp,v 1.1 2008/04/16 22:31:22 werner Exp $
//
#ifndef __FIBEROPERATIONS_EIGENVALUES_HPP
#define __FIBEROPERATIONS_EIGENVALUES_HPP

#include <field/MemBase.hpp>
#include <fiberop/TensorProperties.hpp>
#include <eagle/EigenVectors.hpp>
#include <grid/Representation.hpp>
#include <eagle/PhysicalSpace.hpp>
#include "fiberopDllApi.h"


namespace Fiber
{

struct  fiberop_API     EigenValueArrays
{
        RefPtr<TypedArray<double> >     pMajorEval,
                                        pMedianEval,
                                        pMinorEval;

        EigenValueArrays(Representation&R, const string&Fieldname, const RefPtr<FragmentID>&f)
        {
                pMajorEval  = R( Fieldname + "." FIBER_TENSORFIELDNAME_MAJOREIGENVALUE  , f );
                pMedianEval = R( Fieldname + "." FIBER_TENSORFIELDNAME_MEDIANEIGENVALUE , f );
                pMinorEval  = R( Fieldname + "." FIBER_TENSORFIELDNAME_MINOREIGENVALUE  , f );
        }
};

struct  fiberop_API     EigenArrays : EigenValueArrays 
{
        typedef Eagle::tvector3 vec3; 

        string  problem;        

        RefPtr<TypedArray<vec3> > pMajorEvec, pMedianEvec, pMinorEvec; 

        EigenArrays(Representation&R, const string&Fieldname, const RefPtr<FragmentID>&f); 

        EigenArrays(Representation&R, const RefPtr<CreativeArrayBase>&TensorField, const string&Fieldname, const RefPtr<FragmentID>&f,
                    bool TemporaryFields = false, bool Discardable = true);

        void create(const RefPtr<MemBase>&Data);

        void setFields(Representation&R, const string&Fieldname, const RefPtr<FragmentID>&f, 
                       const RefPtr<MemBase>&DataSource,
                       bool Discardable = true);


        bool    HasEigenFields() const;

        operator bool() const
        {
                return HasEigenFields();
        }
};


struct  fiberop_API     EigenValueIterators
{
        const Iterator<double>  &MajorEval, &MedianEval, &MinorEval;

        EigenValueIterators(const EigenValueArrays&EV)
        : MajorEval ( *EV.pMajorEval ->creativeIterator() )
        , MedianEval( *EV.pMedianEval->creativeIterator() )
        , MinorEval ( *EV.pMinorEval ->creativeIterator() )
        {}
};

struct  fiberop_API     EigenIterators : EigenValueIterators
{
        typedef Eagle::tvector3 vec3;

        const Iterator<vec3>&MajorEvec, &MedianEvec, &MinorEvec;

        EigenIterators(const EigenArrays&EA)
        : EigenValueIterators(EA)
        , MajorEvec  ( *EA.pMajorEvec ->creativeIterator()  )
        , MedianEvec ( *EA.pMedianEvec->creativeIterator() )
        , MinorEvec  ( *EA.pMinorEvec ->creativeIterator()  )
        {} 

        void compute(const Iterator<Eagle::metric33>&M, double precision = 1E-8);
};











struct  fiberop_API     WestinShapeFactors
{
        RefPtr<TypedArray<double> > pLinear, pPlanar, pSpherical, pTrace; 

        WestinShapeFactors(Representation&R, const string&Fieldname, const RefPtr<FragmentID>&f); 

        WestinShapeFactors(const EigenValueArrays&EA, Representation&R, 
                           const string&Fieldname, const RefPtr<FragmentID>&f,
                           bool TemporaryFields = false);

        bool HasShapeFactors() const
        {
                if (pLinear && pPlanar && pSpherical && pTrace)
                        return true; 
                else
                        return false;
        }

        operator bool() const
        {
                return HasShapeFactors();
        }

        bool    compute(const EigenValueArrays&EA);

        void setFields(Representation&R, const string&Fieldname, const RefPtr<FragmentID>&f, 
                       const RefPtr<MemBase>&DataSource,
                       bool Discardable = true);

};


} // namespace Fiber

#endif //__FIBEROPERATIONS_EIGENVALUES_HPP