KeModel< T >::Impl Class Reference

#include <KeModel_impl.h>

Collaboration diagram for KeModel< T >::Impl:

Public Types
typedef Array< T >	TArray
typedef Vector< T, 3 >	VectorT3
typedef Array< VectorT3 >	VectorT3Array
typedef Gradient< VectorT3 >	VGradType
typedef Array< Gradient < VectorT3 > >	VGradArray
typedef Gradient< T >	EGradType
typedef Array< EGradType >	EGradArray
typedef Gradient< T >	DGradType
typedef Array< DGradType >	DGradArray
typedef CRMatrix< T, T, T >	T_Matrix

Public Member Functions
	Impl (const GeomFields &geomFields, KeFields &keFields, FlowFields &flowFields, const MeshList &meshes)
void	init ()
KeBCMap &	getBCMap ()
KeVCMap &	getVCMap ()
KeBC< T > &	getBC (const int id)
KeModelOptions< T > &	getOptions ()
void	updateTimek ()
void	updateTimee ()
void	initLinearizationk (LinearSystem &lsk)
void	linearizeenergy (LinearSystem &lsk)
void	initLinearization (LinearSystem &lse)
void	linearizedissipation (LinearSystem &lse)
void	getViscosity (const Mesh &mesh)
void	advance (const int niter)
void	printBCs ()

Private Attributes
const MeshList	_meshes
const GeomFields &	_geomFields
KeFields &	_keFields
FlowFields &	_flowFields
KeBCMap	_bcMap
KeVCMap	_vcMap
KeModelOptions< T >	_options
GradientModel< T >	_energyGradientModel
GradientModel< T >	_dissipationGradientModel
MFRPtr	_initialNormk
MFRPtr	_initialNorm
int	_niters

Detailed Description

template<class T>
class KeModel< T >::Impl

Definition at line 34 of file KeModel_impl.h.

Member Typedef Documentation

template<class T>

typedef Array<DGradType> KeModel< T >::Impl::DGradArray

Definition at line 45 of file KeModel_impl.h.

template<class T>

typedef Gradient<T> KeModel< T >::Impl::DGradType

Definition at line 44 of file KeModel_impl.h.

template<class T>

typedef Array<EGradType> KeModel< T >::Impl::EGradArray

Definition at line 43 of file KeModel_impl.h.

template<class T>

typedef Gradient<T> KeModel< T >::Impl::EGradType

Definition at line 42 of file KeModel_impl.h.

template<class T>

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

Definition at line 46 of file KeModel_impl.h.

template<class T>

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

Definition at line 37 of file KeModel_impl.h.

template<class T>

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

Definition at line 38 of file KeModel_impl.h.

template<class T>

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

Definition at line 39 of file KeModel_impl.h.

template<class T>

typedef Array<Gradient<VectorT3> > KeModel< T >::Impl::VGradArray

Definition at line 41 of file KeModel_impl.h.

template<class T>

typedef Gradient<VectorT3> KeModel< T >::Impl::VGradType

Definition at line 40 of file KeModel_impl.h.

Constructor & Destructor Documentation

template<class T>

KeModel< T >::Impl::Impl ( const GeomFields &  geomFields, KeFields &  keFields, FlowFields &  flowFields, const MeshList &  meshes  )

inline

