StressTensorValues.hpp

 
//
// $Id: hpp,v 1.0 2000/01/01 00:00:01 werner Exp $
//
// $Log: hpp,v $
// Created 2012/01/19 17:35:06  marcel
// Initial version
//
//
#ifndef __FIBEROPERATIONS_STRESSTENSORVALUES_HPP
#define __FIBEROPERATIONS_STRESSTENSORVALUES_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     StressTensorValueArrays
{
        RefPtr<TypedArray<double> >     pInvariant1,
                                        pInvariant2,
                                        pInvariant3,
                                        pPressure,
                                        pMises;
 
        StressTensorValueArrays(Representation&R, const string&Fieldname, const RefPtr<FragmentID>&f)
        {
                pInvariant1  = -R( Fieldname + "." FIBER_TENSORFIELDNAME_STRESSINVARIANT1  , f );
                pInvariant2  = -R( Fieldname + "." FIBER_TENSORFIELDNAME_STRESSINVARIANT2  , f );
                pInvariant3  = -R( Fieldname + "." FIBER_TENSORFIELDNAME_STRESSINVARIANT3  , f ); 
                pPressure    = -R( Fieldname + "." FIBER_TENSORFIELDNAME_PRESSURE          , f ); 
                pMises       = -R( Fieldname + "." FIBER_TENSORFIELDNAME_MISES             , f ); 
        }
 
 
        bool    hasData() const;
};
 
 
struct  fiberop_API     StressTensorFields
{
        RefPtr<Field>
                TheTensorField,
 
                Invariant1,
                Invariant2,
                Invariant3,
                Pressure,
                Mises; 
 
        StressTensorFields(Representation&R, const string&Fieldname)
        {
                TheTensorField = R(Fieldname);
 
                Invariant1  = R( Fieldname + "." FIBER_TENSORFIELDNAME_STRESSINVARIANT1); 
                Invariant2  = R( Fieldname + "." FIBER_TENSORFIELDNAME_STRESSINVARIANT2); 
                Invariant3  = R( Fieldname + "." FIBER_TENSORFIELDNAME_STRESSINVARIANT3); 
                Pressure    = R( Fieldname + "." FIBER_TENSORFIELDNAME_PRESSURE); 
                Mises       = R( Fieldname + "." FIBER_TENSORFIELDNAME_MISES); 
                
 
        }
 
        MemCore::Ageable YoungestStressTensorField() const
        {
        MemCore::Ageable        
                result = MemCore::Ageable::InfinitelyOld(); 
 
                if( Invariant1 ) result.update(*Invariant1); 
                if( Invariant2 ) result.update(*Invariant2); 
                if( Invariant3 ) result.update(*Invariant3); 
                if( Pressure )   result.update(*Pressure); 
                if( Mises )      result.update(*Mises); 
 
                return result;
        } 
 
        bool    NeedComputation() const
        {
                if (!TheTensorField) return false; 
 
                return TheTensorField->isNewerThan( YoungestStressTensorField() );
        }
};
 
struct  fiberop_API     StressTensorArrays : StressTensorValueArrays 
{
        typedef Eagle::tvector3 vec3; 
 
        string  problem; 
 
//      RefPtr<TypedArray<vec3> > pMajorEvec, pMedianEvec, pMinorEvec; 
 
        StressTensorArrays(Representation&R, const string&Fieldname, const RefPtr<FragmentID>&f); 
 
        StressTensorArrays(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    HasStressTensorFields() const;
 
        operator bool() const
        {
                return HasStressTensorFields();
        }
};
 
 
struct  fiberop_API     StressTensorValueIterators
{
const Iterator<double>  &Invariant1, &Invariant2, &Invariant3, &Pressure, &Mises;
 
        StressTensorValueIterators(const StressTensorValueArrays&SV)
        : Invariant1 ( *SV.pInvariant1->creativeIterator() )
        , Invariant2 ( *SV.pInvariant2->creativeIterator() )
        , Invariant3 ( *SV.pInvariant3->creativeIterator() )
        , Pressure   ( *SV.pPressure->creativeIterator() )
        , Mises      ( *SV.pMises->creativeIterator() )
        {} 
 
void compute(const Iterator<Eagle::metric33>&M, double precision = 1E-8);
};
 
} // namespace fiber
 
#endif