inline void EulerUpstream<GI, RP, BC>::initObj(const GI& g, const RP& r, const BC& b)
{
residual_computer_.initObj(g, r, b);
porevol_.resize(g.numberOfCells());
for (CIt c = g.cellbegin(); c != g.cellend(); ++c) {
porevol_[c->index()] = c->volume()*r.porosity(c->index());
}
}
inline void EulerUpstreamImplicit<GI, RP, BC>::initObj(const GI& g, const RP& r, const BC& b)
{
//residual_computer_.initObj(g, r, b);
mygrid_.init(g.grid());
porevol_.resize(mygrid_.numCells());
for (int i = 0; i < mygrid_.numCells(); ++i){
porevol_[i]= mygrid_.cellVolume(i)*r.porosity(i);
}
// int numf=mygrid_.numFaces();
int num_cells = mygrid_.numCells();
int ngconn = mygrid_.c_grid()->cell_facepos[num_cells];
//std::vector<double> htrans_(ngconn);
htrans_.resize(ngconn);
const double* perm = &(r.permeability(0)(0,0));
tpfa_htrans_compute(mygrid_.c_grid(), perm, &htrans_[0]);
// int count = 0;
myrp_= r;
typedef typename GI::CellIterator CIt;
typedef typename CIt::FaceIterator FIt;
std::vector<FIt> bid_to_face;
int maxbid = 0;
for (CIt c = g.cellbegin(); c != g.cellend(); ++c) {
for (FIt f = c->facebegin(); f != c->faceend(); ++f) {
int bid = f->boundaryId();
maxbid = std::max(maxbid, bid);
}
}
bid_to_face.resize(maxbid + 1);
std::vector<int> egf_cf(mygrid_.numFaces());
int cix=0;
for (CIt c = g.cellbegin(); c != g.cellend(); ++c) {
int loc_fix=0;
for (FIt f = c->facebegin(); f != c->faceend(); ++f) {
if (f->boundary() && b.satCond(*f).isPeriodic()) {
bid_to_face[f->boundaryId()] = f;
}
int egf=f->index();
int cf=mygrid_.cellFace(cix,loc_fix);
egf_cf[egf]=cf;
loc_fix+=1;
}
cix+=1;
}
#ifndef NDEBUG
const UnstructuredGrid& c_grid=*mygrid_.c_grid();
#endif
int hf_ind=0;
int bf_ind=0;
periodic_cells_.resize(0);
periodic_faces_.resize(0);
periodic_hfaces_.resize(0);
periodic_nbfaces_.resize(0);
//cell1 = cell0;
direclet_cells_.resize(0);
direclet_sat_.resize(0);
direclet_sat_.resize(0);
direclet_hfaces_.resize(0);
assert(periodic_cells_.size()==0);
for (CIt c = g.cellbegin(); c != g.cellend(); ++c) {
int cell0 = c->index();
for (FIt f = c->facebegin(); f != c->faceend(); ++f) {
// Neighbour face, will be changed if on a periodic boundary.
// Compute cell[1], cell_sat[1]
FIt nbface = f;
if (f->boundary()) {
bf_ind+=1;
if (b.satCond(*f).isPeriodic()) {
nbface = bid_to_face[b.getPeriodicPartner(f->boundaryId())];
assert(nbface != f);
int cell1 = nbface->cellIndex();
assert(cell0 != cell1);
int f_ind=f->index();
int fn_ind=nbface->index();
// mapping face indices
f_ind=egf_cf[f_ind];
fn_ind=egf_cf[fn_ind];
assert((c_grid.face_cells[2*f_ind]==-1) || (c_grid.face_cells[2*f_ind+1]==-1));
assert((c_grid.face_cells[2*fn_ind]==-1) || (c_grid.face_cells[2*fn_ind+1]==-1));
assert((c_grid.face_cells[2*f_ind]==cell0) || (c_grid.face_cells[2*f_ind+1]==cell0));
assert((c_grid.face_cells[2*fn_ind]==cell1) || (c_grid.face_cells[2*fn_ind+1]==cell1));
periodic_cells_.push_back(cell0);
periodic_cells_.push_back(cell1);
periodic_faces_.push_back(f_ind);
periodic_hfaces_.push_back(hf_ind);
periodic_nbfaces_.push_back(fn_ind);
} else if (!( b.flowCond(*f).isNeumann() && b.flowCond(*f).outflux() == 0.0)) {
//cell1 = cell0;
direclet_cells_.push_back(cell0);
direclet_sat_.push_back(b.satCond(*f).saturation());
direclet_sat_.push_back(1-b.satCond(*f).saturation());//only work for 2 phases
direclet_hfaces_.push_back(hf_ind);
}
}
hf_ind+=1;
}
}
mygrid_.makeQPeriodic(periodic_hfaces_,periodic_cells_);
// use fractional flow instead of saturation as src
TwophaseFluid myfluid(myrp_);
int num_b=direclet_cells_.size();
for(int i=0; i <num_b; ++i){
std::array<double,2> sat = {{direclet_sat_[2*i] ,direclet_sat_[2*i+1] }};
std::array<double,2> mob;
std::array<double,2*2> dmob;
myfluid.mobility(direclet_cells_[i], sat, mob, dmob);
double fl = mob[0]/(mob[0]+mob[1]);
direclet_sat_[2*i] = fl;
direclet_sat_[2*i+1] = 1-fl;
}
}