Definition at line 48 of file KeModel_impl.h.

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

                               :
    _meshes(meshes),
    _geomFields(geomFields),
    _keFields(keFields),
    _flowFields(flowFields),
   // _velocityGradientModel(_meshes,_flowFields.velocity,
     //                      _flowFields.velocityGradient,_geomFields),
    _energyGradientModel(_meshes,_keFields.energy,
                         _keFields.energyGradient,_geomFields),
    _dissipationGradientModel(_meshes,_keFields.dissipation,
                              _keFields.dissipationGradient,_geomFields),
    _initialNormk(),
    _initialNorm(),
    _niters(0)
  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
  /*      
        FlowVC<T> *vc1(new FlowVC<T>());
        vc1->vcType = "flow";
        _vcMap[mesh.getID()] = vc1;
*/
        KeVC<T> *vc(new KeVC<T>());
        vc->vcType = "flow";
        _vcMap[mesh.getID()] = vc;
        
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          {
            const FaceGroup& fg = *fgPtr;
            KeBC<T> *bc(new KeBC<T>());
            
            _bcMap[fg.id] = bc;
            
            if ((fg.groupType == "symmetry"))
              {
                bc->bcType = "Symmetry";
              }

            else if ((fg.groupType == "velocity-inlet"))
            {
              bc->bcType = "Specifiedkandepsilon";
            }
             else if ((fg.groupType == "wall"))
             {
               bc->bcType = "Wall";
             }

             else if ((fg.groupType == "pressure-inlet") ||
                      (fg.groupType == "pressure-outlet"))
              {
                bc->bcType = "PressureBoundary";
              }

            else
              throw CException("KeModel: unknown face group type "
                               + fg.groupType);             
            
          }
      }
  }

Member Function Documentation

template<class T>

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

inline

Definition at line 875 of file KeModel_impl.h.

References Model::_meshes, KeModel< T >::getViscosity(), LinearSystem::initAssembly(), LinearSystem::initSolve(), LinearSystem::postSolve(), and LinearSystem::updateSolution().

  {
    for(int n=0; n<niter; n++)
    { 
 
     {
        LinearSystem lsk;
        initLinearizationk(lsk);
        
        lsk.initAssembly();

        linearizeenergy(lsk);
  
        lsk.initSolve();

        MFRPtr rNorm(_options.getLinearSolver().solve(lsk));
     
        
        if (!_initialNormk) _initialNormk = rNorm;
        
        MFRPtr normRatio((*rNorm)/(*_initialNormk));
     
      if (_options.printNormalizedResiduals)
          cout << _niters << ": " << *normRatio  <<  endl;
      else
        cout << _niters << ": " << *rNorm << endl;

        
        _options.getLinearSolver().cleanup();

        lsk.postSolve();
        lsk.updateSolution();


        _niters++;

        if (*rNorm < _options.absoluteTolerance ||
            *normRatio < _options.relativeTolerance)
          break;
      }

      { 
        LinearSystem lse;
        initLinearization(lse);

        lse.initAssembly();

        linearizedissipation(lse);

        lse.initSolve();

        MFRPtr rNorm(_options.getLinearSolver().solve(lse));

        if (!_initialNorm) _initialNorm = rNorm;

        MFRPtr normRatio((*rNorm)/(*_initialNorm));

        cout << _niters << ": " << *rNorm << endl;


        _options.getLinearSolver().cleanup();

        lse.postSolve();
        lse.updateSolution();

        _niters++;
        if (*rNorm < _options.absoluteTolerance ||
            *normRatio < _options.relativeTolerance)
          break;
    }

    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
    {
        const Mesh& mesh = *_meshes[n];

        getViscosity(mesh);
    }

    }

  }

template<class T>

KeBC<T>& KeModel< T >::Impl::getBC ( const int  id )

inline

Definition at line 276 of file KeModel_impl.h.

{return *_bcMap[id];}

template<class T>

KeBCMap& KeModel< T >::Impl::getBCMap ( )

inline

Definition at line 273 of file KeModel_impl.h.

{return _bcMap;}

template<class T>

KeModelOptions<T>& KeModel< T >::Impl::getOptions ( )

inline

Definition at line 278 of file KeModel_impl.h.

{return _options;}

template<class T>

KeVCMap& KeModel< T >::Impl::getVCMap ( )

inline

Definition at line 274 of file KeModel_impl.h.

{return _vcMap;}

template<class T>

void KeModel< T >::Impl::getViscosity ( const Mesh &  mesh )

inline

Definition at line 824 of file KeModel_impl.h.

