Memosa-FVM  0.2
Public Types | Public Member Functions | Private Attributes | List of all members
InjectionDiscretization< X, Diag, OffDiag > Class Template Reference

#include <InjectionDiscretization.h>

Inheritance diagram for InjectionDiscretization< X, Diag, OffDiag >:
Inheritance graph
[legend]
Collaboration diagram for InjectionDiscretization< X, Diag, OffDiag >:
Collaboration graph
[legend]

Public Types

typedef NumTypeTraits< X >
::T_Scalar 		T_Scalar
 
typedef Array< T_Scalar > TArray
 
typedef CRMatrix< Diag,
OffDiag, X > 		CCMatrix
 
typedef CCMatrix::DiagArray DiagArray
 
typedef CCMatrix::OffDiagArray OffDiagArray
 
typedef Array< X > XArray
 
typedef Array< Vector
< T_Scalar, 3 > > 		VectorT3Array
 

Public Member Functions

 InjectionDiscretization (const MeshList &meshes, const GeomFields &geomFields, const Field &varField, const Field &electricField, const Field &conductionbandField, const ElectricModelConstants< T_Scalar > &constants)
 
void discretize (const Mesh &mesh, MultiFieldMatrix &mfmatrix, MultiField &xField, MultiField &rField)
 
- Public Member Functions inherited from Discretization
 Discretization (const MeshList &meshes)
 
virtual ~Discretization ()
 
 DEFINE_TYPENAME ("Discretization")
 

Private Attributes

const GeomFields & _geomFields
 
const Field & _varField
 
const Field & _electricField
 
const Field & _conductionbandField
 
const ElectricModelConstants
< T_Scalar > & 		_constants
 

Additional Inherited Members

- Protected Attributes inherited from Discretization
const MeshList & _meshes
 

Detailed Description

template<class X, class Diag, class OffDiag>
class InjectionDiscretization< X, Diag, OffDiag >

Definition at line 40 of file InjectionDiscretization.h.

Member Typedef Documentation

template<class X , class Diag , class OffDiag >
typedef CRMatrix<Diag,OffDiag,X> InjectionDiscretization< X, Diag, OffDiag >::CCMatrix

Definition at line 46 of file InjectionDiscretization.h.

template<class X , class Diag , class OffDiag >
typedef CCMatrix::DiagArray InjectionDiscretization< X, Diag, OffDiag >::DiagArray

Definition at line 47 of file InjectionDiscretization.h.

template<class X , class Diag , class OffDiag >
typedef CCMatrix::OffDiagArray InjectionDiscretization< X, Diag, OffDiag >::OffDiagArray

Definition at line 48 of file InjectionDiscretization.h.

template<class X , class Diag , class OffDiag >
typedef NumTypeTraits<X>::T_Scalar InjectionDiscretization< X, Diag, OffDiag >::T_Scalar

Definition at line 44 of file InjectionDiscretization.h.

template<class X , class Diag , class OffDiag >
typedef Array<T_Scalar> InjectionDiscretization< X, Diag, OffDiag >::TArray

Definition at line 45 of file InjectionDiscretization.h.

template<class X , class Diag , class OffDiag >
typedef Array<Vector<T_Scalar, 3> > InjectionDiscretization< X, Diag, OffDiag >::VectorT3Array

Definition at line 50 of file InjectionDiscretization.h.

template<class X , class Diag , class OffDiag >
typedef Array<X> InjectionDiscretization< X, Diag, OffDiag >::XArray

Definition at line 49 of file InjectionDiscretization.h.

Constructor & Destructor Documentation

template<class X , class Diag , class OffDiag >
InjectionDiscretization< X, Diag, OffDiag >::InjectionDiscretization ( const MeshList &  meshes,
const GeomFields &  geomFields,
const Field &  varField,
const Field &  electricField,
const Field &  conductionbandField,
const ElectricModelConstants< T_Scalar > &  constants 
)
inline

