示例#1
0
int main(/*int argc, char *argv[]*/)
{
    InitializePZLOG();
    gRefDBase.InitializeUniformRefPattern(EOned);
    gRefDBase.InitializeUniformRefPattern(EQuadrilateral);
    gRefDBase.InitializeUniformRefPattern(ETriangle);
    
    
    int p =1;
    int ndiv = 1;
    TPZGeoMesh *gmesh = GMesh(false, 1, 1);
    UniformRefine( gmesh,ndiv);
    
    ofstream filegmesh1("gmes.txt");
    gmesh->Print(filegmesh1);
    
    
    TPZCompMesh *cmesh1 = MeshH1(gmesh, p, 2,true);//malha para y(estado)
        ofstream filemesh1("malhaY.txt");
        cmesh1->Print(filemesh1);
    TPZCompMesh *cmesh2 = MeshL2(gmesh, p, 2);//malha para controle(u)
    ofstream filemesh2("malhaU.txt");
    cmesh2->Print(filemesh2);
    TPZCompMesh *cmesh3 = MeshH1(gmesh, p, 2,false);//malha para mult.lagrange(p)
    ofstream filemesh3("malhaP.txt");
    cmesh3->Print(filemesh3);
    
    TPZManVector<TPZCompMesh *,3> meshvec(3);
    meshvec[0] = cmesh1;
    meshvec[1] = cmesh2;
    meshvec[2] = cmesh3;
    TPZCompMesh * mphysics = MalhaMultifisicaOpt(meshvec, gmesh);
    ofstream filemesh4("malhaMulti.txt");
    mphysics->Print(filemesh4);
    
    
    
    //Resolver problema
    TPZAnalysis analysis(mphysics,false);
    //TPZParFrontStructMatrix<TPZFrontSym<STATE> > strmat(mphysics);
    //strmat.SetDecomposeType(ELDLt);
    TPZSkylineStructMatrix strmat(mphysics);
    
    //strmat.SetNumThreads(6);
    analysis.SetStructuralMatrix(strmat);
    TPZStepSolver<STATE> step;
    step.SetDirect(ELDLt); //caso simetrico
    analysis.SetSolver(step);
    analysis.Assemble();
    analysis.Solve();
    
    std::ofstream out("SolOpt.txt");
    analysis.Solution().Print("Solucao",out);

    
    
    //Post-Process
    TPZBuildMultiphysicsMesh::TransferFromMultiPhysics(meshvec, mphysics);
    
    TPZManVector<std::string,10> scalnames(4), vecnames(0);
    scalnames[0] = "State";
    scalnames[1] = "Control";
    scalnames[2]="LagrangeMult";
    scalnames[3]="ExactState";
    
    std::stringstream name;
    name << "Solution_Opt" <<ndiv<< ".vtk";
    std::string paraviewfile(name.str());
    analysis.DefineGraphMesh(2,scalnames,vecnames,paraviewfile);
    analysis.PostProcess(0);
    
    //visualizar matriz no vtk
    //    TPZFMatrix<REAL> vismat(100,100);
    //    mphysics->ComputeFillIn(100,vismat);
    //    VisualMatrixVTK(vismat,"matrixstruct.vtk");
    
    
	return EXIT_SUCCESS;
}
示例#2
0
文件: Main.cpp 项目: labmec/neopz
int main(int argc, char *argv[])
{
    
    std::string dirname = PZSOURCEDIR;
#ifdef LOG4CXX
    InitializePZLOG();
#endif
    
    gRefDBase.InitializeRefPatterns();
    
    TPZReadGIDGrid readGid;
    
    TPZGeoMesh *gmesh =  readGid.GeometricGIDMesh("../rail.dump");
    
    {
        std::ofstream out("../GmeshOrig.vtk");
        TPZVTKGeoMesh::PrintGMeshVTK(gmesh, out);
    }
    InsertBoundaryElements(gmesh);
    // CASO NAO TEM TRILHO 2
    SwitchBCTrilho2(gmesh);
    
    AddZZeroFaces(gmesh);

    RefineGMesh(gmesh);
    
    {
        std::ofstream out("../GmeshRef.vtk");
        TPZVTKGeoMesh::PrintGMeshVTK(gmesh, out);
    }
    
    const int porder = 2;
    TPZCompMesh * cmesh = ComputationalElasticityMesh3D(gmesh,porder);
    
    AdaptPOrders(cmesh, -400., 2);

    // toto
//    {
//        std::set<int> mats;
//        mats.insert(bcbottom);
//        TPZManVector<STATE> force(1,0.);
//        force = cmesh->Integrate("StressZ", mats);
//        std::cout << "force = " << force << std::endl;
//    }
    
    {
        std::ofstream out("../CmeshRef.vtk");
        TPZVTKGeoMesh::PrintCMeshVTK(cmesh, out);
    }
    {
        TPZFMatrix<STATE> visualf;
        cmesh->ComputeFillIn(150, visualf);
        VisualMatrix(visualf,"../VisualMatrixBefore.vtk");
    }

    
    TPZAnalysis an;
    TPZAutoPointer<TPZRenumbering> renumber;
//    renumber = new TPZSloan;
//    renumber = new TPZCutHillMcKee;
    renumber = new TPZMetis;
    an.SetRenumber(renumber);
    an.SetCompMesh(cmesh, true);
    
#ifdef PZDEBUG
    {
        std::ofstream out("../gmesh.txt");
        gmesh->Print(out);
    }
    
    {
        std::ofstream out("../cmesh.txt");
        cmesh->Print(out);
    }
    
#endif
    {
        TPZFMatrix<STATE> visualf;
        cmesh->ComputeFillIn(150, visualf);
        VisualMatrix(visualf,"../MatrixMetis.vtk");
    }

    std::cout << "NEquations " << an.Solution().Rows() << std::endl;
    
    SolveSist(&an,cmesh);
    
    std::set<int> mats;
    mats.insert(bcbottom);
    TPZManVector<STATE> Force(1,0.);
    Force = cmesh->Integrate("StressZ", mats);
    std::cout << "Integrated sigma_Z " << Force << std::endl;
    
    std::cout << "Post processing" << std::endl;
    
    PostProcessElasticity(an, "../postProc.vtk");
    
    std::cout << "Finished\n";
//    delete cmesh;
//    delete gmesh;
    return EXIT_SUCCESS;
}
示例#3
0
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);
    
}
示例#4
0
文件: flavio.c 项目: labmec/neopz
int main() {

   //malha geometrica
   TPZGeoMesh *firstmesh = new TPZGeoMesh;
   firstmesh->SetName("Malha Geometrica : Nós e Elementos");
   firstmesh->NodeVec().Resize(10);
   TPZVec<REAL> coord(2);   //,coordtrans(2);
//   REAL ct,st,PI=3.141592654;
//   cout << "\nEntre rotacao do eixo n1 (graus) -> ";
//   REAL g;
//   cin >> g;
//   g = g*PI/180.;
//   ct = cos(g);
//   st = sin(g);
//ct = 1.;
//st = 0.;

   //nos geometricos

   //no 0
   coord[0] = 0;
   coord[1] = 0;
// coordtrans[0] =  ct*coord[0]-st*coord[1];
// coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[0].Initialize(coord,*firstmesh);

   //no 1
   coord[0] = 1.;
   coord[1] = 0;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[1].Initialize(coord,*firstmesh);

   //no 2
   coord[0] = 2.;
   coord[1] = 0.;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[2].Initialize(coord,*firstmesh);

   //no 3
   coord[0] = 3.;
   coord[1] = 0.;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[3].Initialize(coord,*firstmesh);

   //no 4
   coord[0] = 4;
   coord[1] = 0.;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[4].Initialize(coord,*firstmesh);

   //no 5
   coord[0] = 0;
   coord[1] = 1;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[5].Initialize(coord,*firstmesh);

   //no 6
   coord[0] = 1.;
   coord[1] = 1.;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[6].Initialize(coord,*firstmesh);

   //no 7
   coord[0] = 2.;
   coord[1] = 1.;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[7].Initialize(coord,*firstmesh);

   //no 8
   coord[0] = 3.;
   coord[1] = 1;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//  coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[8].Initialize(coord,*firstmesh);

   //no 9
   coord[0] = 4;
   coord[1] = 1;
//   coordtrans[0] =  ct*coord[0]-st*coord[1];
//   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[9].Initialize(coord,*firstmesh);

   /*
   TPZVec<int> nodeindexes(3);
   nodeindexes[0] = 0;
   nodeindexes[1] = 1;
   nodeindexes[2] = 2;
    //elementos geometricos
   TPZGeoElT2d *elg0 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);
   nodeindexes[0] = 0;
   nodeindexes[1] = 2;
   nodeindexes[2] = 3;
   TPZGeoElT2d *elg1 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);
   nodeindexes[0] = 0;
   nodeindexes[1] = 1;
   nodeindexes[2] = 2;
   TPZGeoElT2d *elg2 = new TPZGeoElT2d(nodeindexes,2,*firstmesh);
   nodeindexes[0] = 0;
   nodeindexes[1] = 2;
   nodeindexes[2] = 3;
   TPZGeoElT2d *elg3 = new TPZGeoElT2d(nodeindexes,2,*firstmesh);
*/
   TPZVec<int> nodeindexes(4);
    //elementos geometricos
   TPZGeoEl *elg[4];

   nodeindexes[0] = 0;
   nodeindexes[1] = 1;
   nodeindexes[2] = 6;
   nodeindexes[3] = 5;
   elg[0] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);

   nodeindexes[0] = 1;
   nodeindexes[1] = 2;
   nodeindexes[2] = 7;
   nodeindexes[3] = 6;
   elg[1] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);

   nodeindexes[0] = 2;
   nodeindexes[1] = 3;
   nodeindexes[2] = 8;
   nodeindexes[3] = 7;
   elg[2] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);

   nodeindexes[0] = 3;
   nodeindexes[1] = 4;
   nodeindexes[2] = 9;
   nodeindexes[3] = 8;
   elg[3] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);

   //Arquivos de saida
   ofstream outgm1("outgm1.dat");
   ofstream outcm1("outcm1.dat");
   ofstream outcm2("outcm2.dat");

   //montagem de conectividades entre elementos
   firstmesh->BuildConnectivity();
   //malha computacional
   TPZCompMesh *secondmesh = new TPZCompMesh(firstmesh);
   secondmesh->SetName("Malha Computacional : Conectividades e Elementos");


   //material
   TPZMaterial *pl = LerMaterial("flavio.dat");
   secondmesh->InsertMaterialObject(pl);
