COMETModel< T > Class Template Reference

#include <COMETModel.h>

Inheritance diagram for COMETModel< T >:

Collaboration diagram for COMETModel< T >:

Public Types
typedef NumTypeTraits< T > ::T_Scalar	T_Scalar
typedef Array< int >	IntArray
typedef Array< T >	TArray
typedef shared_ptr< TArray >	TArrptr
typedef Array< bool >	BArray
typedef Array2D< T >	TArray2D
typedef Vector< T, 3 >	VectorT3
typedef Array< VectorT3 >	VectorT3Array
typedef shared_ptr< VectorT3Array >	VT3Ptr
typedef StressTensor< T >	StressTensorT6
typedef Array< StressTensorT6 >	StressTensorArray
typedef std::vector< Field * >	stdVectorField
typedef DistFunctFields< T >	TDistFF
typedef Vector< T, 5 >	VectorT5
typedef Array< VectorT5 >	VectorT5Array
typedef Vector< T, 6 >	VectorT6
typedef Array< VectorT6 >	VectorT6Array
typedef Vector< T, 10 >	VectorT10
typedef Array< VectorT10 >	VectorT10Array
typedef shared_ptr< MeshList >	MshLstPtr
typedef shared_ptr< Mesh >	MeshPtr
typedef shared_ptr< GeomFields >	GeoFldsPtr
typedef shared_ptr< StorageSite >	SSPtr
typedef shared_ptr < CRConnectivity >	CRPtr
typedef Array< int >	BCfaceArray
typedef shared_ptr< BCfaceArray >	BfacePtr
typedef vector< BfacePtr >	BCfaceList
typedef Array< int >	BCcellArray
typedef shared_ptr< BCcellArray >	BCellPtr
typedef vector< BCellPtr >	BCcellList
typedef Quadrature< T >	TQuad
typedef std::map< int, COMETBC < T > * >	COMETBCMap
typedef std::map< int, COMETVC < T > * >	COMETVCMap
typedef COMETModel< T >	TCOMET
typedef shared_ptr< TCOMET >	TCOMETPtr
typedef MultiField::ArrayIndex	Index
typedef pair< Index, Index >	EntryIndex
typedef pair< const StorageSite *, const StorageSite * >	SSPair
typedef map< EntryIndex, shared_ptr< Matrix > >	MatrixMap
typedef map< Index, int >	MatrixSizeMap
typedef map< const Mesh *, int >	SizeMap
typedef map< const StorageSite *, StorageSite * >	SiteMap
typedef map< SSPair, shared_ptr< Array< int > > >	MatrixMappersMap
typedef map< Index, shared_ptr < StorageSite > >	StorageSiteMap
typedef map< const StorageSite *, shared_ptr< StorageSite > >	GhostStorageSiteMap
typedef NumTypeTraits< T > ::T_Scalar	T_Scalar
typedef Vector< T_Scalar, 3 >	VectorT3
typedef Array< VectorT3 >	VectorT3Array
typedef shared_ptr< VectorT3Array >	VT3Ptr
typedef Kspace< T >	Tkspace
typedef Tkspace *	TkspPtr
typedef vector< Tkspace * >	TkspList
typedef kvol< T >	Tkvol
typedef pmode< T >	Tmode
typedef Array< bool >	BArray
typedef Array< int >	IntArray
typedef shared_ptr< IntArray >	IntArrPtr
typedef Array< T >	TArray
typedef shared_ptr< TArray >	TArrptr
typedef map< int, COMETBC< T > * >	COMETBCMap
typedef vector< COMETIC< T > * >	IClist
typedef map< int, int >	MeshKspaceMap
typedef COMETModel< T >	TCOMET
typedef shared_ptr< TCOMET >	TCOMETPtr
typedef COMETModelOptions< T >	TCModOpts
typedef Tmode::Mode_ptr	Mode_ptr
typedef Tmode::Reflection	Reflection
typedef Tmode::Reflptr	Reflptr
typedef Tmode::Refl_pair	Refl_pair
typedef Tmode::Refl_Map	Refl_Map
typedef shared_ptr< MeshList >	MshLstPtr
typedef shared_ptr< Mesh >	MeshPtr
typedef shared_ptr< GeomFields >	GeoFldsPtr
typedef shared_ptr< Tkspace >	KspPtr
typedef shared_ptr< PhononMacro >	PMacroPtr
typedef shared_ptr< StorageSite >	SSPtr
typedef shared_ptr < CRConnectivity >	CRPtr
typedef Array< int >	BCfaceArray
typedef shared_ptr< BCfaceArray >	BfacePtr
typedef vector< BfacePtr >	BCfaceList
typedef Array< int >	BCcellArray
typedef shared_ptr< BCcellArray >	BCellPtr
typedef vector< BCellPtr >	BCcellList
typedef vector< IntArrPtr >	MeshICmap
typedef KSConnectivity< T >	TKConnectivity
typedef TKConnectivity *	TKCptr
typedef vector< TKCptr >	TKClist
typedef map< int, TKClist >	FgTKClistMap
typedef vector< shared_ptr < Field > >	FieldVector
typedef pair< const StorageSite *, const StorageSite * >	SSPair
typedef map< SSPair, shared_ptr< Array< int > > >	ScatGathMaps
typedef map< const StorageSite *, StorageSite * >	SiteMap

Public Member Functions
	COMETModel (const MeshList &meshes, const int level, GeomFields &geomFields, MacroFields &macroFields, Quadrature< T > &quad, const int ibm=0, GeomFields *finestGeomFields=NULL, const MeshList *finestMeshes=NULL, MacroFields *finestMacroFields=NULL)
void	init ()
void	MakeCoarseModel (TCOMET *finerModel)
void	MakeIBCoarseModel (TCOMET *finerModel, const StorageSite &solidFaces)
void	MakeCoarseIndex (const StorageSite &solidFaces)
void	MakeParallel ()
void	InitializeMacroparameters ()
void	InitializeFgammaCoefficients ()
void	ComputeMacroparameters ()
void	ComputeCOMETMacroparameters ()
void	ComputeFineMacroparameters ()
void	ComputeCoarseMacroparameters ()
void	ComputeMacroparametersESBGK ()
void	ComputeCollisionfrequency ()
void	MomentHierarchy ()
void	EntropyGeneration ()
void	initializeMaxwellianEq ()
void	NewtonsMethodBGK (const int ktrial)
void	EquilibriumDistributionBGK ()
void	setJacobianBGK (SquareMatrix< T, 5 > &fjac, VectorT5 &fvec, const VectorT5 &xn, const VectorT3 &v, const int c)
void	NewtonsMethodESBGK (const int ktrial)
void	EquilibriumDistributionESBGK ()
void	setJacobianESBGK (SquareMatrix< T, 10 > &fjac, VectorT10 &fvec, const VectorT10 &xn, const VectorT3 &v, const int c)
void	initializeMaxwellian ()
void	initializeFineMaxwellian ()
void	initializeCoarseMaxwellian ()
void	weightedMaxwellian (double weight1, double uvel1, double vvel1, double wvel1, double uvel2, double vvel2, double wvel2, double temp1, double temp2)
void	weightedMaxwellian (double weight1, double uvel1, double uvel2, double temp1, double temp2)
COMETBCMap &	getBCMap ()
COMETVCMap &	getVCMap ()
COMETModelOptions< T > &	getOptions ()
const map< int, vector< int > > &	getFaceReflectionArrayMap () const
map< string, shared_ptr < ArrayBase > > &	getPersistenceData ()
void	restart ()
void	SetBoundaryConditions ()
void	updateTime ()
void	callCOMETBoundaryConditions ()
void	OutputDsfBLOCK (const char *filename)
void	MakeCoarseMesh1 (const MeshList &inMeshes, GeomFields &inGeomFields, MeshList &outMeshes)
int	MakeCoarseMesh2 (const MeshList &inMeshes, GeomFields &inGeomFields, GeomFields &coarseGeomFields, MeshList &outMeshes)
void	syncGhostCoarsening (const MeshList &inMeshes, GeomFields &inGeomFields, MeshList &outMeshes)
void	computeIBFaceDsf (const StorageSite &solidFaces, const int method, const int RelaxDistribution=0)
void	computeSolidFacePressure (const StorageSite &solidFaces)
void	computeSolidFaceDsf (const StorageSite &solidFaces, const int method, const int RelaxDistribution=0)
void	correctMassDeficit ()
void	correctMassDeficit2 (double n1, double n2)
const double	ConservationofMassCheck ()
void	ConservationofMFSolid (const StorageSite &solidFaces) const
void	doSweeps (const int sweeps, const int num)
void	doSweeps (const int sweeps, const int num, const StorageSite &solidFaces)
void	smooth (const int num, const StorageSite &solidFaces)
void	smooth (const int num)
T	updateResid (const bool addFAS)
T	updateResid (const bool addFAS, const StorageSite &solidFaces)
void	cycle ()
void	cycle (const StorageSite &solidFaces)
void	injectResid ()
void	makeFAS ()
void	makeFAS (const StorageSite &solidFaces)
void	correctSolution ()
void	advance (const int iters)
T	advance (const int iters, const StorageSite &solidFaces)
void	computeSurfaceForce (const StorageSite &solidFaces, bool perUnitArea, bool IBM=0)
void	OutputDsfPOINT ()
DistFunctFields< T > &	getdsf ()
const DistFunctFields< T > &	getdsf1 () const
const DistFunctFields< T > &	getdsf2 () const
const DistFunctFields< T > &	getdsfEq () const
const DistFunctFields< T > &	getdsfEqES () const
DistFunctFields< T > &	getdsf0 ()
DistFunctFields< T > &	getdsfInj ()
DistFunctFields< T > &	getdsfRes ()
DistFunctFields< T > &	getdsfFAS ()
void	setBCMap (COMETBCMap *bcMap)
void	setCoarserLevel (TCOMET *cl)
void	setFinerLevel (TCOMET *fl)
int	getLevel ()
const MeshList &	getMeshList ()
GeomFields &	getGeomFields ()
TQuad &	getQuadrature ()
MacroFields &	getMacro ()
T	getResidual ()
	COMETModel (const MeshList &meshes, const int level, GeomFields &geomFields, TkspList &kspaces, PhononMacro &macro)
TCModOpts &	getOptions ()
COMETBCMap &	getBCs ()
MeshKspaceMap &	getMKMap ()
void	init ()
void	initFromOld ()
void	initCoarse ()
void	setLocalScatterMaps (const Mesh &mesh0, StorageSite &faces0, const Mesh &mesh1, StorageSite &faces1)
void	applyTemperatureBoundaries ()
void	initializeTemperatureBoundaries ()
void	MakeCoarseModel (TCOMET *finerModel)
void	setFinestLevel (TCOMET *finest)
void	MakeNewKspaces (TkspList &inList, TkspList &outList)
void	MakeInteriorCoarseMesh (const MeshList &inMeshes, GeomFields &inGeomFields, MeshList &outMeshes, IntArray &CoarseCounts, map< const StorageSite *, IntArray * > &PreFacePairMap, IntArray &CoarseGhost, SiteMap &siteMap)
void	syncGhostCoarsening (const MeshList &inMeshes, GeomFields &inGeomFields, MeshList &outMeshes, ScatGathMaps &coarseScatMaps, ScatGathMaps &coarseGathMaps, IntArray &coarseSizes, IntArray &CoarseGhost)
void	makeCoarseScatGath (const MeshList &inMeshes, SiteMap &siteMap, ScatGathMaps &coarseScatMaps, ScatGathMaps &coarseGathMaps)
int	FinishCoarseMesh (const MeshList &inMeshes, GeomFields &inGeomFields, MeshList &outMeshes, IntArray &CoarseCounts, map< const StorageSite *, IntArray * > &PreFacePairMap, IntArray &coarseGhost)
int	coarsenInterior (const int m, const Mesh &mesh, GeomFields &inGeomFields, int &coarseCount)
int	correctSingleNeighbor (const int m, const Mesh &mesh, GeomFields &inGeomFields, int coarseCount, map< const StorageSite *, IntArray * > PreFacePairMap)
void	coarsenInterfaceCells (COMETIC< T > &ic, IntArray &coarseCounts, GeomFields &inGeomFields, const MeshList &inMeshes)
void	doSweeps (const int sweeps)
void	smooth (int dir)
T	updateResid (const bool addFAS)
void	swapGhostInfo ()
void	cycle ()
void	injectResid ()
void	makeFAS ()
void	sete0 ()
void	correctSolution ()
void	updateTL ()
void	advance (const int iters)
T	HeatFluxIntegral (const Mesh &mesh, const int faceGroupId)
T	HeatFluxIntegralFace (const Mesh &mesh, const int f)
ArrayBase *	binwiseHeatFluxIntegral (const Mesh &mesh, const int faceGroupId)
ArrayBase *	modewiseHeatFluxIntegral (const Mesh &mesh, const int faceGroupId)
T	getWallArea (const Mesh &mesh, const int faceGroupId)
VectorT3	getWallAreaVector (const Mesh &mesh, const int faceGroupId)
ArrayBase *	getValueArray (const Mesh &mesh, const int cell)
void	equilibrate ()
ArrayBase &	getLatticeTemp (const Mesh &mesh)
void	setStraightLine (const T T1, const T T2)
void	calcModeTemps ()
void	calcBandTemps ()
void	calcBandRelEnergy ()
void	calcModeFlux ()
void	calcBandFlux ()
T	calcDomainStats ()
void	makeCellColors (const int level)
void	makePlotColors (const int level)
void	makeFinestToCoarseConn ()
TCOMET *	getModelPointer (const int level)
bool	sameFaceGroup (const Mesh &mesh, const int f0, const int f1)
T	getAverageTemperature ()
void	makeNonEqTemp ()
void	setBCMap (COMETBCMap *bcMap)
void	setCoarserLevel (TCOMET *cl)
void	setFinerLevel (TCOMET *fl)
TCOMET *	getFinerModel ()
int	getLevel ()
const MeshList &	getMeshList ()
GeomFields &	getGeomFields ()
TkspList &	getKspaces ()
Tkspace &	getKspace (const int i)
PhononMacro &	getMacro ()
T	getResidual ()
IClist &	getIClist ()
MeshICmap &	getMeshICmap ()
Public Member Functions inherited from Model
	Model (const MeshList &meshes)
virtual	~Model ()
	DEFINE_TYPENAME ("Model")

Private Attributes
const int	_level
GeomFields &	_geomFields
GeomFields	_coarseGeomFields
GeomFields &	_finestGeomFields
const MeshList &	_finestMeshes
Quadrature< T > &	_quadrature
const int	_ibm
MacroFields &	_macroFields
MacroFields &	_finestMacroFields
TCOMET *	_finestLevel
TCOMET *	_coarserLevel
TCOMET *	_finerLevel
DistFunctFields< T >	_dsfPtr
DistFunctFields< T >	_dsfPtr1
DistFunctFields< T >	_dsfPtr2
DistFunctFields< T >	_dsfEqPtr
DistFunctFields< T >	_dsfEqPtrES
DistFunctFields< T >	_dsfPtr0
DistFunctFields< T >	_dsfPtrInj
DistFunctFields< T >	_dsfPtrRes
DistFunctFields< T >	_dsfPtrFAS
COMETBCMap	_bcMap
COMETVCMap	_vcMap
COMETModelOptions< T >	_options
T	_residual
T	_initialResidual
MFRPtr	_initialKmodelNorm
BCcellList	_BCells
BCfaceList	_BFaces
BCcellList	_ZCells
int	_niters
map< int, vector< int > >	_faceReflectionArrayMap
map< string, shared_ptr < ArrayBase > >	_persistenceData
SizeMap	_coarseSizes
SizeMap	_coarseGhostSizes
SiteMap	_siteMap
GhostStorageSiteMap	_sharedSiteMap
MatrixMappersMap	_coarseScatterMaps
MatrixMappersMap	_coarseGatherMaps
TkspList &	_kspaces
PhononMacro &	_macro
TCModOpts	_options
MeshKspaceMap	_MeshKspaceMap
IClist	_IClist
MeshICmap	_MeshToIC
int	_rank

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 COMETModel< T >

Definition at line 51 of file esbgkbase/COMETModel.h.

Member Typedef Documentation

template<class T >

typedef Array<bool> COMETModel< T >::BArray

Definition at line 35 of file phononbase/COMETModel.h.

template<class T >

typedef Array<bool> COMETModel< T >::BArray

Definition at line 58 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<int> COMETModel< T >::BCcellArray

Definition at line 61 of file phononbase/COMETModel.h.

template<class T >

typedef Array<int> COMETModel< T >::BCcellArray

Definition at line 84 of file esbgkbase/COMETModel.h.

template<class T >

typedef vector<BCellPtr> COMETModel< T >::BCcellList

Definition at line 63 of file phononbase/COMETModel.h.

template<class T >

typedef vector<BCellPtr> COMETModel< T >::BCcellList

Definition at line 86 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<BCcellArray> COMETModel< T >::BCellPtr

Definition at line 62 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<BCcellArray> COMETModel< T >::BCellPtr

Definition at line 85 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<int> COMETModel< T >::BCfaceArray

Definition at line 58 of file phononbase/COMETModel.h.

template<class T >

typedef Array<int> COMETModel< T >::BCfaceArray

Definition at line 81 of file esbgkbase/COMETModel.h.

template<class T >

typedef vector<BfacePtr> COMETModel< T >::BCfaceList

Definition at line 60 of file phononbase/COMETModel.h.

template<class T >

typedef vector<BfacePtr> COMETModel< T >::BCfaceList

Definition at line 83 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<BCfaceArray> COMETModel< T >::BfacePtr

Definition at line 59 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<BCfaceArray> COMETModel< T >::BfacePtr

Definition at line 82 of file esbgkbase/COMETModel.h.

template<class T >

typedef map<int,COMETBC<T>*> COMETModel< T >::COMETBCMap

Definition at line 40 of file phononbase/COMETModel.h.

template<class T >

typedef std::map<int,COMETBC<T>*> COMETModel< T >::COMETBCMap

Definition at line 90 of file esbgkbase/COMETModel.h.

template<class T >

typedef std::map<int,COMETVC<T>*> COMETModel< T >::COMETVCMap

Definition at line 91 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<CRConnectivity> COMETModel< T >::CRPtr

Definition at line 57 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<CRConnectivity> COMETModel< T >::CRPtr

Definition at line 79 of file esbgkbase/COMETModel.h.

template<class T >

typedef pair<Index,Index> COMETModel< T >::EntryIndex

Definition at line 96 of file esbgkbase/COMETModel.h.

template<class T >

typedef map<int, TKClist> COMETModel< T >::FgTKClistMap

Definition at line 68 of file phononbase/COMETModel.h.

template<class T >

typedef vector<shared_ptr<Field> > COMETModel< T >::FieldVector

Definition at line 69 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<GeomFields> COMETModel< T >::GeoFldsPtr

Definition at line 53 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<GeomFields> COMETModel< T >::GeoFldsPtr

Definition at line 77 of file esbgkbase/COMETModel.h.

template<class T >

typedef map<const StorageSite*,shared_ptr<StorageSite> > COMETModel< T >::GhostStorageSiteMap

Definition at line 107 of file esbgkbase/COMETModel.h.

template<class T >

typedef vector<COMETIC<T>*> COMETModel< T >::IClist

Definition at line 41 of file phononbase/COMETModel.h.

template<class T >

typedef MultiField::ArrayIndex COMETModel< T >::Index

Definition at line 95 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<int> COMETModel< T >::IntArray

Definition at line 36 of file phononbase/COMETModel.h.

template<class T >

typedef Array<int> COMETModel< T >::IntArray

Definition at line 55 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<IntArray> COMETModel< T >::IntArrPtr

Definition at line 37 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<Tkspace> COMETModel< T >::KspPtr

Definition at line 54 of file phononbase/COMETModel.h.

template<class T >

typedef map<EntryIndex,shared_ptr<Matrix> > COMETModel< T >::MatrixMap

Definition at line 99 of file esbgkbase/COMETModel.h.

template<class T >

typedef map<SSPair,shared_ptr<Array<int> > > COMETModel< T >::MatrixMappersMap

Definition at line 104 of file esbgkbase/COMETModel.h.

template<class T >

typedef map<Index,int> COMETModel< T >::MatrixSizeMap

Definition at line 100 of file esbgkbase/COMETModel.h.

template<class T >

typedef vector<IntArrPtr> COMETModel< T >::MeshICmap

Definition at line 64 of file phononbase/COMETModel.h.

template<class T >

typedef map<int,int> COMETModel< T >::MeshKspaceMap

Definition at line 42 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<Mesh> COMETModel< T >::MeshPtr

Definition at line 52 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<Mesh> COMETModel< T >::MeshPtr

Definition at line 76 of file esbgkbase/COMETModel.h.

template<class T >

typedef Tmode::Mode_ptr COMETModel< T >::Mode_ptr

Definition at line 46 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<MeshList> COMETModel< T >::MshLstPtr

Definition at line 51 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<MeshList> COMETModel< T >::MshLstPtr

Definition at line 75 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<PhononMacro> COMETModel< T >::PMacroPtr

Definition at line 55 of file phononbase/COMETModel.h.

template<class T >

typedef Tmode::Refl_Map COMETModel< T >::Refl_Map

Definition at line 50 of file phononbase/COMETModel.h.

template<class T >

typedef Tmode::Refl_pair COMETModel< T >::Refl_pair

Definition at line 49 of file phononbase/COMETModel.h.

template<class T >

typedef Tmode::Reflection COMETModel< T >::Reflection

Definition at line 47 of file phononbase/COMETModel.h.

template<class T >

typedef Tmode::Reflptr COMETModel< T >::Reflptr

Definition at line 48 of file phononbase/COMETModel.h.

template<class T >

typedef map<SSPair,shared_ptr<Array<int> > > COMETModel< T >::ScatGathMaps

Definition at line 71 of file phononbase/COMETModel.h.

template<class T >

typedef map<const StorageSite*, StorageSite*> COMETModel< T >::SiteMap

Definition at line 72 of file phononbase/COMETModel.h.

template<class T >

typedef map<const StorageSite*,StorageSite*> COMETModel< T >::SiteMap

Definition at line 102 of file esbgkbase/COMETModel.h.

template<class T >

typedef map<const Mesh*,int> COMETModel< T >::SizeMap

Definition at line 101 of file esbgkbase/COMETModel.h.

template<class T >

typedef pair<const StorageSite*, const StorageSite*> COMETModel< T >::SSPair

Definition at line 70 of file phononbase/COMETModel.h.

template<class T >

typedef pair<const StorageSite*, const StorageSite*> COMETModel< T >::SSPair

Definition at line 97 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<StorageSite> COMETModel< T >::SSPtr

Definition at line 56 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<StorageSite> COMETModel< T >::SSPtr

Definition at line 78 of file esbgkbase/COMETModel.h.

template<class T >

typedef std::vector<Field*> COMETModel< T >::stdVectorField

Definition at line 65 of file esbgkbase/COMETModel.h.

template<class T >

typedef map<Index,shared_ptr<StorageSite> > COMETModel< T >::StorageSiteMap

Definition at line 106 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<StressTensorT6> COMETModel< T >::StressTensorArray

Definition at line 64 of file esbgkbase/COMETModel.h.

template<class T >

typedef StressTensor<T> COMETModel< T >::StressTensorT6

Definition at line 63 of file esbgkbase/COMETModel.h.

template<class T >

typedef NumTypeTraits<T>::T_Scalar COMETModel< T >::T_Scalar

Definition at line 26 of file phononbase/COMETModel.h.

template<class T >

typedef NumTypeTraits<T>:: T_Scalar COMETModel< T >::T_Scalar

Definition at line 54 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<T> COMETModel< T >::TArray

Definition at line 38 of file phononbase/COMETModel.h.

template<class T >

typedef Array<T> COMETModel< T >::TArray

Definition at line 56 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array2D<T> COMETModel< T >::TArray2D

Definition at line 59 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<TArray> COMETModel< T >::TArrptr

Definition at line 39 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<TArray> COMETModel< T >::TArrptr

Definition at line 57 of file esbgkbase/COMETModel.h.

template<class T >

typedef COMETModelOptions<T> COMETModel< T >::TCModOpts

Definition at line 45 of file phononbase/COMETModel.h.

template<class T >

typedef COMETModel<T> COMETModel< T >::TCOMET

Definition at line 43 of file phononbase/COMETModel.h.

template<class T >

typedef COMETModel<T> COMETModel< T >::TCOMET

Definition at line 92 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<TCOMET> COMETModel< T >::TCOMETPtr

Definition at line 44 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<TCOMET> COMETModel< T >::TCOMETPtr

Definition at line 93 of file esbgkbase/COMETModel.h.

template<class T >

typedef DistFunctFields<T> COMETModel< T >::TDistFF

Definition at line 66 of file esbgkbase/COMETModel.h.

template<class T >

typedef vector<TKCptr> COMETModel< T >::TKClist

Definition at line 67 of file phononbase/COMETModel.h.

template<class T >

typedef KSConnectivity<T> COMETModel< T >::TKConnectivity

Definition at line 65 of file phononbase/COMETModel.h.

template<class T >

typedef TKConnectivity* COMETModel< T >::TKCptr

Definition at line 66 of file phononbase/COMETModel.h.

template<class T >

typedef Kspace<T> COMETModel< T >::Tkspace

Definition at line 30 of file phononbase/COMETModel.h.

template<class T >

typedef vector<Tkspace*> COMETModel< T >::TkspList

Definition at line 32 of file phononbase/COMETModel.h.

template<class T >

typedef Tkspace* COMETModel< T >::TkspPtr

Definition at line 31 of file phononbase/COMETModel.h.

template<class T >

typedef kvol<T> COMETModel< T >::Tkvol

Definition at line 33 of file phononbase/COMETModel.h.

template<class T >

typedef pmode<T> COMETModel< T >::Tmode

Definition at line 34 of file phononbase/COMETModel.h.

template<class T >

typedef Quadrature<T> COMETModel< T >::TQuad

Definition at line 88 of file esbgkbase/COMETModel.h.

template<class T >

typedef Vector<T,10> COMETModel< T >::VectorT10

Definition at line 72 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<VectorT10> COMETModel< T >::VectorT10Array

Definition at line 73 of file esbgkbase/COMETModel.h.

template<class T >

typedef Vector<T_Scalar,3> COMETModel< T >::VectorT3

Definition at line 27 of file phononbase/COMETModel.h.

template<class T >

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

Definition at line 60 of file esbgkbase/COMETModel.h.

template<class T >

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

Definition at line 28 of file phononbase/COMETModel.h.

template<class T >

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

Definition at line 61 of file esbgkbase/COMETModel.h.

template<class T >

typedef Vector<T,5> COMETModel< T >::VectorT5

Definition at line 68 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<VectorT5> COMETModel< T >::VectorT5Array

Definition at line 69 of file esbgkbase/COMETModel.h.

template<class T >

typedef Vector<T,6> COMETModel< T >::VectorT6

Definition at line 70 of file esbgkbase/COMETModel.h.

template<class T >

typedef Array<VectorT6> COMETModel< T >::VectorT6Array

Definition at line 71 of file esbgkbase/COMETModel.h.

template<class T >

typedef shared_ptr<VectorT3Array> COMETModel< T >::VT3Ptr

Definition at line 29 of file phononbase/COMETModel.h.

template<class T >

typedef shared_ptr<VectorT3Array> COMETModel< T >::VT3Ptr

Definition at line 62 of file esbgkbase/COMETModel.h.

Constructor & Destructor Documentation

template<class T >

COMETModel< T >::COMETModel ( const MeshList &  meshes, const int  level, GeomFields &  geomFields, MacroFields &  macroFields, Quadrature< T > &  quad, const int  ibm = 0, GeomFields *  finestGeomFields = NULL, const MeshList *  finestMeshes = NULL, MacroFields *  finestMacroFields = NULL  )

inline

Calculation of macro-parameters density, temperature, components of velocity, pressure by taking moments of distribution function using quadrature points and weights from quadrature.h

Definition at line 115 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_BFaces, COMETModel< T >::_level, Model::_meshes, COMETModel< T >::_vcMap, COMETModel< T >::_ZCells, COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::ComputeFineMacroparameters(), COMETModel< T >::ComputeMacroparameters(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaces(), Mesh::getID(), StorageSite::getSelfCount(), COMETModel< T >::init(), COMETModel< T >::initializeFineMaxwellian(), COMETModel< T >::InitializeMacroparameters(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::SetBoundaryConditions(), and COMETVC< T >::vcType.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

                                                                                                                       :
       
    Model(meshes),
    _level(level),
    _geomFields(geomFields),
    _quadrature(quad),
    _macroFields(macroFields),
    _dsfPtr(_meshes,_quadrature,"dsf_"),
    _dsfPtr1(_meshes,_quadrature,"dsf1_"),
    _dsfPtr2(_meshes,_quadrature,"dsf2_"),
    _dsfEqPtr(_meshes,_quadrature,"dsfEq_"),
    _dsfEqPtrES(_meshes,_quadrature,"dsfEqES_"),
    _dsfPtr0(_meshes,_quadrature,"dsf0_"),
    _dsfPtrInj(_meshes,_quadrature,"dsfInj_"),
    _dsfPtrRes(_meshes,_quadrature,"dsfRes_"),
    _dsfPtrFAS(_meshes,_quadrature,"dsfFAS_"),
    _coarseGeomFields("coarse"),
    _initialKmodelNorm(),
    _niters(0),
    _residual(0.0),
    _initialResidual(0.0),
    _ibm(ibm),
    _finestGeomFields(finestGeomFields ? *finestGeomFields : _geomFields),
    _finestMeshes(finestMeshes ? *finestMeshes : _meshes),
    _finestMacroFields(finestMacroFields ? *finestMacroFields : _macroFields)
    {     
     
      const int numMeshes = _meshes.size();
      for (int n=0; n<numMeshes; n++)
        {
          const Mesh& mesh = *_meshes[n];
          const StorageSite& faces=mesh.getFaces();
          const StorageSite& cells=mesh.getCells();
          const int faceCount=faces.getCount();
          const int cellCount=cells.getSelfCount();
          
          BfacePtr BFptr(new BCfaceArray(faceCount));
          BFptr->zero();
          _BFaces.push_back(BFptr);
          
          BCellPtr BCptr(new BCcellArray(cellCount));
          _BCells.push_back(BCptr);
          BCptr->zero();

          BCellPtr ZCptr(new BCcellArray(cellCount));
          _ZCells.push_back(ZCptr);
          ZCptr->zero();
          if(_level==0)
          {
              COMETVC<T> *vc(new COMETVC<T>());
              vc->vcType = "flow";
              _vcMap[mesh.getID()] = vc;
          }
        }

      if(_level==0)
      {
          SetBoundaryConditions();
          init();
          InitializeMacroparameters();
          initializeMaxwellian();
          initializeFineMaxwellian();
          ComputeMacroparameters(); //calculate density,velocity,temperature
          ComputeFineMacroparameters();
          ComputeCollisionfrequency(); //calculate viscosity, collisionFrequency
          initializeMaxwellianEq();    //equilibrium distribution
      }
    }

template<class T >

COMETModel< T >::COMETModel ( const MeshList &  meshes, const int  level, GeomFields &  geomFields, TkspList &  kspaces, PhononMacro &  macro  )

inline

Definition at line 74 of file phononbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_level, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_rank, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaces(), and FaceGroup::id.

                                                  :
  Model(meshes),
    _level(level),
    _geomFields(geomFields),
    _kspaces(kspaces),
    _macro(macro),
    _finestLevel(NULL),
    _coarserLevel(NULL),
    _finerLevel(NULL),
    _residual(1.0),
    _MeshToIC(),
    _rank(-1)
      {
        const int numMeshes = _meshes.size();

#ifdef FVM_PARALLEL
        _rank=MPI::COMM_WORLD.Get_rank();
#endif
        
        for (int n=0; n<numMeshes; n++)
          {
            Mesh& mesh = *_meshes[n];
            const StorageSite& faces=mesh.getFaces();
            const StorageSite& cells=mesh.getCells();
            const int faceCount=faces.getCount();
            const int cellCount=cells.getCount();
            _MeshKspaceMap[n]=-1; //mesh map not set
            
            BfacePtr BFptr(new BCfaceArray(faceCount));
            BFptr->zero();
            _BFaces.push_back(BFptr);
            
            BCellPtr BCptr(new BCcellArray(cellCount));
            _BCells.push_back(BCptr);
            BCptr->zero();
            
            if(_level==0)
              {
                foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
                  {
                    const FaceGroup& fg = *fgPtr;
                    if (_bcMap.find(fg.id) == _bcMap.end() && fg.id>0)
                      {
                        COMETBC<T> *bc(new COMETBC<T>()); 
                        _bcMap[fg.id] = bc;
                      }
                  }
              }
          }
      }

Member Function Documentation

template<class T >

void COMETModel< T >::advance ( const int  iters )

inline

Definition at line 3270 of file phononbase/COMETModel.h.

References COMETModel< T >::_options, COMETModel< T >::_residual, COMETModel< T >::cycle(), and COMETModel< T >::updateResid().

  {
    _residual=updateResid(false);
    int niters=0;
    const T absTol=_options.absTolerance;
    const int show=_options.showResidual;

    while((niters<iters) && (_residual>absTol))
      {
        cycle();
        niters++;
        _residual=updateResid(false);
        if(niters%show==0)
          cout<<"Iteration:"<<niters<<" Residual:"<<_residual<<endl;
        
      }
    
    //applyTemperatureBoundaries();
    //calcModeTemps();
  }

template<class T >

void COMETModel< T >::advance ( const int  iters )

inline

Definition at line 5388 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_initialResidual, COMETModel< T >::_options, COMETModel< T >::_residual, COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::cycle(), and COMETModel< T >::updateResid().

  {
    callCOMETBoundaryConditions();
    _residual=updateResid(false);
    _initialResidual=_residual;
    T residualRatio(1.0);
    
#ifdef FVM_PARALLEL    
    if ( MPI::COMM_WORLD.Get_rank() == 0 )
      cout<<"Initial Residual:"<<_initialResidual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif


#ifndef FVM_PARALLEL    
    cout << "Initial Residual:"<<_initialResidual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif
    
    
    
    int niters=0;
    const T absTol=_options.absoluteTolerance;
    const T relTol=_options.relativeTolerance;
    const int show=_options.showResidual;

    while((niters<iters) && ((_residual>absTol)&&(residualRatio>relTol)))
      {
        cycle();
        niters++;
        _residual=updateResid(false);
        if(niters==1)
          _initialResidual=_residual;
        residualRatio=_residual/_initialResidual;
#ifdef FVM_PARALLEL
        if((niters%show==0)&&(MPI::COMM_WORLD.Get_rank()==0))
          cout<<"Iteration:"<<niters<<" Residual:"<<_residual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif

#ifndef FVM_PARALLEL
        if(niters%show==0)
          cout<<"Iteration:"<<niters<<" Residual:"<<_residual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif
      }
    callCOMETBoundaryConditions();
    //cout<<endl<<"Total Iterations:"<<niters<<" Residual:"<<_residual<<endl;
  }

template<class T >

T COMETModel< T >::advance ( const int  iters, const StorageSite &  solidFaces  )

inline

Definition at line 5434 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_initialResidual, COMETModel< T >::_options, COMETModel< T >::_residual, COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::cycle(), and COMETModel< T >::updateResid().

  {
    callCOMETBoundaryConditions();
    _residual=updateResid(false,solidFaces);
    _initialResidual=_residual;
    T residualRatio(1.0);
    
#ifdef FVM_PARALLEL    
    if ( MPI::COMM_WORLD.Get_rank() == 0 )
        cout<<"Initial Residual:"<<_initialResidual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif


#ifndef FVM_PARALLEL    
    cout << "Initial Residual:"<<_initialResidual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif  
    
    
    
    int niters=0;
    const T absTol=_options.absoluteTolerance;
    const T relTol=_options.relativeTolerance;
    const int show=_options.showResidual;

    while((niters<iters) && ((_residual>absTol)&&(residualRatio>relTol)))
      {
        cycle(solidFaces);
        niters++;
        _residual=updateResid(false,solidFaces);
        if(niters==1)
          _initialResidual=_residual;
        residualRatio=_residual/_initialResidual;
#ifdef FVM_PARALLEL
        if((niters%show==0)&&(MPI::COMM_WORLD.Get_rank()==0))
          cout<<"Iteration:"<<niters<<" Residual:"<<_residual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif

#ifndef FVM_PARALLEL
        if(niters%show==0)
          cout<<"Iteration:"<<niters<<" Residual:"<<_residual<<"  ResidualRatio: "<<residualRatio<<endl;
#endif
      }
    callCOMETBoundaryConditions();
    return _residual;
    //cout<<endl<<"Total Iterations:"<<niters<<" Residual:"<<_residual<<endl;
  }

template<class T >

void COMETModel< T >::applyTemperatureBoundaries ( )

inline

Definition at line 1011 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap, COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, COMETModel< T >::_level, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_options, COMETBoundary< T >::applyTemperatureWallCoarse(), COMETBC< T >::bcType, Mesh::getBoundaryFaceGroups(), FloatVarDict< T >::getVal(), FaceGroup::id, and FaceGroup::site.

Referenced by COMETModel< T >::initCoarse(), and COMETModel< T >::smooth().

  {
    const int numMeshes=_meshes.size();

    for(int n=0;n<numMeshes;n++)
      {
        const Mesh& mesh=*_meshes[n];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          {
            const FaceGroup& fg = *fgPtr;
            if(fg.id>0)
              {   
                const StorageSite& faces = fg.site;
                const COMETBC<T>& bc = *_bcMap[fg.id];
                
                COMETBoundary<T> cbc(faces, mesh,_geomFields,kspace,_options,fg.id);
                
                if(bc.bcType=="temperature")
                  {           
                    FloatValEvaluator<T>
                      bTemperature(bc.getVal("specifiedTemperature"),faces);
                    
                    if(_level>0 || _options.Convection=="FirstOrder")
                      cbc.applyTemperatureWallCoarse(bTemperature);
                    else
                      cbc.applyTemperatureWallCoarse(bTemperature);

                  }
              }
          }
      }
  }

template<class T >

ArrayBase* COMETModel< T >::binwiseHeatFluxIntegral ( const Mesh &  mesh, const int  faceGroupId  )

inline

Definition at line 3400 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, COMETModel< T >::_MeshKspaceMap, GeomFields::area, Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::getDOSptr(), Kspace< T >::geteArray(), Mesh::getFaceCells(), DensityOfStates< T >::getFreqMidsT(), Kspace< T >::getGlobalIndex(), Mesh::getID(), pmode< T >::getIndex(), DensityOfStates< T >::getKIndices(), Kspace< T >::getkvol(), Array< T >::getLength(), DensityOfStates< T >::getMIndices(), kvol< T >::getmode(), pmode< T >::getv(), FaceGroup::id, FaceGroup::site, and Array< T >::zero().

  {
    bool found = false;
    const int n=mesh.getID();
    Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
    DensityOfStates<T>& dos=*kspace.getDOSptr();
    TArray& freqMids=dos.getFreqMidsT();
    const T binNos=freqMids.getLength();
    TArray& eArray=kspace.geteArray();
    TArray* qptr(new TArray(binNos));
    TArray& q(*qptr);
    q.zero();

    //const T hbar=6.582119e-16;  // (eV s)

    foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
      {
        const FaceGroup& fg = *fgPtr;
        if (fg.id == faceGroupId)
          {
            const StorageSite& faces = fg.site;
            const int nFaces = faces.getCount();
            //const StorageSite& cells = mesh.getCells();
            const CRConnectivity& faceCells=mesh.getFaceCells(faces);
            const Field& areaField=_geomFields.area;
            const VectorT3Array& faceArea=dynamic_cast<const VectorT3Array&>(areaField[faces]);
            
            for(int f=0; f<nFaces; f++)
              {
                const VectorT3 An=faceArea[f];
                const int c1=faceCells(f,1);

                for(int binIndx=0;binIndx<binNos;binIndx++)
                  {
                    IntArray& kpts=dos.getKIndices(binIndx);
                    IntArray& mpts=dos.getMIndices(binIndx);

                    for(int k=0;k<kpts.getLength();k++)
                      {
                        Tkvol& kv=kspace.getkvol(kpts[k]);
                        T dk3=kv.getdk3();
                        Tmode& mode=kv.getmode(mpts[k]);
                        VectorT3 vg=mode.getv();
                        T vgdotAn=vg[0]*An[0]+vg[1]*An[1]+vg[2]*An[2];
                        const int index=mode.getIndex()-1;
                        int cellIndex=kspace.getGlobalIndex(c1,index);
                        q[binIndx]+= eArray[cellIndex]*vgdotAn*dk3;//*energy;
                        cellIndex++;
                      }
                  }
              }
            found=true;
          }
      }

    if (!found)
      throw CException("getHeatFluxIntegral: invalid faceGroupID");
    return qptr;
  }

template<class T >

void COMETModel< T >::calcBandFlux ( )

inline

Definition at line 3886 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, PhononMacro::BandFlux, Mesh::getCells(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::getDK3(), Kspace< T >::getDOSptr(), Kspace< T >::gete(), DensityOfStates< T >::getFreqMidsT(), pmode< T >::getIndex(), DensityOfStates< T >::getKIndices(), Kspace< T >::getkvol(), Array< T >::getLength(), DensityOfStates< T >::getMIndices(), kvol< T >::getmode(), pmode< T >::getv(), and Array< T >::zero().

  {
    const int numMeshes=_meshes.size();
    const T eVtoJoule=1.60217646e-19;
    for (int n=0;n<numMeshes;n++)
      {
        Mesh& mesh=*_meshes[n];
        if(_MeshKspaceMap[n]==-1)
          throw CException("Have not set the Kspace for this Mesh!!");
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        //const int numK=kspace.getlength();
        const StorageSite& cells=mesh.getCells();
        const int numcells=cells.getCount();
        //const int modeCount=kspace.getkvol(0).getmodenum();
        const T DK3=kspace.getDK3();
        DensityOfStates<T>& dos=*kspace.getDOSptr();
        const int bandCount=dos.getFreqMidsT().getLength();

        FieldVector* FieldVecPtr=new FieldVector();
        _macro.BandFlux[n]=FieldVecPtr;
        for(int b=0;b<bandCount;b++)
          {
            shared_ptr<Field> bandField(new Field("BandFlux"));
            VT3Ptr qptr(new VectorT3Array(numcells));
            VectorT3Array& q(*qptr);
            q.zero();
            bandField->addArray(cells,qptr);
            FieldVecPtr->push_back(bandField);
            IntArray& kpts=dos.getKIndices(b);
            IntArray& mpts=dos.getMIndices(b);
            for(int c=0;c<numcells;c++)
              {
                for(int i=0;i<kpts.getLength();i++)
                  {
                    const int k=kpts[i];
                    const int m=mpts[i];
                    Tmode& mode=kspace.getkvol(k).getmode(m);
                    T dk3=kspace.getkvol(k).getdk3();
                    const int index=mode.getIndex()-1;
                    q[c]+=mode.getv()*(dk3/DK3)*kspace.gete(c,index)*eVtoJoule;
                  }

              }
            for(int i=0;i<q.getLength();i++)
              q[i]*=DK3;
          }
      }
  }

template<class T >

void COMETModel< T >::calcBandRelEnergy ( )

inline

Definition at line 3772 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, PhononMacro::BandRelEnergy, Mesh::getCells(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::getDK3(), Kspace< T >::getDOSptr(), Kspace< T >::gete(), DensityOfStates< T >::getFreqMidsT(), pmode< T >::getIndex(), DensityOfStates< T >::getKIndices(), Kspace< T >::getkvol(), Array< T >::getLength(), Kspace< T >::getlength(), DensityOfStates< T >::getMIndices(), kvol< T >::getmode(), kvol< T >::getmodenum(), and Array< T >::zero().

  {
    const int numMeshes=_meshes.size();
    for (int n=0;n<numMeshes;n++)
      {
        Mesh& mesh=*_meshes[n];
        if(_MeshKspaceMap[n]==-1)
          throw CException("Have not set the Kspace for this Mesh!!");
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        const T DK3=kspace.getDK3();
        DensityOfStates<T>& dos=*kspace.getDOSptr();
        const StorageSite& cells=mesh.getCells();
        const int numcells=cells.getCount();
        TArray eSum(numcells);
        eSum.zero();
        const int bandCount=dos.getFreqMidsT().getLength();
        const int numK=kspace.getlength();
        FieldVector* FieldVecPtr=new FieldVector();
        _macro.BandRelEnergy[n]=FieldVecPtr;

        for(int c=0;c<numcells;c++)
          {
            int index(0);
            for(int k=0;k<numK;k++)
              {
                Tkvol& kv=kspace.getkvol(k);
                T dk3=kv.getdk3();
                const int numM=kv.getmodenum();
                for(int m=0;m<numM;m++)
                  {
                    eSum[c]+=kspace.gete(c,index)*(dk3/DK3);
                    index++;
                  }
              }
          }

        for(int b=0;b<bandCount;b++)
          {
            shared_ptr<Field> bandField(new Field("bandRelEnergy"));
            TArrptr Tptr(new TArray(numcells));
            bandField->addArray(cells,Tptr);
            FieldVecPtr->push_back(bandField);
            TArray& bandEn=*Tptr;
            bandEn.zero();
            IntArray& kpts=dos.getKIndices(b);
            IntArray& mpts=dos.getMIndices(b);
            for(int c=0;c<numcells;c++)
              {
                T cellSum(0);
                for(int i=0;i<kpts.getLength();i++)
                  {
                    const int k=kpts[i];
                    const int m=mpts[i];
                    T dk3=kspace.getkvol(k).getdk3();
                    Tmode& mode=kspace.getkvol(k).getmode(m);
                    const int index=mode.getIndex()-1;
                    cellSum+=kspace.gete(c,index)*(dk3/DK3);
                  }
                bandEn[c]=cellSum/eSum[c];
              }
          }

      }
  }

template<class T >

void COMETModel< T >::calcBandTemps ( )

inline

Definition at line 3724 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, PhononMacro::BandTemperatures, Kspace< T >::calcBandTemp(), Mesh::getCells(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::getDOSptr(), Kspace< T >::gete(), DensityOfStates< T >::getFreqMidsT(), pmode< T >::getIndex(), DensityOfStates< T >::getKIndices(), Kspace< T >::getkvol(), Array< T >::getLength(), DensityOfStates< T >::getMIndices(), kvol< T >::getmode(), PhononMacro::temperature, and Array< T >::zero().

  {
    const int numMeshes=_meshes.size();
    for (int n=0;n<numMeshes;n++)
      {
        Mesh& mesh=*_meshes[n];
        if(_MeshKspaceMap[n]==-1)
          throw CException("Have not set the Kspace for this Mesh!!");
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        DensityOfStates<T>& dos=*kspace.getDOSptr();
        const StorageSite& cells=mesh.getCells();
        const TArray& TL=dynamic_cast<const TArray&>(_macro.temperature[cells]);
        const int numcells=cells.getCount();
        TArray eSum(numcells);
        const int bandCount=dos.getFreqMidsT().getLength();

        FieldVector* FieldVecPtr=new FieldVector();
        _macro.BandTemperatures[n]=FieldVecPtr;
        for(int b=0;b<bandCount;b++)
          {
            eSum.zero();
            shared_ptr<Field> bandField(new Field("bandTemp"));
            TArrptr Tptr(new TArray(numcells));
            bandField->addArray(cells,Tptr);
            FieldVecPtr->push_back(bandField);
            TArray& bandTemp=*Tptr;
            bandTemp.zero();
            IntArray& kpts=dos.getKIndices(b);
            IntArray& mpts=dos.getMIndices(b);
            for(int c=0;c<numcells;c++)
              {
                for(int i=0;i<kpts.getLength();i++)
                  {
                    const int k=kpts[i];
                    const int m=mpts[i];
                    T dk3=kspace.getkvol(k).getdk3();
                    Tmode& mode=kspace.getkvol(k).getmode(m);
                    const int index=mode.getIndex()-1;
                    eSum[c]+=kspace.gete(c,index)*dk3;
                  }
              }
            for(int c=0;c<numcells;c++)
              bandTemp[c]=kspace.calcBandTemp(TL[c],eSum[c],kpts,mpts);
          }

      }
  }

template<class T >

T COMETModel< T >::calcDomainStats ( )

inline

Definition at line 3935 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap, COMETModel< T >::_geomFields, Model::_meshes, GeomFields::area, GeomFields::areaMag, fabs(), Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), StorageSite::getSelfCount(), FaceGroup::id, FaceGroup::site, GeomFields::volume, and Array< T >::zero().

Referenced by COMETModel< T >::init().

  {
    const int numMeshes=_meshes.size();
    TArray meshVols(numMeshes);
    T totalVol(0.);
    meshVols.zero();
    T interfaceArea(0.);
    T interfaceAreaX(0.);
    T interfaceAreaY(0.);
    T interfaceAreaZ(0.);
    int interfaceFaces(0);

    for (int n=0;n<numMeshes;n++)
      {
         Mesh& mesh=*_meshes[n];
         const StorageSite& cells=mesh.getCells();
         const  TArray& vol=dynamic_cast<const TArray&>(_geomFields.volume[cells]);
         
         for(int c=0;c<cells.getSelfCount();c++)
           meshVols[n]+=vol[c];

         totalVol+=meshVols[n];

         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
           {
             const FaceGroup& fg = *fgPtr;
             if(fg.id>0)
               {
                 if(_bcMap[fg.id]->bcType == "Interface")
                   {
                     const StorageSite& faces=fg.site;
                     const int numFaces=faces.getCount();
                     const Field& AreaMagField=_geomFields.areaMag;
                     const TArray& AreaMag=
                       dynamic_cast<const TArray&>(AreaMagField[faces]);
                     const VectorT3Array& AreaDir=
                       dynamic_cast<const VectorT3Array&>(_geomFields.area[faces]);
                     
                     interfaceFaces+=numFaces;

                     for(int f=0;f<numFaces;f++)
                       {
                         interfaceArea+=AreaMag[f];
                         interfaceAreaX+=fabs(AreaDir[f][0]);
                         interfaceAreaY+=fabs(AreaDir[f][1]);
                         interfaceAreaZ+=fabs(AreaDir[f][2]);
                       }

                   }
               }
           }
      }

    interfaceArea/=2.;
    interfaceAreaX/=2.;
    interfaceAreaY/=2.;
    interfaceAreaZ/=2.;
    interfaceFaces/=2;

    for (int n=0;n<numMeshes;n++)
      {
        Mesh& mesh=*_meshes[n];
        const StorageSite& cells=mesh.getCells();
        cout<<endl;
        cout<<"Mesh: "<<n<<endl;
        cout<<"Self Cell Count: "<<cells.getSelfCount()<<endl;
        cout<<"Ghost Cell Count: "<<cells.getCount()-cells.getSelfCount()<<endl;
        cout<<"Mesh Volume: "<<meshVols[n]<<endl;
      }

    cout<<endl;
    cout<<"Total Volume: "<<totalVol<<endl;
    cout<<"Interface Area: "<<interfaceArea<<endl;
    cout<<"Interface Area (X): "<<interfaceAreaX<<endl;
    cout<<"Interface Area (Y): "<<interfaceAreaY<<endl;
    cout<<"Interface Area (Z): "<<interfaceAreaZ<<endl;
    cout<<"Area/Volume: "<<interfaceArea/totalVol<<endl;
    cout<<"Volume/Area: "<<totalVol/interfaceArea<<endl;
    cout<<"Interface Face Count: "<<interfaceFaces<<endl;
    return interfaceArea/totalVol;
    
  }

template<class T >

void COMETModel< T >::calcModeFlux ( )

inline

Definition at line 3837 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, PhononMacro::BranchFlux, Mesh::getCells(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::getDK3(), Kspace< T >::gete(), pmode< T >::getIndex(), Kspace< T >::getkvol(), Array< T >::getLength(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), pmode< T >::getv(), PhononMacro::heatFlux, and Array< T >::zero().

  {
    const int numMeshes=_meshes.size();
    const T eVtoJoule=1.60217646e-19;
    for (int n=0;n<numMeshes;n++)
      {
        Mesh& mesh=*_meshes[n];
        if(_MeshKspaceMap[n]==-1)
          throw CException("Have not set the Kspace for this Mesh!!");
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        const int numK=kspace.getlength();
        const StorageSite& cells=mesh.getCells();
        const int numcells=cells.getCount();
        const int modeCount=kspace.getkvol(0).getmodenum();
        const T DK3=kspace.getDK3();
        VectorT3Array& Q=dynamic_cast<VectorT3Array&>(_macro.heatFlux[cells]);
        Q.zero();

        FieldVector* FieldVecPtr=new FieldVector();
        _macro.BranchFlux[n]=FieldVecPtr;
        for(int m=0;m<modeCount;m++)
          {
            shared_ptr<Field> modeField(new Field("mode"));
            VT3Ptr qptr(new VectorT3Array(numcells));
            VectorT3Array& q(*qptr);
            q.zero();
            modeField->addArray(cells,qptr);
            FieldVecPtr->push_back(modeField);

            for(int c=0;c<numcells;c++)
              {
                for(int k=0;k<numK;k++)
                  {
                    Tmode& mode=kspace.getkvol(k).getmode(m);
                    T dk3=kspace.getkvol(k).getdk3();
                    const int index=mode.getIndex()-1;
                    q[c]+=mode.getv()*(dk3/DK3)*kspace.gete(c,index)*eVtoJoule;
                    Q[c]+=mode.getv()*(dk3/DK3)*kspace.gete(c,index)*eVtoJoule;
                  }

              }
            for(int i=0;i<q.getLength();i++)
              q[i]*=DK3;
          }
        for(int i=0;i<Q.getLength();i++)
          Q[i]*=DK3;
      }
  }

template<class T >

void COMETModel< T >::calcModeTemps ( )

inline

Definition at line 3685 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, PhononMacro::BranchTemperatures, Kspace< T >::calcModeTemp(), Mesh::getCells(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::gete(), pmode< T >::getIndex(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), PhononMacro::temperature, and Array< T >::zero().

  {
    const int numMeshes=_meshes.size();
    for (int n=0;n<numMeshes;n++)
       {
         Mesh& mesh=*_meshes[n];
         if(_MeshKspaceMap[n]==-1)
           throw CException("Have not set the Kspace for this Mesh!!");
         Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
         const int numK=kspace.getlength();
         const StorageSite& cells=mesh.getCells();
         const int numcells=cells.getCount();
         FieldVector& FieldVec=*_macro.BranchTemperatures[n];
         const int modeCount=FieldVec.size();
         TArray eSum(numcells);
         const TArray& TL=dynamic_cast<const TArray&>(_macro.temperature[cells]);
         
         for(int m=0;m<modeCount;m++)
           {
             eSum.zero();
             Field& modeField=*FieldVec[m];
             TArray& modeTemp=dynamic_cast<TArray&>(modeField[cells]);
             for(int c=0;c<numcells;c++)
               {
                 for(int k=0;k<numK;k++)
                   {
                     T dk3=kspace.getkvol(k).getdk3();
                     Tmode& mode=kspace.getkvol(k).getmode(m);
                     const int index=mode.getIndex()-1;
                     eSum[c]+=kspace.gete(c,index)*dk3;
                   }
               }
             for(int c=0;c<numcells;c++)
               modeTemp[c]=kspace.calcModeTemp(TL[c],eSum[c],m);
           }

       }
  }

template<class T >

void COMETModel< T >::callCOMETBoundaryConditions ( )

inline

Definition at line 2426 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_bcMap, COMETModel< T >::_dsfPtr, COMETModel< T >::_faceReflectionArrayMap, COMETModel< T >::_geomFields, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_quadrature, COMETBoundaryConditions< X, Diag, OffDiag >::applyNSInterfaceBC(), COMETBoundaryConditions< X, Diag, OffDiag >::applyPressureInletBC(), COMETBoundaryConditions< X, Diag, OffDiag >::applyPressureOutletBC(), COMETBoundaryConditions< X, Diag, OffDiag >::applyRealWallBC(), COMETBoundaryConditions< X, Diag, OffDiag >::applyZeroGradientBC(), COMETBC< T >::bcType, Mesh::getBoundaryFaceGroups(), Mesh::getInterfaceGroups(), FloatVarDict< T >::getVal(), FaceGroup::groupType, FaceGroup::id, and FaceGroup::site.

Referenced by COMETModel< T >::advance(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

  { 
    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 COMETBC<T>& bc = *_bcMap[fg.id];
            COMETBoundaryConditions<T,T,T> cbc(faces, mesh,_geomFields,_quadrature,_macroFields,_dsfPtr);
            FloatValEvaluator<VectorT3> bVelocity(bc.getVal("specifiedXVelocity"),
                                                  bc.getVal("specifiedYVelocity"),
                                                  bc.getVal("specifiedZVelocity"),
                                                  faces);
            FloatValEvaluator<T> accomCoeff(bc.getVal("accommodationCoefficient"),faces);
            FloatValEvaluator<T> bTemperature(bc.getVal("specifiedTemperature"),faces);
            FloatValEvaluator<T> bPressure(bc.getVal("specifiedPressure"),faces);
            if(bc.bcType=="PressureInletBC")
              {
                cbc.applyPressureInletBC(bTemperature,bPressure);
              } 
            else if(bc.bcType=="PressureOutletBC")
              {
                cbc.applyPressureOutletBC(bTemperature,bPressure);
              }
            else if (bc.bcType == "RealWallBC")
              {
                //kbc.applyRealWallBC(bVelocity,bTemperature,accomCoeff);
                map<int, vector<int> >::iterator pos = _faceReflectionArrayMap.find(fg.id);
                const vector<int>& vecReflection=(*pos).second;
                cbc.applyRealWallBC(bVelocity,bTemperature,accomCoeff,vecReflection);
              }
            /*
              else if(bc.bcType=="SymmetryBC")
              {
                //kbc.applySpecularWallBC(); //old boundary works only for cartesian-type quadrature
                map<int, vector<int> >::iterator pos = _faceReflectionArrayMap.find(fg.id);
                const vector<int>& vecReflection=(*pos).second;
                cbc.applySpecularWallBC(vecReflection);
              }
            */ 
            else if(bc.bcType=="ZeroGradBC")
              {
                cbc.applyZeroGradientBC();
              }
          }
        foreach(const FaceGroupPtr igPtr, mesh.getInterfaceGroups())
          {
            
            const FaceGroup& ig = *igPtr;
            const StorageSite& faces = ig.site;
            //const int nFaces = faces.getCount();
            
            
            COMETBoundaryConditions<T,T,T> cbc(faces, mesh,_geomFields,_quadrature,_macroFields,_dsfPtr); 
            if(ig.groupType=="NSinterface")
              {
                cbc.applyNSInterfaceBC();//bTemperature,bPressure,bVelocity,bStress);
              } 
          }
      }//end of loop through meshes
  }

template<class T >

void COMETModel< T >::coarsenInterfaceCells ( COMETIC< T > &  ic, IntArray &  coarseCounts, GeomFields &  inGeomFields, const MeshList &  inMeshes  )

inline

Definition at line 2509 of file phononbase/COMETModel.h.

References COMETModel< T >::_BFaces, COMETModel< T >::_level, GeomFields::areaMag, COMETIC< T >::FgID0, COMETIC< T >::FgID1, GeomFields::fineToCoarse, Mesh::getAllFaceCells(), Mesh::getCellCells(), Mesh::getCellFaces(), Mesh::getCells(), StorageSite::getCommonMap(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getFaceCells(), Mesh::getFaceGroup(), Mesh::getFaces(), StorageSite::getSelfCount(), CRConnectivity::getTranspose(), COMETIC< T >::MeshID0, COMETIC< T >::MeshID1, CRConnectivity::multiply(), FaceGroup::site, and Array< T >::zero().

Referenced by COMETModel< T >::MakeInteriorCoarseMesh().

  {
    const int Mid0=ic.MeshID0;
    const int Mid1=ic.MeshID1;
    const int Fid0=ic.FgID0;
    const int Fid1=ic.FgID1;
    const Mesh& mesh0=*inMeshes[Mid0];
    const Mesh& mesh1=*inMeshes[Mid1];
    const StorageSite& faces0=mesh0.getFaceGroup(Fid0).site;
    const StorageSite& faces1=mesh1.getFaceGroup(Fid1).site;
    const StorageSite& cells0=mesh0.getCells();
    const StorageSite& cells1=mesh1.getCells();
    const StorageSite& globFaces0=mesh0.getFaces();
    const StorageSite::CommonMap& ComMap = faces0.getCommonMap();
    const IntArray& common01=*(ComMap.find(&faces1)->second);
    const CRConnectivity& faceCells0=mesh0.getFaceCells(faces0);
    const CRConnectivity& faceCells1=mesh1.getFaceCells(faces1);
    const CRConnectivity& cellCells0=mesh0.getCellCells();
    const CRConnectivity& cellCells1=mesh1.getCellCells();
    const CRConnectivity& globFaceCells0=mesh0.getAllFaceCells();
    const CRConnectivity& globCellFaces0=mesh0.getCellFaces();
    const int inFaceCount=faces0.getCount();
    Field& areaMagField=inGeomFields.areaMag;
    const TArray& areaMagArray0=dynamic_cast<const TArray&>(areaMagField[globFaces0]);
    const BCfaceArray& inBCfArray0=*(_BFaces[Mid0]);

    const CRPtr cellFaces0Ptr=faceCells0.getTranspose();
    const CRConnectivity& cellFaces0=*cellFaces0Ptr;
    const CRPtr cellsIntGhost0Ptr=cellFaces0.multiply(faceCells0,true);
    const CRConnectivity& cellsIntGhost0=*cellsIntGhost0Ptr;

    IntArray CoarseFineCount(cells0.getCount());
    CoarseFineCount.zero();

    IntArray& f2c0=dynamic_cast<IntArray&>(inGeomFields.fineToCoarse[cells0]);
    IntArray& f2c1=dynamic_cast<IntArray&>(inGeomFields.fineToCoarse[cells1]);
    int& count0=coarseCounts[Mid0];
    int& count1=coarseCounts[Mid1];

    //const VectorT3Array& cpos0=dynamic_cast<const VectorT3Array&>(inGeomFields.coordinate[cells0]);
    //const VectorT3Array& cpos1=dynamic_cast<const VectorT3Array&>(inGeomFields.coordinate[cells1]);
    
    //agglomerate mesh0 first
    int pairWith;

    if(_level>=0)
      {
        for(int f=0;f<inFaceCount;f++)
          {
            const int c=faceCells0(f,0);
            const int cCoarse=CoarseFineCount[c];
            if(f2c0[c]<0 || cCoarse<4) //dont bother if im already paired
              {
                //loop through all neighbors to find pairing
                const int neibCount=cellCells0.getCount(c);
                pairWith=-2;
                T maxArea=0.;
                int c2;
                for(int neib=0;neib<neibCount;neib++)
                  {
                    const int fglob=globCellFaces0(c,neib);
                    
                    if(inBCfArray0[fglob]==0)  //not a boundary face
                      {
                        if(c==globFaceCells0(fglob,1))
                          c2=globFaceCells0(fglob,0);
                        else
                          c2=globFaceCells0(fglob,1);
                        
                        int c2Coarse=f2c0[c2];
                        
                        if(_level==0)
                          {
                            if(c2Coarse==-1)// || CoarseFineCount[c2Coarse]<5)  //not already paired
                              {
                                if(areaMagArray0[fglob]>maxArea)
                                  {
                                    pairWith=c2;
                                    maxArea=areaMagArray0[fglob];
                                    if(cellsIntGhost0.getCount(c2)>0)  //pick first interface cell
                                      break;
                                  }
                              }
                          }
                        else
                          {
                            if(c2Coarse==-1)
                              {
                                if(areaMagArray0[fglob]>maxArea)
                                  {
                                    pairWith=c2;
                                    maxArea=areaMagArray0[fglob];
                                    if(cellsIntGhost0.getCount(c2)>0)  //pick first interface cell
                                      break;
                                  }
                              }
                          }

                      }
                  }
                
                if(pairWith>=0)
                  {
                    int c2Coarse=f2c0[pairWith];
                    if(c2Coarse==-1 && f2c0[c]==-1)
                      {
                        f2c0[pairWith]=count0;
                        f2c0[c]=count0;
                        CoarseFineCount[count0]++;
                        count0++;
                      }
                    else if(f2c0[c]==-1 && c2Coarse>=0)
                      f2c0[c]=c2Coarse;/*
                    else if(f2c0[c]!=-1 && c2Coarse==-1)
                      f2c0[pairWith]=f2c0[c];
                       */
                  }
              }
          }
      }
    else
      {
        for(int f=0;f<inFaceCount;f++)
          {
            const int c=faceCells0(f,0);
            if(f2c0[c]<0) //dont bother if im already paired
              {
                //loop through all neighbors to find pairing
                const int neibCount=cellCells0.getCount(c);
                pairWith=-1;
                T maxArea=0.;
                int c2;
                for(int neib=0;neib<neibCount;neib++)
                  {
                    const int fglob=globCellFaces0(c,neib);
                    
                    if(inBCfArray0[fglob]==0)  //not a boundary face
                      {
                        if(c==globFaceCells0(fglob,1))
                          c2=globFaceCells0(fglob,0);
                        else
                          c2=globFaceCells0(fglob,1);
                        
                        if(f2c0[c2]==-1)  //not already paired
                          {
                            if(areaMagArray0[fglob]>maxArea)
                              {
                                pairWith=c2;
                                maxArea=areaMagArray0[fglob];
                              }
                          }

                      }
                  }
                
                if(pairWith!=-1)
                  {
                    f2c0[pairWith]=count0;
                    f2c0[c]=count0;
                    count0++;
                  }
              }
          }
      }

    StorageSite preCoarse0(count0);
    CRPtr preCoarseToFineCells0=CRPtr(new CRConnectivity(preCoarse0,cells0));
    preCoarseToFineCells0->initCount();

    for(int c=0;c<cells0.getSelfCount();c++)
      if(f2c0[c]!=-1)
        preCoarseToFineCells0->addCount(f2c0[c],1);


    preCoarseToFineCells0->finishCount();

    for(int c=0;c<cells0.getSelfCount();c++)
      if(f2c0[c]!=-1)
        preCoarseToFineCells0->add(f2c0[c],c);

    preCoarseToFineCells0->finishAdd();

    //now use mesh0 pairing to pair mesh1
    for(int f=0;f<inFaceCount;f++)
      {
        const int f1=common01[f];
        //const int c01ghost=faceCells1(f1,1);
        const int c01=faceCells1(f1,0);
        const int c00=faceCells0(f,0);
        if(f2c0[c00]>-1) //dont bother if im already paired, mesh0 must be paired
          {
            //const int neibCount0=cellCells0.getCount(c00);
            const int coarseC00=f2c0[c00];
            const int cC00fineCnt=preCoarseToFineCells0->getCount(coarseC00);
            
            for(int cC00fine=0;cC00fine<cC00fineCnt;cC00fine++)   //who is mesh0 paired with
              {
                //const int c10=cellCells0(c00,neib0);
                const int fineCell=(*preCoarseToFineCells0)(coarseC00,cC00fine);
                if(fineCell!=c00)//(f2c0[c00]==f2c0[c10])
                  {
                    const int c10gNeibs=cellsIntGhost0.getCount(fineCell);  //cell is on an interface
                    for(int c10ghost=0;c10ghost<c10gNeibs;c10ghost++)
                      {
                        const int c10g=cellsIntGhost0(fineCell,c10ghost);
                        const int f10=cellFaces0(c10g,0);
                        const int f11=common01[f10];
                        //const int c11ghost=faceCells1(f11,1);
                        const int c11=faceCells1(f11,0);
                        const int neibCount1=cellCells1.getCount(c01);
                        bool isNeib(false);
                        for(int c01neibs=0;c01neibs<neibCount1;c01neibs++)
                          {
                            if(cellCells1(c01,c01neibs)==c11)
                              {
                                isNeib=true;
                                break;
                              }
                          }

                        if(isNeib)  //direct neighbor
                          {
                            if(f2c1[c11]>-1 && f2c1[c01]<0)  //other guy paired, im not
                              f2c1[c01]=f2c1[c11];
                            else if(f2c1[c01]>-1 && f2c1[c11]<0)  //im paired, other guy's not
                              f2c1[c11]=f2c1[c01];
                            else if(f2c1[c11]<0 && f2c1[c01]<0)  //both not paired
                              {
                                f2c1[c11]=count1;
                                f2c1[c01]=count1;
                                count1++;
                              }
                          }
                        else if(_level<-1)   //check for indirect neighbors
                          {
                            const int c11neibCnt=cellCells1.getCount(c11);
                            int middleMan=-1;
                            for(int c11nb=0;c11nb<c11neibCnt;c11nb++)
                              {
                                const int c11neib=cellCells1(c11,c11nb);
                                for(int c01neibs=0;c01neibs<neibCount1;c01neibs++)
                                  {
                                    if(cellCells1(c01,c01neibs)==c11neib)
                                      {
                                        middleMan=c11neib;
                                        break;
                                      }
                                  }
                              }
                            if(middleMan!=-1)
                              {
                                if(f2c1[middleMan]==-1)
                                  {
                                    if(f2c1[c11]<0 && f2c1[c01]<0)  //both not paired
                                      {
                                        f2c1[c11]=count1;
                                        f2c1[c01]=count1;
                                        f2c1[middleMan]=count1;
                                        count1++;
                                      }
                                    else if(f2c1[c11]>-1 && f2c1[c01]<0)  //other guy paired, im not
                                      {
                                        f2c1[c01]=f2c1[c11];
                                        f2c1[middleMan]=f2c1[c11];
                                      }
                                    else if(f2c1[c01]>-1 && f2c1[c11]<0)  //im paired, other guy's not
                                      {
                                        f2c1[c11]=f2c1[c01];
                                        f2c1[middleMan]=f2c1[c01];
                                      }
                                  }
                              }
                          }

                      }
                  }
              }

            /*
            if(f2c1[c01]==-1)  //still hasnt been paired -- means mesh0 cell wasnt paired.
              {
                f2c1[c01]=count1;
                count1++;
              }*/
            
          }
      }
    
  }

template<class T >

int COMETModel< T >::coarsenInterior ( const int  m, const Mesh &  mesh, GeomFields &  inGeomFields, int &  coarseCount  )

inline

Definition at line 2249 of file phononbase/COMETModel.h.

References COMETModel< T >::_BFaces, GeomFields::areaMag, GeomFields::fineToCoarse, Mesh::getCellFaces(), Mesh::getCells(), CRConnectivity::getCount(), Mesh::getFaceCells(), Mesh::getFaces(), and StorageSite::getSelfCount().

Referenced by COMETModel< T >::MakeInteriorCoarseMesh().

  {
    const StorageSite& inCells=mesh.getCells();
    const StorageSite& inFaces=mesh.getFaces();
    const int inCellCount=inCells.getSelfCount();
    const CRConnectivity& inCellinFaces=mesh.getCellFaces();
    const CRConnectivity& inFaceinCells=mesh.getFaceCells(inFaces);
    Field& areaMagField=inGeomFields.areaMag;
    const TArray& areaMagArray=dynamic_cast<const TArray&>(areaMagField[inFaces]);
    const BCfaceArray& inBCfArray=*(_BFaces[m]);

    IntArray& FineToCoarse=dynamic_cast<IntArray&>(inGeomFields.fineToCoarse[inCells]);

    //first sweep to make initial pairing
    int pairWith;
    for(int c=0;c<inCellCount;c++)
      {
        if(FineToCoarse[c]<0) //dont bother if im already paired
          {
            //loop through all neighbors to find pairing
            const int neibCount=inCellinFaces.getCount(c);
            pairWith=-1;
            T maxArea=0.;
            int c2;
            for(int neib=0;neib<neibCount;neib++)
              {
                const int f=inCellinFaces(c,neib);
                    
                if(inBCfArray[f]==0)  //not a boundary face
                  {
                    if(c==inFaceinCells(f,1))
                      c2=inFaceinCells(f,0);
                    else
                      c2=inFaceinCells(f,1);
                        
                    if(FineToCoarse[c2]==-1)  //not already paired
                      {
                        if(areaMagArray[f]>maxArea)
                          {
                            pairWith=c2;
                            maxArea=areaMagArray[f];
                          }
                      }

                  }
              }
                
            if(pairWith!=-1)
              {
                FineToCoarse[c]=coarseCount;
                FineToCoarse[pairWith]=coarseCount;
                coarseCount++;
              }
          }
      }
        
    //second sweep to group stragglers, or group with self
    for(int c=0;c<inCellCount;c++)
      {
        if(FineToCoarse[c]==-1)
          {
            const int neibCount=inCellinFaces.getCount(c);
            T maxArea=0.;
            int c2,c2perm;
            pairWith=-2;
                
            for(int neib=0;neib<neibCount;neib++)
              {
                const int f=inCellinFaces(c,neib);
                    
                if(inBCfArray[f]==0)  //not a boundary face
                  {
                    if(c==inFaceinCells(f,1))
                      c2=inFaceinCells(f,0);
                    else
                      c2=inFaceinCells(f,1);
                        
                    if(areaMagArray[f]>maxArea)
                      {
                        pairWith=FineToCoarse[c2]; //coarse level cell
                        c2perm=c2;                 //fine level cell
                        maxArea=areaMagArray[f];
                      }
                  }
              }
                
            if(pairWith==-2)  //could not find suitable pair
              {
                FineToCoarse[c]=coarseCount;
                coarseCount++;
              }
            else  //found cell to pair with
              {
                if(FineToCoarse[c2perm]==-1)
                  {
                    FineToCoarse[c]=coarseCount;
                    FineToCoarse[c2perm]=coarseCount;
                    coarseCount++;
                  }
                else
                  FineToCoarse[c]=FineToCoarse[c2perm];
              }
          }         
      }
    return coarseCount;
  }

template<class T >

void COMETModel< T >::ComputeCoarseMacroparameters ( )

inline

Definition at line 1353 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields, Model::_meshes, Field::addArray(), Mesh::getCells(), StorageSite::getCount(), MacroFields::velocityFASCorrection, MacroFields::velocityInjected, and MacroFields::velocityResidual.

Referenced by COMETModel< T >::MakeIBCoarseModel().

  {
    const int numMeshes = _meshes.size();
    const T zero(0.0);
    for (int n=0; n<numMeshes; n++)
      {

        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();  //

        VectorT3 zeroVelocity;
        zeroVelocity[0] = zero;
        zeroVelocity[1] = zero;
        zeroVelocity[2] = zero;

        shared_ptr<VectorT3Array> vRCell(new VectorT3Array(nCells));
        *vRCell = zeroVelocity;
        _macroFields.velocityResidual.addArray(cells,vRCell);

        shared_ptr<VectorT3Array> vICell(new VectorT3Array(nCells));
        *vICell = zeroVelocity;
        _macroFields.velocityInjected.addArray(cells,vICell);

        shared_ptr<VectorT3Array> vFCell(new VectorT3Array(nCells));
        *vFCell = zeroVelocity;
        _macroFields.velocityFASCorrection.addArray(cells,vFCell);

        /*
        VectorT3Array& vR = dynamic_cast<VectorT3Array&>(_macroFields.velocityResidual[cells]);
        VectorT3Array& vI = dynamic_cast<VectorT3Array&>(_macroFields.velocityInjected[cells]);
        VectorT3Array& vF = dynamic_cast<VectorT3Array&>(_macroFields.velocityFASCorrection[cells]);

        for(int c=0; c<nCells;c++)
          {
            vR[c][0]=0.0;
            vR[c][1]=0.0;
            vR[c][2]=0.0;

            vI[c][0]=0.0;
            vI[c][1]=0.0;
            vI[c][2]=0.0;

            vF[c][0]=0.0;
            vF[c][1]=0.0;
            vF[c][2]=0.0;
          }
        */

      }// end of loop over nmeshes
    //fclose(pFile);
  }

template<class T >

void COMETModel< T >::ComputeCollisionfrequency ( )

inline

Definition at line 1486 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, MacroFields::collisionFrequency, MacroFields::density, Mesh::getCells(), StorageSite::getCount(), MacroFields::temperature, and MacroFields::viscosity.

Referenced by COMETModel< T >::COMETModel(), COMETModel< T >::cycle(), COMETModel< T >::MakeIBCoarseModel(), and COMETModel< T >::smooth().

                                    {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        
        const T rho_init=_options["rho_init"]; 
        const T T_init= _options["T_init"]; 
        const T mu_w= _options["mu_w"];
        const T Tmuref= _options["Tmuref"];
        const T muref= _options["muref"];
        const T R=8314.0/_options["molecularWeight"];
        const T nondim_length=_options["nonDimLt"];

        const T mu0=rho_init*R* T_init*nondim_length/pow(2*R* T_init,0.5);  
        
          
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();
        
        TArray& density = dynamic_cast<TArray&>(_macroFields.density[cells]);
        TArray& viscosity = dynamic_cast<TArray&>(_macroFields.viscosity[cells]);
        TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[cells]);

        TArray& collisionFrequency = dynamic_cast<TArray&>(_macroFields.collisionFrequency[cells]);
        for(int c=0; c<nCells;c++)
          {
            viscosity[c]= muref*pow(temperature[c]*T_init/ Tmuref,mu_w); // viscosity power law
            collisionFrequency[c]=density[c]*temperature[c]/viscosity[c]*mu0;
          }
        
        if(_options.fgamma==2){
          for(int c=0; c<nCells;c++)
            collisionFrequency[c]=_options.Prandtl*collisionFrequency[c];
        }
        
      }
  }

template<class T >

void COMETModel< T >::ComputeCOMETMacroparameters ( )

inline

Definition at line 1235 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_quadrature, MacroFields::density, Mesh::getCells(), StorageSite::getCount(), MacroFields::pressure, MacroFields::Stress, MacroFields::temperature, and MacroFields::velocity.

Referenced by COMETModel< T >::cycle(), and COMETModel< T >::smooth().

  {  
    //FILE * pFile;
    //pFile = fopen("distfun_mf.txt","w");
    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.getCount();  //


        TArray& density = dynamic_cast<TArray&>(_macroFields.density[cells]);
        TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[cells]);
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        TArray& pressure = dynamic_cast<TArray&>(_macroFields.pressure[cells]);
        const int N123 = _quadrature.getDirCount(); 

        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);

        VectorT6Array& stress = dynamic_cast<VectorT6Array&>(_macroFields.Stress[cells]);

        //initialize density,velocity,temperature to zero    
        for(int c=0; c<nCells;c++)
          {
            density[c]=0.0;
            temperature[c]=0.0;   
            stress[c][0]=0.0;stress[c][1]=0.0;stress[c][2]=0.0;
            stress[c][3]=0.0;stress[c][4]=0.0;stress[c][5]=0.0;

          }


        for(int j=0;j<N123;j++){
          
          Field& fnd = *_dsfPtr.dsf[j];
          const TArray& f = dynamic_cast<const TArray&>(fnd[cells]);
          
          //fprintf(pFile,"%d %12.6f %E %E %E %E \n",j,dcxyz[j],cx[j],cy[j],f[80],density[80]+dcxyz[j]*f[80]);
          
          for(int c=0; c<nCells;c++){
            density[c] = density[c]+wts[j]*f[c];
            temperature[c]= temperature[c]+(pow(cx[j],2.0)+pow(cy[j],2.0)
                                            +pow(cz[j],2.0))*f[c]*wts[j];
           
          }
          
        }



        for(int c=0; c<nCells;c++){
          temperature[c]=temperature[c]-(pow(v[c][0],2.0)
                                         +pow(v[c][1],2.0)
                                         +pow(v[c][2],2.0))*density[c];
          temperature[c]=temperature[c]/(1.5*density[c]);  
          pressure[c]=density[c]*temperature[c];
        }

        //Find Pxx,Pyy,Pzz,Pxy,Pyz,Pzx, etc in field

        for(int j=0;j<N123;j++){          
          Field& fnd = *_dsfPtr.dsf[j];
          const TArray& f = dynamic_cast<const TArray&>(fnd[cells]);      
          for(int c=0; c<nCells;c++){
            stress[c][0] +=pow((cx[j]-v[c][0]),2.0)*f[c]*wts[j];
            stress[c][1] +=pow((cy[j]-v[c][1]),2.0)*f[c]*wts[j];
            stress[c][2] +=pow((cz[j]-v[c][2]),2.0)*f[c]*wts[j];
            stress[c][3] +=(cx[j]-v[c][0])*(cy[j]-v[c][1])*f[c]*wts[j];
            stress[c][4] +=(cy[j]-v[c][1])*(cz[j]-v[c][2])*f[c]*wts[j];
            stress[c][5] +=(cz[j]-v[c][2])*(cx[j]-v[c][0])*f[c]*wts[j];
            
          }}


      }// end of loop over nmeshes
    //fclose(pFile);
  }

template<class T >

void COMETModel< T >::ComputeFineMacroparameters ( )

inline

Definition at line 1318 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields, Model::_meshes, Field::addArray(), Mesh::getCells(), StorageSite::getCount(), and MacroFields::velocityResidual.

Referenced by COMETModel< T >::COMETModel().

  {  
    const int numMeshes = _meshes.size();
    const T zero(0.0);
    for (int n=0; n<numMeshes; n++)
      {

        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();  //

        VectorT3 zeroVelocity;
        zeroVelocity[0] = zero;
        zeroVelocity[1] = zero;
        zeroVelocity[2] = zero;

        shared_ptr<VectorT3Array> vRCell(new VectorT3Array(nCells));
        *vRCell = zeroVelocity;
        _macroFields.velocityResidual.addArray(cells,vRCell);

        /*
        VectorT3Array& vR = dynamic_cast<VectorT3Array&>(_macroFields.velocityResidual[cells]);
        
        for(int c=0; c<nCells;c++)
          {
            vR[c][0]=0.0;
            vR[c][1]=0.0;
            vR[c][2]=0.0;
          }
        */

      }// end of loop over nmeshes
    //fclose(pFile);
  }

template<class T >

void COMETModel< T >::computeIBFaceDsf ( const StorageSite &  solidFaces, const int  method, const int  RelaxDistribution = 0  )

inline

Definition at line 3473 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_finestGeomFields, COMETModel< T >::_finestMeshes, COMETModel< T >::_geomFields, GeomFields::_interpolationMatrices, COMETModel< T >::_level, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, Field::addArray(), MacroFields::collisionFrequency, GeomFields::coordinate, MacroFields::density, GeomFields::finestToCoarse, Mesh::getAllFaceCells(), Mesh::getCells(), CRConnectivity::getCol(), Mesh::getConnectivity(), StorageSite::getCount(), StorageSite::getCountLevel1(), Array< T >::getData(), Mesh::getFaces(), Mesh::getIBFaceList(), Mesh::getIBFaces(), CRConnectivity::getRow(), GeomFields::ibType, Mesh::isShell(), sqrt(), MacroFields::temperature, MacroFields::velocity, MacroFields::viscosity, and Array< T >::zero().

Referenced by COMETModel< T >::cycle(), and COMETModel< T >::smooth().

  {
    typedef CRMatrixTranspose<T,T,T> IMatrix;
    typedef CRMatrixTranspose<T,VectorT3,VectorT3> IMatrixV3;
    if (method==1){
    const int numMeshes = _meshes.size();
    const int numFields= _quadrature.getDirCount(); 
    for (int direction = 0; direction < numFields; direction++)
      {
        Field& fnd = *_dsfPtr.dsf[direction];
        const TArray& pV =
          dynamic_cast<const TArray&>(fnd[solidFaces]);
 #ifdef FVM_PARALLEL
        MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE,pV.getData(),solidFaces.getCount() , MPI::DOUBLE, MPI::SUM); 
 #endif 

        for (int n=0; n<numMeshes; n++)
          {         
            const Mesh& mesh = *_meshes[n];
            const Mesh& fMesh = *_finestMeshes[n];
            if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
              
              const StorageSite& cells = mesh.getCells();
              const StorageSite& fCells = fMesh.getCells();
              const StorageSite& ibFaces = mesh.getIBFaces();
              const StorageSite& fIbFaces = fMesh.getIBFaces();
              
              GeomFields::SSPair key1(&fIbFaces,&fCells);
              const IMatrix& mIC =
                dynamic_cast<const IMatrix&>
                (*_finestGeomFields._interpolationMatrices[key1]);
              
              IMatrix mICV(mIC);
           

           GeomFields::SSPair key2(&fIbFaces,&solidFaces);
           const IMatrix& mIP =
             dynamic_cast<const IMatrix&>
             (*_finestGeomFields._interpolationMatrices[key2]);

           IMatrix mIPV(mIP);
           

           shared_ptr<TArray> ibV(new TArray(ibFaces.getCount()));
 
           Field& FinestToCoarseField=_finestGeomFields.finestToCoarse;
           const Array<Vector<int,25> >& FinestToCoarse=dynamic_cast<const Array<Vector<int,25> >&>(FinestToCoarseField[fCells]);
      
           const TArray& cV =
            dynamic_cast<const TArray&>(fnd[cells]);
           TArray cFV(fCells.getCountLevel1());
           for(int c=0;c<fCells.getCountLevel1();c++)
             cFV[c]=cV[FinestToCoarse[c][_level]];

           ibV->zero();

           mICV.multiplyAndAdd(*ibV,cFV);
           mIPV.multiplyAndAdd(*ibV,pV);

#if 0
        ofstream debugFile;
        stringstream ss(stringstream::in | stringstream::out);
        ss <<  MPI::COMM_WORLD.Get_rank();
        string  fname1 = "IBVelocity_proc" +  ss.str() + ".dat";
        debugFile.open(fname1.c_str());
        
        //debug use
        const Array<int>& ibFaceList = mesh.getIBFaceList();
        const StorageSite& faces = mesh.getFaces();
        const VectorT3Array& faceCentroid = 
          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[faces]);
        const double angV = 1.0;
        VectorT3 center;
        center[0]=0.;
        center[1]=0.;
        center[2]=0.;   

        for(int f=0; f<ibFaces.getCount();f++){
          int fID = ibFaceList[f];
          debugFile << "f=" <<   f << setw(10) <<  "   fID = " <<  fID << "  faceCentroid = " << faceCentroid[fID] << " ibV = " << (*ibV)[f] << endl;
        }
          
         debugFile.close();
#endif

          fnd.addArray(ibFaces,ibV);     
            }
          }
      }
    /*
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){

          const StorageSite& cells = mesh.getCells();
          const StorageSite& cells = mesh.getCells();
          const StorageSite& ibFaces = mesh.getIBFaces();
          const StorageSite& fIbFaces = fMesh.getIBFaces();
        
          GeomFields::SSPair key1(&fIbFaces,&fCells);
          const IMatrix& mIC =
            dynamic_cast<const IMatrix&>
            (*_finestGeomFields._interpolationMatrices[key1]);
              
          IMatrixV3 mICV3(mIC);  

          GeomFields::SSPair key2(&fIbFaces,&solidFaces);
          const IMatrix& mIP =
            dynamic_cast<const IMatrix&>
            (*_finestGeomFields._interpolationMatrices[key2]);

          IMatrixV3 mIPV3(mIP);    

          shared_ptr<VectorT3Array> ibVvel(new VectorT3Array(ibFaces.getCount()));
          

          const VectorT3Array& cVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[cells]);
          const VectorT3Array& sVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);
          
          ibVvel->zero(); 

          //velocity interpolation (cells+solidfaces) 
          mICV3.multiplyAndAdd(*ibVvel,cVel);
          mIPV3.multiplyAndAdd(*ibVvel,sVel);
          _macroFields.velocity.addArray(ibFaces,ibVvel);


        }
      }
    */
    }
    
    if (method==2){
      const int numMeshes = _meshes.size();
        const int nSolidFaces = solidFaces.getCount();
 
        shared_ptr<TArray> muSolid(new TArray(nSolidFaces));
        *muSolid =0;
        _macroFields.viscosity.addArray(solidFaces,muSolid);

        shared_ptr<TArray> nueSolid(new TArray(nSolidFaces));
        *nueSolid =0;
        _macroFields.collisionFrequency.addArray(solidFaces,nueSolid);

        const T rho_init=_options["rho_init"]; 
        const T T_init= _options["T_init"]; 
        const T mu_w= _options["mu_w"];
        const T Tmuref= _options["Tmuref"];
        const T muref= _options["muref"];
        const T R=8314.0/_options["molecularWeight"];
        const T nondim_length=_options["nonDimLt"];

        const T mu0=rho_init*R* T_init*nondim_length/pow(2*R* T_init,0.5);  
        
        TArray& density = dynamic_cast<TArray&>(_macroFields.density[solidFaces]);
        TArray& viscosity = dynamic_cast<TArray&>(_macroFields.viscosity[solidFaces]);
        TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[solidFaces]);
        TArray& collisionFrequency = dynamic_cast<TArray&>(_macroFields.collisionFrequency[solidFaces]);

        for(int c=0; c<nSolidFaces;c++)
          {
            viscosity[c]= muref*pow(temperature[c]*T_init/ Tmuref,mu_w); // viscosity power law
            collisionFrequency[c]=density[c]*temperature[c]/viscosity[c]*mu0;
          }
        
        if(_options.fgamma==2){
          for(int c=0; c<nSolidFaces;c++)
            collisionFrequency[c]=_options.Prandtl*collisionFrequency[c];
        }
        
 


   for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        const Mesh& fMesh = *_finestMeshes[n];
        if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){

          const StorageSite& cells = mesh.getCells();
          const StorageSite& fCells = fMesh.getCells();
          const StorageSite& ibFaces = mesh.getIBFaces();
          const StorageSite& fIbFaces = fMesh.getIBFaces();        

          GeomFields::SSPair key1(&fIbFaces,&fCells);
          const IMatrix& mIC =
            dynamic_cast<const IMatrix&>
            (*_finestGeomFields._interpolationMatrices[key1]);
              
          IMatrix mICV(mIC);
          IMatrixV3 mICV3(mIC);  

          GeomFields::SSPair key2(&fIbFaces,&solidFaces);
          const IMatrix& mIP =
            dynamic_cast<const IMatrix&>
            (*_finestGeomFields._interpolationMatrices[key2]);

          IMatrix mIPV(mIP);
          IMatrixV3 mIPV3(mIP);    

          shared_ptr<TArray> ibVtemp(new TArray(ibFaces.getCount()));
          shared_ptr<TArray> ibVnue(new TArray(ibFaces.getCount()));
          shared_ptr<TArray> ibVdensity(new TArray(ibFaces.getCount()));
          shared_ptr<VectorT3Array> ibVvel(new VectorT3Array(ibFaces.getCount()));
          
          const TArray& cTemp  = 
            dynamic_cast<TArray&>(_macroFields.temperature[cells]);
          const VectorT3Array& cVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[cells]);
          const TArray& cDensity  = 
            dynamic_cast<TArray&>(_macroFields.density[cells]);
          const TArray& sDensity  = 
            dynamic_cast<TArray&>(_macroFields.density[solidFaces]);
          const TArray& cNue  = 
            dynamic_cast<TArray&>(_macroFields.collisionFrequency[cells]);
          const TArray& sNue  = 
            dynamic_cast<TArray&>(_macroFields.collisionFrequency[solidFaces]);
          const TArray& sTemp  = 
            dynamic_cast<TArray&>(_macroFields.temperature[solidFaces]);
          const VectorT3Array& sVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);
          
          ibVnue->zero(); 
          ibVtemp->zero();
          ibVvel->zero(); 
          ibVdensity->zero();


          Field& FinestToCoarseField=_finestGeomFields.finestToCoarse;
          const Array<Vector<int,25> >& FinestToCoarse=dynamic_cast<const Array<Vector<int,25> >&>(FinestToCoarseField[fCells]);

          TArray cFTemp(fCells.getCount());
          VectorT3Array cFVel(fCells.getCount());
          TArray cFDensity(fCells.getCount());
          TArray cFNue(fCells.getCount());

           for(int c=0;c<fCells.getCount();c++)
           {
               cFTemp[c]=cTemp[FinestToCoarse[c][_level]];
               cFVel[c]=cVel[FinestToCoarse[c][_level]];
               cFDensity[c]=cDensity[FinestToCoarse[c][_level]];
               cFNue[c]=cNue[FinestToCoarse[c][_level]];
           }

           //nue interpolation (cells)
          mICV.multiplyAndAdd(*ibVnue,cFNue);
          mIPV.multiplyAndAdd(*ibVnue,sNue);
          _macroFields.collisionFrequency.addArray(ibFaces,ibVnue);
          //temperature interpolation (cells+solidfaces)         
          mICV.multiplyAndAdd(*ibVtemp,cFTemp);
          mIPV.multiplyAndAdd(*ibVtemp,sTemp);
          _macroFields.temperature.addArray(ibFaces,ibVtemp);
          //density interpolation (cells+solidfaces)         
          mICV.multiplyAndAdd(*ibVdensity,cFDensity);
          mIPV.multiplyAndAdd(*ibVdensity,sDensity);
          _macroFields.density.addArray(ibFaces,ibVdensity);
          //velocity interpolation (cells+solidfaces) 
          mICV3.multiplyAndAdd(*ibVvel,cFVel);
          mIPV3.multiplyAndAdd(*ibVvel,sVel);
          _macroFields.velocity.addArray(ibFaces,ibVvel);


        }
      }

   const int f_out = 3;
   if (f_out ==1){
     //Step 2 Find fgamma using macroparameters
     const int numMeshes = _meshes.size();
      for (int n=0; n<numMeshes; n++)
        {
          const Mesh& mesh = *_meshes[n];
          if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
            const int numDirections = _quadrature.getDirCount();
            const StorageSite& ibFaces = mesh.getIBFaces();
            const int nibFaces=ibFaces.getCount();
            const double pi=_options.pi;
            const TArray& ibTemp  =
              dynamic_cast<TArray&>(_macroFields.temperature[ibFaces]);
            const VectorT3Array& ibVel =
              dynamic_cast<VectorT3Array&>(_macroFields.velocity[ibFaces]);
            const TArray& ibDensity  =
              dynamic_cast<TArray&>(_macroFields.density[ibFaces]);

            for (int j=0; j<numDirections; j++)
              {
                shared_ptr<TArray> ibFndPtrEqES(new TArray(nibFaces));
                TArray&  ibFndEqES= *ibFndPtrEqES;
                ibFndPtrEqES->zero();   
                Field& fndEqES = *_dsfEqPtrES.dsf[j];

                for (int i=0; i<nibFaces; i++)
                  {
                    const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
                    const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
                    const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
                    const T ibu = ibVel[i][0];
                    const T ibv = ibVel[i][1];
                    const T ibw = ibVel[i][2];
                    ibFndEqES[i]=ibDensity[i]/pow(pi*ibTemp[i],1.5)*exp(-(pow(cx[j]-ibu,2.0)+pow(cy[j]-ibv,2.0)+pow(cz[j]-ibw,2.0))/ibTemp[i]);
                  }
                fndEqES.addArray(ibFaces,ibFndPtrEqES);
              }
          }
        }
    }
    else if(f_out==2)
      {
        //Step 2 Find fgamma using interpolation (only ESBGK for now)
        for (int n=0; n<numMeshes; n++)
          {
            const int numFields= _quadrature.getDirCount();
            for (int direction = 0; direction < numFields; direction++)
          {
            Field& fndEqES = *_dsfEqPtrES.dsf[direction];
            const Mesh& mesh = *_meshes[n];
            if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){

              const StorageSite& cells = mesh.getCells();
              const StorageSite& ibFaces = mesh.getIBFaces();
        
              GeomFields::SSPair key1(&ibFaces,&cells);
              const IMatrix& mIC =
                dynamic_cast<const IMatrix&>
                (*_geomFields._interpolationMatrices[key1]);
              
              IMatrix mICV(mIC);

              GeomFields::SSPair key2(&ibFaces,&solidFaces);
              const IMatrix& mIP =
                dynamic_cast<const IMatrix&>
                (*_geomFields._interpolationMatrices[key2]);
              
              IMatrix mIPV(mIP);

              shared_ptr<TArray> ibVf(new TArray(ibFaces.getCount()));
          
              const TArray& cf =
                dynamic_cast<const TArray&>(fndEqES[cells]);
          
              ibVf->zero();
              
              //distribution function interpolation (cells)
              mICV.multiplyAndAdd(*ibVf,cf);
              fndEqES.addArray(ibFaces,ibVf);

            }
          }
          }
      }
       //Step3: Relax Distribution function from ibfaces to solid face
    for (int n=0; n<numMeshes; n++)
      {
        const int numDirections = _quadrature.getDirCount();
        for (int j=0; j<numDirections; j++)
            {
              Field& fnd = *_dsfPtr.dsf[j];
              TArray& dsf = dynamic_cast< TArray&>(fnd[solidFaces]);

#ifdef FVM_PARALLEL
              MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE,dsf.getData(),solidFaces.getCount() , MPI::DOUBLE, MPI::SUM);
#endif
              const Mesh& mesh = *_meshes[n];
              const Mesh& fMesh = *_finestMeshes[n];
              if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
                const StorageSite& ibFaces = mesh.getIBFaces();
                const StorageSite& fIbFaces = fMesh.getIBFaces();
                TArray& dsfIB = dynamic_cast< TArray&>(fnd[ibFaces]);
                Field& fndEqES = *_dsfEqPtrES.dsf[j];
                TArray& dsfEqES = dynamic_cast< TArray&>(fndEqES[ibFaces]);
                const StorageSite& faces = fMesh.getFaces();
                const StorageSite& cells = mesh.getCells();
                const CRConnectivity& faceCells = mesh.getAllFaceCells();
                const CRConnectivity& ibFacesTosolidFaces
                  = fMesh.getConnectivity(fIbFaces,solidFaces);
                const IntArray& ibFaceIndices = fMesh.getIBFaceList();
                const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
                const IntArray& sFCRow = ibFacesTosolidFaces.getRow();
                const IntArray& sFCCol = ibFacesTosolidFaces.getCol();
                const int nibFaces = ibFaces.getCount();
                const int nFaces = faces.getCount();
                const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
                const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
                const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
                VectorT3Array& v = dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);

                for(int f=0; f<nibFaces; f++)
                  {
                    dsfIB[f]=0.0;                                 
                    double distIBSolidInvSum(0.0);
                    for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                      {
                        const int c = sFCCol[nc];
                        const int faceIB= ibFaceIndices[f];
                        const VectorT3Array& solidFaceCentroid =
                          dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[solidFaces]);
                        const VectorT3Array& faceCentroid =
                          dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[faces]);
                              
                        double distIBSolid (0.0);
                        // based on distance - will be thought
                        distIBSolid = sqrt(pow((faceCentroid[faceIB][0]-solidFaceCentroid[c][0]),2)+
                                           pow((faceCentroid[faceIB][1]-solidFaceCentroid[c][1]),2)+
                                           pow((faceCentroid[faceIB][2]-solidFaceCentroid[c][2]),2));
                        distIBSolidInvSum += 1/pow(distIBSolid,RelaxDistribution);
                      }
                    for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                      {
                        const int c = sFCCol[nc];
                        const VectorT3Array& solidFaceCentroid =
                          dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[solidFaces]);
                        const VectorT3Array& faceCentroid =
                          dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[faces]);
                        const TArray& nue  =
                          dynamic_cast<TArray&>(_macroFields.collisionFrequency[ibFaces]);
                        const int faceIB= ibFaceIndices[f];
                        // const T coeff = iCoeffs[nc];
                        double time_to_wall (0.0);
                        double distIBSolid (0.0);
                        const T uwall = v[c][0];
                        const T vwall = v[c][1];
                        const T wwall = v[c][2];
                        // based on distance - will be thought
                        distIBSolid = sqrt(pow((faceCentroid[faceIB][0]-solidFaceCentroid[c][0]),2)+
                                           pow((faceCentroid[faceIB][1]-solidFaceCentroid[c][1]),2)+
                                           pow((faceCentroid[faceIB][2]-solidFaceCentroid[c][2]),2));
                        time_to_wall = -1*(pow(distIBSolid,2)/((cx[j]-uwall)*(faceCentroid[faceIB][0]-solidFaceCentroid[c][0])+(cy[j]-vwall)*(faceCentroid[faceIB][1]-solidFaceCentroid[c][1])+(cz[j]-wwall)*(faceCentroid[faceIB][2]-solidFaceCentroid[c][2])));
                        if(time_to_wall<0)
                          time_to_wall = 0;
              
                        dsfIB[f] += (dsfEqES[f]-(dsfEqES[f]-dsf[c])*exp(-time_to_wall*nue[f]))/(pow(distIBSolid,RelaxDistribution)*distIBSolidInvSum);

                      }

                  }
              }
            }
      }
    }
    if (method==3){
       const int numMeshes = _meshes.size();
      for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){

          const StorageSite& cells = mesh.getCells();
          const StorageSite& ibFaces = mesh.getIBFaces();
        
          GeomFields::SSPair key1(&ibFaces,&cells);
          const IMatrix& mIC =
            dynamic_cast<const IMatrix&>
            (*_geomFields._interpolationMatrices[key1]);
              
          IMatrixV3 mICV3(mIC);  

          GeomFields::SSPair key2(&ibFaces,&solidFaces);
          const IMatrix& mIP =
            dynamic_cast<const IMatrix&>
            (*_geomFields._interpolationMatrices[key2]);

          IMatrixV3 mIPV3(mIP);    

          shared_ptr<VectorT3Array> ibVvel(new VectorT3Array(ibFaces.getCount()));
          

          const VectorT3Array& cVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[cells]);
          const VectorT3Array& sVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);
          
          ibVvel->zero(); 

          //velocity interpolation (cells+solidfaces) 
          mICV3.multiplyAndAdd(*ibVvel,cVel);
          mIPV3.multiplyAndAdd(*ibVvel,sVel);
          _macroFields.velocity.addArray(ibFaces,ibVvel);


        }
      }
      const int nSolidFaces = solidFaces.getCount();
 
        shared_ptr<TArray> muSolid(new TArray(nSolidFaces));
        *muSolid =0;
        _macroFields.viscosity.addArray(solidFaces,muSolid);

        shared_ptr<TArray> nueSolid(new TArray(nSolidFaces));
        *nueSolid =0;
        _macroFields.collisionFrequency.addArray(solidFaces,nueSolid);

        const T rho_init=_options["rho_init"]; 
        const T T_init= _options["T_init"]; 
        const T mu_w= _options["mu_w"];
        const T Tmuref= _options["Tmuref"];
        const T muref= _options["muref"];
        const T R=8314.0/_options["molecularWeight"];
        const T nondim_length=_options["nonDimLt"];

        const T mu0=rho_init*R* T_init*nondim_length/pow(2*R* T_init,0.5);  
        
        TArray& density = dynamic_cast<TArray&>(_macroFields.density[solidFaces]);
        TArray& viscosity = dynamic_cast<TArray&>(_macroFields.viscosity[solidFaces]);
        TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[solidFaces]);
        TArray& collisionFrequency = dynamic_cast<TArray&>(_macroFields.collisionFrequency[solidFaces]);

        for(int c=0; c<nSolidFaces;c++)
          {
            viscosity[c]= muref*pow(temperature[c]*T_init/ Tmuref,mu_w); // viscosity power law
            collisionFrequency[c]=density[c]*temperature[c]/viscosity[c]*mu0;
          }
        
        if(_options.fgamma==2){
          for(int c=0; c<nSolidFaces;c++)
            collisionFrequency[c]=_options.Prandtl*collisionFrequency[c];
        }
        
        //Step 2 Find fgamma using interpolation (only ESBGK for now)
          const int numFields= _quadrature.getDirCount();
          for (int direction = 0; direction < numFields; direction++)
            {
              shared_ptr<TArray> ibVf(new TArray(solidFaces.getCount()));
              Field& fndEqES = *_dsfEqPtrES.dsf[direction];
              ibVf->zero();
              for (int n=0; n<numMeshes; n++)
                {
                  const Mesh& mesh = *_meshes[n];
                  if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){

                    const StorageSite& cells = mesh.getCells();
                    const StorageSite& ibFaces = mesh.getIBFaces();
        
                    GeomFields::SSPair key1(&solidFaces,&cells);
                    const IMatrix& mIC =
                      dynamic_cast<const IMatrix&>
                      (*_geomFields._interpolationMatrices[key1]);
              
                    IMatrix mICV(mIC);
 
                    const TArray& cf =
                      dynamic_cast<const TArray&>(fndEqES[cells]);
          
                    ibVf->zero();
              
                    //distribution function interpolation (cells)
                    mICV.multiplyAndAdd(*ibVf,cf);      
                  }
                }
              fndEqES.addArray(solidFaces,ibVf);
            }
    for (int n=0; n<numMeshes; n++)
      {
        const int numDirections = _quadrature.getDirCount();
        for (int j=0; j<numDirections; j++)
            {
              Field& fnd = *_dsfPtr.dsf[j];
              TArray& dsf = dynamic_cast< TArray&>(fnd[solidFaces]); 
              Field& fndEqES = *_dsfEqPtrES.dsf[j];
              TArray& dsfEqES = dynamic_cast< TArray&>(fndEqES[solidFaces]);
#ifdef FVM_PARALLEL
              MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE,dsf.getData(),solidFaces.getCount() , MPI::DOUBLE, MPI::SUM);
              MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE,dsfEqES.getData(),solidFaces.getCount() , MPI::DOUBLE, MPI::SUM);
#endif

              const Mesh& mesh = *_meshes[n];
              if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
                const StorageSite& ibFaces = mesh.getIBFaces();
                const StorageSite& faces = mesh.getFaces();
                const StorageSite& cells = mesh.getCells();
                const CRConnectivity& faceCells = mesh.getAllFaceCells();
                const CRConnectivity& ibFacesTosolidFaces
                  = mesh.getConnectivity(ibFaces,solidFaces);
                const IntArray& ibFaceIndices = mesh.getIBFaceList();
                const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
                const IntArray& sFCRow = ibFacesTosolidFaces.getRow();
                const IntArray& sFCCol = ibFacesTosolidFaces.getCol();
                const int nibFaces = ibFaces.getCount();
                const int nFaces = faces.getCount();
                const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
                const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
                const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
                VectorT3Array& v = dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);
                shared_ptr<TArray> ibVf(new TArray(ibFaces.getCount()));
                ibVf->zero();
                TArray&  ibVfA= *ibVf;
                for(int f=0; f<nibFaces; f++)
                  {               
                    double distIBSolidInvSum(0.0);
                    for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                      {
                        const int c = sFCCol[nc];
                        const int faceIB= ibFaceIndices[f];
                        const VectorT3Array& solidFaceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[solidFaces]);
                        const VectorT3Array& faceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[faces]);
                              
                        double distIBSolid (0.0);
                        // based on distance - will be thought
                        distIBSolid = sqrt(pow((faceCentroid[faceIB][0]-solidFaceCentroid[c][0]),2)+
                                           pow((faceCentroid[faceIB][1]-solidFaceCentroid[c][1]),2)+
                                           pow((faceCentroid[faceIB][2]-solidFaceCentroid[c][2]),2));
                        distIBSolidInvSum += 1/pow(distIBSolid,RelaxDistribution);
                      }
                    for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                      {
                        const int c = sFCCol[nc];
                        const VectorT3Array& solidFaceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[solidFaces]);
                        const VectorT3Array& faceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[faces]);
                        const TArray& nue  =
                          dynamic_cast<TArray&>(_macroFields.collisionFrequency[solidFaces]);
                        const TArray& nueC  =
                          dynamic_cast<TArray&>(_macroFields.collisionFrequency[cells]);
                        const int faceIB= ibFaceIndices[f];
                        const T uwall = v[c][0];
                        const T vwall = v[c][1];
                        const T wwall = v[c][2];
                        // const T coeff = iCoeffs[nc];
                        double time_to_wall (0.0);
                        double distIBSolid (0.0);
                        // based on distance - will be thought
                        distIBSolid = sqrt(pow((faceCentroid[faceIB][0]-solidFaceCentroid[c][0]),2)+
                                           pow((faceCentroid[faceIB][1]-solidFaceCentroid[c][1]),2)+
                                           pow((faceCentroid[faceIB][2]-solidFaceCentroid[c][2]),2));
                        time_to_wall = -1*(pow(distIBSolid,2)/((cx[j]-uwall)*(faceCentroid[faceIB][0]-solidFaceCentroid[c][0])+(cy[j]-vwall)*(faceCentroid[faceIB][1]-solidFaceCentroid[c][1])+(cz[j]-wwall)*(faceCentroid[faceIB][2]-solidFaceCentroid[c][2])));
                        if(time_to_wall<0)
                          time_to_wall = 0;
                        ibVfA[f] += (dsfEqES[c]-(dsfEqES[c]-dsf[c])*exp(-time_to_wall*nue[c]))/(pow(distIBSolid,RelaxDistribution)*distIBSolidInvSum);
                      }

                  }

                fnd.addArray(ibFaces,ibVf);
              }
            }
      }
    }
  }

template<class T >

void COMETModel< T >::ComputeMacroparameters ( )

inline

Definition at line 1143 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_quadrature, MacroFields::density, Mesh::getCells(), StorageSite::getCount(), MacroFields::pressure, MacroFields::Stress, MacroFields::temperature, and MacroFields::velocity.

Referenced by COMETModel< T >::COMETModel(), and COMETModel< T >::MakeIBCoarseModel().

  {  
    //FILE * pFile;
    //pFile = fopen("distfun_mf.txt","w");
    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.getCount();  //
        
        
        TArray& density = dynamic_cast<TArray&>(_macroFields.density[cells]);
        TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[cells]);
        VectorT3Array& v = dynamic_cast<VectorT3Array&>(_macroFields.velocity[cells]);
        TArray& pressure = dynamic_cast<TArray&>(_macroFields.pressure[cells]);
        const int N123 = _quadrature.getDirCount(); 
        
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
        
        VectorT6Array& stress = dynamic_cast<VectorT6Array&>(_macroFields.Stress[cells]);
        
        //initialize density,velocity,temperature to zero    
        for(int c=0; c<nCells;c++)
          {
            density[c]=0.0;
            v[c][0]=0.0;
            v[c][1]=0.0;
            v[c][2]=0.0;
            temperature[c]=0.0;   
            stress[c][0]=0.0;stress[c][1]=0.0;stress[c][2]=0.0;
            stress[c][3]=0.0;stress[c][4]=0.0;stress[c][5]=0.0;

          }     


        for(int j=0;j<N123;j++){
          
          Field& fnd = *_dsfPtr.dsf[j];
          const TArray& f = dynamic_cast<const TArray&>(fnd[cells]);
          
          //fprintf(pFile,"%d %12.6f %E %E %E %E \n",j,dcxyz[j],cx[j],cy[j],f[80],density[80]+dcxyz[j]*f[80]);
          
          for(int c=0; c<nCells;c++){
            density[c] = density[c]+wts[j]*f[c];
            v[c][0]= v[c][0]+(cx[j]*f[c])*wts[j];
            v[c][1]= v[c][1]+(cy[j]*f[c])*wts[j];
            v[c][2]= v[c][2]+(cz[j]*f[c])*wts[j];
            temperature[c]= temperature[c]+(pow(cx[j],2.0)+pow(cy[j],2.0)
                                           +pow(cz[j],2.0))*f[c]*wts[j];
           
          }
          
        }
        


        for(int c=0; c<nCells;c++){
          v[c][0]=v[c][0]/density[c];
          v[c][1]=v[c][1]/density[c];
          v[c][2]=v[c][2]/density[c];
          temperature[c]=temperature[c]-(pow(v[c][0],2.0)
                                         +pow(v[c][1],2.0)
                                         +pow(v[c][2],2.0))*density[c];
          temperature[c]=temperature[c]/(1.5*density[c]);  
          pressure[c]=density[c]*temperature[c];
        }
        
        //Find Pxx,Pyy,Pzz,Pxy,Pyz,Pzx, etc in field    
        
        for(int j=0;j<N123;j++){          
          Field& fnd = *_dsfPtr.dsf[j];
          const TArray& f = dynamic_cast<const TArray&>(fnd[cells]);      
          for(int c=0; c<nCells;c++){
            stress[c][0] +=pow((cx[j]-v[c][0]),2.0)*f[c]*wts[j];
            stress[c][1] +=pow((cy[j]-v[c][1]),2.0)*f[c]*wts[j];
            stress[c][2] +=pow((cz[j]-v[c][2]),2.0)*f[c]*wts[j];
            stress[c][3] +=(cx[j]-v[c][0])*(cy[j]-v[c][1])*f[c]*wts[j];
            stress[c][4] +=(cy[j]-v[c][1])*(cz[j]-v[c][2])*f[c]*wts[j];
            stress[c][5] +=(cz[j]-v[c][2])*(cx[j]-v[c][0])*f[c]*wts[j];
            
          }}
        
        
      }// end of loop over nmeshes
    //fclose(pFile);
  }

template<class T >

void COMETModel< T >::ComputeMacroparametersESBGK ( )

inline

Definition at line 1406 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtr, COMETModel< T >::_dsfPtr, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, MacroFields::density, Mesh::getCells(), StorageSite::getCount(), MacroFields::Txx, MacroFields::Txy, MacroFields::Tyy, MacroFields::Tyz, MacroFields::Tzx, MacroFields::Tzz, and MacroFields::velocity.

Referenced by COMETModel< T >::EquilibriumDistributionESBGK().

  {  
    
    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.getCount();
        
        const TArray& density = dynamic_cast<const TArray&>(_macroFields.density[cells]);
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);

        TArray& Txx = dynamic_cast<TArray&>(_macroFields.Txx[cells]);
        TArray& Tyy = dynamic_cast<TArray&>(_macroFields.Tyy[cells]);
        TArray& Tzz = dynamic_cast<TArray&>(_macroFields.Tzz[cells]);
        TArray& Txy = dynamic_cast<TArray&>(_macroFields.Txy[cells]);
        TArray& Tyz = dynamic_cast<TArray&>(_macroFields.Tyz[cells]);
        TArray& Tzx = dynamic_cast<TArray&>(_macroFields.Tzx[cells]);
        
        const int N123 = _quadrature.getDirCount(); 
        
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
        
        const double Pr=_options.Prandtl;
        //cout <<"Prandlt" <<Pr<<endl;
        
        //initialize density,velocity,temperature to zero    
        for(int c=0; c<nCells;c++)
          {
            Txx[c]=0.0;
            Tyy[c]=0.0;
            Tzz[c]=0.0;
            Txy[c]=0.0;
            Tyz[c]=0.0;
            Tzx[c]=0.0;
          }
        for(int j=0;j<N123;j++){
          
          Field& fnd = *_dsfPtr.dsf[j];
          const TArray& f = dynamic_cast<const TArray&>(fnd[cells]);
          Field& fndEq = *_dsfEqPtr.dsf[j];
          const TArray& fgam = dynamic_cast<const TArray&>(fndEq[cells]);         
          for(int c=0; c<nCells;c++){
            Txx[c]=Txx[c]+pow(cx[j]-v[c][0],2)*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j];
            Tyy[c]=Tyy[c]+pow(cy[j]-v[c][1],2)*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j] ;
            Tzz[c]=Tzz[c]+pow(cz[j]-v[c][2],2)*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j];
            //Txy[c]=Txy[c]+(cx[j])*(cy[j])*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j];
            //Tyz[c]=Tyz[c]+(cy[j])*(cz[j])*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j];            //Tzx[c]=Tzx[c]+(cz[j])*(cx[j])*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j];

 
            Txy[c]=Txy[c]+(cx[j]-v[c][0])*(cy[j]-v[c][1])*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j];
            Tyz[c]=Tyz[c]+(cy[j]-v[c][1])*(cz[j]-v[c][2])*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j]; 
            Tzx[c]=Tzx[c]+(cz[j]-v[c][2])*(cx[j]-v[c][0])*((1-1/Pr)*f[c]+1/Pr*fgam[c])*wts[j]; 
          }
        }
                
        for(int c=0; c<nCells;c++){
          Txx[c]=Txx[c]/density[c];
          Tyy[c]=Tyy[c]/density[c];
          Tzz[c]=Tzz[c]/density[c];
          Txy[c]=Txy[c]/density[c];
          Tyz[c]=Tyz[c]/density[c];
          Tzx[c]=Tzx[c]/density[c];
        }

     }
  }

template<class T >

void COMETModel< T >::computeSolidFaceDsf ( const StorageSite &  solidFaces, const int  method, const int  RelaxDistribution = 0  )

inline

Definition at line 4154 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_finestGeomFields, COMETModel< T >::_finestMeshes, COMETModel< T >::_geomFields, GeomFields::_interpolationMatrices, COMETModel< T >::_level, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, Field::addArray(), MacroFields::collisionFrequency, GeomFields::coordinate, MacroFields::density, GeomFields::finestToCoarse, Mesh::getCells(), CRConnectivity::getCol(), Mesh::getConnectivity(), StorageSite::getCount(), StorageSite::getCountLevel1(), Mesh::getFaces(), Mesh::getIBFaceList(), Mesh::getIBFaces(), CRConnectivity::getRow(), Mesh::isShell(), sqrt(), MacroFields::temperature, MacroFields::velocity, MacroFields::viscosity, and Array< T >::zero().

Referenced by COMETModel< T >::cycle(), and COMETModel< T >::smooth().

  {
    typedef CRMatrixTranspose<T,T,T> IMatrix;
    typedef CRMatrixTranspose<T,VectorT3,VectorT3> IMatrixV3;
    const int numFields= _quadrature.getDirCount();
    if (method==1){
      const int numMeshes = _meshes.size();
      for (int direction = 0; direction < numFields; direction++) {
        Field& fnd = *_dsfPtr.dsf[direction]; 
        shared_ptr<TArray> ibV(new TArray(solidFaces.getCount()));
        ibV->zero();  
        for (int n=0; n<numMeshes; n++)
          {
            const Mesh& mesh = *_meshes[n];
            const Mesh& fMesh = *_finestMeshes[n];
            if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
            
              const StorageSite& cells = mesh.getCells();
              const StorageSite& fCells = fMesh.getCells();
            
              GeomFields::SSPair key1(&solidFaces,&fCells);
              const IMatrix& mIC =
                dynamic_cast<const IMatrix&>
                (*_finestGeomFields._interpolationMatrices[key1]);
              
              IMatrix mICV(mIC);

              Field& FinestToCoarseField=_finestGeomFields.finestToCoarse;
              const Array<Vector<int,25> >& FinestToCoarse=dynamic_cast<const Array<Vector<int,25> >&>(FinestToCoarseField[fCells]);

              const TArray& cV =
                dynamic_cast<const TArray&>(fnd[cells]);
              TArray cFV(fCells.getCountLevel1());
              for(int c=0;c<fCells.getCountLevel1();c++)
                cFV[c]=cV[FinestToCoarse[c][_level]];

              ibV->zero();        
             
              mICV.multiplyAndAdd(*ibV,cFV);
#if 0
        ofstream debugFile;
        stringstream ss(stringstream::in | stringstream::out);
        ss <<  MPI::COMM_WORLD.Get_rank();
        string  fname1 = "IBVelocity_proc" +  ss.str() + ".dat";
        debugFile.open(fname1.c_str());
        
        //debug use
        const Array<int>& ibFaceList = mesh.getIBFaceList();
        const StorageSite& faces = mesh.getFaces();
        const VectorT3Array& faceCentroid =
          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[faces]);
        const double angV = 1.0;
        VectorT3 center;
        center[0]=0.;
        center[1]=0.;
        center[2]=0.;

        for(int f=0; f<ibFaces.getCount();f++){
          int fID = ibFaceList[f];
          debugFile << "f=" <<   f << setw(10) <<  "   fID = " <<  fID << "  faceCentroid = " << faceCentroid[fID] << " ibV = " << (*ibV)[f] << endl;
        }
          
         debugFile.close();
#endif

            }

          }
        fnd.addArray(solidFaces,ibV);
      }
    }
    if (method==2){

   // Step0: Compute Interpolation Matrices from (only) Cells to IBFaces
      const int numMeshes = _meshes.size();
      for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        const Mesh& fMesh = *_finestMeshes[n];       
   
        const int numFields= _quadrature.getDirCount();
        for (int direction = 0; direction < numFields; direction++)
          {
            Field& fnd = *_dsfPtr.dsf[direction];
            Field& fndEqES = *_dsfEqPtrES.dsf[direction];
            const Mesh& mesh = *_meshes[n];
            if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
        
              const StorageSite& cells = mesh.getCells();
              const StorageSite& fCells = fMesh.getCells();
              const StorageSite& faces = mesh.getFaces();
              const StorageSite& fFaces = fMesh.getFaces();
              const StorageSite& ibFaces = mesh.getIBFaces();
              const StorageSite& fIbFaces = fMesh.getIBFaces(); 

              //GeomFields::SSPair key1(&faces,&cells);
              GeomFields::SSPair key1(&fFaces,&fCells);
              //GeomFields::SSPair key1(&fIbFaces,&fCells);
              const IMatrix& mIC =
                dynamic_cast<const IMatrix&>
                (*_finestGeomFields._interpolationMatrices[key1]);
              
              IMatrix mICV(mIC);
          
              const TArray& cf =
                dynamic_cast<const TArray&>(fnd[cells]);
              const TArray& cfEq =
                dynamic_cast<const TArray&>(fndEqES[cells]);

              Field& FinestToCoarseField=_finestGeomFields.finestToCoarse;
              const Array<Vector<int,25> >& FinestToCoarse=dynamic_cast<const Array<Vector<int,25> >&>(FinestToCoarseField[fCells]);

              TArray cFf(fCells.getCount());
              TArray cFfEq(fCells.getCount());

              for(int c=0;c<fCells.getCount();c++)
              {
                  cFf[c]=cf[FinestToCoarse[c][_level]];
                  cFfEq[c]=cfEq[FinestToCoarse[c][_level]];
              }

              shared_ptr<TArray> ibVf(new TArray(ibFaces.getCount()));
              ibVf->zero();
              if (_options.fgamma==2){
                shared_ptr<TArray> ibVfEq(new TArray(ibFaces.getCount()));
                ibVfEq->zero();
                mICV.multiplyAndAdd(*ibVfEq,cFfEq);
                fndEqES.addArray(ibFaces,ibVfEq);
              }
              mICV.multiplyAndAdd(*ibVf,cFf);
              fnd.addArray(ibFaces,ibVf);
           
      }
    }
      }
      const int nSolidFaces = solidFaces.getCount();
 
      shared_ptr<TArray> muSolid(new TArray(nSolidFaces));
      *muSolid =0;
      _macroFields.viscosity.addArray(solidFaces,muSolid);
      
      shared_ptr<TArray> nueSolid(new TArray(nSolidFaces));
      *nueSolid =0;
      _macroFields.collisionFrequency.addArray(solidFaces,nueSolid);

      const T rho_init=_options["rho_init"]; 
      const T T_init= _options["T_init"]; 
      const T mu_w= _options["mu_w"];
      const T Tmuref= _options["Tmuref"];
      const T muref= _options["muref"];
      const T R=8314.0/_options["molecularWeight"];
      const T nondim_length=_options["nonDimLt"];
      
      const T mu0=rho_init*R* T_init*nondim_length/pow(2*R* T_init,0.5);  
        
      TArray& density = dynamic_cast<TArray&>(_macroFields.density[solidFaces]);
      TArray& viscosity = dynamic_cast<TArray&>(_macroFields.viscosity[solidFaces]);
      TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[solidFaces]);
      TArray& collisionFrequency = dynamic_cast<TArray&>(_macroFields.collisionFrequency[solidFaces]);

      for(int c=0; c<nSolidFaces;c++)
        {
          viscosity[c]= muref*pow(temperature[c]*T_init/ Tmuref,mu_w); // viscosity power law
          collisionFrequency[c]=density[c]*temperature[c]/viscosity[c]*mu0;
        }
        
      if(_options.fgamma==2){
        for(int c=0; c<nSolidFaces;c++)
          collisionFrequency[c]=_options.Prandtl*collisionFrequency[c];
      }

     //Step 1 Interpolate Macroparameters and f to IBface
      for (int n=0; n<numMeshes; n++)
        {
          const Mesh& mesh = *_meshes[n];
          const Mesh& fMesh = *_finestMeshes[n];
          if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){

            const StorageSite& cells = mesh.getCells();
            const StorageSite& fCells = fMesh.getCells();
            const StorageSite& ibFaces = mesh.getIBFaces();
            const StorageSite& fIbFaces = fMesh.getIBFaces();        

          GeomFields::SSPair key1(&fIbFaces,&fCells);
          const IMatrix& mIC =
            dynamic_cast<const IMatrix&>
            (*_finestGeomFields._interpolationMatrices[key1]);
              
          IMatrix mICV(mIC);
          IMatrixV3 mICV3(mIC);  

          GeomFields::SSPair key2(&fIbFaces,&solidFaces);
          const IMatrix& mIP =
            dynamic_cast<const IMatrix&>
            (*_finestGeomFields._interpolationMatrices[key2]);

          IMatrix mIPV(mIP);
          IMatrixV3 mIPV3(mIP);    

          shared_ptr<TArray> ibVtemp(new TArray(ibFaces.getCount()));
          shared_ptr<TArray> ibVnue(new TArray(ibFaces.getCount()));
          shared_ptr<TArray> ibVdensity(new TArray(ibFaces.getCount()));
          shared_ptr<VectorT3Array> ibVvel(new VectorT3Array(ibFaces.getCount()));
          
          const TArray& cTemp  = 
            dynamic_cast<TArray&>(_macroFields.temperature[cells]);
          const VectorT3Array& cVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[cells]);
          const TArray& cDensity  = 
            dynamic_cast<TArray&>(_macroFields.density[cells]);
          const TArray& sDensity  = 
            dynamic_cast<TArray&>(_macroFields.density[solidFaces]);
          const TArray& cNue  = 
            dynamic_cast<TArray&>(_macroFields.collisionFrequency[cells]);
          const TArray& sNue  = 
            dynamic_cast<TArray&>(_macroFields.collisionFrequency[solidFaces]);
          const TArray& sTemp  = 
            dynamic_cast<TArray&>(_macroFields.temperature[solidFaces]);
          const VectorT3Array& sVel = 
            dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);
          
          ibVnue->zero(); 
          ibVtemp->zero();
          ibVvel->zero(); 
          ibVdensity->zero(); 


          Field& FinestToCoarseField=_finestGeomFields.finestToCoarse;
          const Array<Vector<int,25> >& FinestToCoarse=dynamic_cast<const Array<Vector<int,25> >&>(FinestToCoarseField[fCells]);

          TArray cFTemp(fCells.getCount());
          VectorT3Array cFVel(fCells.getCount());
          TArray cFDensity(fCells.getCount());
          TArray cFNue(fCells.getCount());

          for(int c=0;c<fCells.getCount();c++)
          {
              cFTemp[c]=cTemp[FinestToCoarse[c][_level]];
              cFVel[c]=cVel[FinestToCoarse[c][_level]];
              cFDensity[c]=cDensity[FinestToCoarse[c][_level]];
              cFNue[c]=cNue[FinestToCoarse[c][_level]];
          }       

           //nue interpolation (cells)
           mICV.multiplyAndAdd(*ibVnue,cFNue);
           mIPV.multiplyAndAdd(*ibVnue,sNue);
           _macroFields.collisionFrequency.addArray(ibFaces,ibVnue);
           //temperature interpolation (cells+solidfaces)         
           mICV.multiplyAndAdd(*ibVtemp,cFTemp);
           mIPV.multiplyAndAdd(*ibVtemp,sTemp);
           _macroFields.temperature.addArray(ibFaces,ibVtemp);
           //density interpolation (cells+solidfaces)         
           mICV.multiplyAndAdd(*ibVdensity,cFDensity);
           mIPV.multiplyAndAdd(*ibVdensity,sDensity);
           _macroFields.density.addArray(ibFaces,ibVdensity);
           //velocity interpolation (cells+solidfaces) 
           mICV3.multiplyAndAdd(*ibVvel,cFVel);
           mIPV3.multiplyAndAdd(*ibVvel,sVel);
           _macroFields.velocity.addArray(ibFaces,ibVvel);


          }
        }
      if (_options.fgamma==1){
      //Step 2 Find fgamma using macroparameters
      const int numMeshes = _meshes.size();
      for (int n=0; n<numMeshes; n++)
        {
          const Mesh& mesh = *_meshes[n];
          if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
            const int numDirections = _quadrature.getDirCount();
            const StorageSite& ibFaces = mesh.getIBFaces();
            const int nibFaces=ibFaces.getCount();
            const double pi=_options.pi;
            const TArray& ibTemp  =
              dynamic_cast<TArray&>(_macroFields.temperature[ibFaces]);
            const VectorT3Array& ibVel =
              dynamic_cast<VectorT3Array&>(_macroFields.velocity[ibFaces]);
            const TArray& ibDensity  =
              dynamic_cast<TArray&>(_macroFields.density[ibFaces]);

            for (int j=0; j<numDirections; j++)
              {
                shared_ptr<TArray> ibFndPtrEqES(new TArray(nibFaces));
                TArray&  ibFndEqES= *ibFndPtrEqES;
                
                ibFndPtrEqES->zero();

                Field& fndEqES = *_dsfEqPtrES.dsf[j];

                for (int i=0; i<nibFaces; i++)
                  {
                    const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
                    const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
                    const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
                    const T ibu = ibVel[i][0];
                    const T ibv = ibVel[i][1];
                    const T ibw = ibVel[i][2];
                    ibFndEqES[i]=ibDensity[i]/pow(pi*ibTemp[i],1.5)*exp(-(pow(cx[j]-ibu,2.0)+pow(cy[j]-ibv,2.0)+pow(cz[j]-ibw,2.0))/ibTemp[i]);
                  }
                fndEqES.addArray(ibFaces,ibFndPtrEqES);
              }
          }
        }
      }

      //Step3: Relax Distribution function from ibfaces to solid face
        const int numDirections = _quadrature.getDirCount();
        for (int j=0; j<numDirections; j++)
          {
            const int nSolidFaces = solidFaces.getCount();
            shared_ptr<TArray> solidFndPtr(new TArray(nSolidFaces));
            solidFndPtr->zero(); 
            TArray&  solidFnd= *solidFndPtr;
            Field& fnd = *_dsfPtr.dsf[j];
            Field& fndEqES = *_dsfEqPtrES.dsf[j];
            const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
            const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
            const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
            for (int n=0; n<numMeshes; n++)
              {
                const Mesh& mesh = *_meshes[n];
                const Mesh& fMesh = *_finestMeshes[n];
                if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
                  const StorageSite& ibFaces = mesh.getIBFaces();
                  const StorageSite& fIbFaces = fMesh.getIBFaces();
                  const CRConnectivity& solidFacesToibFaces
                    = fMesh.getConnectivity(solidFaces,fIbFaces);
                  const IntArray& ibFaceIndices = fMesh.getIBFaceList();
                  const IntArray& sFCRow = solidFacesToibFaces.getRow();
                  const IntArray& sFCCol = solidFacesToibFaces.getCol();
                  TArray& dsf = dynamic_cast< TArray&>(fnd[ibFaces]);  
                  TArray& dsfEqES = dynamic_cast< TArray&>(fndEqES[ibFaces]);
                  VectorT3Array& v = dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);
            
                  for(int f=0; f<nSolidFaces; f++)
                    {
                      double distIBSolidInvSum(0.0);
                  for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                    {
                      const StorageSite& faces = fMesh.getFaces();
                      const int c = sFCCol[nc];
                      const int faceIB= ibFaceIndices[c];
                      const VectorT3Array& solidFaceCentroid =
                        dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[solidFaces]);
                      const VectorT3Array& faceCentroid =
                        dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[faces]);
              
                      double distIBSolid (0.0);
                      // based on distance - will be thought
                      distIBSolid = sqrt(pow((faceCentroid[faceIB][0]-solidFaceCentroid[f][0]),2)+
                                         pow((faceCentroid[faceIB][1]-solidFaceCentroid[f][1]),2)+
                                         pow((faceCentroid[faceIB][2]-solidFaceCentroid[f][2]),2));
                        distIBSolidInvSum += 1/pow(distIBSolid,RelaxDistribution);
                    }
                  for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                    {
                      const int c = sFCCol[nc];
                      const StorageSite& faces = fMesh.getFaces();
                      const VectorT3Array& solidFaceCentroid =
                        dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[solidFaces]);
                      const VectorT3Array& faceCentroid =
                        dynamic_cast<const VectorT3Array&> (_finestGeomFields.coordinate[faces]);
                      const int faceIB= ibFaceIndices[c];
                      T time_to_wall (0.0);
                      T distIBSolid (0.0);
                      distIBSolid = sqrt(pow((faceCentroid[faceIB][0]-solidFaceCentroid[f][0]),2)+
                                         pow((faceCentroid[faceIB][1]-solidFaceCentroid[f][1]),2)+
                                         pow((faceCentroid[faceIB][2]-solidFaceCentroid[f][2]),2));
                      // based on distance - will be thought
                      const T uwall = v[f][0];
                      const T vwall = v[f][1];
                      const T wwall = v[f][2];
                      const TArray& nue  =
                        dynamic_cast<TArray&>(_macroFields.collisionFrequency[ibFaces]);
                      time_to_wall = (pow(distIBSolid,2)/((cx[j]-uwall)*(faceCentroid[faceIB][0]-solidFaceCentroid[f][0])+(cy[j]-vwall)*(faceCentroid[faceIB][1]-solidFaceCentroid[f][1])+(cz[j]-wwall)*(faceCentroid[faceIB][2]-solidFaceCentroid[f][2])));
                      if(time_to_wall<0)
                        time_to_wall = 0;
                          
                      solidFnd[f] += (dsfEqES[c]-(dsfEqES[c]-dsf[c])*exp(-time_to_wall*nue[c]))/(pow(distIBSolid,RelaxDistribution)*distIBSolidInvSum);
                    }

                    }
                }
              }
            fnd.addArray(solidFaces,solidFndPtr);
          }
    }
    if (method==3){
      const int numDirections = _quadrature.getDirCount();
      for (int j=0; j<numDirections; j++)
        {
          const int nSolidFaces = solidFaces.getCount();
          shared_ptr<TArray> solidFndPtr(new TArray(nSolidFaces));
          solidFndPtr->zero(); 
          TArray&  solidFnd= *solidFndPtr;
          Field& fnd = *_dsfPtr.dsf[j];
          Field& fndEqES = *_dsfEqPtrES.dsf[j];
          const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
          const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
          const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
          const int numMeshes = _meshes.size();
          for (int n=0; n<numMeshes; n++)
            {
              const Mesh& mesh = *_meshes[n];
              if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){
                const StorageSite& cells = mesh.getCells();
                const StorageSite& ibFaces = mesh.getIBFaces();
                const CRConnectivity& solidFacesToCells
                  = mesh.getConnectivity(solidFaces,cells);
                const IntArray& sFCRow = solidFacesToCells.getRow();
                const IntArray& sFCCol = solidFacesToCells.getCol();
                TArray& dsf = dynamic_cast< TArray&>(fnd[cells]);  
                TArray& dsfEqES = dynamic_cast< TArray&>(fndEqES[cells]);
                VectorT3Array& v = dynamic_cast<VectorT3Array&>(_macroFields.velocity[solidFaces]);
            
                for(int f=0; f<nSolidFaces; f++)
                  {
                    double distIBSolidInvSum(0.0);
                    for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                      {
                        const StorageSite& faces = mesh.getFaces();
                        const int c = sFCCol[nc];
                        const VectorT3Array& solidFaceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[solidFaces]);
                        const VectorT3Array& faceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[cells]);
              
                        double distIBSolid (0.0);
                        // based on distance - will be thought
                        distIBSolid = sqrt(pow((faceCentroid[c][0]-solidFaceCentroid[f][0]),2)+
                                           pow((faceCentroid[c][1]-solidFaceCentroid[f][1]),2)+
                                           pow((faceCentroid[c][2]-solidFaceCentroid[f][2]),2));
                        distIBSolidInvSum += 1/pow(distIBSolid,RelaxDistribution);
                      }
                    for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                      {
                        const int c = sFCCol[nc];
                        const StorageSite& faces = mesh.getFaces();
                        const VectorT3Array& solidFaceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[solidFaces]);
                        const VectorT3Array& faceCentroid =
                          dynamic_cast<const VectorT3Array&> (_geomFields.coordinate[cells]);
                        T time_to_wall (0.0);
                        T distIBSolid (0.0);
                        const T uwall = v[f][0];
                        const T vwall = v[f][1];
                        const T wwall = v[f][2];
                        distIBSolid = sqrt(pow((faceCentroid[c][0]-solidFaceCentroid[f][0]),2)+
                                           pow((faceCentroid[c][1]-solidFaceCentroid[f][1]),2)+
                                           pow((faceCentroid[c][2]-solidFaceCentroid[f][2]),2));
                        // based on distance - will be thought
                        
                        const TArray& nue  =
                          dynamic_cast<TArray&>(_macroFields.collisionFrequency[cells]);
                        time_to_wall = (pow(distIBSolid,2)/((cx[j]-uwall)*(faceCentroid[c][0]-solidFaceCentroid[f][0])+(cy[j]-vwall)*(faceCentroid[c][1]-solidFaceCentroid[f][1])+(cz[j]-wwall)*(faceCentroid[c][2]-solidFaceCentroid[f][2])));
                        if(time_to_wall<0)
                          time_to_wall = 0;
                        
                        solidFnd[f] += (dsfEqES[c]-(dsfEqES[c]-dsf[c])*exp(-time_to_wall*nue[c]))/(pow(distIBSolid,RelaxDistribution)*distIBSolidInvSum);
                      }
                  
                  }
              }
            }   
          fnd.addArray(solidFaces,solidFndPtr);
          
        }
    }
  }

template<class T >

void COMETModel< T >::computeSolidFacePressure ( const StorageSite &  solidFaces )

inline

Definition at line 4117 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_geomFields, GeomFields::_interpolationMatrices, COMETModel< T >::_macroFields, Model::_meshes, Field::addArray(), Mesh::getCells(), StorageSite::getCount(), Array< T >::getData(), Mesh::getIBFaces(), Mesh::isShell(), MacroFields::pressure, and Array< T >::zero().

  {
    typedef CRMatrixTranspose<T,T,T> IMatrix;
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        shared_ptr<TArray> ibP(new TArray(solidFaces.getCount()));
        ibP->zero(); 
        const Mesh& mesh = *_meshes[n];
        if (!mesh.isShell() && mesh.getIBFaces().getCount() > 0){

          const StorageSite& cells = mesh.getCells();
  
          GeomFields::SSPair key1(&solidFaces,&cells);
          const IMatrix& mIC =
            dynamic_cast<const IMatrix&>
            (*_geomFields._interpolationMatrices[key1]);
          
          IMatrix mICV(mIC);
    
          const TArray& cP  = 
            dynamic_cast<TArray&>(_macroFields.pressure[cells]);

          ibP->zero(); 


           //nue interpolation (cells)
           mICV.multiplyAndAdd(*ibP,cP);
        }
        _macroFields.pressure.addArray(solidFaces,ibP);
      }
#ifdef FVM_PARALLEL
    TArray& pressure = dynamic_cast<TArray&>(_macroFields.pressure[solidFaces]);
    MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE,pressure.getData(),solidFaces.getCount() , MPI::DOUBLE, MPI::SUM); 
#endif 
  }

template<class T >

void COMETModel< T >::computeSurfaceForce ( const StorageSite &  solidFaces, bool  perUnitArea, bool  IBM = 0  )

inline

Definition at line 5481 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_geomFields, GeomFields::_interpolationMatrices, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, Field::addArray(), GeomFields::area, GeomFields::areaMag, MacroFields::force, Mesh::getCells(), CRConnectivity::getCol(), Mesh::getConnectivity(), StorageSite::getCount(), CRConnectivity::getRow(), StorageSite::getSelfCount(), MacroFields::velocity, and Array< T >::zero().

  {
    typedef CRMatrixTranspose<T,T,T> IMatrix;
    
    const int nSolidFaces = solidFaces.getCount();
    
    boost::shared_ptr<VectorT3Array>
      forcePtr( new VectorT3Array(nSolidFaces));
    VectorT3Array& force = *forcePtr;
    
    force.zero();
    _macroFields.force.addArray(solidFaces,forcePtr);
    
    const VectorT3Array& solidFaceArea =
      dynamic_cast<const VectorT3Array&>(_geomFields.area[solidFaces]);
    
    const TArray& solidFaceAreaMag =
      dynamic_cast<const TArray&>(_geomFields.areaMag[solidFaces]);
    
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const TArray& wts = dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);

        const CRConnectivity& solidFacesToCells
          = mesh.getConnectivity(solidFaces,cells);
        const IntArray& sFCRow = solidFacesToCells.getRow();
        const IntArray& sFCCol = solidFacesToCells.getCol(); 

        const T Lx=_options["nonDimLx"];
        const T Ly=_options["nonDimLy"];
        const T Lz=_options["nonDimLz"];
    

        const int N123= _quadrature.getDirCount(); 

        const int selfCount = cells.getSelfCount();
        for(int f=0; f<nSolidFaces; f++){
          
          StressTensor<T> stress = NumTypeTraits<StressTensor<T> >::getZero();
          
          if (IBM){
            const VectorT3Array& vs = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[solidFaces]);
            GeomFields::SSPair key1(&solidFaces,&cells);
            const IMatrix& mIC =
              dynamic_cast<const IMatrix&>
              (*_geomFields._interpolationMatrices[key1]);
            const Array<T>& iCoeffs = mIC.getCoeff();
            for(int j=0;j<N123;j++){
              Field& fnd = *_dsfPtr.dsf[j];
              const TArray& f_dsf = dynamic_cast<const TArray&>(fnd[cells]);
              const TArray& fs_dsf = dynamic_cast<const TArray&>(fnd[solidFaces]);
              stress[0] -=pow((cx[j]-vs[f][0]),2.0)*fs_dsf[f]*wts[j];
              stress[1] -=pow((cy[j]-vs[f][1]),2.0)*fs_dsf[f]*wts[j];
              stress[2] -=pow((cz[j]-vs[f][2]),2.0)*fs_dsf[f]*wts[j];
              stress[3] -=(cx[j]-vs[f][0])*(cy[j]-vs[f][1])*fs_dsf[f]*wts[j];
              stress[4] -=(cy[j]-vs[f][1])*(cz[j]-vs[f][2])*fs_dsf[f]*wts[j];
              stress[5] -=(cx[j]-vs[f][0])*(cz[j]-vs[f][2])*fs_dsf[f]*wts[j];
              /*
              for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                {
                  
                  const int c = sFCCol[nc];            
                  const T coeff = iCoeffs[nc];
                  stress[0] -=coeff*pow((cx[j]-v[c][0]),2.0)*f_dsf[c]*wts[j];
                  stress[1] -=coeff*pow((cy[j]-v[c][1]),2.0)*f_dsf[c]*wts[j];
                  stress[2] -=coeff*pow((cz[j]-v[c][2]),2.0)*f_dsf[c]*wts[j];
                  stress[3] -=coeff*(cx[j]-v[c][0])*(cy[j]-v[c][1])*f_dsf[c]*wts[j];
                  stress[4] -=coeff*(cy[j]-v[c][1])*(cz[j]-v[c][2])*f_dsf[c]*wts[j];
                  stress[5] -=coeff*(cx[j]-v[c][0])*(cz[j]-v[c][2])*f_dsf[c]*wts[j];
                }
              */
            }
          }
          else
            {
              for(int j=0;j<N123;j++){
                Field& fnd = *_dsfPtr.dsf[j];
                const TArray& f_dsf = dynamic_cast<const TArray&>(fnd[cells]);
                for(int nc = sFCRow[f]; nc<sFCRow[f+1]; nc++)
                  {
                  
                    const int c = sFCCol[nc];            
                    if ( c < selfCount ){
                      stress[0] +=pow((cx[j]-v[c][0]),2.0)*f_dsf[c]*wts[j];
                      stress[1] +=pow((cy[j]-v[c][1]),2.0)*f_dsf[c]*wts[j];
                      stress[2] +=pow((cz[j]-v[c][2]),2.0)*f_dsf[c]*wts[j];
                      stress[3] +=(cx[j]-v[c][0])*(cy[j]-v[c][1])*f_dsf[c]*wts[j];
                      stress[4] +=(cy[j]-v[c][1])*(cz[j]-v[c][2])*f_dsf[c]*wts[j];
                      stress[5] +=(cx[j]-v[c][0])*(cz[j]-v[c][2])*f_dsf[c]*wts[j];
                    }
                  }
              }

            }

          
          const VectorT3& Af = solidFaceArea[f];
          force[f][0] = Af[0]*Ly*Lz*stress[0] + Af[1]*Lz*Lx*stress[3] + Af[2]*Lx*Ly*stress[5];
          force[f][1] = Af[0]*Ly*Lz*stress[3] + Af[1]*Lz*Lx*stress[1] + Af[2]*Lx*Ly*stress[4];
          force[f][2] = Af[0]*Ly*Lz*stress[5] + Af[1]*Lz*Lx*stress[4] + Af[2]*Ly*Ly*stress[2];
          if (perUnitArea){
            force[f] /= solidFaceAreaMag[f];}
        }
      }
  }

template<class T >

const double COMETModel< T >::ConservationofMassCheck ( )

inline

Definition at line 4808 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_geomFields, Model::_meshes, COMETModel< T >::_quadrature, GeomFields::area, GeomFields::areaMag, Mesh::getAllFaceCells(), Mesh::getCells(), StorageSite::getCount(), StorageSite::getCountLevel1(), Mesh::getFaces(), GeomFields::ibFaceIndex, GeomFields::ibType, and Mesh::IBTYPE_FLUID.

 {
  const int numMeshes = _meshes.size();
  T ndens_tot(0.0) ;
     
  for (int n=0; n<numMeshes; n++)
    {
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
        const StorageSite& faces = mesh.getFaces();
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
        const int numDirections = _quadrature.getDirCount();
        const IntArray& ibFaceIndex = dynamic_cast<const IntArray&>(_geomFields.ibFaceIndex[faces]);
        const VectorT3Array& faceArea =
              dynamic_cast<const VectorT3Array&>(_geomFields.area[faces]);
        const TArray& faceAreaMag =
          dynamic_cast<const TArray&>(_geomFields.areaMag[faces]);
        const CRConnectivity& faceCells = mesh.getAllFaceCells();
        const int nFaces = faces.getCount();

        for(int c=0; c<cells.getCountLevel1(); c++)
          {
          if (ibType[c] == Mesh::IBTYPE_FLUID)
            {
              for (int j=0; j<numDirections; j++)
                {
                  Field& fnd = *_dsfPtr.dsf[j];
                  TArray& dsf = dynamic_cast< TArray&>(fnd[cells]);
                  ndens_tot += wts[j]*dsf[c];
                }
            }
          }
    }
    cout << "Hello, I have" << ndens_tot << "number density";
    return ndens_tot;
 }

template<class T >

void COMETModel< T >::ConservationofMFSolid ( const StorageSite &  solidFaces ) const

inline

Definition at line 4846 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_finestGeomFields, COMETModel< T >::_finestMacroFields, COMETModel< T >::_options, COMETModel< T >::_quadrature, GeomFields::area, GeomFields::areaMag, GeomFields::coordinate, MacroFields::density, epsilon, StorageSite::getCount(), MacroFields::temperature, and MacroFields::velocity.

Referenced by COMETModel< T >::cycle(), and COMETModel< T >::smooth().

 {
    const double pi=_options.pi;
    const double epsilon=_options.epsilon_ES;
    const int nSolidFaces = solidFaces.getCount();
    for (int i=0; i<nSolidFaces; i++)
      {
        const int numDirections = _quadrature.getDirCount();
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const VectorT3Array& solidFaceCentroid =
          dynamic_cast<const VectorT3Array&>(_finestGeomFields.coordinate[solidFaces]);
        const VectorT3Array& solidFaceArea =
          dynamic_cast<const VectorT3Array&>(_finestGeomFields.area[solidFaces]);
        const TArray& solidFaceAreaMag =
          dynamic_cast<const TArray&>(_finestGeomFields.areaMag[solidFaces]);
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
        VectorT3Array& v = dynamic_cast<VectorT3Array&>(_finestMacroFields.velocity[solidFaces]);
        TArray& density  = dynamic_cast<TArray&>(_finestMacroFields.density[solidFaces]);
        TArray& temperature  = dynamic_cast<TArray&>(_finestMacroFields.temperature[solidFaces]);
        const T uwall = v[i][0];
        const T vwall = v[i][1];
        const T wwall = v[i][2];
        const T Twall = temperature[i];

        T Nmr(0.0) ;
        T Dmr(0.0) ;
        T incomFlux(0.0);
        for (int j=0; j<numDirections; j++)
          {             
            Field& fnd = *_dsfPtr.dsf[j];
            TArray& dsf = dynamic_cast< TArray&>(fnd[solidFaces]);
            const VectorT3 en = solidFaceArea[i]/solidFaceAreaMag[i];
            const T c_dot_en = cx[j]*en[0]+cy[j]*en[1]+cz[j]*en[2];
            const T wallV_dot_en = uwall*en[0]+vwall*en[1]+wwall*en[2];
            const T fwall = 1.0/pow(pi*Twall,1.5)*exp(-(pow(cx[j]-uwall,2.0)+pow(cy[j]-vwall,2.0)+pow(cz[j]-wwall,2.0))/Twall);
            
            if (c_dot_en-wallV_dot_en > 0) //incoming
              {
                Dmr = Dmr - fwall*wts[j]*(c_dot_en-wallV_dot_en);
                incomFlux=incomFlux-dsf[i]*wts[j]*(c_dot_en-wallV_dot_en);
              }
            else
              {
                Nmr = Nmr + dsf[i]*wts[j]*(c_dot_en-wallV_dot_en);
              }
          }
        const T nwall = Nmr/Dmr; // wall number density for initializing Maxwellian
                    
        density[i]=nwall;
                    
        for (int j=0; j<numDirections; j++)
          {
            Field& fnd = *_dsfPtr.dsf[j];
            TArray& dsf = dynamic_cast< TArray&>(fnd[solidFaces]);
            const VectorT3 en = solidFaceArea[i]/solidFaceAreaMag[i];
            const T c_dot_en = cx[j]*en[0]+cy[j]*en[1]+cz[j]*en[2];
            const T wallV_dot_en = uwall*en[0]+vwall*en[1]+wwall*en[2];
            if (c_dot_en-wallV_dot_en > 0)
              {
                dsf[i] = nwall/pow(pi*Twall,1.5)*exp(-(pow(cx[j]-uwall,2.0)+pow(cy[j]-vwall,2.0)+pow(cz[j]-wwall,2.0))/Twall);
              }     
            else
              dsf[i]=dsf[i];
          }
      }
 }

template<class T >

void COMETModel< T >::correctMassDeficit ( )

inline

Definition at line 4628 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_geomFields, Model::_meshes, COMETModel< T >::_quadrature, GeomFields::area, GeomFields::areaMag, Mesh::getAllFaceCells(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaces(), Mesh::getIBFaces(), StorageSite::getSelfCount(), GeomFields::ibFaceIndex, GeomFields::ibType, Mesh::IBTYPE_BOUNDARY, Mesh::IBTYPE_FLUID, and GeomFields::volume.

 {

 const int numMeshes = _meshes.size();
 T netFlux(0.0);
     
  for (int n=0; n<numMeshes; n++)
    {
        const Mesh& mesh = *_meshes[n];
        const StorageSite& ibFaces = mesh.getIBFaces();
        const StorageSite& cells = mesh.getCells();
        const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
        const StorageSite& faces = mesh.getFaces();
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
        const int numDirections = _quadrature.getDirCount();
        const IntArray& ibFaceIndex = dynamic_cast<const IntArray&>(_geomFields.ibFaceIndex[faces]);
        const VectorT3Array& faceArea =
              dynamic_cast<const VectorT3Array&>(_geomFields.area[faces]);
        const TArray& faceAreaMag =
          dynamic_cast<const TArray&>(_geomFields.areaMag[faces]);
        const CRConnectivity& faceCells = mesh.getAllFaceCells();
        const int nibFaces = ibFaces.getCount();

        for(int f=0; f<nibFaces; f++)
          {
            const int c0 = faceCells(f,0);
            const int c1 = faceCells(f,1);
            if (((ibType[c0] == Mesh::IBTYPE_FLUID) && (ibType[c1] == Mesh::IBTYPE_BOUNDARY)) ||
                ((ibType[c1] == Mesh::IBTYPE_FLUID) && (ibType[c0] == Mesh::IBTYPE_BOUNDARY)))
              {
                const int ibFace = ibFaceIndex[f];
                if (ibFace < 0)
                  throw CException("invalid ib face index");
                if (ibType[c0] == Mesh::IBTYPE_FLUID)
                  {
                    const VectorT3 en = faceArea[f]/faceAreaMag[f]; 
                    for (int j=0; j<numDirections; j++)
                      {
                        const T c_dot_en = cx[j]*en[0]+cy[j]*en[1]+cz[j]*en[2];
                        Field& fnd = *_dsfPtr.dsf[j];
                        TArray& dsf = dynamic_cast<TArray&>(fnd[ibFaces]); 
                
                        netFlux -= dsf[f]*c_dot_en*wts[j]/abs(c_dot_en);
                      }
              
                  }
                else
                  {
                    const VectorT3 en = faceArea[f]/faceAreaMag[f]; 
                    for (int j=0; j<numDirections; j++)
                      {
                        const T c_dot_en = cx[j]*en[0]+cy[j]*en[1]+cz[j]*en[2];
                        Field& fnd = *_dsfPtr.dsf[j];
                        TArray& dsf = dynamic_cast<TArray&>(fnd[ibFaces]); 
                
                        netFlux += dsf[f]*c_dot_en*wts[j]/abs(c_dot_en);
                      }
                  }         
              }
          }
    }  

#ifdef FVM_PARALLEL
  MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &netFlux, 1, MPI::DOUBLE, MPI::SUM);
#endif  

  T volumeSum(0.);
                
  for (int n=0; n<numMeshes; n++)
    {
      const Mesh& mesh = *_meshes[n];
      const StorageSite& cells = mesh.getCells();
      const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
      const TArray& cellVolume = dynamic_cast<const TArray&>(_geomFields.volume[cells]);
      for(int c=0; c<cells.getSelfCount(); c++)
        if (ibType[c] == Mesh::IBTYPE_FLUID)
          volumeSum += cellVolume[c];
                  }
#ifdef FVM_PARALLEL
  MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &volumeSum, 1, MPI::DOUBLE, MPI::SUM);
#endif  

  netFlux /= volumeSum;
  for (int n=0; n<numMeshes; n++)
    {
      const Mesh& mesh = *_meshes[n];
      const StorageSite& cells = mesh.getCells();
      const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
      const TArray& cellVolume = dynamic_cast<const TArray&>(_geomFields.volume[cells]);
      const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
                                     
      for(int c=0; c<cells.getSelfCount(); c++)
        {
          if (ibType[c] == Mesh::IBTYPE_FLUID){
            const int numDirections = _quadrature.getDirCount();
            T cellMass(0.0);
            for (int j=0; j<numDirections; j++)
              {
                Field& fnd = *_dsfPtr.dsf[j];
                TArray& dsf = dynamic_cast< TArray&>(fnd[cells]);
                cellMass += wts[j]*dsf[c];
              }

            for (int j=0; j<numDirections; j++)
              {
                Field& fnd = *_dsfPtr.dsf[j];
                TArray& dsf = dynamic_cast< TArray&>(fnd[cells]);
                Field& feqES = *_dsfEqPtrES.dsf[j]; //for fgamma_2
                TArray& fgam = dynamic_cast< TArray&>(feqES[cells]);
                fgam[c] = fgam[c]*(1+netFlux*cellVolume[c]/cellMass);
                dsf[c] = dsf[c]*(1+netFlux*cellVolume[c]/cellMass);
              }
          }

        }
    }
 }

template<class T >

void COMETModel< T >::correctMassDeficit2 ( double  n1, double  n2  )

inline

Definition at line 4749 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_geomFields, Model::_meshes, COMETModel< T >::_quadrature, Mesh::getCells(), StorageSite::getSelfCount(), GeomFields::ibType, Mesh::IBTYPE_FLUID, and GeomFields::volume.

 {

 const int numMeshes = _meshes.size();
 T netFlux(0.0);
     
 netFlux=n2-n1;

  T volumeSum(0.);
                
  for (int n=0; n<numMeshes; n++)
    {
      const Mesh& mesh = *_meshes[n];
      const StorageSite& cells = mesh.getCells();
      const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
      const TArray& cellVolume = dynamic_cast<const TArray&>(_geomFields.volume[cells]);
      for(int c=0; c<cells.getSelfCount(); c++)
        if (ibType[c] == Mesh::IBTYPE_FLUID)
          volumeSum += cellVolume[c];
                  }
#ifdef FVM_PARALLEL
  MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &volumeSum, 1, MPI::DOUBLE, MPI::SUM);
#endif  

  netFlux /= volumeSum;
  for (int n=0; n<numMeshes; n++)
    {
      const Mesh& mesh = *_meshes[n];
      const StorageSite& cells = mesh.getCells();
      const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
      const TArray& cellVolume = dynamic_cast<const TArray&>(_geomFields.volume[cells]);
      const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
                                     
      for(int c=0; c<cells.getSelfCount(); c++)
        {
          if (ibType[c] == Mesh::IBTYPE_FLUID){
            const int numDirections = _quadrature.getDirCount();
            T cellMass(0.0);
            for (int j=0; j<numDirections; j++)
              {
                Field& fnd = *_dsfPtr.dsf[j];
                TArray& dsf = dynamic_cast< TArray&>(fnd[cells]);
                cellMass += wts[j]*dsf[c];
              }

            for (int j=0; j<numDirections; j++)
              {
                Field& fnd = *_dsfPtr.dsf[j];
                TArray& dsf = dynamic_cast< TArray&>(fnd[cells]);
                Field& feqES = *_dsfEqPtrES.dsf[j]; //for fgamma_2
                TArray& fgam = dynamic_cast< TArray&>(feqES[cells]);
                fgam[c] = fgam[c]*(1+netFlux*cellVolume[c]/cellMass);
                dsf[c] = dsf[c]*(1+netFlux*cellVolume[c]/cellMass);
              }
          }

        }
    }
 }

template<class T >

int COMETModel< T >::correctSingleNeighbor ( const int  m, const Mesh &  mesh, GeomFields &  inGeomFields, int  coarseCount, map< const StorageSite *, IntArray * >  PreFacePairMap  )

inline

Definition at line 2357 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap, GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaceCells(), Mesh::getFaces(), Mesh::getInterfaceGroups(), Array< T >::getLength(), StorageSite::getSelfCount(), FaceGroup::id, and FaceGroup::site.

Referenced by COMETModel< T >::MakeInteriorCoarseMesh().

  {

    const StorageSite& inCells=mesh.getCells();
    const int inCellTotal=inCells.getCount();
    const StorageSite& inFaces=mesh.getFaces();
    const int inFaceCount=inFaces.getCount();
    const CRConnectivity& inFaceinCells=mesh.getFaceCells(inFaces);
    const IntArray& FineToCoarseConst=dynamic_cast<const IntArray&>
      (inGeomFields.fineToCoarse[inCells]);

    IntArray FineToCoarse(FineToCoarseConst.getLength());
    FineToCoarse=FineToCoarseConst;
    
    int coarseGhost=coarseCount;
    int outGhost(0);
    foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
      {
        const FaceGroup& fg=*fgPtr;

        if(fg.id>0)
          {
            const CRConnectivity& faceCells=mesh.getFaceCells(fg.site);
            const int faceCount=fg.site.getCount();

            if(_bcMap[fg.id]->bcType == "Interface")
              {
                IntArray& FaceFine2Coarse=*PreFacePairMap[&fg.site];
                    
                int coarseFaces(0);
                for(int i=0;i<faceCount;i++)
                  {
                    const int cghost=faceCells(i,1);
                    FineToCoarse[cghost]=FaceFine2Coarse[i]+coarseGhost;
                    if(FaceFine2Coarse[i]>coarseFaces)
                      coarseFaces=FaceFine2Coarse[i];
                  }
                coarseGhost+=coarseFaces+1;
                outGhost+=coarseFaces+1;
              }
            else if(_bcMap[fg.id]->bcType == "temperature" ||
                    _bcMap[fg.id]->bcType == "reflecting"       )
              {
                for(int i=0;i<faceCount;i++)
                  {
                    const int cghost=faceCells(i,1);
                    FineToCoarse[cghost]=coarseGhost;
                    coarseGhost++;
                    outGhost++;
                  }
              }
          
          }
      }

    foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
      {
        const FaceGroup& fg=*fgPtr;
        const CRConnectivity& faceCells=mesh.getFaceCells(fg.site);
        const int faceCount=fg.site.getCount();
        
        for(int i=0;i<faceCount;i++)
          {
            const int cghost=faceCells(i,1);
            FineToCoarse[cghost]=coarseGhost;
            coarseGhost++;
            outGhost++;
          }
        
      }

    StorageSite preOutCells(coarseCount,outGhost);
    CRPtr CoarseToFineCells=CRPtr(new CRConnectivity(preOutCells,inCells));
    CoarseToFineCells->initCount();
        
    for(int c=0;c<inCellTotal;c++)
      CoarseToFineCells->addCount(FineToCoarse[c],1);
        
    CoarseToFineCells->finishCount();

    for(int c=0;c<inCellTotal;c++)
      CoarseToFineCells->add(FineToCoarse[c],c);

    CoarseToFineCells->finishAdd();

    CRPtr FineFacesCoarseCells=CRPtr(new CRConnectivity(inFaces,preOutCells));
    FineFacesCoarseCells->initCount();

    //count surviving faces
    int survivingFaces=0;
    int coarse0, coarse1;
    for(int f=0;f<inFaceCount;f++)
      {
        coarse0=FineToCoarse[inFaceinCells(f,0)];
        coarse1=FineToCoarse[inFaceinCells(f,1)];
        if(coarse0!=coarse1)
          {
            survivingFaces++;
            FineFacesCoarseCells->addCount(f,2);
          }
      }
        
    FineFacesCoarseCells->finishCount();
        
    //make non-zero's
    for(int f=0;f<inFaceCount;f++)
      {
        int fc0=inFaceinCells(f,0);
        int fc1=inFaceinCells(f,1);
        int cc0=FineToCoarse[fc0];
        int cc1=FineToCoarse[fc1];
        if(cc0!=cc1)
          {
            FineFacesCoarseCells->add(f,cc0);
            FineFacesCoarseCells->add(f,cc1);
          }
      }

    FineFacesCoarseCells->finishAdd();

    CRPtr CoarseCellsFineFaces=FineFacesCoarseCells->getTranspose();
    CRPtr CellCellCoarse=CoarseCellsFineFaces->multiply(*FineFacesCoarseCells,true);


    for(int c=0;c<preOutCells.getSelfCount();c++)
      {
        if(CellCellCoarse->getCount(c)<2)
          {
            /*
            const int bigCoarse=(*CellCellCoarse)(c,0);
            const int fineCount=CoarseToFineCells->getCount(c);

            for(int j=0;j<fineCount;j++)
              {
                const int fc=(*CoarseToFineCells)(c,j);
                FineToCoarse[fc]=bigCoarse;
              }
            coarseCount-=1;
            */
            
            const int removal=(*CoarseToFineCells)(c,0);
            FineToCoarse[removal]=coarseCount;
            coarseCount++;
            
          }
      }

    return coarseCount;
  }

template<class T >

void COMETModel< T >::correctSolution ( )

inline

Definition at line 3158 of file phononbase/COMETModel.h.

References COMETModel< T >::_BFaces, COMETModel< T >::_coarserLevel, COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, Mesh::getCellFaces(), Mesh::getCells(), Mesh::getConnectivity(), StorageSite::getCount(), CRConnectivity::getCount(), Kspace< T >::geteArray(), Kspace< T >::getGlobalIndex(), Kspace< T >::getInjArray(), COMETModel< T >::getKspace(), Kspace< T >::getkvol(), Kspace< T >::getlength(), COMETModel< T >::getMacro(), COMETModel< T >::getMeshList(), kvol< T >::getmodenum(), StorageSite::getSelfCount(), PhononMacro::temperature, and PhononMacro::TlInjected.

  {
    const int numMeshes = _meshes.size();
    
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& finerMesh=*_meshes[n];
        int Knum=_MeshKspaceMap[n];
        Tkspace& finerKspace=*_kspaces[Knum];
        const Mesh& coarserMesh=*(_coarserLevel->getMeshList())[n];
        Tkspace& coarserKspace=_coarserLevel->getKspace(Knum);
        PhononMacro& coarserMacro=_coarserLevel->getMacro();
        const StorageSite& finerCells=finerMesh.getCells();
        const StorageSite& coarserCells=coarserMesh.getCells();
        const CRConnectivity& CoarserToFiner=coarserMesh.getConnectivity(coarserCells,finerCells);
        const CRConnectivity& coarseCellFaces=coarserMesh.getCellFaces();
        BCfaceArray& BCfArray=*(_BFaces[n]);
        
        TArray& coarserArray=coarserKspace.geteArray();
        TArray& finerArray=finerKspace.geteArray();
        TArray& injArray=coarserKspace.getInjArray();
        
        const int cellCount=coarserCells.getSelfCount();
        const int cellTotCount=coarserCells.getCount();

        for(int c=0;c<cellCount;c++)
          {
            const int fineCount=CoarserToFiner.getCount(c);
            for(int fc=0;fc<fineCount;fc++)
              {
                int coarserCellIndex=coarserKspace.getGlobalIndex(c,0);
                const int finerCell=CoarserToFiner(c,fc);
                int finerCellIndex=finerKspace.getGlobalIndex(finerCell,0);
                const int klen=finerKspace.getlength();
                for(int k=0;k<klen;k++)
                  {
                    Tkvol& kvol=finerKspace.getkvol(k);
                    const int numModes=kvol.getmodenum();
                    for(int m=0;m<numModes;m++)
                      {
                        const T correction=coarserArray[coarserCellIndex]-injArray[coarserCellIndex];               
                        finerArray[finerCellIndex]+=correction;
                        coarserCellIndex++;
                        finerCellIndex++;
                      }
                  }
              }
          }

        for(int c=cellCount;c<cellTotCount;c++)
          {
            const int f=coarseCellFaces(c,0);
            if(BCfArray[f]==4)  //correct interface cells only
              {
                const int fineCount=CoarserToFiner.getCount(c);
                for(int fc=0;fc<fineCount;fc++)
                  {
                    const int finerCell=CoarserToFiner(c,fc);
                    int coarserCellIndex=coarserKspace.getGlobalIndex(c,0);
                    int finerCellIndex=finerKspace.getGlobalIndex(finerCell,0);
                    const int klen=finerKspace.getlength();

                    for(int k=0;k<klen;k++)
                      {
                        Tkvol& kvol=finerKspace.getkvol(k);
                        const int numModes=kvol.getmodenum();
                        for(int m=0;m<numModes;m++)
                          {
                            const T correction=coarserArray[coarserCellIndex]-injArray[coarserCellIndex];
                            finerArray[finerCellIndex]+=correction;
                            coarserCellIndex++;
                            finerCellIndex++;
                          }
                      }

                  }
              }
          }

        TArray& coarserArrayM=dynamic_cast<TArray&>(coarserMacro.temperature[coarserCells]);
        TArray& injArrayM=dynamic_cast<TArray&>(coarserMacro.TlInjected[coarserCells]);
        TArray& finerArrayM=dynamic_cast<TArray&>(_macro.temperature[finerCells]);
        
        for(int c=0;c<cellCount;c++)
          {
            const int fineCount=CoarserToFiner.getCount(c);
            const T correction=coarserArrayM[c]-injArrayM[c];
            
            for(int fc=0;fc<fineCount;fc++)
              finerArrayM[CoarserToFiner(c,fc)]+=correction;
          }
      }
  }

template<class T >

void COMETModel< T >::correctSolution ( )

inline

Definition at line 5336 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_dsfPtr, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_quadrature, DistFunctFields< T >::dsf, Mesh::getCells(), Mesh::getConnectivity(), CRConnectivity::getCount(), COMETModel< T >::getdsf(), COMETModel< T >::getdsf0(), COMETModel< T >::getMacro(), COMETModel< T >::getMeshList(), StorageSite::getSelfCount(), MacroFields::velocity, and MacroFields::velocityInjected.

Referenced by COMETModel< T >::cycle().

  {
    const int numMeshes = _meshes.size();
    
    for (int n=0; n<numMeshes; n++)
    {
        const Mesh& finerMesh=*_meshes[n];
        const Mesh& coarserMesh=*(_coarserLevel->getMeshList())[n];
        MacroFields& coarserMacro=_coarserLevel->getMacro();
        DistFunctFields<T>& coarserdsf = _coarserLevel->getdsf();
        DistFunctFields<T>& coarserdsf0 = _coarserLevel->getdsf0();
        const StorageSite& finerCells=finerMesh.getCells();
        const StorageSite& coarserCells=coarserMesh.getCells();
        const CRConnectivity& CoarserToFiner=coarserMesh.getConnectivity(coarserCells,finerCells);

        const int cellCount=coarserCells.getSelfCount();

        const int numDir=_quadrature.getDirCount();
        for(int dir=0;dir<numDir;dir++)
        {
            Field& fnd = *_dsfPtr.dsf[dir];
            Field& cfnd = *coarserdsf.dsf[dir];
            Field& cfndInj = *coarserdsf0.dsf[dir];
            TArray& finerArray = dynamic_cast<TArray&>(fnd[finerCells]);
            TArray& coarserArray = dynamic_cast<TArray&>(cfnd[coarserCells]);
            TArray& injArray = dynamic_cast<TArray&>(cfndInj[coarserCells]);
            
            for(int c=0;c<cellCount;c++)
            {
                const int fineCount=CoarserToFiner.getCount(c);
                const T correction=coarserArray[c]-injArray[c];
                
                for(int fc=0;fc<fineCount;fc++)
                  finerArray[CoarserToFiner(c,fc)]+=correction;
            }
        }
        
        VectorT3Array& coarserArray=dynamic_cast<VectorT3Array&>(coarserMacro.velocity[coarserCells]);
        VectorT3Array& injArray=dynamic_cast<VectorT3Array&>(coarserMacro.velocityInjected[coarserCells]);
        VectorT3Array& finerArray=dynamic_cast<VectorT3Array&>(_macroFields.velocity[finerCells]);

        for(int c=0;c<cellCount;c++)
        {
            const int fineCount=CoarserToFiner.getCount(c);
            const VectorT3 correction=coarserArray[c]-injArray[c];
            
            for(int fc=0;fc<fineCount;fc++)
              finerArray[CoarserToFiner(c,fc)]+=correction;
        }
    }
  }

template<class T >

void COMETModel< T >::cycle ( )

inline

Definition at line 2971 of file phononbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_level, COMETModel< T >::_options, COMETModel< T >::correctSolution(), COMETModel< T >::cycle(), COMETModel< T >::doSweeps(), COMETModel< T >::injectResid(), COMETModel< T >::makeFAS(), COMETModel< T >::sete0(), and COMETModel< T >::updateResid().

  {
    doSweeps(_options.preSweeps);
    
    if(_level+1<_options.maxLevels)
      {
        updateResid(_level!=0);
        injectResid();
        _coarserLevel->sete0();
        _coarserLevel->makeFAS();
        _coarserLevel->cycle();
        correctSolution();
      }
    
    doSweeps(_options.postSweeps);
  }

template<class T >

void COMETModel< T >::cycle ( )

inline

Definition at line 5113 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_level, COMETModel< T >::_options, COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::ComputeCOMETMacroparameters(), COMETModel< T >::correctSolution(), COMETModel< T >::cycle(), COMETModel< T >::doSweeps(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::injectResid(), COMETModel< T >::makeFAS(), and COMETModel< T >::updateResid().

Referenced by COMETModel< T >::advance(), and COMETModel< T >::cycle().

  {
    if(_level+1<_options.maxLevels)
      doSweeps(_options.preSweeps,1);
    else
      doSweeps(_options.preCoarsestSweeps,1);
    if(_level+1<_options.maxLevels)
    {
        if(_level==0)
          updateResid(false);
        else
          updateResid(true);

        injectResid();
        _coarserLevel->ComputeCOMETMacroparameters();
        _coarserLevel->ComputeCollisionfrequency();
        if (_options.fgamma==0){_coarserLevel->initializeMaxwellianEq();}
        else{_coarserLevel->EquilibriumDistributionBGK();}
        if (_options.fgamma==2){_coarserLevel->EquilibriumDistributionESBGK();}

        _coarserLevel->makeFAS();
        _coarserLevel->cycle();
        correctSolution();

        ComputeCOMETMacroparameters();
        ComputeCollisionfrequency();
        if (_options.fgamma==0){initializeMaxwellianEq();}
        else{EquilibriumDistributionBGK();}
        if (_options.fgamma==2){EquilibriumDistributionESBGK();}
    }
    if(_level+1<_options.maxLevels)
      doSweeps(_options.postSweeps,0);
    else
    {
        if(_options.postCoarsestSweeps==1)
          doSweeps(_options.postCoarsestSweeps,0);
        else if(_options.postCoarsestSweeps>1)
          doSweeps(_options.postCoarsestSweeps,1);
    }
  }

template<class T >

void COMETModel< T >::cycle ( const StorageSite &  solidFaces )

inline

Definition at line 5155 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_level, COMETModel< T >::_options, COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::ComputeCOMETMacroparameters(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::ConservationofMFSolid(), COMETModel< T >::correctSolution(), COMETModel< T >::cycle(), COMETModel< T >::doSweeps(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::injectResid(), COMETModel< T >::makeFAS(), COMETModel< T >::MakeParallel(), and COMETModel< T >::updateResid().

  {
    if(_level+1<_options.maxLevels)
      doSweeps(_options.preSweeps,1,solidFaces);
    else
      doSweeps(_options.preCoarsestSweeps,1,solidFaces);
    if(_level+1<_options.maxLevels)
      {
        if(_level==0)
          updateResid(false,solidFaces);
        else
          updateResid(true,solidFaces);

        injectResid();
        _coarserLevel->ComputeCOMETMacroparameters();
        _coarserLevel->ComputeCollisionfrequency();
        if (_options.fgamma==0){_coarserLevel->initializeMaxwellianEq();}
        else{_coarserLevel->EquilibriumDistributionBGK();}
        if (_options.fgamma==2){_coarserLevel->EquilibriumDistributionESBGK();}
        _coarserLevel->MakeParallel();     
        _coarserLevel->computeSolidFaceDsf(solidFaces,_options.method,_options.relaxDistribution);
        _coarserLevel->ConservationofMFSolid(solidFaces);
        _coarserLevel->computeIBFaceDsf(solidFaces,_options.method,_options.relaxDistribution);

        _coarserLevel->makeFAS(solidFaces);
        _coarserLevel->cycle(solidFaces);
        correctSolution();
        
        ComputeCOMETMacroparameters();
        ComputeCollisionfrequency();
        if (_options.fgamma==0){initializeMaxwellianEq();}
        else{EquilibriumDistributionBGK();}
        if (_options.fgamma==2){EquilibriumDistributionESBGK();}    
        MakeParallel();
        computeSolidFaceDsf(solidFaces,_options.method,_options.relaxDistribution);
        ConservationofMFSolid(solidFaces);
        computeIBFaceDsf(solidFaces,_options.method,_options.relaxDistribution);
      }
    if(_level+1<_options.maxLevels)
      doSweeps(_options.postSweeps,0,solidFaces);
    else
    {
        if(_options.postCoarsestSweeps==1)
          doSweeps(_options.postCoarsestSweeps,0,solidFaces);
        else if(_options.postCoarsestSweeps>1)
          doSweeps(_options.postCoarsestSweeps,1,solidFaces);
    }
  }

template<class T >

void COMETModel< T >::doSweeps ( const int  sweeps )

inline

Definition at line 2800 of file phononbase/COMETModel.h.

References COMETModel< T >::smooth().

  {
    for(int sweepNo=0;sweepNo<sweeps;sweepNo++)
      {
        smooth(1);
        smooth(-1);
      }
    //applyTemperatureBoundaries();
  }

template<class T >

void COMETModel< T >::doSweeps ( const int  sweeps, const int  num  )

inline

Definition at line 4915 of file esbgkbase/COMETModel.h.

References COMETModel< T >::smooth().

Referenced by COMETModel< T >::cycle().

  {
    for(int sweepNo=0;sweepNo<sweeps;sweepNo++)
      smooth(num);
  }

template<class T >

void COMETModel< T >::doSweeps ( const int  sweeps, const int  num, const StorageSite &  solidFaces  )

inline

Definition at line 4921 of file esbgkbase/COMETModel.h.

References COMETModel< T >::smooth().

  {
    for(int sweepNo=0;sweepNo<sweeps;sweepNo++)
      smooth(num,solidFaces);
  }

template<class T >

void COMETModel< T >::EntropyGeneration ( )

inline

Definition at line 1567 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtr, COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, MacroFields::collisionFrequency, MacroFields::Entropy, MacroFields::EntropyGenRate_Collisional, Mesh::getCells(), and StorageSite::getCount().

                            {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const T rho_init=_options["rho_init"]; 
        const T T_init= _options["T_init"]; 
        const T molwt=_options["molecularWeight"]*1E-26/6.023;
        const T R=8314.0/_options["molecularWeight"];
        const T u_init=pow(2.0*R*T_init,0.5);
        const T Planck=_options.Planck;
        const T h3bm4u3=pow(Planck,3)/ pow(molwt,4)*rho_init/pow(u_init,3);
        //cout << "h3bm4u3  " << h3bm4u3 <<endl;        
        //cout <<" u_init "<<u_init<<" rho_init "<<rho_init<<endl;
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);  
        TArray& Entropy = dynamic_cast<TArray&>(_macroFields.Entropy[cells]);
        TArray& EntropyGenRate_Collisional = dynamic_cast<TArray&>(_macroFields.EntropyGenRate_Collisional[cells]);
        TArray& collisionFrequency = dynamic_cast<TArray&>(_macroFields.collisionFrequency[cells]);
        for(int c=0; c<nCells;c++){ 
          Entropy[c]=0.0;EntropyGenRate_Collisional[c]=0.0;
        }
        const int num_directions = _quadrature.getDirCount(); 
        if (_options.fgamma ==2){
          for(int j=0;j<num_directions;j++){
            Field& fnd = *_dsfPtr.dsf[j];
            Field& feqES = *_dsfEqPtrES.dsf[j]; //for fgamma_2
            const TArray& f = dynamic_cast<const TArray&>(fnd[cells]); 
            const TArray& fgam = dynamic_cast<const TArray&>(feqES[cells]);
            for(int c=0; c<nCells;c++){
              Entropy[c]=Entropy[c]+f[c]*wts[j]*(1-log(h3bm4u3*f[c]));
              EntropyGenRate_Collisional[c]+= (f[c]-fgam[c])*collisionFrequency[c]*log(h3bm4u3*f[c])*wts[j];
            }
          }
        }
        else{
          for(int j=0;j<num_directions;j++){
            Field& fnd = *_dsfPtr.dsf[j];
            Field& feq = *_dsfEqPtr.dsf[j];
            const TArray& f = dynamic_cast<const TArray&>(fnd[cells]);
            const TArray& fgam = dynamic_cast<const TArray&>(feq[cells]);
            for(int c=0; c<nCells;c++){
              Entropy[c]=Entropy[c]+f[c]*wts[j]*(1-log(h3bm4u3*f[c]));
              EntropyGenRate_Collisional[c]+=(f[c]-fgam[c])*collisionFrequency[c]*(log(h3bm4u3*f[c]))*wts[j];
            }
          }
        }
        
        
      }
  }

template<class T >

void COMETModel< T >::equilibrate ( )

inline

Definition at line 3606 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, pmode< T >::calce0(), Mesh::getCells(), StorageSite::getCount(), pmode< T >::getfield(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), and PhononMacro::temperature.

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*_meshes[n];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        const StorageSite& cells=mesh.getCells();
        const int numcells=cells.getCount();
        const TArray& Tl=dynamic_cast<const TArray&>(_macro.temperature[cells]);
        const int len=kspace.getlength();
        
        for(int k=0;k<len;k++)
          {
            Tkvol& kvol=kspace.getkvol(k);
            const int modes=kvol.getmodenum();
            for(int m=0;m<modes;m++)
              {
                Tmode& mode=kvol.getmode(m);
                Field& eField=mode.getfield();
                TArray& eArray=dynamic_cast<TArray&>(eField[cells]);
                for(int c=0;c<numcells;c++)
                  eArray[c]=mode.calce0(Tl[c]);
              }
          }
      }
  }

template<class T >

void COMETModel< T >::EquilibriumDistributionBGK ( )

inline

Definition at line 1748 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtr, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, MacroFields::coeff, Mesh::getCells(), StorageSite::getCount(), COMETModel< T >::NewtonsMethodBGK(), and MacroFields::velocity.

Referenced by COMETModel< T >::cycle(), and COMETModel< T >::smooth().

  {     
    const int  ktrial=_options.NewtonsMethod_ktrial;
    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.getCount();
        
        //const double pi=_options.pi;
        //const TArray& density = dynamic_cast<const TArray&>(_macroFields.density[cells]);
        //const TArray& temperature = dynamic_cast<const TArray&>(_macroFields.temperature[cells]);
        
        //initialize coeff
        VectorT5Array& coeff = dynamic_cast<VectorT5Array&>(_macroFields.coeff[cells]);
        
        /*
        for(int c=0; c<nCells;c++){
          coeff[c][0]=density[c]/pow((pi*temperature[c]),1.5);
          coeff[c][1]=1/temperature[c];
          coeff[c][2]=0.0;
          coeff[c][3]=0.0;
          coeff[c][4]=0.0;          
        }
        */
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const int numFields= _quadrature.getDirCount(); 
        
        //call Newtons Method
        
        NewtonsMethodBGK(ktrial);

        //calculate perturbed maxwellian for BGK
        for(int j=0;j< numFields;j++){
          Field& fndEq = *_dsfEqPtr.dsf[j];
          TArray& fEq = dynamic_cast< TArray&>(fndEq[cells]);
          for(int c=0; c<nCells;c++){
            fEq[c]=coeff[c][0]*exp(-coeff[c][1]*(pow(cx[j]-v[c][0],2)+pow(cy[j]-v[c][1],2)
            +pow(cz[j]-v[c][2],2))+coeff[c][2]*(cx[j]-v[c][0])
                                    +coeff[c][3]*(cy[j]-v[c][1])+coeff[c][4]*(cz[j]-v[c][2]));
          } 
          
        }
      }
  }

template<class T >

void COMETModel< T >::EquilibriumDistributionESBGK ( )

inline

Definition at line 1953 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, MacroFields::coeffg, COMETModel< T >::ComputeMacroparametersESBGK(), Mesh::getCells(), StorageSite::getCount(), COMETModel< T >::NewtonsMethodESBGK(), and MacroFields::velocity.

Referenced by COMETModel< T >::cycle(), and COMETModel< T >::smooth().

  {
    ComputeMacroparametersESBGK();
    const int ktrial=_options.NewtonsMethod_ktrial;
    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.getCount();


        //const VectorT5Array& coeff = dynamic_cast<const VectorT5Array&>(_macroFields.coeff[cells]);
        //initialize coeffg
        VectorT10Array& coeffg = dynamic_cast<VectorT10Array&>(_macroFields.coeffg[cells]);
        /*
        for(int c=0; c<nCells;c++){
          coeffg[c][0]=coeff[c][0];
          coeffg[c][1]=coeff[c][1];
          coeffg[c][2]=coeff[c][2];
          coeffg[c][3]=coeff[c][1];
          coeffg[c][4]=coeff[c][3];
          coeffg[c][5]=coeff[c][1];
          coeffg[c][6]=coeff[c][4];
          coeffg[c][7]=0.0;
          coeffg[c][8]=0.0;
          coeffg[c][9]=0.0;         
        }
        */
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const int numFields= _quadrature.getDirCount(); 
        
        NewtonsMethodESBGK(ktrial);
        
        for(int j=0;j< numFields;j++){
          Field& fndEqES = *_dsfEqPtrES.dsf[j];
          TArray& fEqES = dynamic_cast< TArray&>(fndEqES[cells]);
          for(int c=0; c<nCells;c++){ 
            T Cc1=(cx[j]-v[c][0]);
            T Cc2=(cy[j]-v[c][1]);
            T Cc3=(cz[j]-v[c][2]);
            fEqES[c]=coeffg[c][0]*exp(-coeffg[c][1]*pow(Cc1,2)+coeffg[c][2]*Cc1
                                      -coeffg[c][3]*pow(Cc2,2)+coeffg[c][4]*Cc2
                                      -coeffg[c][5]*pow(Cc3,2)+coeffg[c][6]*Cc3
                                    +coeffg[c][7]*cx[j]*cy[j]+coeffg[c][8]*cy[j]*cz[j]
                                    +coeffg[c][9]*cz[j]*cx[j]);
          }
          
        }
      }
  }

template<class T >

int COMETModel< T >::FinishCoarseMesh ( const MeshList &  inMeshes, GeomFields &  inGeomFields, MeshList &  outMeshes, IntArray &  CoarseCounts, map< const StorageSite *, IntArray * > &  PreFacePairMap, IntArray &  coarseGhost  )

inline

needs to be changed

Definition at line 1663 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap, Field::addArray(), GeomFields::area, GeomFields::areaMag, GeomFields::coordinate, Mesh::createBoundaryFaceGroup(), Mesh::createInterfaceGroup(), Mesh::createInteriorFaceGroup(), GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaceCells(), Mesh::getFaces(), StorageSite::getGatherMap(), StorageSite::getGatherProcID(), Array< T >::getLength(), StorageSite::getOffset(), StorageSite::getSelfCount(), FaceGroup::groupType, FaceGroup::id, Mesh::setConnectivity(), StorageSite::setCount(), FaceGroup::site, sqrt(), GeomFields::volume, and Array< T >::zero().

Referenced by COMETModel< T >::MakeCoarseModel().

  {

    const int numMeshes=inMeshes.size();

    int smallestMesh=-1;
    
    for(int n=0;n<numMeshes;n++)
      {
        const Mesh& mesh=*inMeshes[n];
        Mesh* newMeshPtr=outMeshes[n];
        //int coarseCount=CoarseCounts[n];
        const StorageSite& inCells=mesh.getCells();
        IntArray& FineToCoarse=dynamic_cast<IntArray&>(inGeomFields.fineToCoarse[inCells]);
        StorageSite& outCells=newMeshPtr->getCells();
        StorageSite& outFaces=newMeshPtr->getFaces();
        const StorageSite& inFaces=mesh.getFaces();
        const int inCellTotal=inCells.getCount();
        const int inFaceCount=inFaces.getCount();

        const CRConnectivity& inFaceinCells=mesh.getFaceCells(inFaces);
        Field& areaMagField=inGeomFields.areaMag;
        const TArray& areaMagArray=
          dynamic_cast<const TArray&>(areaMagField[inFaces]);

        Field& FaceAreaField=inGeomFields.area;
        const VectorT3Array& inFA=
          dynamic_cast<const VectorT3Array&>(FaceAreaField[inFaces]);
        
        //make the coarse cell to fine cell connectivity.
        outCells.setCount(CoarseCounts[n],coarseGhost[n]-CoarseCounts[n]);
        CRPtr CoarseToFineCells=CRPtr(new CRConnectivity(outCells,inCells));
        CoarseToFineCells->initCount();
        
        for(int c=0;c<inCellTotal;c++)
          CoarseToFineCells->addCount(FineToCoarse[c],1);
        
        CoarseToFineCells->finishCount();

        for(int c=0;c<inCellTotal;c++)
          CoarseToFineCells->add(FineToCoarse[c],c);

        CoarseToFineCells->finishAdd();

        //connectivity between itself (cells) and its finer mesh cells. 
        newMeshPtr->setConnectivity(outCells,inCells,CoarseToFineCells);

        CRPtr FineFacesCoarseCells=CRPtr(new CRConnectivity(inFaces,outCells));
        FineFacesCoarseCells->initCount();

        //count surviving faces
        for(int f=0;f<inFaceCount;f++)
          {
            int coarse0=FineToCoarse[inFaceinCells(f,0)];
            int coarse1=FineToCoarse[inFaceinCells(f,1)];
            if(coarse0!=coarse1)
              FineFacesCoarseCells->addCount(f,2);
          }
        
        FineFacesCoarseCells->finishCount();
        
        //make non-zero's
        for(int f=0;f<inFaceCount;f++)
          {
            int fc0=inFaceinCells(f,0);
            int fc1=inFaceinCells(f,1);
            int cc0=FineToCoarse[fc0];
            int cc1=FineToCoarse[fc1];
            if(cc0!=cc1)
              {
                FineFacesCoarseCells->add(f,cc0);
                FineFacesCoarseCells->add(f,cc1);
              }
          }

        FineFacesCoarseCells->finishAdd();

        CRPtr CoarseCellsFineFaces=FineFacesCoarseCells->getTranspose();
        CRPtr CellCellCoarse=CoarseCellsFineFaces->multiply(*FineFacesCoarseCells,true);

        int counter=0;  //coarse face counter
        BArray counted(outCells.getCount());
        counted=false;
        for(int c=0;c<outCells.getCount();c++)
          {
            counted[c]=true;
            const int neibs=CellCellCoarse->getCount(c);

            for(int n=0;n<neibs;n++)
              {
                const int c1=(*CellCellCoarse)(c,n);
                if(neibs>1)
                  {
                    if(!counted[c1])
                      {
                        counter++;
                      }
                  }
                else  //gives two faces to cells with 1 neighbor
                  {
                    if(c>=outCells.getSelfCount())
                      {
                        if(!counted[c1])
                          counter++;
                      }
                    else  //interior cells
                      {
                        if(counted[c1])
                          counter++;
                        else
                          counter+=2;
                      }
                  }
              }
          }

        outFaces.setCount(counter);

        CRPtr CoarseCellCoarseFace=CRPtr(new CRConnectivity(outCells,outFaces));
        CoarseCellCoarseFace->initCount();

        int tempCount(0);
        for(int c=0;c<outCells.getCount();c++)
          {
            const int neibs=CellCellCoarse->getCount(c);
            CoarseCellCoarseFace->addCount(c,neibs);
            tempCount+=neibs;
            if((neibs==1) && (c<outCells.getSelfCount()))   //adding 2 faces to cells with one neighbor
              {
                CoarseCellCoarseFace->addCount(c,neibs);
                tempCount+=neibs;
              }
          }

        CoarseCellCoarseFace->finishCount();

        //make cell connectivity to interior faces.
        counter=0;
        counted=false;
        for(int c=0;c<outCells.getSelfCount();c++)
          {
            counted[c]=true;
            const int neibs=CellCellCoarse->getCount(c);
            for(int n=0;n<neibs;n++)
              {
                const int c1=(*CellCellCoarse)(c,n);
                if(neibs>1)
                  {
                    if(!counted[c1] && c1<outCells.getSelfCount())
                      {
                        CoarseCellCoarseFace->add(c,counter);
                        CoarseCellCoarseFace->add(c1,counter);
                        counter++;
                      }
                  }
                else
                  {
                    if(counted[c1] && c1<outCells.getSelfCount())
                      {
                        CoarseCellCoarseFace->add(c,counter);
                        CoarseCellCoarseFace->add(c1,counter);
                        counter++;
                      }
                    else if(!counted[c1] && c1<outCells.getSelfCount())
                      {
                        CoarseCellCoarseFace->add(c,counter);
                        CoarseCellCoarseFace->add(c1,counter);
                        counter++;
                        CoarseCellCoarseFace->add(c,counter);
                        CoarseCellCoarseFace->add(c1,counter);
                        counter++;
                      }
                  }
              }
          }

        const int coarseInteriorCount=counter;

        //cell connectivity to boundary faces
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          {
            const FaceGroup& fg=*fgPtr;
            //const int faceCount=fg.site.getCount();
            const CRConnectivity& inBfaceCells=mesh.getFaceCells(fg.site);

            if(fg.id>0)
              {
                int faceCount(0);
                if(_bcMap[fg.id]->bcType == "Interface")
                  {
                    IntArray& FaceFine2Coarse=*PreFacePairMap[&fg.site];
                    int coarseFaces(0);
                    for(int i=0;i<fg.site.getCount();i++)
                      if(FaceFine2Coarse[i]>coarseFaces)
                        coarseFaces=FaceFine2Coarse[i];
                    faceCount=coarseFaces+1;

                    BArray countedFaces(faceCount);
                    countedFaces=false;
                    for(int i=0;i<fg.site.getCount();i++)
                      {
                        const int coarseFace=FaceFine2Coarse[i];
                        if(!countedFaces[coarseFace])
                          {
                            const int globFace=i+fg.site.getOffset();
                            const int cc1=(*FineFacesCoarseCells)(globFace,0);
                            const int cc2=(*FineFacesCoarseCells)(globFace,1);
                            CoarseCellCoarseFace->add(cc1,counter);
                            CoarseCellCoarseFace->add(cc2,counter);
                            counter++;
                            countedFaces[coarseFace]=true;
                          }
                      }

                  }
                else
                  {
                    faceCount=fg.site.getCount();
                    for(int i=0;i<faceCount;i++)
                      {
                        const int c1=inBfaceCells(i,1);   //fine ghost cell
                        const int cc1=FineToCoarse[c1];   //coarse ghost cell
                        const int cc2=(*CellCellCoarse)(cc1,0);  //coarse interior cell
                        CoarseCellCoarseFace->add(cc1,counter);
                        CoarseCellCoarseFace->add(cc2,counter);
                        counter++;
                      }
                  }
              }
          }
        
        // have to count coarse interfaces (parallel) -- !!

        foreach(const StorageSite::GatherMap::value_type pos, outCells.getGatherMap())
          {
            const StorageSite& oSite = *pos.first;
            const Array<int>& toIndices = *pos.second;

            int to_where  = oSite.getGatherProcID();
            if ( to_where != -1 )
              {
                const int fgCount=toIndices.getLength();
                
                for(int i=0;i<fgCount;i++)
                  {
                    const int c1=toIndices[i];
                    const int c1neibs=CellCellCoarse->getCount(c1);
                    for(int j=0;j<c1neibs;j++)
                      {
                        const int c2=(*CellCellCoarse)(toIndices[i],j);
                        CoarseCellCoarseFace->add(c2,counter);
                        CoarseCellCoarseFace->add(toIndices[i],counter);
                        counter++;
                      }
                  }
              }
          }

        CoarseCellCoarseFace->finishAdd();

        CRPtr CoarseFaceCoarseCell=CoarseCellCoarseFace->getTranspose();

        newMeshPtr->setConnectivity(outCells,outFaces,CoarseCellCoarseFace);
        newMeshPtr->setConnectivity(outFaces,outCells,CoarseFaceCoarseCell);

        CRPtr CoarseFacesFineFaces=CRPtr(new CRConnectivity(outFaces,inFaces));
        CoarseFacesFineFaces->initCount();

        VectorT3Array areaSum(outFaces.getCount());
        areaSum.zero();

        for(int f=0;f<inFaceCount;f++)
          {
            int fc0=inFaceinCells(f,0);
            int fc1=inFaceinCells(f,1);
            const int cc0=FineToCoarse[fc0];
            const int cc1=FineToCoarse[fc1];

            int cc0neibs=CellCellCoarse->getCount(cc0);
            int cc1neibs=CellCellCoarse->getCount(cc1);

            if(cc0>=outCells.getSelfCount())
              cc0neibs++;
            if(cc1>=outCells.getSelfCount())
              cc1neibs++;

            if(cc1!=cc0)
              {
                const int cfaces=CoarseCellCoarseFace->getCount(cc0);
                
                for(int cf=0;cf<cfaces;cf++)
                  {
                    const int face=(*CoarseCellCoarseFace)(cc0,cf);
                    const int tempc0=(*CoarseFaceCoarseCell)(face,0);
                    const int tempc1=(*CoarseFaceCoarseCell)(face,1);
                    
                    if(((cc0==tempc0)&&(cc1==tempc1))||((cc1==tempc0)&&(cc0==tempc1)))
                      {
                        T sign(0);

                        if(cc1==tempc0)
                           sign*=-1.;

                        areaSum[face]+=inFA[f]*sign;

                        if(cc1neibs>1 && cc0neibs>1)
                          {
                            CoarseFacesFineFaces->addCount(face,1);
                            break;
                          }
                        else
                          {
                            T sumMag=sqrt(areaSum[face][0]*areaSum[face][0]+
                                          areaSum[face][1]*areaSum[face][1]+
                                          areaSum[face][2]*areaSum[face][2]);

                            T partMag=sqrt(inFA[f][0]*inFA[f][0]+
                                           inFA[f][1]*inFA[f][1]+
                                           inFA[f][2]*inFA[f][2]);
                        
                            if(sumMag/partMag>.75)
                              {
                                CoarseFacesFineFaces->addCount(face,1);
                                break;
                              }
                            else
                              areaSum[face]-=inFA[f]*sign;

                          }
                      }
                  }
              }
          }

        CoarseFacesFineFaces->finishCount();

        areaSum.zero();

        for(int f=0;f<inFaceCount;f++)
          {
            int fc0=inFaceinCells(f,0);
            int fc1=inFaceinCells(f,1);
            const int cc0=FineToCoarse[fc0];
            const int cc1=FineToCoarse[fc1];

            int cc0neibs=CellCellCoarse->getCount(cc0);
            int cc1neibs=CellCellCoarse->getCount(cc1);

            if(cc0>=outCells.getSelfCount())
              cc0neibs++;
            if(cc1>=outCells.getSelfCount())
              cc1neibs++;
            
            if(cc1!=cc0)
              {
                const int cfaces=CoarseCellCoarseFace->getCount(cc0);
                
                for(int cf=0;cf<cfaces;cf++)
                  {
                    const int face=(*CoarseCellCoarseFace)(cc0,cf);
                    const int tempc0=(*CoarseFaceCoarseCell)(face,0);
                    const int tempc1=(*CoarseFaceCoarseCell)(face,1);
                    
                    if(((cc0==tempc0)&&(cc1==tempc1))||((cc1==tempc0)&&(cc0==tempc1)))
                      {

                        T sign(1);
                        if(cc1==tempc0)
                          sign*=-1.;

                        areaSum[face]+=inFA[f]*sign;

                        if(cc1neibs>1 && cc0neibs>1)
                          {
                            CoarseFacesFineFaces->add(face,f);
                            break;
                          }
                        else
                          {
                            T sumMag=sqrt(areaSum[face][0]*areaSum[face][0]+
                                          areaSum[face][1]*areaSum[face][1]+
                                          areaSum[face][2]*areaSum[face][2]);
                            
                            T partMag=sqrt(inFA[f][0]*inFA[f][0]+
                                           inFA[f][1]*inFA[f][1]+
                                           inFA[f][2]*inFA[f][2]);
                            
                            if(sumMag/partMag>.75)
                              {
                                CoarseFacesFineFaces->add(face,f);
                                break;
                              }
                            else
                              areaSum[face]-=inFA[f]*sign;
                          }
                      }
                  }
              }
          }

        CoarseFacesFineFaces->finishAdd();
        
        //const StorageSite& interiorFaces=
        newMeshPtr->createInteriorFaceGroup(coarseInteriorCount);

        int inOffset=coarseInteriorCount;
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          {
            const FaceGroup& fg=*fgPtr;
            const int faceCount=fg.site.getCount();
            if(fg.id>0)
              {
                if(_bcMap[fg.id]->bcType == "Interface")
                  {
                    IntArray& FaceFine2Coarse=*PreFacePairMap[&fg.site];
                    int coarseFaces(0);
                    for(int i=0;i<faceCount;i++)
                      if(FaceFine2Coarse[i]>coarseFaces)
                        coarseFaces=FaceFine2Coarse[i];

                    coarseFaces+=1;

                    //const StorageSite& newBoundarySite=
                    newMeshPtr->createBoundaryFaceGroup(coarseFaces,inOffset,fg.id,fg.groupType);
                    inOffset+=coarseFaces;
                  }
                else
                  {
                    const int size=fg.site.getCount();
                    const StorageSite& newBoundarySite=newMeshPtr->createBoundaryFaceGroup(
                                                                                           size,inOffset,fg.id,fg.groupType);
                    const VectorT3Array& oldFgCoords=dynamic_cast<const VectorT3Array&>(inGeomFields.coordinate[fg.site]);
                    VT3Ptr newFgCoordsPtr=VT3Ptr(new VectorT3Array(size));
                    (*newFgCoordsPtr)=oldFgCoords;
                    inGeomFields.coordinate.addArray(newBoundarySite,newFgCoordsPtr);
                    inOffset+=size;
                  }
              }
          }

        // have to make coarse interface face groups -- !!

        const StorageSite::GatherMap&  coarseGatherMap  = outCells.getGatherMap();

        foreach(const StorageSite::GatherMap::value_type pos, coarseGatherMap)
          {
            const StorageSite& oSite = *pos.first;
            const Array<int>& toIndices = *pos.second;

            int to_where  = oSite.getGatherProcID();
            if ( to_where != -1 )
              {
                const int cellCount=toIndices.getLength();
                int faceCount(0);

                for(int i=0;i<cellCount;i++)
                  {
                    const int c1=toIndices[i];
                    faceCount+=CellCellCoarse->getCount(c1);
                  }

                
                newMeshPtr->createInterfaceGroup(faceCount,inOffset,to_where);
                inOffset+=faceCount;
              }
          }
        
        //now make the geom fields
        const int outCellsCount=outCells.getSelfCount();
        const int outCellsTotCount=outCells.getCount();
        VT3Ptr outCellCoordsPtr=VT3Ptr(new VectorT3Array(outCellsTotCount));
        TArrptr outCellVolumePtr=TArrptr(new TArray(outCellsTotCount));
        TArray& outCV=*outCellVolumePtr;
        VectorT3Array& outCoords=*outCellCoordsPtr;
        outCV=0.;

        Field& VolumeField=inGeomFields.volume;
        const TArray& inCV=dynamic_cast<const TArray&>(VolumeField[inCells]);
        const VectorT3Array& inCoords=dynamic_cast<const VectorT3Array&>(inGeomFields.coordinate[inCells]);

        for(int c=0;c<outCellsCount;c++)
          {
            const int fineCount=CoarseToFineCells->getCount(c);
            VectorT3 newCoord;
            newCoord[0]=0.;
            newCoord[1]=0.;
            newCoord[2]=0.;
            for(int i=0;i<fineCount;i++)
              {
                int fc=(*CoarseToFineCells)(c,i);
                outCV[c]+=inCV[fc];
                newCoord+=inCoords[fc]*inCV[fc];
              }
            outCoords[c]=newCoord/outCV[c];
          }

        for(int c=outCellsCount;c<outCellsTotCount;c++)
          {
            const int fineCount=CoarseToFineCells->getCount(c);
            VectorT3 newCoord;
            newCoord[0]=0.;
            newCoord[1]=0.;
            newCoord[2]=0.;
            for(int i=0;i<fineCount;i++)
              {
                int fc=(*CoarseToFineCells)(c,i);
                newCoord+=inCoords[fc];
              }
            outCoords[c]=newCoord;  
          }     
        
        VolumeField.addArray(outCells,outCellVolumePtr);
        inGeomFields.coordinate.addArray(outCells,outCellCoordsPtr);

        const int outFacesCount=outFaces.getCount();
        VT3Ptr outFaceAreaPtr=VT3Ptr(new VectorT3Array(outFacesCount));
        VectorT3Array& outFA=*outFaceAreaPtr;
        TArrptr outFaceAreaMagPtr=TArrptr(new TArray(outFacesCount));
        TArray& outFAMag=*outFaceAreaMagPtr;

        VectorT3 myZero;
        myZero[0]=0.;
        myZero[1]=0.;
        myZero[2]=0.;

        outFA=myZero;
        outFAMag=0.;
        for(int f=0;f<outFacesCount;f++)
          {
            const int fineCount=CoarseFacesFineFaces->getCount(f);
            const int cCell0=(*CoarseFaceCoarseCell)(f,0);
            for(int i=0;i<fineCount;i++)
              {
                const int fFace=(*CoarseFacesFineFaces)(f,i);
                const int fCell0=inFaceinCells(fFace,0);
                const int CCell0=FineToCoarse[fCell0];
                
                //must make sure the area vector is pointing
                //from c0 to c1
                if(CCell0==cCell0)
                  outFA[f]+=inFA[fFace];
                else
                  outFA[f]-=inFA[fFace];
                outFAMag[f]+=areaMagArray[fFace];
              }
          }

        FaceAreaField.addArray(outFaces,outFaceAreaPtr);
        areaMagField.addArray(outFaces,outFaceAreaMagPtr);
        //cout<<"Level: "<<_level+1<<" Mesh: "<<n<<" Cells: "<<outCells.getSelfCount()<<endl;

        if(smallestMesh<0)
          smallestMesh=outCells.getSelfCount();
        else
          {
            if(outCells.getSelfCount()<smallestMesh)
              smallestMesh=outCells.getSelfCount();
          }

        /*
        //This is for checking purposes only
        cout<<"Coarse Faces to Fine Faces"<<endl;
        for(int f=0;f<outFaces.getCount();f++)
          {
            const int neibs=CoarseFacesFineFaces->getCount(f);
            for(int n=0;n<neibs;n++)
              cout<<f<<" "<<(*CoarseFacesFineFaces)(f,n)<<endl;
            cout<<endl;
          }
        cout<<"Coarse Cells to Coarse Faces"<<endl;
        for(int c=0;c<outCells.getCount();c++)
          {
            const int neibs=CoarseCellCoarseFace->getCount(c);
            for(int n=0;n<neibs;n++)
              cout<<c<<" "<<(*CoarseCellCoarseFace)(c,n)<<endl;
            cout<<endl;
          }
        */
      }

    return smallestMesh;
  }

template<class T >

T COMETModel< T >::getAverageTemperature ( )

inline

Definition at line 4197 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, COMETModel< T >::_macro, Model::_meshes, Mesh::getCells(), StorageSite::getSelfCount(), PhononMacro::temperature, and GeomFields::volume.

  {
    const int numMeshes = _meshes.size();
    T r(0);
    T volTot(0);
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*_meshes[n];
        const StorageSite& cells=mesh.getCells();
        const int numcells=cells.getSelfCount();
        const TArray& Tl=dynamic_cast<const TArray&>(_macro.temperature[cells]);
        const TArray& cv=dynamic_cast<const TArray&>(_geomFields.volume[cells]);
        for(int c=0;c<numcells;c++)
          {
            r+=Tl[c]*cv[c];
            volTot+=cv[c];
          }
      }
    return r/volTot;
  }

template<class T >

COMETBCMap& COMETModel< T >::getBCMap ( )

inline

Definition at line 2258 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_bcMap.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

{return _bcMap;}

template<class T >

COMETBCMap& COMETModel< T >::getBCs ( )

inline

Definition at line 127 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap.

Referenced by COMETModel< T >::MakeCoarseModel().

{return _bcMap;}

template<class T >

DistFunctFields<T>& COMETModel< T >::getdsf ( )

inline

Definition at line 5627 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr.

Referenced by COMETModel< T >::correctSolution(), COMETModel< T >::injectResid(), and COMETModel< T >::MakeIBCoarseModel().

{ return _dsfPtr;} 

template<class T >

DistFunctFields<T>& COMETModel< T >::getdsf0 ( )

inline

Definition at line 5632 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr0.

Referenced by COMETModel< T >::correctSolution(), and COMETModel< T >::injectResid().

{ return _dsfPtr0;}

template<class T >

const DistFunctFields<T>& COMETModel< T >::getdsf1 ( ) const

inline

Definition at line 5628 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr1.

{ return _dsfPtr1;} 

template<class T >

const DistFunctFields<T>& COMETModel< T >::getdsf2 ( ) const

inline

Definition at line 5629 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr2.

{ return _dsfPtr2;}

template<class T >

const DistFunctFields<T>& COMETModel< T >::getdsfEq ( ) const

inline

Definition at line 5630 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtr.

{ return _dsfEqPtr;} 

template<class T >

const DistFunctFields<T>& COMETModel< T >::getdsfEqES ( ) const

inline

Definition at line 5631 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtrES.

{ return _dsfEqPtrES;}

template<class T >

DistFunctFields<T>& COMETModel< T >::getdsfFAS ( )

inline

Definition at line 5635 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtrFAS.

Referenced by COMETModel< T >::injectResid().

{ return _dsfPtrFAS;}

template<class T >

DistFunctFields<T>& COMETModel< T >::getdsfInj ( )

inline

Definition at line 5633 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtrInj.

{ return _dsfPtrInj;}

template<class T >

DistFunctFields<T>& COMETModel< T >::getdsfRes ( )

inline

Definition at line 5634 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtrRes.

{ return _dsfPtrRes;}

template<class T >

const map<int, vector<int> >& COMETModel< T >::getFaceReflectionArrayMap ( ) const

inline

Definition at line 2262 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_faceReflectionArrayMap.

{ return _faceReflectionArrayMap;}

template<class T >

TCOMET* COMETModel< T >::getFinerModel ( )

inline

Definition at line 4241 of file phononbase/COMETModel.h.

References COMETModel< T >::_finerLevel.

Referenced by COMETModel< T >::makeFinestToCoarseConn().

{return _finerLevel;}

template<class T >

GeomFields& COMETModel< T >::getGeomFields ( )

inline

Definition at line 4244 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields.

{return _geomFields;}

template<class T >

GeomFields& COMETModel< T >::getGeomFields ( )

inline

Definition at line 5641 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_geomFields.

Referenced by COMETModel< T >::injectResid(), COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

{return _geomFields;}

template<class T >

IClist& COMETModel< T >::getIClist ( )

inline

Definition at line 4258 of file phononbase/COMETModel.h.

References COMETModel< T >::_IClist.

Referenced by COMETModel< T >::MakeCoarseModel().

{return _IClist;}

template<class T >

Tkspace& COMETModel< T >::getKspace ( const int  i )

inline

Definition at line 4246 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces.

Referenced by COMETModel< T >::correctSolution(), and COMETModel< T >::injectResid().

{return *_kspaces[i];}

template<class T >

TkspList& COMETModel< T >::getKspaces ( )

inline

Definition at line 4245 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces.

Referenced by COMETModel< T >::MakeCoarseModel().

{return _kspaces;}

template<class T >

ArrayBase& COMETModel< T >::getLatticeTemp ( const Mesh &  mesh )

inline

Definition at line 3634 of file phononbase/COMETModel.h.

References COMETModel< T >::_macro, Mesh::getCells(), and PhononMacro::temperature.

  {
    const StorageSite& cells=mesh.getCells();
    TArray& Tl=dynamic_cast<TArray&>(_macro.temperature[cells]);
    return Tl;
  }

template<class T >

int COMETModel< T >::getLevel ( )

inline

Definition at line 4242 of file phononbase/COMETModel.h.

References COMETModel< T >::_level.

{return _level;}

template<class T >

int COMETModel< T >::getLevel ( )

inline

Definition at line 5639 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_level.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

{return _level;}

template<class T >

PhononMacro& COMETModel< T >::getMacro ( )

inline

Definition at line 4247 of file phononbase/COMETModel.h.

References COMETModel< T >::_macro.

{return _macro;}

template<class T >

MacroFields& COMETModel< T >::getMacro ( )

inline

Definition at line 5643 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields.

Referenced by COMETModel< T >::correctSolution(), and COMETModel< T >::injectResid().

{return _macroFields;}

template<class T >

MeshICmap& COMETModel< T >::getMeshICmap ( )

inline

Definition at line 4259 of file phononbase/COMETModel.h.

References COMETModel< T >::_MeshToIC.

Referenced by COMETModel< T >::MakeCoarseModel().

{return _MeshToIC;}

template<class T >

const MeshList& COMETModel< T >::getMeshList ( )

inline

Definition at line 4243 of file phononbase/COMETModel.h.

References Model::_meshes.

{return _meshes;}

template<class T >

const MeshList& COMETModel< T >::getMeshList ( )

inline

Definition at line 5640 of file esbgkbase/COMETModel.h.

References Model::_meshes.

Referenced by COMETModel< T >::correctSolution(), COMETModel< T >::injectResid(), COMETModel< T >::makeCellColors(), COMETModel< T >::MakeCoarseModel(), COMETModel< T >::makeFinestToCoarseConn(), COMETModel< T >::MakeIBCoarseModel(), and COMETModel< T >::makePlotColors().

{return _meshes;}

template<class T >

MeshKspaceMap& COMETModel< T >::getMKMap ( )

inline

Definition at line 128 of file phononbase/COMETModel.h.

References COMETModel< T >::_MeshKspaceMap.

Referenced by COMETModel< T >::MakeCoarseModel().

{return _MeshKspaceMap;}

template<class T >

TCOMET* COMETModel< T >::getModelPointer ( const int  level )

inline

Definition at line 4173 of file phononbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_level, and COMETModel< T >::getModelPointer().

Referenced by COMETModel< T >::getModelPointer(), COMETModel< T >::makeCellColors(), COMETModel< T >::makeFinestToCoarseConn(), and COMETModel< T >::makePlotColors().

  {
    if(_level==level)
      return this;
    else
      return _coarserLevel->getModelPointer(level);
  }

template<class T >

TCModOpts& COMETModel< T >::getOptions ( )

inline

Definition at line 126 of file phononbase/COMETModel.h.

References COMETModel< T >::_options.

{return _options;}

template<class T >

COMETModelOptions<T>& COMETModel< T >::getOptions ( )

inline

Definition at line 2261 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_options.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

{return _options;}

template<class T >

map<string,shared_ptr<ArrayBase> >& COMETModel< T >::getPersistenceData ( )

inlinevirtual

Reimplemented from Model.

Definition at line 2268 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_initialKmodelNorm, COMETModel< T >::_niters, COMETModel< T >::_persistenceData, and Array< T >::zero().

  {
    _persistenceData.clear();
    
    Array<int>* niterArray = new Array<int>(1);
    (*niterArray)[0] = _niters;
    _persistenceData["niters"]=shared_ptr<ArrayBase>(niterArray);
    
    if (_initialKmodelNorm)
    {
      // _persistenceData["initialKmodelNorm"] =_initialKmodelNorm->getArrayPtr(_macroFields.pressure);
       const Field& dsfField = *_dsfPtr.dsf[0];
      _persistenceData["initialKmodelNorm"] =_initialKmodelNorm->getArrayPtr(dsfField);

    }
    else
    {
         Array<T>* xArray = new Array<T>(1);
        xArray->zero();
        _persistenceData["initialKmodelNorm"]=shared_ptr<ArrayBase>(xArray);
        
    }
    return _persistenceData;
  }

template<class T >

TQuad& COMETModel< T >::getQuadrature ( )

inline

Definition at line 5642 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_quadrature.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

{return _quadrature;}

template<class T >

T COMETModel< T >::getResidual ( )

inline

Definition at line 4248 of file phononbase/COMETModel.h.

References COMETModel< T >::_residual.

  {
#ifdef FVM_PARALLEL
    int one=1;
    double tempResid=_residual;
    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &tempResid, one, MPI::DOUBLE, MPI::SUM);
    _residual=tempResid;
#endif
    return _residual;
  }

template<class T >

T COMETModel< T >::getResidual ( )

inline

Definition at line 5644 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_residual.

{return _residual;}

template<class T >

ArrayBase* COMETModel< T >::getValueArray ( const Mesh &  mesh, const int  cell  )

inline

Definition at line 3580 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_MeshKspaceMap, Mesh::getCells(), pmode< T >::getfield(), Mesh::getID(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), and Kspace< T >::gettotmodes().

    {
      //only returns the e" values, not the lattice temperature
      const int n=mesh.getID();
      Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
      const int allModes=kspace.gettotmodes();
      TArray* vals=new TArray(allModes);
      const StorageSite& cells=mesh.getCells();
      const int len=kspace.getlength();
      int count=0;
      for(int k=0;k<len;k++)
        {
          Tkvol& kvol=kspace.getkvol(k);
          const int modes=kvol.getmodenum();
          for(int m=0;m<modes;m++)
            {
              Tmode& mode=kvol.getmode(m);
              Field& eField=mode.getfield();
              const TArray& eArray=dynamic_cast<const TArray&>(eField[cells]);
              (*vals)[count]=eArray[cell];
              count++;
            }
        }
      return vals;
    }

template<class T >

COMETVCMap& COMETModel< T >::getVCMap ( )

inline

Definition at line 2259 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_vcMap.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

{return _vcMap;}

template<class T >

T COMETModel< T >::getWallArea ( const Mesh &  mesh, const int  faceGroupId  )

inline

Definition at line 3513 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, GeomFields::areaMag, Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), FaceGroup::id, and FaceGroup::site.

  {
    T r(0.);
    bool found = false;
    foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
      {
        const FaceGroup& fg = *fgPtr;
        if (fg.id == faceGroupId)
          {
            const StorageSite& faces = fg.site;
            const int nFaces = faces.getCount();
            const Field& areaMagField=_geomFields.areaMag;
            const TArray& faceArea=dynamic_cast<const TArray&>(areaMagField[faces]);
                    
            for(int f=0; f<nFaces; f++)
              r += faceArea[f];
            
            found=true;
            break;
          }
      }

    if (!found)
      throw CException("getwallArea: invalid faceGroupID");
    return r;
  }

template<class T >

VectorT3 COMETModel< T >::getWallAreaVector ( const Mesh &  mesh, const int  faceGroupId  )

inline

Definition at line 3540 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, GeomFields::area, Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), FaceGroup::id, and FaceGroup::site.

  {
    VectorT3 An;
    An=0.;
    bool found = false;
    foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
      {
        const FaceGroup& fg = *fgPtr;
        if (fg.id == faceGroupId)
          {
            const StorageSite& faces = fg.site;
            const int nFaces = faces.getCount();
            const Field& areaField=_geomFields.area;
            const VectorT3Array& faceArea=dynamic_cast<const VectorT3Array&>(areaField[faces]);
            for(int f=0; f<nFaces; f++)
              An+=faceArea[f];
            found=true;
            break;
          }
      }

#ifdef FVM_PARALLEL
    found=true;
    int one=1;
    double tempR=An[0];
    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &tempR, one, MPI::DOUBLE, MPI::SUM);
    An[0]=tempR;
    tempR=An[1];
    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &tempR, one, MPI::DOUBLE, MPI::SUM);
    An[1]=tempR;
    tempR=An[2];
    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &tempR, one, MPI::DOUBLE, MPI::SUM);
    An[2]=tempR;
#endif

    if (!found)
      throw CException("getwallArea: invalid faceGroupID");
    return An;
  }

template<class T >

T COMETModel< T >::HeatFluxIntegral ( const Mesh &  mesh, const int  faceGroupId  )

inline

Definition at line 3291 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, COMETModel< T >::_MeshKspaceMap, GeomFields::area, Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::getDK3(), Kspace< T >::geteArray(), Mesh::getFaceCells(), Kspace< T >::getGlobalIndex(), Mesh::getID(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), pmode< T >::getv(), FaceGroup::id, and FaceGroup::site.

  {
    T r(0.);
    bool found = false;
    const int n=mesh.getID();
    Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
    TArray& eArray=kspace.geteArray();
    const T DK3=kspace.getDK3();

    const T hbar=6.582119e-16;  // (eV s)

    foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
      {
        const FaceGroup& fg = *fgPtr;
        if (fg.id == faceGroupId)
          {
            const StorageSite& faces = fg.site;
            const int nFaces = faces.getCount();
            //const StorageSite& cells = mesh.getCells();
            const CRConnectivity& faceCells=mesh.getFaceCells(faces);
            const Field& areaField=_geomFields.area;
            const VectorT3Array& faceArea=dynamic_cast<const VectorT3Array&>(areaField[faces]);
            
            for(int f=0; f<nFaces; f++)
              {
                const VectorT3 An=faceArea[f];
                const int c1=faceCells(f,1);
                int cellIndex=kspace.getGlobalIndex(c1,0);
                for(int k=0;k<kspace.getlength();k++)
                  {
                    Tkvol& kv=kspace.getkvol(k);
                    int modenum=kv.getmodenum();
                    for(int m=0;m<modenum;m++)
                      {
                        VectorT3 vg=kv.getmode(m).getv();
                        T dk3=kv.getdk3();
                        //T energy=hbar*kv.getmode(m).getomega();
                        const T vgdotAn=An[0]*vg[0]+An[1]*vg[1]+An[2]*vg[2];
                        r += eArray[cellIndex]*vgdotAn*(dk3/DK3);//*energy;
                        cellIndex++;
                      }
                  }
              }
            found=true;
          }
      }

#ifdef FVM_PARALLEL
    found=true;
    int one=1;
    double tempR=r;
    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &tempR, one, MPI::DOUBLE, MPI::SUM);
    r=tempR;
#endif

    if (!found)
      throw CException("getHeatFluxIntegral: invalid faceGroupID");
    return r*DK3;
  }

template<class T >

T COMETModel< T >::HeatFluxIntegralFace ( const Mesh &  mesh, const int  f  )

inline

Definition at line 3351 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, COMETModel< T >::_MeshKspaceMap, GeomFields::area, kvol< T >::getdk3(), Kspace< T >::getDK3(), Kspace< T >::geteArray(), Mesh::getFaceCells(), Kspace< T >::getGlobalIndex(), Mesh::getID(), Mesh::getInteriorFaceGroup(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), pmode< T >::getv(), and FaceGroup::site.

  {
    T r(0.);
    //bool found = false;
    const int n=mesh.getID();
    Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
    TArray& eArray=kspace.geteArray();
    const T DK3=kspace.getDK3();

    const T hbar=6.582119e-16;  // (eV s)
    //const FaceGroupPtr fgPtr=mesh.getInteriorFaceGroup();

    const FaceGroup& fg = mesh.getInteriorFaceGroup();

    const StorageSite& faces = fg.site;
    //const int nFaces = faces.getCount();
    //const StorageSite& cells = mesh.getCells();
    const CRConnectivity& faceCells=mesh.getFaceCells(faces);
    const Field& areaField=_geomFields.area;
    const VectorT3Array& faceArea=dynamic_cast<const VectorT3Array&>(areaField[faces]);
            
    
    const VectorT3 An=faceArea[f];
    const int c1=faceCells(f,1);
    const int c0=faceCells(f,0);
    int cellIndex=kspace.getGlobalIndex(c1,0);
    int cellIndex0=kspace.getGlobalIndex(c0,0);
    for(int k=0;k<kspace.getlength();k++)
      {
        Tkvol& kv=kspace.getkvol(k);
        int modenum=kv.getmodenum();
        for(int m=0;m<modenum;m++)
          {
            VectorT3 vg=kv.getmode(m).getv();
            T dk3=kv.getdk3();
            //T energy=hbar*kv.getmode(m).getomega();
            const T vgdotAn=An[0]*vg[0]+An[1]*vg[1]+An[2]*vg[2];
            if(vgdotAn>0)
              r += eArray[cellIndex0]*vgdotAn*(dk3/DK3);//*energy;
            else
              r += eArray[cellIndex]*vgdotAn*(dk3/DK3);
            cellIndex++;
            cellIndex0++;
          }
      }
      
    return r*DK3;
  }

template<class T >

void COMETModel< T >::init ( )

inlinevirtual

Implements Model.

Definition at line 130 of file phononbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_geomFields, COMETModel< T >::_IClist, COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_MeshToIC, COMETModel< T >::_options, COMETModel< T >::_rank, COMETModel< T >::_residual, Field::addArray(), GeomFields::area, GeomFields::areaMag, PhononMacro::BranchTemperatures, COMETModel< T >::calcDomainStats(), pmode< T >::calce0(), Mesh::COMETfindCommonFaces(), PhononMacro::deltaT, COMETIC< T >::FgID1, Kspace< T >::findSpecs(), GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaceCells(), Kspace< T >::getGlobalIndex(), Mesh::getID(), Mesh::getInterfaceGroups(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), StorageSite::getOffset(), pmode< T >::getreflmap(), pmode< T >::gettau(), Kspace< T >::gettotmodes(), pmode< T >::getv(), PhononMacro::heatFlux, FaceGroup::id, COMETModel< T >::initializeTemperatureBoundaries(), COMETIC< T >::InterfaceModel, PhononMacro::lam, COMETModel< T >::MakeCoarseModel(), COMETInterface< T >::makeDMMcoeffs(), COMETInterface< T >::makeNoInterfaceCoeffs(), COMETIC< T >::MeshID0, COMETIC< T >::MeshID1, Kspace< T >::sete0Array(), Kspace< T >::seteArray(), COMETModel< T >::setFinestLevel(), COMETModel< T >::setLocalScatterMaps(), Kspace< T >::setResArray(), Kspace< T >::setSourceArray(), Kspace< T >::setTauArray(), FaceGroup::site, sqrt(), PhononMacro::temperature, PhononMacro::TlResidual, COMETInterface< T >::updateOtherGhost(), COMETModel< T >::updateResid(), Kspace< T >::updateTau(), Vector< T, N >::zero(), and Array< T >::zero().

  {
    const int numMeshes=_meshes.size();
    const T Tinit=_options["initialTemperature"];

     for (int n=0;n<numMeshes;n++)
       {
         Mesh& mesh=*_meshes[n];
         if(_MeshKspaceMap[n]==-1)
           throw CException("Have not set the Kspace for this Mesh!!");
         Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
         const int kcount=kspace.gettotmodes();
         BCfaceArray& BCfArray=*(_BFaces[n]);
         BCcellArray& BCArray=*(_BCells[n]);
         const int numK=kspace.getlength();
         const StorageSite& cells=mesh.getCells();
         const int numcells=cells.getCount();
         VectorT3 lamTemp;

         // set micro parameters
         //cout<<"Allocating Arrays..."<<endl;
         shared_ptr<TArray> eArray(new TArray(numcells*kcount));
         shared_ptr<TArray> e0Array(new TArray(numcells*kcount));
         shared_ptr<TArray> ResidArray(new TArray(numcells*kcount));
         shared_ptr<TArray> tauArray(new TArray(numcells*kcount));
         kspace.seteArray(eArray);
         kspace.sete0Array(e0Array);
         kspace.setResArray(ResidArray);
         kspace.setTauArray(tauArray);

         if(_options.Source)
           {
             shared_ptr<TArray> SrcArray(new TArray(numcells*kcount));
             SrcArray->zero();
             kspace.setSourceArray(SrcArray);
           }
         
         shared_ptr<TArray> TLcell(new TArray(numcells));
         shared_ptr<TArray> deltaTcell(new TArray(numcells));
         shared_ptr<VectorT3Array> lamArray(new VectorT3Array(numcells));
         shared_ptr<VectorT3Array> q(new VectorT3Array(numcells));
         lamTemp.zero();
         q->zero();
         *lamArray=lamTemp;
         *deltaTcell=0.;
         *TLcell=Tinit;
         _macro.temperature.addArray(cells,TLcell);
         _macro.deltaT.addArray(cells,deltaTcell);
         _macro.lam.addArray(cells,lamArray);
         _macro.heatFlux.addArray(cells,q);

         shared_ptr<IntArray> f2c(new IntArray(numcells));
         *f2c=-1;
         _geomFields.fineToCoarse.addArray(cells, f2c);

         int modeCount=kspace.getkvol(0).getmodenum();
         FieldVector* FieldVecPtr=new FieldVector();

         for(int mode=0;mode<modeCount;mode++)
           {
             shared_ptr<Field> modeField(new Field("mode"));
             shared_ptr<TArray> modeTemp(new TArray(numcells));
             *modeTemp=Tinit;
             modeField->addArray(cells,modeTemp);
             FieldVecPtr->push_back(modeField);
           }

         _macro.BranchTemperatures[n]=FieldVecPtr;

         //cout<<"Arrays Allocated...Initializing Values..."<<endl;
         
         for(int c=0;c<numcells;c++)
           {
             int cellIndex=kspace.getGlobalIndex(c,0);
             for (int k=0;k<numK;k++)
               {
                 Tkvol& kv=kspace.getkvol(k);
                 const int numM=kv.getmodenum();
                 //const T dk3=kv.getdk3();

                 for (int m=0;m<numM;m++)
                   {
                     Tmode& mode=kv.getmode(m);
                     T tau=mode.gettau();
                     const T einit=mode.calce0(Tinit);
                     /*
                     if(m==0 && k==0)
                       (*eArray)[cellIndex]=1.1*einit;
                       else*/

                     (*eArray)[cellIndex]=einit;
                     (*e0Array)[cellIndex]=einit;
                     (*ResidArray)[cellIndex]=0.;
                     (*tauArray)[cellIndex]=tau;
                     cellIndex++;
                   }
               }
             kspace.updateTau(c,Tinit);
           }
         
         
         shared_ptr<TArray> TlResidCell(new TArray(numcells));
         *TlResidCell=0.;
         _macro.TlResidual.addArray(cells,TlResidCell);

         //cout<<"Values Initialized...Setting Facegroups..."<<endl;
         
         //setting facegroups

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

             const int faceCount=faces.getCount();
             const int offSet=faces.getOffset();

             for(int i=offSet;i<offSet+faceCount;i++)
               BCfArray[i]=-1;  //implicit boundary
           }
         

         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
           {
             FaceGroup& fg = *fgPtr;
             if(fg.id>0)
               {
                 if(_bcMap[fg.id]->bcType == "reflecting")
                   {
                     const StorageSite& faces = fg.site;
                     const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                     const int faceCount=faces.getCount();
                     const int offSet=faces.getOffset();
                     const bool Imp=(*(_bcMap[fg.id]))["FullyImplicit"];
                     const T ref=(*(_bcMap[fg.id]))["specifiedReflection"];
                     const Field& AreaMagField=_geomFields.areaMag;
                     const TArray& AreaMag=
                       dynamic_cast<const TArray&>(AreaMagField[faces]);
                     const Field& AreaDirField=_geomFields.area;
                     const VectorT3Array& AreaDir=
                       dynamic_cast<const VectorT3Array&>(AreaDirField[faces]);

                     const VectorT3 norm=AreaDir[0]/AreaMag[0];

                     if(ref==1.)
                       {
                         for (int k=0;k<numK;k++)
                           {
                             Tkvol& kv=kspace.getkvol(k);
                             const int numM=kv.getmodenum();
                             //const T dk3=kv.getdk3();
                             for (int m=0;m<numM;m++)
                               {

                                 Tmode& mode=kv.getmode(m);
                                 const VectorT3 vg=mode.getv();
                                 const T vmag=sqrt(pow(vg[0],2)+pow(vg[1],2)+pow(vg[2],2));
                                 VectorT3 si=vg/vmag;
                                 VectorT3 so;
                                 const T sidotn=si[0]*norm[0]+si[1]*norm[1]+si[2]*norm[2];
                                 Refl_Map& rmap=mode.getreflmap();

                                 if (sidotn > T_Scalar(0.0))
                                   {
                                     so=si-2.*(si[0]*norm[0]+si[1]*norm[1]+si[2]*norm[2])*norm;
                                     T soMag=sqrt(pow(so[0],2)+pow(so[1],2)+pow(so[2],2));
                                     so/=soMag;
                                     so*=vmag;
                                     Refl_pair refls;
                                     Refl_pair reflsFrom;
                                     kspace.findSpecs(norm,m,k,refls);
                                     rmap[fg.id]=refls;
                                     const int k1=refls.first.second;
                                     Tmode& mode2=kspace.getkvol(k1).getmode(m);
                                     Refl_Map& rmap2=mode2.getreflmap();
                                     reflsFrom.first.second=-1;
                                     reflsFrom.second.second=k;
                                     rmap2[fg.id]=reflsFrom;
                                   }
                               }
                           }
                       }
                     
                     if(Imp)
                       {
                         for(int i=offSet;i<offSet+faceCount;i++)
                           BCfArray[i]=2;  //implicit boundary
                       }
                     else
                       {
                         for(int i=offSet;i<offSet+faceCount;i++)
                           BCfArray[i]=3;  //explicit boundary
                       }
                     
                     if(Imp)
                       {
                         for(int i=0;i<faceCount;i++)
                           {
                             int cell1=BfaceCells(i,0);
                             if(BCArray[cell1]==0)
                               BCArray[cell1]=1;    //implicit boundary only
                             else if(BCArray[cell1]==2)
                               BCArray[cell1]=3;  //mix implicit/explicit boundary
                           }
                       }
                     else
                       {
                         for(int i=0;i<faceCount;i++)
                           {
                             int cell1=BfaceCells(i,0);
                             if(BCArray[cell1]==0)
                               BCArray[cell1]=2;  //explicit boundary only
                             else if (BCArray[cell1]==1)
                               BCArray[cell1]=3;  //mix implicit/explicit boundary
                           }
                       }
                   }
                 else if(_bcMap[fg.id]->bcType == "temperature")
                   {
                     const StorageSite& faces = fg.site;
                     const int faceCount=faces.getCount();
                     const int offSet=faces.getOffset();
                     
                     for(int i=offSet;i<offSet+faceCount;i++)
                       BCfArray[i]=1;
                   }
                 else if(_bcMap[fg.id]->bcType == "Interface")
                   {             
                     StorageSite& faces0 = fg.site;
                     const CRConnectivity& BfaceCells=mesh.getFaceCells(faces0);
                     const int faceCount=faces0.getCount();
                     const int offSet=faces0.getOffset();
                     
                     for(int i=offSet;i<offSet+faceCount;i++)
                       {
                         BCfArray[i]=4;  //Interface boundary
                         int cell0=BfaceCells(i-offSet,0);
                         int cell1=BfaceCells(i-offSet,1);
                         BCArray[cell0]=2;  //always treated explicitly
                         BCArray[cell1]=4; //interface ghost cells need to be labeled
                       }
                     
                     bool doneAlready=false;
                     foreach(const COMETIC<T>* icPtr, _IClist)
                       {
                         if(icPtr->FgID1==fg.id && icPtr->MeshID1==mesh.getID())
                           {
                             doneAlready=true;
                             break;
                           }
                       }
                     
                     bool foundMatch=false;
                     if(!doneAlready)
                       {
                         StorageSite* faces1Ptr=NULL;
                         int otherFgID,otherMid;
                         for(int otherMeshID=n+1;otherMeshID<numMeshes;otherMeshID++)
                           {
                             const Mesh& otherMesh=*_meshes[otherMeshID];
                             foreach(const FaceGroupPtr otherfgPtr, otherMesh.getBoundaryFaceGroups())
                               {
                                 foundMatch=mesh.COMETfindCommonFaces(faces0, otherfgPtr->site, _geomFields);
                                 if(foundMatch)
                                   {
                                     otherFgID=otherfgPtr->id;
                                     otherMid=otherMeshID;
                                     faces1Ptr=&(otherfgPtr->site);
                                     break;
                                   }
                               }
                             if(foundMatch)
                               break;
                           }
                         
                         if(foundMatch)
                           {
                             StorageSite& faces1=*faces1Ptr;
                             const Mesh& mesh1=*_meshes[otherMid];
                             COMETIC<T>* icPtr(new COMETIC<T>(n,fg.id,mesh1.getID(),
                                                              otherFgID, faces1.getCount()));
                             
                             icPtr->InterfaceModel=_bcMap[fg.id]->InterfaceModel;
                             
                             setLocalScatterMaps(mesh, faces0, mesh1, faces1);
                             
                             _IClist.push_back(icPtr);
                           }
                         else if(!doneAlready && !foundMatch)
                           {
                             cout<<"Face Group: "<<fg.id<<" MeshID: "<<mesh.getID()<<endl;
                             throw CException("Could not find a matching face group!");
                           }
                       }
                   }// end if interface 
               }
           }//end facegroup loop

         //cout<<"Facegroups Set...Mesh "<<n<<" Complete."<<endl;
         
       }//end meshes loop

     //cout<<"Mesh Loop Complete...Creating Interfaces (if any)..."<<endl;

     //Make map from mesh to IC
     IntArray ICcount(numMeshes);
     ICcount.zero();
     
     foreach(const COMETIC<T>* icPtr, _IClist)
       {
         ICcount[icPtr->MeshID0]++;
         ICcount[icPtr->MeshID1]++;
       }

     if(!_IClist.empty())
       {
         for(int i=0;i<numMeshes;i++)
           {
             IntArrPtr MeshToIC(new IntArray(ICcount[i]));
             _MeshToIC.push_back(MeshToIC);
           }
       }
     
     ICcount.zero();
     const int listSize=_IClist.size();
     for(int ic=0;ic<listSize;ic++)
       {
         const COMETIC<T>* icPtr=_IClist[ic];
         (*(_MeshToIC[icPtr->MeshID0]))[ICcount[icPtr->MeshID0]]=ic;
         (*(_MeshToIC[icPtr->MeshID1]))[ICcount[icPtr->MeshID1]]=ic;
         ICcount[icPtr->MeshID0]++;
         ICcount[icPtr->MeshID1]++;
       }

     COMETInterface<T> ComInt(_meshes,_kspaces,_MeshKspaceMap,_macro,_geomFields);

     for(int ic=0;ic<listSize;ic++)
       {
         COMETIC<T>* icPtr=_IClist[ic];
         const int mid0=icPtr->MeshID0;
         const int mid1=icPtr->MeshID1;
         if(icPtr->InterfaceModel=="DMM")
           ComInt.makeDMMcoeffs(*icPtr);
         else if(icPtr->InterfaceModel=="NoInterface")
           ComInt.makeNoInterfaceCoeffs(*icPtr);
         ComInt.updateOtherGhost(*icPtr,mid0,false);
         ComInt.updateOtherGhost(*icPtr,mid1,false);
       }

     //cout<<"Interfaces Complete..."<<endl;
     
     initializeTemperatureBoundaries();
     _residual=updateResid(false);

     if(_options.DomainStats=="Loud")
       {
         cout<<"Creating Coarse Levels on rank "<<_rank<<"..."<<endl;
         cout<<"Level: 0, rank: "<<_rank<<endl<<endl;
         calcDomainStats();
         cout<<endl;
       }

     MakeCoarseModel(this);
     setFinestLevel(this);
     if(_options.DomainStats=="Loud")
       cout<<"Coarse Levels Completed on rank "<<_rank<<"."<<endl;
  }

template<class T >

void COMETModel< T >::init ( )

inlinevirtual

Implements Model.

Definition at line 185 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_faceReflectionArrayMap, COMETModel< T >::_finestGeomFields, COMETModel< T >::_finestMeshes, COMETModel< T >::_geomFields, COMETModel< T >::_ibm, COMETModel< T >::_initialKmodelNorm, COMETModel< T >::_level, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_niters, COMETModel< T >::_options, COMETModel< T >::_quadrature, COMETModel< T >::_vcMap, COMETModel< T >::_ZCells, Field::addArray(), GeomFields::area, GeomFields::areaMag, MacroFields::coeff, MacroFields::coeffg, MacroFields::collisionFrequency, MacroFields::density, MacroFields::Entropy, MacroFields::EntropyGenRate, MacroFields::EntropyGenRate_Collisional, GeomFields::finestToCoarse, GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), StorageSite::getCountLevel1(), Mesh::getFaceCells(), Mesh::getFaces(), Mesh::getID(), Mesh::getInterfaceGroups(), StorageSite::getOffset(), StorageSite::getSelfCount(), FaceGroup::groupType, GeomFields::ibType, Mesh::IBTYPE_BOUNDARY, Mesh::IBTYPE_FLUID, FaceGroup::id, MacroFields::InterfaceDensity, MacroFields::InterfacePressure, MacroFields::InterfaceStress, MacroFields::InterfaceVelocity, MacroFields::Knq, MacroFields::pressure, FaceGroup::site, MacroFields::Stress, Field::syncLocal(), MacroFields::temperature, MacroFields::Txx, MacroFields::Txy, MacroFields::Tyy, MacroFields::Tyz, MacroFields::Tzx, MacroFields::Tzz, MacroFields::velocity, and MacroFields::viscosity.

Referenced by COMETModel< T >::COMETModel(), and COMETModel< T >::MakeIBCoarseModel().

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

          const COMETVC<T>& vc = *_vcMap[mesh.getID()];
          
          const StorageSite& cells = mesh.getCells();
          const StorageSite& fCells = fMesh.getCells();   

          const int nCells = cells.getCountLevel1();
          shared_ptr<VectorT3Array> vCell(new VectorT3Array(nCells));
          
          VectorT3 initialVelocity;
          initialVelocity[0] = _options["initialXVelocity"];
          initialVelocity[1] = _options["initialYVelocity"];
          initialVelocity[2] = _options["initialZVelocity"];
          *vCell = initialVelocity;
          _macroFields.velocity.addArray(cells,vCell);

          shared_ptr<IntArray> fineToCoarseCell(new IntArray(nCells));
          *fineToCoarseCell = -1;
          _geomFields.fineToCoarse.addArray(cells,fineToCoarseCell);

          if((_ibm==1)&&(_level==0))
          {
              _geomFields.ibType.syncLocal();
              shared_ptr<Array<Vector<int,25> > >finestToCoarseCell(new Array<Vector<int,25> >(fCells.getCountLevel1()));
              Vector<int,25> initialIndex;
              for(int k=0;k<25;k++)
                initialIndex[k]=-1;
              *finestToCoarseCell = initialIndex;
              _finestGeomFields.finestToCoarse.addArray(fCells,finestToCoarseCell);
              Field& FinestToCoarseField=_finestGeomFields.finestToCoarse;
              Array<Vector<int,25> >& FinestToCoarse=dynamic_cast<Array<Vector<int,25> >&>(FinestToCoarseField[fCells]);
              for(int c=0;c<nCells;c++)
                FinestToCoarse[c][_level]=c;
          }
          
          shared_ptr<TArray> pCell(new TArray(nCells));
          *pCell = _options["operatingPressure"];
          _macroFields.pressure.addArray(cells,pCell);
          
          shared_ptr<TArray> rhoCell(new TArray(nCells));
          *rhoCell = 0.;
          //*rhoCell = vc["density"];
          _macroFields.density.addArray(cells,rhoCell);
          
          shared_ptr<TArray> muCell(new TArray(nCells));
          *muCell = 0.;
          //*muCell = vc["viscosity"];
          _macroFields.viscosity.addArray(cells,muCell);

          shared_ptr<TArray> tempCell(new TArray(nCells));
          *tempCell = _options["operatingTemperature"];
          _macroFields.temperature.addArray(cells,tempCell);

          shared_ptr<TArray> collFreqCell(new TArray(nCells));
          *collFreqCell = 0.;
          //*collFreqCell = vc["viscosity"];
          _macroFields.collisionFrequency.addArray(cells,collFreqCell);
          
          //coeffs for perturbed BGK distribution function
          shared_ptr<VectorT5Array> coeffCell(new VectorT5Array(nCells));
          VectorT5 initialCoeff;
          initialCoeff[0] = 1.0;
          initialCoeff[1] = 1.0;
          initialCoeff[2] = 0.0; 
          initialCoeff[3] = 0.0;
          initialCoeff[4] = 0.0;
          *coeffCell = initialCoeff;
          _macroFields.coeff.addArray(cells,coeffCell);
          
          //coeffs for perturbed BGK distribution function
          shared_ptr<VectorT10Array> coeffgCell(new VectorT10Array(nCells));
          VectorT10 initialCoeffg;
          initialCoeffg[0] = 1.0;
          initialCoeffg[1] = 1.0;
          initialCoeffg[2] = 0.0; 
          initialCoeffg[3] = 1.0;
          initialCoeffg[4] = 0.0; 
          initialCoeffg[5] = 1.0;
          initialCoeffg[6] = 0.0;
          initialCoeffg[7] = 0.0; 
          initialCoeffg[8] = 0.0;
          initialCoeffg[9] = 0.0;
          *coeffgCell = initialCoeffg;
          _macroFields.coeffg.addArray(cells,coeffgCell);
          
          // used for ESBGK equilibrium distribution function
          shared_ptr<TArray> tempxxCell(new TArray(cells.getCountLevel1()));
          *tempxxCell = _options["operatingTemperature"]/3;
          _macroFields.Txx.addArray(cells,tempxxCell);
          
          shared_ptr<TArray> tempyyCell(new TArray(cells.getCountLevel1()));
          *tempyyCell = _options["operatingTemperature"]/3;
          _macroFields.Tyy.addArray(cells,tempyyCell);
          
          shared_ptr<TArray> tempzzCell(new TArray(cells.getCountLevel1()));
          *tempzzCell = _options["operatingTemperature"]/3;
          _macroFields.Tzz.addArray(cells,tempzzCell);
          
          shared_ptr<TArray> tempxyCell(new TArray(cells.getCountLevel1()));
          *tempxyCell = 0.0;
          _macroFields.Txy.addArray(cells,tempxyCell);
          
          shared_ptr<TArray> tempyzCell(new TArray(cells.getCountLevel1()));
          *tempyzCell = 0.0;
          _macroFields.Tyz.addArray(cells,tempyzCell);
          
          shared_ptr<TArray> tempzxCell(new TArray(cells.getCountLevel1()));
          *tempzxCell = 0.0;
          _macroFields.Tzx.addArray(cells,tempzxCell);
          
        //Entropy and Entropy Generation Rate for switching
          shared_ptr<TArray> EntropyCell(new TArray(cells.getCountLevel1()));
          *EntropyCell = 0.0;
          _macroFields.Entropy.addArray(cells,EntropyCell);
          
          shared_ptr<TArray> EntropyGenRateCell(new TArray(cells.getCountLevel1()));
          *EntropyGenRateCell = 0.0;
          _macroFields.EntropyGenRate.addArray(cells,EntropyGenRateCell);

          shared_ptr<TArray> EntropyGenRateColl(new TArray(cells.getCountLevel1()));
          *EntropyGenRateColl = 0.0;
          _macroFields.EntropyGenRate_Collisional.addArray(cells,EntropyGenRateColl);
          
        //Pxx,Pyy,Pzz,Pxy,Pxz,Pyz
        shared_ptr<VectorT6Array> stressCell(new VectorT6Array(nCells));
        VectorT6 initialstress;
        initialstress[0] = 1.0;
        initialstress[1] = 1.0;
        initialstress[2] = 1.0; 
        initialstress[3] = 0.0;
        initialstress[4] = 0.0; 
        initialstress[5] = 0.0;
        *stressCell = initialstress;
        _macroFields.Stress.addArray(cells,stressCell);

        //Knq=M300+M120+M102 for Couette with uy
        shared_ptr<TArray> KnqCell(new TArray(cells.getCountLevel1()));
        *KnqCell = 0.0;
        _macroFields.Knq.addArray(cells,KnqCell);


        //higher order moments of distribution function
        /*
        shared_ptr<VectorT3Array> M300Cell(new VectorT3Array(cells.getCount()));
        VectorT3 initialM300;
        initialM300[0] = 0.0;
        initialM300[1] = 0.0;
        initialM300[2] = 0.0; 
        *M300Cell = initialM300;
        _macroFields.M300.addArray(cells,M300Cell);

        shared_ptr<VectorT3Array> M030Cell(new VectorT3Array(cells.getCount()));
        VectorT3 initialM030;
        initialM030[0] = 0.0;
        initialM030[1] = 0.0;
        initialM030[2] = 0.0; 
        *M300Cell = initialM030;
        _macroFields.M030.addArray(cells,M030Cell);
        */
        //if(MPI::COMM_WORLD.Get_rank()==0)
        //cout<<"array for fields created"<<endl;
        const int numDirections = _quadrature.getDirCount();
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        //FILE * pFile;
        //pFile=fopen("ref_incMEMOSA.txt","w");
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups()){
          const FaceGroup& fg = *fgPtr; 
          
          if((_bcMap[fg.id]->bcType == "SymmetryBC")||(_bcMap[fg.id]->bcType == "RealWallBC")||(_bcMap[fg.id]->bcType == "VelocityInletBC")){
          
            const StorageSite& faces = fg.site;
                         
            const Field& areaMagField = _geomFields.areaMag;
            const TArray& faceAreaMag = dynamic_cast<const TArray &>(areaMagField[faces]);
            const Field& areaField = _geomFields.area;
            const VectorT3Array& faceArea=dynamic_cast<const VectorT3Array&>(areaField[faces]); 
          
              const VectorT3 en = faceArea[0]/faceAreaMag[0];
              vector<int> tempVec(numDirections);
              
              for (int j=0; j<numDirections; j++){
                const T c_dot_en = cx[j]*en[0]+cy[j]*en[1]+cz[j]*en[2]; 
                const T cx_incident = cx[j] - 2.0*c_dot_en*en[0];
                const T cy_incident = cy[j] - 2.0*c_dot_en*en[1];
                const T cz_incident = cz[j] - 2.0*c_dot_en*en[2];           
                int direction_incident=0; 
                T Rdotprod=1e54;
                T dotprod=0.0;
                for (int js=0; js<numDirections; js++){
                  dotprod=pow(cx_incident-cx[js],2)+pow(cy_incident-cy[js],2)+pow(cz_incident-cz[js],2);
                  if (dotprod< Rdotprod){
                    Rdotprod =dotprod;
                    direction_incident=js;}
                }
                tempVec[j] = direction_incident;
                //fprintf(pFile,"%d %d %d \n",fg.id, j,direction_incident);
                
              }
              const int fgid=fg.id;
              _faceReflectionArrayMap[fgid] = tempVec; //add to map
            
          }
        }
       
        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups()){
          const FaceGroup& fg = *fgPtr; 
          if(fg.groupType == "NSinterface"){
            const StorageSite& Intfaces = fg.site; 
            
            shared_ptr<VectorT3Array> InterfaceVelFace(new VectorT3Array(Intfaces.getCount()));
            InterfaceVelFace ->zero();
            _macroFields.InterfaceVelocity.addArray(Intfaces,InterfaceVelFace);
            
            shared_ptr<StressTensorArray> InterfaceStressFace(new StressTensorArray(Intfaces.getCount()));
            InterfaceStressFace ->zero();
            _macroFields.InterfaceStress.addArray(Intfaces,InterfaceStressFace);
            
            shared_ptr<TArray> InterfacePressFace(new TArray(Intfaces.getCount()));
            *InterfacePressFace = _options["operatingPressure"];
            _macroFields.InterfacePressure.addArray(Intfaces,InterfacePressFace);
            
            shared_ptr<TArray> InterfaceDensityFace(new TArray(Intfaces.getCount()));
            *InterfaceDensityFace =vc["density"];
            _macroFields.InterfaceDensity.addArray(Intfaces,InterfaceDensityFace);
            
            
          }
          
          //fclose(pFile);
          
          
        } //end of loop through meshes
      
        BCcellArray& BCArray=*(_BCells[n]);
        BCfaceArray& BCfArray=*(_BFaces[n]);
        BCcellArray& ZCArray=*(_ZCells[n]);
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            if((_bcMap[fg.id]->bcType == "WallBC")||(_bcMap[fg.id]->bcType == "RealWallBC"))
            {
                const StorageSite& faces = fg.site;
                const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                const int faceCount=faces.getCount();
                const int offSet=faces.getOffset();

                for(int i=offSet;i<offSet+faceCount;i++)
                  BCfArray[i]=2;

                for(int i=0;i<faceCount;i++)
                {
                    int cell1=BfaceCells(i,0);
                    BCArray[cell1]=1;
                }
            }
            else if(_bcMap[fg.id]->bcType == "VelocityInletBC")
            {
                const StorageSite& faces = fg.site;
                const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                const int faceCount=faces.getCount();
                const int offSet=faces.getOffset();

                for(int i=offSet;i<offSet+faceCount;i++)
                  BCfArray[i]=3;

                for(int i=0;i<faceCount;i++)
                {
                    int cell1=BfaceCells(i,0);
                    BCArray[cell1]=1;
                }
            }
            else if(_bcMap[fg.id]->bcType == "ZeroGradBC")
            {
                const StorageSite& faces = fg.site;
                const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                const int faceCount=faces.getCount();
                const int offSet=faces.getOffset();

                for(int i=offSet;i<offSet+faceCount;i++)
                  BCfArray[i]=4;

                for(int i=0;i<faceCount;i++)
                {
                    int cell1=BfaceCells(i,0);
                    ZCArray[cell1]=1;
                }
            }
            else if((_bcMap[fg.id]->bcType == "PressureInletBC")||(_bcMap[fg.id]->bcType == "PressureOutletBC"))
            {
                const StorageSite& faces = fg.site;
                const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                const int faceCount=faces.getCount();
                const int offSet=faces.getOffset();

                for(int i=offSet;i<offSet+faceCount;i++)
                  BCfArray[i]=5;
            }
            else if(_bcMap[fg.id]->bcType == "SymmetryBC")
            {
                const StorageSite& faces = fg.site;
                const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                const int faceCount=faces.getCount();
                const int offSet=faces.getOffset();

                for(int i=offSet;i<offSet+faceCount;i++)
                  BCfArray[i]=6;

                for(int i=0;i<faceCount;i++)
                {
                    int cell1=BfaceCells(i,0);
                    BCArray[cell1]=1;
                }
            }
            else
            {
                const StorageSite& faces = fg.site;
                const int faceCount=faces.getCount();
                const int offSet=faces.getOffset();
                         
                for(int i=offSet;i<offSet+faceCount;i++)
                  BCfArray[i]=0;
            } 
        }
        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;
            const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
            const int faceCount=faces.getCount();
            const int offSet=faces.getOffset();
            
            for(int i=offSet;i<offSet+faceCount;i++)
              BCfArray[i]=-1;
            /*
            if(MPI::COMM_WORLD.Get_rank()==1)
              {
                int fC = (mesh.getFaces()).getCount();
                cout<<"level,rank,facecount,iID,offSet,ISize = "<<_level<<" "<<MPI::COMM_WORLD.Get_rank()<<" "<<fC<<" "<<fg.id<<" "<<offSet<<" "<<(offSet+faceCount)<<endl;
              }
            */
        }
        
        const StorageSite& faces = mesh.getFaces();
        const int faceCount = faces.getCount();
        const CRConnectivity& faceCells=mesh.getFaceCells(faces);
        const IntArray& ibType = dynamic_cast<const IntArray&>(_geomFields.ibType[cells]);
        for(int i=0;i<faceCount;i++)
        {
            const int c0 = faceCells(i,0);
            const int c1 = faceCells(i,1);
            if (((ibType[c0] == Mesh::IBTYPE_FLUID) && (ibType[c1] == Mesh::IBTYPE_BOUNDARY)) ||
                ((ibType[c1] == Mesh::IBTYPE_FLUID) && (ibType[c0] == Mesh::IBTYPE_BOUNDARY)))
            {
                BCfArray[i]=7;
            }
        }

        int count = 0;
        for(int c=0;c<cells.getSelfCount();c++)
        {
            if(ibType[c] != Mesh::IBTYPE_FLUID)
              count++;
        }
#ifdef FVM_PARALLEL
        MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE, &count, 1, MPI::INT, MPI::SUM);
        if((MPI::COMM_WORLD.Get_rank()==0)&&(_level==0))
          cout<<"number of non-fluid cells in mesh at level "<<_level<<" = "<<count<<endl;
#endif
        
#ifndef FVM_PARALLEL
        if(_level==0)
          cout<<"number of non-fluid cells in mesh at level "<<_level<<" = "<<count<<endl;
#endif
        _niters  =0;
        _initialKmodelNorm = MFRPtr();
        //_initialKmodelvNorm = MFRPtr();
        
        }
    }

template<class T >

void COMETModel< T >::initCoarse ( )

inline

Definition at line 685 of file phononbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_geomFields, COMETModel< T >::_IClist, COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_options, Field::addArray(), COMETModel< T >::applyTemperatureBoundaries(), pmode< T >::calce0(), PhononMacro::deltaT, COMETIC< T >::FgID0, COMETIC< T >::FgID1, GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), Mesh::getFaceCells(), Mesh::getFaceGroup(), Kspace< T >::getGlobalIndex(), Mesh::getInterfaceGroups(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), StorageSite::getOffset(), pmode< T >::gettau(), Kspace< T >::gettotmodes(), FaceGroup::id, COMETIC< T >::MeshID0, COMETIC< T >::MeshID1, Kspace< T >::sete0Array(), Kspace< T >::seteArray(), Kspace< T >::setFASArray(), Kspace< T >::setInjArray(), COMETModel< T >::setLocalScatterMaps(), Kspace< T >::setResArray(), Kspace< T >::setSourceArray(), Kspace< T >::setTauArray(), FaceGroup::site, PhononMacro::temperature, PhononMacro::TlFASCorrection, PhononMacro::TlInjected, PhononMacro::TlResidual, and Kspace< T >::updateTau().

  {
    const int numMeshes=_meshes.size();
    const T Tinit=_options["initialTemperature"];

     for (int n=0;n<numMeshes;n++)
       {
         Mesh& mesh=*_meshes[n];
         Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
         const int numK=kspace.getlength();
         const StorageSite& cells=mesh.getCells();
         const int numcells=cells.getCount();
         const int kcount=kspace.gettotmodes();

         shared_ptr<TArray> eArray(new TArray(numcells*kcount));
         shared_ptr<TArray> e0Array(new TArray(numcells*kcount));
         shared_ptr<TArray> ResidArray(new TArray(numcells*kcount));
         shared_ptr<TArray> InjArray(new TArray(numcells*kcount));
         shared_ptr<TArray> FASArray(new TArray(numcells*kcount));
         shared_ptr<TArray> tauArray(new TArray(numcells*kcount));
         kspace.seteArray(eArray);
         kspace.sete0Array(e0Array);
         kspace.setResArray(ResidArray);
         kspace.setInjArray(InjArray);
         kspace.setFASArray(FASArray);
         kspace.setTauArray(tauArray);

         if(_options.Source)
           {
             shared_ptr<TArray> SrcArray(new TArray(numcells*kcount));
             SrcArray->zero();
             kspace.setSourceArray(SrcArray);
           }
         
         shared_ptr<TArray> TLcell(new TArray(numcells));
         shared_ptr<TArray> deltaTcell(new TArray(numcells));
         *deltaTcell=0.; 
         *TLcell=Tinit;
         _macro.temperature.addArray(cells,TLcell);
         _macro.deltaT.addArray(cells,deltaTcell);

         shared_ptr<IntArray> f2c(new IntArray(numcells));
         *f2c=-1;
         _geomFields.fineToCoarse.addArray(cells, f2c);
         
         for(int c=0;c<numcells;c++)
           {
             int cellIndex=kspace.getGlobalIndex(c,0);
             for (int k=0;k<numK;k++)
               {
                 Tkvol& kv=kspace.getkvol(k);
                 const int numM=kv.getmodenum();

                 for (int m=0;m<numM;m++)
                   {
                     Tmode& mode=kv.getmode(m);
                     const T einit=mode.calce0(Tinit);
                     T tau=mode.gettau();
                     (*eArray)[cellIndex]=einit;
                     (*e0Array)[cellIndex]=einit;
                     (*ResidArray)[cellIndex]=0.;
                     (*InjArray)[cellIndex]=0.;
                     (*FASArray)[cellIndex]=0.;
                     (*tauArray)[cellIndex]=tau;
                     cellIndex++;

                   }
               }
             kspace.updateTau(c,Tinit);
           }

         BCfaceArray& BCfArray=*(_BFaces[n]);
         BCcellArray& BCArray=*(_BCells[n]);

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

             const int faceCount=faces.getCount();
             const int offSet=faces.getOffset();

             for(int i=offSet;i<offSet+faceCount;i++)
               BCfArray[i]=-1;  
           }

         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
           {
             FaceGroup& fg = *fgPtr;
             if(fg.id>0)
               {
                 if(_bcMap[fg.id]->bcType == "reflecting")
                   {
                     const StorageSite& faces = fg.site;
                     const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                     const int faceCount=faces.getCount();
                     const int offSet=faces.getOffset();
                     const bool Imp=(*(_bcMap[fg.id]))["FullyImplicit"];
                     
                     if(Imp)
                       {
                         for(int i=offSet;i<offSet+faceCount;i++)
                           BCfArray[i]=2;  //implicit boundary
                       }
                     else
                       {
                         for(int i=offSet;i<offSet+faceCount;i++)
                           BCfArray[i]=3;  //explicit boundary
                       }
                     
                     if(Imp)
                       {
                         for(int i=0;i<faceCount;i++)
                           {
                             int cell1=BfaceCells(i,0);
                             if(BCArray[cell1]==0)
                               BCArray[cell1]=1;    //implicit boundary only
                             else if(BCArray[cell1]==2)
                               BCArray[cell1]=3;  //mix implicit/explicit boundary
                           }
                       }
                     else
                       {
                         for(int i=0;i<faceCount;i++)
                           {
                             int cell1=BfaceCells(i,0);
                             if(BCArray[cell1]==0)
                               BCArray[cell1]=2;  //explicit boundary only
                             else if (BCArray[cell1]==1)
                               BCArray[cell1]=3;  //mix implicit/explicit boundary
                           }
                       }
                   }
                 else if(_bcMap[fg.id]->bcType == "temperature")
                   {
                     const StorageSite& faces = fg.site;
                     const int faceCount=faces.getCount();
                     const int offSet=faces.getOffset();
                     
                     for(int i=offSet;i<offSet+faceCount;i++)
                       BCfArray[i]=1;
                   }
                 else if(_bcMap[fg.id]->bcType == "Interface")
                   {             
                     StorageSite& faces0 = fg.site;
                     const CRConnectivity& BfaceCells=mesh.getFaceCells(faces0);
                     const int faceCount=faces0.getCount();
                     const int offSet=faces0.getOffset();
                     
                     for(int i=offSet;i<offSet+faceCount;i++)
                       {
                         BCfArray[i]=4;  //Interface boundary
                         int cell0=BfaceCells(i-offSet,0);
                         BCArray[cell0]=2;  //always treated explicitly
                       }



                     /*
                     bool doneAlready=false;
                     foreach(const COMETIC<T>* icPtr, _IClist)
                       {
                         if(icPtr->FgID1==fg.id && icPtr->MeshID1==mesh.getID())
                           {
                             doneAlready=true;
                             break;
                           }
                       }
                     
                     if(!doneAlready)
                       {
                         bool foundMatch=false;
                         StorageSite* faces1Ptr=NULL;
                         int otherFgID,otherMid;
                         for(int otherMeshID=n+1;otherMeshID<numMeshes;otherMeshID++)
                           {
                             const Mesh& otherMesh=*_meshes[otherMeshID];
                             foreach(const FaceGroupPtr otherfgPtr, otherMesh.getAllFaceGroups())
                               {
                                 foundMatch=mesh.COMETfindCommonFaces(faces0, otherfgPtr->site, _geomFields);
                                 if(foundMatch)
                                   {
                                     otherFgID=otherfgPtr->id;
                                     otherMid=otherMeshID;
                                     faces1Ptr=&(otherfgPtr->site);
                                     break;
                                   }
                               }
                             if(foundMatch)
                               break;
                           }
                         
                         if(foundMatch)
                           {
                             StorageSite& faces1=*faces1Ptr;
                             const Mesh& mesh1=*_meshes[otherMid];
                             COMETIC<T>* icPtr(new COMETIC<T>(n,fg.id,mesh1.getID(),
                                                              otherFgID, faces1.getCount()));
                             
                             if(_bcMap[fg.id]->InterfaceModel!="DMM")
                               icPtr->InterfaceModel=_bcMap[fg.id]->InterfaceModel;
                             
                             setLocalScatterMaps(mesh, faces0, mesh1, faces1);
                             
                             _IClist.push_back(icPtr);
                           }
                         else
                           {
                             cout<<"Face Group: "<<fg.id<<" MeshID: "<<mesh.getID()<<endl;
                             throw CException("Could not find a matching face group!");
                           }
                       }
*/
                   }
               }
           }
         
         TArrptr TlResidCell(new TArray(numcells));
         *TlResidCell=0.;
         _macro.TlResidual.addArray(cells,TlResidCell);
         TArrptr TlInj(new TArray(numcells));
         *TlInj=0.;
         _macro.TlInjected.addArray(cells,TlInj);
         TArrptr TlFAS(new TArray(numcells));
         *TlFAS=0.;
         _macro.TlFASCorrection.addArray(cells,TlFAS);
       }

     /*
     const int listSize=_IClist.size();
     for(int ic=0;ic<listSize;ic++)
       {
         //finer level interface condition
         COMETIC<T>* icPtr=_IClist[ic];
         const int meshID0=icPtr->MeshID0;
         const int meshID1=icPtr->MeshID1;
         const int fgid0=icPtr->FgID0;
         const int fgid1=icPtr->FgID1;

         //this level's interface condition
         Mesh& mesh0this=*_meshes[meshID0];
         const FaceGroup& fg0=mesh0this.getFaceGroup(fgid0);
         const StorageSite& faces0=fg0.site;
         const int faceCount=faces0.getCount();
         COMETIC<T>* icPtr2(new COMETIC<T>(meshID0,fgid0,meshID1,
                                           fgid1, faceCount));
         _IClist[ic]=icPtr2;

       }

     
     //Make map from mesh to IC
     IntArray ICcount(numMeshes);
     ICcount.zero();
     
     foreach(const COMETIC<T>* icPtr, _IClist)
       {
         ICcount[icPtr->MeshID0]++;
         ICcount[icPtr->MeshID1]++;
       }
     
     for(int i=0;i<numMeshes;i++)
       {
         IntArrPtr MeshToIC(new IntArray(ICcount[i]));
         _MeshToIC.push_back(MeshToIC);
       }
     
     ICcount.zero();
     */
     const int listSize=_IClist.size();
     for(int i=0;i<listSize;i++)
       {
         COMETIC<T> ic=*_IClist[i];
         const int m0=ic.MeshID0;
         const int m1=ic.MeshID1;
         const int fgid0=ic.FgID0;
         const int fgid1=ic.FgID1;

         Mesh& mesh0=*_meshes[m0];
         Mesh& mesh1=*_meshes[m1];

         FaceGroup& fg0=const_cast<FaceGroup&>(mesh0.getFaceGroup(fgid0));
         FaceGroup& fg1=const_cast<FaceGroup&>(mesh1.getFaceGroup(fgid1));

         setLocalScatterMaps(mesh0,fg0.site,mesh1,fg1.site);
       }
     
     /*
     COMETInterface<T> ComInt(_meshes,_kspaces,_MeshKspaceMap,_macro,_geomFields);
         
     for(int ic=0;ic<listSize;ic++)
       {
         COMETIC<T>* icPtr=_IClist[ic];
         if(icPtr->InterfaceModel=="DMM")
           ComInt.makeDMMcoeffs(*icPtr);

       }
     */
     
     applyTemperatureBoundaries();
  }

template<class T >

void COMETModel< T >::initFromOld ( )

inline

Definition at line 499 of file phononbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_geomFields, COMETModel< T >::_IClist, COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_MeshToIC, COMETModel< T >::_residual, Mesh::COMETfindCommonFaces(), COMETIC< T >::FgID1, Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), Mesh::getFaceCells(), Mesh::getID(), StorageSite::getOffset(), FaceGroup::id, COMETModel< T >::initializeTemperatureBoundaries(), COMETIC< T >::InterfaceModel, COMETModel< T >::MakeCoarseModel(), COMETInterface< T >::makeDMMcoeffs(), COMETIC< T >::MeshID0, COMETIC< T >::MeshID1, FaceGroup::site, COMETModel< T >::updateResid(), and Array< T >::zero().

  {
    const int numMeshes=_meshes.size();

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

         BCfaceArray& BCfArray=*(_BFaces[n]);
         BCcellArray& BCArray=*(_BCells[n]);
         //const StorageSite& cells=mesh.getCells();
         //const int numcells=cells.getCount();

         //setting facegroups
         foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
           {
             FaceGroup& fg = *fgPtr;
             if(fg.id>0)
               {
                 if(_bcMap[fg.id]->bcType == "reflecting")
                   {
                     const StorageSite& faces = fg.site;
                     const CRConnectivity& BfaceCells=mesh.getFaceCells(faces);
                     const int faceCount=faces.getCount();
                     const int offSet=faces.getOffset();
                     const bool Imp=(*(_bcMap[fg.id]))["FullyImplicit"];
                     
                     if(Imp)
                       {
                         for(int i=offSet;i<offSet+faceCount;i++)
                           BCfArray[i]=2;  //implicit boundary
                       }
                     else
                       {
                         for(int i=offSet;i<offSet+faceCount;i++)
                           BCfArray[i]=3;  //explicit boundary
                       }
                     
                     if(Imp)
                       {
                         for(int i=0;i<faceCount;i++)
                           {
                             int cell1=BfaceCells(i,0);
                             if(BCArray[cell1]==0)
                               BCArray[cell1]=1;    //implicit boundary only
                             else if(BCArray[cell1]==2)
                               BCArray[cell1]=3;  //mix implicit/explicit boundary
                           }
                       }
                     else
                       {
                         for(int i=0;i<faceCount;i++)
                           {
                             int cell1=BfaceCells(i,0);
                             if(BCArray[cell1]==0)
                               BCArray[cell1]=2;  //explicit boundary only
                             else if (BCArray[cell1]==1)
                               BCArray[cell1]=3;  //mix implicit/explicit boundary
                           }
                       }
                   }
                 else if(_bcMap[fg.id]->bcType == "temperature")
                   {
                     const StorageSite& faces = fg.site;
                     const int faceCount=faces.getCount();
                     const int offSet=faces.getOffset();
                     
                     for(int i=offSet;i<offSet+faceCount;i++)
                       BCfArray[i]=1;
                   }
                 else if(_bcMap[fg.id]->bcType == "Interface")
                   {             
                     StorageSite& faces0 = fg.site;
                     const CRConnectivity& BfaceCells=mesh.getFaceCells(faces0);
                     const int faceCount=faces0.getCount();
                     const int offSet=faces0.getOffset();
                     
                     for(int i=offSet;i<offSet+faceCount;i++)
                       {
                         BCfArray[i]=4;  //Interface boundary
                         int cell0=BfaceCells(i-offSet,0);
                         int cell1=BfaceCells(i-offSet,1);
                         BCArray[cell0]=2;  //always treated explicitly
                         BCArray[cell1]=4; //interface ghost cells need to be labeled
                       }
                     
                     bool doneAlready=false;
                     foreach(const COMETIC<T>* icPtr, _IClist)
                       {
                         if(icPtr->FgID1==fg.id && icPtr->MeshID1==mesh.getID())
                           {
                             doneAlready=true;
                             break;
                           }
                       }
                     
                     bool foundMatch=false;
                     if(!doneAlready)
                       {
                         StorageSite* faces1Ptr=NULL;
                         int otherFgID,otherMid;
                         for(int otherMeshID=n+1;otherMeshID<numMeshes;otherMeshID++)
                           {
                             const Mesh& otherMesh=*_meshes[otherMeshID];
                             foreach(const FaceGroupPtr otherfgPtr, otherMesh.getBoundaryFaceGroups())
                               {
                                 foundMatch=mesh.COMETfindCommonFaces(faces0, otherfgPtr->site, _geomFields);
                                 if(foundMatch)
                                   {
                                     otherFgID=otherfgPtr->id;
                                     otherMid=otherMeshID;
                                     faces1Ptr=&(otherfgPtr->site);
                                     break;
                                   }
                               }
                             if(foundMatch)
                               break;
                           }
                         
                         if(foundMatch)
                           {
                             StorageSite& faces1=*faces1Ptr;
                             const Mesh& mesh1=*_meshes[otherMid];
                             COMETIC<T>* icPtr(new COMETIC<T>(n,fg.id,mesh1.getID(),
                                                              otherFgID, faces1.getCount()));
                             
                             if(_bcMap[fg.id]->InterfaceModel!="DMM")
                               icPtr->InterfaceModel=_bcMap[fg.id]->InterfaceModel;
                             
                             _IClist.push_back(icPtr);
                           }
                         else if(!doneAlready && !foundMatch)
                           {
                             cout<<"Face Group: "<<fg.id<<" MeshID: "<<mesh.getID()<<endl;
                             throw CException("Could not find a matching face group!");
                           }
                       }
                   }// end if interface 
               }
           }//end facegroup loop
         
       }//end meshes loop
     
     //Make map from mesh to IC
     IntArray ICcount(numMeshes);
     ICcount.zero();
     
     foreach(const COMETIC<T>* icPtr, _IClist)
       {
         ICcount[icPtr->MeshID0]++;
         ICcount[icPtr->MeshID1]++;
       }

     for(int i=0;i<numMeshes;i++)
       {
         IntArrPtr MeshToIC(new IntArray(ICcount[i]));
         _MeshToIC.push_back(MeshToIC);
       }
     
     ICcount.zero();
     const int listSize=_IClist.size();
     for(int ic=0;ic<listSize;ic++)
       {
         const COMETIC<T>* icPtr=_IClist[ic];
         (*(_MeshToIC[icPtr->MeshID0]))[ICcount[icPtr->MeshID0]]=ic;
         (*(_MeshToIC[icPtr->MeshID1]))[ICcount[icPtr->MeshID1]]=ic;
         ICcount[icPtr->MeshID0]++;
         ICcount[icPtr->MeshID1]++;
       }

     COMETInterface<T> ComInt(_meshes,_kspaces,_MeshKspaceMap,_macro,_geomFields);

     for(int ic=0;ic<listSize;ic++)
       {
         COMETIC<T>* icPtr=_IClist[ic];
         if(icPtr->InterfaceModel=="DMM")
           ComInt.makeDMMcoeffs(*icPtr);
       }
     
     initializeTemperatureBoundaries();
     _residual=updateResid(false);
     //cout<<"Creating Coarse Levels..."<<endl;
     MakeCoarseModel(this);
     //cout<<"Coarse Levels Completed."<<endl;
  }

template<class T >

void COMETModel< T >::initializeCoarseMaxwellian ( )

inline

Definition at line 2146 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr0, COMETModel< T >::_dsfPtrFAS, COMETModel< T >::_dsfPtrRes, Model::_meshes, COMETModel< T >::_quadrature, Mesh::getCells(), and StorageSite::getCount().

Referenced by COMETModel< T >::MakeIBCoarseModel().

  {
    const int numMeshes = _meshes.size();
    const T zero(0.);
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();
        const int numFields= _quadrature.getDirCount();

        for(int j=0;j< numFields;j++){
          Field& fnd0 = *_dsfPtr0.dsf[j];
          Field& fndFAS = *_dsfPtrFAS.dsf[j];
          Field& fndRes = *_dsfPtrRes.dsf[j];
          TArray& f0 = dynamic_cast< TArray&>(fnd0[cells]);
          TArray& fFAS = dynamic_cast< TArray&>(fndFAS[cells]);
          TArray& fRes = dynamic_cast< TArray&>(fndRes[cells]);
          for(int c=0; c<nCells;c++){
            f0[c]=zero;
            fFAS[c]=zero;
            fRes[c]=zero;

          }
        }
      }
  }

template<class T >

void COMETModel< T >::InitializeFgammaCoefficients ( )

inline

Definition at line 1089 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, MacroFields::coeff, MacroFields::coeffg, MacroFields::density, Mesh::getCells(), StorageSite::getCount(), MacroFields::temperature, MacroFields::Txx, MacroFields::Txy, MacroFields::Tyy, MacroFields::Tyz, MacroFields::Tzx, and MacroFields::Tzz.

  {
    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.getCount(); 
        //      const double pi(3.14159);
        const double pi=_options.pi;
        
        TArray& density = dynamic_cast<TArray&>(_macroFields.density[cells]);  
        TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[cells]);
        VectorT5Array& coeff = dynamic_cast<VectorT5Array&>(_macroFields.coeff[cells]);
        VectorT10Array& coeffg = dynamic_cast<VectorT10Array&>(_macroFields.coeffg[cells]);
        TArray& Txx = dynamic_cast<TArray&>(_macroFields.Txx[cells]);
        TArray& Tyy = dynamic_cast<TArray&>(_macroFields.Tyy[cells]);
        TArray& Tzz = dynamic_cast<TArray&>(_macroFields.Tzz[cells]);
        TArray& Txy = dynamic_cast<TArray&>(_macroFields.Txy[cells]);
        TArray& Tyz = dynamic_cast<TArray&>(_macroFields.Tyz[cells]);
        TArray& Tzx = dynamic_cast<TArray&>(_macroFields.Tzx[cells]);
        
        for(int c=0; c<nCells;c++)
          {
            
              //BGK
              coeff[c][0]=density[c]/pow((pi*temperature[c]),1.5);
              coeff[c][1]=1/temperature[c];
              coeff[c][2]=0.0;coeff[c][3]=0.0;coeff[c][4]=0.0;
           
            if(_options.fgamma ==2){
              //ESBGK
              coeffg[c][0]=coeff[c][0];
              coeffg[c][1]=coeff[c][1];
              coeffg[c][2]=coeff[c][2];
              coeffg[c][3]=coeff[c][1];
              coeffg[c][4]=coeff[c][3];
              coeffg[c][5]=coeff[c][1];
              coeffg[c][6]=coeff[c][4];
              coeffg[c][7]=0.0;
              coeffg[c][8]=0.0;
              coeffg[c][9]=0.0; 

              Txx[c]=0.5*temperature[c];
              Tyy[c]=0.5*temperature[c];
              Tzz[c]=0.5*temperature[c];
              Txy[c]=0.0;
              Tyz[c]=0.0;
              Tzx[c]=0.0;
            }
          }
      }
  }

template<class T >

void COMETModel< T >::initializeFineMaxwellian ( )

inline

Definition at line 2110 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr0, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, MacroFields::density, Mesh::getCells(), StorageSite::getCount(), MacroFields::temperature, and MacroFields::velocity.

Referenced by COMETModel< T >::COMETModel().

  {
    const int numMeshes = _meshes.size();
    const T zero(0.);
    for (int n=0; n<numMeshes; n++)
    {
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();

        const double pi=_options.pi;
        const TArray& density = dynamic_cast<const TArray&>(_macroFields.density[cells]);
        const TArray& temperature = dynamic_cast<const TArray&>(_macroFields.temperature[cells]);
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);

        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const int numFields= _quadrature.getDirCount(); 

        for(int j=0;j< numFields;j++){
          Field& fnd0 = *_dsfPtr0.dsf[j];
          Field& fndRes = *_dsfPtrRes.dsf[j];
          TArray& f0 = dynamic_cast< TArray&>(fnd0[cells]);
          TArray& fRes = dynamic_cast< TArray&>(fndRes[cells]);
          for(int c=0; c<nCells;c++){
            f0[c]=density[c]/pow((pi*temperature[c]),1.5)*
              exp(-(pow((cx[j]-v[c][0]),2.0)+pow((cy[j]-v[c][1]),2.0)+
                    pow((cz[j]-v[c][2]),2.0))/temperature[c]);
            fRes[c]=zero;
           
          }
        }
    }
  }

template<class T >

void COMETModel< T >::InitializeMacroparameters ( )

inline

Definition at line 1021 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, MacroFields::coeff, MacroFields::coeffg, MacroFields::density, MacroFields::Entropy, Mesh::getCells(), StorageSite::getCount(), MacroFields::Knq, MacroFields::pressure, MacroFields::temperature, MacroFields::Txx, MacroFields::Txy, MacroFields::Tyy, MacroFields::Tyz, MacroFields::Tzx, MacroFields::Tzz, and MacroFields::velocity.

Referenced by COMETModel< T >::COMETModel(), and COMETModel< T >::MakeIBCoarseModel().

  {  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.getCount(); 
        //      const double pi(3.14159);
        const double pi=_options.pi;
        TArray& Entropy = dynamic_cast<TArray&>(_macroFields.Entropy[cells]);  
        TArray& density = dynamic_cast<TArray&>(_macroFields.density[cells]);  
        VectorT3Array& v = dynamic_cast<VectorT3Array&>(_macroFields.velocity[cells]);
        
        TArray& temperature = dynamic_cast<TArray&>(_macroFields.temperature[cells]);
        TArray& pressure = dynamic_cast<TArray&>(_macroFields.pressure[cells]);
        
        VectorT5Array& coeff = dynamic_cast<VectorT5Array&>(_macroFields.coeff[cells]);
        VectorT10Array& coeffg = dynamic_cast<VectorT10Array&>(_macroFields.coeffg[cells]);
        TArray& Txx = dynamic_cast<TArray&>(_macroFields.Txx[cells]);
        TArray& Tyy = dynamic_cast<TArray&>(_macroFields.Tyy[cells]);
        TArray& Tzz = dynamic_cast<TArray&>(_macroFields.Tzz[cells]);
        TArray& Txy = dynamic_cast<TArray&>(_macroFields.Txy[cells]);
        TArray& Tyz = dynamic_cast<TArray&>(_macroFields.Tyz[cells]);
        TArray& Tzx = dynamic_cast<TArray&>(_macroFields.Tzx[cells]);
        //if ( MPI::COMM_WORLD.Get_rank() == 0 ) {cout << "ncells="<<nCells<<endl;}
        
        TArray& Knq = dynamic_cast<TArray&>(_macroFields.Knq[cells]);
        //initialize density,velocity  
        for(int c=0; c<nCells;c++)
          {
            density[c] =1.0;
            v[c][0]=0.0;
            v[c][1]=0.0;
            v[c][2]=0.0;
            temperature[c]=1.0;
            pressure[c]=temperature[c]*density[c];
            
            //BGK
              coeff[c][0]=density[c]/pow((pi*temperature[c]),1.5);
              coeff[c][1]=1/temperature[c];
              coeff[c][2]=0.0;coeff[c][3]=0.0;coeff[c][4]=0.0;
            
            Entropy[c]=0.0;
            if(_options.fgamma ==2){
            //ESBGK
            coeffg[c][0]=coeff[c][0];
            coeffg[c][1]=coeff[c][1];
            coeffg[c][2]=coeff[c][2];
            coeffg[c][3]=coeff[c][1];
            coeffg[c][4]=coeff[c][3];
            coeffg[c][5]=coeff[c][1];
            coeffg[c][6]=coeff[c][4];
            coeffg[c][7]=0.0;
            coeffg[c][8]=0.0;
            coeffg[c][9]=0.0;   
            }    
            
            Txx[c]=0.5;
            Tyy[c]=0.5;
            Tzz[c]=0.5;
            Txy[c]=0.0;
            Tyz[c]=0.0;
            Tzx[c]=0.0;
            
            Knq[c]=0.0;
          }     
      }
  }

template<class T >

void COMETModel< T >::initializeMaxwellian ( )

inline

Definition at line 2057 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, MacroFields::density, Mesh::getCells(), StorageSite::getCount(), MacroFields::temperature, and MacroFields::velocity.

Referenced by COMETModel< T >::COMETModel(), and COMETModel< T >::MakeIBCoarseModel().

  {
    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.getCount();

        const double pi=_options.pi;
        const TArray& density = dynamic_cast<const TArray&>(_macroFields.density[cells]);
        const TArray& temperature = dynamic_cast<const TArray&>(_macroFields.temperature[cells]);
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const int numFields= _quadrature.getDirCount(); 

        for(int j=0;j< numFields;j++){
          Field& fnd = *_dsfPtr.dsf[j];
          TArray& f = dynamic_cast< TArray&>(fnd[cells]);
          for(int c=0; c<nCells;c++){
            f[c]=density[c]/pow((pi*temperature[c]),1.5)*
              exp(-(pow((cx[j]-v[c][0]),2.0)+pow((cy[j]-v[c][1]),2.0)+
                    pow((cz[j]-v[c][2]),2.0))/temperature[c]);
            
           
          }
          
          if (_options.transient)
            //updateTime();
            
            {
              Field& fnd1 = *_dsfPtr1.dsf[j];
              TArray& f1 = dynamic_cast< TArray&>(fnd1[cells]);
              for (int c=0;c<nCells;c++)
                f1[c] = f[c];
              //cout << "discretization order " << _options.timeDiscretizationOrder << endl ;
              if (_options.timeDiscretizationOrder > 1)
                {
                  Field& fnd2 = *_dsfPtr2.dsf[j];
                  TArray& f2 = dynamic_cast< TArray&>(fnd2[cells]);
                  for (int c=0;c<nCells;c++)
                    f2[c] = f[c];
                }
            } 
            
          
        }
      }
  }

template<class T >

void COMETModel< T >::initializeMaxwellianEq ( )

inline

Definition at line 1620 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtr, COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, MacroFields::coeff, MacroFields::coeffg, Mesh::getCells(), StorageSite::getCount(), and MacroFields::velocity.

Referenced by COMETModel< T >::COMETModel(), COMETModel< T >::cycle(), COMETModel< T >::MakeIBCoarseModel(), and COMETModel< T >::smooth().

  {
    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.getCount();
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        const VectorT5Array& coeff = dynamic_cast<VectorT5Array&>(_macroFields.coeff[cells]);
        const VectorT10Array& coeffg = dynamic_cast<VectorT10Array&>(_macroFields.coeffg[cells]);
        
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const int numFields= _quadrature.getDirCount(); 

        for(int j=0;j< numFields;j++){
          Field& fndEq = *_dsfEqPtr.dsf[j];
          TArray& fEq = dynamic_cast< TArray&>(fndEq[cells]);
          for(int c=0; c<nCells;c++){
            fEq[c]=coeff[c][0]*exp(-coeff[c][1]*(pow(cx[j]-v[c][0],2)+pow(cy[j]-v[c][1],2)
                                                 +pow(cz[j]-v[c][2],2))+coeff[c][2]*(cx[j]-v[c][0])
                                   +coeff[c][3]*(cy[j]-v[c][1])+coeff[c][4]*(cz[j]-v[c][2]));
          } 
        }
        
        if(_options.fgamma==2){
          
          for(int j=0;j< numFields;j++){
            Field& fndEqES = *_dsfEqPtrES.dsf[j];
            TArray& fEqES = dynamic_cast< TArray&>(fndEqES[cells]);
            for(int c=0; c<nCells;c++){ 
              T Cc1=(cx[j]-v[c][0]);
              T Cc2=(cy[j]-v[c][1]);
              T Cc3=(cz[j]-v[c][2]);
              fEqES[c]=coeffg[c][0]*exp(-coeffg[c][1]*pow(Cc1,2)+coeffg[c][2]*Cc1
                                        -coeffg[c][3]*pow(Cc2,2)+coeffg[c][4]*Cc2
                                        -coeffg[c][5]*pow(Cc3,2)+coeffg[c][6]*Cc3
                                        +coeffg[c][7]*cx[j]*cy[j]+coeffg[c][8]*cy[j]*cz[j]
                                        +coeffg[c][9]*cz[j]*cx[j]);
            }
          }
        }
        
        
        
      }
  }

template<class T >

void COMETModel< T >::initializeTemperatureBoundaries ( )

inline

Definition at line 1045 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap, COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_options, COMETBoundary< T >::applyTemperatureWallCoarse(), COMETBoundary< T >::applyTemperatureWallFine(), COMETBC< T >::bcType, Mesh::getBoundaryFaceGroups(), FloatVarDict< T >::getVal(), FaceGroup::id, and FaceGroup::site.

Referenced by COMETModel< T >::init(), and COMETModel< T >::initFromOld().

  {
    const int numMeshes=_meshes.size();

    for(int n=0;n<numMeshes;n++)
      {
        const Mesh& mesh=*_meshes[n];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          {
            const FaceGroup& fg = *fgPtr;
            if(fg.id>0)
              {   
                const StorageSite& faces = fg.site;
                const COMETBC<T>& bc = *_bcMap[fg.id];
                
                COMETBoundary<T> cbc(faces, mesh,_geomFields,kspace,_options,fg.id);
                
                if(bc.bcType=="temperature")
                  {           
                    FloatValEvaluator<T>
                      bTemperature(bc.getVal("specifiedTemperature"),faces);
                    

                    cbc.applyTemperatureWallCoarse(bTemperature);
                    
                    if(_options.Convection=="SecondOrder")
                      cbc.applyTemperatureWallFine(bTemperature);

                  }
              }
          }
      }
  }

template<class T >

void COMETModel< T >::injectResid ( )

inline

Definition at line 2988 of file phononbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, Mesh::getCells(), Mesh::getConnectivity(), StorageSite::getCount(), CRConnectivity::getCount(), Kspace< T >::geteArray(), Kspace< T >::getFASArray(), Kspace< T >::getGlobalIndex(), Kspace< T >::getInjArray(), COMETModel< T >::getKspace(), Kspace< T >::getkvol(), Kspace< T >::getlength(), COMETModel< T >::getMacro(), COMETModel< T >::getMeshList(), kvol< T >::getmodenum(), Kspace< T >::getResArray(), StorageSite::getSelfCount(), PhononMacro::temperature, PhononMacro::TlFASCorrection, PhononMacro::TlInjected, PhononMacro::TlResidual, GeomFields::volume, and Array< T >::zero().

  {
    const int numMeshes = _meshes.size();

    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& finerMesh=*_meshes[n];
        int Knum=_MeshKspaceMap[n];
        Tkspace& finerKspace=*_kspaces[Knum];
        const Mesh& coarserMesh=*(_coarserLevel->getMeshList())[n];
        Tkspace& coarserKspace=_coarserLevel->getKspace(Knum);
        PhononMacro& coarserMacro=_coarserLevel->getMacro();
        const StorageSite& finerCells=finerMesh.getCells();
        const StorageSite& coarserCells=coarserMesh.getCells();
        const CRConnectivity& CoarserToFiner=coarserMesh.getConnectivity(coarserCells,finerCells);
        const TArray& coarserVol=dynamic_cast<TArray&>(_geomFields.volume[coarserCells]);
        const TArray& finerVol=dynamic_cast<TArray&>(_geomFields.volume[finerCells]);

        TArray& coarserVar=coarserKspace.geteArray();
        TArray& coarserInj=coarserKspace.getInjArray();
        TArray& coarserFAS=coarserKspace.getFASArray();
        TArray& finerVar=finerKspace.geteArray();
        TArray& finerRes=finerKspace.getResArray();

        const int cellCount=coarserCells.getSelfCount();
        const int cellTotCount=coarserCells.getCount();
        coarserVar.zero();
        coarserFAS.zero();

        for(int c=0;c<cellCount;c++)
          {
            const int fineCount=CoarserToFiner.getCount(c);
            
            //sum up contributions from fine cells
            for(int fc=0;fc<fineCount;fc++)
              {
                const int cell=CoarserToFiner(c,fc);
                const int klen=finerKspace.getlength();
                int coarserCellIndex=coarserKspace.getGlobalIndex(c,0);
                int finerCellIndex=finerKspace.getGlobalIndex(cell,0);

                for(int k=0;k<klen;k++)
                  {
                    Tkvol& kvol=finerKspace.getkvol(k);
                    const int numModes=kvol.getmodenum();
                    for(int m=0;m<numModes;m++)
                      {
                        coarserVar[coarserCellIndex]+=finerVar[finerCellIndex]*finerVol[cell];
                        coarserFAS[coarserCellIndex]+=finerRes[finerCellIndex];
                        finerCellIndex++;
                        coarserCellIndex++;
                      }
                  }
              }

            //make volume average
            int coarserCellIndex=coarserKspace.getGlobalIndex(c,0);
            const int klen=finerKspace.getlength();
            for(int k=0;k<klen;k++)
              {
                Tkvol& kvol=finerKspace.getkvol(k);
                //Tkvol& ckvol=coarserKspace.getkvol(k);
                const int numModes=kvol.getmodenum();
                for(int m=0;m<numModes;m++)
                  {
                    coarserVar[coarserCellIndex]/=coarserVol[c];
                    coarserInj[coarserCellIndex]=coarserVar[coarserCellIndex];
                    coarserCellIndex++;
                  }
              }
          }

        for(int c=cellCount;c<cellTotCount;c++)
          {
            const int cell=CoarserToFiner(c,0);
            int coarserCellIndex=coarserKspace.getGlobalIndex(c,0);
            int finerCellIndex=finerKspace.getGlobalIndex(cell,0);
            const int klen=finerKspace.getlength();
            for(int k=0;k<klen;k++)
              {
                Tkvol& kvol=finerKspace.getkvol(k);
                const int numModes=kvol.getmodenum();
                for(int m=0;m<numModes;m++)
                  {
                    coarserVar[coarserCellIndex]=0.;
                    coarserFAS[coarserCellIndex]=0.;
                    coarserVar[coarserCellIndex]+=finerVar[finerCellIndex];
                    coarserFAS[coarserCellIndex]+=finerRes[finerCellIndex];     
                    coarserInj[coarserCellIndex]=coarserVar[coarserCellIndex];
                    coarserCellIndex++;
                    finerCellIndex++;
                  }
              }
          }     
        
        TArray& coarserVarM=dynamic_cast<TArray&>(coarserMacro.temperature[coarserCells]);
        TArray& coarserInjM=dynamic_cast<TArray&>(coarserMacro.TlInjected[coarserCells]);
        TArray& coarserFASM=dynamic_cast<TArray&>(coarserMacro.TlFASCorrection[coarserCells]);
        TArray& finerVarM=dynamic_cast<TArray&>(_macro.temperature[finerCells]);
        TArray& finerResM=dynamic_cast<TArray&>(_macro.TlResidual[finerCells]);
            
        for(int c=0;c<cellCount;c++)
          {
            const int fineCount=CoarserToFiner.getCount(c);
            coarserVarM[c]=0.;
            coarserFASM[c]=0.;
                
            for(int fc=0;fc<fineCount;fc++)
              {
                const int cell=CoarserToFiner(c,fc);
                coarserVarM[c]+=finerVarM[cell]*finerVol[cell];
                coarserFASM[c]+=finerResM[cell];
              }
            coarserVarM[c]/=coarserVol[c];
            coarserInjM[c]=coarserVarM[c];
          }     
      }
  }

template<class T >

void COMETModel< T >::injectResid ( )

inline

Definition at line 5204 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_geomFields, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_quadrature, DistFunctFields< T >::dsf, Mesh::getCells(), Mesh::getConnectivity(), CRConnectivity::getCount(), COMETModel< T >::getdsf(), COMETModel< T >::getdsf0(), COMETModel< T >::getdsfFAS(), COMETModel< T >::getGeomFields(), COMETModel< T >::getMacro(), COMETModel< T >::getMeshList(), StorageSite::getSelfCount(), MacroFields::velocity, MacroFields::velocityFASCorrection, MacroFields::velocityInjected, MacroFields::velocityResidual, and GeomFields::volume.

Referenced by COMETModel< T >::cycle().

  {
    const int numMeshes = _meshes.size();

    for (int n=0; n<numMeshes; n++)
    {
        const Mesh& finerMesh=*_meshes[n];
        const Mesh& coarserMesh=*(_coarserLevel->getMeshList())[n];
        MacroFields& coarserMacro=_coarserLevel->getMacro();
        GeomFields& coarserGeomFields=_coarserLevel->getGeomFields();
        DistFunctFields<T>& coarserdsf = _coarserLevel->getdsf();
        DistFunctFields<T>& coarserdsf0 = _coarserLevel->getdsf0();
        DistFunctFields<T>& coarserdsfFAS = _coarserLevel->getdsfFAS();
        const StorageSite& finerCells=finerMesh.getCells();
        const StorageSite& coarserCells=coarserMesh.getCells();
        const CRConnectivity& CoarserToFiner=coarserMesh.getConnectivity(coarserCells,finerCells);
        //const TArray& coarserVol=dynamic_cast<TArray&>(_geomFields.volume[coarserCells]);
        const TArray& coarserVol=dynamic_cast<TArray&>(coarserGeomFields.volume[coarserCells]);
        const TArray& finerVol=dynamic_cast<TArray&>(_geomFields.volume[finerCells]);

        const int cellCount=coarserCells.getSelfCount();
        const int numDir=_quadrature.getDirCount();
        for(int dir=0;dir<numDir;dir++)
        {
            Field& fnd = *_dsfPtr.dsf[dir];
            Field& fndRes = *_dsfPtrRes.dsf[dir];
            Field& cfnd = *coarserdsf.dsf[dir];
            Field& cfndInj = *coarserdsf0.dsf[dir];
            Field& cfndFAS = *coarserdsfFAS.dsf[dir];
            TArray& coarserVar=dynamic_cast<TArray&>(cfnd[coarserCells]);
            TArray& coarserInj=dynamic_cast<TArray&>(cfndInj[coarserCells]);
            TArray& coarserFAS=dynamic_cast<TArray&>(cfndFAS[coarserCells]);
            TArray& finerVar=dynamic_cast<TArray&>(fnd[finerCells]);
            TArray& finerRes=dynamic_cast<TArray&>(fndRes[finerCells]);

            for(int c=0;c<cellCount;c++)
            {
                const int fineCount=CoarserToFiner.getCount(c);
                coarserVar[c]=0.;
                coarserFAS[c]=0.;
                
                for(int fc=0;fc<fineCount;fc++)
                {
                    const int cell=CoarserToFiner(c,fc);
                    coarserVar[c]+=finerVar[cell]*finerVol[cell];
                    coarserFAS[c]+=finerRes[cell];
                }
                coarserVar[c]/=coarserVol[c];
                coarserInj[c]=coarserVar[c];
            }              
        }

        VectorT3Array& coarserVar=dynamic_cast<VectorT3Array&>(coarserMacro.velocity[coarserCells]);
        VectorT3Array& coarserInj=dynamic_cast<VectorT3Array&>(coarserMacro.velocityInjected[coarserCells]);
        VectorT3Array& coarserFAS=dynamic_cast<VectorT3Array&>(coarserMacro.velocityFASCorrection[coarserCells]);
        VectorT3Array& finerVar=dynamic_cast<VectorT3Array&>(_macroFields.velocity[finerCells]);
        VectorT3Array& finerRes=dynamic_cast<VectorT3Array&>(_macroFields.velocityResidual[finerCells]);

        for(int c=0;c<cellCount;c++)
        {
            const int fineCount=CoarserToFiner.getCount(c);
            coarserVar[c]=0.;
            coarserFAS[c]=0.;

            for(int fc=0;fc<fineCount;fc++)
            {
                const int cell=CoarserToFiner(c,fc);
                coarserVar[c]+=finerVar[cell]*finerVol[cell];
                coarserFAS[c]+=finerRes[cell];
            }
            coarserVar[c]/=coarserVol[c];
            coarserInj[c]=coarserVar[c];
        }
    }
  }

template<class T >

void COMETModel< T >::makeCellColors ( const int  level )

inline

Definition at line 4018 of file phononbase/COMETModel.h.

References COMETModel< T >::_macro, Field::addArray(), PhononMacro::CellColors, Mesh::getCellCells(), Mesh::getCells(), StorageSite::getCount(), CRConnectivity::getCount(), COMETModel< T >::getMeshList(), COMETModel< T >::getModelPointer(), and StorageSite::getSelfCount().

  {
    
    TCOMET* thismodel=getModelPointer(level);
    MeshList& meshes=const_cast<MeshList&>(thismodel->getMeshList());
    const int numMeshes = meshes.size();
    shared_ptr<Field> colorFieldPtr(new Field("Colors"));
    _macro.CellColors.push_back(colorFieldPtr);
    Field& colorField=*colorFieldPtr;
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*meshes[n];
        const StorageSite& cells=mesh.getCells();
        const int cellCount=cells.getSelfCount();
        const int cellTotCount=cells.getCount();
        const CRConnectivity& cellCells=mesh.getCellCells();
        
        TArrptr colorPtr(new TArray(cellTotCount));
        colorField.addArray(cells, colorPtr);
        TArray& colorArray=(*colorPtr);
        colorArray=-1;

        for(int c=0;c<cellCount;c++)
          {
            T color=0.;
            const int neibs=cellCells.getCount(c);

            while(colorArray[c]==-1)
              {

                bool same(false);

                for(int j=0;j<neibs;j++)
                  {
                    if(color==colorArray[cellCells(c,j)])
                      {
                        same=true;
                        break;
                      }
                  }

                if(same)
                  color++;
                else
                  colorArray[c]=color;

              }

          }
      }

    //if(_coarserLevel!=NULL)
    //_coarserLevel->makeCellColors();

  }

template<class T >

void COMETModel< T >::MakeCoarseIndex ( const StorageSite &  solidFaces )

inline

Definition at line 970 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_dsfPtr, COMETModel< T >::_finestGeomFields, COMETModel< T >::_finestMeshes, COMETModel< T >::_geomFields, COMETModel< T >::_level, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, Field::addArray(), GeomFields::finestToCoarse, GeomFields::fineToCoarse, Mesh::getCells(), StorageSite::getCount(), COMETModel< T >::MakeCoarseIndex(), and COMETModel< T >::MakeParallel().

Referenced by COMETModel< T >::MakeCoarseIndex().

    {

      const int maxLevs=_options.maxLevels;
      int thisLevel=_level+1;
      
      const Mesh& mesh = *_meshes[0];
      const StorageSite& cells = mesh.getCells();
      const int nCells = cells.getCount();
      const Mesh& fMesh = *_finestMeshes[0];
      const StorageSite& fCells = fMesh.getCells();
      const int nFCells = fCells.getCount();
      Field& FineToCoarseField=_geomFields.fineToCoarse;
      const IntArray& FineToCoarse=dynamic_cast<const IntArray&>(FineToCoarseField[cells]);
      Field& FinestToCoarseField=_finestGeomFields.finestToCoarse;
      Array<Vector<int,25> >& FinestToCoarse=dynamic_cast<Array<Vector<int,25> >&>(FinestToCoarseField[fCells]);

      if(_level==0)
        MakeParallel();
      else
      {
          for(int dir=0;dir<_quadrature.getDirCount();dir++)
          {
              Field& fnd = *_dsfPtr.dsf[dir];
              shared_ptr<TArray> cSV(new TArray(solidFaces.getCount()));
              cSV->zero();
              fnd.addArray(solidFaces,cSV);
          }
      }

      if(thisLevel<maxLevs)  //assumes # of levels will always work for the mesh
      {
          for(int c=0;c<nFCells;c++)
            FinestToCoarse[c][_level+1]=FineToCoarse[FinestToCoarse[c][_level]];
          
          _coarserLevel->MakeCoarseIndex(solidFaces);
      }
    }

template<class T >

void COMETModel< T >::MakeCoarseMesh1 ( const MeshList &  inMeshes, GeomFields &  inGeomFields, MeshList &  outMeshes  )

inline

Definition at line 2545 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BFaces, COMETModel< T >::_coarseSizes, COMETModel< T >::_siteMap, GeomFields::area, GeomFields::areaMag, GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCellFaces(), Mesh::getCells(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getDimension(), Mesh::getFaceCells(), Mesh::getFaces(), StorageSite::getSelfCount(), GeomFields::ibType, Mesh::IBTYPE_FLUID, mag(), and FaceGroup::site.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

  {

    int smallestMesh=-1;
    const int numMeshes=inMeshes.size();
    
    for(int n=0;n<numMeshes;n++)
      {
        const Mesh& mesh=*inMeshes[n];
        const int dim=mesh.getDimension();
        Mesh* newMeshPtr=new Mesh(dim);

        outMeshes.push_back(newMeshPtr);
        
        const StorageSite& inCells=mesh.getCells();
        StorageSite& outCells=newMeshPtr->getCells();
        StorageSite& outFaces=newMeshPtr->getFaces();
        const StorageSite& inFaces=mesh.getFaces();
        const int inCellCount=inCells.getSelfCount();
        const int inCellTotal=inCells.getCount();
        const int inFaceCount=inFaces.getCount();
        const int inGhost=inCellTotal-inCellCount;
        int coarseCount=0;
        _siteMap[&inCells]=&outCells;
        Field& FineToCoarseField=inGeomFields.fineToCoarse;
        IntArray& FineToCoarse=dynamic_cast<IntArray&>(FineToCoarseField[inCells]);

        const CRConnectivity& inCellinFaces=mesh.getCellFaces();
        const CRConnectivity& inFaceinCells=mesh.getFaceCells(inFaces);
        Field& areaMagField=inGeomFields.areaMag;
        Field& areaField=inGeomFields.area;
        const TArray& areaMagArray=dynamic_cast<const TArray&>(areaMagField[inFaces]);
        const VectorT3Array& areaArray=dynamic_cast<const VectorT3Array&>(areaField[inFaces]);
        const BCfaceArray& inBCfArray=*(_BFaces[n]);

        const IntArray& ibType = dynamic_cast<const IntArray&>(inGeomFields.ibType[inCells]);

        //first sweep to make initial pairing
        int pairWith;
        Array<bool> marker(inFaceCount);
        Array<bool> marked(inCellCount);
        const T zero(0.);
        for(int c=0;c<inCellCount;c++)
        {
            if((FineToCoarse[c]<0)&&(ibType[c] == Mesh::IBTYPE_FLUID)) //dont bother if im already paired
            {
                //loop through all neighbors to find pairing
                const int neibCount=inCellinFaces.getCount(c);
                pairWith=-1;
                T maxArea=0.;
                int c2;
                for(int i=0; i<inFaceCount; i++)
                {
                    marker[i] = false;
                }
                for(int i=0; i<inCellCount; i++)
                {
                    marked[i] = false;
                }
                for(int neib=0;neib<neibCount;neib++)
                {
                    const int f=inCellinFaces(c,neib);
                    
                    if(inBCfArray[f]==0)  //not a boundary face
                    {
                        if(c==inFaceinCells(f,1))
                          c2=inFaceinCells(f,0);
                        else
                          c2=inFaceinCells(f,1);

                        VectorT3 tempArea;
                        tempArea[0]=zero;
                        tempArea[1]=zero;
                        tempArea[2]=zero;
                        if((FineToCoarse[c2]==-1)&&(!marked[c2]))
                        {
                            marker[f]=true;
                            marked[c2]=true;
                            for(int face=0;face<inFaceCount;face++)
                            {
                                if((c==inFaceinCells(face,0))&&(c2==inFaceinCells(face,1)))
                                  tempArea+=areaArray[face];
                                else if((c2==inFaceinCells(face,0))&&(c==inFaceinCells(face,1)))
                                  tempArea-=areaArray[face];
                            }
                        }

                        if((FineToCoarse[c2]==-1)&&(marker[f]))
                          if(mag(tempArea)>maxArea)
                          {
                              pairWith=c2;
                              maxArea=mag(tempArea);
                          }

                        /*
                        if(FineToCoarse[c2]==-1)
                          if(areaMagArray[f]>maxArea)
                          {
                              pairWith=c2;
                              maxArea=areaMagArray[f];
                          }
                        */
                    }
                }
                
                if(pairWith!=-1)
                {
                    FineToCoarse[c]=coarseCount;
                    FineToCoarse[pairWith]=coarseCount;
                    coarseCount++;
                }
            }
        }
        
        //second sweep to group stragglers, or group with self
        for(int c=0;c<inCellCount;c++)
        {
            if((FineToCoarse[c]==-1)&&(ibType[c] == Mesh::IBTYPE_FLUID))
            {
                const int neibCount=inCellinFaces.getCount(c);
                T maxArea=0.;
                int c2,c2perm;
                pairWith=-2;
                for(int i=0; i<inFaceCount; i++)
                {
                    marker[i] = false;
                }
                for(int i=0; i<inCellCount; i++)
                {
                    marked[i] = false;
                }

                for(int neib=0;neib<neibCount;neib++)
                {
                    const int f=inCellinFaces(c,neib);
                    
                    if(inBCfArray[f]==0)  //not a boundary face
                    {
                        if(c==inFaceinCells(f,1))
                          c2=inFaceinCells(f,0);
                        else
                          c2=inFaceinCells(f,1);

                        VectorT3 tempArea;
                        tempArea[0]=zero;
                        tempArea[1]=zero;
                        tempArea[2]=zero;
                        if(!marked[c2])
                        {
                            marker[f]=true;
                            marked[c2]=true;
                            for(int face=0;face<inFaceCount;face++)
                            {
                                if((c==inFaceinCells(face,0))&&(c2==inFaceinCells(face,1)))
                                  tempArea+=areaArray[face];
                                else if((c2==inFaceinCells(face,0))&&(c==inFaceinCells(face,1)))
                                  tempArea-=areaArray[face];
                            }
                        }
                        
                        if(marker[f])
                          if(mag(tempArea)>maxArea)
                          {
                              pairWith=FineToCoarse[c2]; //coarse level cell
                              c2perm=c2;                 //fine level cell
                              maxArea=mag(tempArea);
                          }

                        /*
                        if(areaMagArray[f]>maxArea)
                        {
                            pairWith=FineToCoarse[c2]; //coarse level cell
                            c2perm=c2;                 //fine level cell
                            maxArea=areaMagArray[f];
                        }
                        */
                    }
                }

                if(pairWith==-2)
                {
                    FineToCoarse[c]=coarseCount;
                    coarseCount++;
                }
                else
                {
                    if(FineToCoarse[c2perm]==-1)
                    {
                        FineToCoarse[c]=coarseCount;
                        FineToCoarse[c2perm]=coarseCount;
                        coarseCount++;
                    }
                    else
                      FineToCoarse[c]=pairWith;
                }
            }     
        }

        for(int c=0;c<inCellCount;c++)
        {
            if(ibType[c] != Mesh::IBTYPE_FLUID)
            {
                FineToCoarse[c]=coarseCount;
                coarseCount++;
            }
        }

        int coarseGhost=coarseCount;
        _coarseSizes[&mesh]=coarseCount;

        /*      
        if(MPI::COMM_WORLD.Get_rank()==1)
          for(int c=0;c<inCells.getCount();c++)
            cout<<" in makecoarsemesh1 before boundary, rank,level,cell,index = "<<MPI::COMM_WORLD.Get_rank()<<" "<<_level<<" "<<c<<" "<<FineToCoarse[c]<<endl;
        */      

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

            const CRConnectivity& faceCells = mesh.getFaceCells(faces);                  
            
            for(int f=0; f< nFaces; f++)
            {
                const int c1= faceCells(f,1);// boundary cell
                FineToCoarse[c1]=coarseGhost;
                coarseGhost++;
            }
        }
        
        /*
        if(MPI::COMM_WORLD.Get_rank()==1)
          for(int c=0;c<inCells.getCount();c++)
            cout<<" in makecoarsemesh1, rank, level,cell,index = "<<MPI::COMM_WORLD.Get_rank()<<" "<<_level<<" "<<c<<" "<<FineToCoarse[c]<<endl;
        */
      }
  }

template<class T >

int COMETModel< T >::MakeCoarseMesh2 ( const MeshList &  inMeshes, GeomFields &  inGeomFields, GeomFields &  coarseGeomFields, MeshList &  outMeshes  )

inline

Definition at line 2786 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BFaces, COMETModel< T >::_coarseGhostSizes, COMETModel< T >::_coarseSizes, COMETModel< T >::_siteMap, Field::addArray(), GeomFields::area, GeomFields::areaMag, Mesh::createBoundaryFaceGroup(), Mesh::createInterfaceGroup(), Mesh::createInteriorFaceGroup(), GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCellFaces(), Mesh::getCells(), StorageSite::getCount(), StorageSite::getCountLevel1(), Mesh::getDimension(), Mesh::getFaceCells(), Mesh::getFaces(), Mesh::getIBFaces(), Mesh::getInterfaceGroups(), StorageSite::getSelfCount(), FaceGroup::groupType, GeomFields::ibFaceIndex, GeomFields::ibType, Mesh::IBTYPE_FLUID, FaceGroup::id, Mesh::setConnectivity(), StorageSite::setCount(), StorageSite::setCountLevel1(), FaceGroup::site, and GeomFields::volume.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

  {

    int smallestMesh=-1;
    const int numMeshes=inMeshes.size();
    for(int n=0;n<numMeshes;n++)
      {
        const Mesh& mesh=*inMeshes[n];
        const int dim=mesh.getDimension();
        //Mesh* newMeshPtr=new Mesh(dim);

        //outMeshes.push_back(newMeshPtr);
        Mesh& newMeshPtr=*outMeshes[n];

        const StorageSite& inCells=mesh.getCells();
        StorageSite& outCells=newMeshPtr.getCells();
        StorageSite& outFaces=newMeshPtr.getFaces();
        StorageSite& outIBFaces=newMeshPtr.getIBFaces();
        const IntArray& ibType = dynamic_cast<const IntArray&>(inGeomFields.ibType[inCells]);
        const StorageSite& inFaces=mesh.getFaces();
        const StorageSite& inIBFaces=mesh.getIBFaces();
        const int inCellCount=inCells.getSelfCount();
        const int inCellTotal=inCells.getCount();
        const int inFaceCount=inFaces.getCount();
        const int inGhost=inCellTotal-inCellCount;
        int outGhost = 0;
        int coarseCount=0;
        Field& FineToCoarseField=inGeomFields.fineToCoarse;
        const IntArray& FineToCoarse=dynamic_cast<const IntArray&>(FineToCoarseField[inCells]);
        const CRConnectivity& inCellinFaces=mesh.getCellFaces();
        const CRConnectivity& inFaceinCells=mesh.getFaceCells(inFaces);
        Field& areaMagField=inGeomFields.areaMag;
        const TArray& areaMagArray=dynamic_cast<const TArray&>(areaMagField[inFaces]);
        const BCfaceArray& inBCfArray=*(_BFaces[n]);

        /*** creating coarse level cells ***/
        coarseCount = _coarseSizes[&mesh];
        int interfaceCellsLevel0 = _coarseGhostSizes[&mesh];    

        int boundaryCell=0;
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
        {
            const FaceGroup& fg = *fgPtr;
            const StorageSite& faces = fg.site;
            const int nFaces = faces.getCount();
            
            const CRConnectivity& faceCells = mesh.getFaceCells(faces);
            
            for(int f=0; f< nFaces; f++)
              {
                const int c1= faceCells(f,1);// boundary cell
                if(boundaryCell<FineToCoarse[c1])
                  boundaryCell=FineToCoarse[c1];
              }
        }
        boundaryCell++;
        if(boundaryCell!=1)
          boundaryCell-=coarseCount;
        else
          boundaryCell=0;

        for(int c=0; c< inCells.getCountLevel1(); c++)
        {
            if(outGhost<FineToCoarse[c])
              outGhost=FineToCoarse[c];
        }
        outGhost++;
        outGhost-=coarseCount;

        int interfaceCells = outGhost - boundaryCell;

        /*      
        if(MPI::COMM_WORLD.Get_rank()==1)
          cout<<"rank,level,inCellinternal, incelltotal,outCellInternal, outCellExternal, outInterface ="<<MPI::COMM_WORLD.Get_rank()<<" "<<_level<<" "<<inCellCount<<" and  "<<inCellTotal<<" and "<<coarseCount<<" and "<<outGhost<<" "<<interfaceCells<<endl;
        */
        
        /*
        if(MPI::COMM_WORLD.Get_rank()==1)
          for(int c=0;c<inCellTotal;c++)
            cout<<" in makecoarsemesh2, rank,level, cell,index = "<<MPI::COMM_WORLD.Get_rank()<<" "<<_level<<" "<<c<<" and "<<FineToCoarse[c]<<endl;
        */

        outCells.setCount(coarseCount,boundaryCell+interfaceCellsLevel0);
        outCells.setCountLevel1(coarseCount+outGhost);        

        /*** created coarse level cells ***/

        //make the coarse cell to fine cell connectivity.
        CRPtr CoarseToFineCells=CRPtr(new CRConnectivity(outCells,inCells));
        CoarseToFineCells->initCount();
        
        for(int c=0;c<inCells.getCountLevel1();c++)
          CoarseToFineCells->addCount(FineToCoarse[c],1);

        CoarseToFineCells->finishCount();

        for(int c=0;c<inCells.getCountLevel1();c++)
          CoarseToFineCells->add(FineToCoarse[c],c);

        CoarseToFineCells->finishAdd();

        /*** connectivity between itself (cells) and its finer mesh cells ***/ 
        newMeshPtr.setConnectivity(outCells,inCells,CoarseToFineCells);

        CRPtr FineFacesCoarseCells=CRPtr(new CRConnectivity(inFaces,outCells));
        FineFacesCoarseCells->initCount();

        //count surviving faces
        int survivingFaces=0;
        int coarse0, coarse1;
        for(int f=0;f<inFaceCount;f++)
        {
            coarse0=FineToCoarse[inFaceinCells(f,0)];
            coarse1=FineToCoarse[inFaceinCells(f,1)];
            if(coarse0!=coarse1)
            {
                survivingFaces++;
                FineFacesCoarseCells->addCount(f,2);
            }
        }
        
        FineFacesCoarseCells->finishCount();

        //make non-zero's
        int fc0,fc1,cc0,cc1;
        for(int f=0;f<inFaceCount;f++)
          {
            fc0=inFaceinCells(f,0);
            fc1=inFaceinCells(f,1);
            cc0=FineToCoarse[fc0];
            cc1=FineToCoarse[fc1];
            if(cc0!=cc1)
              {
                FineFacesCoarseCells->add(f,cc0);
                FineFacesCoarseCells->add(f,cc1);
              }
          }
        
        FineFacesCoarseCells->finishAdd();

        CRPtr CoarseCellsFineFaces=FineFacesCoarseCells->getTranspose();
        CRPtr CellCellCoarse=CoarseCellsFineFaces->multiply(*FineFacesCoarseCells,true);

        /*** coarse level cellcell connectivity created ***/ 

        /*
        int counter=0;
        BArray counted(outCells.getCount());
        counted=false;
        for(int c=0;c<outCells.getCount();c++)
          {
            counted[c]=true;
            const int neibs=CellCellCoarse->getCount(c);
            for(int n=0;n<neibs;n++)
              {
                const int c1=(*CellCellCoarse)(c,n);
                if(!counted[c1])
                  counter++;
              }
          }

        //outFaces.setCount(counter);
        */

        int countFaces=0;
        int cCell0, cCell1;
        for(int f=0;f<inFaceCount;f++)
        {
            cCell0=FineToCoarse[inFaceinCells(f,0)];
            cCell1=FineToCoarse[inFaceinCells(f,1)];
            if(cCell0!=cCell1)
            {
                countFaces++;
            }
        }

        outFaces.setCount(countFaces);

        int inFaceGhost = 0;
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          inFaceGhost+=(*fgPtr).site.getCount();
        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
          inFaceGhost+=(*fgPtr).site.getCount();
        const int inInteriorFaces = inFaceCount - inFaceGhost;

        const int del = inFaceCount - outFaces.getCount();

        //const int interiorCount=outFaces.getCount()-inGhost;
        const int interiorCount=inInteriorFaces-del;
        //if(MPI::COMM_WORLD.Get_rank()==1)
        //cout<<"level,outfaces, outghost, totalfaces = "<<_level<<" "<<interiorCount<<" "<<inGhost<<" "<<countFaces<<endl;
        const StorageSite& interiorFaces=newMeshPtr.createInteriorFaceGroup(interiorCount);
        
        int inOffset=interiorCount;
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
        {
            const FaceGroup& fg=*fgPtr;
            const int size=fg.site.getCount();
            newMeshPtr.createBoundaryFaceGroup(size,inOffset,fg.id,fg.groupType);
            inOffset+=size;
        }

        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
        {
            const FaceGroup& fg=*fgPtr;
            const int size=fg.site.getCount();
            newMeshPtr.createInterfaceGroup(size,inOffset,fg.id);
            inOffset+=size;
        }

        CRPtr CoarseFaceCoarseCell=CRPtr(new CRConnectivity(outFaces,outCells));
        CoarseFaceCoarseCell->initCount();

        survivingFaces=0;
        for(int f=0;f<inFaceCount;f++)
        {
            coarse0=FineToCoarse[inFaceinCells(f,0)];
            coarse1=FineToCoarse[inFaceinCells(f,1)];
            if(coarse0!=coarse1)
            {
                CoarseFaceCoarseCell->addCount(survivingFaces,2);
                survivingFaces++;
            }
        }
        
        CoarseFaceCoarseCell->finishCount();

        //make non-zero's
        survivingFaces=0;
        for(int f=0;f<inFaceCount;f++)
          {
            fc0=inFaceinCells(f,0);
            fc1=inFaceinCells(f,1);
            cc0=FineToCoarse[fc0];
            cc1=FineToCoarse[fc1];
            if(cc0!=cc1)
              {
                CoarseFaceCoarseCell->add(survivingFaces,cc0);
                CoarseFaceCoarseCell->add(survivingFaces,cc1);
                survivingFaces++;
              }
          }
        
        CoarseFaceCoarseCell->finishAdd();

        CRPtr CoarseCellCoarseFace=CoarseFaceCoarseCell->getTranspose();

        newMeshPtr.setConnectivity(outCells,outFaces,CoarseCellCoarseFace);
        newMeshPtr.setConnectivity(outFaces,outCells,CoarseFaceCoarseCell);

        Field& coarseIbTypeField=coarseGeomFields.ibType;
        shared_ptr<IntArray> ibTypePtr(new IntArray(outCells.getCountLevel1()));
        *ibTypePtr = Mesh::IBTYPE_FLUID;
        coarseIbTypeField.addArray(outCells,ibTypePtr);

        IntArray& coarseIBType = dynamic_cast<IntArray&>(coarseGeomFields.ibType[outCells]);

        for(int c=0;c<inCellCount;c++)
          if(ibType[c] != Mesh::IBTYPE_FLUID)
            coarseIBType[FineToCoarse[c]]=ibType[c];

        outIBFaces.setCount(inIBFaces.getCount());
        _siteMap[&inIBFaces]=&outIBFaces;

        shared_ptr<IntArray> ibFaceIndexPtr(new IntArray(outFaces.getCount()));
        *ibFaceIndexPtr = -1;
        coarseGeomFields.ibFaceIndex.addArray(outFaces,ibFaceIndexPtr);

        const IntArray& fineIBFaceIndex=dynamic_cast<const IntArray&>(inGeomFields.ibFaceIndex[inFaces]);
        IntArray& coarseIBFaceIndex=dynamic_cast<IntArray&>(coarseGeomFields.ibFaceIndex[outFaces]);

        CRPtr CoarseFacesFineFaces=CRPtr(new CRConnectivity(outFaces,inFaces));
        CoarseFacesFineFaces->initCount();

        survivingFaces=0;
        for(int f=0;f<inFaceCount;f++)
          {
            int fc0=inFaceinCells(f,0);
            int fc1=inFaceinCells(f,1);
            const int cc0=FineToCoarse[fc0];
            const int cc1=FineToCoarse[fc1];

            if(cc1!=cc0)
              {
                CoarseFacesFineFaces->addCount(survivingFaces,1);
                survivingFaces++;
              }
          }
        //cout<<"hello 3 rank "<<MPI::COMM_WORLD.Get_rank()<<endl;
        CoarseFacesFineFaces->finishCount();
        
        survivingFaces=0;
        for(int f=0;f<inFaceCount;f++)
        {
            int fc0=inFaceinCells(f,0);
            int fc1=inFaceinCells(f,1);
            const int cc0=FineToCoarse[fc0];
            const int cc1=FineToCoarse[fc1];
            if(cc1!=cc0)
            {
                CoarseFacesFineFaces->add(survivingFaces,f);
                coarseIBFaceIndex[survivingFaces]=fineIBFaceIndex[f];
                survivingFaces++;
            }
        }
        //cout<<"hello 4 rank "<<MPI::COMM_WORLD.Get_rank()<<endl;
        CoarseFacesFineFaces->finishAdd();

        /*
        if(MPI::COMM_WORLD.Get_rank()==1)
        {
            for(int f=0;f<outFaces.getCount();f++)
            {
                cout<<"level,rank,face,neighbor = "<<_level<<" "<<MPI::COMM_WORLD.Get_rank()<<" "<<f<<" "<<(*CoarseFaceCoarseCell)(f,0)<<" "<<(*CoarseFaceCoarseCell)(f,1)<<endl;
            }
        }
        */      

        //cout<<"hello 5 rank "<<MPI::COMM_WORLD.Get_rank()<<endl;
        
        //now make the geom fields
        const int outCellsCount=outCells.getSelfCount();
        TArrptr outCellVolumePtr=TArrptr(new TArray(outCellsCount));
        TArray& outCV=*outCellVolumePtr;
        outCV=0.;
        
        Field& VolumeField=inGeomFields.volume;
        Field& coarseVolumeField=coarseGeomFields.volume;
        const TArray& inCV=dynamic_cast<const TArray&>(VolumeField[inCells]);

        for(int c=0;c<outCellsCount;c++)
          {
            const int fineCount=CoarseToFineCells->getCount(c);
            for(int i=0;i<fineCount;i++)
              {
                int fc=(*CoarseToFineCells)(c,i);
                outCV[c]+=inCV[fc];
              }
          }

        coarseVolumeField.addArray(outCells,outCellVolumePtr);

        //cout<<"hello 6"<<endl;
        
        const int outFacesCount=outFaces.getCount();
        VT3Ptr outFaceAreaPtr=VT3Ptr(new VectorT3Array(outFacesCount));
        VectorT3Array& outFA=*outFaceAreaPtr;
        TArrptr outFaceAreaMagPtr=TArrptr(new TArray(outFacesCount));
        TArray& outFAMag=*outFaceAreaMagPtr;

        Field& FaceAreaField=inGeomFields.area;
        Field& coarseFaceAreaField=coarseGeomFields.area;
        Field& coarseAreaMagField=coarseGeomFields.areaMag;
        const VectorT3Array& inFA=
          dynamic_cast<const VectorT3Array&>(FaceAreaField[inFaces]);

        VectorT3 myZero;
        myZero[0]=0.;
        myZero[1]=0.;
        myZero[2]=0.;

        outFA=myZero;
        outFAMag=0.;
        for(int f=0;f<outFacesCount;f++)
          {
            const int fineCount=CoarseFacesFineFaces->getCount(f);
            const int cCell0=(*CoarseFaceCoarseCell)(f,0);
            for(int i=0;i<fineCount;i++)
              {
                const int fFace=(*CoarseFacesFineFaces)(f,i);
                const int fCell0=inFaceinCells(fFace,0);
                const int CCell0=FineToCoarse[fCell0];

                //must make sure the area vector is pointing
                //from c0 to c1
                if(CCell0==cCell0)
                  outFA[f]+=inFA[fFace];
                else
                  outFA[f]-=inFA[fFace];
                outFAMag[f]+=areaMagArray[fFace];
              }
          }
        
        coarseFaceAreaField.addArray(outFaces,outFaceAreaPtr);
        coarseAreaMagField.addArray(outFaces,outFaceAreaMagPtr);
        
        //cout<<"hello 7"<<endl;
        /*
        Field& ibTypeField=inGeomFields.ibType;
        Field& coarseIbTypeField=coarseGeomFields.ibType;
        shared_ptr<IntArray> ibTypePtr(new IntArray(outCells.getSelfCount()));
        *ibTypePtr = Mesh::IBTYPE_FLUID;
        coarseIbTypeField.addArray(outCells,ibTypePtr);
        */
        if(smallestMesh<0)
          smallestMesh=outCells.getSelfCount();
        else
          {
            if(outCells.getSelfCount()<smallestMesh)
              smallestMesh=outCells.getSelfCount();
          }
        //cout<<"hello 8"<<endl;
        /*
        //This is for checking purposes only
        cout<<"Coarse Faces to Fine Faces"<<endl;
        for(int f=0;f<outFaces.getCount();f++)
          {
            const int neibs=CoarseFacesFineFaces->getCount(f);
            for(int n=0;n<neibs;n++)
              cout<<f<<" "<<(*CoarseFacesFineFaces)(f,n)<<endl;
            cout<<endl;
          }
        cout<<"Coarse Cells to Coarse Faces"<<endl;
        for(int c=0;c<outCells.getCount();c++)
          {
            const int neibs=CoarseCellCoarseFace->getCount(c);
            for(int n=0;n<neibs;n++)
              cout<<c<<" "<<(*CoarseCellCoarseFace)(c,n)<<endl;
            cout<<endl;
          }
        */
      }
    //cout<<"hello 6"<<endl;
    return smallestMesh;
  }

template<class T >

void COMETModel< T >::MakeCoarseModel ( TCOMET *  finerModel )

inline

Definition at line 575 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarseGatherMaps, COMETModel< T >::_coarseGeomFields, COMETModel< T >::_coarseScatterMaps, COMETModel< T >::_geomFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_sharedSiteMap, COMETModel< T >::_siteMap, COMETModel< T >::COMETModel(), Quadrature< T >::CopyQuad(), GeomFields::fineToCoarse, COMETModel< T >::getBCMap(), Mesh::getCells(), StorageSite::getCount(), StorageSite::getGatherMap(), StorageSite::getGatherMapLevel1(), StorageSite::getGatherProcID(), COMETModel< T >::getGeomFields(), COMETModel< T >::getLevel(), COMETModel< T >::getMeshList(), COMETModel< T >::getOptions(), COMETModel< T >::getQuadrature(), StorageSite::getScatterMap(), StorageSite::getScatterMapLevel1(), StorageSite::getScatterProcID(), StorageSite::getTag(), COMETModel< T >::getVCMap(), COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::setCoarserLevel(), COMETModel< T >::syncGhostCoarsening(), and Field::syncLocal().

Referenced by COMETModel< T >::init(), and COMETModel< T >::initFromOld().

    {

      if(_options.AgglomerationMethod=="FaceArea")
      {
          int maxLevs=finerModel->getOptions().maxLevels;
          int thisLevel=(finerModel->getLevel())+1;

          if(thisLevel<maxLevs)  //assumes # of levels will always work for the mesh
          {
              MeshList* newMeshesPtr=new MeshList;
              TQuad* newQuadPtr=new TQuad();
              MacroFields* newMacroPtr=new MacroFields("coarse");

              newQuadPtr->CopyQuad(finerModel->getQuadrature());

              MakeCoarseMesh1(finerModel->getMeshList(),
                                           finerModel->getGeomFields(),
                                           *newMeshesPtr);
              
              _geomFields.fineToCoarse.syncLocal();
              const Mesh& mesh = *_meshes[0];
              const StorageSite& cells = mesh.getCells();
              const int nCells = cells.getCount();
              Field& FineToCoarseField=(finerModel->getGeomFields()).fineToCoarse;
              const IntArray& coarseIndex=dynamic_cast<const IntArray&>(FineToCoarseField[cells]);
              
              /*              
              if(MPI::COMM_WORLD.Get_rank()==1)
                for(int c=0;c<nCells;c++)
                  cout<<" after sync, rank, level, cell no and finetocoarse = "<<MPI::COMM_WORLD.Get_rank()<<" "<<_level<<" "<<c<<" "<<coarseIndex[c]<<endl;
              */                
 
              syncGhostCoarsening(finerModel->getMeshList(),
                                  finerModel->getGeomFields(),
                                  *newMeshesPtr);
              const int numMeshes =_meshes.size();
              for (int n=0; n<numMeshes; n++)
              {
                  const Mesh& mesh = *_meshes[n];
                  const StorageSite& fineSite = mesh.getCells();
                  StorageSite& coarseSite = *_siteMap[&fineSite];
                  const StorageSite::ScatterMap& fineScatterMap = fineSite.getScatterMap();
                  const StorageSite::ScatterMap& fineScatterMapLevel1 = fineSite.getScatterMapLevel1();
                  StorageSite::ScatterMap& coarseScatterMap = coarseSite.getScatterMap();

                  foreach(const StorageSite::ScatterMap::value_type& pos, fineScatterMap)
                  {
                      const StorageSite& fineOSite = *pos.first;

#ifdef FVM_PARALLEL
                      // the ghost site will not have its corresponding coarse
                      // site created yet so we create it here
                      if (_siteMap.find(&fineOSite) == _siteMap.end())
                      {
                          shared_ptr<StorageSite> ghostSite
                            (new StorageSite(-1));
                          ghostSite->setGatherProcID ( fineOSite.getGatherProcID() );
                          ghostSite->setScatterProcID( fineOSite.getScatterProcID() );
                          ghostSite->setTag( fineOSite.getTag() );
                          StorageSite& coarseOSite = *ghostSite;
                          _siteMap[&fineOSite]=&coarseOSite;
                          _sharedSiteMap[&fineOSite]=ghostSite;
                      }
#endif
   
                      StorageSite& coarseOSite = *_siteMap[&fineOSite];
                      
                      SSPair sskey(&fineSite,&fineOSite);
                      coarseScatterMap[&coarseOSite] = _coarseScatterMaps[sskey];               
                  }

                  foreach(const StorageSite::ScatterMap::value_type& pos, fineScatterMapLevel1)
                  {
                      const StorageSite& fineOSite = *pos.first;
                      SSPair sskey(&fineSite,&fineOSite);
                      if (_coarseScatterMaps.find(sskey) != _coarseScatterMaps.end())
                      {

#ifdef FVM_PARALLEL
                          // the ghost site will not have its corresponding coarse
                          // site created yet so we create it here
                          if (_siteMap.find(&fineOSite) == _siteMap.end())
                          {
                              shared_ptr<StorageSite> ghostSite
                                (new StorageSite(-1));
                              ghostSite->setGatherProcID ( fineOSite.getGatherProcID() );
                              ghostSite->setScatterProcID( fineOSite.getScatterProcID() );
                              ghostSite->setTag( fineOSite.getTag() );
                              StorageSite& coarseOSite = *ghostSite;
                              _siteMap[&fineOSite]=&coarseOSite;
                              _sharedSiteMap[&fineOSite]=ghostSite;
                          }
#endif
                          
                          StorageSite& coarseOSite = *_siteMap[&fineOSite];

                          coarseScatterMap[&coarseOSite] = _coarseScatterMaps[sskey];
                      }
                  }
                  
                  const StorageSite::GatherMap& fineGatherMap = fineSite.getGatherMap();
                  const StorageSite::GatherMap& fineGatherMapLevel1 = fineSite.getGatherMapLevel1();
                  StorageSite::GatherMap& coarseGatherMap = coarseSite.getGatherMap();
                  foreach(const StorageSite::GatherMap::value_type& pos, fineGatherMap)
                  {
                      const StorageSite& fineOSite = *pos.first;
                      StorageSite& coarseOSite = *_siteMap[&fineOSite];
                      SSPair sskey(&fineSite,&fineOSite);

                      coarseGatherMap[&coarseOSite] = _coarseGatherMaps[sskey];
                  }

                  foreach(const StorageSite::GatherMap::value_type& pos, fineGatherMapLevel1)
                  {
                      const StorageSite& fineOSite = *pos.first;
                      SSPair sskey(&fineSite,&fineOSite);
                      if (_coarseGatherMaps.find(sskey) != _coarseGatherMaps.end())
                      {
                          foreach(SiteMap::value_type tempPos, _siteMap)
                          {
                              const StorageSite& tempOSite = *tempPos.first;
                              if(fineOSite.getTag()==tempOSite.getTag())
                              {
                                  //StorageSite& coarseOSite = *_siteMap[&fineOSite];
                                  StorageSite& coarseOSite = *_siteMap[&tempOSite];
                                  coarseGatherMap[&coarseOSite] = _coarseGatherMaps[sskey];
                              }
                          }
                      }
                  }
                  
              }
              
              int newCount= MakeCoarseMesh2(finerModel->getMeshList(),
                                            finerModel->getGeomFields(),_coarseGeomFields,
                                            *newMeshesPtr);

              TCOMET* newModelPtr=new COMETModel(*newMeshesPtr,thisLevel,
                                                 _coarseGeomFields,
                                                 *newMacroPtr,*newQuadPtr);
#ifdef FVM_PARALLEL
              MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE, &newCount, 1, MPI::INT, MPI::SUM);
              if(MPI::COMM_WORLD.Get_rank()==0)
                cout<<"Number of cells in level "<<thisLevel<<"  is "<<newCount<<endl;            
#endif

#ifndef FVM_PARALLEL
              cout<<"Number of cells in level "<<thisLevel<<"  is "<<newCount<<endl;
#endif

              newModelPtr->setFinerLevel(finerModel);
              finerModel->setCoarserLevel(newModelPtr);
              newModelPtr->getOptions()=finerModel->getOptions();
              newModelPtr->getBCMap()=finerModel->getBCMap();
              newModelPtr->getVCMap()=finerModel->getVCMap();

              newModelPtr->init();
              newModelPtr->InitializeMacroparameters();
              newModelPtr->initializeMaxwellian();
              newModelPtr->initializeCoarseMaxwellian();
              newModelPtr->ComputeMacroparameters();
              newModelPtr->ComputeCoarseMacroparameters();
              newModelPtr->ComputeCollisionfrequency();
              newModelPtr->initializeMaxwellianEq();

              if(newCount>_options.minCells)
                newModelPtr->MakeCoarseModel(newModelPtr);
              else
                _options.maxLevels=newModelPtr->getLevel();
          }
      }
      else if(_options.AgglomerationMethod=="AMG")
        throw CException("Have not implemented AMG agglomeration method.");
      else
        throw CException("Unknown agglomeration method.");
    }

template<class T >

void COMETModel< T >::MakeCoarseModel ( TCOMET *  finerModel )

inline

Definition at line 1080 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_options, COMETModel< T >::COMETModel(), GeomFields::fineToCoarse, COMETModel< T >::FinishCoarseMesh(), COMETModel< T >::getBCs(), COMETModel< T >::getGeomFields(), COMETModel< T >::getIClist(), COMETModel< T >::getKspaces(), COMETModel< T >::getLevel(), COMETModel< T >::getMeshICmap(), COMETModel< T >::getMeshList(), COMETModel< T >::getMKMap(), COMETModel< T >::getOptions(), COMETInterface< T >::makeCoarseCoeffs(), COMETModel< T >::makeCoarseScatGath(), COMETModel< T >::MakeInteriorCoarseMesh(), COMETModel< T >::MakeNewKspaces(), COMETModel< T >::setCoarserLevel(), COMETModel< T >::syncGhostCoarsening(), and Field::syncLocal().

  {

    if(_options.AgglomerationMethod=="FaceArea")
      {
        int maxLevs=finerModel->getOptions().maxLevels;
        int thisLevel=(finerModel->getLevel())+1;
        
        if(thisLevel<maxLevs)  //assumes # of levels will always work for the mesh
          {
            MeshList* newMeshesPtr=new MeshList;
            TkspList* newKspacesPtr=new TkspList;
            PhononMacro* newMacroPtr=new PhononMacro("coarse");

            MakeNewKspaces(finerModel->getKspaces(),*newKspacesPtr);
            
            IntArray CoarseCounts(_meshes.size());
            IntArray CoarseGhost(_meshes.size());
            map<const StorageSite*, IntArray*> PreFacePairMap;
            SiteMap siteMap;

            MakeInteriorCoarseMesh(finerModel->getMeshList(), finerModel->getGeomFields(),
                                   *newMeshesPtr, CoarseCounts, PreFacePairMap, CoarseGhost, siteMap);

#ifdef FVM_PARALLEL
            _geomFields.fineToCoarse.syncLocal();
            ScatGathMaps coarseScatterMaps;
            ScatGathMaps coarseGatherMaps;

            syncGhostCoarsening(finerModel->getMeshList(), finerModel->getGeomFields(),
                                *newMeshesPtr, coarseScatterMaps, coarseGatherMaps, CoarseCounts,
                                CoarseGhost);

            makeCoarseScatGath(finerModel->getMeshList(), siteMap, coarseScatterMaps, coarseGatherMaps);
#endif

            int newCount=FinishCoarseMesh(finerModel->getMeshList(), finerModel->getGeomFields(),
                                          *newMeshesPtr, CoarseCounts, PreFacePairMap, CoarseGhost);

            TCOMET* newModelPtr=new COMETModel(*newMeshesPtr,thisLevel,
                                               finerModel->getGeomFields(),
                                               *newKspacesPtr,*newMacroPtr);
            
            newModelPtr->setFinerLevel(finerModel);
            finerModel->setCoarserLevel(newModelPtr);
            newModelPtr->getOptions()=finerModel->getOptions();
            newModelPtr->getBCs()=finerModel->getBCs();
            newModelPtr->getMKMap()=finerModel->getMKMap();
            newModelPtr->getIClist()=finerModel->getIClist();
            newModelPtr->getMeshICmap()=finerModel->getMeshICmap();
            COMETInterface<T> ComInt(_meshes,_kspaces,_MeshKspaceMap,_macro,_geomFields);
            ComInt.makeCoarseCoeffs(finerModel->getIClist(),newModelPtr->getIClist(),*newMeshesPtr);
            newModelPtr->initCoarse();

            if(_options.DomainStats=="Loud")
              {
                cout<<"Level: "<<newModelPtr->getLevel()<<endl<<endl;
                newModelPtr->calcDomainStats();
                cout<<endl;
              }

            if(newCount>3)
              newModelPtr->MakeCoarseModel(newModelPtr);
            else
              _options.maxLevels=newModelPtr->getLevel();
          }
      }
    else if(_options.AgglomerationMethod=="AMG")
      throw CException("Have not implemented AMG agglomeration method.");
    else
      throw CException("Unknown agglomeration method.");
  }

template<class T >

void COMETModel< T >::makeCoarseScatGath ( const MeshList &  inMeshes, SiteMap &  siteMap, ScatGathMaps &  coarseScatMaps, ScatGathMaps &  coarseGathMaps  )

inline

Definition at line 1614 of file phononbase/COMETModel.h.

References Model::_meshes, Mesh::getCells(), StorageSite::getGatherMap(), StorageSite::getGatherProcID(), StorageSite::getScatterMap(), StorageSite::getScatterProcID(), StorageSite::getTag(), StorageSite::setGatherProcID(), StorageSite::setScatterProcID(), and StorageSite::setTag().

Referenced by COMETModel< T >::MakeCoarseModel().

  {
    const int numMeshes =_meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        const StorageSite& fineSite = mesh.getCells();
        StorageSite& coarseSite = *siteMap[&fineSite];
        const StorageSite::ScatterMap& fineScatterMap = fineSite.getScatterMap();
        StorageSite::ScatterMap& coarseScatterMap = coarseSite.getScatterMap();

        foreach(const StorageSite::ScatterMap::value_type& pos, fineScatterMap)
          {
            const StorageSite& fineOSite = *pos.first;

            // the ghost site will not have its corresponding coarse
            // site created yet so we create it here
            if (siteMap.find(&fineOSite) == siteMap.end())
              {
                StorageSite* ghostSite=new StorageSite(-1);
                ghostSite->setGatherProcID (fineOSite.getGatherProcID());
                ghostSite->setScatterProcID(fineOSite.getScatterProcID());
                ghostSite->setTag( fineOSite.getTag() );
                siteMap[&fineOSite]=ghostSite;
              }
   
            StorageSite* coarseOSite = siteMap[&fineOSite];
                      
            SSPair sskey(&fineSite,&fineOSite);
            coarseScatterMap[coarseOSite] = coarseScatMaps[sskey];

          }
                  
        const StorageSite::GatherMap& fineGatherMap = fineSite.getGatherMap();
        StorageSite::GatherMap& coarseGatherMap = coarseSite.getGatherMap();

        foreach(const StorageSite::GatherMap::value_type& pos, fineGatherMap)
          {
            const StorageSite& fineOSite = *pos.first;
            StorageSite& coarseOSite = *siteMap[&fineOSite];
            SSPair sskey(&fineSite,&fineOSite);

            coarseGatherMap[&coarseOSite] = coarseGathMaps[sskey];
          }
                  
      }
  }

template<class T >

void COMETModel< T >::makeFAS ( )

inline

Definition at line 3107 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, Mesh::getCells(), Kspace< T >::makeFAS(), PhononMacro::TlFASCorrection, PhononMacro::TlResidual, and COMETModel< T >::updateResid().

  {
    updateResid(false);

    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*_meshes[n];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        const StorageSite& cells=mesh.getCells();
        kspace.makeFAS();

        TArray& resArray=dynamic_cast<TArray&>(_macro.TlResidual[cells]);
        TArray& fasArray=dynamic_cast<TArray&>(_macro.TlFASCorrection[cells]);
        fasArray-=resArray;
      }
  }

template<class T >

void COMETModel< T >::makeFAS ( )

inline

Definition at line 5280 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtrFAS, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_quadrature, Mesh::getCells(), COMETModel< T >::updateResid(), MacroFields::velocityFASCorrection, and MacroFields::velocityResidual.

Referenced by COMETModel< T >::cycle().

  {
    updateResid(false);

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

        const int numDir = _quadrature.getDirCount();
        for(int dir=0;dir<numDir;dir++)
        {
            Field& fndRes = *_dsfPtrRes.dsf[dir];
            Field& fndFAS = *_dsfPtrFAS.dsf[dir];
            TArray& fRes = dynamic_cast<TArray&>(fndRes[cells]);
            TArray& fFAS = dynamic_cast<TArray&>(fndFAS[cells]);

            fFAS-=fRes;
        }

        VectorT3Array& vR = dynamic_cast<VectorT3Array&>(_macroFields.velocityResidual[cells]);
        VectorT3Array& vF = dynamic_cast<VectorT3Array&>(_macroFields.velocityFASCorrection[cells]);

        vF-=vR;
    }
  }

template<class T >

void COMETModel< T >::makeFAS ( const StorageSite &  solidFaces )

inline

Definition at line 5308 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtrFAS, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_quadrature, Mesh::getCells(), COMETModel< T >::updateResid(), MacroFields::velocityFASCorrection, and MacroFields::velocityResidual.

  {
    updateResid(false,solidFaces);

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

        const int numDir = _quadrature.getDirCount();
        for(int dir=0;dir<numDir;dir++)
        {
            Field& fndRes = *_dsfPtrRes.dsf[dir];
            Field& fndFAS = *_dsfPtrFAS.dsf[dir];
            TArray& fRes = dynamic_cast<TArray&>(fndRes[cells]); 
            TArray& fFAS = dynamic_cast<TArray&>(fndFAS[cells]);
              
            fFAS-=fRes;              
        }

        VectorT3Array& vR = dynamic_cast<VectorT3Array&>(_macroFields.velocityResidual[cells]);
        VectorT3Array& vF = dynamic_cast<VectorT3Array&>(_macroFields.velocityFASCorrection[cells]);

        vF-=vR;
      }
  }

template<class T >

void COMETModel< T >::makeFinestToCoarseConn ( )

inline

Definition at line 4139 of file phononbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, Model::_meshes, COMETModel< T >::_options, Mesh::getCells(), Mesh::getConnectivity(), COMETModel< T >::getFinerModel(), COMETModel< T >::getMeshList(), COMETModel< T >::getModelPointer(), CRConnectivity::getTranspose(), and Mesh::setConnectivity().

Referenced by COMETModel< T >::makePlotColors().

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        Mesh& mesh=*_meshes[n];
        const StorageSite& cells=mesh.getCells();
        
        Mesh& mesh1=*(_coarserLevel->getMeshList()[n]);
        const StorageSite& cells1=mesh1.getCells();

        const CRConnectivity& firstCRC=mesh1.getConnectivity(cells1,cells);
        CRPtr FineToCoarseOld=firstCRC.getTranspose();

        mesh.setConnectivity(cells,cells1,FineToCoarseOld);

        for(int lvl=2;lvl<_options.maxLevels;lvl++)
          {
            TCOMET* coarseModel=getModelPointer(lvl);
            Mesh& coarseMesh=*(coarseModel->getMeshList()[n]);
            const StorageSite& coarseCells=coarseMesh.getCells();
            TCOMET* finerModel=coarseModel->getFinerModel();
            Mesh& finerMesh=*(finerModel->getMeshList()[n]);
            const StorageSite& finerCells=finerMesh.getCells();
            const CRConnectivity& coarseToFine=coarseMesh.getConnectivity(coarseCells, finerCells);
            CRPtr FineToCoarseNew=coarseToFine.getTranspose();
            FineToCoarseNew=FineToCoarseOld->multiply(*FineToCoarseNew,true);
            mesh.setConnectivity(cells, coarseCells,FineToCoarseNew);
            FineToCoarseOld=FineToCoarseNew;
          }
        
      }
  }

template<class T >

void COMETModel< T >::MakeIBCoarseModel ( TCOMET *  finerModel, const StorageSite &  solidFaces  )

inline

Definition at line 753 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarseGatherMaps, COMETModel< T >::_coarseGeomFields, COMETModel< T >::_coarserLevel, COMETModel< T >::_coarseScatterMaps, COMETModel< T >::_dsfPtr, COMETModel< T >::_finestGeomFields, COMETModel< T >::_finestMacroFields, COMETModel< T >::_finestMeshes, COMETModel< T >::_geomFields, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, COMETModel< T >::_sharedSiteMap, COMETModel< T >::_siteMap, Field::addArray(), COMETModel< T >::COMETModel(), COMETModel< T >::ComputeCoarseMacroparameters(), COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::ComputeMacroparameters(), Quadrature< T >::CopyQuad(), MacroFields::density, DistFunctFields< T >::dsf, GeomFields::fineToCoarse, COMETModel< T >::getBCMap(), Mesh::getCells(), StorageSite::getCount(), COMETModel< T >::getdsf(), StorageSite::getGatherMap(), StorageSite::getGatherMapLevel1(), StorageSite::getGatherProcID(), COMETModel< T >::getGeomFields(), Mesh::getIBFaces(), COMETModel< T >::getLevel(), COMETModel< T >::getMeshList(), COMETModel< T >::getOptions(), COMETModel< T >::getQuadrature(), StorageSite::getScatterMap(), StorageSite::getScatterMapLevel1(), StorageSite::getScatterProcID(), StorageSite::getTag(), COMETModel< T >::getVCMap(), GeomFields::ibType, COMETModel< T >::init(), COMETModel< T >::initializeCoarseMaxwellian(), COMETModel< T >::InitializeMacroparameters(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::MakeIBCoarseModel(), COMETModel< T >::setCoarserLevel(), COMETModel< T >::setFinerLevel(), COMETModel< T >::syncGhostCoarsening(), Field::syncLocal(), MacroFields::temperature, and MacroFields::velocity.

Referenced by COMETModel< T >::MakeIBCoarseModel().

    {

      if(_options.AgglomerationMethod=="FaceArea")
        {
          int maxLevs=finerModel->getOptions().maxLevels;
          int thisLevel=(finerModel->getLevel())+1;

          if(thisLevel<maxLevs)  //assumes # of levels will always work for the mesh
            {
              MeshList* newMeshesPtr=new MeshList;
              TQuad* newQuadPtr=new TQuad();
              MacroFields* newMacroPtr=new MacroFields("coarse");

              newQuadPtr->CopyQuad(finerModel->getQuadrature());

              MakeCoarseMesh1(finerModel->getMeshList(),
                              finerModel->getGeomFields(),
                              *newMeshesPtr);
              
              _geomFields.fineToCoarse.syncLocal();
              const Mesh& mesh = *_meshes[0];
              const StorageSite& cells = mesh.getCells();
              const int nCells = cells.getCount();
              Field& FineToCoarseField=(finerModel->getGeomFields()).fineToCoarse;
              const IntArray& coarseIndex=dynamic_cast<const IntArray&>(FineToCoarseField[cells]);
              
              /*              
              if(MPI::COMM_WORLD.Get_rank()==1)
                for(int c=0;c<nCells;c++)
                  cout<<" after sync, rank, level, cell no and finetocoarse = "<<MPI::COMM_WORLD.Get_rank()<<" "<<_level<<" "<<c<<" "<<coarseIndex[c]<<endl;
              */                
 
              syncGhostCoarsening(finerModel->getMeshList(),
                                  finerModel->getGeomFields(),
                                  *newMeshesPtr);
              const int numMeshes =_meshes.size();
              for (int n=0; n<numMeshes; n++)
                {
                  const Mesh& mesh = *_meshes[n];
                  const StorageSite& fineSite = mesh.getCells();
                  StorageSite& coarseSite = *_siteMap[&fineSite];
                  const StorageSite::ScatterMap& fineScatterMap = fineSite.getScatterMap();
                  const StorageSite::ScatterMap& fineScatterMapLevel1 = fineSite.getScatterMapLevel1();
                  StorageSite::ScatterMap& coarseScatterMap = coarseSite.getScatterMap();

                  foreach(const StorageSite::ScatterMap::value_type& pos, fineScatterMap)
                    {
                      const StorageSite& fineOSite = *pos.first;

#ifdef FVM_PARALLEL
                      // the ghost site will not have its corresponding coarse
                      // site created yet so we create it here
                      if (_siteMap.find(&fineOSite) == _siteMap.end())
                        {
                          shared_ptr<StorageSite> ghostSite
                            (new StorageSite(-1));
                          ghostSite->setGatherProcID ( fineOSite.getGatherProcID() );
                          ghostSite->setScatterProcID( fineOSite.getScatterProcID() );
                          ghostSite->setTag( fineOSite.getTag() );
                          StorageSite& coarseOSite = *ghostSite;
                          _siteMap[&fineOSite]=&coarseOSite;
                          _sharedSiteMap[&fineOSite]=ghostSite;
                        }
#endif
   
                      StorageSite& coarseOSite = *_siteMap[&fineOSite];
                      
                      SSPair sskey(&fineSite,&fineOSite);
                      coarseScatterMap[&coarseOSite] = _coarseScatterMaps[sskey];
                    }
                  
                  foreach(const StorageSite::ScatterMap::value_type& pos, fineScatterMapLevel1)
                  {
                      const StorageSite& fineOSite = *pos.first;
                      SSPair sskey(&fineSite,&fineOSite);
                      if (_coarseScatterMaps.find(sskey) != _coarseScatterMaps.end())
                      {

#ifdef FVM_PARALLEL
                          // the ghost site will not have its corresponding coarse
                          // site created yet so we create it here
                          if (_siteMap.find(&fineOSite) == _siteMap.end())
                          {
                              shared_ptr<StorageSite> ghostSite
                                (new StorageSite(-1));
                              ghostSite->setGatherProcID ( fineOSite.getGatherProcID() );
                              ghostSite->setScatterProcID( fineOSite.getScatterProcID() );
                              ghostSite->setTag( fineOSite.getTag() );
                              StorageSite& coarseOSite = *ghostSite;
                              _siteMap[&fineOSite]=&coarseOSite;
                              _sharedSiteMap[&fineOSite]=ghostSite;
                          }
#endif

                          StorageSite& coarseOSite = *_siteMap[&fineOSite];
                          
                          coarseScatterMap[&coarseOSite] = _coarseScatterMaps[sskey];
                      }
                  }

                  const StorageSite::GatherMap& fineGatherMap = fineSite.getGatherMap();
                  const StorageSite::GatherMap& fineGatherMapLevel1 = fineSite.getGatherMapLevel1();
                  StorageSite::GatherMap& coarseGatherMap = coarseSite.getGatherMap();
                  foreach(const StorageSite::GatherMap::value_type& pos, fineGatherMap)
                    {
                      const StorageSite& fineOSite = *pos.first;
                      StorageSite& coarseOSite = *_siteMap[&fineOSite];
                      SSPair sskey(&fineSite,&fineOSite);

                      coarseGatherMap[&coarseOSite] = _coarseGatherMaps[sskey];
                    }
                  foreach(const StorageSite::GatherMap::value_type& pos, fineGatherMapLevel1)
                  {
                      const StorageSite& fineOSite = *pos.first;
                      SSPair sskey(&fineSite,&fineOSite);
                      if (_coarseGatherMaps.find(sskey) != _coarseGatherMaps.end())
                      {
                          foreach(SiteMap::value_type tempPos, _siteMap)
                          {
                              const StorageSite& tempOSite = *tempPos.first;
                              if(fineOSite.getTag()==tempOSite.getTag())
                              {
                                  //StorageSite& coarseOSite = *_siteMap[&fineOSite];
                                  StorageSite& coarseOSite = *_siteMap[&tempOSite];
                                  coarseGatherMap[&coarseOSite] = _coarseGatherMaps[sskey];
                              }
                          }
                      }
                  } 
                  
                }
              
              int newCount= MakeCoarseMesh2(finerModel->getMeshList(),
                                            finerModel->getGeomFields(),_coarseGeomFields,
                                            *newMeshesPtr);

              _coarseGeomFields.ibType.syncLocal();

              TCOMET* newModelPtr=new COMETModel(*newMeshesPtr,thisLevel,
                                                 _coarseGeomFields,
                                                 *newMacroPtr,*newQuadPtr,1,&_finestGeomFields,&_finestMeshes,&_finestMacroFields);
#ifdef FVM_PARALLEL
              MPI::COMM_WORLD.Allreduce( MPI::IN_PLACE, &newCount, 1, MPI::INT, MPI::SUM);
              if(MPI::COMM_WORLD.Get_rank()==0)
                cout<<"Number of cells in level "<<thisLevel<<"  is "<<newCount<<endl;
#endif

#ifndef FVM_PARALLEL
              cout<<"Number of cells in level "<<thisLevel<<"  is "<<newCount<<endl;
#endif

              newModelPtr->setFinerLevel(finerModel);
              finerModel->setCoarserLevel(newModelPtr);
              newModelPtr->getOptions()=finerModel->getOptions();
              newModelPtr->getBCMap()=finerModel->getBCMap();
              newModelPtr->getVCMap()=finerModel->getVCMap();

              for (int n=0; n<numMeshes; n++)
              {
                  const Mesh& mesh = *_meshes[n];
                  const StorageSite& fineIBFaces = mesh.getIBFaces();
                  if(fineIBFaces.getCount()>0)
                  {
                      StorageSite& coarseIBFaces = *_siteMap[&fineIBFaces];
                      for(int dir=0;dir<_quadrature.getDirCount();dir++)
                      {
                          Field& fnd = *_dsfPtr.dsf[dir];
                          const TArray& fIB = dynamic_cast<const TArray&>(fnd[fineIBFaces]);
                          shared_ptr<TArray> cIBV(new TArray(coarseIBFaces.getCount()));
                          cIBV->zero();
                          DistFunctFields<T>& coarserdsf = _coarserLevel->getdsf();
                          Field& cfnd = *coarserdsf.dsf[dir];
                          cfnd.addArray(coarseIBFaces,cIBV);
                          TArray& cIB = dynamic_cast<TArray&>(cfnd[coarseIBFaces]);
                          for(int i=0;i<coarseIBFaces.getCount();i++)
                            cIB[i]=fIB[i];
                      }
                  }

                  shared_ptr<VectorT3Array> coarseSolidVel(new VectorT3Array(solidFaces.getCount()));
                  const VectorT3Array& fineSolidVel = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[solidFaces]);
                  *coarseSolidVel = fineSolidVel;
                  newMacroPtr->velocity.addArray(solidFaces,coarseSolidVel);

                  shared_ptr<TArray> coarseSolidDensity(new TArray(solidFaces.getCount()));
                  const TArray& fineSolidDensity = dynamic_cast<const TArray&>(_macroFields.density[solidFaces]);
                  *coarseSolidDensity = fineSolidDensity;
                  newMacroPtr->density.addArray(solidFaces,coarseSolidDensity);

                  shared_ptr<TArray> coarseSolidTemperature(new TArray(solidFaces.getCount()));
                  const TArray& fineSolidTemperature = dynamic_cast<const TArray&>(_macroFields.temperature[solidFaces]);
                  *coarseSolidTemperature = fineSolidTemperature;
                  newMacroPtr->temperature.addArray(solidFaces,coarseSolidTemperature);
              }
              
              newModelPtr->init();
              newModelPtr->InitializeMacroparameters();
              newModelPtr->initializeMaxwellian();
              newModelPtr->initializeCoarseMaxwellian();
              newModelPtr->ComputeMacroparameters();
              newModelPtr->ComputeCoarseMacroparameters();
              newModelPtr->ComputeCollisionfrequency();
              newModelPtr->initializeMaxwellianEq();

              if(newCount>_options.minCells)
                newModelPtr->MakeIBCoarseModel(newModelPtr,solidFaces);
              else
                _options.maxLevels=newModelPtr->getLevel();
            }
        }
      else if(_options.AgglomerationMethod=="AMG")
        throw CException("Have not implemented AMG agglomeration method.");
      else
        throw CException("Unknown agglomeration method.");
    }

template<class T >

void COMETModel< T >::MakeInteriorCoarseMesh ( const MeshList &  inMeshes, GeomFields &  inGeomFields, MeshList &  outMeshes, IntArray &  CoarseCounts, map< const StorageSite *, IntArray * > &  PreFacePairMap, IntArray &  CoarseGhost, SiteMap &  siteMap  )

inline

break up face agglomeration if summed area is zero-ish

Definition at line 1176 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap, COMETModel< T >::_IClist, Model::_meshes, GeomFields::area, COMETModel< T >::coarsenInterfaceCells(), COMETModel< T >::coarsenInterior(), COMETModel< T >::correctSingleNeighbor(), COMETIC< T >::FgID0, COMETIC< T >::FgID1, GeomFields::fineToCoarse, COMETIC< T >::FineToCoarse0, COMETIC< T >::FineToCoarse1, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCommonMap(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getDimension(), Mesh::getFaceCells(), Mesh::getFaceGroup(), Mesh::getFaces(), StorageSite::getOffset(), StorageSite::getSelfCount(), CRConnectivity::getTranspose(), FaceGroup::id, COMETIC< T >::MeshID0, COMETIC< T >::MeshID1, CRConnectivity::multiply(), Mesh::setID(), FaceGroup::site, sqrt(), and Array< T >::zero().

Referenced by COMETModel< T >::MakeCoarseModel().

  {
    
    const int numMeshes=inMeshes.size();
    CoarseCounts=0;

    //coarsen interfaces first
    
    foreach(COMETIC<T>* icPtr, _IClist)
      {
        COMETIC<T>& ic=*icPtr;
        coarsenInterfaceCells(ic, CoarseCounts, inGeomFields, inMeshes);
      }

    //coarsen interiors
    for(int m=0;m<numMeshes;m++)
      {
        const Mesh& mesh=*inMeshes[m];
        const int dim=mesh.getDimension();
        Mesh* newMeshPtr=new Mesh(dim);
        outMeshes.push_back(newMeshPtr);
        newMeshPtr->setID(m);
        siteMap[&(mesh.getCells())]=&(newMeshPtr->getCells());
        int coarseCount=coarsenInterior(m, mesh, inGeomFields, CoarseCounts[m]);
      }

    foreach(COMETIC<T>* icPtr, _IClist)
      {
        COMETIC<T>& ic=*icPtr;
        const int Mid0=ic.MeshID0;
        const int Mid1=ic.MeshID1;
        const int Fid0=ic.FgID0;
        const int Fid1=ic.FgID1;
        const Mesh& mesh0=*inMeshes[Mid0];
        const Mesh& mesh1=*inMeshes[Mid1];
        const StorageSite& faces0=mesh0.getFaceGroup(Fid0).site;
        const StorageSite& faces1=mesh1.getFaceGroup(Fid1).site;
        const StorageSite::CommonMap& ComMap = faces0.getCommonMap();
        const IntArray& common01=*(ComMap.find(&faces1)->second);
        const StorageSite& cells0=mesh0.getCells();
        const StorageSite& cells1=mesh1.getCells();
        //const int f1Offset=faces1.getOffset();
        const StorageSite& allFaces0=mesh0.getFaces();
        const CRConnectivity& faceCells0=mesh0.getFaceCells(faces0);
        //const CRConnectivity& cellCells0=mesh0.getCellCells();
        //const CRConnectivity& cellCells1=mesh1.getCellCells();
        const CRPtr cellFaces0Ptr=faceCells0.getTranspose();
        const CRConnectivity& cellFaces0=*cellFaces0Ptr;
        const CRConnectivity& faceCells1=mesh1.getFaceCells(faces1);
        const CRPtr cellFaces1Ptr=faceCells1.getTranspose();
        //const CRConnectivity& cellFaces1=*cellFaces1Ptr;
        const int faceCount=faces0.getCount();
        IntArray& FineToCoarse0=dynamic_cast<IntArray&>(inGeomFields.fineToCoarse[cells0]);
        IntArray& FineToCoarse1=dynamic_cast<IntArray&>(inGeomFields.fineToCoarse[cells1]);
        const int cCount0=CoarseCounts[Mid0];
        //const int cCount1=CoarseCounts[Mid1];

        const CRPtr cellsIntGhost0Ptr=cellFaces0.multiply(faceCells0,true);
        const CRConnectivity& cellsIntGhost0=*cellsIntGhost0Ptr;

        Field& FaceAreaField=inGeomFields.area;
        const VectorT3Array& FArea0=
          dynamic_cast<const VectorT3Array&>(FaceAreaField[allFaces0]);  //global ordering

        IntArray* FaceFine2CoarsePtr0=new IntArray(faceCount);
        *FaceFine2CoarsePtr0=-1;
        IntArray& FaceFine2Coarse0=*FaceFine2CoarsePtr0;
        ic.FineToCoarse0=FaceFine2CoarsePtr0;

        IntArray* FaceFine2CoarsePtr1=new IntArray(faceCount);
        *FaceFine2CoarsePtr1=-1;
        IntArray& FaceFine2Coarse1=*FaceFine2CoarsePtr1;
        ic.FineToCoarse1=FaceFine2CoarsePtr1;

        StorageSite preCoarse0(cCount0);

        CRPtr preCoarseToFineCells0=CRPtr(new CRConnectivity(preCoarse0,cells0));

        preCoarseToFineCells0->initCount();

        for(int c=0;c<cells0.getSelfCount();c++)
          preCoarseToFineCells0->addCount(FineToCoarse0[c],1);
        
        preCoarseToFineCells0->finishCount();

        for(int c=0;c<cells0.getSelfCount();c++)
          preCoarseToFineCells0->add(FineToCoarse0[c],c);

        preCoarseToFineCells0->finishAdd();
        
        //initial pairing, no regard to zero summed area
        int coarseFace(0);
        for(int f=0;f<faceCount;f++)
          {
            
            if(FaceFine2Coarse0[f]==-1)
              {
                const int c00=faceCells0(f,0);   //interior cells
                const int f01=common01[f];
                const int c01=faceCells1(f01,0);
                const int coarseC00=FineToCoarse0[c00];  //coarse indices
                const int coarseC01=FineToCoarse1[c01];

                const int cC00fineCnt=preCoarseToFineCells0->getCount(coarseC00);
                for(int cC00fine=0;cC00fine<cC00fineCnt;cC00fine++)
                  {
                    const int fineCell=(*preCoarseToFineCells0)(coarseC00,cC00fine);
                    if(fineCell!=c00)
                      {
                        const int fineGhostCount=cellsIntGhost0.getCount(fineCell);
                        for(int fineGhostNum=0;fineGhostNum<fineGhostCount;fineGhostNum++)
                          {
                            const int fineGhost=cellsIntGhost0(fineCell,fineGhostNum);
                            const int f10=cellFaces0(fineGhost,0);
                            const int f11=common01[f10];
                            const int c11=faceCells1(f11,0);
                            
                            if(FineToCoarse1[c11]==coarseC01)
                              {
                                if(FaceFine2Coarse0[f10]==-1 && FaceFine2Coarse0[f]==-1)
                                  {
                                    FaceFine2Coarse0[f10]=coarseFace;
                                    FaceFine2Coarse0[f]=coarseFace;
                                    FaceFine2Coarse1[f11]=coarseFace;
                                    FaceFine2Coarse1[f01]=coarseFace;
                                    coarseFace++;
                                  }
                                else if(FaceFine2Coarse0[f10]==-1 && FaceFine2Coarse0[f]!=-1)
                                  {
                                    FaceFine2Coarse0[f10]=FaceFine2Coarse0[f];
                                    FaceFine2Coarse1[f11]=FaceFine2Coarse0[f01];
                                  }
                                else if(FaceFine2Coarse0[f10]!=-1 && FaceFine2Coarse0[f]==-1)
                                  {
                                    FaceFine2Coarse0[f]=FaceFine2Coarse0[f10];
                                    FaceFine2Coarse1[f01]=FaceFine2Coarse1[f11];
                                  }
                              }
                            
                          }
                      }
                  }

                if(FaceFine2Coarse0[f]==-1)
                  {
                    FaceFine2Coarse0[f]=coarseFace;
                    FaceFine2Coarse1[f01]=coarseFace;
                    coarseFace++;
                  }
              }

            //FOR NO AGGLOMERATION OF INTERFACE FACES
            //FaceFine2Coarse0[f]=coarseFace;
            //FaceFine2Coarse1[f]=coarseFace;
            //coarseFace++;


          }


        
        //must check for zero summed area
        VectorT3Array summedArea(coarseFace);
        summedArea.zero();
        for(int f=0;f<faceCount;f++)
          {
            const int offset=faces0.getOffset();
            summedArea[FaceFine2Coarse0[f]]+=FArea0[f+offset];
          }

        for(int f=0;f<faceCount;f++)
          {
            const int f01=common01[f];
            const int offset=faces0.getOffset();
            VectorT3& sumVec=summedArea[FaceFine2Coarse0[f]];
            const VectorT3& partVec=FArea0[f+offset];
            T sumMag=sqrt(sumVec[0]*sumVec[0]+sumVec[1]*sumVec[1]+
                          sumVec[2]*sumVec[2]);
            T partMag=sqrt(partVec[0]*partVec[0]+partVec[1]*partVec[1]+
                           partVec[2]*partVec[2]);

            if(sumMag/partMag<1.0)
              {
                sumVec-=partVec;
                FaceFine2Coarse0[f]=coarseFace;
                FaceFine2Coarse1[f01]=coarseFace;
                coarseFace++;
              }
            
          }

        PreFacePairMap[&faces0]=FaceFine2CoarsePtr0;
        PreFacePairMap[&faces1]=FaceFine2CoarsePtr1;

      }

    for(int n=0;n<numMeshes;n++)
      {
        const Mesh& mesh=*_meshes[n];
        
        if(!_IClist.empty())
          {
            CoarseCounts[n]=correctSingleNeighbor(n, mesh, inGeomFields, 
                                                  CoarseCounts[n], PreFacePairMap);
          }

        IntArray& FineToCoarse=dynamic_cast<IntArray&>(
                                                       inGeomFields.fineToCoarse[mesh.getCells()]);

        CoarseGhost[n]=CoarseCounts[n];
        int outGhost(0);

        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          {
            const FaceGroup& fg=*fgPtr;
            if(fg.id>0)
              {
                const CRConnectivity& faceCells=mesh.getFaceCells(fg.site);
                const int faceCount=fg.site.getCount();

                if(_bcMap[fg.id]->bcType == "Interface")
                  {
                    IntArray& FaceFine2Coarse=*PreFacePairMap[&fg.site];
                    
                    int coarseFaces(0);
                    for(int i=0;i<faceCount;i++)
                      {
                        const int cghost=faceCells(i,1);
                        FineToCoarse[cghost]=FaceFine2Coarse[i]+CoarseGhost[n];
                        if(FaceFine2Coarse[i]>coarseFaces)
                          coarseFaces=FaceFine2Coarse[i];
                      }
                    CoarseGhost[n]+=coarseFaces+1;
                    outGhost+=coarseFaces+1;
                  }
                else if(_bcMap[fg.id]->bcType == "temperature" ||
                        _bcMap[fg.id]->bcType == "reflecting"   )
                  {
                    for(int i=0;i<faceCount;i++)
                      {
                        const int cghost=faceCells(i,1);
                        FineToCoarse[cghost]=CoarseGhost[n];
                        CoarseGhost[n]++;
                        outGhost++;
                      }
                  }
              }
          }

      }

  }

template<class T >

void COMETModel< T >::MakeNewKspaces ( TkspList &  inList, TkspList &  outList  )

inline

Definition at line 1160 of file phononbase/COMETModel.h.

References Kspace< T >::CopyKspace().

Referenced by COMETModel< T >::MakeCoarseModel().

  {
    const int len=inList.size();
    for(int i=0;i<len;i++)
      {
        TkspPtr newKspacePtr=TkspPtr(new Tkspace());
        newKspacePtr->CopyKspace(*inList[i]);
        inList[i]->setCoarseKspace(newKspacePtr);
        outList.push_back(newKspacePtr);
      }
    
    for(int i=0;i<len;i++)
      inList[i]->giveTransmissions();

  }

template<class T >

void COMETModel< T >::makeNonEqTemp ( )

inline

Definition at line 4218 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, Kspace< T >::calcLatTemp(), Mesh::getCells(), StorageSite::getSelfCount(), and PhononMacro::temperature.

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*_meshes[n];
        const StorageSite& cells=mesh.getCells();
        const int numcells=cells.getSelfCount();
        TArray& Tl=dynamic_cast<TArray&>(_macro.temperature[cells]);
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        //const TArray& e=kspace.geteArray();

        //const int len=kspace.getlength();

        for(int c=0;c<numcells;c++)
          Tl[c]=kspace.calcLatTemp(c);      

      }
  }

template<class T >

void COMETModel< T >::MakeParallel ( )

inline

Definition at line 1009 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_quadrature, Field::syncLocal(), and Field::syncLocalVectorFields().

Referenced by COMETModel< T >::cycle(), COMETModel< T >::MakeCoarseIndex(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

    {
      Field::syncLocalVectorFields( _dsfPtr.dsf );
#if 0
      for(int dir=0;dir<_quadrature.getDirCount();dir++)
        {
          Field& fnd = *_dsfPtr.dsf[dir];
          fnd.syncLocal();
        }
#endif
    }

template<class T >

void COMETModel< T >::makePlotColors ( const int  level )

inline

Definition at line 4074 of file phononbase/COMETModel.h.

References COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_options, Field::addArray(), Mesh::getCells(), PhononMacro::getColorField(), Mesh::getConnectivity(), StorageSite::getCount(), COMETModel< T >::getMeshList(), COMETModel< T >::getModelPointer(), StorageSite::getSelfCount(), COMETModel< T >::makeFinestToCoarseConn(), and PhononMacro::plottingCellColors.

  {

    if(level==0)
      {
        if(_options.maxLevels>1)
          makeFinestToCoarseConn();
        shared_ptr<Field> field0ptr(new Field("plotColor"));
        _macro.plottingCellColors.push_back(field0ptr);
        Field& field0=*field0ptr;
        Field& colorField=_macro.getColorField(0);

        const int numMeshes = _meshes.size();
        for (int n=0; n<numMeshes; n++)
          {
            const Mesh& mesh=*_meshes[n];
            const StorageSite& cells=mesh.getCells();
            //const int cellCount=cells.getSelfCount();
            const int cellTotCount=cells.getCount();
            //const CRConnectivity& cellCells=mesh.getCellCells();
            TArray& colorArray=dynamic_cast<TArray&>(colorField[cells]);

            TArrptr colorPtr(new TArray(cellTotCount));
            (*colorPtr)=colorArray;
            field0.addArray(cells, colorPtr);
          }
        //if(_coarserLevel!=NULL)
        //  _coarserLevel->makePlotColors();
      }
    else
      {
        shared_ptr<Field> fieldptr(new Field("plotColor"));
        _macro.plottingCellColors.push_back(fieldptr);
        Field& field=*fieldptr;

        Field& colorField=_macro.getColorField(level);

        TCOMET* coarseModel=getModelPointer(level);
        const MeshList& coarseMeshes=coarseModel->getMeshList();
        const int numMeshes = _meshes.size();
        for(int n=0;n<numMeshes;n++)
          {
            const Mesh& finestMesh=*_meshes[n];
            const Mesh& coarseMesh=*coarseMeshes[n];
            const StorageSite& coarseCells=coarseMesh.getCells();
            const StorageSite& finestCells=finestMesh.getCells();
            const int finestCellTotCount=finestCells.getCount();
            const int finestCellCount=finestCells.getSelfCount();
            const CRConnectivity& finestToCoarse=finestMesh.getConnectivity(finestCells,coarseCells);
                    
            TArrptr plotColorPtr(new TArray(finestCellTotCount));
            TArray& plotColorArray=*plotColorPtr;
            field.addArray(finestCells, plotColorPtr);

            TArray& colorArray=dynamic_cast<TArray&>(colorField[coarseCells]);

            for(int c=0;c<finestCellCount;c++)
              plotColorArray[c]=colorArray[finestToCoarse(c,0)];
          }

        //if(_coarserLevel!=NULL)
        //  _coarserLevel->makePlotColors();
      }
  }

template<class T >

ArrayBase* COMETModel< T >::modewiseHeatFluxIntegral ( const Mesh &  mesh, const int  faceGroupId  )

inline

Definition at line 3460 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, COMETModel< T >::_kspaces, COMETModel< T >::_MeshKspaceMap, GeomFields::area, Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), kvol< T >::getdk3(), Kspace< T >::geteArray(), Mesh::getFaceCells(), Kspace< T >::getGlobalIndex(), Mesh::getID(), pmode< T >::getIndex(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), Kspace< T >::gettotmodes(), pmode< T >::getv(), FaceGroup::id, FaceGroup::site, and Array< T >::zero().

  {
    //bool found = false;
    const int n=mesh.getID();
    Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
    TArray& eArray=kspace.geteArray();
    //const T DK3=kspace.getDK3();
    TArray* qptr(new TArray(kspace.gettotmodes()));
    TArray& q(*qptr);
    q.zero();

    const T hbar=6.582119e-16;  // (eV s)

    foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
      {
        const FaceGroup& fg = *fgPtr;
        if (fg.id == faceGroupId)
          {
            const StorageSite& faces = fg.site;
            const int nFaces = faces.getCount();
            //const StorageSite& cells = mesh.getCells();
            const CRConnectivity& faceCells=mesh.getFaceCells(faces);
            const Field& areaField=_geomFields.area;
            const VectorT3Array& faceArea=dynamic_cast<const VectorT3Array&>(areaField[faces]);
            
            for(int f=0; f<nFaces; f++)
              {
                const VectorT3 An=faceArea[f];
                const int c1=faceCells(f,1);
                int cellIndex=kspace.getGlobalIndex(c1,0);
                for(int k=0;k<kspace.getlength();k++)
                  {
                    Tkvol& kv=kspace.getkvol(k);
                    int modenum=kv.getmodenum();
                    for(int m=0;m<modenum;m++)
                      {
                        VectorT3 vg=kv.getmode(m).getv();
                        const int index=kv.getmode(m).getIndex()-1;
                        T dk3=kv.getdk3();
                        //T energy=hbar*kv.getmode(m).getomega();
                        const T vgdotAn=An[0]*vg[0]+An[1]*vg[1]+An[2]*vg[2];
                        q[index]+= eArray[cellIndex]*vgdotAn*dk3;//*energy;
                        cellIndex++;
                      }
                  }
              }

          }
      }
    
    return qptr;
  }

template<class T >

void COMETModel< T >::MomentHierarchy ( )

inline

Definition at line 1525 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, Mesh::getCells(), StorageSite::getCount(), MacroFields::Knq, and MacroFields::velocity.

                          {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const int Knq_dir=_options.Knq_direction; 
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const TArray& wts= dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);
        VectorT3Array& v = dynamic_cast<VectorT3Array&>(_macroFields.velocity[cells]);
        TArray& Knq = dynamic_cast<TArray&>(_macroFields.Knq[cells]);
        const int num_directions = _quadrature.getDirCount(); 
        if (Knq_dir ==0){
          for(int j=0;j<num_directions;j++){
            Field& fnd = *_dsfPtr.dsf[j];
            const TArray& f = dynamic_cast<const TArray&>(fnd[cells]);
            for(int c=0; c<nCells;c++){
              Knq[c]=Knq[c]+0.5*f[c]*wts[j]*(pow(cx[j]-v[c][0],3.0)+(cx[j]-v[c][0])*pow(cy[j]-v[c][1],2.0)+(cx[j]-v[c][0])*pow(cz[j]-v[c][2],2.0));
          }
          }}
        else if(Knq_dir ==1){
          for(int j=0;j<num_directions;j++){
            Field& fnd = *_dsfPtr.dsf[j];
            const TArray& f = dynamic_cast<const TArray&>(fnd[cells]); 
            for(int c=0; c<nCells;c++){
              Knq[c]=Knq[c]+0.5*f[c]*wts[j]*(pow(cy[j]-v[c][1],3.0)+(cy[j]-v[c][1])*pow(cx[j]-v[c][0],2.0)+(cy[j]-v[c][1])*pow(cz[j]-v[c][2],2.0));
            }
          }}
        
        else if(Knq_dir ==2){
          for(int j=0;j<num_directions;j++){
            Field& fnd = *_dsfPtr.dsf[j];
            const TArray& f = dynamic_cast<const TArray&>(fnd[cells]); 
            for(int c=0; c<nCells;c++){
              Knq[c]=Knq[c]+0.5*f[c]*wts[j]*(pow(cz[j]-v[c][2],3.0)+(cz[j]-v[c][2])*pow(cx[j]-v[c][0],2.0)+(cz[j]-v[c][2])*pow(cy[j]-v[c][1],2.0));
            }
          }}
      }
  }

template<class T >

void COMETModel< T >::NewtonsMethodBGK ( const int  ktrial )

inline

Definition at line 1670 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, MacroFields::coeff, MacroFields::density, fabs(), Mesh::getCells(), StorageSite::getCount(), inverseGauss(), COMETModel< T >::setJacobianBGK(), MacroFields::temperature, and MacroFields::velocity.

Referenced by COMETModel< T >::EquilibriumDistributionBGK().

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {         
        //cout << " NewtonsMethod" <<endl;
        const T tolx=_options["ToleranceX"];
        const T tolf=_options["ToleranceF"];
        const int sizeC=5;
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();
        
        const TArray& density = dynamic_cast<const TArray&>(_macroFields.density[cells]);
        const TArray& temperature = dynamic_cast<const TArray&>(_macroFields.temperature[cells]);
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        
        VectorT5Array& coeff = dynamic_cast<VectorT5Array&>(_macroFields.coeff[cells]);
        
        for(int c=0; c<nCells;c++){
          
          for (int trial=0;trial<ktrial;trial ++){
            SquareMatrix<T,sizeC> fjac(0);
            SquareMatrix<T,sizeC> fjacinv(0);
            VectorT5 fvec;
           
            
            fvec[0]=density[c];
            fvec[1]=density[c]*v[c][0];
            fvec[2]=density[c]*v[c][1];
            fvec[3]=density[c]*v[c][2];
            fvec[4]=1.5*density[c]*temperature[c]+density[c]*(pow(v[c][0],2)+pow(v[c][1],2)+pow(v[c][2],2.0));
            
          
            setJacobianBGK(fjac,fvec,coeff[c],v[c],c);
            
            //solve using GE or inverse
            T errf=0.;
            for (int row=0;row<sizeC;row++){errf+=fabs(fvec[row]);}
            
            if(errf <= tolf)
              break;
            VectorT5 pvec;
            for (int row=0;row<sizeC;row++){pvec[row]=-fvec[row];}//rhs
          

            //solve Ax=b for x 
            //p=GE_elim(fjac,p,3);
            VectorT5 xvec;
            fjacinv=inverseGauss(fjac,sizeC);
            
           
            
            for (int row=0;row<sizeC;row++){ 
              xvec[row]=0.0;
              for (int col=0;col<sizeC;col++){
                xvec[row]+=fjacinv(row,col)*pvec[col];}
            }
            //check for convergence, update
            
            T errx=0.;
            for (int row=0;row<sizeC;row++){
              errx +=fabs(xvec[row]);
              coeff[c][row]+= xvec[row];
            }
            
          
            if(errx <= tolx)
              break;
            
          }
          
          
        }
      }
    
  }

template<class T >

void COMETModel< T >::NewtonsMethodESBGK ( const int  ktrial )

inline

Definition at line 1840 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, MacroFields::coeffg, MacroFields::density, fabs(), Mesh::getCells(), StorageSite::getCount(), inverseGauss(), COMETModel< T >::setJacobianESBGK(), MacroFields::Txx, MacroFields::Txy, MacroFields::Tyy, MacroFields::Tyz, MacroFields::Tzx, MacroFields::Tzz, and MacroFields::velocity.

Referenced by COMETModel< T >::EquilibriumDistributionESBGK().

  {
    // cout<< "Inside Newtons Method" <<endl;
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const T tolx=_options["ToleranceX"];
        const T tolf=_options["ToleranceF"];
        const int sizeC=10;
        const Mesh& mesh = *_meshes[n];
        const StorageSite& cells = mesh.getCells();
        const int nCells = cells.getCount();
        
        const TArray& density = dynamic_cast<const TArray&>(_macroFields.density[cells]);
        
        const TArray& Txx = dynamic_cast<const TArray&>(_macroFields.Txx[cells]);
        const TArray& Tyy = dynamic_cast<const TArray&>(_macroFields.Tyy[cells]);
        const TArray& Tzz = dynamic_cast<const TArray&>(_macroFields.Tzz[cells]);
        const TArray& Txy = dynamic_cast<const TArray&>(_macroFields.Txy[cells]);
        const TArray& Tyz = dynamic_cast<const TArray&>(_macroFields.Tyz[cells]);
        const TArray& Tzx = dynamic_cast<const TArray&>(_macroFields.Tzx[cells]);
        
        const VectorT3Array& v = dynamic_cast<const VectorT3Array&>(_macroFields.velocity[cells]);
        
        VectorT10Array& coeffg = dynamic_cast<VectorT10Array&>(_macroFields.coeffg[cells]);
        
        for(int c=0; c<nCells;c++){
          // {cout <<"NM:ES" <<c <<endl;}
          for (int trial=0;trial<ktrial;trial ++){
            SquareMatrix<T,sizeC> fjac(0);
            SquareMatrix<T,sizeC> fjacinv(0);
            Vector<T,sizeC> fvec;
            // if (c==_options.printCellNumber){cout <<"trial" <<trial <<endl;}
            
            fvec[0]=density[c];
            fvec[1]=density[c]*v[c][0];
            fvec[2]=density[c]*v[c][1];
            fvec[3]=density[c]*v[c][2];
            fvec[4]=density[c]*(pow(v[c][0],2)+Txx[c]); 
            fvec[5]=density[c]*(pow(v[c][1],2)+Tyy[c]);
            fvec[6]=density[c]*(pow(v[c][2],2)+Tzz[c]);
            fvec[7]=density[c]*(v[c][0]*v[c][1]+Txy[c]);
            fvec[8]=density[c]*(v[c][1]*v[c][2]+Tyz[c]);
            fvec[9]=density[c]*(v[c][2]*v[c][0]+Tzx[c]);
            
            //calculate Jacobian
            setJacobianESBGK(fjac,fvec,coeffg[c],v[c],c);
            
            
            //solve using GaussElimination
            T errf=0.; //and Jacobian matrix in fjac.
            for (int row=0;row<sizeC;row++){errf+=fabs(fvec[row]);}
            if(errf <= tolf)
              break;
            Vector<T,sizeC> pvec;
            for (int row=0;row<sizeC;row++){pvec[row]=-fvec[row];}
            
            
            //solve Ax=b for x 
            //p=GE_elim(fjac,p,3);
            Vector<T,sizeC> xvec; 
            fjacinv=inverseGauss(fjac,sizeC);
            for (int row=0;row<sizeC;row++){ 
              xvec[row]=0.0;
              for (int col=0;col<sizeC;col++){
                xvec[row]+=fjacinv(row,col)*pvec[col];
              
              }
            }
            /*
            if (c==_options.printCellNumber){
              cout << " cg0 "<<coeffg[c][0]<<" cg1 "<<coeffg[c][1]<<"  cg2 "<<coeffg[c][2] << endl;
              cout <<" cg3 " <<coeffg[c][3]<< " cg4 "<<coeffg[c][4]<<" cg5 "<<coeffg[c][5]<<"  cg6 "<<coeffg[c][6] << endl;
              cout <<" cg7 " <<coeffg[c][7]<< " cg8 "<<coeffg[c][8]<<" cg9 "<<coeffg[c][9]<<endl;
            
                  
            //cout << " fvec-ESBGK " << fvec[4] <<fvec[5]<<fvec[6]<<fvec[7]<<fvec[8]<<fvec[9] <<endl;
            FILE * pFile;
            pFile = fopen("fvecfjac.dat","wa");  
            //fprintf(pFile,"%s %d \n","trial",trial);
            for (int mat_col=0;mat_col<sizeC;mat_col++){fprintf(pFile,"%12.4E",fvec[mat_col]);} 
            fprintf(pFile,"\n");
            for (int mat_row=0;mat_row<sizeC;mat_row++){
              for (int mat_col=0;mat_col<sizeC;mat_col++){
                  fprintf(pFile,"%12.4E",fjac(mat_row,mat_col));}
              fprintf(pFile,"\n");} 
            // fprintf(pFile,"done \n");
            //inverse
            for (int mat_row=0;mat_row<sizeC;mat_row++){
              for (int mat_col=0;mat_col<sizeC;mat_col++){
                fprintf(pFile,"%12.4E",fjacinv(mat_row,mat_col));}
              fprintf(pFile,"\n");} 
            //solution
            for (int mat_col=0;mat_col<sizeC;mat_col++){
              fprintf(pFile,"%12.4E",pvec[mat_col]);} 
              } 
            */
            
            //check for convergence, update
            T errx=0.;//%Check root convergence.
            for (int row=0;row<sizeC;row++){
              errx +=fabs(xvec[row]);
              coeffg[c][row]+= xvec[row];
            }
            //if (c==_options.printCellNumber){cout <<"errx "<<errx<<endl;}
            if(errx <= tolx)
              break;
            
          }
          
        }
      }
  }

template<class T >

void COMETModel< T >::OutputDsfBLOCK ( const char *  filename )

inline

Definition at line 2493 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtr, COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, and Mesh::getCells().

  {
    FILE * pFile;
    pFile = fopen(filename,"w"); 
    int N1=_quadrature.getNVCount();
    int N2=_quadrature.getNthetaCount();
    int N3=_quadrature.getNphiCount();
    fprintf(pFile,"%s \n", "VARIABLES= cx, cy, cz, f,fEq,fES");
    fprintf(pFile, "%s %i %s %i %s %i \n","ZONE I=", N3,",J=",N2,",K=",N1);
    fprintf(pFile, "%s \n","F=BLOCK, VARLOCATION=(NODAL,NODAL,NODAL,NODAL,NODAL,NODAL)");
    const int numMeshes = _meshes.size();
    const int cellno=_options.printCellNumber;
    for (int n=0; n<numMeshes; n++){
      const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
      const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
      const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
      const int numFields= _quadrature.getDirCount();   
      for(int j=0;j< numFields;j++){fprintf(pFile,"%E \n",cx[j]);}
      for(int j=0;j< numFields;j++){fprintf(pFile,"%E \n",cy[j]);}
      for(int j=0;j< numFields;j++){fprintf(pFile,"%E \n",cz[j]);}
      
      const Mesh& mesh = *_meshes[n];
      const StorageSite& cells = mesh.getCells();
      for(int j=0;j< numFields;j++){
        Field& fnd = *_dsfPtr.dsf[j];
        TArray& f = dynamic_cast< TArray&>(fnd[cells]);
        fprintf(pFile,"%E\n",f[cellno]);
      } 
      for(int j=0;j< numFields;j++){
        Field& fEqnd = *_dsfEqPtr.dsf[j];
        TArray& fEq = dynamic_cast< TArray&>(fEqnd[cells]);
        fprintf(pFile,"%E\n",fEq[cellno]);
      }
      if(_options.fgamma==2){
        for(int j=0;j< numFields;j++){
         
            Field& fndEqES = *_dsfEqPtrES.dsf[j];
          TArray& fEqES = dynamic_cast< TArray&>(fndEqES[cells]);
          fprintf(pFile,"%E\n",fEqES[cellno]);
        }}
      else{
        for(int j=0;j< numFields;j++){

            Field& fndEq = *_dsfEqPtr.dsf[j];
          TArray& fEq = dynamic_cast< TArray&>(fndEq[cells]);
          fprintf(pFile,"%E\n",fEq[cellno]);
        }}
      
    }
    fclose(pFile);
  }

template<class T >

void COMETModel< T >::OutputDsfPOINT ( )

inline

Definition at line 5595 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfEqPtr, COMETModel< T >::_dsfPtr, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, and Mesh::getCells().

  {
    FILE * pFile;
    pFile = fopen("cxyz0.plt","w");  
    int N1=_quadrature.getNVCount();
    int N2=_quadrature.getNthetaCount();
    int N3=_quadrature.getNphiCount();
    fprintf(pFile,"%s \n", "VARIABLES= cx, cy, cz, f,");
    fprintf(pFile, "%s %i %s %i %s %i \n","ZONE I=", N3,",J=",N2,"K=",N1);
    fprintf(pFile,"%s\n","F=POINT");
    const int numMeshes = _meshes.size();
    const int cellno=_options.printCellNumber;
    for (int n=0; n<numMeshes; n++)
      {
      const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
      const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
      const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
      const int numFields= _quadrature.getDirCount();   
      
      const Mesh& mesh = *_meshes[n];
      const StorageSite& cells = mesh.getCells();
      for(int j=0;j< numFields;j++)
        {
        Field& fnd = *_dsfPtr.dsf[j];
        TArray& f = dynamic_cast< TArray&>(fnd[cells]); 
        Field& fEqnd = *_dsfEqPtr.dsf[j];
        TArray& fEq = dynamic_cast< TArray&>(fEqnd[cells]);
        fprintf(pFile,"%E %E %E %E %E\n",cx[j],cy[j],cz[j],f[cellno],fEq[cellno]);
        }
      }
  }

template<class T >

void COMETModel< T >::restart ( )

inlinevirtual

Reimplemented from Model.

Definition at line 2293 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_initialKmodelNorm, COMETModel< T >::_niters, and COMETModel< T >::_persistenceData.

  {
    if (_persistenceData.find("niters") != _persistenceData.end())
    {
        shared_ptr<ArrayBase> rp = _persistenceData["niters"];
        ArrayBase& r = *rp;
        Array<int>& niterArray = dynamic_cast<Array<int>& >(r);
        _niters = niterArray[0];
    }

    if (_persistenceData.find("initialKmodelNorm") != _persistenceData.end())
    {
        shared_ptr<ArrayBase>  r = _persistenceData["initialKmodelNorm"];
        _initialKmodelNorm = MFRPtr(new MultiFieldReduction());
        Field& dsfField = *_dsfPtr.dsf[0];
        _initialKmodelNorm->addArray(dsfField,r);
        //_initialKmodelNorm->addArray(_dsfPtr,r);
    }
  }

template<class T >

bool COMETModel< T >::sameFaceGroup ( const Mesh &  mesh, const int  f0, const int  f1  )

inline

Definition at line 4181 of file phononbase/COMETModel.h.

References Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), StorageSite::getOffset(), and FaceGroup::site.

  {
    foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
      {
        const FaceGroup& fg=*fgPtr;
        const int off=fg.site.getOffset();
        const int cnt=fg.site.getCount();
        const int fin=off+cnt;

        if(f0<fin && f0>=off)
          if(f1<fin && f1>=off)
            return true;
      }
    return false;
  }

template<class T >

void COMETModel< T >::setBCMap ( COMETBCMap *  bcMap )

inline

Definition at line 4238 of file phononbase/COMETModel.h.

References COMETModel< T >::_bcMap.

{_bcMap=*bcMap;}

template<class T >

void COMETModel< T >::setBCMap ( COMETBCMap *  bcMap )

inline

Definition at line 5636 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_bcMap.

{_bcMap=*bcMap;}

template<class T >

void COMETModel< T >::SetBoundaryConditions ( )

inline

Definition at line 2313 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_bcMap, Model::_meshes, COMETModel< T >::_vcMap, COMETBC< T >::bcType, Mesh::getBoundaryFaceGroups(), Mesh::getID(), FaceGroup::groupType, FaceGroup::id, and COMETVC< T >::vcType.

Referenced by COMETModel< T >::COMETModel().

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh = *_meshes[n];
        
        COMETVC<T> *vc(new COMETVC<T>());
        vc->vcType = "flow";
        _vcMap[mesh.getID()] = vc;
        foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
          {
            const FaceGroup& fg = *fgPtr;
            if (_bcMap.find(fg.id) == _bcMap.end())
              {
                COMETBC<T> *bc(new COMETBC<T>());
                
                _bcMap[fg.id] = bc;
                if((fg.groupType == "wall"))
                  {
                    bc->bcType = "WallBC";
                  }
                else if((fg.groupType == "realwall"))
                  {
                    bc->bcType = "RealWallBC";
                  }
                else if (fg.groupType == "velocity-inlet")
                  {
                    bc->bcType = "VelocityInletBC";
                  }
                else if (fg.groupType == "pressure-inlet")
                  {
                    bc->bcType = "PressureInletBC";
                  }
                else if (fg.groupType == "pressure-outlet")
                  {
                    bc->bcType = "PressureOutletBC";
                  }
                else if ((fg.groupType == "symmetry"))
                  {
                    bc->bcType = "SymmetryBC";
                    }
        
                else if((fg.groupType =="zero-gradient "))
                  {
                      bc->bcType = "ZeroGradBC";
                  }
                else
                  throw CException("COMETModel: unknown face group type "
                                     + fg.groupType);
              }
          }
        /*
        foreach(const FaceGroupPtr fgPtr, mesh.getInterfaceGroups())
          {
            const FaceGroup& fg = *fgPtr;
            if (_bcMap.find(fg.id) == _bcMap.end())
              { COMETBC<T> *bc(new COMETBC<T>());
                
                _bcMap[fg.id] = bc;
                
                if ((fg.groupType == "NSinterface"))
                  {
                    bc->bcType = "NSInterfaceBC";
                  }
              }
          }
        */
      }
  }

template<class T >

void COMETModel< T >::setCoarserLevel ( TCOMET *  cl )

inline

Definition at line 4239 of file phononbase/COMETModel.h.

References COMETModel< T >::_coarserLevel.

{_coarserLevel=cl;}

template<class T >

void COMETModel< T >::setCoarserLevel ( TCOMET *  cl )

inline

Definition at line 5637 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarserLevel.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

{_coarserLevel=cl;}

template<class T >

void COMETModel< T >::sete0 ( )

inline

Definition at line 3125 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, pmode< T >::calce0(), Mesh::getCells(), Kspace< T >::gete0Array(), Kspace< T >::getGlobalIndex(), Kspace< T >::getkvol(), Kspace< T >::getlength(), kvol< T >::getmode(), kvol< T >::getmodenum(), StorageSite::getSelfCount(), PhononMacro::temperature, and Kspace< T >::updateTau().

Referenced by COMETModel< T >::cycle().

  {
    const int numMeshes = _meshes.size();
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*_meshes[n];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];
        const StorageSite& cells=mesh.getCells();
        const int cellCount=cells.getSelfCount();
        TArray& Tl=dynamic_cast<TArray&>(_macro.temperature[cells]);
        TArray& e0Array=kspace.gete0Array();
        const int klen=kspace.getlength();

        for(int c=0;c<cellCount;c++)
          {
            const T Tlat=Tl[c];
            int cellIndex=kspace.getGlobalIndex(c,0);
            for(int k=0;k<klen;k++)
              {
                Tkvol& kvol=kspace.getkvol(k);
                const int numModes=kvol.getmodenum();
                for(int m=0;m<numModes;m++)
                  {
                    Tmode& mode=kvol.getmode(m);
                    e0Array[cellIndex]=mode.calce0(Tlat);
                    kspace.updateTau(c,Tl[c]);
                    cellIndex++;
                  }
              }
          }
      }
  }

template<class T >

void COMETModel< T >::setFinerLevel ( TCOMET *  fl )

inline

Definition at line 4240 of file phononbase/COMETModel.h.

References COMETModel< T >::_finerLevel.

{_finerLevel=fl;}

template<class T >

void COMETModel< T >::setFinerLevel ( TCOMET *  fl )

inline

Definition at line 5638 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_finerLevel.

Referenced by COMETModel< T >::MakeIBCoarseModel().

{_finerLevel=fl;}

template<class T >

void COMETModel< T >::setFinestLevel ( TCOMET *  finest )

inline

Definition at line 1153 of file phononbase/COMETModel.h.

References COMETModel< T >::_coarserLevel, COMETModel< T >::_finestLevel, and COMETModel< T >::setFinestLevel().

Referenced by COMETModel< T >::init(), and COMETModel< T >::setFinestLevel().

  {
    _finestLevel=finest;
    if(_coarserLevel!=NULL)
      _coarserLevel->setFinestLevel(finest);
  }

template<class T >

void COMETModel< T >::setJacobianBGK ( SquareMatrix< T, 5 > &  fjac, VectorT5 &  fvec, const VectorT5 &  xn, const VectorT3 &  v, const int  c  )

inline

Definition at line 1799 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_quadrature.

Referenced by COMETModel< T >::NewtonsMethodBGK().

  { 
    
   
    const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
    const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
    const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
    const TArray& wts = dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);     
    
    const TArray2D& malphaBGK = dynamic_cast<const TArray2D&>(*_quadrature.malphaBGKPtr);       
    const int numFields= _quadrature.getDirCount(); 
    VectorT5 mexp;
    
    for(int j=0;j< numFields;j++){   
      T Cconst=pow(cx[j]-v[0],2.0)+pow(cy[j]-v[1],2.0)+pow(cz[j]-v[2],2.0);
      T Econst=xn[0]*exp(-xn[1]*Cconst+xn[2]*(cx[j]-v[0])+xn[3]*(cy[j]-v[1])+xn[4]*(cz[j]-v[2]))*wts[j];
      
      for (int row=0;row<5;row++){
        fvec[row]+= -Econst*malphaBGK(j,row); //smm
        
        //fvec[row]=tvec[row]+fvec[row];               //mma  
      }
     
      mexp[0]=-Econst/xn[0];
      mexp[1]=Econst*Cconst;
      mexp[2]=-Econst*(cx[j]-v[0]);
      mexp[3]=-Econst*(cy[j]-v[1]);
      mexp[4]=-Econst*(cz[j]-v[2]);
      for (int row=0;row<5;row++){
        for (int col=0;col<5;col++){
          fjac(row,col)+=malphaBGK(j,row)*mexp[col];  //new
        }
      }
      
      
    }
    
    
  
  }

template<class T >

void COMETModel< T >::setJacobianESBGK ( SquareMatrix< T, 10 > &  fjac, VectorT10 &  fvec, const VectorT10 &  xn, const VectorT3 &  v, const int  c  )

inline

Definition at line 2008 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_quadrature.

Referenced by COMETModel< T >::NewtonsMethodESBGK().

  {
    const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
    const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
    const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
    const TArray& wts = dynamic_cast<const TArray&>(*_quadrature.dcxyzPtr);     
    
    const TArray2D& malphaESBGK = dynamic_cast<const TArray2D&>(*_quadrature.malphaESBGKPtr);   
    const int numFields= _quadrature.getDirCount(); 
    VectorT10 mexp;
    
    for(int j=0;j< numFields;j++){   
      T Cc1=cx[j]-v[0];
      T Cc2=cy[j]-v[1];
      T Cc3=cz[j]-v[2];
      T Econst=xn[0]*exp(-xn[1]*pow(Cc1,2)+xn[2]*Cc1-xn[3]*pow(Cc2,2)+ xn[4]*Cc2
                         -xn[5]*pow(Cc3,2)+xn[6]*Cc3
                         +xn[7]*cx[j]*cy[j]+xn[8]*cy[j]*cz[j]+xn[9]*cz[j]*cx[j])*wts[j];     
      
      for (int row=0;row<10;row++){
        fvec[row]+= -Econst*malphaESBGK(j,row); //smm
      }
      
      mexp[0]=-Econst/xn[0];
      mexp[1]=Econst*pow(Cc1,2);
      mexp[2]=-Econst*Cc1;
      mexp[3]=Econst*pow(Cc2,2);
      mexp[4]=-Econst*Cc2; 
      mexp[5]=Econst*pow(Cc3,2);
      mexp[6]=-Econst*Cc3;
      
      mexp[7]=-Econst*cx[j]*cy[j];
      mexp[8]=-Econst*cy[j]*cz[j];
      mexp[9]=-Econst*cz[j]*cx[j];
   
      for (int row=0;row<10;row++){
        for (int col=0;col<10;col++){
          fjac(row,col)+=malphaESBGK(j,row)*mexp[col];  //new
        }
      }
      
      
      
      
    }
    
        
  }

template<class T >

void COMETModel< T >::setLocalScatterMaps ( const Mesh &  mesh0, StorageSite &  faces0, const Mesh &  mesh1, StorageSite &  faces1  )

inline

Definition at line 988 of file phononbase/COMETModel.h.

References StorageSite::getCommonMap(), StorageSite::getCount(), Mesh::getFaceCells(), and StorageSite::getScatterMap().

Referenced by COMETModel< T >::init(), and COMETModel< T >::initCoarse().

  {//makes the IntArray for the indices of the cells1 to which the cells0 scatter
    
    const IntArray& common01=*(faces0.getCommonMap()[&faces1]);
    IntArrPtr scatter01(new IntArray(faces0.getCount()));
    IntArrPtr scatter10(new IntArray(faces0.getCount()));
    const CRConnectivity& faceCells0=mesh0.getFaceCells(faces0);
    const CRConnectivity& faceCells1=mesh1.getFaceCells(faces1);

    for(int i=0;i<faces0.getCount();i++)
      {
        const int f01=common01[i];
        const int c01=faceCells1(f01,1);
        const int c10=faceCells0(i,1);
        (*scatter01)[i]=c01;
        (*scatter10)[f01]=c10;
      }

    faces0.getScatterMap()[&faces1]=scatter01;
    faces1.getScatterMap()[&faces0]=scatter10;
    
  }

template<class T >

void COMETModel< T >::setStraightLine ( const T  T1, const T  T2  )

inline

Definition at line 3641 of file phononbase/COMETModel.h.

References COMETModel< T >::_geomFields, COMETModel< T >::_macro, Model::_meshes, GeomFields::coordinate, Mesh::getCells(), StorageSite::getCount(), StorageSite::getSelfCount(), and PhononMacro::temperature.

  {
    const int numMeshes = _meshes.size();

    T xmax(0.);
    T xmin(0.);

    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*_meshes[n];
        const StorageSite& cells=mesh.getCells();
        const int numcells=cells.getCount();
        const VectorT3Array& coords=dynamic_cast<const VectorT3Array&>(_geomFields.coordinate[cells]);

        for(int c=0;c<numcells;c++)
          {
            T x=coords[c][0];
            if(x>xmax)
              xmax=x;
            if(x<xmin)
              xmin=x;
          }

      }
    
    for (int n=0; n<numMeshes; n++)
      {
        const Mesh& mesh=*_meshes[n];
        const StorageSite& cells=mesh.getCells();
        //const int numcells=cells.getCount();
        const int selfcells=cells.getSelfCount();
        TArray& Tl=dynamic_cast<TArray&>(_macro.temperature[cells]);
        const VectorT3Array& coords=dynamic_cast<const VectorT3Array&>(_geomFields.coordinate[cells]);
        
        for(int c=0;c<selfcells;c++)
          {
            T factor=(coords[c][0]-xmin)/(xmax-xmin);
            Tl[c]=T1+factor*(T2-T1);
          }

      }

  }

template<class T >

void COMETModel< T >::smooth ( int  dir )

inline

Definition at line 2810 of file phononbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_geomFields, COMETModel< T >::_IClist, COMETModel< T >::_kspaces, COMETModel< T >::_level, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_MeshToIC, COMETModel< T >::_options, COMETModel< T >::applyTemperatureBoundaries(), COMETDiscretizer< T >::COMETSolveCoarse(), COMETDiscretizer< T >::COMETSolveFine(), COMETDiscretizer< T >::COMETSolveFull(), COMETIC< T >::getKConnectivity(), Array< T >::getLength(), COMETIC< T >::getSelfFaceID(), COMETDiscretizer< T >::setfgFinder(), COMETModel< T >::swapGhostInfo(), and COMETInterface< T >::updateOtherGhost().

  {

    const int numMeshes=_meshes.size();
    int start;
    if(dir==1)
      start=0;
    else
      start=numMeshes-1;

    COMETInterface<T> ComInt(_meshes,_kspaces,_MeshKspaceMap,_macro,_geomFields);

    for(int msh=start;((msh<numMeshes)&&(msh>-1));msh+=dir)
      {
        const Mesh& mesh=*_meshes[msh];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[msh]];
        FgTKClistMap FgToKsc;

        if(!_MeshToIC.empty())
          {
            IntArray& ICs=*_MeshToIC[msh];
            const int totIC=ICs.getLength();
            for(int i=0;i<totIC;i++)
              {
                COMETIC<T>& ic=*_IClist[ICs[i]];
                int fgid=ic.getSelfFaceID(msh);
                FgToKsc[fgid]=ic.getKConnectivity(fgid);
              }
          }
        
        const BCcellArray& BCArray=*(_BCells[msh]);
        const BCfaceArray& BCfArray=*(_BFaces[msh]);

        COMETDiscretizer<T> CDisc(mesh,_geomFields,_macro,
                                  kspace,_bcMap,BCArray,BCfArray,_options,
                                  FgToKsc);

        CDisc.setfgFinder();

#ifdef FVM_PARALLEL
        swapGhostInfo();
#endif

        if(_options.Scattering=="Full")
          {
            applyTemperatureBoundaries();
            if(_level==0)
              {
                CDisc.COMETSolveFull(dir,_level);
                //CDisc.COMETSolveFull(-dir,_level);
              }
            else
              {
                CDisc.COMETSolveCoarse(dir,_level); 
                CDisc.COMETSolveCoarse(-dir,_level); 
              }
          }
        else
          {
            if(_level>0 || _options.Convection=="FirstOrder")
              {
                applyTemperatureBoundaries();
                CDisc.COMETSolveCoarse(dir,_level); 
                CDisc.COMETSolveCoarse(-dir,_level); 
              }
            else
              {
                //applyTemperatureBoundaries();
                CDisc.COMETSolveFine(dir,_level);
                CDisc.COMETSolveFine(-dir,_level);
              }
          }
        
        if(!_MeshToIC.empty())
          {
            IntArray& ICs=*_MeshToIC[msh];
            const int totIC=ICs.getLength();
            for(int i=0;i<totIC;i++)
              {
                COMETIC<T>& ic=*_IClist[ICs[i]];
                ComInt.updateOtherGhost(ic,msh,_level!=0);
              }
          }
        
      }

  }

template<class T >

void COMETModel< T >::smooth ( const int  num, const StorageSite &  solidFaces  )

inline

Definition at line 4927 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, COMETModel< T >::_dsfPtrFAS, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_faceReflectionArrayMap, COMETModel< T >::_geomFields, COMETModel< T >::_level, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, COMETModel< T >::_ZCells, COMETESBGKDiscretizer< T >::COMETSolve(), COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::ComputeCOMETMacroparameters(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::ConservationofMFSolid(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::MakeParallel(), and COMETESBGKDiscretizer< T >::setfgFinder().

Referenced by COMETModel< T >::doSweeps().

  {
    const int numDir=_quadrature.getDirCount();
    const int numMeshes=_meshes.size();
    for(int msh=0;msh<numMeshes;msh++)
    {
        const Mesh& mesh=*_meshes[msh];
        const BCcellArray& BCArray=*(_BCells[msh]);
        const BCfaceArray& BCfArray=*(_BFaces[msh]);
        const BCcellArray& ZCArray=*(_ZCells[msh]);
        COMETESBGKDiscretizer<T> CDisc(mesh,_geomFields,solidFaces,_macroFields,_quadrature,
                                       _dsfPtr,_dsfPtr1,_dsfPtr2,_dsfEqPtrES,_dsfPtrRes,_dsfPtrFAS,
                                       _options["timeStep"],_options.timeDiscretizationOrder,
                                       _options.transient,_options.underRelaxation,_options["rho_init"], 
                                       _options["T_init"],_options["molecularWeight"],_options.conOrder,
                                       _bcMap,_faceReflectionArrayMap,BCArray,BCfArray,ZCArray);

        CDisc.setfgFinder();

        MakeParallel();
  
        CDisc.COMETSolve(1,_level); //forward

        MakeParallel();

        //callCOMETBoundaryConditions();
        ComputeCOMETMacroparameters();
        ComputeCollisionfrequency();
        //update equilibrium distribution function 0-maxwellian, 1-BGK,2-ESBGK
        if (_options.fgamma==0){initializeMaxwellianEq();}
        else{ EquilibriumDistributionBGK();}
        if (_options.fgamma==2){EquilibriumDistributionESBGK();} 
        computeSolidFaceDsf(solidFaces,_options.method,_options.relaxDistribution);
        ConservationofMFSolid(solidFaces);
        computeIBFaceDsf(solidFaces,_options.method,_options.relaxDistribution);
                  
        CDisc.COMETSolve(-1,_level); //reverse
        if((num==1)||(num==0&&_level==0))
          {
            MakeParallel();
            //callCOMETBoundaryConditions();
            ComputeCOMETMacroparameters();
            ComputeCollisionfrequency();
            //update equilibrium distribution function 0-maxwellian, 1-BGK,2-ESBGK
            if (_options.fgamma==0){initializeMaxwellianEq();}
            else{ EquilibriumDistributionBGK();}
            if (_options.fgamma==2){EquilibriumDistributionESBGK();}
            computeSolidFaceDsf(solidFaces,_options.method,_options.relaxDistribution);
            ConservationofMFSolid(solidFaces);
            computeIBFaceDsf(solidFaces,_options.method,_options.relaxDistribution);
          }
      }
  }

template<class T >

void COMETModel< T >::smooth ( const int  num )

inline

Definition at line 4981 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, COMETModel< T >::_dsfPtrFAS, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_faceReflectionArrayMap, COMETModel< T >::_geomFields, COMETModel< T >::_level, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, COMETModel< T >::_ZCells, COMETModel< T >::callCOMETBoundaryConditions(), COMETESBGKDiscretizer< T >::COMETSolve(), COMETESBGKDiscretizer< T >::COMETSolveFine(), COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::ComputeCOMETMacroparameters(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::MakeParallel(), and COMETESBGKDiscretizer< T >::setfgFinder().

  {
    const int numDir=_quadrature.getDirCount();
    const int numMeshes=_meshes.size();
    for(int msh=0;msh<numMeshes;msh++)
      {
        const Mesh& mesh=*_meshes[msh];
        const BCcellArray& BCArray=*(_BCells[msh]);
        const BCfaceArray& BCfArray=*(_BFaces[msh]);
        const BCcellArray& ZCArray=*(_ZCells[msh]);
        shared_ptr<StorageSite> solidFaces(new StorageSite(-1));
        COMETESBGKDiscretizer<T> CDisc(mesh,_geomFields,*solidFaces,_macroFields,_quadrature,
                                       _dsfPtr,_dsfPtr1,_dsfPtr2,_dsfEqPtrES,_dsfPtrRes,_dsfPtrFAS,
                                       _options["timeStep"],_options.timeDiscretizationOrder,
                                       _options.transient,_options.underRelaxation,_options["rho_init"], 
                                       _options["T_init"],_options["molecularWeight"],_options.conOrder,
                                       _bcMap,_faceReflectionArrayMap,BCArray,BCfArray,ZCArray);

        CDisc.setfgFinder();

        if(_level==0)callCOMETBoundaryConditions();
        MakeParallel();

        if(_level==0)
          CDisc.COMETSolveFine(1,_level); //forward
        else
          CDisc.COMETSolve(1,_level); //forward
        //callCOMETBoundaryConditions();
        ComputeCOMETMacroparameters();
        ComputeCollisionfrequency();
        //update equilibrium distribution function 0-maxwellian, 1-BGK,2-ESBGK
        if (_options.fgamma==0){initializeMaxwellianEq();}
        else{ EquilibriumDistributionBGK();}
        if (_options.fgamma==2){EquilibriumDistributionESBGK();} 
      
        if(_level==0)callCOMETBoundaryConditions();
        MakeParallel();
          

        if(_level==0)
          CDisc.COMETSolveFine(-1,_level); //reverse
        else
          CDisc.COMETSolve(-1,_level); //forward
        if((num==1)||(num==0&&_level==0))
          {
            //callCOMETBoundaryConditions();
            ComputeCOMETMacroparameters();
            ComputeCollisionfrequency();
            //update equilibrium distribution function 0-maxwellian, 1-BGK,2-ESBGK
            if (_options.fgamma==0){initializeMaxwellianEq();}
            else{ EquilibriumDistributionBGK();}
            if (_options.fgamma==2){EquilibriumDistributionESBGK();}
          }

      }
  }

template<class T >

void COMETModel< T >::swapGhostInfo ( )

inline

Definition at line 2959 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, Model::_meshes, COMETModel< T >::_MeshKspaceMap, Mesh::getCells(), and Kspace< T >::syncLocal().

Referenced by COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

  {
    const int numMeshes=_meshes.size();
    for(int msh=0;msh<numMeshes;msh++)
      {
        const Mesh& mesh=*_meshes[msh];
        const StorageSite& cells=mesh.getCells();
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[msh]];
        kspace.syncLocal(cells);
      }
  }

template<class T >

void COMETModel< T >::syncGhostCoarsening ( const MeshList &  inMeshes, GeomFields &  inGeomFields, MeshList &  outMeshes, ScatGathMaps &  coarseScatMaps, ScatGathMaps &  coarseGathMaps, IntArray &  coarseSizes, IntArray &  CoarseGhost  )

inline

Definition at line 1433 of file phononbase/COMETModel.h.

References GeomFields::fineToCoarse, Mesh::getCells(), StorageSite::getCountLevel1(), UnorderedSet::getData(), StorageSite::getGatherMap(), Array< T >::getLength(), StorageSite::getScatterMap(), UnorderedSet::insert(), and UnorderedSet::size().

  {

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

        const StorageSite& inCells=mesh.getCells();
        const StorageSite& site=mesh.getCells();
        //const int inCellCount=inCells.getSelfCount();
        //const int inCellTotal=inCells.getCount();
      
        Field& FineToCoarseField=inGeomFields.fineToCoarse;
        IntArray& coarseIndex=dynamic_cast<IntArray&>(FineToCoarseField[inCells]);
        IntArray tempIndex(inCells.getCountLevel1());
        for(int c=0;c<inCells.getCountLevel1();c++)
          tempIndex[c]=coarseIndex[c];

        //int coarseGhostSize=0;
        //int tempGhostSize=0;
        //int coarseSize= CoarseGhost[n];

        const StorageSite::GatherMap&  gatherMap  = site.getGatherMap();

        // collect all the toIndices arrays for each storage site from
        // gatherMap
      
        typedef map<const StorageSite*, vector<const Array<int>* > > IndicesMap;
        IndicesMap toIndicesMap;
        //IndicesMap tempIndicesMap;

        foreach(const StorageSite::GatherMap::value_type pos, gatherMap)
          {
            const StorageSite& oSite = *pos.first;
            //const Array<int>& tempIndices = *pos.second;
            const Array<int>& toIndices = *pos.second;

            //tempIndicesMap[&oSite].push_back(&tempIndices);
            toIndicesMap[&oSite].push_back(&toIndices);
          }
        
        /*
        foreach(IndicesMap::value_type pos, tempIndicesMap)
          {
            const StorageSite& oSite = *pos.first;
            const vector<const Array<int>* > tempIndicesArrays = pos.second;

            map<int,int> otherToMyMapping;
            UnorderedSet  gatherSet;

            foreach(const Array<int>* tempIndicesPtr, tempIndicesArrays)
              {
                const Array<int>& tempIndices = *tempIndicesPtr;
                const int nGhostRows = tempIndices.getLength();
                for(int ng=0; ng<nGhostRows; ng++)
                  {
                    const int fineIndex = tempIndices[ng];
                    const int coarseOtherIndex = tempIndex[fineIndex];

                    if (coarseOtherIndex < 0)
                      continue;

                    if (otherToMyMapping.find(coarseOtherIndex) !=
                        otherToMyMapping.end())
                      {
                      
                        tempIndex[fineIndex] = otherToMyMapping[coarseOtherIndex];
                      }
                    else
                      {
                        tempIndex[fineIndex] = tempGhostSize+coarseSize;
                        otherToMyMapping[coarseOtherIndex] = tempIndex[fineIndex];
                        gatherSet.insert( tempIndex[fineIndex] );
                        tempGhostSize++;
                      }
                  }
              }
          }*/
      
        foreach(IndicesMap::value_type pos, toIndicesMap)
          {
            const StorageSite& oSite = *pos.first;
            const vector<const Array<int>* > toIndicesArrays = pos.second;

          
            map<int,int> otherToMyMapping;
            UnorderedSet  gatherSet;

            foreach(const Array<int>* toIndicesPtr, toIndicesArrays)
              {
                const Array<int>& toIndices = *toIndicesPtr;
                const int nGhostRows = toIndices.getLength();
                for(int ng=0; ng<nGhostRows; ng++)
                  {
                    const int fineIndex = toIndices[ng];
                    const int coarseOtherIndex = coarseIndex[fineIndex];
                  
                    if (coarseOtherIndex < 0)
                      continue;
                  
                    if (otherToMyMapping.find(coarseOtherIndex) !=
                        otherToMyMapping.end())
                      {
                        coarseIndex[fineIndex] = otherToMyMapping[coarseOtherIndex];
                      }
                    else
                      {
                        coarseIndex[fineIndex] = CoarseGhost[n];
                        otherToMyMapping[coarseOtherIndex] = coarseIndex[fineIndex];
                        gatherSet.insert( coarseIndex[fineIndex] );
                        CoarseGhost[n]++;
                      }
                  
                  }

              }

            const int coarseMappersSize = otherToMyMapping.size();

            shared_ptr<Array<int> > coarseToIndices(new Array<int>(coarseMappersSize));

            for(int n = 0; n < gatherSet.size(); n++)
              (*coarseToIndices)[n]   = gatherSet.getData().at(n);
            
            SSPair sskey(&site,&oSite);
            coarseGathMaps [sskey] = coarseToIndices;

          }
        
        const StorageSite::ScatterMap& scatterMap = site.getScatterMap();
      
        IndicesMap fromIndicesMap;

        foreach(const StorageSite::GatherMap::value_type pos, scatterMap)
          {
            const StorageSite& oSite = *pos.first;
            const Array<int>& fromIndices = *pos.second;

            fromIndicesMap[&oSite].push_back(&fromIndices);
          }
      
        foreach(IndicesMap::value_type pos, fromIndicesMap)
          {
            const StorageSite& oSite = *pos.first;
            const vector<const Array<int>* > fromIndicesArrays = pos.second;

            UnorderedSet  scatterSet;

            foreach(const Array<int>* fromIndicesPtr, fromIndicesArrays)
              {
                const Array<int>& fromIndices = *fromIndicesPtr;
                const int nGhostRows = fromIndices.getLength();
                for(int ng=0; ng<nGhostRows; ng++)
                  {
                    const int fineIndex = fromIndices[ng];
                    const int coarseOtherIndex = coarseIndex[fineIndex];
                    if (coarseOtherIndex >= 0)
                      scatterSet.insert( coarseOtherIndex );
                  }

              }

            const int coarseMappersSize = scatterSet.size();
          
            shared_ptr<Array<int> > coarseFromIndices(new Array<int>(coarseMappersSize));
          
            for(int n = 0; n < scatterSet.size(); n++ ) 
              (*coarseFromIndices)[n] = scatterSet.getData().at(n);
          
            SSPair sskey(&site,&oSite);
            coarseScatMaps[sskey] = coarseFromIndices;
            
          }
        
      }
  }

template<class T >

void COMETModel< T >::syncGhostCoarsening ( const MeshList &  inMeshes, GeomFields &  inGeomFields, MeshList &  outMeshes  )

inline

Definition at line 3214 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_coarseGatherMaps, COMETModel< T >::_coarseGhostSizes, COMETModel< T >::_coarseScatterMaps, COMETModel< T >::_coarseSizes, GeomFields::fineToCoarse, Mesh::getBoundaryFaceGroups(), Mesh::getCells(), StorageSite::getCount(), StorageSite::getCountLevel1(), UnorderedSet::getData(), Mesh::getDimension(), Mesh::getFaceCells(), StorageSite::getGatherMap(), StorageSite::getGatherMapLevel1(), Array< T >::getLength(), StorageSite::getScatterMap(), StorageSite::getScatterMapLevel1(), StorageSite::getSelfCount(), StorageSite::getTag(), UnorderedSet::insert(), FaceGroup::site, and UnorderedSet::size().

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

  {
  //const int xLen = coarseIndexField.getLength();

  //#pragma omp parallel for
    const int numMeshes=inMeshes.size();
    for(int n=0;n<numMeshes;n++)
    {
      const Mesh& mesh=*inMeshes[n];
      const int dim=mesh.getDimension();
      Mesh& newMeshPtr=*outMeshes[n];

      const StorageSite& inCells=mesh.getCells();
      const StorageSite& site=mesh.getCells();
      //const StorageSite& site=newMeshPtr.getCells();
      const int inCellCount=inCells.getSelfCount();
      const int inCellTotal=inCells.getCount();
      
      Field& FineToCoarseField=inGeomFields.fineToCoarse;
      IntArray& coarseIndex=dynamic_cast<IntArray&>(FineToCoarseField[inCells]);
      IntArray tempIndex(inCells.getCountLevel1());
      for(int c=0;c<inCells.getCountLevel1();c++)
        tempIndex[c]=coarseIndex[c];

      int coarseGhostSize=0;
      int tempGhostSize=0;
      //const int coarseSize = _coarseSizes.find(rowIndex)->second;
      //const int coarseSize = _coarseSizes[&mesh];
      int coarseSize = -1;
      coarseSize = _coarseSizes[&mesh];

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

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

          for(int f=0; f< nFaces; f++)
          {
              const int c1= faceCells(f,1);// boundary cell
              //if(MPI::COMM_WORLD.Get_rank()==1)
              //cout<<"fgid, boundarycell, boundary coarse index = "<<fg.id<<" "<<c1<<" "<<coarseIndex[c1]<<endl;
              if(boundaryCell<coarseIndex[c1])
                boundaryCell=coarseIndex[c1];
          }
      }
      boundaryCell++;
      if(boundaryCell!=1)
        coarseSize = boundaryCell;
  
      //const StorageSite& site = *rowIndex.second;

      const StorageSite::GatherMap&  gatherMap  = site.getGatherMap();
      const StorageSite::GatherMap&  gatherMapLevel1  = site.getGatherMapLevel1();

      // collect all the toIndices arrays for each storage site from
      // both gatherMap and gatherMapLevel1
      
      typedef map<const StorageSite*, vector<const Array<int>* > > IndicesMap;
      IndicesMap toIndicesMap;
      IndicesMap tempIndicesMap;

      foreach(const StorageSite::GatherMap::value_type pos, gatherMap)
        {
          const StorageSite& oSite = *pos.first;
          const Array<int>& tempIndices = *pos.second;
          const Array<int>& toIndices = *pos.second;

          tempIndicesMap[&oSite].push_back(&tempIndices);
          toIndicesMap[&oSite].push_back(&toIndices);
        }
      
      foreach(const StorageSite::GatherMap::value_type pos, gatherMapLevel1)
        {
          const StorageSite& oSite = *pos.first;
          const Array<int>& toIndices = *pos.second;

          int found=0;
          foreach(const StorageSite::GatherMap::value_type posLevel0, gatherMap)
          {
              const StorageSite& oSiteLevel0 = *posLevel0.first;
              if(oSite.getTag()==oSiteLevel0.getTag())
              {
                  toIndicesMap[&oSiteLevel0].push_back(&toIndices);
                  found=1;
              }
          }
          
          if(found==0)
            toIndicesMap[&oSite].push_back(&toIndices);
        }

      foreach(IndicesMap::value_type pos, tempIndicesMap)
      {
          const StorageSite& oSite = *pos.first;
          const vector<const Array<int>* > tempIndicesArrays = pos.second;


          map<int,int> otherToMyMapping;
          UnorderedSet  gatherSet;

          foreach(const Array<int>* tempIndicesPtr, tempIndicesArrays)
          {
              const Array<int>& tempIndices = *tempIndicesPtr;
              const int nGhostRows = tempIndices.getLength();
              for(int ng=0; ng<nGhostRows; ng++)
              {
                  const int fineIndex = tempIndices[ng];
                  const int coarseOtherIndex = tempIndex[fineIndex];

                  if (coarseOtherIndex < 0)
                    continue;


                  if (otherToMyMapping.find(coarseOtherIndex) !=
                      otherToMyMapping.end())
                  {
                      
                      tempIndex[fineIndex] = otherToMyMapping[coarseOtherIndex];
                  }
                  else
                  {
                      tempIndex[fineIndex] = tempGhostSize+coarseSize;
                      otherToMyMapping[coarseOtherIndex] = tempIndex[fineIndex];
                      gatherSet.insert( tempIndex[fineIndex] );
                      tempGhostSize++;
                  }
              }
          }
      }
      
      foreach(IndicesMap::value_type pos, toIndicesMap)
        {
          const StorageSite& oSite = *pos.first;
          const vector<const Array<int>* > toIndicesArrays = pos.second;

          
          map<int,int> otherToMyMapping;
          UnorderedSet  gatherSet;

          foreach(const Array<int>* toIndicesPtr, toIndicesArrays)
            {
              const Array<int>& toIndices = *toIndicesPtr;
              const int nGhostRows = toIndices.getLength();
              for(int ng=0; ng<nGhostRows; ng++)
                {
                  const int fineIndex = toIndices[ng];
                  const int coarseOtherIndex = coarseIndex[fineIndex];
                  
                  if (coarseOtherIndex < 0)
                    continue;
                  
                  if (otherToMyMapping.find(coarseOtherIndex) !=
                      otherToMyMapping.end())
                    {
                      coarseIndex[fineIndex] = otherToMyMapping[coarseOtherIndex];
                    }
                  else
                    {
                      coarseIndex[fineIndex] = coarseGhostSize+coarseSize;
                      otherToMyMapping[coarseOtherIndex] = coarseIndex[fineIndex];
                      gatherSet.insert( coarseIndex[fineIndex] );
                      coarseGhostSize++;
                    }
                  //if(MPI::COMM_WORLD.Get_rank()==1)
                  //cout<<"level,fineIndex, coarseIndex = "<<_level<<" "<<fineIndex<<" "<<coarseIndex[fineIndex]<<endl;
                }
              //if(MPI::COMM_WORLD.Get_rank()==1)
              //cout<<endl<<endl;
            }

          const int coarseMappersSize = otherToMyMapping.size();

          shared_ptr<Array<int> > coarseToIndices(new Array<int>(coarseMappersSize));

          for(int n = 0; n < gatherSet.size(); n++)
            {
              (*coarseToIndices)[n]   = gatherSet.getData().at(n);
            }

          SSPair sskey(&site,&oSite);
          _coarseGatherMaps [sskey] = coarseToIndices;
        }

      const StorageSite::ScatterMap& scatterMap = site.getScatterMap();
      const StorageSite::ScatterMap& scatterMapLevel1 = site.getScatterMapLevel1();
      
      IndicesMap fromIndicesMap;

      foreach(const StorageSite::GatherMap::value_type pos, scatterMap)
        {
          const StorageSite& oSite = *pos.first;
          const Array<int>& fromIndices = *pos.second;

          fromIndicesMap[&oSite].push_back(&fromIndices);
        }
      
      foreach(const StorageSite::GatherMap::value_type pos, scatterMapLevel1)
        {
          const StorageSite& oSite = *pos.first;
          const Array<int>& fromIndices = *pos.second;

          int found=0;
          foreach(const StorageSite::ScatterMap::value_type posLevel0, scatterMap)
            {
              const StorageSite& oSiteLevel0 = *posLevel0.first;
              if(oSite.getTag()==oSiteLevel0.getTag())
                {
                  fromIndicesMap[&oSiteLevel0].push_back(&fromIndices);
                  found=1;
                }
            }
          
          if(found==0)
            fromIndicesMap[&oSite].push_back(&fromIndices);
        }
      
      foreach(IndicesMap::value_type pos, fromIndicesMap)
        {
          const StorageSite& oSite = *pos.first;
          const vector<const Array<int>* > fromIndicesArrays = pos.second;

          UnorderedSet  scatterSet;

          foreach(const Array<int>* fromIndicesPtr, fromIndicesArrays)
            {
              const Array<int>& fromIndices = *fromIndicesPtr;
              const int nGhostRows = fromIndices.getLength();
              for(int ng=0; ng<nGhostRows; ng++)
                {
                  const int fineIndex = fromIndices[ng];
                  const int coarseOtherIndex = coarseIndex[fineIndex];
                  if (coarseOtherIndex >= 0)
                    scatterSet.insert( coarseOtherIndex );
                }

            }

          const int coarseMappersSize = scatterSet.size();
          
          shared_ptr<Array<int> > coarseFromIndices(new Array<int>(coarseMappersSize));
          
          for(int n = 0; n < scatterSet.size(); n++ ) {
            (*coarseFromIndices)[n] = scatterSet.getData().at(n);
          }
          
          SSPair sskey(&site,&oSite);
          _coarseScatterMaps[sskey] = coarseFromIndices;
          
        }
      //_coarseGhostSizes[rowIndex]=coarseGhostSize;
      _coarseGhostSizes[&mesh]=coarseGhostSize;
    }
  }

template<class T >

T COMETModel< T >::updateResid ( const bool  addFAS )

inline

Definition at line 2898 of file phononbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_geomFields, COMETModel< T >::_IClist, COMETModel< T >::_kspaces, COMETModel< T >::_level, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, COMETModel< T >::_options, COMETDiscretizer< T >::findResidCoarse(), COMETDiscretizer< T >::findResidFine(), COMETDiscretizer< T >::findResidFull(), COMETDiscretizer< T >::getAveResid(), COMETDiscretizer< T >::setfgFinder(), COMETModel< T >::swapGhostInfo(), and COMETInterface< T >::updateResid().

  {
    const int numMeshes=_meshes.size();

    COMETInterface<T> ComInt(_meshes,_kspaces,_MeshKspaceMap,_macro,_geomFields);

    const int listSize=_IClist.size();
    for(int ic=0;ic<listSize;ic++)
      {
        COMETIC<T>* icPtr=_IClist[ic];
        //if(icPtr->InterfaceModel=="DMM" && _level==0)
        // ComInt.makeDMMcoeffs(*icPtr);
        ComInt.updateResid(*icPtr,addFAS);
      }

    T highResid=-1.;
    T currentResid;

#ifdef FVM_PARALLEL
    swapGhostInfo();
#endif

    for(int msh=0;msh<numMeshes;msh++)
      {
        const Mesh& mesh=*_meshes[msh];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[msh]];
        const BCcellArray& BCArray=*(_BCells[msh]);
        const BCfaceArray& BCfArray=*(_BFaces[msh]);
        FgTKClistMap FgToKsc;
        COMETDiscretizer<T> CDisc(mesh,_geomFields,_macro,
                                  kspace,_bcMap,BCArray,BCfArray,_options,
                                  FgToKsc);
        
        CDisc.setfgFinder();
        if(_options.Scattering=="Full")
          {
            if(_level==0)
              CDisc.findResidFull();
            else
              CDisc.findResidCoarse(addFAS);
          }
        else
          {
            if(_level>0 || _options.Convection=="FirstOrder")
              CDisc.findResidCoarse(addFAS);
            else
              CDisc.findResidFine();
          }

        currentResid=CDisc.getAveResid();

        if(highResid<0)
          highResid=currentResid;
        else
          if(currentResid>highResid)
            highResid=currentResid;
      }

    return highResid;
  }

template<class T >

T COMETModel< T >::updateResid ( const bool  addFAS )

inline

Definition at line 5038 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, COMETModel< T >::_dsfPtrFAS, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_faceReflectionArrayMap, COMETModel< T >::_geomFields, COMETModel< T >::_level, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, COMETModel< T >::_ZCells, COMETModel< T >::callCOMETBoundaryConditions(), COMETESBGKDiscretizer< T >::findResid(), COMETESBGKDiscretizer< T >::findResidFine(), COMETESBGKDiscretizer< T >::getAveResid(), COMETModel< T >::MakeParallel(), and COMETESBGKDiscretizer< T >::setfgFinder().

Referenced by COMETModel< T >::advance(), COMETModel< T >::cycle(), COMETModel< T >::init(), COMETModel< T >::initFromOld(), and COMETModel< T >::makeFAS().

  {
    const int numMeshes=_meshes.size();
    T lowResid=-1.;
    T currentResid;
    for(int msh=0;msh<numMeshes;msh++)
      {
        const Mesh& mesh=*_meshes[msh];
        const BCcellArray& BCArray=*(_BCells[msh]);
        const BCfaceArray& BCfArray=*(_BFaces[msh]);
        const BCcellArray& ZCArray=*(_ZCells[msh]);
        shared_ptr<StorageSite> solidFaces(new StorageSite(-1));
        COMETESBGKDiscretizer<T> CDisc(mesh,_geomFields,*solidFaces,_macroFields,_quadrature,
                                       _dsfPtr,_dsfPtr1,_dsfPtr2,_dsfEqPtrES,_dsfPtrRes,_dsfPtrFAS,
                                       _options["timeStep"],_options.timeDiscretizationOrder,
                                       _options.transient,_options.underRelaxation,_options["rho_init"], 
                                       _options["T_init"],_options["molecularWeight"], _options.conOrder,
                                       _bcMap,_faceReflectionArrayMap,BCArray,BCfArray,ZCArray);

        CDisc.setfgFinder();
        const int numDir=_quadrature.getDirCount();

        if(_level==0)callCOMETBoundaryConditions();
        MakeParallel();

        if(_level==0)
          CDisc.findResidFine(addFAS);
        else
          CDisc.findResid(addFAS);
        currentResid=CDisc.getAveResid();

        if(lowResid<0)
          lowResid=currentResid;
        else
          if(currentResid<lowResid)
            lowResid=currentResid;
      }
    return lowResid;
  }

template<class T >

T COMETModel< T >::updateResid ( const bool  addFAS, const StorageSite &  solidFaces  )

inline

Definition at line 5078 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_BCells, COMETModel< T >::_bcMap, COMETModel< T >::_BFaces, COMETModel< T >::_dsfEqPtrES, COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, COMETModel< T >::_dsfPtrFAS, COMETModel< T >::_dsfPtrRes, COMETModel< T >::_faceReflectionArrayMap, COMETModel< T >::_geomFields, COMETModel< T >::_macroFields, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, COMETModel< T >::_ZCells, COMETESBGKDiscretizer< T >::findResid(), COMETESBGKDiscretizer< T >::getAveResid(), COMETModel< T >::MakeParallel(), and COMETESBGKDiscretizer< T >::setfgFinder().

  {
    const int numMeshes=_meshes.size();
    T lowResid=-1.;
    T currentResid;
    for(int msh=0;msh<numMeshes;msh++)
      {
        const Mesh& mesh=*_meshes[msh];
        const BCcellArray& BCArray=*(_BCells[msh]);
        const BCfaceArray& BCfArray=*(_BFaces[msh]);
        const BCcellArray& ZCArray=*(_ZCells[msh]);
        COMETESBGKDiscretizer<T> CDisc(mesh,_geomFields,solidFaces,_macroFields,_quadrature,
                                       _dsfPtr,_dsfPtr1,_dsfPtr2,_dsfEqPtrES,_dsfPtrRes,_dsfPtrFAS,
                                       _options["timeStep"],_options.timeDiscretizationOrder,
                                       _options.transient,_options.underRelaxation,_options["rho_init"],
                                       _options["T_init"],_options["molecularWeight"],_options.conOrder,
                                       _bcMap,_faceReflectionArrayMap,BCArray,BCfArray,ZCArray);

        CDisc.setfgFinder();
        const int numDir=_quadrature.getDirCount();
        
        MakeParallel();

        CDisc.findResid(addFAS);
        currentResid=CDisc.getAveResid();

        if(lowResid<0)
          lowResid=currentResid;
        else
          if(currentResid<lowResid)
            lowResid=currentResid;
      }
    return lowResid;
  }

template<class T >

void COMETModel< T >::updateTime ( )

inline

Definition at line 2384 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, 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();
        const int numFields= _quadrature.getDirCount(); 
        //callBoundaryConditions();  //new
        for (int direction = 0; direction < numFields; direction++)
          {
            Field& fnd = *_dsfPtr.dsf[direction];
            Field& fndN1 = *_dsfPtr1.dsf[direction];
            TArray& f = dynamic_cast<TArray&>(fnd[cells]);
            TArray& fN1 = dynamic_cast<TArray&>(fndN1[cells]);
            if (_options.timeDiscretizationOrder > 1)
              {
                Field& fndN2 = *_dsfPtr2.dsf[direction];
                TArray& fN2 = dynamic_cast<TArray&>(fndN2[cells]);
                fN2 = fN1; 
              }
            fN1 = f;
          }
#ifdef FVM_PARALLEL
        if ( MPI::COMM_WORLD.Get_rank() == 0 )
          {cout << "updated time" <<endl;}
        
#endif
#ifndef FVM_PARALLEL 
        cout << "updated time" <<endl;
#endif
        //ComputeMacroparameters();     //update macroparameters
        //ComputeCollisionfrequency();
        //if (_options.fgamma==0){initializeMaxwellianEq();}
        //else{ EquilibriumDistributionBGK();}  
        //if (_options.fgamma==2){EquilibriumDistributionESBGK();}
        
      }
  }

template<class T >

void COMETModel< T >::updateTL ( )

inline

Definition at line 3252 of file phononbase/COMETModel.h.

References COMETModel< T >::_kspaces, COMETModel< T >::_macro, Model::_meshes, COMETModel< T >::_MeshKspaceMap, Kspace< T >::calcTauTot(), PhononMacro::e0, Mesh::getCells(), StorageSite::getCount(), Kspace< T >::NewtonSolve(), and PhononMacro::temperature.

  {
    const int numMeshes=_meshes.size();
    for(int n=0;n<numMeshes;n++)
      {
        const Mesh& mesh=*_meshes[n];
        Tkspace& kspace=*_kspaces[_MeshKspaceMap[n]];   
        const StorageSite& cells = mesh.getCells();
        const int numcells = cells.getCount();
        const T tauTot=kspace.calcTauTot();
        TArray& TL=dynamic_cast<TArray&>(_macro.temperature[cells]);
        TArray& e0Array=dynamic_cast<TArray&>(_macro.e0[cells]);
        
        for(int c=0;c<numcells;c++)
          kspace.NewtonSolve(TL[c],e0Array[c]*tauTot);
      }
  }

template<class T >

void COMETModel< T >::weightedMaxwellian ( double  weight1, double  uvel1, double  vvel1, double  wvel1, double  uvel2, double  vvel2, double  wvel2, double  temp1, double  temp2  )

inline

Definition at line 2174 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, Mesh::getCells(), and StorageSite::getCount().

  {
    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.getCount();
        //double pi(acos(-1.0));
        const double pi=_options.pi;
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const int numFields= _quadrature.getDirCount(); 
        
        for(int j=0;j< numFields;j++){
          Field& fnd = *_dsfPtr.dsf[j];
          TArray& f = dynamic_cast< TArray&>(fnd[cells]);
          for(int c=0; c<nCells;c++){
            f[c]=weight1*1.0/pow((pi*1.0),1.5)*exp(-(pow((cx[j]-uvel1),2.0)+pow((cy[j]-vvel1),2.0)+pow((cz[j]-wvel1),2.0))/temp1)
              +(1-weight1)*1.0/pow((pi*1.0),1.5)*exp(-(pow((cx[j]-uvel2),2.0)+pow((cy[j]-vvel2),2.0)+pow((cz[j]-wvel2),2.0))/temp2);
          }
          if (_options.transient)
            {
              Field& fnd1 = *_dsfPtr1.dsf[j];
              TArray& f1 = dynamic_cast< TArray&>(fnd1[cells]);
              for (int c=0;c<nCells;c++)
                f1[c] = f[c];
              //cout << "discretization order " << _options.timeDiscretizationOrder << endl ;
              if (_options.timeDiscretizationOrder > 1)
                {
                  Field& fnd2 = *_dsfPtr2.dsf[j];
                  TArray& f2 = dynamic_cast< TArray&>(fnd2[cells]);
                  for (int c=0;c<nCells;c++)
                    f2[c] = f[c];
                }
            }
        }
      }
  }

template<class T >

void COMETModel< T >::weightedMaxwellian ( double  weight1, double  uvel1, double  uvel2, double  temp1, double  temp2  )

inline

Definition at line 2214 of file esbgkbase/COMETModel.h.

References COMETModel< T >::_dsfPtr, COMETModel< T >::_dsfPtr1, COMETModel< T >::_dsfPtr2, Model::_meshes, COMETModel< T >::_options, COMETModel< T >::_quadrature, Mesh::getCells(), and StorageSite::getCount().

  {
    const double vvel1=0.0;
    const double wvel1=0.0;
    const double vvel2=0.0;
    const double wvel2=0.0;
    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.getCount();
        //double pi(acos(-1.0));
        const double pi=_options.pi;
        const TArray& cx = dynamic_cast<const TArray&>(*_quadrature.cxPtr);
        const TArray& cy = dynamic_cast<const TArray&>(*_quadrature.cyPtr);
        const TArray& cz = dynamic_cast<const TArray&>(*_quadrature.czPtr);
        const int numFields= _quadrature.getDirCount(); 
        
        for(int j=0;j< numFields;j++){
          Field& fnd = *_dsfPtr.dsf[j];
          TArray& f = dynamic_cast< TArray&>(fnd[cells]);
          for(int c=0; c<nCells;c++){
            f[c]=weight1*1.0/pow((pi*1.0),1.5)*exp(-(pow((cx[j]-uvel1),2.0)+pow((cy[j]-vvel1),2.0)+pow((cz[j]-wvel1),2.0))/temp1)
              +(1-weight1)*1.0/pow((pi*1.0),1.5)*exp(-(pow((cx[j]-uvel2),2.0)+pow((cy[j]-vvel2),2.0)+pow((cz[j]-wvel2),2.0))/temp2);
          }
          if (_options.transient)
            {
              Field& fnd1 = *_dsfPtr1.dsf[j];
              TArray& f1 = dynamic_cast< TArray&>(fnd1[cells]);
              for (int c=0;c<nCells;c++)
                f1[c] = f[c];
              //cout << "discretization order " << _options.timeDiscretizationOrder << endl ;
              if (_options.timeDiscretizationOrder > 1)
                {
                  Field& fnd2 = *_dsfPtr2.dsf[j];
                  TArray& f2 = dynamic_cast< TArray&>(fnd2[cells]);
                  for (int c=0;c<nCells;c++)
                    f2[c] = f[c];
                }
            }
        }
      }
  }

Member Data Documentation

template<class T >

BCcellList COMETModel< T >::_BCells

private

Definition at line 5683 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::COMETModel(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

COMETBCMap COMETModel< T >::_bcMap

private

Definition at line 5674 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::applyTemperatureBoundaries(), COMETModel< T >::calcDomainStats(), COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::COMETModel(), COMETModel< T >::correctSingleNeighbor(), COMETModel< T >::FinishCoarseMesh(), COMETModel< T >::getBCMap(), COMETModel< T >::getBCs(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::initializeTemperatureBoundaries(), COMETModel< T >::MakeInteriorCoarseMesh(), COMETModel< T >::setBCMap(), COMETModel< T >::SetBoundaryConditions(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

BCfaceList COMETModel< T >::_BFaces

private

Definition at line 5684 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::coarsenInterfaceCells(), COMETModel< T >::coarsenInterior(), COMETModel< T >::COMETModel(), COMETModel< T >::correctSolution(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

MatrixMappersMap COMETModel< T >::_coarseGatherMaps

private

Definition at line 5697 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::MakeCoarseModel(), COMETModel< T >::MakeIBCoarseModel(), and COMETModel< T >::syncGhostCoarsening().

template<class T >

GeomFields COMETModel< T >::_coarseGeomFields

private

Definition at line 5653 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

template<class T >

SizeMap COMETModel< T >::_coarseGhostSizes

private

Definition at line 5693 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::MakeCoarseMesh2(), and COMETModel< T >::syncGhostCoarsening().

template<class T >

TCOMET * COMETModel< T >::_coarserLevel

private

Definition at line 5662 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::correctSolution(), COMETModel< T >::cycle(), COMETModel< T >::getModelPointer(), COMETModel< T >::injectResid(), COMETModel< T >::MakeCoarseIndex(), COMETModel< T >::makeFinestToCoarseConn(), COMETModel< T >::MakeIBCoarseModel(), COMETModel< T >::setCoarserLevel(), and COMETModel< T >::setFinestLevel().

template<class T >

MatrixMappersMap COMETModel< T >::_coarseScatterMaps

private

Definition at line 5696 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::MakeCoarseModel(), COMETModel< T >::MakeIBCoarseModel(), and COMETModel< T >::syncGhostCoarsening().

template<class T >

SizeMap COMETModel< T >::_coarseSizes

private

Definition at line 5692 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), and COMETModel< T >::syncGhostCoarsening().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfEqPtr

private

Definition at line 5667 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::ComputeMacroparametersESBGK(), COMETModel< T >::EntropyGeneration(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::getdsfEq(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::OutputDsfBLOCK(), and COMETModel< T >::OutputDsfPOINT().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfEqPtrES

private

Definition at line 5668 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::correctMassDeficit(), COMETModel< T >::correctMassDeficit2(), COMETModel< T >::EntropyGeneration(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::getdsfEqES(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::OutputDsfBLOCK(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfPtr

private

Definition at line 5664 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::ComputeCOMETMacroparameters(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::ComputeMacroparameters(), COMETModel< T >::ComputeMacroparametersESBGK(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSurfaceForce(), COMETModel< T >::ConservationofMassCheck(), COMETModel< T >::ConservationofMFSolid(), COMETModel< T >::correctMassDeficit(), COMETModel< T >::correctMassDeficit2(), COMETModel< T >::correctSolution(), COMETModel< T >::EntropyGeneration(), COMETModel< T >::getdsf(), COMETModel< T >::getPersistenceData(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::injectResid(), COMETModel< T >::MakeCoarseIndex(), COMETModel< T >::MakeIBCoarseModel(), COMETModel< T >::MakeParallel(), COMETModel< T >::MomentHierarchy(), COMETModel< T >::OutputDsfBLOCK(), COMETModel< T >::OutputDsfPOINT(), COMETModel< T >::restart(), COMETModel< T >::smooth(), COMETModel< T >::updateResid(), COMETModel< T >::updateTime(), and COMETModel< T >::weightedMaxwellian().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfPtr0

private

Definition at line 5669 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getdsf0(), COMETModel< T >::initializeCoarseMaxwellian(), and COMETModel< T >::initializeFineMaxwellian().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfPtr1

private

Definition at line 5665 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getdsf1(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::smooth(), COMETModel< T >::updateResid(), COMETModel< T >::updateTime(), and COMETModel< T >::weightedMaxwellian().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfPtr2

private

Definition at line 5666 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getdsf2(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::smooth(), COMETModel< T >::updateResid(), COMETModel< T >::updateTime(), and COMETModel< T >::weightedMaxwellian().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfPtrFAS

private

Definition at line 5672 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getdsfFAS(), COMETModel< T >::initializeCoarseMaxwellian(), COMETModel< T >::makeFAS(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfPtrInj

private

Definition at line 5670 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getdsfInj().

template<class T >

DistFunctFields<T> COMETModel< T >::_dsfPtrRes

private

Definition at line 5671 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getdsfRes(), COMETModel< T >::initializeCoarseMaxwellian(), COMETModel< T >::initializeFineMaxwellian(), COMETModel< T >::injectResid(), COMETModel< T >::makeFAS(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

map<int, vector<int> > COMETModel< T >::_faceReflectionArrayMap

private

Definition at line 5687 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::getFaceReflectionArrayMap(), COMETModel< T >::init(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

TCOMET * COMETModel< T >::_finerLevel

private

Definition at line 5663 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getFinerModel(), and COMETModel< T >::setFinerLevel().

template<class T >

GeomFields& COMETModel< T >::_finestGeomFields

private

Definition at line 5654 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::ConservationofMFSolid(), COMETModel< T >::init(), COMETModel< T >::MakeCoarseIndex(), and COMETModel< T >::MakeIBCoarseModel().

template<class T >

TCOMET * COMETModel< T >::_finestLevel

private

Definition at line 5661 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::setFinestLevel().

template<class T >

MacroFields& COMETModel< T >::_finestMacroFields

private

Definition at line 5660 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::ConservationofMFSolid(), and COMETModel< T >::MakeIBCoarseModel().

template<class T >

const MeshList& COMETModel< T >::_finestMeshes

private

Definition at line 5655 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::init(), COMETModel< T >::MakeCoarseIndex(), and COMETModel< T >::MakeIBCoarseModel().

template<class T >

GeomFields & COMETModel< T >::_geomFields

private

Definition at line 5652 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::applyTemperatureBoundaries(), COMETModel< T >::binwiseHeatFluxIntegral(), COMETModel< T >::calcDomainStats(), COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSolidFacePressure(), COMETModel< T >::computeSurfaceForce(), COMETModel< T >::ConservationofMassCheck(), COMETModel< T >::correctMassDeficit(), COMETModel< T >::correctMassDeficit2(), COMETModel< T >::getAverageTemperature(), COMETModel< T >::getGeomFields(), COMETModel< T >::getWallArea(), COMETModel< T >::getWallAreaVector(), COMETModel< T >::HeatFluxIntegral(), COMETModel< T >::HeatFluxIntegralFace(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::initializeTemperatureBoundaries(), COMETModel< T >::injectResid(), COMETModel< T >::MakeCoarseIndex(), COMETModel< T >::MakeCoarseModel(), COMETModel< T >::MakeIBCoarseModel(), COMETModel< T >::modewiseHeatFluxIntegral(), COMETModel< T >::setStraightLine(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

const int COMETModel< T >::_ibm

private

Definition at line 5657 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::init().

template<class T >

IClist COMETModel< T >::_IClist

private

Definition at line 4276 of file phononbase/COMETModel.h.

Referenced by COMETModel< T >::getIClist(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::MakeInteriorCoarseMesh(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

MFRPtr COMETModel< T >::_initialKmodelNorm

private

Definition at line 5682 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getPersistenceData(), COMETModel< T >::init(), and COMETModel< T >::restart().

template<class T >

T COMETModel< T >::_initialResidual

private

Definition at line 5679 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::advance().

template<class T >

TkspList& COMETModel< T >::_kspaces

private

Definition at line 4265 of file phononbase/COMETModel.h.

Referenced by COMETModel< T >::applyTemperatureBoundaries(), COMETModel< T >::binwiseHeatFluxIntegral(), COMETModel< T >::calcBandFlux(), COMETModel< T >::calcBandRelEnergy(), COMETModel< T >::calcBandTemps(), COMETModel< T >::calcModeFlux(), COMETModel< T >::calcModeTemps(), COMETModel< T >::correctSolution(), COMETModel< T >::equilibrate(), COMETModel< T >::getKspace(), COMETModel< T >::getKspaces(), COMETModel< T >::getValueArray(), COMETModel< T >::HeatFluxIntegral(), COMETModel< T >::HeatFluxIntegralFace(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::initializeTemperatureBoundaries(), COMETModel< T >::injectResid(), COMETModel< T >::MakeCoarseModel(), COMETModel< T >::makeFAS(), COMETModel< T >::makeNonEqTemp(), COMETModel< T >::modewiseHeatFluxIntegral(), COMETModel< T >::sete0(), COMETModel< T >::smooth(), COMETModel< T >::swapGhostInfo(), COMETModel< T >::updateResid(), and COMETModel< T >::updateTL().

template<class T >

const int COMETModel< T >::_level

private

Definition at line 5651 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::applyTemperatureBoundaries(), COMETModel< T >::coarsenInterfaceCells(), COMETModel< T >::COMETModel(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::cycle(), COMETModel< T >::getLevel(), COMETModel< T >::getModelPointer(), COMETModel< T >::init(), COMETModel< T >::MakeCoarseIndex(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

PhononMacro& COMETModel< T >::_macro

private

Definition at line 4266 of file phononbase/COMETModel.h.

Referenced by COMETModel< T >::calcBandFlux(), COMETModel< T >::calcBandRelEnergy(), COMETModel< T >::calcBandTemps(), COMETModel< T >::calcModeFlux(), COMETModel< T >::calcModeTemps(), COMETModel< T >::correctSolution(), COMETModel< T >::equilibrate(), COMETModel< T >::getAverageTemperature(), COMETModel< T >::getLatticeTemp(), COMETModel< T >::getMacro(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::injectResid(), COMETModel< T >::makeCellColors(), COMETModel< T >::MakeCoarseModel(), COMETModel< T >::makeFAS(), COMETModel< T >::makeNonEqTemp(), COMETModel< T >::makePlotColors(), COMETModel< T >::sete0(), COMETModel< T >::setStraightLine(), COMETModel< T >::smooth(), COMETModel< T >::updateResid(), and COMETModel< T >::updateTL().

template<class T >

MacroFields& COMETModel< T >::_macroFields

private

Definition at line 5659 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::ComputeCoarseMacroparameters(), COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::ComputeCOMETMacroparameters(), COMETModel< T >::ComputeFineMacroparameters(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::ComputeMacroparameters(), COMETModel< T >::ComputeMacroparametersESBGK(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSolidFacePressure(), COMETModel< T >::computeSurfaceForce(), COMETModel< T >::correctSolution(), COMETModel< T >::EntropyGeneration(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::getMacro(), COMETModel< T >::init(), COMETModel< T >::InitializeFgammaCoefficients(), COMETModel< T >::initializeFineMaxwellian(), COMETModel< T >::InitializeMacroparameters(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::injectResid(), COMETModel< T >::makeFAS(), COMETModel< T >::MakeIBCoarseModel(), COMETModel< T >::MomentHierarchy(), COMETModel< T >::NewtonsMethodBGK(), COMETModel< T >::NewtonsMethodESBGK(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

template<class T >

MeshKspaceMap COMETModel< T >::_MeshKspaceMap

private

Definition at line 4275 of file phononbase/COMETModel.h.

Referenced by COMETModel< T >::applyTemperatureBoundaries(), COMETModel< T >::binwiseHeatFluxIntegral(), COMETModel< T >::calcBandFlux(), COMETModel< T >::calcBandRelEnergy(), COMETModel< T >::calcBandTemps(), COMETModel< T >::calcModeFlux(), COMETModel< T >::calcModeTemps(), COMETModel< T >::COMETModel(), COMETModel< T >::correctSolution(), COMETModel< T >::equilibrate(), COMETModel< T >::getMKMap(), COMETModel< T >::getValueArray(), COMETModel< T >::HeatFluxIntegral(), COMETModel< T >::HeatFluxIntegralFace(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::initFromOld(), COMETModel< T >::initializeTemperatureBoundaries(), COMETModel< T >::injectResid(), COMETModel< T >::MakeCoarseModel(), COMETModel< T >::makeFAS(), COMETModel< T >::makeNonEqTemp(), COMETModel< T >::modewiseHeatFluxIntegral(), COMETModel< T >::sete0(), COMETModel< T >::smooth(), COMETModel< T >::swapGhostInfo(), COMETModel< T >::updateResid(), and COMETModel< T >::updateTL().

template<class T >

MeshICmap COMETModel< T >::_MeshToIC

private

Definition at line 4277 of file phononbase/COMETModel.h.

Referenced by COMETModel< T >::getMeshICmap(), COMETModel< T >::init(), COMETModel< T >::initFromOld(), and COMETModel< T >::smooth().

template<class T >

int COMETModel< T >::_niters

private

Definition at line 5686 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getPersistenceData(), COMETModel< T >::init(), and COMETModel< T >::restart().

template<class T >

TCModOpts COMETModel< T >::_options

private

Definition at line 4271 of file phononbase/COMETModel.h.

template<class T >

COMETModelOptions<T> COMETModel< T >::_options

private

Definition at line 5677 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::advance(), COMETModel< T >::applyTemperatureBoundaries(), COMETModel< T >::ComputeCollisionfrequency(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::ComputeMacroparametersESBGK(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSurfaceForce(), COMETModel< T >::ConservationofMFSolid(), COMETModel< T >::cycle(), COMETModel< T >::EntropyGeneration(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::getOptions(), COMETModel< T >::init(), COMETModel< T >::initCoarse(), COMETModel< T >::InitializeFgammaCoefficients(), COMETModel< T >::initializeFineMaxwellian(), COMETModel< T >::InitializeMacroparameters(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::initializeTemperatureBoundaries(), COMETModel< T >::MakeCoarseIndex(), COMETModel< T >::MakeCoarseModel(), COMETModel< T >::makeFinestToCoarseConn(), COMETModel< T >::MakeIBCoarseModel(), COMETModel< T >::makePlotColors(), COMETModel< T >::MomentHierarchy(), COMETModel< T >::NewtonsMethodBGK(), COMETModel< T >::NewtonsMethodESBGK(), COMETModel< T >::OutputDsfBLOCK(), COMETModel< T >::OutputDsfPOINT(), COMETModel< T >::smooth(), COMETModel< T >::updateResid(), COMETModel< T >::updateTime(), and COMETModel< T >::weightedMaxwellian().

template<class T >

map<string,shared_ptr<ArrayBase> > COMETModel< T >::_persistenceData

private

Definition at line 5688 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::getPersistenceData(), and COMETModel< T >::restart().

template<class T >

Quadrature<T>& COMETModel< T >::_quadrature

private

Definition at line 5656 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::callCOMETBoundaryConditions(), COMETModel< T >::ComputeCOMETMacroparameters(), COMETModel< T >::computeIBFaceDsf(), COMETModel< T >::ComputeMacroparameters(), COMETModel< T >::ComputeMacroparametersESBGK(), COMETModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSurfaceForce(), COMETModel< T >::ConservationofMassCheck(), COMETModel< T >::ConservationofMFSolid(), COMETModel< T >::correctMassDeficit(), COMETModel< T >::correctMassDeficit2(), COMETModel< T >::correctSolution(), COMETModel< T >::EntropyGeneration(), COMETModel< T >::EquilibriumDistributionBGK(), COMETModel< T >::EquilibriumDistributionESBGK(), COMETModel< T >::getQuadrature(), COMETModel< T >::init(), COMETModel< T >::initializeCoarseMaxwellian(), COMETModel< T >::initializeFineMaxwellian(), COMETModel< T >::initializeMaxwellian(), COMETModel< T >::initializeMaxwellianEq(), COMETModel< T >::injectResid(), COMETModel< T >::MakeCoarseIndex(), COMETModel< T >::makeFAS(), COMETModel< T >::MakeIBCoarseModel(), COMETModel< T >::MakeParallel(), COMETModel< T >::MomentHierarchy(), COMETModel< T >::OutputDsfBLOCK(), COMETModel< T >::OutputDsfPOINT(), COMETModel< T >::setJacobianBGK(), COMETModel< T >::setJacobianESBGK(), COMETModel< T >::smooth(), COMETModel< T >::updateResid(), COMETModel< T >::updateTime(), and COMETModel< T >::weightedMaxwellian().

template<class T >

int COMETModel< T >::_rank

private

Definition at line 4278 of file phononbase/COMETModel.h.

Referenced by COMETModel< T >::COMETModel(), and COMETModel< T >::init().

template<class T >

T COMETModel< T >::_residual

private

Definition at line 5678 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::advance(), COMETModel< T >::getResidual(), COMETModel< T >::init(), and COMETModel< T >::initFromOld().

template<class T >

GhostStorageSiteMap COMETModel< T >::_sharedSiteMap

private

Definition at line 5695 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

template<class T >

SiteMap COMETModel< T >::_siteMap

private

Definition at line 5694 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::MakeCoarseModel(), and COMETModel< T >::MakeIBCoarseModel().

template<class T >

COMETVCMap COMETModel< T >::_vcMap

private

Definition at line 5675 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::COMETModel(), COMETModel< T >::getVCMap(), COMETModel< T >::init(), and COMETModel< T >::SetBoundaryConditions().

template<class T >

BCcellList COMETModel< T >::_ZCells

private

Definition at line 5685 of file esbgkbase/COMETModel.h.

Referenced by COMETModel< T >::COMETModel(), COMETModel< T >::init(), COMETModel< T >::smooth(), and COMETModel< T >::updateResid().

---

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

• esbgkbase/COMETModel.h