Definition at line 53 of file InjectionDiscretization.h.

59  :
60  Discretization(meshes),
61  _geomFields(geomFields),
62  _varField(varField),
63  _electricField(electricField),
64  _conductionbandField(conductionbandField),
65  _constants(constants)
66  {}
Discretization::Discretization
Discretization(const MeshList &meshes)
Definition: Discretization.cpp:8
InjectionDiscretization::_constants
const ElectricModelConstants< T_Scalar > & _constants
Definition: InjectionDiscretization.h:328

Member Function Documentation

template<class X , class Diag , class OffDiag >
void InjectionDiscretization< X, Diag, OffDiag >::discretize ( const Mesh &  mesh,
MultiFieldMatrix &  mfmatrix,
MultiField &  xField,
MultiField &  rField 
)
inlinevirtual

Implements Discretization.

Definition at line 68 of file InjectionDiscretization.h.

References InjectionDiscretization< X, Diag, OffDiag >::_conductionbandField, InjectionDiscretization< X, Diag, OffDiag >::_constants, InjectionDiscretization< X, Diag, OffDiag >::_geomFields, InjectionDiscretization< X, Diag, OffDiag >::_varField, GeomFields::coordinate, ElectronSupplyFunction(), fabs(), FermiFunction(), Mesh::getBoundaryFaceGroups(), Mesh::getCellCells(), Mesh::getCells(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getFaceCells(), StorageSite::getSelfCount(), H_SI, HBAR_SI, FaceGroup::id, ME, PI, PositiveValueOf(), QE, FaceGroup::site, sqrt(), and GeomFields::volume.

70  {
71  const StorageSite& cells = mesh.getCells();
72 
73  const int nCells = cells.getSelfCount();
74 
75  //const VectorT3Array& electric_field = dynamic_cast<const VectorT3Array&> (_electricField[cells]);
76 
77  const TArray& conduction_band = dynamic_cast<const TArray&> (_conductionbandField[cells]);
78 
79  TArray* ts = (new TArray(cells.getCount()));
80  *ts = 0;
81  TArray& transmission = *ts;
82 
83  const MultiField::ArrayIndex cVarIndex(&_varField,&cells);
84 
85  //CCMatrix& matrix = dynamic_cast<CCMatrix&>(mfmatrix.getMatrix(cVarIndex,cVarIndex));
86 
87  const VectorT3Array& cellCentroid =
88  dynamic_cast<const VectorT3Array& > (_geomFields.coordinate[cells]);
89 
90  //const XArray& xCell = dynamic_cast<const XArray&>(xField[cVarIndex]);
91 
92  const TArray& cellVolume =
93  dynamic_cast<const TArray&>(_geomFields.volume[cells]);
94 
95  XArray& rCell = dynamic_cast<XArray&>(rField[cVarIndex]);
96 
97  //DiagArray& diag = matrix.getDiag();
98 
99  //OffDiagArray& offdiag = matrix.getOffDiag();
100 
101  const T_Scalar dielectric_thickness = _constants["dielectric_thickness"];
102  const T_Scalar electron_effmass = _constants["electron_effmass"];
103  const T_Scalar temperature = _constants["OP_temperature"];
104  //const T_Scalar substrate_voltage = _constants["substrate_voltage"];
105  //const T_Scalar membrane_voltage = _constants["membrane_voltage"];
106  const T_Scalar fermilevelsubstrate = -_constants["substrate_workfunction"] - _constants["substrate_voltage"];
107  //const T_Scalar fermilevelmembrane = -_constants["substrate_workfunction"] - _constants["membrane_voltage"];
108  const int subID = _constants["substrate_id"];
109  //const int memID = _constants["membrane_id"];
110  const int nLevel = _constants["nLevel"];
111  const int normal = _constants["normal_direction"];
112  const int nTrap = _constants["nTrap"];
113 
114  T_Scalar fluxCoeff(0), fermilevel(0); // scatterfactor(0);
115  //T_Scalar sourceInjection(0);
116  const T_Scalar alpha = 4.0 * PI * (electron_effmass*ME) / pow(H_SI, 3.0);
117  //const T_Scalar energystep = fabs(substrate_voltage - membrane_voltage) / nLevel;
118  const T_Scalar energystep = 0.01;
119  //=======================================//
120  // injection from substrate to dielectric
121  //=======================================//
122  for(int c=0; c<cells.getCount(); c++){
123  transmission[c] = 0.0;
124  }
125 
126  fermilevel = fermilevelsubstrate;
127 
128  for (T_Scalar en = fermilevel-4.0; en <= fermilevel+4.0; en += energystep){
129 
130  const T_Scalar supplyfunction = ElectronSupplyFunction(en, fermilevel, temperature);
131 
132  const T_Scalar fermifunction = FermiFunction(en, fermilevel, temperature);
133 
134  foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
135  {
136  const FaceGroup& fg = *fgPtr;
137 
138  if (fg.id == subID){
139  const StorageSite& faces = fg.site;
140  const CRConnectivity& faceCells = mesh.getFaceCells(faces);
141  const CRConnectivity& cellCells = mesh.getCellCells();
142  const int nFaces = faces.getCount();
143 
144  for(int f=0; f<nFaces; f++){
145 
146  //--------------------------------------------------------------------------------------------
147  // 1D int array to store the cell index along each straight line from substrate to membrane
148  int indices[nLevel+1];
149 
150  int c0 = faceCells(f,0);
151  int c1 = faceCells(f,1);
152 
153  indices[0] = c1;
154 
155  int low = c1;
156  int me = c0;
157  int high = c0;
158 
159  for(int l=0; l < nLevel; l++){
160  if (me > nCells)
161  throw CException("index out of boundary in elec_model injection calculation");
162  indices[l+1] = me;
163  const int nbc = cellCells.getCount(me);
164  T_Scalar drmin = 0.0;
165  int neighborUp = 0;
166  for(int nc = 0; nc < nbc; nc++){
167  const int neighbor = cellCells(me, nc);
168  const T_Scalar dr = cellCentroid[me][normal] - cellCentroid[neighbor][normal];
169  if (dr < drmin){
170  drmin = dr;
171  neighborUp = neighbor;
172  }
173  }
174  high = neighborUp;
175  low = me;
176  me = high;
177  }
178  //--------------------------------------------------------------------------------------------
179  //calculate transmission coefficient along the line
180  transmission[indices[0]]=1.0;
181  for(int l=0; l < nLevel; l++){
182  int low = indices[l];
183  int me = indices[l+1];
184 
185  T_Scalar dX = cellCentroid[me][normal] - cellCentroid[low][normal];
186  T_Scalar factor = -2.0/HBAR_SI * sqrt(2.0*electron_effmass*ME*QE);
187  T_Scalar valueMe = PositiveValueOf( conduction_band[me] - en);
188  T_Scalar valueLow = PositiveValueOf( conduction_band[low] - en);
189  T_Scalar avg = (valueMe + valueLow) / 2.0;
190  T_Scalar exponent = factor * sqrt(avg) * fabs(dX);
191 #if DEBUG
192  (*mark)[me] = 1;
193 #endif
194  transmission[me] = transmission[low] * exp(exponent);
195  }
196  //--------------------------------------------------------------------------------------------
197  for(int l=0; l < nLevel; l++){
198  //int low = indices[l];
199  int me = indices[l+1];
200  //injection occurs where the sign of (en-conductionband) switches.
201  if ((en-conduction_band[me]) > 0) {
202 
203  const T_Scalar dX = dielectric_thickness/nLevel;
204  fluxCoeff = alpha * transmission[me] * supplyfunction * fermifunction * energystep * QE * cellVolume[me] / fabs(dX) ;
205  rCell[me][nTrap] += fluxCoeff;
206  break;
207  }
208 
209  }
210  }
211  }
212  }
213  }
214 
215 
216 #if 0
217  //=======================================//
218  // Injection from membrane to dielectric
219  //=======================================//
220  for(int c=0; c < cells.getCount(); c++){
221  transmission[c] = 0.0;
222  }
223 
224  fermilevel = fermilevelmembrane;
225  for (T_Scalar en = fermilevel-4.0; en <= fermilevel+4.0; en += energystep){
226 
227  const T_Scalar supplyfunction = ElectronSupplyFunction(en, fermilevel, temperature);
228 
229  const T_Scalar fermifunction = FermiFunction(en, fermilevel, temperature);
230 
231  foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
232  {
233  const FaceGroup& fg = *fgPtr;
234 
235  if (fg.id == memID){
236  const StorageSite& faces = fg.site;
237  const CRConnectivity& faceCells = mesh.getFaceCells(faces);
238  const CRConnectivity& cellCells = mesh.getCellCells();
239  const int nFaces = faces.getCount();
240 
241  for(int f=0; f<nFaces; f++){
242 
243  //--------------------------------------------------------------------------------------------
244  // 1D int array to store the cell index along each straight line from substrate to membrane
245  int indices[nLevel+1];
246 
247  int c0 = faceCells(f,0);
248  int c1 = faceCells(f,1);
249 
250  indices[0] = c1;
251 
252  int low = c1;
253  int me = c0;
254  int high = c0;
255 
256  for(int l=0; l < nLevel; l++){
257  if (me > nCells)
258  throw CException("index out of boundary in elec_model injection calculation");
259  indices[l+1] = me;
260  const int nbc = cellCells.getCount(me);
261  T_Scalar drmin = 0.0;
262  int neighborUp = 0;
263  for(int nc = 0; nc < nbc; nc++){
264  const int neighbor = cellCells(me, nc);
265  const T_Scalar dr = cellCentroid[me][normal] - cellCentroid[neighbor][normal];
266  if (dr > drmin){
267  drmin = dr;
268  neighborUp = neighbor;
269  }
270  }
271  high = neighborUp;
272  low = me;
273  me = high;
274  }
275  //--------------------------------------------------------------------------------------------
276  //calculate transmission coefficient along the line
277  transmission[indices[0]]=1.0;
278  for(int l=0; l < nLevel; l++){
279  int low = indices[l];
280  int me = indices[l+1];
281 
282  T_Scalar dX = cellCentroid[me][normal] - cellCentroid[low][normal];
283  T_Scalar factor = -2.0/HBAR_SI * sqrt(2.0*electron_effmass*ME*QE);
284  T_Scalar valueMe = PositiveValueOf( conduction_band[me] - en);
285  T_Scalar valueLow = PositiveValueOf( conduction_band[low] - en);
286  T_Scalar avg = (valueMe + valueLow) / 2.0;
287  T_Scalar exponent = factor * sqrt(avg) * fabs(dX);
288 #if DEBUG
289  (*mark)[me] = 1;
290 #endif
291  transmission[me] = transmission[low] * exp(exponent);
292  }
293  //--------------------------------------------------------------------------------------------
294  for(int l=0; l < nLevel; l++){
295  int low = indices[l];
296  int me = indices[l+1];
297  //injection occurs where the sign of (en-conductionband) switches.
298  if ((en-conduction_band[me]) > 0) {
299 
300  const T_Scalar dX = energystep / electric_field[me][normal];
301 
302  fluxCoeff = alpha * transmission[me] * supplyfunction * fermifunction * energystep * QE * cellVolume[me] / fabs(dX) ;
303 
304  rCell[me][nTrap] += fluxCoeff;
305  //cout << "transmission " << me << " " << transmission[me] << endl;
306 
307  break;
308  }
309  }
310  }
311  }
312  }
313  }
314 
315 #endif
316 
317 
318  }
Mesh::getBoundaryFaceGroups
const FaceGroupList & getBoundaryFaceGroups() const
Definition: Mesh.h:187
CRConnectivity::getCount
int getCount(const int i) const
Definition: CRConnectivity.h:165
FaceGroupPtr
shared_ptr< FaceGroup > FaceGroupPtr
Definition: Mesh.h:46
PI
#define PI
Definition: PhysicsConstant.h:10
StorageSite::getSelfCount
int getSelfCount() const
Definition: StorageSite.h:40
GeomFields::coordinate
Field coordinate
Definition: GeomFields.h:19
FaceGroup
Definition: Mesh.h:28
FermiFunction
const T FermiFunction(const T &energy, const T &fermilevel, const T &temperature)
Definition: ElectricUtilityFunctions.h:19
InjectionDiscretization::T_Scalar
NumTypeTraits< X >::T_Scalar T_Scalar
Definition: InjectionDiscretization.h:44
ME
#define ME
Definition: PhysicsConstant.h:16
InjectionDiscretization::_constants
const ElectricModelConstants< T_Scalar > & _constants
Definition: InjectionDiscretization.h:328
sqrt
Tangent sqrt(const Tangent &a)
Definition: Tangent.h:317
HBAR_SI
#define HBAR_SI
Definition: PhysicsConstant.h:22
FaceGroup::id
const int id
Definition: Mesh.h:41
MultiField::ArrayIndex
pair< const Field *, const StorageSite * > ArrayIndex
Definition: MultiField.h:21
H_SI
#define H_SI
Definition: PhysicsConstant.h:14
QE
#define QE
Definition: PhysicsConstant.h:18
Mesh::getCellCells
const CRConnectivity & getCellCells() const
Definition: Mesh.cpp:480
Mesh::getCells
const StorageSite & getCells() const
Definition: Mesh.h:109
GeomFields::volume
Field volume
Definition: GeomFields.h:26
PositiveValueOf
const T PositiveValueOf(T input)
Definition: ElectricUtilityFunctions.h:50
Mesh::getFaceCells
const CRConnectivity & getFaceCells(const StorageSite &site) const
Definition: Mesh.cpp:388
fabs
Tangent fabs(const Tangent &a)
Definition: Tangent.h:312
ElectronSupplyFunction
const T ElectronSupplyFunction(const T &energy, const T &fermilevel, const T &temperature)
Definition: ElectricUtilityFunctions.h:25
StorageSite::getCount
int getCount() const
Definition: StorageSite.h:39
FaceGroup::site
StorageSite site
Definition: Mesh.h:40

Member Data Documentation

template<class X , class Diag , class OffDiag >
const Field& InjectionDiscretization< X, Diag, OffDiag >::_conductionbandField
private

Definition at line 327 of file InjectionDiscretization.h.

Referenced by InjectionDiscretization< X, Diag, OffDiag >::discretize().

template<class X , class Diag , class OffDiag >
const ElectricModelConstants<T_Scalar>& InjectionDiscretization< X, Diag, OffDiag >::_constants
private

Definition at line 328 of file InjectionDiscretization.h.

Referenced by InjectionDiscretization< X, Diag, OffDiag >::discretize().

template<class X , class Diag , class OffDiag >
const Field& InjectionDiscretization< X, Diag, OffDiag >::_electricField
private

Definition at line 326 of file InjectionDiscretization.h.

template<class X , class Diag , class OffDiag >
const GeomFields& InjectionDiscretization< X, Diag, OffDiag >::_geomFields
private

Definition at line 324 of file InjectionDiscretization.h.

Referenced by InjectionDiscretization< X, Diag, OffDiag >::discretize().

template<class X , class Diag , class OffDiag >
const Field& InjectionDiscretization< X, Diag, OffDiag >::_varField
private

Definition at line 325 of file InjectionDiscretization.h.

Referenced by InjectionDiscretization< X, Diag, OffDiag >::discretize().

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