References Mesh::getCells(), and StorageSite::getCount().

  {
    const StorageSite& cells = mesh.getCells();

//turbulent viscosity
     TArray& muCell =
      dynamic_cast<TArray&>(_flowFields.eddyviscosity[cells]);

//laminar viscosity
     TArray& lmuCell =
      dynamic_cast<TArray&>(_flowFields.viscosity[cells]);

//total viscosity
     TArray& tmuCell =
      dynamic_cast<TArray&>(_flowFields.totalviscosity[cells]);

    const TArray & rhoCell =
      dynamic_cast<const TArray&>(_flowFields.density[cells]);

    const TArray& eCell =
      dynamic_cast<const TArray&>(_keFields.dissipation[cells]);

    const TArray& kCell =
      dynamic_cast<const TArray&>(_keFields.energy[cells]);

    TArray& c1Cell =
     dynamic_cast<TArray&>(_keFields.c1[cells]);

    TArray& c2Cell =
      dynamic_cast<TArray&>(_keFields.c2[cells]);



    const int nCells = cells.getCount();
    T two(2.0);
    T cmu = _options.cmu;
    T sigmak = _options.sigmak;
    T sigmae = _options.sigmae;
    for(int c=0; c<nCells; c++)
    {
        //cout << "c2" << c2Cell[c] << endl;
        muCell[c] = (cmu*pow(kCell[c],two)*rhoCell[c])/eCell[c];
        c1Cell[c] = muCell[c]/sigmak;
        c2Cell[c] = muCell[c]/sigmae;
        tmuCell[c] = muCell[c] + lmuCell[c];

    }

  }

template<class T>

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

inline

Definition at line 114 of file KeModel_impl.h.

References Model::_meshes, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), 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 FlowVC<T>&vc1 = *_vcMap[mesh.getID()];
        const KeVC<T>&vc = *_vcMap[mesh.getID()];

        const StorageSite& cells = mesh.getCells();
        //energy(k)

        shared_ptr<TArray> kCell(new TArray(cells.getCount()));
        *kCell = vc["InitialEnergy"];
        _keFields.energy.addArray(cells,kCell);

        //dissipation(e)
        shared_ptr<TArray> eCell(new TArray(cells.getCount()));
        *eCell = vc["InitialDissipation"];
        _keFields.dissipation.addArray(cells,eCell);


        shared_ptr<TArray> sourcekCell(new TArray(cells.getCount()));
        *sourcekCell = T(1.0);
        _keFields.sourcek.addArray(cells,sourcekCell);

        shared_ptr<TArray> sourcedCell(new TArray(cells.getCount()));
        *sourcedCell = T(1.0);
        _keFields.sourced.addArray(cells,sourcedCell);

        shared_ptr<TArray> sourcecCell(new TArray(cells.getCount()));
        *sourcecCell = T(1.0);
        _keFields.sourcec.addArray(cells,sourcecCell);

        shared_ptr<TArray> sourcepCell(new TArray(cells.getCount()));
        *sourcepCell = T(1.0);
        _keFields.sourcep.addArray(cells,sourcepCell);


      if (_options.transient)
       {
            _keFields.dissipationN1.addArray(cells,
                                            dynamic_pointer_cast<ArrayBase>(eCell->newCopy()));
            if (_options.timeDiscretizationOrder > 1)
              _keFields.dissipationN2.addArray(cells,
                                              dynamic_pointer_cast<ArrayBase>(eCell->newCopy()));

       }


