#include <FractureModel_impl.h>

Collaboration diagram for FractureModel< T >::Impl:

Public Types
typedef Array< T >	TArray

typedef Vector< T, 3 >	VectorT3

typedef Array< VectorT3 >	VectorT3Array

typedef Gradient< T >	TGradType

typedef Array< Gradient< T > >	TGradArray

typedef CRMatrix< T, T, T >	T_Matrix

typedef SquareTensor< T, 3 >	DiagTensorT3

Public Member Functions
	Impl (const GeomFields &geomFields, FractureFields &fractureFields, const MeshList &meshes)

void	init ()

FractureBCMap &	getBCMap ()

FractureVCMap &	getVCMap ()

FractureBC< T > &	getBC (const int id)

FractureModelOptions< T > &	getOptions ()

void	initLinearization (LinearSystem &ls)

void	linearize (LinearSystem &ls)

void	advance (const int niter)

void	printBCs ()

void	updateTime ()

Private Attributes
const MeshList	_meshes

const GeomFields &	_geomFields

FractureFields &	_fractureFields

FractureBCMap	_bcMap

FractureVCMap	_vcMap

FractureModelOptions< T >	_options

GradientModel< T >	_phasefieldGradientModel

MFRPtr	_initialNorm

int	_niters

Detailed Description

template<class T>
class FractureModel< T >::Impl

Definition at line 32 of file FractureModel_impl.h.

Member Typedef Documentation

template<class T>

typedef SquareTensor<T,3> FractureModel< T >::Impl::DiagTensorT3

Definition at line 41 of file FractureModel_impl.h.

template<class T>

typedef CRMatrix<T,T,T> FractureModel< T >::Impl::T_Matrix

Definition at line 40 of file FractureModel_impl.h.

template<class T>

typedef Array<T> FractureModel< T >::Impl::TArray

Definition at line 35 of file FractureModel_impl.h.

template<class T>

typedef Array<Gradient<T> > FractureModel< T >::Impl::TGradArray

Definition at line 39 of file FractureModel_impl.h.

template<class T>

typedef Gradient<T> FractureModel< T >::Impl::TGradType

Definition at line 38 of file FractureModel_impl.h.

template<class T>

typedef Vector<T,3> FractureModel< T >::Impl::VectorT3

Definition at line 36 of file FractureModel_impl.h.

template<class T>

typedef Array<VectorT3> FractureModel< T >::Impl::VectorT3Array

Definition at line 37 of file FractureModel_impl.h.

Constructor & Destructor Documentation

template<class T>

FractureModel< T >::Impl::Impl	(	const GeomFields &	geomFields,
		FractureFields &	fractureFields,
		const MeshList &	meshes
	)

inline

Definition at line 43 of file FractureModel_impl.h.

References Model::_meshes, FractureBC< T >::bcType, Mesh::getBoundaryFaceGroups(), Mesh::getID(), FaceGroup::groupType, FaceGroup::id, and FractureVC< T >::vcType.

                                :
     _meshes(meshes),
     _geomFields(geomFields),
     _fractureFields(fractureFields),
     _phasefieldGradientModel(_meshes,_fractureFields.phasefieldvalue,
                               _fractureFields.phasefieldGradient,_geomFields),
     _initialNorm(),
     _niters(0)
   {
     const int numMeshes = _meshes.size();
     for (int n=0; n<numMeshes; n++)
     {
         const Mesh& mesh = *_meshes[n];
         FractureVC<T> *vc(new FractureVC<T>());
         vc->vcType = "flow";
        _vcMap[mesh.getID()] = vc;
         
         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
         {
             const FaceGroup& fg = *fgPtr;
             FractureBC<T> *bc(new FractureBC<T>());
             
             _bcMap[fg.id] = bc;
 
             if ((fg.groupType == "wall") ||
                 (fg.groupType == "symmetry"))
             {
                 bc->bcType = "SpecifiedPhaseFieldFlux";
             }
             else if ((fg.groupType == "velocity-inlet") ||
                      (fg.groupType == "pressure-outlet"))
             {
                 bc->bcType = "SpecifiedPhaseFieldValue";
             }
             else
               throw CException("FractureModel: unknown face group type "
                                + fg.groupType);
         }
     }
   }