//   pl = LerMaterial("placa2.dat");
//   secondmesh->InsertMaterialObject(pl);
//   pl = LerMaterial("placa3.dat");
//   secondmesh->InsertMaterialObject(pl);

   // carregamento hidrostatico no plano vertica xz
   pl->SetForcingFunction(PressaoHid);

   //CC : condicões de contorno
   TPZBndCond *bc;
   REAL big = 1.e12;
   TPZFMatrix val1(6,6,0.),val2(6,1,0.);

   // engastes nos lados 4 e 7 do elemento 0
   TPZGeoElBC(elg[0],4,-2,*firstmesh);
   TPZGeoElBC(elg[0],7,-2,*firstmesh);

   // engaste no lado 4 do elemento 1
   TPZGeoElBC(elg[1],4,-2,*firstmesh);

   // engaste no lado 4 do elemento 2
   TPZGeoElBC(elg[2],4,-2,*firstmesh);

   // engaste no lado 4 do elemento 3
   TPZGeoElBC(elg[3],4,-2,*firstmesh);

   // imposicao do valor zero associado a condicao -2 (engaste)
   bc = pl->CreateBC(-2,0,val1,val2);
   secondmesh->InsertMaterialObject(bc);

   // imposicao da condicao de simetria no lado 5 do elemento 4
   val1(0,0)=big;
   val1(1,1)=0.;
   val1(2,2)=0.;
   val1(3,3)=0.;
   val1(4,4)=big;
   val1(5,5)=big;
   TPZGeoElBC(elg[3],5,-3,*firstmesh);
   bc = pl->CreateBC(-3,2,val1,val2);
   secondmesh->InsertMaterialObject(bc);

   //ordem de interpolacao
   int ord;
   cout << "Entre ordem 1,2,3,4,5 : ";
   cin >> ord;