/*      
        //initial velocity gradient array
        shared_ptr<VGradArray> gradV(new VGradArray(cells.getCount()));
        gradV->zero();
        _flowFields.velocityGradient.addArray(cells,gradV);
  */      
         //initial energy gradient array
        shared_ptr<EGradArray> gradE(new EGradArray(cells.getCount()));
        gradE->zero();
        _keFields.energyGradient.addArray(cells,gradE);

         //initial dissipation gradient array
        shared_ptr<DGradArray> gradD(new DGradArray(cells.getCount()));
        gradD->zero();
        _keFields.dissipationGradient.addArray(cells,gradD);
       
       // density field
        shared_ptr<TArray> densityCell(new TArray(cells.getCount()));
        *densityCell = T(1.225);
        //*densityCell = vc1["density"];
        _flowFields.density.addArray(cells,densityCell);
 
        //c1
        shared_ptr<TArray> c1Cell(new TArray(cells.getCount()));
        *c1Cell = vc["c1"];
        _keFields.c1.addArray(cells,c1Cell);

        //c2
        shared_ptr<TArray> c2Cell(new TArray(cells.getCount()));
        *c2Cell = vc["c2"];
        _keFields.c2.addArray(cells,c2Cell);

        //kflux 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();
            _keFields.kFlux.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();
            _keFields.kFlux.addArray(faces,fluxFace);

        }
    
        //eflux 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();
            _keFields.eFlux.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();
            _keFields.eFlux.addArray(faces,fluxFace);

        }
 

       //laminar viscosity
        shared_ptr<TArray> lmuCell(new TArray(cells.getCount()));
        *lmuCell = T(1.7894e-5);
       // *lmuCell = vc["viscosity"];
        _flowFields.viscosity.addArray(cells,lmuCell);

       //turbulent viscosity
        shared_ptr<TArray> muCell(new TArray(cells.getCount()));
       *muCell = T(1e-05); 
       //*muCell = vc["eddyviscosity"];
        _flowFields.eddyviscosity.addArray(cells,muCell);


        //total viscosity
        shared_ptr<TArray> tmuCell(new TArray(cells.getCount()));
        *tmuCell = T(1e-03);
        // *tmuCell = vc["totalviscosity"];
        _flowFields.totalviscosity.addArray(cells,tmuCell);

    }
    //_keFields.energy.synclocal();
   // _keFields.dissipation.synclocal(); 
    _niters  =0;
    _initialNormk = MFRPtr();
    _initialNorm = MFRPtr();

  }

template<class T>

void KeModel< T >::Impl::initLinearization ( LinearSystem &  lse )

inline

Definition at line 560 of file KeModel_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 eIndex(&_keFields.dissipation,&cells);

        lse.getX().addArray(eIndex,_keFields.dissipation.getArrayPtr(cells));

        const CRConnectivity& cellCells = mesh.getCellCells();

        shared_ptr<Matrix> m(new CRMatrix<T,T,T>(cellCells));

        lse.getMatrix().addMatrix(eIndex,eIndex,m);

        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;

            MultiField::ArrayIndex fIndex(&_keFields.eFlux,&faces);
            lse.getX().addArray(fIndex,_keFields.eFlux.getArrayPtr(faces));

            const CRConnectivity& faceCells = mesh.getFaceCells(faces);

            shared_ptr<Matrix> mft(new FluxJacobianMatrix<T,T>(faceCells));
            lse.getMatrix().addMatrix(fIndex,eIndex,mft);

            shared_ptr<Matrix> mff(new DiagonalMatrix<T,T>(faces.getCount()));
            lse.getMatrix().addMatrix(fIndex,fIndex,mff);
        }
         foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;

            MultiField::ArrayIndex fIndex(&_keFields.eFlux,&faces);
            lse.getX().addArray(fIndex,_keFields.eFlux.getArrayPtr(faces));

            const CRConnectivity& faceCells = mesh.getFaceCells(faces);

            shared_ptr<Matrix> mft(new FluxJacobianMatrix<T,T>(faceCells));
            lse.getMatrix().addMatrix(fIndex,eIndex,mft);

            shared_ptr<Matrix> mff(new DiagonalMatrix<T,T>(faces.getCount()));
            lse.getMatrix().addMatrix(fIndex,fIndex,mff);
        }

    }
  }

template<class T>

void KeModel< T >::Impl::initLinearizationk ( LinearSystem &  lsk )

inline

