NeoPZ
pzblackoil2p3d.cpp
Go to the documentation of this file.
1 
6 #include "pzblackoil2p3d.h"
7 #include "pzbndcond.h"
8 
9 using namespace std;
10 
11 #ifdef _AUTODIFF
12 
13 #include "fad.h"
14 
15 TPZBlackOil2P3D::EState TPZBlackOil2P3D::gState = ELastState;
16 
18 void TPZBlackOil2P3D::Interpolate(std::map<REAL,REAL> &dados, double x, double &y, double &dy){
19  double x0, xL, y0, yL;
20  std::map< REAL, REAL >::iterator w;
21  w = dados.lower_bound(x);
22 
23  if(dados.size() < 2){
24  std::cout << "Error at " << __PRETTY_FUNCTION__ << "\n";
25  std::cout.flush();
26  }
27 
28  if(w == dados.end()){
29  w--;
30  y = w->second;
31 
32  //derivada
33  xL = w->first;
34  yL = w->second;
35  w--;
36  x0 = w->first;
37  y0 = w->second;
38  dy = (yL-y0)/(xL-x0);
39 
40  return;
41  }
42  if (w == dados.begin()){
43  y = w->second;
44 
45  //derivada
46  x0 = w->first;
47  y0 = w->second;
48  w++;
49  xL = w->first;
50  yL = w->second;
51  dy = (yL-y0)/(xL-x0);
52  return;
53  }
54 
55  xL = w->first;
56  yL = w->second;
57  w--;
58 
59  x0 = w->first;
60  y0 = w->second;
61 
62  y = (yL-y0)*(x-x0)/(xL-x0)+y0;
63  dy = (yL-y0)/(xL-x0);
64 
65 }
66 
67 void TPZBlackOil2P3D::Interpolate(std::map<REAL,REAL> &dados, BFadREAL x, BFadREAL &y){
68  REAL x0, xL, y0, yL;
69  std::map< REAL, REAL >::iterator w;
70  w = dados.lower_bound(x.val());
71 
72  if(dados.size() < 2){
73  std::cout << "Error at " << __PRETTY_FUNCTION__ << "\n";
74  std::cout.flush();
75  }
76 
77  if(w == dados.end()){
78  w--;
79  y = w->second;
80 
81  return;
82  }
83  if (w == dados.begin()){
84  y = w->second;
85 
86  return;
87  }
88 
89  xL = w->first;
90  yL = w->second;
91  w--;
92 
93  x0 = w->first;
94  y0 = w->second;
95  y = (yL-y0)*(x-x0)/(xL-x0)+y0;
96 }
97 
99 void TPZBlackOil2P3D::Kro(double So, double &Kro, double &dKroSo) {
100  const int n = 8;
101  double tabela[n][2] = {{0.12,1.},{0.2,0.8},{0.3,0.6},{0.4,0.45},{0.5,0.3},{0.6,0.2},{0.7,0.1},{0.82,0.}};
102  std::map<REAL,REAL> dados;
103  for(int i = 0; i < n; i++){
104  dados[ 1.-tabela[i][0] ] = tabela[i][1];
105  }
106  this->Interpolate(dados,So,Kro,dKroSo);
107 }
108 
109 void TPZBlackOil2P3D::Kro(BFadREAL So, BFadREAL &Kro) {
110  const int n = 8;
111  double tabela[n][2] = {{0.12,1.},{0.2,0.8},{0.3,0.6},{0.4,0.45},{0.5,0.3},{0.6,0.2},{0.7,0.1},{0.82,0.}};
112  std::map<REAL,REAL> dados;
113  for(int i = 0; i < n; i++){
114  dados[ 1.-tabela[i][0] ] = tabela[i][1];
115  }
116  this->Interpolate(dados,So,Kro);
117 }
118 
120 void TPZBlackOil2P3D::Krw(double So, double &Krw, double &dKrwSo) {
121  const int n = 8;
122  double tabela[n][2] = {{0.12,0.},{0.2,0.1},{0.3,0.2},{0.4,0.3},{0.5,0.4},{0.6,0.55},{0.7,0.7},{0.82,1.}};
123  std::map<REAL,REAL> dados;
124  for(int i = 0; i < n; i++){
125  dados[ 1.-tabela[i][0] ] = tabela[i][1];
126  }
127  this->Interpolate(dados,So,Krw,dKrwSo);
128 }
129 
130 void TPZBlackOil2P3D::testeKrw() {
131  ofstream KrFDP("Krw.txt");
132  double doubleI;
133  BFadREAL Krw;
134  for(int i = 0; i < 1000; i++){
135  doubleI = i;
136  BFadREAL So(0. + doubleI * 1./100., 0);
137  this->Krw(So,Krw);
138  KrFDP << So.val() << "\t" << Krw.val() << "\t" << Krw.dx(0) << " \n";
139  }
140 }//void
141 
142 void TPZBlackOil2P3D::Krw(BFadREAL So, BFadREAL &Krw){
143  static bool testeAG = true;
144  if(testeAG){
145  testeAG = false;
146  testeKrw();
147  }
148  const int n = 8;
149  double tabela[n][2] = {{0.12,0.},{0.2,0.1},{0.3,0.2},{0.4,0.3},{0.5,0.4},{0.6,0.55},{0.7,0.7},{0.82,1.}};
150  std::map<REAL,REAL> dados;
151  for(int i = 0; i < n; i++){
152  dados[ 1.-tabela[i][0] ] = tabela[i][1];
153  }
154  this->Interpolate(dados,So,Krw);
155 }
156 
159 void TPZBlackOil2P3D::Bo(double po, double &Bo, double &dBoDpo) {
160  const int n = 9;
161  double tabela[n][2] = {{14.7, 1.062}, {264.7, 1.15}, {514.7, 1.207}, {1014.7, 1.295}, {2014.7, 1.435}, {2514., 1.5},
162  {3014.7, 1.565}, {4014.7, 1.695}, {9014.7, 1.695}};
163  const double conv = 6894.757;
164  std::map<REAL,REAL> dados;
165  for(int i = 0; i < n; i++){
166  dados[ tabela[i][0]*conv ] = tabela[i][1];
167  }
168  this->Interpolate(dados,po,Bo,dBoDpo);
169 }
170 
171 
172 void TPZBlackOil2P3D::testedoBo() {
173  ofstream BOFDP("bo.txt");
174  double doubleI;
175  BFadREAL Bo;
176  for(int i = 0; i < 1000; i++){
177  doubleI = i;
178  BFadREAL p(10135.93 + doubleI * (621562370.- 101352.93)/100., 0);
179  this->Bo(p,Bo);
180  BOFDP << p.val() << "\t" << Bo.val() << "\t" << Bo.dx(0) << " \n";
181  }
182 }
183 
184 void TPZBlackOil2P3D::Bo(BFadREAL po, BFadREAL &Bo) {
185  const int n = 9;
186  double tabela[n][2] = {{14.7, 1.062}, {264.7, 1.15}, {514.7, 1.207}, {1014.7, 1.295}, {2014.7, 1.435}, {2514., 1.5},
187  {3014.7, 1.565}, {4014.7, 1.695}, {9014.7, 1.695}};
188  const double conv = 6894.757;
189  std::map<REAL,REAL> dados;
190  for(int i = 0; i < n; i++){
191  dados[ tabela[i][0]*conv ] = tabela[i][1];
192  }
193  this->Interpolate(dados,po,Bo);
194 }
195 
197 void TPZBlackOil2P3D::ViscOleo(double po, double &ViscOleo, double &dViscOleoDpo){
198  const int n = 9;
199  double tabela[n][2] = {{14.7, 1.062}, {264.7, 1.15}, {514.7, 1.207}, {1014.7, 1.295}, {2014.7, 1.435}, {2514., 1.5},
200  {3014.7, 1.565}, {4014.7, 1.695}, {9014.7, 1.6}};
201  const double conv = 6894.757;
202  const double convVisc = 1e-3;
203  std::map<REAL,REAL> dados;
204  for(int i = 0; i < n; i++){
205  dados[ tabela[i][0]*conv ] = tabela[i][1]*convVisc;
206  }
207  this->Interpolate(dados,po,ViscOleo,dViscOleoDpo);
208 }
209 
210 void TPZBlackOil2P3D::ViscOleo(BFadREAL po, BFadREAL &ViscOleo){
211 
212  const int n = 10;
213  double tabela[n][2] = {{14.7,1.04},{264.7,0.975},{514.7,0.91},{1014.7,0.83},{2014.7,0.695},
214  {2514.,0.641},{3014.7,0.594},{4014.7,0.51},{5014.7,0.449},{9014.7,0.203}};
215  const double conv = 6894.757;
216  const double convVisc = 1e-3;
217  std::map<REAL,REAL> dados;
218  for(int i = 0; i < n; i++){
219  dados[ tabela[i][0]*conv ] = tabela[i][1]*convVisc;
220  }
221  this->Interpolate(dados,po,ViscOleo);
222 }
223 
225 void TPZBlackOil2P3D::PressaoCapilar(double So, double &pc, double &DpcDSo){
226  pc = 0.;
227  DpcDSo = 0.;
228 }
229 
230 void TPZBlackOil2P3D::PressaoCapilar(BFadREAL So, BFadREAL &pc){
231  pc = 0.;
232 }
233 
235 void TPZBlackOil2P3D::Porosidade(double po, double &poros, double &dPorosDpo){
236  const double comp = 3.625943e-10;
237  const double pref = 101352.93;
238  const double porosRef = 0.22;
239  poros = porosRef*exp(comp*(po-pref));
240  dPorosDpo = comp*porosRef*exp(comp*(po-pref));
241 }
242 
243 void TPZBlackOil2P3D::Porosidade(BFadREAL po, BFadREAL &poros){
244  const double comp = 3.625943e-10;
245  const double pref = 101352.93;
246  const double porosRef = 0.22;
247  poros = porosRef*exp(comp*((po.val())-pref));
248 }
249 
250 // Constant data
251 
253 double TPZBlackOil2P3D::RhoOleoSC(){
254  return 740.75782;
255 }
256 
258 double TPZBlackOil2P3D::RhoAguaSC(){
259  return 996.95712;
260 }
261 
263 double TPZBlackOil2P3D::g(){
264  return 9.81;
265 }
266 
268 double TPZBlackOil2P3D::Bw(){
269  return 1.041;
270 }
271 
273 double TPZBlackOil2P3D::ViscAgua(){
274  return 0.31e-3;
275 }
276 
278 void TPZBlackOil2P3D::K(TPZFMatrix<REAL> &K){
279  K.Resize(3,3);
280  K.Zero();
281  K(0,0) = 2.96077e-13;//10;
282  K(1,1) = 2.96077e-13;//10;
283  K(2,2) = 4.93462e-14;//11;
284 }
285 
286 
287 //Programa
288 
289 TPZBlackOil2P3D::TPZBlackOil2P3D(int id, double deltaT):TPZDiscontinuousGalerkin(id){
290  this->fDeltaT = deltaT;
291 }
292 
293 TPZBlackOil2P3D::~TPZBlackOil2P3D(){
294  //nothing to be done
295 }
296 
297 TPZBlackOil2P3D::TPZBlackOil2P3D(const TPZBlackOil2P3D &cp):TPZDiscontinuousGalerkin(cp){
298 
299 }
300 
301 TPZMaterial * TPZBlackOil2P3D::NewMaterial(){
302  return new TPZBlackOil2P3D(*this);
303 }
304 
305 void TPZBlackOil2P3D::Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef){
306 
307  //un ou un+1
308  double stateVal = 0.;
309  if(gState == ELastState) stateVal = -1.;
310  if(gState == ECurrentState) stateVal = +1.;
311 
312  //pressao e saturacao
313  const BFadREAL po(data.sol[0][0],0);
314  const BFadREAL So(data.sol[0][1],1);
315  BFadREAL pc;
316  this->PressaoCapilar(So,pc);
317  const BFadREAL pw = po - pc;
318  const BFadREAL Sw = ((BFadREAL)1.)-So;
319 
320  //porosidade
321  BFadREAL porosidade;
322  this->Porosidade(po,porosidade);
323 
324  //fator volume formacao
325  BFadREAL Bo;
326  this->Bo(po,Bo);
327  const double Bw = this->Bw();
328 
329  //Equacao 1
330  BFadREAL VolOp1 = (porosidade*So/Bo)/this->fDeltaT;
331 
332  //Equacao 2
333  BFadREAL VolOp2 = (porosidade*Sw/Bw)/this->fDeltaT;
334 
335  ef(0,0) += -1.*weight*stateVal*VolOp1.val();
336  ef(1,0) += -1.*weight*stateVal*VolOp2.val();
337 
338  if(gState == ECurrentState){//Last state has no tangent
339  ek(0,0) += +1.*weight*stateVal*VolOp1.dx(0);
340  ek(0,1) += +1.*weight*stateVal*VolOp1.dx(1);
341 
342  ek(1,0) += +1.*weight*stateVal*VolOp2.dx(0);
343  ek(1,1) += +1.*weight*stateVal*VolOp2.dx(1);
344  }
345 
346 }//method
347 
348 void TPZBlackOil2P3D::ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc) {
349  cout << "Error: This method shoud not be called. " << __PRETTY_FUNCTION__ << "\n";
350 }//method
351 
352 void TPZBlackOil2P3D::ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) {
353 
354  if(gState == ELastState) return;
355 
356  //calculando distancia entre centro dos elementos
357  double dist = 0;
358  for(int i = 0; i < 3; i++){
359  double val = dataright.XCenter[i] - dataleft.XCenter[i];
360  dist += val*val;
361  }
362  dist = sqrt(dist);
363 
364  //pressao e saturacao
365  const BFadREAL poL(dataleft.sol[0][0],0);
366  const BFadREAL SoL(dataleft.sol[0][1],1);
367  const BFadREAL poR(dataright.sol[0][0],2);
368  const BFadREAL SoR(dataright.sol[0][1],3);
369 
370  BFadREAL pcL,pcR;
371  this->PressaoCapilar(SoL,pcL);
372  this->PressaoCapilar(SoR,pcR);
373  const BFadREAL pwL = poL - pcL;
374  const BFadREAL pwR = poR - pcR;
375  const BFadREAL SwL = ((BFadREAL)1.)-SoL;
376  const BFadREAL SwR = ((BFadREAL)1.)-SoR;
377 
378  //Permeabilidade
379  TPZFNMatrix<9> K(3,3,0.);
380  this->K(K);
381 
382  const REAL knormal = K(0,0)*data.normal[0]*data.normal[0] + 2.*K(0,1)*data.normal[0]*data.normal[1] +
383  K(1,1)*data.normal[1]*data.normal[1] + data.normal[2]*(2.*K(0,2)*data.normal[0] +
384  2.*K(1,2)*data.normal[1] + K(2,2)*data.normal[2]);
385 
386  const REAL kgradZn = -K(0,2)*data.normal[0] - K(1,2)*data.normal[1] - K(2,2)*data.normal[2];
387 
388  // ************* Equacao 1 ******************* /
389 
390  //Oleo
391  BFadREAL BoL,BoR;
392  this->Bo(poL, BoL);
393  this->Bo(poR, BoR);
394  const BFadREAL GammaOleoLeft = this->g() * this->RhoOleoSC()/BoL.val();
395  const BFadREAL GammaOleoRight = this->g() * this->RhoOleoSC()/BoR.val();
396 
397  //velocidade de Darcy
398  BFadREAL velocOleo = -1.*((knormal*poR-knormal*poL)/dist - (GammaOleoRight*kgradZn+GammaOleoLeft*kgradZn)/2.);
399 
400  //Mobilidades
401  BFadREAL KroL,KroR;
402  this->Kro(SoL,KroL);
403  this->Kro(SoR,KroR);
404  BFadREAL ViscOleoLeft, ViscOleoRight;
405  this->ViscOleo(poL, ViscOleoLeft);
406  this->ViscOleo(poR, ViscOleoRight);
407  BFadREAL LambdaOleoLeft = KroL/(ViscOleoLeft*BoL);
408  BFadREAL LambdaOleoRight = KroR/(ViscOleoRight*BoR);
409 
410  //Fluxo numerico da primeira equacao do residuo
411  BFadREAL Fn1 = 0.;
412  if(velocOleo.val() > 0.){
413  Fn1 = -LambdaOleoLeft*velocOleo;
414  }
415  else{
416  Fn1 = -LambdaOleoRight*velocOleo;
417  }
418 
419  ef(0,0) += -1.*weight*( -Fn1.val() );
420  ef(2,0) += -1.*weight*( +Fn1.val() );
421 
422 #ifndef EXPLICITO
423  //ek = -T (R)
424  ek(0,0) += -1.*weight*( +Fn1.dx(0) );
425  ek(0,1) += -1.*weight*( +Fn1.dx(1) );
426  ek(0,2) += -1.*weight*( +Fn1.dx(2) );
427  ek(0,3) += -1.*weight*( +Fn1.dx(3) );
428 
429  ek(2,0) += -1.*weight*( -Fn1.dx(0) );
430  ek(2,1) += -1.*weight*( -Fn1.dx(1) );
431  ek(2,2) += -1.*weight*( -Fn1.dx(2) );
432  ek(2,3) += -1.*weight*( -Fn1.dx(3) );
433 #endif
434 
435  // ************* Equacao 2 ******************* /
436 
437  //Agua
438  const REAL Bw = this->Bw();
439  const REAL GammaAgua = this->g() * this->RhoAguaSC() / Bw;
440 
441  //velocidade de Darcy
442  BFadREAL velocAgua = -1.*( (knormal*pwR-knormal*pwL)/dist - (GammaAgua*kgradZn+GammaAgua*kgradZn)/2. );
443 
444  //Mobilidades
445  BFadREAL KrwL,KrwR;
446  this->Krw(SoL,KrwL);
447  this->Krw(SoR,KrwR);
448  REAL ViscAgua = this->ViscAgua();
449  BFadREAL LambdaAguaLeft = KrwL.val()/(ViscAgua*Bw);
450  BFadREAL LambdaAguaRight = KrwR.val()/(ViscAgua*Bw);
451 
452  //Fluxo numerico da segunda equacao do residuo
453  BFadREAL Fn2 = 0.;
454  if(velocAgua.val() > 0.){
455  Fn2 = -LambdaAguaLeft*velocAgua;
456  }
457  else{
458  Fn2 = -LambdaAguaRight*velocAgua;
459  }
460 
461  ef(1,0) += -1.*weight*( -Fn2.val() );
462  ef(3,0) += -1.*weight*( +Fn2.val() );
463 
464 #ifndef EXPLICITO
465  //ek = -T (R)
466  ek(1,0) += -1.*weight*( +Fn2.dx(0) );
467  ek(1,1) += -1.*weight*( +Fn2.dx(1) );
468  ek(1,2) += -1.*weight*( +Fn2.dx(2) );
469  ek(1,3) += -1.*weight*( +Fn2.dx(3) );
470 
471  ek(3,0) += -1.*weight*( -Fn2.dx(0) );
472  ek(3,1) += -1.*weight*( -Fn2.dx(1) );
473  ek(3,2) += -1.*weight*( -Fn2.dx(2) );
474  ek(3,3) += -1.*weight*( -Fn2.dx(3) );
475 #endif
476 
477 }//method
478 
479 void TPZBlackOil2P3D::ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) {
480 
481  if(gState == ELastState) return;
482 
483  if(bc.Type() == 3){
484  double vazao = -1. * (- fabs(bc.Val2()(0,0)) ); //em m3/m2
485  ef(1,0) += weight * vazao;
486  }//impondo vazao da injecao de agua
487 
488  if(bc.Type() == 2) return;//Parede ou simetria
489  TPZMaterialData dataright;
490 
491  if((bc.Type() == 0) || (bc.Type() == 1)){
492 
493  //pressao e saturacao
494  dataright.sol[0][0] = bc.Val2()(0,0);
495  dataright.sol[0][1] = bc.Val2()(1,0);
496 
497  TPZFNMatrix<16,STATE> auxek(4,4,0.), auxef(4,1,0.);
498  this->ContributeInterface(data,dataleft,dataright,weight,auxek,auxef);
499 
500  for(int i = 0; i < 2; i++){
501  ef(i,0) += auxef(i,0);
502  for(int j = 0; j < 2; j++){
503  ek(i,j) += auxek(i,j);
504  }
505  }
506 
507  }//Dirichlet na pressao e Dirichlet ou outflow na saturacao
508 
509 }//method
510 
511 
512 enum ESolutionVars { ENone = 0, EWaterPressure = 1, EOilPressure, EWaterSaturation, EOilSaturation, EDarcyVelocity };
513 
514 int TPZBlackOil2P3D::VariableIndex(const std::string &name){
515  if(!strcmp("WaterPressure",name.c_str())) return EWaterPressure;
516  if(!strcmp("OilPressure",name.c_str())) return EOilPressure;
517  if(!strcmp("WaterSaturation",name.c_str())) return EWaterSaturation;
518  if(!strcmp("OilSaturation",name.c_str())) return EOilSaturation;
519  if(!strcmp("DarcyVelocity",name.c_str())) return EDarcyVelocity;
520  return TPZMaterial::VariableIndex(name);
521 }
522 
523 int TPZBlackOil2P3D::NSolutionVariables(int var){
524  if(var == EWaterPressure) return 1;
525  if(var == EOilPressure) return 1;
526  if(var == EWaterSaturation) return 1;
527  if(var == EOilSaturation) return 1;
528  if(var == EDarcyVelocity) return 3;
529  return TPZMaterial::NSolutionVariables(var);
530 }
531 
532 void TPZBlackOil2P3D::Solution(TPZVec<STATE> &Sol, TPZFMatrix<STATE> &DSol,
533  TPZFMatrix<REAL> &axes, int var, TPZVec<STATE> &Solout){
534  const double po = Sol[0];
535  const double So = Sol[1];
536 
537  if(var == EWaterPressure){
538  BFadREAL pc;
539  this->PressaoCapilar(So, pc);
540  Solout[0] = (po-pc.val());
541  return;
542  }//pw
543 
544  if(var == EOilPressure){
545  Solout[0] = po;
546  return;
547  }//po
548 
549  if(var == EWaterSaturation){
550  Solout[0] = 1.-So;
551  return;
552  }//Sw
553 
554  if(var == EOilSaturation){
555  Solout[0] = So;
556  return;
557  }//So
558 
559  if(var == EDarcyVelocity){
560  cout << "\nERROR AT " << __PRETTY_FUNCTION__ << " \n";
561  Solout.Fill(0.);
562  return;
563  }//Velocity
564 
565  TPZMaterial::Solution(Sol,DSol,axes,var,Solout);
566 
567 }//method
568 
569 #endif
TPZDiscontinuousGalerkin
Defines the interface which material objects need to implement for discontinuous Galerkin formulation...
Definition: pzdiscgal.h:20
TPZMaterial::Solution
virtual void Solution(TPZMaterialData &data, int var, TPZVec< STATE > &Solout)
Returns the solution associated with the var index based on the finite element approximation.
Definition: TPZMaterial.cpp:200
TPZBiharmonic::ContributeInterface
virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix< STATE > &ek, TPZFMatrix< STATE > &ef) override
It computes a contribution to stiffness matrix and load vector at one integration point...
Definition: pzbiharmonic.cpp:146
fabs
expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ fabs
Definition: tfadfunc.h:140
TPZMaterialData::normal
TPZManVector< REAL, 3 > normal
normal to the element at the integration point
Definition: pzmaterialdata.h:69
bc
clarg::argBool bc("-bc", "binary checkpoints", false)
TPZBndCond::Type
int Type()
Definition: pzbndcond.h:249
TPZMaterial::VariableIndex
virtual int VariableIndex(const std::string &name)
Returns the variable index associated with the name.
Definition: TPZMaterial.cpp:141
val
REAL val(STATE &number)
Returns value of the variable.
Definition: pzartdiff.h:23
TPZBndCond::Val2
TPZFMatrix< STATE > & Val2(int loadcase=0)
Definition: pzbndcond.h:255
TPZMaterial
This abstract class defines the behaviour which each derived class needs to implement.
Definition: TPZMaterial.h:39
pzbndcond.h
Contains the TPZBndCond class which implements a boundary condition for TPZMaterial objects...
TPZFMatrix::Zero
int Zero() override
Makes Zero all the elements.
Definition: pzfmatrix.h:651
TPZMaterialData::XCenter
TPZManVector< REAL, 3 > XCenter
value of the coordinate at the center of the element
Definition: pzmaterialdata.h:87
TPZBndCond
This class defines the boundary condition for TPZMaterial objects.
Definition: pzbndcond.h:29
sqrt
expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ sqrt
Definition: tfadfunc.h:120
dist
REAL dist(TPZVec< T1 > &vec1, TPZVec< T1 > &vec2)
Definition: pzvec_extras.h:124
TPZMaterial::NSolutionVariables
virtual int NSolutionVariables(int var)
Returns the number of variables associated with the variable indexed by var.
Definition: TPZMaterial.cpp:176
TPZVec::Fill
void Fill(const T &copy, const int64_t from=0, const int64_t numelem=-1)
Will fill the elements of the vector with a copy object.
Definition: pzvec.h:460
exp
expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ expr_ exp
Definition: tfadfunc.h:125
TPZFMatrix::Resize
int Resize(const int64_t newRows, const int64_t wCols) override
Redimension a matrix, but maintain your elements.
Definition: pzfmatrix.cpp:1016
pzblackoil2p3d.h
Contains the TPZBlackOil2P3D class which implements a 3D two-phase (oil-water) black-oil flow...
TPZMaterialData::sol
TPZSolVec sol
vector of the solutions at the integration point
Definition: pzmaterialdata.h:77
Generated on Sun Aug 16 2020 11:17:03 for NeoPZ by   doxygen 1.8.13