//   TPZCompEl::gOrder = ord;
   firstmesh.SetDefaultOrder(order);
   //construção malha computacional
   TPZVec<int> csub(0);
   TPZManVector<TPZGeoEl *> pv(4);
   int n1=1,level=0;
   cout << "\nDividir ate nivel ? ";
   int resp;
   cin >> resp;
   int nelc = firstmesh->ElementVec().NElements();
   int el;
   TPZGeoEl *cpel;
   for(el=0;el<firstmesh->ElementVec().NElements();el++) {
     cpel = firstmesh->ElementVec()[el];
     if(cpel && cpel->Level() < resp)
		cpel->Divide(pv);

   }
   cout << "\nDividir o elemento esquerdo superior quantas vezes? ";
   cin >> resp;
   cpel = firstmesh->ElementVec()[0];
   for(el=0; el<resp; el++) {
		cpel->Divide(pv);
		cpel = pv[3];
   }
   //analysis
   secondmesh->AutoBuild();
   firstmesh->Print(outgm1);
   outgm1.flush();
   secondmesh->AdjustBoundaryElements();
   secondmesh->InitializeBlock();
   secondmesh->Print(outcm1);
   TPZAnalysis an(secondmesh,outcm1);
   int numeq = secondmesh->NEquations();
   secondmesh->Print(outcm1);
   outcm1.flush();
   TPZVec<int> skyline;
   secondmesh->Skyline(skyline);
   TPZSkylMatrix *stiff = new TPZSkylMatrix(numeq,skyline);
   an.SetMatrix(stiff);
   an.Solver().SetDirect(ECholesky);
   secondmesh->SetName("Malha Computacional :  Connects e Elementos");
   // Posprocessamento
   an.Run(outcm2);
   TPZVec<char *> scalnames(5);
   scalnames[0] = "Mn1";
   scalnames[1] = "Mn2";
   scalnames[2] = "Vn1";
   scalnames[3] = "Vn2";
   scalnames[4] = "Deslocz";
   TPZVec<char *> vecnames(0);
   char plotfile[] =  "placaPos.pos";
   char pltfile[] =  "placaView.plt";
   an.DefineGraphMesh(2, scalnames, vecnames, plotfile);
   an.Print("FEM SOLUTION ",outcm1);
   an.PostProcess(3);
   an.DefineGraphMesh(2, scalnames, vecnames, pltfile);
   an.PostProcess(2);
   firstmesh->Print(outgm1);
   outgm1.flush();
   delete secondmesh;
   delete firstmesh;
   return 0;
}
示例#5
0
文件: main.cpp 项目: labmec/neopz
TPZCompMesh * CMeshFooting2D(TPZGeoMesh * gmesh, int p_order){
    
    unsigned int dim  = gmesh->Dimension();
    const std::string name("ElastoPlastic Footing Problem ");

    // Setting up attributes
    TPZCompMesh * cmesh = new TPZCompMesh(gmesh);
    cmesh->SetName(name);
    cmesh->SetDefaultOrder(p_order);
    cmesh->SetDimModel(dim);
    
    // Mohr Coulomb data
    REAL mc_cohesion    = 10.0;
    REAL mc_phi         = (20.0*M_PI/180);
    REAL mc_psi         = mc_phi;
    
    /// ElastoPlastic Material using Mohr Coulomb
    // Elastic predictor
    TPZElasticResponse ER;
    REAL G = 400*mc_cohesion;
    REAL nu = 0.3;
    REAL E = 2.0*G*(1+nu);
    

    TPZPlasticStepPV<TPZYCMohrCoulombPV, TPZElasticResponse> LEMC;
    ER.SetEngineeringData(E, nu);
    LEMC.SetElasticResponse(ER);
    LEMC.fYC.SetUp(mc_phi, mc_psi, mc_cohesion, ER);
    int PlaneStrain = 1;
    
//    TPZElasticCriterion MatEla;
//    MatEla.SetElasticResponse(ER);
//    TPZMatElastoPlastic2D < TPZElasticCriterion, TPZElastoPlasticMem > * material = new TPZMatElastoPlastic2D < TPZElasticCriterion, TPZElastoPlasticMem >(ERock,PlaneStrain);
//    material->SetPlasticityModel(MatEla);
//    cmesh->InsertMaterialObject(material);
    
    TPZMatElastoPlastic2D < TPZPlasticStepPV<TPZYCMohrCoulombPV, TPZElasticResponse>, TPZElastoPlasticMem > * material = new TPZMatElastoPlastic2D < TPZPlasticStepPV<TPZYCMohrCoulombPV, TPZElasticResponse>, TPZElastoPlasticMem >(ERock,PlaneStrain);
    material->SetPlasticityModel(LEMC);
    cmesh->InsertMaterialObject(material);
    
    
    TPZFMatrix<STATE> val1(2,2,0.), val2(2,1,0.);
    
    val2(0,0) = 0;
    val2(1,0) = 1;
    TPZBndCond * bc_bottom = material->CreateBC(material, EBottomBC, Eu_null, val1, val2);
    
    val2(0,0) = 1;
    val2(1,0) = 0;
    TPZBndCond * bc_lateral = material->CreateBC(material, ELateralBC, Eu_null, val1, val2);
    
//    val2(0,0) = 0;
//    val2(1,0) = 0;
//    val1(0,0) = 0;
//    val1(1,1) = 1;
    val2(0,0) = 0;
    val2(1,0) = 0;
    TPZBndCond * bc_top = material->CreateBC(material, ETopBC, ETn, val1, val2);
    
    val2(0,0) = 0;
    val2(1,0) = 0;
    TPZBndCond * bc_top_null = material->CreateBC(material, ETopNullBC, ETn, val1, val2);
    
    cmesh->InsertMaterialObject(bc_bottom);
    cmesh->InsertMaterialObject(bc_lateral);
    cmesh->InsertMaterialObject(bc_top);
//    cmesh->InsertMaterialObject(bc_top_null);
    
    cmesh->SetAllCreateFunctionsContinuousWithMem();
    cmesh->AutoBuild();
    
#ifdef PZDEBUG
    std::ofstream out("cmesh.txt");
    cmesh->Print(out);
#endif
    
    return cmesh;
}
示例#6
0
文件: mainHp.cpp 项目: labmec/neopz
int main2()
{
	
#ifdef LOG4CXX
	{
		InitializePZLOG();
		std::stringstream sout;
		sout<< "Testando p adaptatividade"<<endl;
		LOGPZ_DEBUG(logger, sout.str().c_str());
	}
#endif
    
    //std::ofstream erro("TaxaArcTanQuadUni.txt");
   // std::ofstream erro("TaxaArcTanTriangNaoUni.txt");
    //std::ofstream erro("TaxaProbJuan.txt");
    //std::ofstream erro("TaxaCNMACQuadUni.txt");
    //    std::ofstream erro("TaxaCNMACQuadNaoUni.txt");
    std::ofstream erro("TaxaCNMACTriangUni.txt");
    
   //bool ftriang=false;
    bool prefine=false;
//    bool nouniform=false;//false para ref uniforme
//    REAL Lx=1;
//    REAL Ly=1;
    
    
    
    //TPZGeoMesh *gmesh = GMesh(ftriang, Lx,  Ly);
    //UniformRefine(gmesh, 1);
    //RefiningNearCircunference(2,gmesh,1,1);
    //std::ofstream filemesh2("MalhaGeoIni.vtk");
    //PrintGMeshVTK( gmesh, filemesh2);
   // TPZGeoMesh *gmesh =GMesh(ftriang, Lx,  Ly);//MalhaGeoT(h,hrefine);
    TPZGeoMesh *gmesh =MalhaGeo2(1);
    ofstream arg("gmeshInicial.txt");
    gmesh->Print(arg);
    
	TPZVec<REAL> calcErro;
	for (int porder=1; porder<2; porder++) {
        
//        TPZCompMesh *cmesh = CompMeshPAdap(*gmesh,porder,prefine);
//        ofstream arg2("CmeshInicial.txt");
//        cmesh->Print(arg2);
//        
//        SetDifferentOrderP(cmesh,porder);
//        ofstream arg22("CmeshDifOrder.txt");
//        cmesh->Print(arg22);

        
        erro<<"ordem "<<porder <<std::endl;
        for(int h=1;h<4;h++){
        //    erro << "NRef " << h << std::endl;
            
            erro<<std::endl;
            
            //1. Criacao da malha geom. e computacional
 //           bool hrefine=true;//true nao uniforme
           // TPZGeoMesh *gmesh =MalhaGeo2(h);//MalhaGeoT(h,nouniform);//MalhaGeo(h,nouniform);//GMesh(ftriang, Lx,  Ly);//MalhaGeo(h,nonuniform);
            

//            UniformRefine(gmesh, h);
//            ofstream arg3("gmeshRefinada.txt");
//            gmesh->Print(arg3);
//         NoUniformRefine(gmesh, h);
//            std::ofstream filemesh("MalhaGeoNaoUniT.vtk");
//            std::ofstream filemesh("MalhaGeoUniQCNMAC.vtk");
            //std::ofstream filemesh("MalhaGeoNaoUniQCNMAC.vtk");
           std::ofstream filemesh("MalhaGeo4ElCNMAC.vtk");
            PrintGMeshVTK( gmesh, filemesh);
            

//            RefiningNearCircunference(2,gmesh,h,1);
//            std::ofstream filemesh2("MalhaGeoQArcTanRefeineNearCirc.vtk");
//            PrintGMeshVTK( gmesh, filemesh2);
            
            TPZCompMesh *cmesh = CompMeshPAdap(*gmesh,porder,prefine);//CompMeshPAdapJuan(*gmesh,porder,prefine);
            ofstream arg2("CmeshInicial.txt");
            cmesh->Print(arg2);
            
            SetDifferentOrderPMesh4Elem(cmesh,porder);
            ofstream arg22("CmeshDifOrder.txt");
            cmesh->Print(arg22);
            
            
            int nDofs;
            nDofs=cmesh->NEquations();
            
            erro<< "\nNRefinamento "<<h<< "   NDofs "<<nDofs<<std::endl;
            
            std::cout << "Neq = " << nDofs << std::endl;
            
            //2. Resolve o problema
            
            TPZAnalysis analysis(cmesh);
            int numthreads = 1;
            SolveSyst(analysis, cmesh, numthreads);
            // SolveLU ( analysis );
            
            
            
            //3. Calcula o erro

//			TPZVec<REAL> calcErro;
//            analysis.SetExact(*SolExata);
//			analysis.PostProcess(calcErro,erro);
            
            ErrorHDiv(cmesh, erro);
            
            UniformRefine(gmesh, h);
            ofstream arg3("gmeshRefinada.txt");
            gmesh->Print(arg3);
            
      
            /*4. visualizacao grafica usando vtk
            
            TPZVec<std::string> scalnames(5), vecnames(2);
            scalnames[0] = "Divergence";
            scalnames[1] = "ExactDiv";
            scalnames[2] = "Pressure";//"Solution";//
            scalnames[3] = "ExactPressure";
            scalnames[4] = "ExactDiv";
            
            
            vecnames[0] = "ExactFlux";
            vecnames[1] = "Flux";//"Derivative";//

            const int dim = 2;
            int div = 2;
            
            char buf[256] ;
            //sprintf(buf,"ArcTanPhilUniMeshQ_porder%d_h%d.vtk",porder,h);
           // sprintf(buf,"ProblemaJuan_porder%d_h%d.vtk",porder,h);
            sprintf(buf,"ProblemaCNAMC_porder%d_h%d.vtk",porder,h);
            analysis.DefineGraphMesh(dim,scalnames,vecnames,buf);
            analysis.PostProcess(div);
 
#ifdef LOG4CXX
            if (logger->isDebugEnabled()) {
                std::stringstream sout;
                cmesh->Print(sout);
                LOGPZ_DEBUG(logger, sout.str())
            }
#endif
            */
            
            
            //              std::string plotfile("GraficArcTanHpAdaptivity.vtk");
            //              const int dim = 2;
            //              int div = 2;
            //              analysis.DefineGraphMesh(dim,scalnames,vecnames,plotfile);
            //              analysis.PostProcess(div);
            //
            //        UniformRefine(gmesh, 1);
            //         std::ofstream filemesh2("MalhaGeoDepois.vtk");
            //        PrintGMeshVTK( gmesh, filemesh2);
           // delete cmesh;
           // delete gmesh;
            
        }
    }
	
	
	return 0;
}
示例#7
0
文件: placa.c 项目: labmec/neopz
int main() {

   //malha geometrica
   TPZGeoMesh *firstmesh = new TPZGeoMesh;
   firstmesh->SetName("Malha Geometrica : Nós e Elementos");
   firstmesh->NodeVec().Resize(4);
   TPZVec<REAL> coord(2),coordtrans(2);
   REAL ct,st,PI=3.141592654;
   cout << "\nEntre rotacao do eixo n1 (graus) -> ";
   REAL g;
   cin >> g;
   g = g*PI/180.;
   ct = cos(g);
   st = sin(g);
   //ct = 1.;
   //st = 0.;
   coord[0] = 0;
   coord[1] = 0;
   coordtrans[0] =  ct*coord[0]-st*coord[1];
   coordtrans[1] =  st*coord[0]+ct*coord[1];
   //nos geometricos
   firstmesh->NodeVec()[0].Initialize(coordtrans,*firstmesh);
   coord[0] = 5;
   coordtrans[0] =  ct*coord[0]-st*coord[1];
   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[1].Initialize(coordtrans,*firstmesh);
   coord[0] = 5;
   coord[1] = 5;
   coordtrans[0] =  ct*coord[0]-st*coord[1];
   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[2].Initialize(coordtrans,*firstmesh);
   coord[0] = 0;
   coordtrans[0] =  ct*coord[0]-st*coord[1];
   coordtrans[1] =  st*coord[0]+ct*coord[1];
   firstmesh->NodeVec()[3].Initialize(coordtrans,*firstmesh);
/*
   TPZVec<int> nodeindexes(3);
   nodeindexes[0] = 0;
   nodeindexes[1] = 1;
   nodeindexes[2] = 2;
    //elementos geometricos
   TPZGeoElT2d *elg0 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);
   nodeindexes[0] = 0;
   nodeindexes[1] = 2;
   nodeindexes[2] = 3;
   TPZGeoElT2d *elg1 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);
   nodeindexes[0] = 0;
   nodeindexes[1] = 1;
   nodeindexes[2] = 2;
   TPZGeoElT2d *elg2 = new TPZGeoElT2d(nodeindexes,2,*firstmesh);
   nodeindexes[0] = 0;
   nodeindexes[1] = 2;
   nodeindexes[2] = 3;
   TPZGeoElT2d *elg3 = new TPZGeoElT2d(nodeindexes,2,*firstmesh);
*/
   TPZVec<int> nodeindexes(4);
   nodeindexes[0] = 0;
   nodeindexes[1] = 1;
   nodeindexes[2] = 2;
   nodeindexes[3] = 3;
    //elementos geometricos
   TPZGeoEl *elg0 = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);
   TPZGeoEl *elg1 = new TPZGeoElQ2d(nodeindexes,2,*firstmesh);
   TPZGeoEl *elg2 = new TPZGeoElQ2d(nodeindexes,3,*firstmesh);

   //Arquivos de saida
   ofstream outgm1("outgm1.dat");
   ofstream outcm1("outcm1.dat");
   ofstream outcm2("outcm2.dat");
   //montagem de conectividades entre elementos
   firstmesh->BuildConnectivity();
   //malha computacional
   TPZCompMesh *secondmesh = new TPZCompMesh(firstmesh);
   secondmesh->SetName("Malha Computacional : Conectividades e Elementos");
   //material
   TPZMaterial *pl = LerMaterial("placa1.dat");
   secondmesh->InsertMaterialObject(pl);
   pl = LerMaterial("placa2.dat");
   secondmesh->InsertMaterialObject(pl);
   pl = LerMaterial("placa3.dat");
   secondmesh->InsertMaterialObject(pl);
   //CC : condicões de contorno
   TPZBndCond *bc;
   REAL big = 1.e12;
   TPZFMatrix val1(6,6,0.),val2(6,1,0.);

   val1(0,0)=big;
   val1(1,1)=big;
   val1(2,2)=big;
   val1(3,3)=0.;
   val1(4,4)=0.;
   val1(5,5)=0.;

   TPZGeoElBC(elg0,5,-2,*firstmesh);
   bc = pl->CreateBC(-2,2,val1,val2);
   secondmesh->InsertMaterialObject(bc);


   TPZGeoElBC(elg0,6,-3,*firstmesh);
   bc = pl->CreateBC(-3,2,val1,val2);
   secondmesh->InsertMaterialObject(bc);

   val1(0,0)=0.;
   val1(1,1)=big;
   val1(2,2)=0.;
   val1(3,3)=big;
   val1(4,4)=0.;
   val1(5,5)=0.;

	TPZGeoElBC(elg0,4,-1,*firstmesh);
   bc = pl->CreateBC(-1,2,val1,val2);
   secondmesh->InsertMaterialObject(bc);

   val1(0,0)=big;
   val1(1,1)=0.;
   val1(2,2)=0.;
   val1(3,3)=0.;
   val1(4,4)=big;
   val1(5,5)=0.;

	TPZGeoElBC(elg0,7,-4,*firstmesh);
   bc = pl->CreateBC(-4,2,val1,val2);
   secondmesh->InsertMaterialObject(bc);

   //ordem de interpolacao
   int ord;
   cout << "Entre ordem 1,2,3,4,5 : ";
   cin >> ord;