Definition at line 333 of file KeModel_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 kIndex(&_keFields.energy,&cells);

        lsk.getX().addArray(kIndex,_keFields.energy.getArrayPtr(cells));

        const CRConnectivity& cellCells = mesh.getCellCells();

        shared_ptr<Matrix> m(new CRMatrix<T,T,T>(cellCells));

        lsk.getMatrix().addMatrix(kIndex,kIndex,m);

        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;

            MultiField::ArrayIndex fIndex(&_keFields.kFlux,&faces);
            lsk.getX().addArray(fIndex,_keFields.kFlux.getArrayPtr(faces));

            const CRConnectivity& faceCells = mesh.getFaceCells(faces);

            shared_ptr<Matrix> mft(new FluxJacobianMatrix<T,T>(faceCells));
            lsk.getMatrix().addMatrix(fIndex,kIndex,mft);

            shared_ptr<Matrix> mff(new DiagonalMatrix<T,T>(faces.getCount()));
            lsk.getMatrix().addMatrix(fIndex,fIndex,mff);
        }

        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;

            MultiField::ArrayIndex fIndex(&_keFields.kFlux,&faces);
            lsk.getX().addArray(fIndex,_keFields.kFlux.getArrayPtr(faces));

            const CRConnectivity& faceCells = mesh.getFaceCells(faces);

            shared_ptr<Matrix> mft(new FluxJacobianMatrix<T,T>(faceCells));
            lsk.getMatrix().addMatrix(fIndex,kIndex,mft);

            shared_ptr<Matrix> mff(new DiagonalMatrix<T,T>(faces.getCount()));
            lsk.getMatrix().addMatrix(fIndex,fIndex,mff);
        }

    }
  }

template<class T>

void KeModel< T >::Impl::linearizedissipation ( LinearSystem &  lse )

inline

Definition at line 615 of file KeModel_impl.h.

