#include <StructureDeformationModel.h>

Inheritance diagram for StructureDeformationModel< T >:

Collaboration diagram for StructureDeformationModel< T >:

Public Types
typedef Array< T >	TArray

typedef Vector< T, 3 >	VectorT3

typedef Array< VectorT3 >	VectorT3Array

Public Member Functions
	StructureDeformationModel (GeomFields &geomFields, StructureFields &structureFields, const MeshList &meshes)

virtual	~StructureDeformationModel ()

void	calculateNodeDisplacement ()

void	deformStructure ()

void	deformMeshStructure ()

void	updateBoundaryMesh (const Mesh &mesh, Mesh &bMesh, Field &velocityField, const double timeStep)

void	updateBoundaryMesh (const Mesh &mesh, Mesh &bMesh, Field &velocityField, const map< int, int > &commonFacesMap, const double timeStep)

const ArrayBase &	getCommon (const StorageSite &site, const StorageSite &osite)

void	init ()

void	updateTime ()

Public Member Functions inherited from Model
	Model (const MeshList &meshes)

virtual	~Model ()

	DEFINE_TYPENAME ("Model")

virtual map< string, shared_ptr< ArrayBase > > &	getPersistenceData ()

virtual void	restart ()

Private Attributes
GeomFields &	_geomFields

StructureFields &	_structureFields

const MeshList	_meshes

Additional Inherited Members
Protected Attributes inherited from Model
const MeshList	_meshes

StorageSiteList	_varSites

StorageSiteList	_fluxSites

map< string, shared_ptr < ArrayBase > >	_persistenceData

Detailed Description

template<class T>
class StructureDeformationModel< T >

Definition at line 21 of file StructureDeformationModel.h.

Member Typedef Documentation

template<class T >

typedef Array<T> StructureDeformationModel< T >::TArray

Definition at line 24 of file StructureDeformationModel.h.

template<class T >

typedef Vector<T,3> StructureDeformationModel< T >::VectorT3

Definition at line 25 of file StructureDeformationModel.h.

template<class T >

typedef Array<VectorT3> StructureDeformationModel< T >::VectorT3Array

Definition at line 26 of file StructureDeformationModel.h.

Constructor & Destructor Documentation

template<class T >

StructureDeformationModel< T >::StructureDeformationModel	(	GeomFields &	geomFields,
		StructureFields &	structureFields,
		const MeshList &	meshes
	)

inline

Definition at line 28 of file StructureDeformationModel.h.

References logCtor.

                                                     :
     Model(meshes),
     _geomFields(geomFields),
     _structureFields(structureFields),
     _meshes(meshes)
   {
     logCtor();
   }

template<class T >

virtual StructureDeformationModel< T >::~StructureDeformationModel ( )

inlinevirtual

Definition at line 39 of file StructureDeformationModel.h.

39 {}

Member Function Documentation

template<class T >

void StructureDeformationModel< T >::calculateNodeDisplacement ( )

inline

Definition at line 41 of file StructureDeformationModel.h.

References StructureDeformationModel< T >::_geomFields, StructureDeformationModel< T >::_meshes, StructureDeformationModel< T >::_structureFields, GeomFields::coordinate, StructureFields::deformation, Mesh::getCellNodes(), Mesh::getCells(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getNodes(), CRConnectivity::getTranspose(), mag(), and GeomFields::nodeDisplacement.

   {
       const int numMeshes = _meshes.size();
       for (int m=0;m<numMeshes;m++)
       {
           const Mesh& mesh = *_meshes[m];
           const StorageSite& nodes = mesh.getNodes();
           const StorageSite& cells = mesh.getCells();
           const int nNodes = nodes.getCount();
           const CRConnectivity& cellNodes = mesh.getCellNodes();
           shared_ptr<CRConnectivity> nodeCellsPtr = cellNodes.getTranspose();
           CRConnectivity& nodeCells = *nodeCellsPtr;
           const VectorT3Array& nodeCoordinate =
             dynamic_cast<const VectorT3Array&>(_geomFields.coordinate[nodes]);
           const VectorT3Array& cellCentroid =
             dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[cells]);
           const VectorT3Array& cellDisplacement =
             dynamic_cast<const VectorT3Array&>(_structureFields.deformation[cells]);
           VectorT3Array& nodeDisplacement =
             dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacement[nodes]);
           const T one(1.0);
 
           for(int j=0;j<nNodes;j++)
           {
               VectorT3 dr(NumTypeTraits<VectorT3>::getZero());
               T weight(0.0);
               for(int k=0;k<nodeCells.getCount(j);k++)
               {
                   const int num = nodeCells(j,k);
                   const VectorT3 ds = cellCentroid[num]-nodeCoordinate[j];
                   dr += cellDisplacement[num]/mag(ds);
                   weight += one/mag(ds);
               }
               dr = dr/weight;
               nodeDisplacement[j] = dr;
           }
       }
   }