//   TPZCompEl::gOrder = ord;
   cmesh.SetDefaultOrder(ord);
   //construção malha computacional
   TPZVec<int> csub(0);
   TPZManVector<TPZGeoEl *> pv(4);
   int n1=1,level=0;
   cout << "\nDividir ate nivel ? ";
   int resp;
   cin >> resp;
   int nelc = firstmesh->ElementVec().NElements();
   int el;
   TPZGeoEl *cpel;
   for(el=0;el<firstmesh->ElementVec().NElements();el++) {
     cpel = firstmesh->ElementVec()[el];
     if(cpel && cpel->Level() < resp)
		cpel->Divide(pv);

   }
   //analysis
   secondmesh->AutoBuild();
   secondmesh->AdjustBoundaryElements();
   secondmesh->InitializeBlock();
   secondmesh->Print(outcm1);
   TPZAnalysis an(secondmesh,outcm1);
   int numeq = secondmesh->NEquations();
   secondmesh->Print(outcm1);
   outcm1.flush();
   TPZVec<int> skyline;
   secondmesh->Skyline(skyline);
   TPZSkylMatrix *stiff = new TPZSkylMatrix(numeq,skyline);
   an.SetMatrix(stiff);
   an.Solver().SetDirect(ECholesky);
   secondmesh->SetName("Malha Computacional :  Connects e Elementos");
   // Posprocessamento
   an.Run(outcm2);
   TPZVec<char *> scalnames(5);
   scalnames[0] = "Mn1";
   scalnames[1] = "Mn2";
   scalnames[2] = "Sign1";
   scalnames[3] = "Sign2";
   scalnames[4] = "Deslocz";
   TPZVec<char *> vecnames(0);
   char plotfile[] =  "placaPos.pos";
   char pltfile[] =  "placaView.plt";
   an.DefineGraphMesh(2, scalnames, vecnames, plotfile);
   an.Print("FEM SOLUTION ",outcm1);
   an.PostProcess(2);
   an.DefineGraphMesh(2, scalnames, vecnames, pltfile);
   an.PostProcess(2);
   firstmesh->Print(outgm1);
   outgm1.flush();
   delete secondmesh;
   delete firstmesh;
   return 0;
}
示例#8
0
文件: cedric1.c 项目: labmec/neopz
int main() {

   //malha geometrica
   TPZGeoMesh *firstmesh = new TPZGeoMesh;
   firstmesh->NodeVec().Resize(3);
   TPZVec<REAL> coord(2);
   coord[0] = 0.;
   coord[1] = 0.;
   //nos geometricos
   firstmesh->NodeVec()[0].Initialize(coord,*firstmesh);
   coord[0] = 1.0;
   firstmesh->NodeVec()[1].Initialize(coord,*firstmesh);
   coord[1] = 1.0;
   firstmesh->NodeVec()[2].Initialize(coord,*firstmesh);
//   coord[0] = 0.0;
//   firstmesh->NodeVec()[3].Initialize(coord,*firstmesh);
   TPZVec<int> nodeindexes(3);//triangulo
   nodeindexes[0] = 0;//local[i] = global[i] , i=0,1,2,3
   nodeindexes[1] = 1;
   nodeindexes[2] = 2;
   //elementos geometricos
   TPZGeoElT2d *elq1 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);
 //orientacao local de um segundo elemento superposto
   int i,sen;;
   cout<<"Sentido local antihorario/horario : 0/1 ?  ";
   cin>>sen;
   cout<<"Entre primeiro no = 0,1,2 : ";
   cin>>i;
   if(sen==0) {//direito
        nodeindexes[0] = (0+i)%3;//local[i] = global[j] , i,j em {0,1,2}
        nodeindexes[1] = (1+i)%3;
        nodeindexes[2] = (2+i)%3;
	} else {//inverso
        nodeindexes[0] = (0+i)%3;//local[i] = global[j] , i,j em {0,1,2}
        nodeindexes[1] = (2+i)%3;
        nodeindexes[2] = (1+i)%3;
   }