References Model::_meshes, BaseGenericBCS< X, Diag, OffDiag >::applyInterfaceBC(), KeBC< T >::bcType, LinearSystem::getB(), Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaceCells(), Mesh::getInterfaceGroups(), LinearSystem::getMatrix(), MultiFieldMatrix::getMatrix(), FloatVarDict< T >::getVal(), LinearSystem::getX(), FaceGroup::id, Linearizer::linearize(), CRMatrix< T_Diag, T_OffDiag, X >::setDirichlet(), and FaceGroup::site.

  {
    //_velocityGradientModel.compute();
    _dissipationGradientModel.compute();

    DiscrList discretizations1;
 if (_options.transient)
    {

    shared_ptr<Discretization>
      td(new TimeDerivativeDiscretization<T,T,T>
        (_meshes,_geomFields,
         _keFields.dissipation,
         _keFields.dissipationN1,
         _keFields.dissipationN2,
         _flowFields.density,
         _options["timeStep"]));
    discretizations1.push_back(td);
    
}
    shared_ptr<Discretization>
      dd(new DiffusionDiscretization<T,T,T>
         (_meshes,_geomFields,
          _keFields.dissipation,
          _keFields.c2,
          _keFields.dissipationGradient));
    discretizations1.push_back(dd);

    shared_ptr<Discretization>
      cd(new ConvectionDiscretization<T,T,T>
         (_meshes,_geomFields,
          _keFields.dissipation,
          _flowFields.massFlux,
          _flowFields.continuityResidual,
          _keFields.dissipationGradient,
          _options.useCentralDifference));
    discretizations1.push_back(cd);


    shared_ptr<Discretization>
      sd(new SourceDiscretizationdissi<T,T,T>
         (_meshes,
          _geomFields,
          _keFields.dissipation,
          _flowFields.velocity,
          _flowFields.eddyviscosity,
          _keFields.energy,
          _flowFields.density,
          _keFields.sourced,
          _keFields.sourcec,
          _keFields.sourcep,
          _flowFields.velocityGradient));
    discretizations1.push_back(sd);

    shared_ptr<Discretization>
      dis(new GenericIBDiscretization<T,T,T>
          (_meshes,_geomFields,_keFields.dissipation));

    discretizations1.push_back(dis);

    Linearizer linearizer;
    linearizer.linearize(discretizations1,_meshes,lse.getMatrix(),
                         lse.getX(), lse.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 int nFaces = faces.getCount();

            const KeBC<T>& bc = *_bcMap[fg.id];


            GenericBCS<T,T,T> gbc(faces,mesh,
                                  _geomFields,
                                  _keFields.dissipation,
                                  _keFields.eFlux,
                                  lse.getMatrix(), lse.getX(), lse.getB());

            FloatValEvaluator<T>
              be(bc.getVal("specifiede"),faces);

          const StorageSite& cells = mesh.getCells();
          const CRConnectivity& faceCells = mesh.getFaceCells(faces);
          MultiFieldMatrix& MFMatrix = lse.getMatrix();
          MultiField::ArrayIndex beIndex(&_keFields.dissipation,&cells);
          MultiField& b = lse.getB();
          TArray& rCell = dynamic_cast<TArray&>(b[beIndex]);
          T_Matrix& matrix = dynamic_cast<T_Matrix&>(MFMatrix.getMatrix(beIndex,beIndex));

          const TArray& faceAreaMag =dynamic_cast<const TArray &>(_geomFields.areaMag[faces]);

          const VectorT3Array& faceArea=dynamic_cast<const VectorT3Array&>(_geomFields.area[faces]);

          //const TArray& cellVolume = dynamic_cast<const TArray&>(_geomFields.volume[cells]);

          const VectorT3Array& faceCentroid =dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[faces]);

          const VectorT3Array& cellCentroid = dynamic_cast<const VectorT3Array&>(_geomFields.coordinate[cells]);

          TArray& kCell = dynamic_cast< TArray&>(_keFields.energy[cells]);
          TArray& eCell = dynamic_cast<TArray&>(_keFields.dissipation[cells]);
          T cmu = _options.cmu;
          T vonk = _options.vk;
 
          TArray& massFlux = dynamic_cast<TArray&>(_flowFields.massFlux[faces]);
            const int nFaces = faces.getCount();

           // if (bc.bcType == "Specifiede")
            if (bc.bcType == "Specifiedkandepsilon")
            {
              for(int f=0; f<nFaces; f++)
               {
                if (massFlux[f] > 0.)
                   gbc.applyExtrapolationBC(f);
              
                else
                   gbc.applyDirichletBC(f,be[f]);
                 
               }
                                
           }

          else if((bc.bcType == "Wall"))
           {
            for ( int f=0; f<nFaces; f++)
             {
         
              const int c0 = faceCells(f,0); 
           // const int c1 = faceCells(f,1);
           // T vol0 = cellVolume[c0];
           // T vol1 = cellVolume[c1];
              VectorT3 ds;
              VectorT3 n = faceArea[f]/faceAreaMag[f];
        /*
              if (vol1==0)
              ds =faceCentroid[f] - cellCentroid[c0];
             else
               ds = cellCentroid[c1]-faceCentroid[f];
           
        */
             ds =faceCentroid[f] - cellCentroid[c0];
             const T yp = ds[0]*n[0] + ds[1]*n[1] + ds[2]*n[2];
             rCell[0] = T(0);
             eCell[c0] = (pow(kCell[c0],1.5)*pow(cmu,0.75))/(vonk*yp);
             matrix.setDirichlet(c0);


          }
 
        }
            else if ((bc.bcType == "PressureBoundary"))
            {
            for(int f=0; f<nFaces; f++)
                {
                    if (massFlux[f] > 0.)
                    {
                        gbc.applyExtrapolationBC(f);
                    }
                    else
                    {
                        gbc.applyDirichletBC(f,be[f]);
                    }
                }
              }

            else if ((bc.bcType == "Symmetry"))
            {
                   gbc.applySymmetryBC();
            }
            else
              throw CException(bc.bcType + " not implemented for KeModel");
        }

        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;
            GenericBCS<T,T,T> gbc(faces,mesh,
                                  _geomFields,
                                  _keFields.dissipation,
                                  _keFields.eFlux,
                                  lse.getMatrix(), lse.getX(), lse.getB());

            gbc.applyInterfaceBC();

 
       }
    }
      DiscrList discretizations3;
      shared_ptr<Discretization>
        ud1(new Underrelaxer<T,T,T>
         (_meshes,_keFields.dissipation,
          _options["dissipationURF"]));

    discretizations3.push_back(ud1);

    linearizer.linearize(discretizations3,_meshes,lse.getMatrix(),
                         lse.getX(), lse.getB());
 
}