Member Function Documentation

template<class T>

void FractureModel< T >::Impl::advance ( const int niter )

inline

Definition at line 387 of file FractureModel_impl.h.

References LinearSystem::initAssembly(), LinearSystem::initSolve(), LinearSystem::postSolve(), and LinearSystem::updateSolution().

   {
     for(int n=0; n<niter; n++)
     { 
         LinearSystem ls;
         initLinearization(ls);
         
         ls.initAssembly();
 
         linearize(ls);
 
         ls.initSolve();
 
         MFRPtr rNorm(_options.getLinearSolver().solve(ls));
 
         if (!_initialNorm) _initialNorm = rNorm;
         
         MFRPtr normRatio((*rNorm)/(*_initialNorm));
 
         cout << _niters << ": " << *rNorm << endl;
 
         
         _options.getLinearSolver().cleanup();
 
         ls.postSolve();
         ls.updateSolution();
 
         _niters++;
         if (*rNorm < _options.absoluteTolerance ||
             *normRatio < _options.relativeTolerance)
           break;
     }
   }

template<class T>

FractureBC<T>& FractureModel< T >::Impl::getBC ( const int id )

inline

Definition at line 186 of file FractureModel_impl.h.

186 {return *_bcMap[id];}

FractureModel::Impl::_bcMap

FractureBCMap _bcMap

Definition: FractureModel_impl.h:584

template<class T>

FractureBCMap& FractureModel< T >::Impl::getBCMap ( )

inline

Definition at line 183 of file FractureModel_impl.h.

183 {return _bcMap;}

FractureModel::Impl::_bcMap

FractureBCMap _bcMap

Definition: FractureModel_impl.h:584

template<class T>

FractureModelOptions<T>& FractureModel< T >::Impl::getOptions ( )

inline

Definition at line 188 of file FractureModel_impl.h.

188 {return _options;}

FractureModel::Impl::_options

FractureModelOptions< T > _options

Definition: FractureModel_impl.h:586

template<class T>

FractureVCMap& FractureModel< T >::Impl::getVCMap ( )

inline

Definition at line 184 of file FractureModel_impl.h.

184 {return _vcMap;}

FractureModel::Impl::_vcMap

FractureVCMap _vcMap

Definition: FractureModel_impl.h:585

template<class T>

void FractureModel< T >::Impl::init ( )

inline

Definition at line 86 of file FractureModel_impl.h.

