TPZIntelGen<TSHAPE>::TPZIntelGen(TPZCompMesh &mesh, TPZGeoEl *gel, int &index) : TPZInterpolatedElement(mesh,gel,index) { int i; fPreferredOrder = mesh.GetDefaultOrder(); for(i=0;i<TSHAPE::NSides-TSHAPE::NCornerNodes;i++) { // fSideOrder[i] = gOrder; } for(i=0; i<TSHAPE::NSides; i++) fConnectIndexes[i]=-1; // RemoveSideRestraintsII(EInsert); gel->SetReference(this); for(i=0;i<TSHAPE::NCornerNodes;i++) { fConnectIndexes[i] = CreateMidSideConnect(i); mesh.ConnectVec()[fConnectIndexes[i]].IncrementElConnected(); } for(;i<TSHAPE::NSides;i++) { fConnectIndexes[i] = CreateMidSideConnect(i); mesh.ConnectVec()[fConnectIndexes[i]].IncrementElConnected(); IdentifySideOrder(i); } int sideorder = SideOrder(TSHAPE::NSides-1); sideorder = 2*sideorder; if (sideorder > fIntRule.GetMaxOrder()) sideorder = fIntRule.GetMaxOrder(); // TPZManVector<int,3> order(3,2*sideorder+2); TPZManVector<int,3> order(3,sideorder); //TPZManVector<int,3> order(3,20); fIntRule.SetOrder(order); }
///Funcao principal do programa int main(int argc, char *argv[]) { int dim = 2;//dimensao do problema int uNDiv=3, vNDiv=4;//numero de divisoes feitas no dominio int nel = uNDiv*vNDiv; //numero de elementos a serem utilizados int pOrder = 4; //ordem polinomial de aproximacao TPZGeoMesh *gmesh = CreateGMesh(nel, uNDiv, vNDiv); //funcao para criar a malha geometrica TPZCompMesh *cmesh = CMesh(gmesh, pOrder); //funcao para criar a malha computacional // Resolvendo o Sistema bool optimizeBandwidth = false; //impede a renumeracao das equacoes do problema(para obter o mesmo resultado do Oden) TPZAnalysis an(cmesh, optimizeBandwidth); //cria objeto de analise que gerenciaria a analise do problema an.Run();//assembla a matriz de rigidez (e o vetor de carga) global e inverte o sistema de equacoes TPZFMatrix<STATE> solucao=cmesh->Solution();//Pegando o vetor de solucao, alphaj solucao.Print("Sol",cout,EMathematicaInput);//imprime na formatacao do Mathematica //fazendo pos processamento para paraview TPZStack<string> scalnames, vecnames; scalnames.Push("State");//setando para imprimir u string plotfile = "ModelProblemSol.vtk";//arquivo de saida que estara na pasta debug an.DefineGraphMesh(dim, scalnames, vecnames, plotfile);//define malha grafica int postProcessResolution = 3;//define resolucao do pos processamento an.PostProcess(postProcessResolution);//realiza pos processamento std::cout << "FINISHED!" << std::endl; return 0; }
TPZCompMesh *TetraMesh(){ REAL Coord [8][3] = { {0.,0.,0.},{1.,0.,0.},{1.,1.,0.},{0.,1.,0.}, {0.,0.,1.},{1.,0.,1.},{1.,1.,1.},{0.,1.,1.} }; int Connects [5][4] = { {0,1,3,4}, {1,2,3,6}, {5,6,4,1}, {7,6,4,3}, {1,3,4,6} }; int i,j; TPZGeoMesh *gmesh = new TPZGeoMesh(); TPZGeoEl * elvec[5]; TPZVec <REAL> coord (3,0.); int index; //Nodes initialization for(i = 0; i < 8; i++){ for(j=0;j<3;j++){ coord[j] = Coord[i][j]; } index = gmesh->NodeVec().AllocateNewElement(); gmesh->NodeVec()[index] = TPZGeoNode(i,coord,*gmesh); } TPZVec<TPZRefPattern *> refinement_Patterns(6,0); // refinement_Patterns.Resize(6); refinement_Patterns[0] = new TPZRefPattern("/home/pos/cesar/RefPattern/Tetra_Rib_Side_4.rpt"); refinement_Patterns[1] = new TPZRefPattern("/home/pos/cesar/RefPattern/Tetra_Rib_Side_5.rpt"); refinement_Patterns[2] = new TPZRefPattern("/home/pos/cesar/RefPattern/Tetra_Rib_Side_6.rpt"); refinement_Patterns[3] = new TPZRefPattern("/home/pos/cesar/RefPattern/Tetra_Rib_Side_7.rpt"); refinement_Patterns[4] = new TPZRefPattern("/home/pos/cesar/RefPattern/Tetra_Rib_Side_8.rpt"); refinement_Patterns[5] = new TPZRefPattern("/home/pos/cesar/RefPattern/Tetra_Rib_Side_9.rpt"); for (i=0;i<6;i++) gmesh->InsertRefPattern(refinement_Patterns[i]); for (i=0;i<5;i++){ int ncon = 4; TPZVec <int> connect(ncon,0); for(j=0; j<ncon;j++){ connect[j] = Connects[i][j]; } elvec[i] = GeoElementRefPattern(gmesh,7,connect,1,i,refinement_Patterns); } //Generate neighborhod information // gmesh->Print(cout); gmesh->BuildConnectivity(); // gmesh->Print(cout); //Create computational mesh TPZCompMesh *cmesh = new TPZCompMesh(gmesh); TPZMaterial *mat; mat = new TPZMaterialTest3D (1); cmesh->InsertMaterialObject(mat); cmesh->AutoBuild(); return cmesh; }
/** * @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(); }
TPZCompMesh * ComputationalMesh(TPZGeoMesh * gmesh, int p) { int matid = 1; int dim = 2; REAL wavespeed = 1.0; ///Computational Mesh TPZCompEl::SetgOrder(p); TPZCompMesh * cmesh = new TPZCompMesh(gmesh); cmesh->SetDimModel(dim); cmesh->SetAllCreateFunctionsContinuous(); TPZMaterial * Air = new TPZLinearWave(matid,dim); cmesh->InsertMaterialObject(Air); { //Boundary Conditions TPZFMatrix<STATE> k1(dim,dim,0.), k2(dim,dim,0.); TPZMaterial * BCD = Air->CreateBC(Air, 2, 0, k1, k2); cmesh->InsertMaterialObject(BCD); TPZMaterial * BCN = Air->CreateBC(Air, 3, 1, k1, k2); cmesh->InsertMaterialObject(BCN); } cmesh->AutoBuild(); cmesh->AdjustBoundaryElements(); cmesh->CleanUpUnconnectedNodes(); return cmesh; }
TPZCompMesh *CompMesh1D(TPZGeoMesh *gmesh,int p, TPZMaterial *material,TPZVec<int> &bc,TPZVec<int> &bcType) { if(!material || bc.NElements()<2 || bcType.NElements() != bc.NElements()) return NULL; int dim = 1; TPZAutoPointer<TPZMaterial> mat(material); // related to interpolation space TPZCompEl::SetgOrder(p); TPZCompMesh *cmesh = new TPZCompMesh(gmesh); cmesh->SetDimModel(dim); cmesh->SetAllCreateFunctionsContinuous(); cmesh->InsertMaterialObject(mat); // Related to boundary conditions // REAL uN=1-cosh(1.)/sinh(1.); TPZFMatrix<STATE> val1(1,1,0.), val2(1,1,0.); if(!bcType[0]) // dirichlet val2.PutVal(0,0,0.0); TPZAutoPointer<TPZMaterial> BCond1 = material->CreateBC(mat, bc[0],bcType[0], val1, val2); cmesh->InsertMaterialObject(BCond1); if(!bcType[1]) // dirichlet val2.PutVal(0,0,0.0); TPZAutoPointer<TPZMaterial> BCond2 = material->CreateBC(mat, bc[1],bcType[1], val1, val2); cmesh->InsertMaterialObject(BCond2); //Adjusting data cmesh->AutoBuild(); cmesh->AdjustBoundaryElements(); cmesh->CleanUpUnconnectedNodes(); return cmesh; }
/** * @brief Undo the encapsulate elements */ void TPZCreateApproximationSpace::UndoCondenseLocalEquations(TPZCompMesh &cmesh) { int nel = cmesh.NElements(); int iel; for (iel=0; iel<nel; iel++) { TPZCompEl *cel = cmesh.ElementVec()[iel]; TPZCondensedCompEl *condel = dynamic_cast<TPZCondensedCompEl *>(cel); if(!condel) { continue; } condel->Unwrap(); } }
/** * @brief Encapsulate the elements in condensed computational elements */ void TPZCreateApproximationSpace::CondenseLocalEquations(TPZCompMesh &cmesh) { int nel = cmesh.NElements(); int iel; for (iel=0; iel<nel; iel++) { TPZCompEl *cel = cmesh.ElementVec()[iel]; if(!cel) { continue; } new TPZCondensedCompEl(cel); } }
TPZCompMesh *MeshH1(TPZGeoMesh *gmesh, int pOrder, int dim,bool hasbc) { /// criar materiais dim = 2; TPZMatPoisson3d *material = new TPZMatPoisson3d( MatId, dim); material->NStateVariables(); TPZCompMesh * cmesh = new TPZCompMesh(gmesh); cmesh->SetDimModel(dim); TPZMaterial * mat(material); cmesh->InsertMaterialObject(mat); ///Inserir condicao de contorno if(hasbc){ TPZFMatrix<STATE> val1(2,2,0.), val2(2,1,0.); TPZMaterial * BCond0 = material->CreateBC(mat, bc0,dirichlet, val1, val2); TPZMaterial * BCond1 = material->CreateBC(mat, bc1,dirichlet, val1, val2); TPZMaterial * BCond2 = material->CreateBC(mat, bc2,dirichlet, val1, val2); TPZMaterial * BCond3 = material->CreateBC(mat, bc3,dirichlet, val1, val2); cmesh->InsertMaterialObject(BCond0); cmesh->InsertMaterialObject(BCond1); cmesh->InsertMaterialObject(BCond2); cmesh->InsertMaterialObject(BCond3); } //solucao exata // TPZAutoPointer<TPZFunction<STATE> > solexata; // solexata = new TPZDummyFunction<STATE>(EstadoAd); // material->SetForcingFunctionExact(solexata); // // //funcao do lado direito da equacao do problema // TPZAutoPointer<TPZFunction<STATE> > force; // TPZDummyFunction<STATE> *dum; // // dum = new TPZDummyFunction<STATE>(ForcingOpt); // dum->SetPolynomialOrder(20); // force = dum; // material->SetForcingFunction(force); cmesh->SetDefaultOrder(pOrder); cmesh->SetDimModel(dim); cmesh->SetAllCreateFunctionsContinuous(); //Ajuste da estrutura de dados computacional cmesh->AutoBuild(); return cmesh; }
TPZCompElHDivFull<TSHAPE>::TPZCompElHDivFull(TPZCompMesh &mesh, TPZGeoEl *gel, int64_t &index) : TPZRegisterClassId(&TPZCompElHDivFull::ClassId), TPZCompElHDiv<TSHAPE>(mesh,gel,index) { int i; int nconflux= TPZCompElHDiv<TSHAPE>::NConnects(); this->fConnectIndexes.Resize(nconflux); gel->SetReference(this); for(i=0;i< nconflux;i++) { int sideaux= i + TSHAPE::NCornerNodes; this->fConnectIndexes[i] = this->CreateMidSideConnect(sideaux); #ifdef LOG4CXX if (logger->isDebugEnabled()) { std::stringstream sout; sout << "After creating last flux connect " << i << std::endl; // this->Print(sout); LOGPZ_DEBUG(logger,sout.str()) } #endif mesh.ConnectVec()[this->fConnectIndexes[i]].IncrementElConnected(); this->IdentifySideOrder(sideaux); }
void TPZBndCond::Read(TPZStream &buf, void *context) { TPZMaterial::Read(buf, context); buf.Read(&fType, 1); fBCVal1.Read(buf, 0); fBCVal2.Read(buf, 0); int MatId; buf.Read(&MatId,1); TPZCompMesh * pCM = (TPZCompMesh * )/*dynamic_cast<TPZCompMesh *>*/(context); fMaterial = pCM->FindMaterial(MatId); if(!fMaterial) { std::cout << " reading a boundary condition without material object!!\n"; #ifdef LOG4CXX LOGPZ_FATAL(logger,"reading a boundary condition without material object!!"); #endif } }
TPZCompMesh *CMesh(TPZGeoMesh *gmesh, int pOrder) { const int dim = 2; //dimensao do problema const int matId = 1, bc0 = -1, bc1 = -2, bc2=-3, bc3=-4; //MESMOS ids da malha geometrica const int dirichlet = 0, neumann = 1; // const int mixed = 2; //tipo da condicao de contorno do problema ->default dirichlet na esquerda e na direita ///criar malha computacional TPZCompMesh * cmesh = new TPZCompMesh(gmesh); cmesh->SetDefaultOrder(pOrder);//seta ordem polimonial de aproximacao cmesh->SetDimModel(dim);//seta dimensao do modelo // Criando material TPZMatExSimples2D *material = new TPZMatExSimples2D(matId);//criando material que implementa a formulacao fraca do problema modelo // Inserindo material na malha cmesh->InsertMaterialObject(material); ///Inserir condicao de contorno esquerda TPZFMatrix<STATE> val1(1,1,0.), val2(1,1,0.); TPZMaterial * BCond0 = material->CreateBC(material, bc0, neumann, val1, val2);//cria material que implementa a condicao de contorno da esquerda cmesh->InsertMaterialObject(BCond0);//insere material na malha // Condicao de contorno da direita TPZMaterial * BCond1 = material->CreateBC(material, bc1, neumann, val1, val2);//cria material que implementa a condicao de contorno da direita cmesh->InsertMaterialObject(BCond1);//insere material na malha val2(0,0) = 1.0;//potencial na placa inferior // Condicao de contorno da placa inferior TPZMaterial * BCond2 = material->CreateBC(material, bc2, dirichlet, val1, val2);//cria material que implementa a condicao de contorno da placa inferior cmesh->InsertMaterialObject(BCond2);//insere material na malha val2(0,0) = 1.5;//potencial na placa superior // Condicao de contorno da placa superior TPZMaterial * BCond3 = material->CreateBC(material, bc3, dirichlet, val1, val2);//cria material que implementa a condicao de contorno da placa superior cmesh->InsertMaterialObject(BCond3);//insere material na malha //Cria elementos computacionais que gerenciarao o espaco de aproximacao da malha cmesh->AutoBuild(); return cmesh; }
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; }
/** * @brief transform in low order Raviar Tomas */ void TPZCreateApproximationSpace::MakeRaviartTomas(TPZCompMesh &cmesh) { int numcell = cmesh.NElements(); int el; for (el = 0; el<numcell ; el++) { TPZCompEl *cel = cmesh.ElementVec()[el]; TPZInterpolationSpace *intel = dynamic_cast<TPZInterpolationSpace *>(cel); if (!intel) { continue; } intel->SetPreferredOrder(1); } cmesh.ExpandSolution(); for (el = 0; el<numcell ; el++) { TPZCompEl *cel = cmesh.ElementVec()[el]; TPZInterpolatedElement *intel = dynamic_cast<TPZInterpolatedElement *>(cel); if (!intel) { continue; } TPZGeoEl *gel = intel->Reference(); int geldim = gel->Dimension(); int is; int nsides = gel->NSides(); for (is=0; is<nsides; is++) { if (gel->SideDimension(is) != geldim-1) { continue; } int nsconnects = intel->NSideConnects(is); // only interested in HDiv elements if (nsconnects != 1) { continue; } int cindex = intel->SideConnectIndex(0, is); TPZConnect &c = intel->Connect(intel->SideConnectLocId(0,is)); if (c.HasDependency()) { continue; } int nshape = 1; int nstate = 1; int order = 0; int cindex2 = cmesh.AllocateNewConnect(nshape, nstate, order); // TPZConnect &c2 = cmesh.ConnectVec()[cindex]; TPZFNMatrix<2> depmat(2,1,1.); c.AddDependency(cindex, cindex2, depmat, 0, 0, 2, 1); } } cmesh.ExpandSolution(); }
TPZCompMesh *L2ProjectionP(TPZGeoMesh *gmesh, int pOrder, TPZVec<STATE> &solini) { /// criar materiais int dim = 2; TPZL2Projection *material; material = new TPZL2Projection(1, dim, 1, solini, pOrder); TPZCompMesh * cmesh = new TPZCompMesh(gmesh); cmesh->SetDimModel(dim); TPZMaterial * mat(material); cmesh->InsertMaterialObject(mat); TPZAutoPointer<TPZFunction<STATE> > forcef = new TPZDummyFunction<STATE>(InitialPressure); material->SetForcingFunction(forcef); cmesh->SetAllCreateFunctionsContinuous(); cmesh->SetDefaultOrder(pOrder); cmesh->SetDimModel(dim); cmesh->AutoBuild(); return cmesh; }
void InsertMaterialObjects(TPZCompMesh &cmesh) { /// criar materiais int dim = cmesh.Dimension(); TPZMatLaplacianLagrange *materialcoarse = new TPZMatLaplacianLagrange(matcoarsemesh,dim); // TPZAutoPointer<TPZFunction<REAL> > forcef = new TPZDummyFunction<REAL>(ForceSuave); // materialcoarse->SetForcingFunction(forcef); TPZMaterial * mat1(materialcoarse); cmesh.InsertMaterialObject(mat1); ///Inserir condicao de contorno TPZFMatrix<STATE> val1(2,2,1.), val2(2,1,0.); //BC -1 TPZMaterial * BCondD1 = materialcoarse->CreateBC(mat1, bc1,dirichlet, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet1 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD1->SetForcingFunction(bcmatDirichlet1); cmesh.InsertMaterialObject(BCondD1); //BC -2 TPZMaterial * BCondD2 = materialcoarse->CreateBC(mat1, bc2,dirichlet, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet2 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD2->SetForcingFunction(bcmatDirichlet2); cmesh.InsertMaterialObject(BCondD2); //BC -3 TPZMaterial * BCondD3 = materialcoarse->CreateBC(mat1, bc3,dirichlet, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet3 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD3->SetForcingFunction(bcmatDirichlet3); cmesh.InsertMaterialObject(BCondD3); //BC -4 TPZMaterial * BCondD4 = materialcoarse->CreateBC(mat1, bc4,dirichlet, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet4 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD4->SetForcingFunction(bcmatDirichlet4); cmesh.InsertMaterialObject(BCondD4); }
TPZCompMesh * ComputationalElasticityMesh3D(TPZGeoMesh *gmesh,int pOrder) { // Getting mesh dimension const int dim = 3; TPZCompMesh * cmesh = new TPZCompMesh(gmesh); cmesh->SetDefaultOrder(pOrder); cmesh->SetDimModel(dim); {//material da chapa const REAL Ey = 205000.; const REAL poisson = 0.3; const int matid = matchapa; TPZManVector<STATE,3> fx(3,0.); TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx); mat->SetVonMises(300.); cmesh->InsertMaterialObject(mat); } {//material da trilho1 const REAL Ey = 205000.; const REAL poisson = 0.3; const int matid = mattrilho1; TPZManVector<STATE,3> fx(3,0.); TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx); mat->SetVonMises(690.); cmesh->InsertMaterialObject(mat); //int bcsidex = 9; TPZFNMatrix<9,STATE> val1(3,3,0.), val2(3,1,0.); val2(0,0) = 1.; cmesh->InsertMaterialObject(mat->CreateBC(mat, bctrilho1, 3, val1, val2)); } if(1) {//material da trilho2 const REAL Ey = 205000.; const REAL poisson = 0.3; const int matid = mattrilho2; TPZManVector<STATE,3> fx(3,0.); TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx); mat->SetVonMises(690.); cmesh->InsertMaterialObject(mat); //int bcsidex = 9; TPZFNMatrix<9,STATE> val1(3,3,0.), val2(3,1,0.); val2(0,0) = 1.; cmesh->InsertMaterialObject(mat->CreateBC(mat, bctrilho2, 3, val1, val2)); } REAL percTracao = 0.1; {//material do concreto de 40 MPa const REAL Ey = 35417.; const REAL poisson = 0.2; const int matid = matgraut; TPZManVector<STATE,3> fx(3,0.); TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx); mat->SetMohrCoulomb(40.,percTracao*40.); cmesh->InsertMaterialObject(mat); } {//material do concreto de 30 MPa const REAL Ey = 27000; const REAL poisson = 0.2; const int matid = matenchimento; TPZManVector<STATE,3> fx(3,0.); TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx); mat->SetMohrCoulomb(30.,percTracao*30.); cmesh->InsertMaterialObject(mat); //c.c. //int bcbottom = 8; TPZFNMatrix<9,STATE> val1(3,3,0.), val2(3,1,0.); // val1(0,0) = 1.e-3; // val1(1,1) = 1.e-3; // val1(2,2) = 1.e12; val2(2) = 1.; cmesh->InsertMaterialObject(mat->CreateBC(mat, bcbottom, 3, val1, val2)); val1.Zero(); val2.Zero(); //int bcsidex = 9; val2.Zero(); val2(0,0) = 1.; cmesh->InsertMaterialObject(mat->CreateBC(mat, bcsidex, 3, val1, val2)); //int bcsidey = 10; val1.Zero(); val2.Zero(); val2(1,0) = 1.; cmesh->InsertMaterialObject(mat->CreateBC(mat, bcsidey, 3, val1, val2)); //int bcloadtop = 11; val2.Zero(); val2(2,0) = -800000./120.; cmesh->InsertMaterialObject(mat->CreateBC(mat, bcloadtop, 1, val1, val2)); // somente para teste de tensao uniforme // cmesh->InsertMaterialObject(mat->CreateBC(mat, bcloadtopTESTE, 1, val1, val2));//toto } cmesh->SetAllCreateFunctionsContinuous(); cmesh->AutoBuild(); return cmesh; }
TPZCompMesh *ComputationalElasticityMesh2D(TPZAutoPointer<TPZGeoMesh> gmesh,int pOrder) { // remove some connectivities 3, 5 TPZGeoEl *gel = gmesh->Element(0); TPZGeoElSide gelside(gel,3); gelside.RemoveConnectivity(); gelside.SetSide(5); gelside.RemoveConnectivity(); gelside.SetSide(4); TPZGeoElSide neighbour = gelside.NNeighbours(); int matid = neighbour.Element()->MaterialId(); gel->SetMaterialId(matid); neighbour.Element()->RemoveConnectivities(); int64_t index = neighbour.Element()->Index(); delete neighbour.Element(); gmesh->ElementVec()[index] = 0; // Plane strain assumption int planestress = 0; // Getting mesh dimension int dim = 2; TPZMatElasticity2D *materialConcrete; materialConcrete = new TPZMatElasticity2D(EMatConcrete); TPZMatElasticity2D *materialSteel; materialSteel = new TPZMatElasticity2D(EMatSteel); // Setting up paremeters materialConcrete->SetfPlaneProblem(planestress); materialConcrete->SetElasticity(25.e6, 0.25); materialSteel->SetElasticity(205.e6, 0.25); //material->SetBiotAlpha(Alpha);cade o metodo? TPZCompMesh * cmesh = new TPZCompMesh(gmesh); cmesh->SetDefaultOrder(pOrder); cmesh->SetDimModel(dim); TPZFMatrix<STATE> val1(2,2,0.), val2(2,1,0.); val2(0,0) = 0.0; val2(1,0) = 0.0; val1(1,1) = 1.e12; TPZMaterial * BCond2 = materialConcrete->CreateBC(materialConcrete,EBottom,3, val1, val2); val2(0,0) = 0.0; val2(1,0) = 0.0; val1.Zero(); val1(0,0) = 1.e12; TPZMaterial * BCond3 = materialConcrete->CreateBC(materialConcrete,ELateral,3, val1, val2); val2(0,0) = 0.0; val2(1,0) = -1000.0; val1.Zero(); TPZMaterial * BCond4 = materialSteel->CreateBC(materialSteel,EBeam,1, val1, val2); cmesh->SetAllCreateFunctionsContinuous(); cmesh->InsertMaterialObject(materialConcrete); cmesh->InsertMaterialObject(materialSteel); cmesh->InsertMaterialObject(BCond2); cmesh->InsertMaterialObject(BCond3); cmesh->InsertMaterialObject(BCond4); cmesh->AutoBuild(); return cmesh; }
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; }
void InsertMaterialObjectsMHM(TPZCompMesh &cmesh, bool useDPGPhil, bool useDPG) { /// criar materiais int dim = cmesh.Dimension(); TPZMatLaplacianLagrange *materialFiner = new TPZMatLaplacianLagrange(matfinermesh,dim); // TPZAutoPointer<TPZFunction<REAL> > forcef = new TPZDummyFunction<REAL>(ForceSuave); // materialFiner->SetForcingFunction(forcef); TPZAutoPointer<TPZFunction<STATE> > solExata= new TPZDummyFunction<STATE>(SolSuave); materialFiner->SetForcingFunctionExact(solExata); TPZAutoPointer<TPZFunction<STATE> > forcef; TPZDummyFunction<STATE> *dum; dum = new TPZDummyFunction<STATE>(ForceSuave); dum->SetPolynomialOrder(20); forcef = dum; materialFiner->SetForcingFunction(forcef); if(useDPGPhil==true){ materialFiner->SetDPGPhil(); useDPG=false; } if(useDPG==true){ materialFiner->SetMDP(); useDPGPhil=false; } TPZMaterial * mat1(materialFiner); TPZMat1dLin *materialSkeleton = new TPZMat1dLin(matskeletonmesh); TPZFNMatrix<1,STATE> xk(1,1,0.),xb(1,1,0.),xc(1,1,0.),xf(1,1,0.); materialSkeleton->SetMaterial(xk, xc, xb, xf); cmesh.InsertMaterialObject(mat1); cmesh.InsertMaterialObject(materialSkeleton); ///Inserir condicao de contorno TPZFMatrix<STATE> val1(2,2,1.), val2(2,1,0.); int boundcond = dirichlet; if(useDPG) boundcond = neumanndirichlet; //BC -1 TPZMaterial * BCondD1 = materialFiner->CreateBC(mat1, bc1,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet1 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD1->SetForcingFunction(bcmatDirichlet1); cmesh.InsertMaterialObject(BCondD1); //BC -2 TPZMaterial * BCondD2 = materialFiner->CreateBC(mat1, bc2,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet2 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD2->SetForcingFunction(bcmatDirichlet2); cmesh.InsertMaterialObject(BCondD2); //BC -3 TPZMaterial * BCondD3 = materialFiner->CreateBC(mat1, bc3,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet3 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD3->SetForcingFunction(bcmatDirichlet3); cmesh.InsertMaterialObject(BCondD3); //BC -4 TPZMaterial * BCondD4 = materialFiner->CreateBC(mat1, bc4,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet4 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD4->SetForcingFunction(bcmatDirichlet4); cmesh.InsertMaterialObject(BCondD4); }
//************************************* //************Option 0***************** //*******L Shape Quadrilateral********* //************************************* TPZCompMesh *CreateCubeMesh(){ //malha 2 cubos const int nelem = 2; //número de nós const int ncoord = 12; //TPZVec<REAL> coord(ncoord,0.); REAL Coord[ncoord][3] = { { 0.,0.,0.} , { 1.,0.,0.} , { 2.,0.,0.} , { 0.,1.,0.} , { 1.,1.,0.} , { 2.,1.,0.} , { 0.,0.,1.} , { 1.,0.,1.} , { 2.,0.,1.} , { 0.,1.,1.} , { 1.,1.,1.} , { 2.,1.,1.} }; int Connect[nelem][8] = { {0,1,4,3,6,7,10,9}, {1,2,5,4,7,8,11,10} }; int nConnect[nelem] = {8,8}; // criar um objeto tipo malha geometrica TPZGeoMesh *geomesh = new TPZGeoMesh(); // criar nos int i,j; for(i=0; i<(ncoord); i++) { int nodind = geomesh->NodeVec().AllocateNewElement(); TPZVec<REAL> coord(3); for (j=0; j<3; j++) { coord[j] = Coord[i][j]; } geomesh->NodeVec()[nodind] = TPZGeoNode(i,coord,*geomesh); } // criação dos elementos TPZGeoEl *gel[nelem]; for(i=0;i<nelem;i++) { TPZVec<int64_t> indices(nConnect[i]); for(j=0;j<nConnect[i];j++) { indices[j] = Connect[i][j]; } int64_t index; switch (nConnect[i]){ case (4): gel[i] = geomesh->CreateGeoElement(EQuadrilateral,indices,1,index); break; case(3): gel[i] = geomesh->CreateGeoElement(ETriangle,indices,1,index); break; case (8) : gel[i] = geomesh->CreateGeoElement(ECube,indices,1,index); break; default: cout << "Erro : elemento nao implementado" << endl; } } // Descomentar o trecho abaixo para habilitar a // divisão dos elementos geométricos criados geomesh->BuildConnectivity(); // geomesh->Print(cout); //Divisão dos elementos // TPZVec<TPZGeoEl *> sub,subsub; // gel[0]->Divide(sub); // sub[0]->Divide(subsub); // subsub[2]->Divide(sub); // for (i=0;i< (sub.NElements()-1) ;i++){ // sub[i]->Divide(subsub); // } // Criação das condições de contorno geométricas TPZGeoElBC heman_1(gel[0],20,-1); TPZGeoElBC heman_2(gel[1],20,-1); // geomesh->BuildConnectivity2(); //geomesh->Print(cout); // Criação da malha computacional TPZCompMesh *comp = new TPZCompMesh(geomesh); // Criar e inserir os materiais na malha TPZMaterial *mat = new TPZMatPoisson3d(1,3); comp->InsertMaterialObject(mat); TPZMaterial *meumat = mat; // Condições de contorno // Dirichlet TPZFMatrix<STATE> val1(3,3,0.),val2(3,1,0.); TPZMaterial *bnd = meumat->CreateBC (meumat,-1,0,val1,val2); comp->InsertMaterialObject(bnd); bnd = meumat->CreateBC (meumat,-1,0,val1,val2); // comp->Print(cout); // Ajuste da estrutura de dados computacional comp->AutoBuild(); return comp; }
int main(){ #define HUGE_DEBUG int i; TPZCompMesh *cmesh; TPZVec <REAL> solution; int nstate, nsteps; TPZVec<int> meshsize(3,0); TPZVec<int> dimstate(3,0); TPZVec<int> usestate(3,0); TPZVec<int> erind(3,0); TPZVec<int> erantype(3,0); TPZVec <REAL> maxerror; TPZVec <REAL> minerror; ifstream arq_control ("/compile/cesar/NeoPZ/Projects/Error/control.txt"); ReadControl(arq_control,meshsize,nstate,dimstate,usestate,erind,erantype,maxerror,minerror,nsteps); // cout << "Reading Mesh\n"; ifstream arq_mesh ("/compile/cesar/NeoPZ/Projects/Error/Mesh.data"); //cmesh = ReadMesh(arq_mesh,meshsize); //cmesh = ReadElementsMesh(); cmesh = TetraMesh(); cout << "Reading Solution\n"; ifstream arq_solution ("/compile/cesar/NeoPZ/Projects/Error/Solution.data"); TPZStack<char *> scalnames,vecnames; scalnames.Push("POrder"); //cmesh->Print(cout); //cmesh->Reference()->Print(cout); for (i=0;i<nsteps;i++){ cout << "\n\nEntering step...: " << i << endl; //Just for visualization purposes... TPZAnalysis an (cmesh); char buf [256]; sprintf(buf,"htest%d.dx",i); //an.DefineGraphMesh(3,scalnames,vecnames,buf); //an.PostProcess(0,3); ofstream arq(buf); WriteMesh(cmesh->Reference(),arq); ReadSolution(arq_solution,solution,cmesh,nstate,dimstate); // cout << solution << endl; TPZCompMesh *adaptmesh; TMBAdaptInterface adapt(cmesh,nstate,dimstate,usestate,solution); adapt.SetMaxMinError(maxerror,minerror); adaptmesh = adapt.GetAdaptedMesh(erind,erantype,true,1,1,0); //cmesh->Reference()->ResetReference(); // cmesh->LoadReferences(); //delete cmesh; cmesh = adaptmesh; //cmesh->Reference()->Print(cout); } //Just for visualization purposes... TPZAnalysis an (cmesh); char buf [256]; sprintf(buf,"htest%d.dx",i); ofstream arq (buf); WriteMesh(cmesh->Reference(),arq); // an.DefineGraphMesh(3,scalnames,vecnames,buf); // an.PostProcess(0,3); // WriteCompMesh(cmesh,cout); delete cmesh; cout << "End..." << endl; return 0; }
TPZCompMesh *ReadElementsMesh(){ REAL Coord [18][3] = { {0.,0.,0.},{0.5,0.,0.},{1.,0.,0.}, {0.,1.,0.},{0.5,1.,0.},{1.,1.,0.}, {0.,0.,0.5},{0.5,0.,0.5},{1.,0.,0.5}, {0.,1.,0.5},{0.5,1.,0.5},{1.,1.,0.5}, {0.,0.,1.},{0.5,0.,1.},{1.,0.,1.}, {0.,1.,1.},{0.5,1.,1.},{1.,1.,1.} }; int NodesPerEl [11] = { 8, 5,5,5, 6,6, 4,4,4,4,4}; int Connects [11][8] = { {0,1,4,3,6,7,10,9}, {6,7,10,9,16,-1,-1,-1}, {6,7,13,12,16,-1,-1,-1}, {6,9,15,12,16,-1,-1,-1}, {1,2,5,7,8,11,-1,-1}, {1,5,4,7,11,10,-1,-1}, {7,8,11,14,-1,-1,-1,-1}, {7,11,10,16,-1,-1,-1,-1}, {16,17,14,11,-1,-1,-1,-1}, {16,14,13,7,-1,-1,-1,-1}, {7,11,16,14,-1,-1,-1,-1} }; int i,j; TPZGeoMesh *gmesh = new TPZGeoMesh(); TPZGeoEl * elvec[11]; TPZVec <REAL> coord (3,0.); int index; //Nodes initialization for(i = 0; i < 18; i++){ for(j=0;j<3;j++){ coord[j] = Coord[i][j]; } index = gmesh->NodeVec().AllocateNewElement(); gmesh->NodeVec()[index] = TPZGeoNode(i,coord,*gmesh); } TPZVec<TPZRefPattern *> refinement_Patterns; refinement_Patterns.Resize(8); refinement_Patterns[0] = 0; refinement_Patterns[1] = new TPZRefPattern("/home/pos/cesar/RefPattern/Line_Unif_Side_2.rpt"); refinement_Patterns[2] = new TPZRefPattern("/home/pos/cesar/RefPattern/Triang_Unif.rpt"); refinement_Patterns[3] = new TPZRefPattern("/home/pos/cesar/RefPattern/Quad_Unif.rpt"); refinement_Patterns[4] = new TPZRefPattern("/home/pos/cesar/RefPattern/Tetra_Unif.rpt"); refinement_Patterns[5] = new TPZRefPattern("/home/pos/cesar/RefPattern/Piram_Unif.rpt"); refinement_Patterns[6] = new TPZRefPattern("/home/pos/cesar/RefPattern/Prism_Unif.rpt"); refinement_Patterns[7] = new TPZRefPattern("/home/pos/cesar/RefPattern/Hexa_Unif.rpt"); for (i=0;i<11;i++){ int ncon = NodesPerEl[i]; TPZVec <int> connect(ncon,0); for(j=0; j<ncon;j++){ connect[j] = Connects[i][j]; } //elvec[i] = GeoElement(gmesh,ncon,connect,1,i); if (ncon ==4 ) ncon = 7; elvec[i] = GeoElementRefPattern(gmesh,ncon,connect,1,i,refinement_Patterns); } //Generate neighborhod information gmesh->Print(cout); gmesh->BuildConnectivity(); gmesh->Print(cout); //Create computational mesh TPZCompMesh *cmesh = new TPZCompMesh(gmesh); TPZMaterial *mat; mat = new TPZMaterialTest3D (1); cmesh->InsertMaterialObject(mat); cmesh->AutoBuild(); return cmesh; }
TPZCompMesh *ReadMesh(ifstream &arq, TPZVec<int> &meshsize){ int nx = meshsize[0]; int ny = meshsize[1]; int nz = meshsize[2]; int i,j,k; TPZGeoMesh *gmesh = new TPZGeoMesh(); TPZGeoEl * elvec[(const int)((nx-1)*(ny-1)*(nz-1))]; TPZVec <REAL> coord (3,0.); TPZVec <int> connect(8,0); REAL lx = 1.; REAL ly = 1.; REAL lz = 1.; int id, index; //Nodes initialization for(i = 0; i < nx; i++){ for(j = 0; j < ny; j++){ for(k = 0; k < nz; k++){ id = (i)*nz*ny + (j)*nz + k; coord[0] = (i)*lx/(nx - 1); coord[1] = (j)*ly/(ny - 1); coord[2] = (k)*lz/(nz - 1); //cout << coord << endl; index = gmesh->NodeVec().AllocateNewElement(); gmesh->NodeVec()[index] = TPZGeoNode(id,coord,*gmesh); } } } //Element connectivities TPZRefPattern *unifcube = new TPZRefPattern ("/home/pos/cesar/RefPattern/Hexa_Unif.rpt"); for(i = 0; i < (nx - 1); i++){ for(j = 0; j < (ny - 1); j++){ for(k = 0; k < (nz - 1); k++){ index = (i)*(nz - 1)*(ny - 1) + (j)*(nz - 1) + k; connect[0] = (i)*nz*ny + (j)*nz + k; connect[1] = connect[0]+(ny)*(nz); connect[2] = connect[1]+(nz); connect[3] = connect[0]+(nz); connect[4] = connect[0] + 1; connect[5] = connect[1] + 1; connect[6] = connect[2] + 1; connect[7] = connect[3] + 1; //cout << connect << endl; // elvec[index] = gmesh->CreateGeoElement(ECube,connect,1,id); TPZGeoElRefPattern <TPZShapeCube,TPZGeoCube> *gel = new TPZGeoElRefPattern <TPZShapeCube,TPZGeoCube> (index,connect,1,*gmesh,unifcube); elvec[index] = gel; } } } //Generate neighborhod information gmesh->BuildConnectivity(); gmesh->Print(cout); //Create computational mesh TPZCompMesh *cmesh = new TPZCompMesh(gmesh); TPZMaterial *mat; mat = new TPZMaterialTest3D (1); cmesh->InsertMaterialObject(mat); cmesh->AutoBuild(); return cmesh; }
int main2(int argc, char *argv[]) { #ifdef LOG4CXX InitializePZLOG(); #endif REAL Lx = 1.; REAL Ly = 1.; {// Checando funcoes TPZVec<REAL> pto(2,0.); TPZVec<STATE> disp(1,0.),solp(1,0.); pto[0]=0.200935; pto[1]=0.598129; TPZFMatrix<STATE>flux(3,1,0.); SolExata(pto, solp,flux); Forcing(pto, disp); solp.Print(std::cout); flux.Print(std::cout); disp.Print(std::cout); } // ofstream saidaerro("../ErroPoissonHdivMalhaQuad.txt",ios::app); ofstream saidaerro("../ErroPoissonHdivMalhaTriang.txt",ios::app); for(int p = 1; p<2; p++) { int pq = p; int pp; if(ftriang==true){ pp = pq-1; }else{ pp = pq; } int ndiv; saidaerro<<"\n CALCULO DO ERRO, COM ORDEM POLINOMIAL pq = " << pq << " e pp = "<< pp <<endl; for (ndiv = 1; ndiv< 2; ndiv++) { //std::cout << "p order " << p << " number of divisions " << ndiv << std::endl; saidaerro<<"\n<<<<<< Numero de divisoes uniforme ndiv = " << ndiv <<" >>>>>>>>>>> "<<endl; TPZGeoMesh *gmesh = GMesh(ftriang, Lx, Ly); ofstream arg("gmesh1.txt"); gmesh->Print(arg); UniformRefine(gmesh, ndiv); TPZCompMesh *cmesh1 = CMeshFlux(gmesh, pq); TPZCompMesh *cmesh2 = CMeshPressure(gmesh, pp); // ofstream arg1("cmeshflux.txt"); // cmesh1->Print(arg1); // // ofstream arg2("cmeshpressure.txt"); // cmesh2->Print(arg2); // // ofstream arg4("gmesh2.txt"); // gmesh->Print(arg4); //malha multifisica TPZVec<TPZCompMesh *> meshvec(2); meshvec[0] = cmesh1; meshvec[1] = cmesh2; TPZCompMesh * mphysics = CMeshMixed(gmesh,meshvec); std::cout << "Number of equations " << mphysics->NEquations() << std::endl; int numthreads = 8; std::cout << "Number of threads " << numthreads << std::endl; TPZAnalysis an(mphysics); SolveSyst(an, mphysics,numthreads); // ofstream arg5("cmeshmultiphysics.txt"); // mphysics->Print(arg5); //Calculo do erro TPZBuildMultiphysicsMesh::TransferFromMultiPhysics(meshvec, mphysics); TPZVec<REAL> erros; saidaerro << "Valor de epsilone " << EPSILON << std::endl; saidaerro << "Numero de threads " << numthreads << std::endl; saidaerro<<" \nErro da simulacao multifisica do fluxo (q)" <<endl; ErrorHDiv(cmesh1, saidaerro); saidaerro<<" Erro da simulacao multifisica da pressao (p)" <<endl; ErrorL2(cmesh2, saidaerro); std::cout << "Postprocessed\n"; //Plot da solucao aproximada // string plotfile("Solution_mphysics.vtk"); // PosProcessMultphysics(meshvec, mphysics, an, plotfile); } } return EXIT_SUCCESS; }
//malha multifisica para o metodo da dupla projecao TPZCompMesh *MalhaMDP(TPZVec<TPZCompMesh *> meshvec,TPZGeoMesh * gmesh){ //Creating computational mesh for multiphysic elements gmesh->ResetReference(); TPZCompMesh *mphysics = new TPZCompMesh(gmesh); //criando material int dim =2; TPZMDPMaterial *material = new TPZMDPMaterial(1,dim); //incluindo os dados do problema REAL coefk = 1.; material->SetParameters(coefk, 0.); //solucao exata TPZAutoPointer<TPZFunction<STATE> > solexata; solexata = new TPZDummyFunction<STATE>(SolSuave); material->SetForcingFunctionExact(solexata); //funcao do lado direito da equacao do problema TPZAutoPointer<TPZFunction<STATE> > force; TPZDummyFunction<STATE> *dum; dum = new TPZDummyFunction<STATE>(ForceSuave); dum->SetPolynomialOrder(20); force = dum; material->SetForcingFunction(force); //inserindo o material na malha computacional TPZMaterial *mat(material); mphysics->InsertMaterialObject(mat); //Criando condicoes de contorno TPZFMatrix<STATE> val1(2,2,0.), val2(2,1,0.); int boundcond = dirichlet; //BC -1 TPZMaterial * BCondD1 = material->CreateBC(mat, bc1,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet1 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD1->SetForcingFunction(bcmatDirichlet1); mphysics->InsertMaterialObject(BCondD1); //BC -2 TPZMaterial * BCondD2 = material->CreateBC(mat, bc2,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet2 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD2->SetForcingFunction(bcmatDirichlet2); mphysics->InsertMaterialObject(BCondD2); //BC -3 TPZMaterial * BCondD3 = material->CreateBC(mat, bc3,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet3 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD3->SetForcingFunction(bcmatDirichlet3); mphysics->InsertMaterialObject(BCondD3); //BC -4 TPZMaterial * BCondD4 = material->CreateBC(mat, bc4,boundcond, val1, val2); TPZAutoPointer<TPZFunction<REAL> > bcmatDirichlet4 = new TPZDummyFunction<REAL>(DirichletSuave); BCondD4->SetForcingFunction(bcmatDirichlet4); mphysics->InsertMaterialObject(BCondD4); mphysics->InsertMaterialObject(BCondD1); mphysics->InsertMaterialObject(BCondD2); mphysics->InsertMaterialObject(BCondD3); mphysics->InsertMaterialObject(BCondD4); //set multiphysics element mphysics->SetDimModel(dim); mphysics->SetAllCreateFunctionsMultiphysicElem(); //Fazendo auto build 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); return mphysics; }
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; }
TPZCompMesh *MalhaMultifisicaOpt(TPZVec<TPZCompMesh *> meshvec, TPZGeoMesh *gmesh){ //Creating computational mesh for multiphysic elements gmesh->ResetReference(); TPZCompMesh *mphysics = new TPZCompMesh(gmesh); //criando material int dim =2; TPZMatPoissonControl *material = new TPZMatPoissonControl(MatId,dim); //incluindo os dados do problema REAL k=1; REAL alpha=1; material-> SetParameters( k, alpha); //solucao exata TPZAutoPointer<TPZFunction<STATE> > solexata; solexata = new TPZDummyFunction<STATE>(StateAd, 5); material->SetForcingFunctionExact(solexata); //funcao do lado direito da equacao do problema TPZAutoPointer<TPZFunction<STATE> > force; TPZDummyFunction<STATE> *dum; dum = new TPZDummyFunction<STATE>(OptForcing, 5); dum->SetPolynomialOrder(20); force = dum; material->SetForcingFunction(force); //inserindo o material na malha computacional TPZMaterial *mat(material); mphysics->InsertMaterialObject(mat); mphysics->SetDimModel(dim); //Criando condicoes de contorno TPZFMatrix<STATE> val1(2,2,0.), val2(2,1,0.); TPZMaterial * BCond0 = material->CreateBC(mat, bc0, bcdirichlet, val1, val2); TPZMaterial * BCond1 = material->CreateBC(mat, bc1, bcdirichlet, val1, val2); TPZMaterial * BCond2 = material->CreateBC(mat, bc2, bcdirichlet, val1, val2); TPZMaterial * BCond3 = material->CreateBC(mat, bc3, bcdirichlet, val1, val2); ///Inserir condicoes de contorno mphysics->InsertMaterialObject(BCond0); mphysics->InsertMaterialObject(BCond1); mphysics->InsertMaterialObject(BCond2); mphysics->InsertMaterialObject(BCond3); mphysics->SetAllCreateFunctionsMultiphysicElem(); //Fazendo auto build mphysics->AutoBuild(); mphysics->AdjustBoundaryElements(); mphysics->CleanUpUnconnectedNodes(); TPZBuildMultiphysicsMesh::AddElements(meshvec, mphysics); TPZBuildMultiphysicsMesh::AddConnects(meshvec,mphysics); TPZBuildMultiphysicsMesh::TransferFromMeshes(meshvec, mphysics); return mphysics; }
//************************************* //************Option 8***************** //*****All element types Mesh********** //************************************* TPZCompMesh * CreateTestMesh() { REAL nodeco[12][3] = { {0.,0.,0.}, {1.,0.,0.}, {2.,0.,0.}, {0.,1.,0.}, {1.,1.,0.}, {2.,1.,0.}, {0.,0.,1.}, {1.,0.,1.}, {2.,0.,1.}, {0.,1.,1.}, {1.,1.,1.}, {2.,1.,1.} }; int nodind[7][8] = { {0,1,4,3,6,7,10,9}, {2,4,10,8,5}, {8,10,11,5}, {2,4,1,8,10,7}, {0,1}, {0,1,7,6}, {1,2,7} }; int numnos[7] = {8,5,4,6,2,4,3}; TPZGeoMesh *gmesh = new TPZGeoMesh(); int noind[12]; int no; for(no=0; no<12; no++) { noind[no] = gmesh->NodeVec().AllocateNewElement(); TPZVec<REAL> coord(3); coord[0] = nodeco[no][0]; coord[1] = nodeco[no][1]; coord[2] = nodeco[no][2]; gmesh->NodeVec()[noind[no]].Initialize(coord,*gmesh); } int matid = 1; TPZVec<int> nodeindex; int nel; TPZVec<TPZGeoEl *> gelvec; gelvec.Resize(4); for(nel=0; nel<4; nel++) { int in; nodeindex.Resize(numnos[nel]); for(in=0; in<numnos[nel]; in++) { nodeindex[in] = nodind[nel][in]; } int index; switch(nel) { case 0: // elvec[el] = gmesh->CreateGeoElement(ECube,nodeindex,1,index); // gelvec[nel]=new TPZGeoElC3d(nodeindex,matid,*gmesh); break; case 1: gelvec[nel] = gmesh->CreateGeoElement(EPiramide,nodeindex,matid,index); // gelvec[nel]=new TPZGeoElPi3d(nodeindex,matid,*gmesh); break; case 2: gelvec[nel] = gmesh->CreateGeoElement(ETetraedro,nodeindex,matid,index); // gelvec[nel]=new TPZGeoElT3d(nodeindex,matid,*gmesh); break; case 3: // gelvec[nel]=new TPZGeoElPr3d(nodeindex,matid,*gmesh); // gelvec[nel] = gmesh->CreateGeoElement(EPrisma,nodeindex,matid,index); break; case 4: // gelvec[nel]=new TPZGeoEl1d(nodeindex,2,*gmesh); break; case 5: // gelvec[nel]=new TPZGeoElQ2d(nodeindex,3,*gmesh); break; case 6: // gelvec[nel]=new TPZGeoElT2d(nodeindex,3,*gmesh); break; default: break; } } gmesh->BuildConnectivity2(); //TPZVec<TPZGeoEl *> sub; //elvec[0]->Divide(sub); // elvec[1]->Divide(sub); // elvec[2]->Divide(sub); // TPZGeoElBC gbc; // bc -1 -> Dirichlet // TPZGeoElBC gbc1(gelvec[0],20,-1,*gmesh); TPZGeoElBC gbc11(gelvec[1],14,-1,*gmesh); // TPZGeoElBC gbc12(gelvec[3],15,-1,*gmesh); // bc -2 -> Neumann at the right x==1 // TPZGeoElBC gbc2(gelvec[0],25,-2,*gmesh); // TPZGeoElBC gbc21(gelvec[3],19,-2,*gmesh); TPZGeoElBC gbc22(gelvec[2],10,-2,*gmesh); TPZCompMesh *cmesh = new TPZCompMesh(gmesh); TPZAutoPointer<TPZMaterial> mat; // if(nstate == 3) { mat = new TPZMaterialTest3D(1); TPZFMatrix mp (3,1,0.); TPZMaterialTest3D * mataux = dynamic_cast<TPZMaterialTest3D *> (mat.operator ->()); TPZMaterialTest3D::geq3=1; mataux->SetMaterial(mp); /* } else { TPZMat2dLin *mat2d = new TPZMat2dLin(1); int ist,jst; TPZFMatrix xk(nstate,nstate,1.),xc(nstate,nstate,0.),xf(nstate,1,0.); for(ist=0; ist<nstate; ist++) { if(nstate != 1) xf(ist,0) = 1.; for(jst=0; jst<nstate; jst++) { if(ist != jst) xk(ist,jst) = 0.; } } mat2d->SetMaterial(xk,xc,xf); mat = mat2d; }*/ TPZFMatrix val1(3,3,0.),val2(3,1,0.); TPZAutoPointer<TPZMaterial> bc[2]; bc[0] = mat->CreateBC(mat,-1,0,val1,val2); val2(0,0) = 1.; bc[1] = mat->CreateBC(mat,-2,1,val1,val2); cmesh->InsertMaterialObject(mat); int i; for(i=0; i<2; i++) cmesh->InsertMaterialObject(bc[i]); gmesh->Print(cout); cmesh->AutoBuild(); cmesh->AdjustBoundaryElements(); cmesh->CleanUpUnconnectedNodes(); gmesh->Print(cout); return cmesh; }
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; }