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 TPZGeoCloneMesh::main(){
cout << "**************************************" << endl;
cout << "****** Getting Patchs!************" << endl;
cout << "**************************************" << endl;
/*******************************************************
* Constru��o da malha
* *****************************************************/
//malha quadrada de nr x nc
const int numrel = 3;
const int numcel = 3;
// int numel = numrel*numcel;
TPZVec<REAL> coord(2,0.);
// criar um objeto tipo malha geometrica
TPZGeoMesh geomesh;
// criar nos
int i,j;
for(i=0; i<(numrel+1); i++) {
for (j=0; j<(numcel+1); j++) {
int64_t nodind = geomesh.NodeVec().AllocateNewElement();
TPZVec<REAL> coord(2);
coord[0] = j;//co[nod][0];
coord[1] = i;//co[nod][1];
geomesh.NodeVec()[nodind] = TPZGeoNode(i*(numrel+1)+j,coord,geomesh);
}
}
// cria��o dos elementos
int elc, elr;
TPZGeoEl *gel[numrel*numcel];
TPZVec<int64_t> indices(4);
for(elr=0; elr<numrel; elr++) {
for(elc=0; elc<numcel; elc++) {
indices[0] = (numrel+1)*elr+elc;
indices[1] = indices[0]+1;
indices[3] = indices[0]+numrel+1;
indices[2] = indices[1]+numrel+1;
// O proprio construtor vai inserir o elemento na malha
int64_t index;
gel[elr*numrel+elc] = geomesh.CreateGeoElement(EQuadrilateral,indices,1,index);
//gel[elr*numrel+elc] = new TPZGeoElQ2d(elr*numrel+elc,indices,1,geomesh);
}
}
//Divis�o dos elementos
TPZVec<TPZGeoEl *> sub;
gel[0]->Divide(sub);
// gel[1]->Divide(sub);
// gel[3]->Divide(sub);
ofstream output("patches.dat");
geomesh.Print(output);
// TPZGeoElBC t3(gel[0],4,-1,geomesh);
// TPZGeoElBC t4(gel[numel-1],6,-2,geomesh);
geomesh.Print(output);
geomesh.BuildConnectivity();
std::set <TPZGeoEl *> patch;
TPZCompMesh *comp = new TPZCompMesh(&geomesh);
// inserir os materiais
TPZMaterial *meumat = new TPZElasticityMaterial(1,1.e5,0.2,0,0);
comp->InsertMaterialObject(meumat);
// inserir a condicao de contorno
// TPZFMatrix val1(3,3,0.),val2(3,1,0.);
// TPZMaterial *bnd = meumat->CreateBC (-1,0,val1,val2);
// comp->InsertMaterialObject(bnd);
// TPZFMatrix val3(3,3,1);
// bnd = meumat->CreateBC (-2,1,val3,val2);
// comp->InsertMaterialObject(bnd);
comp->AutoBuild();
comp->Print(output);
output.flush();
/**********************************************************************
* Cria��o de uma malha computacional clone
* ********************************************************************/
comp->GetRefPatches(patch);
geomesh.ResetReference();
TPZStack <int64_t> patchel;
TPZStack <TPZGeoEl *> toclonegel;
TPZStack <int64_t> patchindex;
TPZVec<int64_t> n2elgraph;
TPZVec<int64_t> n2elgraphid;
TPZStack<int64_t> elgraph;
TPZVec<int64_t> elgraphindex;
int64_t k;
TPZCompMesh *clonecmesh = new TPZCompMesh(&geomesh);
cout << "Check 1: number of reference elements for patch before createcompel: " << patch.size() << endl;
std::set<TPZGeoEl *>::iterator it;
for (it=patch.begin(); it!=patch.end(); it++)
{
//patch[i]->Print(cout);
int64_t index;
TPZGeoEl *gel = *it;
clonecmesh->CreateCompEl(gel, index);
// patch[i]->CreateCompEl(*clonecmesh,i);
}
// cout << "Check 2: number of reference elements for patch after createcompel: " << patch.NElements() << endl;
clonecmesh->CleanUpUnconnectedNodes();
// clonecmesh->Print(cout);
clonecmesh->GetNodeToElGraph(n2elgraph,n2elgraphid,elgraph,elgraphindex);
int64_t clnel = clonecmesh->NElements();
// cout << "Number of elements in clonemessh: " << clnel << endl;
//o primeiro patch come�a em zero
patchindex.Push(0);
for (i=0; i<clnel; i++){
//cout << endl << endl << "Evaluating patch for element: " << i << endl;
clonecmesh->GetElementPatch(n2elgraph,n2elgraphid,elgraph,elgraphindex,i,patchel);
cout << "Patch elements: " << patchel.NElements() << endl;
/*for (k=0;k<patchel.NElements();k++){
clonecmesh->ElementVec()[patchel[k]]->Reference()->Print();
cout << endl;
}*/
for (j=0; j<patchel.NElements(); j++){
//obten��o do elemento geom�trico do patch
//cout << "Creating geometric clone elements for computational element :" << j << endl;
TPZGeoEl *gel = clonecmesh->ElementVec()[patchel[j]]->Reference();
//gel->Print(cout);
//inserir todos os pais do elemento geom�trico do patch
int64_t count = 0;
//cout << "Inserting father element:" << "\t";
while(gel){
TPZGeoEl *father = gel->Father();
if (father){
//father->Print(cout);
gel = father;
continue;
}
else toclonegel.Push(gel);
gel = father;
//cout << count << "\t";
count ++;
}
//cout << endl;
}
int64_t sum = toclonegel.NElements()-1;
//cout << endl << sum << endl;
patchindex.Push(sum);
/*for (k=patchindex[i];k<patchindex[i+1];k++){
toclonegel[k]->Print();
}*/
}
cout <<endl;
cout << endl;
TPZGeoCloneMesh geoclone(&geomesh);
TPZStack<TPZGeoEl*> testpatch;
for (j=0; j<1/*patchindex.NElements()-1*/;j++){
cout << "\n\n\nClone do Patch do elemento: " << j <<endl;
k=0;
cout << patchindex[j] << "\t" << patchindex[j+1] <<endl;
for (i=patchindex[j];i<=patchindex[j+1];i++){
testpatch.Push(toclonegel[i]);
toclonegel[i]->Print();
cout << k << endl;
k++;
}
geoclone.SetElements(testpatch,testpatch[patchindex[j]]);
geoclone.Print(cout);
}
//geoclone.SetElements(testpatch);
//geoclone.Print(cout);
/**************************************************************************
* Fim da cria��o do clone
**************************************************************************/
/* output <<"Impress�o dos Pathces\nN�mero total de patches encontrados\t" << patchindex.NElements()-1 << endl;
cout << "\n\n&&&&&&&&&&&&&&&&&&&&&&&&\n N�mero total de patches: " << patchindex.NElements()-1 << endl
<< "&&&&&&&&&&&&&&&&&&&&&&&&" << endl;
for (i=0;i<patchindex.NElements()-1;i++){
cout << "Patch do elemento " << i << "\t" << "N�mero de elementos componentes do patch: " << (patchindex[i+1]-patchindex[i]) << endl;
for (j = patchindex[i]; j<patchindex[i+1]; j++){
toclonegel[j]->Print();
cout << "||||||||||||||||||||||||||||||||" << endl;
}
cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n" <<">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n";
cout.flush();
}
*/
comp->LoadReferences();
cout.flush();
cout << endl;
cout.flush();
delete comp;
delete clonecmesh;
return (0);
}
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;
}
void TPZAdaptMesh::BuildReferencePatch() {
// the fGeoRef elements are a partition of the computational domain (should be)
// create a computational element based on each reference element
TPZGeoMesh *gmesh = fReferenceCompMesh->Reference();
gmesh->ResetReference();
TPZCompMesh *tmpcmesh = new TPZCompMesh (gmesh);
int i,j;
for (i=0;i<fGeoRef.NElements();i++){
long index;
tmpcmesh->CreateCompEl(fGeoRef[i],index);
}
tmpcmesh->CleanUpUnconnectedNodes();
tmpcmesh->ExpandSolution();
TPZStack <long> patchelindex;
TPZStack <TPZGeoEl *> toclonegel;
TPZStack<long> elgraph;
TPZVec<long> n2elgraph;
TPZVec<long> n2elgraphid;
TPZVec<long> elgraphindex;
tmpcmesh->GetNodeToElGraph(n2elgraph,n2elgraphid,elgraph,elgraphindex);
// we use the node to elgraph structure to decide which elements will be included
int clnel = tmpcmesh->NElements();
// clnel corresponds to the number of patches
// fPatch and fPatchIndex form a compacted list which form the patches.
// Boundary elements will be added to each patch.
fPatchIndex.Push(0);
for (int ipatch=0; ipatch<clnel; ipatch++){
tmpcmesh->GetElementPatch(n2elgraph,n2elgraphid,elgraph,elgraphindex,ipatch,patchelindex);
for (j=0; j<patchelindex.NElements(); j++){
TPZGeoEl *gel = tmpcmesh->ElementVec()[patchelindex[j]]->Reference();
// int count = 0;
if(gel) fPatch.Push(gel);
}
int sum = fPatch.NElements();
fPatchIndex.Push(sum);
}
#ifdef DEBUG2
// CAJU TOOL
{
std::string filename("cMeshVtk.");
{
std::stringstream finalname;
finalname << filename << 0 << ".vtk";
ofstream file(finalname.str().c_str());
/** @brief Generate an output of all geometric elements that have a computational counterpart to VTK */
//static void PrintCMeshVTK(TPZGeoMesh *gmesh, std::ofstream &file, bool matColor = false);
TPZVTKGeoMesh::PrintCMeshVTK(gmesh,file,true);
}
for (int ip=0; ip<clnel; ip++) {
int firstindex = fPatchIndex[ip];
int lastindex = fPatchIndex[ip+1];
gmesh->ResetReference();
tmpcmesh->LoadReferences();
std::set<TPZGeoEl *> loaded;
for (int ind=firstindex; ind<lastindex; ind++) {
TPZGeoEl *gel = fPatch[ind];
loaded.insert(gel);
}
int ngel = gmesh->NElements();
for (int el=0; el<ngel; el++) {
TPZGeoEl *gel = gmesh->ElementVec()[el];
if (!gel) {
continue;
}
if (gel->Reference() && loaded.find(gel) == loaded.end()) {
gel->ResetReference();
}
}
std::stringstream finalname;
finalname << filename << ip+1 << ".vtk";
ofstream file(finalname.str().c_str());
/** @brief Generate an output of all geometric elements that have a computational counterpart to VTK */
//static void PrintCMeshVTK(TPZGeoMesh *gmesh, std::ofstream &file, bool matColor = false);
TPZVTKGeoMesh::PrintCMeshVTK(gmesh,file,true);
}
}
#endif
// cleaning reference to computational elements into temporary cmesh
gmesh->ResetReference();
delete tmpcmesh;
// loading references between geometric and computational meshes (originals)
fReferenceCompMesh->LoadReferences();
}