References Model::_meshes, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), StorageSite::getCountLevel1(), Mesh::getID(), Mesh::getInterfaceGroups(), and FaceGroup::site.

   {
     const int numMeshes = _meshes.size();
     for (int n=0; n<numMeshes; n++)
     {
         const Mesh& mesh = *_meshes[n];
 
         const StorageSite& cells = mesh.getCells();
         const FractureVC<T>& vc = *_vcMap[mesh.getID()];
 
         //phasefieldvalue
         shared_ptr<TArray> tCell(new TArray(cells.getCountLevel1()));
         *tCell = _options["initialPhaseFieldValue"];
         _fractureFields.phasefieldvalue.addArray(cells,tCell);
         
         if(_options.transient)
           {
             _fractureFields.phasefieldvalueN1.addArray(cells, dynamic_pointer_cast<ArrayBase>(tCell->newCopy()));
             if (_options.timeDiscretizationOrder > 1)
               _fractureFields.phasefieldvalueN2.addArray(cells, dynamic_pointer_cast<ArrayBase>(tCell->newCopy()));
           }
 
         //conductivity
         shared_ptr<TArray> condCell(new TArray(cells.getCountLevel1()));
         *condCell = vc["fractureConductivity"];
         _fractureFields.conductivity.addArray(cells,condCell);
         
         //source 
         shared_ptr<TArray> sCell(new TArray(cells.getCountLevel1()));
         *sCell = vc["fractureSource"];
         //*sCell =T(0.0);
         _fractureFields.source.addArray(cells,sCell);
 
         //source coef
         shared_ptr<TArray> scoefCell(new TArray(cells.getCountLevel1()));
         *scoefCell = vc["fractureSourceCoef"];
         //*scoefCell=T(0.0);
         _fractureFields.sourcecoef.addArray(cells,scoefCell);
 
         //create a zero field
         shared_ptr<TArray> zeroCell(new TArray(cells.getCountLevel1()));
         *zeroCell = T(0.0);
         _fractureFields.zero.addArray(cells,zeroCell);
 
         //create a one field
         shared_ptr<TArray> oneCell(new TArray(cells.getCountLevel1()));
         *oneCell = T(1.0);
         _fractureFields.one.addArray(cells,oneCell);
 
         //create specific heat field   rho*Cp
         //shared_ptr<TArray> cp(new TArray(cells.getCount()));
         //*cp = vc["density"] * vc["specificHeat"];
         //_thermalFields.specificHeat.addArray(cells, cp);
 
         //initial phasefieldvalue gradient array
         shared_ptr<TGradArray> gradT(new TGradArray(cells.getCountLevel1()));
         gradT->zero();
         _fractureFields.phasefieldGradient.addArray(cells,gradT);
         
         //inital convection flux at faces
         
         //const StorageSite& allFaces = mesh.getFaces();
         //shared_ptr<TArray> convFlux(new TArray(allFaces.getCount()));
         //convFlux->zero();
         //_thermalFields.convectionFlux.addArray(allFaces,convFlux);
 
         //phasefield flux at faces
         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
         {
             const FaceGroup& fg = *fgPtr;
             const StorageSite& faces = fg.site;
           
             shared_ptr<TArray> fluxFace(new TArray(faces.getCount()));
 
             fluxFace->zero();
             _fractureFields.phasefieldFlux.addArray(faces,fluxFace);
           
         }
         foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
         {
             const FaceGroup& fg = *fgPtr;
             const StorageSite& faces = fg.site;
           
             shared_ptr<TArray> fluxFace(new TArray(faces.getCount()));
 
             fluxFace->zero();
             _fractureFields.phasefieldFlux.addArray(faces,fluxFace);
           
         }
         
         
     }
     _fractureFields.conductivity.syncLocal();
     _niters  =0;
     _initialNorm = MFRPtr();
   }

template<class T>

void FractureModel< T >::Impl::initLinearization ( LinearSystem & ls )

inline

Definition at line 190 of file FractureModel_impl.h.

