void UniformRefinement(TPZGeoMesh *gMesh, int nh)
{
for ( int ref = 0; ref < nh; ref++ ){
TPZVec<TPZGeoEl *> filhos;
int64_t n = gMesh->NElements();
for ( int64_t i = 0; i < n; i++ ){
TPZGeoEl * gel = gMesh->ElementVec() [i];
if (gel->Dimension() == 2 || gel->Dimension() == 1) gel->Divide (filhos);
}//for i
}//ref
}
void RefinamentoUniforme(TPZAutoPointer<TPZGeoMesh> gmesh, int nref,TPZVec<int> dims)
{
int ir, iel, k;
int nel=0, dim=0;
int ndims = dims.size();
for(ir = 0; ir < nref; ir++ )
{
TPZVec<TPZGeoEl *> filhos;
nel = gmesh->NElements();
for (iel = 0; iel < nel; iel++ )
{
TPZGeoEl * gel = gmesh->ElementVec()[iel];
if(!gel) DebugStop();
dim = gel->Dimension();
for(k = 0; k<ndims; k++)
{
if(dim == dims[k])
{
gel->Divide (filhos);
break;
}
}
}
}
}
void AdjustBoundary(TPZGeoMesh *gmesh)
{
int64_t nel = gmesh->NElements();
for (int64_t el = 0; el<nel; el++) {
TPZGeoEl *gel = gmesh->Element(el);
if (gel->Dimension() == 3 || gel->HasSubElement()) {
continue;
}
TPZGeoElSide gelside(gel,gel->NSides()-1);
TPZGeoElSide neighbour = gelside.Neighbour();
bool should_refine = false;
int nsub = -1;
int numneigh = 0;
while (gelside != neighbour) {
nsub = neighbour.Element()->NSideSubElements(neighbour.Side());
if (neighbour.Element()->HasSubElement() && nsub > 1) {
should_refine = true;
}
numneigh++;
neighbour = neighbour.Neighbour();
}
if (should_refine == true) {
TPZAutoPointer<TPZRefPattern> match = TPZRefPatternTools::PerfectMatchRefPattern(gel);
if (!match) {
DebugStop();
}
gel->SetRefPattern(match);
TPZStack<TPZGeoEl *> subels;
gel->Divide(subels);
}
}
}
void ErrorH1(TPZCompMesh *l2mesh, std::ostream &out)
{
int64_t nel = l2mesh->NElements();
int dim = l2mesh->Dimension();
TPZManVector<STATE,10> globerrors(10,0.);
for (int64_t el=0; el<nel; el++) {
TPZCompEl *cel = l2mesh->ElementVec()[el];
if (!cel) {
continue;
}
TPZGeoEl *gel = cel->Reference();
if (!gel || gel->Dimension() != dim) {
continue;
}
TPZManVector<STATE,10> elerror(10,0.);
elerror.Fill(0.);
cel->EvaluateError(SolSuave, elerror, NULL);
int nerr = elerror.size();
//globerrors.resize(nerr);
#ifdef LOG4CXX
if (logger->isDebugEnabled()) {
std::stringstream sout;
sout << "L2 Error sq of element " << el << elerror[0]*elerror[0];
LOGPZ_DEBUG(logger, sout.str())
}
#endif
for (int i=0; i<nerr; i++) {
globerrors[i] += elerror[i]*elerror[i];
}
}
/**
* @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 RefinamentoUniforme(TPZGeoMesh *gMesh, int nh){
for ( int ref = 0; ref < nh; ref++ ){
TPZVec<TPZGeoEl *> filhos;
int n = gMesh->NElements();
for ( int i = 0; i < n; i++ ){
TPZGeoEl * gel = gMesh->ElementVec() [i];
int GelDimension = gel->Dimension();
if (GelDimension == 2 || GelDimension == 1)
{
gel->Divide (filhos);
}
}//for i
}//ref
}
/**
* @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();
}
void GetElIndexCoarseMesh(TPZAutoPointer<TPZGeoMesh> gmesh, std::set<int64_t> &coarseindex)
{
int nel = gmesh->NElements();
int iel;
int hassubel=0;
int dim = gmesh->Dimension();
int eldim;
for(iel = 0; iel<nel; iel++)
{
TPZGeoEl * gel = gmesh->ElementVec()[iel];
if(!gel) DebugStop();
hassubel = gel->HasSubElement();
eldim = gel->Dimension();
if(!hassubel && eldim ==dim)
{
coarseindex.insert(gel->Index());
}
}
}
int main()
{
TPZManVector<REAL,3> x0(3,0.),x1(3,1.);
x1[2] = 0.;
TPZManVector<int,2> nelx(2,4);
nelx[0] = 8;
TPZGenGrid gengrid(nelx,x0,x1);
gengrid.SetElementType(ETriangle);
TPZGeoMesh *gmesh = new TPZGeoMesh;
gmesh->SetDimension(2);
gengrid.Read(gmesh);
{
std::ofstream out("gmesh.vtk");
TPZVTKGeoMesh::PrintGMeshVTK(gmesh, out, true);
}
TPZExtendGridDimension extend(gmesh,0.5);
extend.SetElType(1);
TPZGeoMesh *gmesh3d = extend.ExtendedMesh(4);
{
std::ofstream out("gmesh3d.vtk");
TPZVTKGeoMesh::PrintGMeshVTK(gmesh3d, out, true);
}
{
int numel = nelx[1];
for(int el=0; el<numel; el++)
{
TPZManVector<int64_t, 3> nodes(2);
nodes[0] = 2+(nelx[0]+1)*el+el;
nodes[1] = 2+(nelx[0]+1)*(el+1)+1+el;
int matid = 2;
int64_t index;
gmesh3d->CreateGeoElement(EOned, nodes, matid, index);
}
{
std::ofstream out("gmesh3dbis.vtk");
TPZVTKGeoMesh::PrintGMeshVTK(gmesh3d, out, true);
}
}
gmesh3d->BuildConnectivity();
gRefDBase.InitializeRefPatterns();
std::set<int> matids;
matids.insert(2);
TPZRefPatternTools::RefineDirectional(gmesh3d, matids);
{
std::ofstream out("gmesh3dtris.vtk");
TPZVTKGeoMesh::PrintGMeshVTK(gmesh3d, out, true);
}
{
int64_t nel = gmesh3d->NElements();
for (int64_t el = 0; el<nel; el++) {
TPZGeoEl *gel = gmesh3d->Element(el);
if(gel->Father()) gel->SetMaterialId(3);
}
for (int64_t el = 0; el<nel; el++) {
TPZGeoEl *gel = gmesh3d->Element(el);
if(gel->Dimension() == 1)
{
for(int side=0; side < gel->NSides(); side++)
{
TPZGeoElSide gelside(gel,side);
TPZGeoElSide neighbour(gelside.Neighbour());
while (neighbour != gelside) {
if(neighbour.Element()->Father())
{
neighbour.Element()->SetMaterialId(4);
}
neighbour = neighbour.Neighbour();
}
}
}
}
}
{
std::ofstream out("gmesh3dtris.vtk");
TPZVTKGeoMesh::PrintGMeshVTK(gmesh3d, out, true);
}
return 0;
}
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
}
int SubStructure(TPZAutoPointer<TPZCompMesh> cmesh, REAL height)
{
int nelem = cmesh->NElements();
TPZManVector<int> subindex(nelem,-1);
int iel;
int nsub = 0;
for (iel=0; iel<nelem; iel++)
{
TPZCompEl *cel = cmesh->ElementVec()[iel];
if (!cel) {
continue;
}
TPZGeoEl *gel = cel->Reference();
if (!gel) {
continue;
}
int nsides = gel->NSides();
TPZManVector<REAL> center(gel->Dimension(),0.), xco(3,0.);
gel->CenterPoint(nsides-1,center);
gel->X(center,xco);
REAL z = xco[2];
int floor = (int) z/height;
nsub = (floor+1) > nsub ? (floor+1) : nsub;
subindex[iel] = floor;
}
#ifdef DEBUG
{
TPZGeoMesh *gmesh = cmesh->Reference();
int nelgeo = gmesh->NElements();
TPZVec<int> domaincolor(nelgeo,-999);
int cel;
int nel = cmesh->NElements();
for (cel=0; cel<nel; cel++) {
TPZCompEl *compel = cmesh->ElementVec()[cel];
if(!compel) continue;
TPZGeoEl *gel = compel->Reference();
if (!gel) {
continue;
}
domaincolor[gel->Index()] = subindex[cel];
}
ofstream vtkfile("partition.vtk");
TPZVTKGeoMesh::PrintGMeshVTK(gmesh, vtkfile, domaincolor);
}
#endif
int isub;
TPZManVector<TPZSubCompMesh *> submeshes(nsub,0);
for (isub=0; isub<nsub; isub++)
{
int index;
std::cout << '^'; std::cout.flush();
submeshes[isub] = new TPZSubCompMesh(cmesh,index);
if (index < subindex.NElements())
{
subindex[index] = -1;
}
}
for (iel=0; iel<nelem; iel++)
{
int domindex = subindex[iel];
if (domindex >= 0)
{
TPZCompEl *cel = cmesh->ElementVec()[iel];
if (!cel)
{
continue;
}
submeshes[domindex]->TransferElement(cmesh.operator->(),iel);
}
}
cmesh->ComputeNodElCon();
for (isub=0; isub<nsub; isub++)
{
submeshes[isub]->MakeAllInternal();
std::cout << '*'; std::cout.flush();
}
cmesh->ComputeNodElCon();
cmesh->CleanUpUnconnectedNodes();
return nsub;
}