/*   nodeindexes[0] = 1;//local[i] = global[i] , i=0,1,2,3
   nodeindexes[1] = 2;
   nodeindexes[2] = 3;*/
   TPZGeoElT2d *elq2 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);//segundo elemento superposto ao primeiro
/*   coord[1] = 0.0;
   coord[0] = 2.0;
   firstmesh->NodeVec()[4].Initialize(coord,*firstmesh);
   coord[1] = 1.0;
   firstmesh->NodeVec()[5].Initialize(coord,*firstmesh);
   nodeindexes[0] = 1;//local[i] = global[i] , i=0,1,2,3
   nodeindexes[1] = 4;
   nodeindexes[2] = 5;
   nodeindexes[3] = 2;
   TPZGeoElT2d *elq2 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);    */
   //Arquivos de saida
	ofstream outgm1("outgm1.dat");
   ofstream outcm1("outcm1.dat");
	ofstream outcm2("outcm2.dat");
   //montagem de conectividades entre elementos
   firstmesh->BuildConnectivity();
 	firstmesh->Print(outgm1);
   outgm1.flush();
  	//teste de divisao geometrica : 1 elemento
   TPZVec<TPZGeoEl *> vecsub,vecsub1;
   elq1->Divide(vecsub);//divide 0
   elq2->Divide(vecsub);//divide 1
