#include <TractionVal.h>

Collaboration diagram for TractionValEvaluator< T >:

Public Member Functions
	TractionValEvaluator (const FloatVal< T > &fval0, const FloatVal< T > &fval1, const FloatVal< T > &fval2, const FloatVal< T > &fval3, const FloatVal< T > &fval4, const FloatVal< T > &fval5, const FloatVal< T > &fval6, const FloatVal< T > &fval7, const FloatVal< T > &fval8, const GeomFields &geomFields, const StorageSite &site)

const Vector< T, 3 > &	operator[] (const int i) const

Private Attributes
Vector< T, 3 >	_constant0

Vector< T, 3 >	_constant1

Vector< T, 3 >	_constant2

Vector< T, 3 >	_constant

const Array< Vector< T, 3 > > &	_faceArea

const Array< T > &	_faceAreaMag

const bool	_isField0

const bool	_isField1

const bool	_isField2

shared_ptr< Array< T > >	_arrayPtr0

shared_ptr< Array< T > >	_arrayPtr1

shared_ptr< Array< T > >	_arrayPtr2

shared_ptr< Array< T > >	_arrayPtr3

shared_ptr< Array< T > >	_arrayPtr4

shared_ptr< Array< T > >	_arrayPtr5

shared_ptr< Array< T > >	_arrayPtr6

shared_ptr< Array< T > >	_arrayPtr7

shared_ptr< Array< T > >	_arrayPtr8

Detailed Description

template<class T>
class TractionValEvaluator< T >

Definition at line 28 of file TractionVal.h.

Constructor & Destructor Documentation

template<class T >

TractionValEvaluator< T >::TractionValEvaluator	(	const FloatVal< T > &	fval0,
		const FloatVal< T > &	fval1,
		const FloatVal< T > &	fval2,
		const FloatVal< T > &	fval3,
		const FloatVal< T > &	fval4,
		const FloatVal< T > &	fval5,
		const FloatVal< T > &	fval6,
		const FloatVal< T > &	fval7,
		const FloatVal< T > &	fval8,
		const GeomFields &	geomFields,
		const StorageSite &	site
	)

inline

Definition at line 31 of file TractionVal.h.

                                              :
     _faceArea(dynamic_cast<const Array<Vector<T,3> >&>(geomFields.area[site])),
     _faceAreaMag(dynamic_cast<const Array<T>&>(geomFields.areaMag[site])),
     _isField0(fval0.field != 0),
     _isField1(fval4.field != 0),
     _isField2(fval8.field != 0),
     _arrayPtr0(),
     _arrayPtr1(),
     _arrayPtr2(),
     _arrayPtr3(),
     _arrayPtr4(),
     _arrayPtr5(),
     _arrayPtr6(),
     _arrayPtr7(),
     _arrayPtr8()
   {
     if (_isField0)
     {
         _arrayPtr0 = dynamic_pointer_cast<Array<T> >(fval0.field->getArrayPtr(site));
         _arrayPtr1 = dynamic_pointer_cast<Array<T> >(fval1.field->getArrayPtr(site));
         _arrayPtr2 = dynamic_pointer_cast<Array<T> >(fval2.field->getArrayPtr(site));
     }
     else
     {
         _constant0[0] = fval0.constant;
         _constant0[1] = fval1.constant;
         _constant0[2] = fval2.constant;
     }
     if (_isField1)
     {
         _arrayPtr3 = dynamic_pointer_cast<Array<T> >(fval3.field->getArrayPtr(site));
         _arrayPtr4 = dynamic_pointer_cast<Array<T> >(fval4.field->getArrayPtr(site));
         _arrayPtr5 = dynamic_pointer_cast<Array<T> >(fval5.field->getArrayPtr(site));
     }
     else
     {
         _constant1[0] = fval3.constant;
         _constant1[1] = fval4.constant;
         _constant1[2] = fval5.constant;
     }      
     if (_isField2)
     {
         _arrayPtr6 = dynamic_pointer_cast<Array<T> >(fval6.field->getArrayPtr(site));
         _arrayPtr7 = dynamic_pointer_cast<Array<T> >(fval7.field->getArrayPtr(site));
         _arrayPtr8 = dynamic_pointer_cast<Array<T> >(fval8.field->getArrayPtr(site));
     }
     else
     {
         _constant2[0] = fval6.constant;
         _constant2[1] = fval7.constant;
         _constant2[2] = fval8.constant;
     }
   }

Member Function Documentation

template<class T >

const Vector<T,3>& TractionValEvaluator< T >::operator[] ( const int i ) const

inline

Definition at line 95 of file TractionVal.h.

References TractionValEvaluator< T >::_constant, TractionValEvaluator< T >::_constant0, TractionValEvaluator< T >::_constant1, TractionValEvaluator< T >::_constant2, TractionValEvaluator< T >::_faceArea, TractionValEvaluator< T >::_faceAreaMag, TractionValEvaluator< T >::_isField0, TractionValEvaluator< T >::_isField1, TractionValEvaluator< T >::_isField2, and dot().

   {
    
     Vector<T,3> en(_faceArea[i]/_faceAreaMag[i]);
     Vector<T,3> traction0(NumTypeTraits<Vector<T,3> >::getZero());
     Vector<T,3> traction1(NumTypeTraits<Vector<T,3> >::getZero());
     Vector<T,3> traction2(NumTypeTraits<Vector<T,3> >::getZero());
 
     if (_isField0)
     {
         traction0[0] = (*_arrayPtr0)[i];
         traction0[1] = (*_arrayPtr1)[i];
         traction0[2] = (*_arrayPtr2)[i];
         _constant[0] = dot(traction0,en);
     }
     else
     {
         _constant[0] = dot(_constant0,en);
     }
     if (_isField1)
     {
         traction1[0] = (*_arrayPtr3)[i];
         traction1[1] = (*_arrayPtr4)[i];
         traction1[2] = (*_arrayPtr5)[i];
         _constant[1] = dot(traction1,en);
     }
     else
     {
         _constant[1] = dot(_constant1,en);
     }
     if (_isField2)
     {
         traction2[0] = (*_arrayPtr6)[i];
         traction2[1] = (*_arrayPtr7)[i];
         traction2[2] = (*_arrayPtr8)[i];
         _constant[2] = dot(traction2,en);
     }
     else
     {
         _constant[2] = dot(_constant2,en);
     }
 
     return _constant;
   }