template<class T >

void StructureDeformationModel< T >::deformMeshStructure ( )

inline

Definition at line 104 of file StructureDeformationModel.h.

References StructureDeformationModel< T >::_geomFields, StructureDeformationModel< T >::_meshes, GeomFields::coordinate, GeomFields::coordinate0, GeomFields::coordinateK1, GeomFields::displacementOptions, StorageSite::getCount(), Mesh::getNodes(), and GeomFields::nodeDisplacement.

   {
       const int numMeshes = _meshes.size();
       for (int n=0;n<numMeshes;n++)
       {
           const Mesh& mesh = *_meshes[n];
           const StorageSite& nodes = mesh.getNodes();
           const int nNodes = nodes.getCount();
           const Array<int>& displacementOptions =
             dynamic_cast<Array<int>& > (_geomFields.displacementOptions[nodes]);
           VectorT3Array& nodeCoord =
             dynamic_cast<VectorT3Array&>(_geomFields.coordinate[nodes]);
           const VectorT3Array& nodeCoord0 =
             dynamic_cast<const VectorT3Array&>(_geomFields.coordinate0[nodes]);
           VectorT3Array& nodeDisplacement =
             dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacement[nodes]);
           VectorT3Array& nodeCoordK1 =
             dynamic_cast<VectorT3Array&>(_geomFields.coordinateK1[nodes]);
           nodeCoordK1 = nodeCoord;        
           for (int i=0;i<nNodes;i++)
           {
               if(displacementOptions[i] == 3)
               {
                   nodeCoord[i] = nodeCoord0[i] + nodeDisplacement[i];
               }
           }
       }
   }

template<class T >

void StructureDeformationModel< T >::deformStructure ( )

inline

Definition at line 80 of file StructureDeformationModel.h.

References StructureDeformationModel< T >::_geomFields, StructureDeformationModel< T >::_meshes, GeomFields::coordinate, GeomFields::coordinate0, GeomFields::coordinateK1, StorageSite::getCount(), Mesh::getNodes(), and GeomFields::nodeDisplacement.

   {
       const int numMeshes = _meshes.size();
       for (int n=0;n<numMeshes;n++)
       {
           const Mesh& mesh = *_meshes[n];
           const StorageSite& nodes = mesh.getNodes();
           const int nNodes = nodes.getCount();
           VectorT3Array& nodeCoord =
             dynamic_cast<VectorT3Array&>(_geomFields.coordinate[nodes]);
           const VectorT3Array& nodeCoord0 =
             dynamic_cast<const VectorT3Array&>(_geomFields.coordinate0[nodes]);
           VectorT3Array& nodeDisplacement =
             dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacement[nodes]);
           VectorT3Array& nodeCoordK1 =
             dynamic_cast<VectorT3Array&>(_geomFields.coordinateK1[nodes]);
           nodeCoordK1 = nodeCoord;
           for (int i=0;i<nNodes;i++)
           {
               nodeCoord[i] = nodeCoord0[i] + nodeDisplacement[i];
           }
       }
   }

template<class T >

const ArrayBase& StructureDeformationModel< T >::getCommon	(	const StorageSite &	site,
		const StorageSite &	osite
	)

inline

Definition at line 254 of file StructureDeformationModel.h.