template<class T>

void KeModel< T >::Impl::linearizeenergy ( LinearSystem &  lsk )

inline

Definition at line 388 of file KeModel_impl.h.

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

  {
    //_velocityGradientModel.compute();
    _energyGradientModel.compute();
    DiscrList discretizations;

    if (_options.transient)
    {

       shared_ptr<Discretization>
         td(new TimeDerivativeDiscretization<T,T,T>
           (_meshes,_geomFields,
            _keFields.energy,
            _keFields.energyN1,
            _keFields.energyN2,
            _flowFields.density,
            _options["timeStep"]));

       discretizations.push_back(td);
    }  
 
    shared_ptr<Discretization>
      dd(new DiffusionDiscretization<T,T,T>
         (_meshes,_geomFields,
          _keFields.energy,
          _keFields.c1,
          _keFields.energyGradient));
    discretizations.push_back(dd);
    
    shared_ptr<Discretization>
      cd(new ConvectionDiscretization<T,T,T>
         (_meshes,_geomFields,
          _keFields.energy,
          _flowFields.massFlux,
          _flowFields.continuityResidual,
          _keFields.energyGradient,
          _options.useCentralDifference));
    discretizations.push_back(cd);
    
  
    shared_ptr<Discretization>
      sd(new SourceDiscretizationene<T>
         (_meshes, 
          _geomFields,
          _keFields.energy, 
          _flowFields.velocity,
          _flowFields.eddyviscosity,
          _keFields.dissipation,
          _flowFields.density,
          _keFields.sourcek,
          _flowFields.velocityGradient));
    discretizations.push_back(sd);
   
    shared_ptr<Discretization>
      ene(new GenericIBDiscretization<T,T,T>
          (_meshes,_geomFields,_keFields.energy));
    
    discretizations.push_back(ene);
    
    Linearizer linearizer;
    
    linearizer.linearize(discretizations,_meshes,lsk.getMatrix(),
                         lsk.getX(), lsk.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 KeBC<T>& bc = *_bcMap[fg.id];

            GenericBCS<T,T,T> gbc(faces,mesh,
                                  _geomFields,
                                  _keFields.energy,
                                  _keFields.kFlux,
                                  lsk.getMatrix(), lsk.getX(), lsk.getB());

            FloatValEvaluator<T>
             bk(bc.getVal("Specifiedk"),faces);
            TArray& massFlux = dynamic_cast<TArray&>(_flowFields.massFlux[faces]);
            const int nFaces = faces.getCount();


            
          //  if (bc.bcType == "Specifiedk")
          if ( bc.bcType == "Specifiedkandepsilon")
              {
                for(int f=0; f<nFaces; f++)
                   {

                    //cout << "massflux" << massFlux[f] << endl;

                     if (massFlux[f] > 0.)
                       {
                         gbc.applyExtrapolationBC(f);
                       }
                      else
                        {
                          gbc.applyDirichletBC(f,bk[f]);
                        }
                     }
                
               }

           else if ((bc.bcType == "Wall"))
                 {
                   for(int f=0; f<nFaces; f++)
                     {

                       gbc.applyNeumannBC(f,0);
                     }
                 }
           else if ((bc.bcType == "PressureBoundary"))
            {
            for(int f=0; f<nFaces; f++)
                {

                    if (massFlux[f] > 0.)
                    {
                        gbc.applyExtrapolationBC(f);
                    }
                    else
                    {
                        gbc.applyDirichletBC(f,bk[f]);
                    }
                }
              }
 



           else if ((bc.bcType == "Symmetry"))
              {
     cout <<"nfaces" << nFaces << endl;

                 gbc.applySymmetryBC();
              }
            else
              throw CException(bc.bcType + " not implemented for KeModel");
          }

        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;
            GenericBCS<T,T,T> gbc(faces,mesh,
                                  _geomFields,
                                  _keFields.energy,
                                  _keFields.kFlux,
                                  lsk.getMatrix(), lsk.getX(), lsk.getB());

            gbc.applyInterfaceBC();

        }
      }
      DiscrList discretizations2;
      shared_ptr<Discretization>
        ud(new Underrelaxer<T,T,T>
         (_meshes,_keFields.energy,
          _options["energyURF"]));

    discretizations2.push_back(ud);

    linearizer.linearize(discretizations2,_meshes,lsk.getMatrix(),
                         lsk.getX(), lsk.getB());
 
  }