/*   vecsub[2]->Divide(vecsub1);//
   vecsub1[3]->Divide(vecsub1);
	vecsub[0]->Divide(vecsub1);//divide 1
   vecsub1[2]->Divide(vecsub1); */
 	firstmesh->Print(outgm1);
   outgm1.flush();
   //malha computacional
   TPZCompMesh *secondmesh = new TPZCompMesh(firstmesh);
   //material
   int matindex = secondmesh->MaterialVec().AllocateNewElement();
   TPZFMatrix k(1,1,1.),f(1,1,0.),c(1,2,1.);
   TPZMat2dLin * mat = new TPZMat2dLin(1);
   mat->SetMaterial(k,c,f);
   //mat->SetForcingFunction(force);
   mat->SetForcingFunction(derivforce);
   secondmesh->MaterialVec()[matindex] = mat;
   //CC : condicao de contorno
   //ordem de interpolacao
//   TPZCompEl::gOrder = 3;
   cmesh.SetDefaultOrder(3);
   //constroe a malha computacional
   secondmesh->AutoBuild();
   secondmesh->InitializeBlock();
   secondmesh->ComputeConnectSequence();
   secondmesh->Print(outcm1);
   outcm1.flush();
	//Resolucao do sistema
   TPZFMatrix Rhs(secondmesh->NEquations(),1),Stiff(secondmesh->NEquations(),secondmesh->NEquations()),U;
   Stiff.Zero();
   Rhs.Zero();
   secondmesh->Assemble(Stiff,Rhs);
   Rhs.Print("Rhs teste",outcm2);
   Stiff.Print("Bloco teste",outcm2);
	Rhs.Print("Computational Mesh -> fBlock",outcm2);
   TPZMatrixSolver solver(&Stiff);
   solver.SetDirect(ELU);
   solver.Solve(Rhs,U);
   U.Print("Resultado",outcm2);
   secondmesh->LoadSolution(U);
   secondmesh->Solution().Print("Mesh solution ",outcm2);