References StorageSite::getCommonMap().

   {
     
     const StorageSite::CommonMap& commonMap = site.getCommonMap();    
     //cout<<"\n The size of commonMap is "<<commonMap.size()<<"\n";
 
     const Array<int>& myNodeIndices =
       *(site.getCommonMap().find(&osite)->second);
     return myNodeIndices;
   }

template<class T >

void StructureDeformationModel< T >::init ( )

inlinevirtual

Implements Model.

Definition at line 265 of file StructureDeformationModel.h.

References StructureDeformationModel< T >::_geomFields, StructureDeformationModel< T >::_meshes, Field::addArray(), GeomFields::coordinate, GeomFields::coordinate0, GeomFields::coordinateK1, StorageSite::getCount(), Mesh::getNodes(), Array< T >::newCopy(), GeomFields::nodeDisplacement, and GeomFields::nodeDisplacementN1.

   {
       const int numMeshes = _meshes.size();
       for (int n=0;n<numMeshes;n++)
       {
           const Mesh& mesh = *_meshes[n];
           const StorageSite& nodes = mesh.getNodes();
           VectorT3Array& nodeCoord =
             dynamic_cast<VectorT3Array&>(_geomFields.coordinate[nodes]);
           _geomFields.coordinateK1.addArray(nodes,
             dynamic_pointer_cast<ArrayBase>(nodeCoord.newCopy()));
 
           _geomFields.coordinate0.addArray(nodes,
             dynamic_pointer_cast<ArrayBase>(nodeCoord.newCopy()));
 
           shared_ptr<VectorT3Array>
             nodeDisplacement(new VectorT3Array(nodes.getCount()));
           nodeDisplacement->zero();
           _geomFields.nodeDisplacement.addArray(nodes,nodeDisplacement);
 
           shared_ptr<VectorT3Array>
             nodeDisplacementN1(new VectorT3Array(nodes.getCount()));
           nodeDisplacementN1->zero();
 
           _geomFields.nodeDisplacementN1.addArray(nodes,
                                                   nodeDisplacementN1);
       }
   }

template<class T >

void StructureDeformationModel< T >::updateBoundaryMesh	(	const Mesh &	mesh,
		Mesh &	bMesh,
		Field &	velocityField,
		const double	timeStep
	)

inline

Definition at line 136 of file StructureDeformationModel.h.

References StructureDeformationModel< T >::_geomFields, Field::addArray(), GeomFields::coordinate, Mesh::getAllFaceGroups(), StorageSite::getCommonMap(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getFaceNodes(), Mesh::getFaces(), Array< T >::getLength(), Mesh::getNodeCoordinates(), Mesh::getNodes(), Vector< T, 3 >::getZero(), FaceGroup::groupType, GeomFields::nodeDisplacement, GeomFields::nodeDisplacementN1, and FaceGroup::site.

   {
     // update node coords
     const StorageSite& bMeshNodes = bMesh.getNodes();
     
     
     const StorageSite& nodes = mesh.getNodes();
 
     const VectorT3Array& nodeCoord =
       dynamic_cast<const VectorT3Array&>(_geomFields.coordinate[nodes]);
 
     VectorT3Array& bNodeCoord =
       dynamic_cast<VectorT3Array&>(_geomFields.coordinate[bMeshNodes]);
 
     VectorT3Array& bMeshCoord = bMesh.getNodeCoordinates();
 
     const Array<int>& myNodeIndices =
       *(bMeshNodes.getCommonMap().find(&nodes)->second);
     const Array<int>& bNodeIndices =
       *(nodes.getCommonMap().find(&bMeshNodes)->second);
 
     const int nCommon = myNodeIndices.getLength();
     for(int n=0; n<nCommon; n++)
     {
         bNodeCoord[bNodeIndices[n]] = nodeCoord[myNodeIndices[n]];
         bMeshCoord[bNodeIndices[n]] = nodeCoord[myNodeIndices[n]];
     }
    
 
 
     // update face velocity
     
     const StorageSite& bMeshFaces = bMesh.getFaces();
 
     shared_ptr<VectorT3Array>
       bVelocity(new VectorT3Array(bMeshFaces.getCount()));
 
     velocityField.addArray(bMeshFaces,bVelocity);
 
     VectorT3Array& w =
       dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacement[nodes]);
     VectorT3Array& wN1 =
       dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacementN1[nodes]);
 
     int bMeshFaceCount=0;
 
     foreach(const FaceGroupPtr fgPtr, mesh.getAllFaceGroups())
     {
         const FaceGroup& fg = *fgPtr;
         const StorageSite& faces = fg.site;
         if (fg.groupType!="interior")
         {
             const int nFaces = faces.getCount();
             const CRConnectivity& faceNodes = mesh.getFaceNodes(faces);
             for(int f=0; f<nFaces; f++)
             {
                 const int nFaceNodes = faceNodes.getCount(f);
                 VectorT3 vf(VectorT3::getZero());
                 
                 for(int nn=0; nn<nFaceNodes; nn++)
                 {
                     const int node = faceNodes(f,nn);
                     VectorT3 vn = (w[node] - wN1[node])/timeStep;
                     vf += vn;
                 }
                 vf /= nFaceNodes;
                 (*bVelocity)[bMeshFaceCount] = vf;
                  bMeshFaceCount++;
             }
         }
     }
   }