template<class T>

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

inline

Definition at line 958 of file KeModel_impl.h.

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

template<class T>

void KeModel< T >::Impl::updateTimee ( )

inline

Definition at line 307 of file KeModel_impl.h.

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

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
    {
        const Mesh& mesh = *_meshes[n];

        const StorageSite& cells = mesh.getCells();
        TArray& e =
          dynamic_cast<TArray&>(_keFields.dissipation[cells]);
        TArray& eN1 =
          dynamic_cast<TArray&>(_keFields.dissipationN1[cells]);

        if (_options.timeDiscretizationOrder > 1)
        {
            TArray& eN2 =
              dynamic_cast<TArray&>(_keFields.dissipationN2[cells]);
            eN2 = eN1;
        }
        eN1 = e;
    }
  }

template<class T>

void KeModel< T >::Impl::updateTimek ( )

inline

Definition at line 280 of file KeModel_impl.h.

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

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
    {
        const Mesh& mesh = *_meshes[n];

        const StorageSite& cells = mesh.getCells();
        TArray& k =
          dynamic_cast<TArray&>(_keFields.energy[cells]);
        TArray& kN1 =
          dynamic_cast<TArray&>(_keFields.energyN1[cells]);

        if (_options.timeDiscretizationOrder > 1)
        {
            TArray& kN2 =
              dynamic_cast<TArray&>(_keFields.energyN2[cells]);
            kN2 = kN1;
        }
        kN1 = k;

    }
  }

Member Data Documentation

template<class T>

KeBCMap KeModel< T >::Impl::_bcMap

private

Definition at line 977 of file KeModel_impl.h.

template<class T>

GradientModel<T> KeModel< T >::Impl::_dissipationGradientModel

private

Definition at line 983 of file KeModel_impl.h.

template<class T>

GradientModel<T> KeModel< T >::Impl::_energyGradientModel

private

Definition at line 982 of file KeModel_impl.h.

template<class T>

FlowFields& KeModel< T >::Impl::_flowFields

private

Definition at line 975 of file KeModel_impl.h.

template<class T>

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

private

Definition at line 973 of file KeModel_impl.h.

template<class T>

MFRPtr KeModel< T >::Impl::_initialNorm

private

Definition at line 985 of file KeModel_impl.h.

template<class T>

MFRPtr KeModel< T >::Impl::_initialNormk

private

Definition at line 984 of file KeModel_impl.h.

template<class T>

KeFields& KeModel< T >::Impl::_keFields

private

Definition at line 974 of file KeModel_impl.h.

template<class T>

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

private

Definition at line 972 of file KeModel_impl.h.

template<class T>

int KeModel< T >::Impl::_niters

private

Definition at line 986 of file KeModel_impl.h.

template<class T>

KeModelOptions<T> KeModel< T >::Impl::_options

private

Definition at line 980 of file KeModel_impl.h.

template<class T>

KeVCMap KeModel< T >::Impl::_vcMap

private

Definition at line 979 of file KeModel_impl.h.

---

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

• KeModel_impl.h