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 );
        }
 
 
        bool    hasData() const;
};
 
struct  fiberop_API     EigenFields
{
        RefPtr<Field>
                TheTensorField,
 
                MajorEvec,
                MedianEvec,
                MinorEvec,
 
                MajorEval,
                MedianEval,
                MinorEval; 
 
        EigenFields(Representation&R, const string&Fieldname)
        {
                TheTensorField = R(Fieldname);
 
                MajorEvec  = R( Fieldname + "." FIBER_TENSORFIELDNAME_MAJOREIGENVECTOR ); 
                MedianEvec = R( Fieldname + "." FIBER_TENSORFIELDNAME_MEDIANEIGENVECTOR ); 
                MinorEvec  = R( Fieldname + "." FIBER_TENSORFIELDNAME_MINOREIGENVECTOR );
 
                MajorEval  = R( Fieldname + "." FIBER_TENSORFIELDNAME_MAJOREIGENVALUE ); 
                MedianEval = R( Fieldname + "." FIBER_TENSORFIELDNAME_MEDIANEIGENVALUE );
                MinorEval  = R( Fieldname + "." FIBER_TENSORFIELDNAME_MINOREIGENVALUE  );
        }
 
        MemCore::Ageable YoungestEigenField() const
        {
        MemCore::Ageable        
                result = MemCore::Ageable::InfinitelyOld(); 
 
                if (MajorEvec ) result.update(*MajorEvec); 
                if (MedianEvec) result.update(*MedianEvec); 
                if (MinorEvec ) result.update(*MinorEvec); 
 
                if (MajorEval ) result.update(*MajorEval); 
                if (MedianEval) result.update(*MedianEval); 
                if (MinorEval ) result.update(*MinorEval);
 
                return result;
        } 
 
        bool    NeedComputation() const
        {
                if (!TheTensorField) return false; 
 
                return TheTensorField->isNewerThan( YoungestEigenField() );
        }
};
 
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