References Model::_meshes, MultiField::addArray(), MultiFieldMatrix::addMatrix(), Mesh::getBoundaryFaceGroups(), Mesh::getCellCells(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaceCells(), Mesh::getInterfaceGroups(), LinearSystem::getMatrix(), LinearSystem::getX(), and FaceGroup::site.

   {
     const int numMeshes = _meshes.size();
     for (int n=0; n<numMeshes; n++)
     {
         const Mesh& mesh = *_meshes[n];
 
         const StorageSite& cells = mesh.getCells();
         MultiField::ArrayIndex tIndex(&_fractureFields.phasefieldvalue,&cells);
 
         ls.getX().addArray(tIndex,_fractureFields.phasefieldvalue.getArrayPtr(cells));
 
         const CRConnectivity& cellCells = mesh.getCellCells();
 
         shared_ptr<Matrix> m(new CRMatrix<T,T,T>(cellCells));
 
         ls.getMatrix().addMatrix(tIndex,tIndex,m);
 
         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
         {
             const FaceGroup& fg = *fgPtr;
             const StorageSite& faces = fg.site;
 
             MultiField::ArrayIndex fIndex(&_fractureFields.phasefieldFlux,&faces);
             ls.getX().addArray(fIndex,_fractureFields.phasefieldFlux.getArrayPtr(faces));
 
             const CRConnectivity& faceCells = mesh.getFaceCells(faces);
 
             shared_ptr<Matrix> mft(new FluxJacobianMatrix<T,T>(faceCells));
             ls.getMatrix().addMatrix(fIndex,tIndex,mft);
 
             shared_ptr<Matrix> mff(new DiagonalMatrix<T,T>(faces.getCount()));
             ls.getMatrix().addMatrix(fIndex,fIndex,mff);
         }
 
         foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
         {
             const FaceGroup& fg = *fgPtr;
             const StorageSite& faces = fg.site;
 
             MultiField::ArrayIndex fIndex(&_fractureFields.phasefieldFlux,&faces);
             ls.getX().addArray(fIndex,_fractureFields.phasefieldFlux.getArrayPtr(faces));
 
             const CRConnectivity& faceCells = mesh.getFaceCells(faces);
 
             shared_ptr<Matrix> mft(new FluxJacobianMatrix<T,T>(faceCells));
             ls.getMatrix().addMatrix(fIndex,tIndex,mft);
 
             shared_ptr<Matrix> mff(new DiagonalMatrix<T,T>(faces.getCount()));
             ls.getMatrix().addMatrix(fIndex,fIndex,mff);
         }
 
     }
   }

template<class T>

void FractureModel< T >::Impl::linearize ( LinearSystem & ls )

inline

Definition at line 245 of file FractureModel_impl.h.

References Model::_meshes, BaseGenericBCS< X, Diag, OffDiag >::applyInterfaceBC(), FractureBC< T >::bcType, LinearSystem::getB(), Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), Mesh::getInterfaceGroups(), LinearSystem::getMatrix(), FloatVarDict< T >::getVal(), LinearSystem::getX(), FaceGroup::id, Linearizer::linearize(), and FaceGroup::site.

   {
     _phasefieldGradientModel.compute();
     
     DiscrList discretizations;
 
     shared_ptr<Discretization>
       dd(new DiffusionDiscretization<T,T,T>
          (_meshes,_geomFields,
           _fractureFields.phasefieldvalue,
           _fractureFields.conductivity,
           _fractureFields.phasefieldGradient));
     discretizations.push_back(dd);
  
     //shared_ptr<Discretization>
     //  cd(new ConvectionDiscretization<T,T,T>
         //(_meshes,_geomFields,
         //  _fractureFields.phasefieldvalue,
         //  _fractureFields.phasefieldFlux,
         //  _fractureFields.zero,
         //  _fractureFields.phasefieldGradient,
     //      _options.useCentralDifference));
     //discretizations.push_back(cd);
     
     shared_ptr<Discretization>
       scfd(new SourceDiscretizationforFracture<T, T, T>
          (_meshes, 
           _geomFields, 
           _fractureFields.phasefieldvalue,
           _fractureFields.source,
           _fractureFields.sourcecoef));
     discretizations.push_back(scfd);
     
     if (_options.transient)
       {
         shared_ptr<Discretization>
           td(new TimeDerivativeDiscretization<T, T, T>
              (_meshes, _geomFields, 
               _fractureFields.phasefieldvalue, 
               _fractureFields.phasefieldvalueN1,
               _fractureFields.phasefieldvalueN2,
               _fractureFields.one,
               _options["timeStep"]));
         discretizations.push_back(td);
       }
     
     //shared_ptr<Discretization>
     //  ibm(new GenericIBDiscretization<T,T,T>
         //  (_meshes,_geomFields,_thermalFields.temperature));
     //discretizations.push_back(ibm);
     
 
     Linearizer linearizer;
 
     linearizer.linearize(discretizations,_meshes,ls.getMatrix(),
                          ls.getX(), ls.getB());
 
     const int numMeshes = _meshes.size();
     for (int n=0; n<numMeshes; n++)
     {
         const Mesh& mesh = *_meshes[n];
 
         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
         {
             const FaceGroup& fg = *fgPtr;
             const StorageSite& faces = fg.site;
 
             const FractureBC<T>& bc = *_bcMap[fg.id];
             
 
             GenericBCS<T,T,T> gbc(faces,mesh,
                                   _geomFields,
                                   _fractureFields.phasefieldvalue,
                                   _fractureFields.phasefieldFlux,
                                   ls.getMatrix(), ls.getX(), ls.getB());
 
             if (bc.bcType == "SpecifiedPhaseFieldValue")
             {
                 FloatValEvaluator<T>
                   bT(bc.getVal("specifiedPhaseFieldValue"),faces);
                 gbc.applyDirichletBC(bT);
             }
             else if (bc.bcType == "SpecifiedPhaseFieldFlux")
             {
                 FloatValEvaluator<T>
                     bPhaseFieldFlux(bc.getVal("specifiedPhaseFieldFlux"),faces);
                     
                 const int nFaces = faces.getCount();
                                 
                 for(int f=0; f<nFaces; f++)
                     {                        
                         gbc.applyNeumannBC(f, bPhaseFieldFlux[f]);
                     }                              
             }
             else if (bc.bcType == "Symmetry")
             {
                  T zeroFlux(NumTypeTraits<T>::getZero());
                  gbc.applyNeumannBC(zeroFlux);
             }
             else
               throw CException(bc.bcType + " not implemented for FractureModel");
         }
 
         foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
         {
             const FaceGroup& fg = *fgPtr;
             const StorageSite& faces = fg.site;
             GenericBCS<T,T,T> gbc(faces,mesh,
                                   _geomFields,
                                   _fractureFields.phasefieldvalue,
                                   _fractureFields.phasefieldFlux,
                                   ls.getMatrix(), ls.getX(), ls.getB());
 
             gbc.applyInterfaceBC();
         }
     }
   }

