/**
* @brief transform in low order Raviar Tomas
*/
void TPZCreateApproximationSpace::UndoMakeRaviartTomas(TPZCompMesh &cmesh)
{
int numcell = cmesh.NElements();
int el;
for (el = 0; el<numcell ; el++) {
TPZCompEl *cel = cmesh.ElementVec()[el];
TPZInterpolatedElement *intel = dynamic_cast<TPZInterpolatedElement *>(cel);
if (!intel) {
continue;
}
TPZGeoEl *gel = intel->Reference();
int geldim = gel->Dimension();
int is;
int nsides = gel->NSides();
for (is=0; is<nsides; is++) {
if (gel->SideDimension(is) != geldim-1) {
continue;
}
int nsconnects = intel->NSideConnects(is);
// only interested in HDiv elements
if (nsconnects != 1) {
continue;
}
// int cindex = intel->SideConnectIndex(0, is);
TPZConnect &c = intel->Connect(intel->SideConnectLocId(0,is));
if (c.HasDependency()) {
c.RemoveDepend();
}
}
}
cmesh.ExpandSolution();
cmesh.CleanUpUnconnectedNodes();
}
void TPZMGAnalysis::MeshError(TPZCompMesh *fine, TPZCompMesh *coarse, TPZVec<REAL> &ervec,
void (*f)(TPZVec<REAL> &loc, TPZVec<REAL> &val, TPZFMatrix<REAL> &deriv),TPZVec<REAL> &truervec){
coarse->Reference()->ResetReference();
coarse->LoadReferences();
int dim = fine->MaterialVec().begin()->second->Dimension();
ervec.Resize(coarse->NElements());
if(f) {
truervec.Resize(coarse->NElements());
truervec.Fill(0.,0);
}
ervec.Fill(0.,0);
TPZCompEl *cel;
TPZAdmChunkVector<TPZCompEl *> &elementvec = fine->ElementVec();
int numel = elementvec.NElements();
int el;
for(el=0; el<numel; el++) {
cel = elementvec[el];
if (!cel) continue;
TPZInterpolatedElement *cint = dynamic_cast<TPZInterpolatedElement *> (cel);
if(!cint) continue;
int ncon = cint->NConnects();
TPZGeoElSide gelside(cint->Reference(),ncon-1);
if(gelside.Dimension() != dim) continue;
TPZGeoElSide gellarge(gelside);
while(!gellarge.Reference().Exists() && gellarge.Father2().Exists()) gellarge = gellarge.Father2();
if(!gellarge.Reference().Exists()) {
cout << "TPZMGAnalsysis::BuildTransferMatrix element " << el << " found no corresponding element\n";
continue;
}
TPZCompElSide cellargeside = gellarge.Reference();
TPZCompEl *cellarge = cellargeside.Element();
TPZInterpolatedElement *cintlarge = (TPZInterpolatedElement *) cellarge;
TPZTransform transform(gelside.Dimension(),gellarge.Dimension());
gelside.SideTransform3(gellarge,transform);
int index = cellarge->Index();
REAL truerror = 0.;
ervec[index] += ElementError(cint,cintlarge,transform,f,truerror);
if(f) truervec[index] += truerror;
}
}
void TPZNonDarcyAnalysis::InitializeFirstSolution(TPZFMatrix<STATE> &Pressure, REAL &pini)
{
Pressure.Redim(fSolution.Rows(),fSolution.Cols());
TPZBlock<STATE> &block = this->Mesh()->Block();
int nel = this->Mesh()->NElements();
for (int iel = 0 ; iel < nel ; iel++){
TPZCompEl *cel = this->Mesh()->ElementVec()[iel];
if (!cel) continue;
TPZInterpolatedElement *intel = dynamic_cast <TPZInterpolatedElement *> (cel);
if (!intel) DebugStop();
if (intel->Reference()->Dimension() != 2) continue; //soh elem 2d.
int ncc = intel->NCornerConnects();
//if (ncc != 4) DebugStop(); // I expect only quad element, althought it would work for triang
for (int icc = 0 ; icc < ncc ; icc++){
TPZConnect *con = &intel->Connect(icc);
int conseq = con->SequenceNumber();
int pos = block.Position(conseq);
Pressure(pos,0) = pini;
}
}
}
void TPZAdaptMesh::DeleteElements(TPZCompMesh *mesh)
{
int nelem = mesh->NElements();
int iel;
for(iel=0; iel<nelem; iel++) {
TPZCompEl *cel = mesh->ElementVec()[iel];
if(!cel) continue;
TPZInterpolatedElement *cint = dynamic_cast<TPZInterpolatedElement *> (cel);
if(!cint) continue;
while(cint->HasDependency()) {
TPZInterpolatedElement *large = LargeElement(cint);
TPZInterpolatedElement *nextlarge = LargeElement(large);
while(nextlarge != large) {
large = nextlarge;
nextlarge = LargeElement(large);
}
large->RemoveSideRestraintsII(TPZInterpolatedElement::EDelete);
delete large;
}
cint->RemoveSideRestraintsII(TPZInterpolatedElement::EDelete);
delete cint;
}
}
/**
* @brief transform in low order Raviar Tomas
*/
void TPZCreateApproximationSpace::MakeRaviartTomas(TPZCompMesh &cmesh)
{
int numcell = cmesh.NElements();
int el;
for (el = 0; el<numcell ; el++) {
TPZCompEl *cel = cmesh.ElementVec()[el];
TPZInterpolationSpace *intel = dynamic_cast<TPZInterpolationSpace *>(cel);
if (!intel) {
continue;
}
intel->SetPreferredOrder(1);
}
cmesh.ExpandSolution();
for (el = 0; el<numcell ; el++) {
TPZCompEl *cel = cmesh.ElementVec()[el];
TPZInterpolatedElement *intel = dynamic_cast<TPZInterpolatedElement *>(cel);
if (!intel) {
continue;
}
TPZGeoEl *gel = intel->Reference();
int geldim = gel->Dimension();
int is;
int nsides = gel->NSides();
for (is=0; is<nsides; is++) {
if (gel->SideDimension(is) != geldim-1) {
continue;
}
int nsconnects = intel->NSideConnects(is);
// only interested in HDiv elements
if (nsconnects != 1) {
continue;
}
int cindex = intel->SideConnectIndex(0, is);
TPZConnect &c = intel->Connect(intel->SideConnectLocId(0,is));
if (c.HasDependency()) {
continue;
}
int nshape = 1;
int nstate = 1;
int order = 0;
int cindex2 = cmesh.AllocateNewConnect(nshape, nstate, order);
// TPZConnect &c2 = cmesh.ConnectVec()[cindex];
TPZFNMatrix<2> depmat(2,1,1.);
c.AddDependency(cindex, cindex2, depmat, 0, 0, 2, 1);
}
}
cmesh.ExpandSolution();
}
TPZCompMesh *TPZMGAnalysis::UniformlyRefineMesh(TPZCompMesh *mesh, bool withP) {
TPZGeoMesh *gmesh = mesh->Reference();
if(!gmesh) {
cout << "TPZMGAnalysis::UniformlyRefineMesh encountered no geometric mesh\n";
return 0;
}
gmesh->ResetReference();
TPZCompMesh *cmesh = new TPZCompMesh(gmesh);
mesh->CopyMaterials(*cmesh);
TPZAdmChunkVector<TPZCompEl *> &elementvec = mesh->ElementVec();
int el,nelem = elementvec.NElements();
for(el=0; el<nelem; el++) {
TPZCompEl *cel = elementvec[el];
if(!cel) continue;
TPZInterpolatedElement *cint = dynamic_cast<TPZInterpolatedElement *> (cel);
if(!cint) {
cout << "TPZMGAnalysis::UniformlyRefineMesh encountered a non interpolated element\n";
continue;
}
int ncon = cint->NConnects();
int porder = cint->PreferredSideOrder(ncon-1);
TPZGeoEl *gel = cint->Reference();
if(!gel) {
cout << "TPZMGAnalysis::UniformlyRefineMesh encountered an element without geometric reference\n";
continue;
}
TPZVec<TPZGeoEl *> sub;
gel->Divide(sub);
int nsub = sub.NElements();
int isub;
int celindex;
for(isub=0; isub<nsub; isub++) {
TPZInterpolatedElement *csint;
csint = (TPZInterpolatedElement *) cmesh->CreateCompEl(sub[isub],celindex);
if(withP) csint->PRefine(porder+1);
else csint->PRefine(porder);
}
}
return cmesh;
}
int CompareShapeFunctions(TPZCompElSide celsideA, TPZCompElSide celsideB)
{
TPZGeoElSide gelsideA = celsideA.Reference();
TPZGeoElSide gelsideB = celsideB.Reference();
int sideA = gelsideA.Side();
int sideB = gelsideB.Side();
TPZCompEl *celA = celsideA.Element();
TPZCompEl *celB = celsideB.Element(); TPZMultiphysicsElement *MFcelA = dynamic_cast<TPZMultiphysicsElement *>(celA);
TPZMultiphysicsElement *MFcelB = dynamic_cast<TPZMultiphysicsElement *>(celB);
TPZInterpolatedElement *interA = dynamic_cast<TPZInterpolatedElement *>(MFcelA->Element(0));
TPZInterpolatedElement *interB = dynamic_cast<TPZInterpolatedElement *>(MFcelB->Element(0));
TPZMaterialData dataA;
TPZMaterialData dataB;
interA->InitMaterialData(dataA);
interB->InitMaterialData(dataB);
TPZTransform<> tr = gelsideA.NeighbourSideTransform(gelsideB);
TPZGeoEl *gelA = gelsideA.Element();
TPZTransform<> trA = gelA->SideToSideTransform(gelsideA.Side(), gelA->NSides()-1);
TPZGeoEl *gelB = gelsideB.Element();
TPZTransform<> trB = gelB->SideToSideTransform(gelsideB.Side(), gelB->NSides()-1);
int dimensionA = gelA->Dimension();
int dimensionB = gelB->Dimension();
int nSideshapeA = interA->NSideShapeF(sideA);
int nSideshapeB = interB->NSideShapeF(sideB);
int is;
int firstShapeA = 0;
int firstShapeB = 0;
for (is=0; is<sideA; is++) {
firstShapeA += interA->NSideShapeF(is);
}
for (is=0; is<sideB; is++) {
firstShapeB += interB->NSideShapeF(is);
}
TPZIntPoints *intrule = gelA->CreateSideIntegrationRule(gelsideA.Side(), 4);
int nwrong = 0;
int npoints = intrule->NPoints();
int ip;
for (ip=0; ip<npoints; ip++) {
TPZManVector<REAL,3> pointA(gelsideA.Dimension()),pointB(gelsideB.Dimension()), pointElA(gelA->Dimension()),pointElB(gelB->Dimension());
REAL weight;
intrule->Point(ip, pointA, weight);
int sidedim = gelsideA.Dimension();
TPZFNMatrix<9> jacobian(sidedim,sidedim),jacinv(sidedim,sidedim),axes(sidedim,3);
REAL detjac;
gelsideA.Jacobian(pointA, jacobian, jacinv, detjac, jacinv);
TPZManVector<REAL,3> normal(3,0.), xA(3),xB(3);
normal[0] = axes(0,1);
normal[1] = -axes(0,0);
tr.Apply(pointA, pointB);
trA.Apply(pointA, pointElA);
trB.Apply(pointB, pointElB);
gelsideA.Element()->X(pointElA, xA);
gelsideB.Element()->X(pointElB, xB);
for (int i=0; i<3; i++) {
if(fabs(xA[i]- xB[i])> 1.e-6) DebugStop();
}
int nshapeA = 0, nshapeB = 0;
interA->ComputeRequiredData(dataA, pointElA);
interB->ComputeRequiredData(dataB, pointElB);
nshapeA = dataA.phi.Rows();
nshapeB = dataB.phi.Rows();
if(nSideshapeA != nSideshapeB) DebugStop();
TPZManVector<REAL> shapesA(nSideshapeA), shapesB(nSideshapeB);
int nwrongkeep(nwrong);
int i,j;
for(i=firstShapeA,j=firstShapeB; i<firstShapeA+nSideshapeA; i++,j++)
{
int Ashapeind = i;
int Bshapeind = j;
int Avecind = -1;
int Bvecind = -1;
// if A or B are boundary elements, their shapefunctions come in the right order
if (dimensionA != sidedim) {
Ashapeind = dataA.fVecShapeIndex[i].second;
Avecind = dataA.fVecShapeIndex[i].first;
}
if (dimensionB != sidedim) {
Bshapeind = dataB.fVecShapeIndex[j].second;
Bvecind = dataB.fVecShapeIndex[j].first;
}
if (dimensionA != sidedim && dimensionB != sidedim) {
// vefify that the normal component of the normal vector corresponds
Avecind = dataA.fVecShapeIndex[i].first;
Bvecind = dataB.fVecShapeIndex[j].first;
REAL vecnormalA = dataA.fNormalVec(0,Avecind)*normal[0]+dataA.fNormalVec(1,Avecind)*normal[1];
REAL vecnormalB = dataB.fNormalVec(0,Bvecind)*normal[0]+dataB.fNormalVec(1,Bvecind)*normal[1];
if(fabs(vecnormalA-vecnormalB) > 1.e-6)
{
nwrong++;
LOGPZ_ERROR(logger, "normal vectors aren't equal")
}
}
shapesA[i-firstShapeA] = dataA.phi(Ashapeind,0);
shapesB[j-firstShapeB] = dataB.phi(Bshapeind,0);
REAL valA = dataA.phi(Ashapeind,0);
REAL valB = dataB.phi(Bshapeind,0);
REAL diff = valA-valB;
REAL decision = fabs(diff)-1.e-6;
if(decision > 0.)
{
nwrong ++;
std::cout << "valA = " << valA << " valB = " << valB << " Avecind " << Avecind << " Bvecind " << Bvecind <<
" Ashapeind " << Ashapeind << " Bshapeind " << Bshapeind <<
" sideA " << sideA << " sideB " << sideB << std::endl;
LOGPZ_ERROR(logger, "shape function values are different")
}
void InputDataStruct::UpdateLeakoff(TPZCompMesh * cmesh)
{
#ifdef PZDEBUG
if(fLeakoffmap.size() == 0)
{//Se a fratura nao alcancou ainda a regiao elastica 2, este mapa estah vazio!!!
//DebugStop();
}
#endif
std::map<int,REAL>::iterator it;
int outVlCount = 0;
for(int i = 0; i < cmesh->ElementVec().NElements(); i++)
{
///////////////////////
TPZCompEl * cel = cmesh->ElementVec()[i];
#ifdef PZDEBUG
if(!cel)
{
DebugStop();
}
#endif
TPZGeoEl * gel = cel->Reference();
if(gel->Dimension() != 1)
{
continue;
}
TPZInterpolatedElement * sp = dynamic_cast <TPZInterpolatedElement*> (cel);
if(!sp)
{
continue;
}
it = globFractInputData.GetLeakoffmap().find(gel->Id());
if(it == globFractInputData.GetLeakoffmap().end())
{
continue;
}
TPZVec<REAL> qsi(1,0.);
cel->Reference()->CenterPoint(cel->Reference()->NSides()-1, qsi);
TPZMaterialData data;
sp->InitMaterialData(data);
sp->ComputeShape(qsi, data);
sp->ComputeSolution(qsi, data);
REAL pfrac = data.sol[0][0];
///////////////////////
REAL deltaT = globFractInputData.actDeltaT();
REAL VlAcum = it->second;
REAL tStar = FictitiousTime(VlAcum, pfrac);
REAL Vlnext = VlFtau(pfrac, tStar + deltaT);
if (fusingLeakOff) {
it->second = Vlnext;
}
else{
it->second = 0.;
}
outVlCount++;
}
#ifdef PZDEBUG
if(outVlCount < globFractInputData.GetLeakoffmap().size())
{
DebugStop();
}
#endif
}
//void DivideRecursive(TPZCompEl *locel,int index,TPZVec<int> indexsubs,int hn);
void TPZAnalysisError::HPAdapt(REAL CurrentEtaAdmissible, std::ostream &out) {
arq << "CurrentEtaAdmissible " << CurrentEtaAdmissible << endl;
TPZAdmChunkVector<TPZCompEl *>&listel = Mesh()->ElementVec();
bool store_error = false;
EvaluateError(CurrentEtaAdmissible,store_error, out);
TPZVec<TPZCompElSide> SingLocal(fSingular);
fSingular.Resize(0);
int64_t nel = fElIndexes.NElements();
for(int64_t ielloc=0;ielloc<nel;ielloc++) {
int64_t iel = fElIndexes[ielloc];
// if the element has already been treated (e.g. singularity) skip the process
if(iel == -1) continue;
TPZInterpolatedElement *elem = (TPZInterpolatedElement *) listel[iel];
if(!elem || elem->Material()->Id() < 0) {
PZError << "TPZAnalysisError::HPAdapt boundary element with error?\n";
PZError.flush();
continue;
}
REAL csi = fElErrors[ielloc] / fAdmissibleError;
// Verificar se o element atual e um elemento singular
int64_t ising, nsing = SingLocal.NElements();
for(ising=0; ising<nsing; ising++) {
if(elem == SingLocal[ising].Element()) {
ZoomInSingularity(csi,SingLocal[ising]);
break;
}
}
// Go to the end of the loop if the element was handled by the singularity
if(ising < nsing) continue;
//calculo da ordem pn do elemento atual
int nsides = elem->Reference()->NSides();
REAL pFo = double(elem->EffectiveSideOrder(nsides-1));//quadrilatero
// Newton's Method -> compute pNew
REAL pFn = pFo, res = 10.0, phi, del, dph, tol = 0.001;
int64_t MaxIter = 100; int64_t iter=0;
while (iter < MaxIter && res > tol) {
phi = pFo+log(csi)-pFo*log(pFn/pFo);
dph = pFn/(pFo+pFn);
del = dph*(phi-pFn);
if (del+pFn <= 0.0) // caiu fora do intervalo!
del = 0.5 - pFn;
res = fabs(del);
pFn = del+pFn;
iter++;
} // end of Newton's Method
if (iter == MaxIter)
PZError << "\n - Newton's Method Failed at Element = " << elem->Reference()->Id() << endl;
if(pFn < 1.) pFn = 1.;
REAL factor = pow(csi,-1.0/pFn)*(pow(pFn/pFo,pFo/pFn));
if(factor <= 0.75)
factor = 0.5; // refine h
else factor = 1.0; // don't refine h
// Newton's Method -> compute once again pNew
pFn = pFo; iter = 0; res = 10.0;
while (iter < MaxIter && res > tol) {
phi = -pFn*log(factor)-log(csi)+pFo*log(pFn/pFo);
dph = pFn/(pFo-pFn*log(factor));
del = -dph*phi;
if (del+pFn <= 0.0) // caiu fora do intervalo!
del = 0.5 - pFn;
res = fabs(del);
pFn = del+pFn;
iter++;
} // end of Newton's Method
if (iter == MaxIter)
PZError << "\n - Newton's Method Failed at Element = " << elem->Reference()->Id() << endl;
if(pFn < 1.) pFn = 1.;
int pNew = 0;//(int) floor(pFn + 0.5); // get the integer
while(REAL(pNew) < (pFn+0.5)) pNew++;
TPZVec<REAL> x(3),cs(2,0.);
elem->Reference()->X(cs,x);
elem->PRefine(pNew);
TPZCompEl *locel = elem;
//Divide elements
if(factor == 0.5 ) {
TPZVec<int64_t> indexsubs;
int64_t index = locel->Index();
elem->Divide(index,indexsubs,1);
}
}
}
//SingularElements(..)
void TPZAnalysisError::ZoomInSingularity(REAL csi, TPZCompElSide elside, REAL singularity_strength) {
REAL hn = 1./pow(csi,1./singularity_strength);
REAL Q=2.;
REAL NcReal = log( 1.+(1./hn - 1.)*(Q - 1.) )/log(Q);
int Nc = 0;
while(REAL(Nc) < (NcReal+0.5)) Nc++;
int minporder = 2;
TPZStack<TPZCompElSide> ElToRefine;
TPZStack<int> POrder;
TPZStack<TPZGeoElSide> subelements;
TPZStack<int64_t> csubindex;
ElToRefine.Push(elside);
POrder.Push(Nc);
while(ElToRefine.NElements()) {
/** Take the next element and its interpolation order from the stack*/
TPZCompElSide curelside = ElToRefine.Pop();
int curporder = POrder.Pop();
if(!curelside.Exists()) continue;
int64_t cindex = curelside.Element()->Index();
if(cindex < 0) continue;
/** Cast the element to an interpolated element if possible*/
TPZCompEl *cel = curelside.Element();
TPZInterpolatedElement *cintel = 0;
cintel = dynamic_cast<TPZInterpolatedElement *> (cel);
/** If the element is not interpolated, nothing to do */
if(!cintel) continue;
/** Set the interpolation order of the current element to curporder*/
if(curporder == minporder) {
cintel->PRefine(Nc);
fSingular.Push(curelside);
} else {
cintel->PRefine(curporder);
cintel->Divide(cindex,csubindex,1);
/** Identify the subelements along the side and push them on the stack*/
}
TPZGeoElSide gelside = curelside.Reference();
if(!gelside.Exists()) continue;
gelside.GetSubElements2(subelements);
int64_t ns = subelements.NElements();
curporder--;
int64_t is;
for(is=0; is<ns; is++) {
TPZGeoElSide sub = subelements[is];
TPZCompElSide csub = sub.Reference();
if(csub.Exists()) {
ElToRefine.Push(csub);
POrder.Push(curporder);
}
}
}
ExpandConnected(fSingular);
/*
REAL H1_error,L2_error,estimate;
TPZBlock *flux=0;
int64_t nel = fElIndexes.NElements();
for(int64_t elloc=0;elloc<nel;elloc++) {
int64_t el = fElIndexes[elloc];
estimate = fElErrors[elloc];
REAL csi = estimate / fAdmissibleError;
REAL h = h_Parameter(intellist[el]);
REAL hn = h/pow(csi,1./.9);
REAL Nc = log( 1.+(h/hn - 1.)*(Q - 1.) )/log(Q);
if(hn > 1.3*h) hn = 2.0*h*hn / (h + hn);
REAL hsub = h;//100.0;//pode ser = h ; Cedric
TPZCompEl *locel = intellist[el];
//obter um subelemento que contem o ponto singular e tem tamanho <= hn
TPZAdmChunkVector<TPZCompEl *> sublist;
while(hsub > hn) {
TPZVec<int64_t> indexsubs;
int64_t index = locel->Index();
locel->Divide(index,indexsubs,1);
int64_t nsub = indexsubs.NElements();
TPZAdmChunkVector<TPZCompEl *> listsub(0);
for(int64_t k=0;k<nsub;k++) {
index = listsub.AllocateNewElement();
listsub[index] = Mesh()->ElementVec()[indexsubs[k]];
}
//existe um unico filho que contem o ponto singular
SingularElement(point,listsub,sublist);
hsub = h_Parameter(sublist[0]);
}
TPZInterpolatedElement *intel = (TPZInterpolatedElement *) locel;
intel->PRefine(Nc+1);
indexlist.Push(intel->Index());
//os elemento viz devem ter ordens menores a cel quanto mais longe de point
TPZInterpolatedElement *neighkeep,*neigh;
//feito s�para o caso 1d , extender para o caso geral
int dim = intel->Dimension();
if(dim != 1) {
cout << "TPZAnalysisError::Step3 not dimension implemented , dimension = " << intellist[el]->Dimension() << endl;
return ;//exit(1);
}
for(int side=0;side<2;side++) {
int ly = 1;
TPZGeoElSide neighside = intel->Reference()->Neighbour(side);
TPZGeoElSide neighsidekeep = neighside;
TPZCompElSide neighsidecomp(0,0);
TPZStack<TPZCompElSide> elvec(0);
TPZCompElSide thisside(intel,side);
if(!neighsidekeep.Exists()) thisside.HigherLevelElementList(elvec,1,1);
if(!neighsidekeep.Exists() && elvec.NElements() == 0) {
neighsidekeep = thisside.LowerLevelElementList(1).Reference();
} else if(elvec.NElements() != 0) {
neighsidekeep = elvec[0].Reference();
}
while(ly < (Nc+1) && neighsidekeep.Exists() && neighsidekeep.Element()->Reference()->Material()->Id() > -1) {
neigh = (TPZInterpolatedElement *) neighsidekeep.Element()->Reference();
if(neigh) {
neigh->PRefine(ly);
int otherside = (neighsidekeep.Side()+1)%2;
neighsidekeep.SetSide(otherside);
indexlist.Push(neighsidekeep.Reference().Element()->Index());
}
neighside = neighsidekeep.Neighbour();
while(!neighside.Exists()) {
neighsidecomp = neighsidekeep.Reference();
neighsidecomp.HigherLevelElementList(elvec,1,1);
if(elvec.NElements()) {
neighside = elvec[0].Reference();
break;
}
neighside = neighsidecomp.LowerLevelElementList(1).Reference();
if(!neighside.Exists()) break;
}
neighsidekeep = neighside;
ly++;
}
}
}//for
Mesh()->InitializeBlock();
*/
}
TPZFlowCompMesh * RSNACompMesh(TPZFlowCompMesh *cmesh, REAL CFL, REAL delta,
int degree, int nSubdiv,
TPZArtDiffType DiffType,
TPZTimeDiscr Diff_TD,
TPZTimeDiscr ConvVol_TD,
TPZTimeDiscr ConvFace_TD)
{
TPZCompEl::SetgOrder(degree);
REAL gamma = 1.4;
// Configuring the PZ to generate discontinuous elements
// TPZGeoElement<TPZShapeQuad,TPZGeoQuad,TPZRefQuad>
// ::SetCreateFunction(TPZCompElDisc::CreateDisc);
//
// TPZGeoElement<TPZShapeLinear,TPZGeoLinear,TPZRefLinear>
// ::SetCreateFunction(TPZCompElDisc::CreateDisc);
int dim = 2;
// int interfdim = dim -1;
// TPZCompElDisc::gInterfaceDimension = interfdim;
// Retrieving the point coordinates and element references
TPZVec< TPZVec< REAL > > nodes;
TPZVec< TPZVec< int64_t > > elms;
TPZVec< TPZGeoEl *> gElem;
RSNAMeshPoints(nodes, elms);
// Creating the geometric mesh
TPZGeoMesh * gmesh = CreateRSNAGeoMesh(cmesh->Reference(), nodes, elms, EQuadrilateral, 1, gElem, nSubdiv);
//TPZFlowCompMesh * cmesh = new TPZFlowCompMesh(gmesh);
cmesh->SetDimModel(2);
// Creating the materials
TPZEulerConsLaw * matp = new TPZEulerConsLaw(1/*nummat*/,
0/*timeStep*/,
gamma /*gamma*/,
2 /* dim*/,
DiffType);
// Setting initial solution
matp->SetForcingFunction(NULL);
// Setting the time discretization method
matp->SetTimeDiscr(Diff_TD,
ConvVol_TD,
ConvFace_TD);
//mat->SetDelta(0.1); // Not necessary, since the artDiff
// object computes the delta when it equals null.
matp->SetCFL(CFL);
/*
REAL us = sqrt(2.6 * 2.6 + .51 * .51);
REAL press = 1.52819;
REAL cspeed = sqrt(1.4*press/1.7);
REAL lambdaMax = us + cspeed;
*/
// cout << .22/(2/**lambdaMax*/);
matp->SetDelta(delta);
TPZMaterial * mat(matp);
cmesh -> InsertMaterialObject(mat);
// Boundary conditions
TPZMaterial *bc;
TPZFMatrix<STATE> val1(4,4), val2(4,1);
REAL ro = 1.7,
u = 2.61934,
v = -0.50632,
p = 1.52819,
vel2 = u*u + v*v;
// copiado do Cedric
//CC ARESTA INFERIOR : PAREDE
val1.Zero();
val2.Zero();
TPZGeoElBC((TPZGeoEl *)gElem[0],4,-1);
TPZGeoElBC((TPZGeoEl *)gElem[1],4,-1);
bc = mat->CreateBC(mat,-1,5,val1,val2);
cmesh->InsertMaterialObject(bc);
//CC ARESTA DIREITA : OUTFLOW
val1.Zero();
val2.Zero();
TPZGeoElBC((TPZGeoEl *)gElem[1],5,-2);
bc = mat->CreateBC(mat,-2,4,val1,val2);
cmesh->InsertMaterialObject(bc);
//CC ARESTA SUPERIOR : DIRICHLET
val1.Zero();
val2.Zero();
val2(0,0) = ro;
val2(1,0) = ro * u;
val2(2,0) = ro * v;
val2(3,0) = p/(gamma-1.0) + 0.5 * ro * vel2;
TPZGeoElBC((TPZGeoEl *)gElem[0],6,-3);
TPZGeoElBC((TPZGeoEl *)gElem[1],6,-3);
bc = mat->CreateBC(mat,-3,3,val1,val2);
cmesh->InsertMaterialObject(bc);
//CC ARESTA ESQUERDA : INFLOW
val1.Zero();
val2.Zero();
ro = 1.0;
u = 2.9;
v = 0.0;
p = 0.714286;
val2(0,0) = ro;
val2(1,0) = ro * u;
val2(2,0) = ro * v;
vel2 = u*u+v*v;
val2(3,0) = p/(gamma-1.0) + 0.5 * ro * vel2;
TPZGeoElBC((TPZGeoEl *)gElem[0],7,-4);
bc = mat->CreateBC(mat,-4,3,val1,val2);
cmesh->InsertMaterialObject(bc);
cmesh->AutoBuild();
cmesh->AdjustBoundaryElements();
// printing meshes
ofstream geoOut("geomesh.out");
gmesh->Print(geoOut);
geoOut.close();
ofstream compOut("compmesh.out");
cmesh->Print(compOut);
compOut.close();
// generating initial guess for the mesh solution
TPZFMatrix<STATE> Solution = cmesh->Solution();
int nVars = Solution.Rows();
for(int k = 0; k < nVars; k++)Solution(k)=.1;
int nel = cmesh->NElements();
int iel;
for(iel=0; iel<nel; iel++)
{
TPZCompEl *cel = cmesh->ElementVec()[iel];
TPZInterpolatedElement *intel = dynamic_cast<TPZInterpolatedElement *>(cel);
TPZCompElDisc *disc = dynamic_cast<TPZCompElDisc *>(cel);
if(intel)
{
int nnodes = intel->Reference()->NNodes();
int in;
for(in = 0; in<nnodes; in++)
{
int blnum = intel->SideConnect(0,in).SequenceNumber();
int blockOffset = cmesh->Block().Position(blnum);
REAL ro = 1.7,
u = 2.9,
v = 0,
p = 2.714286,
vel2 = u*u + v*v;
Solution(blockOffset ,0) = ro;
Solution(blockOffset+1,0) = ro * u;
Solution(blockOffset+2,0) = ro * v;
Solution(blockOffset+3,0) = p/(gamma-1.0) + 0.5 * ro * vel2;
}
} else if(disc)
{
int conind = disc->ConnectIndex();
// skip boundary elements
if(conind < 0) continue;
int blnum = cmesh->ConnectVec()[conind].SequenceNumber();
int blpos = cmesh->Block().Position(blnum);
int blsize = cmesh->Block().Size(blnum);
int blockOffset = blpos+blsize-(dim+2);
REAL ro = 1.7,
u = 2.9,
v = 0,
p = 2.714286,
vel2 = u*u + v*v;
Solution(blockOffset ,0) = ro;
Solution(blockOffset+1,0) = ro * u;
Solution(blockOffset+2,0) = ro * v;
Solution(blockOffset+3,0) = p/(gamma-1.0) + 0.5 * ro * vel2;
}
}
/* int j, NSolutionBlocks;
//TPZBlock * pBlock = cmesh->Block();
NSolutionBlocks = cmesh->Block().NBlocks();
int nShape = Solution.Rows() / NSolutionBlocks / (dim + 2);
int lastShapeFun = (nShape - 1)*(dim+2);
for(j = 0; j < NSolutionBlocks; j++)
{
int blockOffset = cmesh->Block().Position(j) + lastShapeFun;
REAL ro = 1.7,
u = 2.9,
v = 0,
p = 2.714286,
vel2 = u*u + v*v;
Solution(blockOffset ,0) = ro;
Solution(blockOffset+1,0) = ro * u;
Solution(blockOffset+2,0) = ro * v;
Solution(blockOffset+3,0) = p/(gamma-1.0) + 0.5 * ro * vel2;
}*/
cmesh->LoadSolution(Solution);
return cmesh;
}
TPZCompMesh *TPZAdaptMesh::CreateCompMesh (TPZCompMesh *mesh, //malha a refinar
TPZVec<TPZGeoEl *> &gelstack, //
TPZVec<int> &porders) {
//Cria um ponteiro para a malha geom�trica de mesh
TPZGeoMesh *gmesh = mesh->Reference();
if(!gmesh) {
cout << "TPZAdaptMesh::CreateCompMesh encountered no geometric mesh\n";
return 0;
}
//Reseta as refer�ncias do ponteiro para a malha geom�trica criada
//e cria uma nova malha computacional baseada nesta malha geom�trica
gmesh->ResetReference();
TPZCompMesh *cmesh = new TPZCompMesh(gmesh);
// int nmat = mesh->MaterialVec().size();
// int m;
//Cria um clone do vetor de materiais da malha mesh
mesh->CopyMaterials(*cmesh);
/* for(m=0; m<nmat; m++) {
TPZMaterial * mat = mesh->MaterialVec()[m];
if(!mat) continue;
mat->Clone(cmesh->MaterialVec());
}
*/
//Idenifica o vetor de elementos computacionais de mesh
// TPZAdmChunkVector<TPZCompEl *> &elementvec = mesh->ElementVec();
int el,nelem = gelstack.NElements();
// cmesh->SetName("Antes PRefine");
// cmesh->Print(cout);
for(el=0; el<nelem; el++) {
//identifica os elementos geom�tricos passados em gelstack
TPZGeoEl *gel = gelstack[el];
if(!gel) {
cout << "TPZAdaptMesh::CreateCompMesh encountered an null element\n";
continue;
}
long celindex;
//Cria um TPZIntel baseado no gel identificado
TPZInterpolatedElement *csint;
csint = dynamic_cast<TPZInterpolatedElement *> (cmesh->CreateCompEl(gel,celindex));
if(!csint) continue;
//Refina em p o elemento criado
// cmesh->SetName("depois criar elemento");
// cmesh->Print(cout);
csint->PRefine(porders[el]);
// cmesh->SetName("depois prefine no elemento");
// cmesh->Print(cout);
}
#ifndef CLONEBCTOO
nelem = gmesh->NElements();
for (el=0; el<nelem; el++) {
TPZGeoEl *gel = gmesh->ElementVec()[el];
if (!gel || gel->Reference()) {
continue;
}
int matid = gel->MaterialId();
if (matid < 0) {
TPZStack<TPZCompElSide> celstack;
int ns = gel->NSides();
TPZGeoElSide gelside(gel,ns-1);
gelside.HigherLevelCompElementList2(celstack, 1, 1);
if (celstack.size()) {
TPZStack<TPZGeoEl *> subels;
gel->Divide(subels);
}
}
}
nelem = gmesh->NElements();
for (el=0; el<nelem; el++) {
TPZGeoEl *gel = gmesh->ElementVec()[el];
if (!gel || gel->Reference()) {
continue;
}
int matid = gel->MaterialId();
if (matid < 0) {
TPZStack<TPZCompElSide> celstack;
int ns = gel->NSides();
TPZGeoElSide gelside(gel,ns-1);
gelside.EqualLevelCompElementList(celstack, 1, 0);
if (celstack.size()) {
long index;
cmesh->CreateCompEl(gel, index);
}
}
}
#endif
//Mais einh!!
// cmesh->SetName("Antes Adjust");
// cmesh->Print(cout);
cmesh->AdjustBoundaryElements();
// cmesh->SetName("Depois");
// cmesh->Print(cout);
return cmesh;
}