template<class T >

void StructureDeformationModel< T >::updateBoundaryMesh	(	const Mesh &	mesh,
		Mesh &	bMesh,
		Field &	velocityField,
		const map< int, int > &	commonFacesMap,
		const double	timeStep
	)

inline

Definition at line 214 of file StructureDeformationModel.h.

References StructureDeformationModel< T >::_geomFields, Field::addArray(), Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getFaceNodes(), Mesh::getFaces(), Mesh::getNodes(), StorageSite::getOffset(), Vector< T, 3 >::getZero(), GeomFields::nodeDisplacement, GeomFields::nodeDisplacementN1, and FaceGroup::site.

   {
     // update face velocity
     const StorageSite& bMeshFaces = bMesh.getFaces();
     shared_ptr<VectorT3Array>
       bVelocity(new VectorT3Array(bMeshFaces.getCount()));
       bVelocity->zero();
 
     velocityField.addArray(bMeshFaces,bVelocity);
   
     const StorageSite& nodes = mesh.getNodes();
     VectorT3Array& w =
       dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacement[nodes]);
     VectorT3Array& wN1 =
       dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacementN1[nodes]);
 
     foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups()){
        const FaceGroup& fg = *fgPtr;
        const StorageSite& faces = fg.site;
        const int nFaces = faces.getCount();
        const CRConnectivity& faceNodes = mesh.getFaceNodes(faces);
        for(int f=0; f<nFaces; f++){
           const int faceID = f + faces.getOffset();
           const int nFaceNodes = faceNodes.getCount(f);
           VectorT3 vf(VectorT3::getZero());
               
           for(int nn=0; nn<nFaceNodes; nn++){
              const int node = faceNodes(f,nn);
              VectorT3 vn = (w[node] - wN1[node])/timeStep;
              vf += vn;
           }
           vf /= nFaceNodes;
           (*bVelocity)[ commonFacesMap.find(faceID)->second ] = vf;
        }
     }
   } 

template<class T >

void StructureDeformationModel< T >::updateTime ( )

inline

Definition at line 294 of file StructureDeformationModel.h.

References StructureDeformationModel< T >::_geomFields, StructureDeformationModel< T >::_meshes, Mesh::getNodes(), GeomFields::nodeDisplacement, and GeomFields::nodeDisplacementN1.

   {
     const int numMeshes = _meshes.size();
     for (int n=0; n<numMeshes; n++)
     {
         const Mesh& mesh = *_meshes[n];
 
         const StorageSite& nodes = mesh.getNodes();
         VectorT3Array& w =
           dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacement[nodes]);
         VectorT3Array& wN1 =
           dynamic_cast<VectorT3Array&>(_geomFields.nodeDisplacementN1[nodes]);
         wN1 = w;
     }
   }