template<class T>

void FractureModel< T >::Impl::printBCs ( )

inline

Definition at line 421 of file FractureModel_impl.h.

   {
     foreach(typename FractureBCMap::value_type& pos, _bcMap)
     {
         cout << "Face Group " << pos.first << ":" << endl;
         cout << "    bc type " << pos.second->bcType << endl;
         foreach(typename FractureBC<T>::value_type& vp, *pos.second)
         {
             cout << "   " << vp.first << " "  << vp.second.constant <<  endl;
         }
     }
   }

template<class T>

void FractureModel< T >::Impl::updateTime ( )

inline

Definition at line 435 of file FractureModel_impl.h.

References Model::_meshes, Mesh::getCells(), and StorageSite::getCountLevel1().

   {
     const int numMeshes = _meshes.size();
     for (int n=0; n<numMeshes; n++)    {
      
       const Mesh& mesh = *_meshes[n];
       const StorageSite& cells = mesh.getCells();
       const int nCells = cells.getCountLevel1();
         
       TArray& phasefieldvalue =
           dynamic_cast<TArray&>(_fractureFields.phasefieldvalue[cells]);
       TArray& phasefieldvalueN1 =
           dynamic_cast<TArray&>(_fractureFields.phasefieldvalueN1[cells]);
      
       if (_options.timeDiscretizationOrder > 1)
         {
           TArray& phasefieldvalueN2 =
             dynamic_cast<TArray&>(_fractureFields.phasefieldvalueN2[cells]);
           phasefieldvalueN2 = phasefieldvalueN1;
         }
       phasefieldvalueN1 = phasefieldvalue;
     }
   }

Member Data Documentation

template<class T>

FractureBCMap FractureModel< T >::Impl::_bcMap

private

Definition at line 584 of file FractureModel_impl.h.

template<class T>

FractureFields& FractureModel< T >::Impl::_fractureFields

private

Definition at line 582 of file FractureModel_impl.h.

template<class T>

const GeomFields& FractureModel< T >::Impl::_geomFields

private

Definition at line 581 of file FractureModel_impl.h.

template<class T>

MFRPtr FractureModel< T >::Impl::_initialNorm

private

Definition at line 589 of file FractureModel_impl.h.

template<class T>

const MeshList FractureModel< T >::Impl::_meshes

private

Definition at line 580 of file FractureModel_impl.h.

template<class T>

int FractureModel< T >::Impl::_niters

private

Definition at line 590 of file FractureModel_impl.h.

template<class T>

FractureModelOptions<T> FractureModel< T >::Impl::_options

private

Definition at line 586 of file FractureModel_impl.h.

template<class T>

GradientModel<T> FractureModel< T >::Impl::_phasefieldGradientModel

private

Definition at line 587 of file FractureModel_impl.h.

template<class T>

FractureVCMap FractureModel< T >::Impl::_vcMap

private

Definition at line 585 of file FractureModel_impl.h.

The documentation for this class was generated from the following file:

FractureModel_impl.h

Public Types

Public Member Functions

Private Attributes

Detailed Description

template<class T> class FractureModel< T >::Impl

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class T>
class FractureModel< T >::Impl