//   TPZElementMatrix ek,ef;
//   secondmesh->ElementVec()[0]->CalcStiff(ek,ef);
//	ek.fMat->Print();
//   ef.fMat->Print();
   delete secondmesh;
   delete firstmesh;
   return 0;
}
示例#9
0
文件: main.cpp 项目: labmec/neopz
int main(int argc, char *argv[])
{
#ifdef LOG4CXX
    InitializePZLOG();
#endif

    // example log statement
#ifdef LOG4CXX
    {
        std::stringstream sout;
        sout<<"Starting up " << std::endl;
        LOGPZ_DEBUG(logdata,sout.str())
    }
#endif
    
    ofstream arg12("Erro.txt");
    // Ordem polinomial das funções de aproximação
    int p;
    int h;
    
    for(p = 1; p < 2; p++)
    {
        arg12<<"\n ================================="<<endl;
        arg12<<"PARA ORDEM p = " << p<<endl;
        for(h = 1; h < 2;h++)
        {
            arg12<<"\nREFINAMENTO h  = " << h <<"\n\n";
            
            //---- Create a 2D geometric mesh ----
            TPZGeoMesh * gmesh = GMesh(true);
            //            ofstream arg1("gmesh_inicial.txt");
            //            gmesh->Print(arg1);
            
            //---- Create a first computational mesh -----
            TPZCompMesh * cmesh1= MalhaCompUm(gmesh, p,disc_functions);
            
            //----- Create a second computational mesh ------
            TPZCompMesh * cmesh2 = MalhaCompDois(gmesh, p,disc_functions);
            
            
            // -------Refinando as malhas de cada equacao-------
            
            // Refinando a malha da primeira equação
            gmesh->ResetReference();
            cmesh1->LoadReferences();
            // Refinando a malha com dois níveis de refinamneto uniforme
            TPZBuildMultiphysicsMesh::UniformRefineCompMesh(cmesh1,h, false);
            cmesh1->AdjustBoundaryElements();
            cmesh1->CleanUpUnconnectedNodes();
            
            //            ofstream arg4("cmesh_edp1_final.txt");
            //            cmesh1->Print(arg4);
            
            // Refinando a malha da segunda equação
            gmesh->ResetReference();
            cmesh2->LoadReferences();
            // Refinando a malha com três níveis de refinamneto uniforme
            TPZBuildMultiphysicsMesh::UniformRefineCompMesh(cmesh2,h, false);
            cmesh2->AdjustBoundaryElements();
            cmesh2->CleanUpUnconnectedNodes();
            
            //            ofstream arg6("cmesh_edp2_final.txt");
            //            cmesh2->Print(arg6);
            
            //--- Criando a malha computacional multifísica ----
            
            // Criando um vetor de malhas computacionais
            TPZVec<TPZCompMesh *> meshvec(2);
            meshvec[0] = cmesh1;
            meshvec[1] = cmesh2;
            
            // Criando a malha computacional multifisica
            TPZMatUncoupledPoissonDisc * multiphysics_material;
            TPZCompMesh * mphysics = MalhaCompMultifisica(gmesh,meshvec,multiphysics_material);
            
            ofstream arg13("gmesh_multiphysics.txt");
            gmesh->Print(arg13);
            
            // Resolvendo o sistema linear
            TPZAnalysis an(mphysics);
            ResolverSistema(an, mphysics,false);
            
            ofstream arg18("mphysics_cmesh.txt");
            mphysics->Print(arg18);
            
            // Arquivo de saida para plotar a solução
            string plotfile3("Solution_mphysics.vtk");
            SaidaSolucaoMultifisica(meshvec, mphysics, an, plotfile3);
            
            
            //Saida dos erros
            
            TPZBuildMultiphysicsMesh::TransferFromMultiPhysics(meshvec, mphysics);
            
            TPZVec<REAL> erros;
            arg12 << " Erro da simulacao multifisica para EDP 1 (solU)" << std::endl;
            
            TPZAnalysis analysis1(cmesh1);
            analysis1.SetExact(*SolExataU);
            bool store_errors = false;
            analysis1.PostProcessError(erros, store_errors, arg12);
            
            arg12<<" \nErro da simulacao multifisica para EDP 2 (solP)" <<endl;
            TPZAnalysis analysis2(cmesh2);
            analysis2.SetExact(*SolExataP);
            analysis2.PostProcessError(erros, store_errors, arg12);
            
            
            cmesh1->CleanUp();
            cmesh2->CleanUp();
            //mphysics->CleanUp();
            delete cmesh1;
            delete cmesh2;
            //delete mphysics;
            delete gmesh;
            
        }
    }
    
    return EXIT_SUCCESS;
}