void TPZAnalysis::PrePostProcessTable(){
TPZCompEl *cel;
int numvar = fTable.fVariableNames.NElements();
for(int iv=0; iv<numvar; iv++) {
int numel = fTable.fCompElPtr.NElements();
for(int iel=0; iel<numel; iel++) {
cel = (TPZCompEl *) fTable.fCompElPtr[iel];
if(cel) cel->PrintTitle((char *)fTable.fVariableNames[iv],*(fTable.fOutfile));
}
}
*(fTable.fOutfile) << endl;
int dim;
TPZVec<REAL> point(fTable.fDimension);
for(dim=1; dim<fTable.fDimension+1; dim++) {
for(int iv=0; iv<numvar; iv++) {
int numel = fTable.fCompElPtr.NElements();
for(int iel=0; iel<numel; iel++) {
int d;
for(d=0; d<fTable.fDimension; d++) {
point[d] = fTable.fLocations[iel*fTable.fDimension+d];
}
cel = (TPZCompEl *) fTable.fCompElPtr[iel];
if(cel) cel->PrintCoordinate(point,dim,*(fTable.fOutfile));
}
}
*(fTable.fOutfile) << endl;
}
}
TPZGraphMesh::TPZGraphMesh(TPZCompMesh *cm, int dimension, TPZAutoPointer<TPZMaterial> mat)
{
int nel,i;
fElementList.Resize(0);
fElementList.CompactDataStructure(1);
fNodeMap.Resize(0);
fNodeMap.CompactDataStructure(1);
fMaterial = mat;
fCompMesh = cm;
fDimension = dimension;
// TPZGeoMesh *geomesh = fCompMesh->Reference();
// TPZAdmChunkVector<TPZGeoEl *> &gelvec = geomesh->ElementVec();
// TPZGeoEl *ge;
// nel = gelvec.NElements();
// for(i=0;i<nel;i++) {
// ge = gelvec[i];
// if(!ge || !ge->Reference() || ge->Reference()->Type() == EInterface ) continue;
// ge->Reference()->CreateGraphicalElement(*this, dimension);
// }
TPZAdmChunkVector<TPZCompEl *> &celvec = fCompMesh->ElementVec();
TPZCompEl *ce;
nel = celvec.NElements();
for(i=0;i<nel;i++) {
ce = (TPZCompEl *) celvec[i];
if(!ce) continue;
// if (ce->Dimension() != dimension) continue;
ce->CreateGraphicalElement(*this, dimension);
}
fScalarNames = "";
fVecNames = "";
}
TPZDXGraphMesh::TPZDXGraphMesh(TPZCompMesh *cmesh, int dimension, TPZAutoPointer<TPZMaterial> mat, const TPZVec<std::string> &scalarnames, const TPZVec<std::string> &vecnames) :
TPZGraphMesh(cmesh,dimension,mat) {
SetNames(scalarnames,vecnames);
fNextDataField = 1;
fStyle = EDXStyle;
// int index = 0;
TPZCompEl *ce = FindFirstInterpolatedElement(cmesh,dimension);
fElementType = "noname";
if(ce) {
int type = ce->Type();
if(type == EOned) fElementType = "lines";
if(type == ETriangle) fElementType = "triangles";
if(type == EQuadrilateral) fElementType = "quads";
if(type == ECube) fElementType = "cubes";
if(type == EPrisma) fElementType = "cubes";
TPZGeoEl *gel = ce->Reference();
if( type == EDiscontinuous || (type == EAgglomerate && gel) ){
int nnodes = gel->NNodes();
if(nnodes==4 && dimension==2) fElementType = "quads";
if(nnodes==3 && dimension==2) fElementType = "triangles";
if(dimension==3) fElementType = "cubes";
}
}
fNumCases = 0;
fNumConnectObjects[0] = 1;
fNumConnectObjects[1] = 1;
fNumConnectObjects[2] = 1;
fNormalObject = 0;
for(int i = 0; i < 8; i++) fElConnectivityObject[i] = -1;
}
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];
}
}
TPZCompEl *TPZGraphMesh::FindFirstInterpolatedElement(TPZCompMesh *mesh, int dim) {
int64_t nel = mesh->NElements();
TPZCompEl *cel;
int64_t iel;
for(iel=0; iel<nel; iel++) {
cel = mesh->ElementVec()[iel];
if(!cel) continue;
int type = cel->Type();
if(type == EAgglomerate){
#ifndef STATE_COMPLEX
if(!cel->Reference()) continue;
TPZAgglomerateElement *agg = dynamic_cast<TPZAgglomerateElement *>(cel);
if(agg && agg->Dimension() == dim) return agg;
#else
DebugStop();
#endif
}
if(type == EDiscontinuous){
TPZCompElDisc *disc = dynamic_cast<TPZCompElDisc *>(cel);
if(disc && disc->Reference()->Dimension() == dim) return disc;
}
TPZCompEl *intel = dynamic_cast<TPZInterpolatedElement *>(cel);
if(intel && intel->Reference()->Dimension() == dim) return intel;
TPZSubCompMesh *subcmesh = dynamic_cast<TPZSubCompMesh *> (cel);
if(subcmesh) {
intel = FindFirstInterpolatedElement(subcmesh,dim);
if(intel) return intel;
}
}
return 0;
}
void ReadSolution(ifstream &arq, TPZVec<REAL> &sol, TPZCompMesh *cmesh, int &nstate, TPZVec<int> &dimstate){
int i,j,totaldim=0;
for(i=0;i<nstate;i++) totaldim += dimstate[i];
TPZVec<REAL> pt(3,0.);
TPZVec<REAL> coord(3,0.);
TPZVec<REAL> auxsol(totaldim,0.);
int iter = 0;
int nel = cmesh->NElements();
int solsize = totaldim * nel;
sol.Resize(solsize);
sol.Fill(0.);
for(i=0; i<nel; i++){
TPZCompEl *el = cmesh->ElementVec()[i];
if (!el) continue;
el->Reference()->CenterPoint(el->Reference()->NSides()-1,pt);
el->Reference()->X(pt,coord);
EvaluateSolution(coord,auxsol);
for (j=0;j<totaldim;j++){
sol[iter] = auxsol[j];
iter++;
}
}
}
void TPZAdaptMesh::RemoveCloneBC(TPZCompMesh *mesh)
{
int nelem = mesh->NElements();
int iel;
for(iel=0; iel<nelem; iel++) {
TPZCompEl *cel = mesh->ElementVec()[iel];
if(!cel) continue;
int matid = cel->Material()->Id();
if(matid == -1000) delete cel;
}
}
void TPZAnalysis::SetBlockNumber(){
//enquanto nao compilamos o BOOST no windows, vai o sloan antigo
#ifdef WIN32
if(!fCompMesh) return;
fCompMesh->InitializeBlock();
TPZVec<int> perm,iperm;
TPZStack<int> elgraph,elgraphindex;
int nindep = fCompMesh->NIndependentConnects();
fCompMesh->ComputeElGraph(elgraph,elgraphindex);
int nel = elgraphindex.NElements()-1;
TPZSloan sloan(nel,nindep);
sloan.SetElementGraph(elgraph,elgraphindex);
sloan.Resequence(perm,iperm);
fCompMesh->Permute(perm);
#else
if(!fCompMesh) return;
fCompMesh->InitializeBlock();
TPZVec<int> perm,iperm;
TPZStack<int> elgraph,elgraphindex;
int nindep = fCompMesh->NIndependentConnects();
fCompMesh->ComputeElGraph(elgraph,elgraphindex);
int nel = elgraphindex.NElements()-1;
int el,ncel = fCompMesh->NElements();
int maxelcon = 0;
for(el = 0; el<ncel; el++)
{
TPZCompEl *cel = fCompMesh->ElementVec()[el];
if(!cel) continue;
std::set<int> indepconlist,depconlist;
cel->BuildConnectList(indepconlist,depconlist);
int locnindep = indepconlist.size();
maxelcon = maxelcon < locnindep ? locnindep : maxelcon;
}
fRenumber->SetElementsNodes(nel,nindep);
// TPZSloan sloan(nel,nindep,maxelcon);
fRenumber->SetElementGraph(elgraph,elgraphindex);
fRenumber->Resequence(perm,iperm);
fCompMesh->Permute(perm);
/*
fCompMesh->ComputeElGraph(elgraph,elgraphindex);
TPZMetis metis(nel,nindep);
metis.SetElementGraph(elgraph,elgraphindex);
metis.Resequence(perm,iperm);
fCompMesh->Permute(iperm);
*/
#endif
}
void RefinElemComp(TPZCompMesh *cMesh, int indexEl)
{
TPZVec<int64_t > subindex;
int64_t nel = cMesh->ElementVec().NElements();
for(int64_t el=0; el < nel; el++){
TPZCompEl * compEl = cMesh->ElementVec()[el];
if(!compEl) continue;
int64_t ind = compEl->Index();
if(ind==indexEl){
compEl->Divide(indexEl, subindex, 1);
}
}
}
int TPZAdaptMesh::HasTrueError(int clindex, REAL &minerror, TPZVec<REAL> &ervec){
TPZGeoCloneMesh *gmesh = dynamic_cast<TPZGeoCloneMesh *> (fCloneMeshes [clindex]->Reference());
int nref = gmesh->NReference();
int i;
for (i=0;i<nref;i++){
TPZGeoEl *gel = gmesh->ReferenceElement(i);
TPZCompEl *cel = gel->Reference();
if (!cel) continue;
int celindex = cel->Index();
if (ervec[celindex] >= minerror) return 1;
}
return 0;
}
void RefinUniformElemComp(TPZCompMesh *cMesh, int ndiv)
{
TPZVec<int64_t > subindex;
for (int64_t iref = 0; iref < ndiv; iref++) {
TPZAdmChunkVector<TPZCompEl *> elvec = cMesh->ElementVec();
int64_t nel = elvec.NElements();
for(int64_t el=0; el < nel; el++){
TPZCompEl * compEl = elvec[el];
if(!compEl) continue;
int64_t ind = compEl->Index();
compEl->Divide(ind, subindex, 0);
}
}
}
void CreatInterface(TPZCompMesh *cmesh){
for(int el = 0; el < cmesh->ElementVec().NElements(); el++)
{
TPZCompEl * compEl = cmesh->ElementVec()[el];
if(!compEl) continue;
int index = compEl ->Index();
if(compEl->Dimension() == cmesh->Dimension())
{
TPZInterpolationSpace * InterpEl = dynamic_cast<TPZInterpolationSpace *>(cmesh->ElementVec()[index]);
if(!InterpEl) continue;
InterpEl->CreateInterfaces(false);
}
}
// cmesh->AdjustBoundaryElements();
//cmesh->CleanUpUnconnectedNodes();
}
void TPZAnalysisError::EvaluateError(REAL CurrentEtaAdmissible, std::ostream &out) {
//Code isn�t place to chat
//#warning Philippe, tambem nao entendo aqui //<!>
TPZManVector<REAL,3> elerror(3);
elerror.Fill(0.);
TPZManVector<REAL,3> errorSum(3);
errorSum.Fill(0.0);
TPZBlock<REAL> *flux = 0;
int elcounter=0;
int numel = Mesh()->ElementVec().NElements();
fElErrors.Resize(numel);
fElIndexes.Resize(numel);
Mesh()->ElementSolution().Redim(numel,1);
//soma de erros sobre os elementos
int el;
for(el=0;el< numel;el++) {
TPZCompEl *elptr = Mesh()->ElementVec()[el];
if(elptr && !(elptr->Material()->Id() < 0)) {
elptr->EvaluateError(fExact,elerror, flux);
int nerrors = elerror.NElements();
errorSum.Resize(nerrors, 0.);
for(int ii = 0; ii < nerrors; ii++)
errorSum[ii] += elerror[ii]*elerror[ii];
fElErrors[elcounter] = elerror[0];
(Mesh()->ElementSolution())(el,0) = elerror[0];
fElIndexes[elcounter++] = el;
} else {
(Mesh()->ElementSolution())(el,0) = 0.;
}
}
fElErrors.Resize(elcounter);
fElIndexes.Resize(elcounter);
fTotalError = sqrt(errorSum[0]);
Mesh()->EvaluateError(NullFunction,elerror);
// fAdmissibleError = CurrentEtaAdmissible*sqrt(true_error*true_error + fTotalError*fTotalError) / sqrt(1.*elcounter);
//<!>pra compilar
//Code isn�t place to chat
//#warning Phil, ver isso urgente. Tiago
fAdmissibleError = CurrentEtaAdmissible*sqrt(elerror[0]*elerror[0] + fTotalError*fTotalError) / sqrt(1.*elcounter);
}
TPZGraphMesh::TPZGraphMesh(TPZCompMesh *cm, int dimension, const std::set<int> & matids, const TPZVec<std::string> &scalarnames, const TPZVec<std::string> &vecnames, const TPZVec<std::string> &tensornames) :
fCompMesh(cm), fDimension(dimension), fMaterialIds(matids), fScalarNames(scalarnames), fVecNames(vecnames), fTensorNames(tensornames)
{
int64_t nel,i;
fElementList.Resize(0);
fElementList.CompactDataStructure(fElementList.NOW);
fNodeMap.Resize(0);
fNodeMap.CompactDataStructure(fNodeMap.NOW);
TPZAdmChunkVector<TPZCompEl *> &celvec = fCompMesh->ElementVec();
TPZCompEl *ce;
nel = celvec.NElements();
for(i=0;i<nel;i++) {
ce = (TPZCompEl *) celvec[i];
if(!ce) continue;
ce->CreateGraphicalElement(*this, dimension);
}
}
void TPZAnalysisError::EvaluateError(REAL CurrentEtaAdmissible, bool store_error, std::ostream &out) {
//Code isn�t place to chat
//#warning Philippe, tambem nao entendo aqui //<!>
TPZManVector<REAL,3> elerror(3);
elerror.Fill(0.);
TPZManVector<REAL,3> errorSum(3);
errorSum.Fill(0.0);
TPZBlock<REAL> *flux = 0;
int64_t elcounter=0;
int64_t numel = Mesh()->ElementVec().NElements();
fElErrors.Resize(numel);
fElIndexes.Resize(numel);
Mesh()->ElementSolution().Redim(numel,1);
// Sum of the errors over all computational elements
int64_t el;
for(el=0;el< numel;el++) {
TPZCompEl *elptr = Mesh()->ElementVec()[el];
if(elptr && !(elptr->Material()->Id() < 0)) {
elptr->EvaluateError(fExact,elerror, flux);
int nerrors = elerror.NElements();
errorSum.Resize(nerrors, 0.);
for(int ii = 0; ii < nerrors; ii++)
errorSum[ii] += elerror[ii]*elerror[ii];
fElErrors[elcounter] = elerror[0];
(Mesh()->ElementSolution())(el,0) = elerror[0];
fElIndexes[elcounter++] = el;
} else {
(Mesh()->ElementSolution())(el,0) = 0.;
}
}
fElErrors.Resize(elcounter);
fElIndexes.Resize(elcounter);
fTotalError = sqrt(errorSum[0]);
// void NullFunction(TPZVec<REAL> &point,TPZVec<STATE>&val,TPZFMatrix<STATE> &deriv);
std::function<void(const TPZVec<REAL> &,TPZVec<STATE>&,TPZFMatrix<STATE> &)> func(NullFunction);
Mesh()->EvaluateError(func,store_error, elerror);
fAdmissibleError = CurrentEtaAdmissible*sqrt(elerror[0]*elerror[0] + fTotalError*fTotalError) / sqrt(1.*elcounter);
}
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 TPZGraphMesh::SetCompMesh(TPZCompMesh *mesh, const std::set<int> & matids){
if(fCompMesh == mesh && matids == fMaterialIds) return;
int64_t i;
fCompMesh = mesh;
fMaterialIds = matids;
int64_t nel = fElementList.NElements();
TPZGraphEl *el;
for(i=0;i<nel;i++) {
el = fElementList[i];
if(!el) continue;
if(el) delete el;
}
fElementList.Resize(0);
fNodeMap.Resize(0);
TPZAdmChunkVector<TPZCompEl *> &celvec = fCompMesh->ElementVec();
TPZCompEl *ce;
nel = celvec.NElements();
for(i=0;i<nel;i++) {
ce = (TPZCompEl *) celvec[i];
if(ce) ce->CreateGraphicalElement(*this, fDimension);
}
}
void TPZDarcyAnalysis::CreateInterfaces()
{
fgmesh->ResetReference();
fcmeshdarcy->LoadReferences();
// Creation of interface elements
int nel = fcmeshdarcy->ElementVec().NElements();
for(int el = 0; el < nel; el++)
{
TPZCompEl * compEl = fcmeshdarcy->ElementVec()[el];
if(!compEl) continue;
TPZGeoEl * gel = compEl->Reference();
if(!gel) {continue;}
if(gel->HasSubElement()) {continue;}
int index = compEl ->Index();
if(compEl->Dimension() == fcmeshdarcy->Dimension())
{
TPZMultiphysicsElement * InterpEl = dynamic_cast<TPZMultiphysicsElement *>(fcmeshdarcy->ElementVec()[index]);
if(!InterpEl) continue;
InterpEl->CreateInterfaces();
}
}
}
TPZMultiphysicsInterfaceElement * TPZMultiphysicsElement::CreateInterface(int side)
{
// LOGPZ_INFO(logger, "Entering CreateInterface");
TPZMultiphysicsInterfaceElement * newcreatedinterface = NULL;
TPZGeoEl *ref = Reference();
if(!ref) {
LOGPZ_WARN(logger, "Exiting CreateInterface Null reference reached - NULL interface returned");
return newcreatedinterface;
}
TPZCompElSide thisside(this,side);
TPZStack<TPZCompElSide> list;
list.Resize(0);
thisside.EqualLevelElementList(list,0,0);//retorna distinto ao atual ou nulo
int64_t size = list.NElements();
//espera-se ter os elementos computacionais esquerdo e direito
//ja criados antes de criar o elemento interface
// try to create an interface element between myself and an equal sized neighbour
for (int64_t is=0; is<size; is++)
{
//Interface has the same material of the neighbour with lesser dimension.
//It makes the interface have the same material of boundary conditions (TPZCompElDisc with interface dimension)
int matid;
int thisdim = this->Dimension();
int neighbourdim = list[is].Element()->Dimension();
if(thisdim != neighbourdim)
{
if (thisdim < neighbourdim)
{
// return the material id of boundary condition IF the associated material is derived from bndcond
TPZMaterial *mat = this->Material();
TPZBndCond *bnd = dynamic_cast<TPZBndCond *>(mat);
if(bnd)
{
matid = this->Material()->Id();
}
else
{
matid = this->Mesh()->Reference()->InterfaceMaterial(this->Reference()->MaterialId(),list[0].Element()->Reference()->MaterialId());
continue;
}
}
else
{
TPZMaterial *mat = list[is].Element()->Material();
TPZBndCond *bnd = dynamic_cast<TPZBndCond *>(mat);
if (bnd) {
matid = bnd->Id();
}
else {
matid = this->Mesh()->Reference()->InterfaceMaterial(this->Reference()->MaterialId(), list[0].Element()->Reference()->MaterialId());
continue;
}
}
}else
{
matid = this->Mesh()->Reference()->InterfaceMaterial(this->Reference()->MaterialId(), list[0].Element()->Reference()->MaterialId());
if(matid == GMESHNOMATERIAL)
{
continue;
}
}
int64_t index;
TPZGeoEl *gel = ref->CreateBCGeoEl(side,matid); //isto acertou as vizinhanas da interface geometrica com o atual
if(!gel){
DebugStop();
#ifdef LOG4CXX
if (logger->isDebugEnabled())
{
std::stringstream sout;
sout << "CreateBCGeoEl devolveu zero!@@@@";
LOGPZ_DEBUG(logger,sout.str());
}
#endif
}
bool withmem = fMesh->ApproxSpace().NeedsMemory();
if(Dimension() > list[is].Reference().Dimension()) {
//o de volume eh o direito caso um deles seja BC
//a normal aponta para fora do contorno
TPZCompElSide thiscompelside(this, thisside.Side());
TPZCompElSide neighcompelside(list[is]);
if (!withmem) {
newcreatedinterface = new TPZMultiphysicsInterfaceElement(*fMesh,gel,index,thiscompelside,neighcompelside);
}
else
{
newcreatedinterface = new TPZCompElWithMem<TPZMultiphysicsInterfaceElement>(*fMesh,gel,index,thiscompelside,neighcompelside);
}
} else {
//caso contrario ou caso ambos sejam de volume
TPZCompElSide thiscompelside(this, thisside.Side());
TPZCompElSide neighcompelside(list[is]);
if (!withmem) {
newcreatedinterface = new TPZMultiphysicsInterfaceElement(*fMesh,gel,index,neighcompelside,thiscompelside);
}
else
{
newcreatedinterface = new TPZCompElWithMem<TPZMultiphysicsInterfaceElement>(*fMesh,gel,index,neighcompelside,thiscompelside);
}
}
return newcreatedinterface;
}
//If there is no equal or lower level element, we try the lower elements.
//Higher elements will not be considered by this method. In that case the interface must be created by the neighbour.
TPZCompElSide lower = thisside.LowerLevelElementList(0);
if(lower.Exists()){
//Interface has the same material of the neighbour with lesser dimension.
//It makes the interface has the same material of boundary conditions (TPZCompElDisc with interface dimension)
int matid = GMESHNOMATERIAL;
int thisdim = this->Dimension();
int neighbourdim = lower.Element()->Dimension();
matid = this->Mesh()->Reference()->InterfaceMaterial(this->Material()->Id(), lower.Element()->Material()->Id() );
if (matid == GMESHNOMATERIAL && thisdim == neighbourdim){
// matid = this->Material()->Id();
//break;
}
else if(matid == GMESHNOMATERIAL && thisdim != neighbourdim)
{
if (thisdim < neighbourdim)
{
// return the material id of boundary condition IF the associated material is derived from bndcond
TPZMaterial *mat = this->Material();
TPZBndCond *bnd = dynamic_cast<TPZBndCond *>(mat);
if(bnd)
{
matid = this->Material()->Id();
}
else {
//continue;
}
}
else
{
TPZMaterial *mat = lower.Element()->Material();
TPZBndCond *bnd = dynamic_cast<TPZBndCond *>(mat);
if (bnd) {
matid = bnd->Id();
}
else {
//continue;
}
}
}
// return zero
if(matid == GMESHNOMATERIAL)
{
return newcreatedinterface;
}
TPZCompEl *lowcel = lower.Element();
//int lowside = lower.Side();
//existem esquerdo e direito: this e lower
TPZGeoEl *gel = ref->CreateBCGeoEl(side,matid);
int64_t index;
bool withmem = fMesh->ApproxSpace().NeedsMemory();
if(Dimension() > lowcel->Dimension()){
//para que o elemento esquerdo seja de volume
TPZCompElSide thiscompelside(this, thisside.Side());
TPZCompElSide lowcelcompelside(lower);
if (!withmem) {
newcreatedinterface = new TPZMultiphysicsInterfaceElement(*fMesh,gel,index,thiscompelside,lowcelcompelside);
}
else
{
newcreatedinterface = new TPZCompElWithMem<TPZMultiphysicsInterfaceElement>(*fMesh,gel,index,thiscompelside,lowcelcompelside);
}
} else {
TPZCompElSide thiscompelside(this, thisside.Side());
TPZCompElSide lowcelcompelside(lower);
#ifdef LOG4CXX_KEEP
if (logger->isDebugEnabled())
{
std::stringstream sout;
sout << __PRETTY_FUNCTION__ << " left element";
sout << lowcelcompelside << thiscompelside;
sout << "Left Element ";
lowcelcompelside.Element()->Print(sout);
sout << "Right Element ";
thiscompelside.Element()->Print(sout);
LOGPZ_DEBUG(logger,sout.str())
}
#endif
if (!withmem)
{
newcreatedinterface = new TPZMultiphysicsInterfaceElement(*fMesh,gel,index,lowcelcompelside,thiscompelside);
}
else
{
newcreatedinterface = new TPZCompElWithMem<TPZMultiphysicsInterfaceElement>(*fMesh,gel,index,lowcelcompelside,thiscompelside);
}
}
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;
}
//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);
}
}
}
TPZCompMesh *MalhaCompMultifisica(TPZGeoMesh * gmesh,TPZVec<TPZCompMesh *> meshvec, TPZMatUncoupledPoissonDisc* &mymaterial){
// Creating computational mesh for multiphysic elements
gmesh->ResetReference();
TPZCompMesh *mphysics = new TPZCompMesh(gmesh);
mphysics->SetAllCreateFunctionsMultiphysicElem();
int dim = 2;
mphysics->SetDimModel(dim);
mymaterial = new TPZMatUncoupledPoissonDisc(matId, mphysics->Dimension());
mymaterial->SetParameters(1., 1.);
mymaterial->SetInternalFlux(-8.,0.);
//mymaterial->SetInternalFlux(0.,0.);
mymaterial->SetNonSymmetricOne();
mymaterial->SetNonSymmetricTwo();
mymaterial->SetPenaltyConstant(0., 0.);
TPZMaterial * mat(mymaterial);
mphysics->InsertMaterialObject(mat);
TPZAutoPointer<TPZFunction<STATE> > forcef = new TPZDummyFunction<STATE>(ForcingF, 5);
//
// TPZAutoPointer<TPZFunction<STATE> > forcef = new TPZDummyFunction<STATE>(ForcingF);
mymaterial->SetForcingFunction(forcef);
///Inserir condicao de contorno
TPZFMatrix<STATE> val1(2,2,0.), val2(2,1,0.);
TPZMaterial * BCond0 = mymaterial->CreateBC(mat, bc0,neumann_dirichlet, val1, val2);
TPZMaterial * BCond2 = mymaterial->CreateBC(mat, bc2,neumann_dirichlet, val1, val2);
TPZMaterial * BCond1 = mymaterial->CreateBC(mat, bc1,dirichlet, val1, val2);
TPZMaterial * BCond3 = mymaterial->CreateBC(mat, bc3,dirichlet, val1, val2);
// TPZMaterial * BCond0 = mymaterial->CreateBC(mat, bc0,dirichlet, val1, val2);
// TPZMaterial * BCond2 = mymaterial->CreateBC(mat, bc2,dirichlet, val1, val2);
// TPZMaterial * BCond1 = mymaterial->CreateBC(mat, bc1,dirichlet, val1, val2);
// TPZMaterial * BCond3 = mymaterial->CreateBC(mat, bc3,dirichlet, val1, val2);
mphysics->InsertMaterialObject(BCond0);
mphysics->InsertMaterialObject(BCond1);
mphysics->InsertMaterialObject(BCond2);
mphysics->InsertMaterialObject(BCond3);
mphysics->AutoBuild();
mphysics->AdjustBoundaryElements();
mphysics->CleanUpUnconnectedNodes();
//Creating multiphysic elements into mphysics computational mesh
TPZBuildMultiphysicsMesh::AddElements(meshvec, mphysics);
TPZBuildMultiphysicsMesh::AddConnects(meshvec,mphysics);
TPZBuildMultiphysicsMesh::TransferFromMeshes(meshvec, mphysics);
mphysics->Reference()->ResetReference();
mphysics->LoadReferences();
if (disc_functions==true){
//criar elementos de interface
int nel = mphysics->ElementVec().NElements();
for(int el = 0; el < nel; el++)
{
TPZCompEl * compEl = mphysics->ElementVec()[el];
if(!compEl) continue;
int index = compEl ->Index();
if(compEl->Dimension() == mphysics->Dimension())
{
TPZMultiphysicsElement * InterpEl = dynamic_cast<TPZMultiphysicsElement *>(mphysics->ElementVec()[index]);
if(!InterpEl) continue;
InterpEl->CreateInterfaces();
}
}
}
return mphysics;
}
void TPZCreateApproximationSpace::SetAllCreateFunctions(TPZCompEl &cel, TPZCompMesh *mesh){
cel.SetCreateFunctions(mesh);
}
void TPZAnalysis::PostProcess(TPZVec<REAL> &, std::ostream &out ){
int i, neq = fCompMesh->NEquations();
TPZVec<REAL> ux((int) neq);
TPZVec<REAL> sigx((int) neq);
TPZManVector<REAL,10> values(10,0.);
TPZManVector<REAL,10> values2(10,0.);
fCompMesh->LoadSolution(fSolution);
// SetExact(&Exact);
TPZAdmChunkVector<TPZCompEl *> elvec = fCompMesh->ElementVec();
TPZManVector<REAL,10> errors(10);
errors.Fill(0.0);
int nel = elvec.NElements();
int matId0;
for(i=0;i<nel;i++) {
matId0=elvec[i]->Material()->Id();
if(matId0 > 0)
break;
}
bool lastEl=false;
for(i=0;i<nel;i++) {
TPZCompEl *el = (TPZCompEl *) elvec[i];
if(el) {
errors.Fill(0.0);
el->EvaluateError(fExact, errors, 0);
if(matId0==el->Material()->Id()){
for(int ier = 0; ier < errors.NElements(); ier++) values[ier] += errors[ier] * errors[ier];
lastEl=false;
}
else{
for(int ier = 0; ier < errors.NElements(); ier++) values2[ier] += errors[ier] * errors[ier];
lastEl=true;
}
}
}
int nerrors = errors.NElements();
if (nerrors==4) {
if(lastEl){
out << endl << "############" << endl;
out << endl << "L2 Norm for pressure = " << sqrt(values2[0]) << endl;
out << endl << "L2 Norm for flux = " << sqrt(values2[1]) << endl;
out << endl << "L2 Norm for divergence = " << sqrt(values2[2]) <<endl;
out << endl << "Hdiv Norm for flux = " << sqrt(values2[3]) <<endl;
out << endl << "############" << endl;
out << endl << "true_error (Norma H1) = " << sqrt(values[0]) << endl;
out << endl << "L2_error (Norma L2) = " << sqrt(values[1]) << endl;
out << endl << "estimate (Semi-norma H1) = " << sqrt(values[2]) <<endl;
}
else{
out << endl << "############" << endl;
out << endl << "L2 Norm for pressure = " << sqrt(values[0]) << endl;
out << endl << "L2 Norm for flux = " << sqrt(values[1]) << endl;
out << endl << "L2 Norm for divergence = " << sqrt(values[2]) <<endl;
out << endl << "Hdiv Norm for flux = " << sqrt(values[3]) <<endl;
out << endl << "############" << endl;
out << endl << "true_error (Norma H1) = " << sqrt(values2[0]) << endl;
out << endl << "L2_error (Norma L2) = " << sqrt(values2[1]) << endl;
out << endl << "estimate (Semi-norma H1) = " << sqrt(values2[2]) <<endl;
}
}
else {
if(lastEl){
out << endl << "############" << endl;
out << endl << "L2 Norm for pressure = " << sqrt(values[0]) << endl;
out << endl << "L2 Norm for flux = " << sqrt(values[1]) << endl;
out << endl << "L2 Norm for divergence = " << sqrt(values[2]) <<endl;
out << endl << "Hdiv Norm for flux = " << sqrt(values[3]) <<endl;
out << endl << "############" << endl;
out << endl << "true_error (Norma H1) = " << sqrt(values2[0]) << endl;
out << endl << "L2_error (Norma L2) = " << sqrt(values2[1]) << endl;
out << endl << "estimate (Semi-norma H1) = " << sqrt(values2[2]) <<endl;
}
else{
out << endl << "############" << endl;
out << endl << "L2 Norm for pressure = " << sqrt(values2[0]) << endl;
out << endl << "L2 Norm for flux = " << sqrt(values2[1]) << endl;
out << endl << "L2 Norm for divergence = " << sqrt(values2[2]) <<endl;
out << endl << "Hdiv Norm for flux = " << sqrt(values2[3]) <<endl;
out << endl << "############" << endl;
out << endl << "true_error (Norma H1) = " << sqrt(values[0]) << endl;
out << endl << "L2_error (Norma L2) = " << sqrt(values[1]) << endl;
out << endl << "estimate (Semi-norma H1) = " << sqrt(values[2]) <<endl;
}
}
return;
}
// Output as Mathematica format
void OutputMathematica(std::ofstream &outMath,int var,int pointsByElement,TPZCompMesh *cmesh) {
int i, j, k, nnodes;
int nelem = cmesh->ElementVec().NElements();
int dim = cmesh->Dimension(); // Dimension of the model
REAL w;
if(var-1 < 0) var = 1;
// Map to store the points and values
map<REAL,TPZVec<REAL> > Graph;
TPZVec<REAL> tograph(4,0.);
map<TPZVec<REAL>,REAL> Graphics;
for(i=0;i<nelem;i++) {
TPZCompEl *cel = cmesh->ElementVec()[i];
TPZGeoEl *gel = cel->Reference();
TPZInterpolationSpace * sp = dynamic_cast <TPZInterpolationSpace*>(cel);
int nstates = cel->Material()->NStateVariables();
// If var is higher than nstates of the element, go to next element
if(var > nstates)
continue;
TPZVec<REAL> qsi(3,0.), sol(nstates,0.), outfem(3,0.);
nnodes = gel->NNodes();
if(pointsByElement < nnodes) pointsByElement = nnodes;
for(j=0;j<gel->NNodes();j++) {
// Get corners points to compute solution on
gel->CenterPoint(j,qsi);
sp->Solution(qsi,0,sol);
cel->Reference()->X(qsi,outfem);
// Jointed point coordinates and solution value on
for(k=0;k<3;k++) tograph[k] = outfem[k];
tograph[k] = sol[var-1];
Graph.insert(pair<REAL,TPZVec<REAL> >(outfem[0],tograph));
Graphics.insert(pair<TPZVec<REAL>,REAL>(outfem,sol[var-1]));
// If cel is point gets one point value
if(cel->Type() == EPoint) {
break;
}
}
// If cel is point gets one point value
if(cel->Type() == EPoint) continue;
// Print another points using integration points
TPZIntPoints *rule = NULL;
int order = 1, npoints = 0;
while(pointsByElement-(npoints+nnodes) > 0) {
if(rule) delete rule; // Cleaning unnecessary allocation
int nsides = gel->NSides();
// Get the integration rule to compute internal points to print, not to print
rule = gel->CreateSideIntegrationRule(nsides-1,order);
if(!rule) break;
npoints = rule->NPoints();
order += 2;
}
for(j=0;j<npoints;j++) {
// Get integration points to get internal points
rule->Point(j,qsi,w);
sp->Solution(qsi,0,sol);
cel->Reference()->X(qsi,outfem);
// Jointed point coordinates and solution value on
for(k=0;k<3;k++) tograph[k] = outfem[k];
tograph[k] = sol[var-1];
Graph.insert(pair<REAL,TPZVec<REAL> >(outfem[0],tograph));
Graphics.insert(pair<TPZVec<REAL>,REAL>(outfem,sol[var-1]));
}
}
// Printing the points and values into the Mathematica file
outMath << "Saida = { ";
// Formatting output
outMath << fixed << setprecision(10);
if(dim<2) {
map<REAL,TPZVec<REAL> >::iterator it;
for(it=Graph.begin();it!=Graph.end();it++) {
if(it!=Graph.begin()) outMath << ",";
outMath << "{";
for(j=0;j<dim;j++)
outMath << (*it).second[j] << ",";
outMath << (*it).second[3] << "}";
}
outMath << "};" << std::endl;
// Choose Mathematica command depending on model dimension
outMath << "ListPlot[Saida,Joined->True]"<< endl;
}
else {
map<TPZVec<REAL>,REAL>::iterator it;
for(it=Graphics.begin();it!=Graphics.end();it++) {
if(it!=Graphics.begin()) outMath << ",";
outMath << "{";
for(j=0;j<dim;j++)
outMath << (*it).first[j] << ",";
outMath << (*it).second << "}";
}
outMath << "};" << std::endl;
outMath << "ListPlot3D[Saida]"<< endl;
}
}
