arquivos-html/html/_t_p_z_front_struct_matrix_8cpp_source.html

 #include "pzstrmatrix.h"
 #include "pzfstrmatrix.h"
 #include "TPZFrontStructMatrix.h"

 #include "pzgmesh.h"
 #include "pzcmesh.h"
 #include "pzsubcmesh.h"
 #include "pzconnect.h"
 #include "pzadmchunk.h"

 #include "pzsmfrontalanal.h"


 #include "pzanalysis.h"
 #include "pzsolve.h"
 #include "pzstepsolver.h"
 #include "TPZFrontMatrix.h"

 #include "pzdxmesh.h"
 #include <fstream>

 using namespace std;

 #include "pzelmat.h"
 #include "pzbndcond.h"

 #include "pzlog.h"

 #ifdef LOG4CXX
 static LoggerPtr logger(Logger::getLogger("pz.strmatrix.frontstructmatrix"));
 static LoggerPtr loggerel(Logger::getLogger("pz.strmatrix.element"));
 #endif


 template <class front>
 void TPZFrontStructMatrix<front>::GetNumElConnected(TPZVec <int> &numelconnected){
                 int64_t ic;

                 fMesh->ComputeNodElCon();

                 for(ic=0; ic<fMesh->ConnectVec().NElements(); ic++) {
                                 TPZConnect &cn = fMesh->ConnectVec()[ic];
                                 if(cn.HasDependency() || cn.IsCondensed()) continue;
                                 int64_t seqn = cn.SequenceNumber();
                                 if(seqn < 0) continue;
                                 int64_t firsteq = fMesh->Block().Position(seqn);
                                 int64_t lasteq = firsteq+fMesh->Block().Size(seqn);
         int64_t numactive = fEquationFilter.NumActive(firsteq, lasteq);
                                 if(!numactive) continue;
         if (numactive != lasteq-firsteq) {
             DebugStop();
         }
         TPZManVector<int64_t> firstind(numactive),destindex(numactive);
         for (int64_t i = 0; i<numactive; i++) {
             firstind[i] = i;
             destindex[i] = firsteq+i;
         }
         fEquationFilter.Filter(firstind, destindex);
                                 for(int64_t ind=0;ind<destindex.size();ind++)
                                                 numelconnected[destindex[ind] ] = fMesh->ConnectVec()[ic].NElConnected();
                 }
 }

 template<class front>
 TPZFrontStructMatrix<front>::TPZFrontStructMatrix() : TPZStructMatrix(), f_quiet(0), fDecomposeType(ENoDecompose) {
 }

 template<class front>
 TPZFrontStructMatrix<front>::TPZFrontStructMatrix(TPZCompMesh *mesh): TPZStructMatrix(mesh), f_quiet(0), fDecomposeType(ENoDecompose){
 }


 template<class front>
 TPZFrontStructMatrix<front>::~TPZFrontStructMatrix(){}


 template<class front>
 TPZMatrix<STATE> * TPZFrontStructMatrix<front>::Create(){

     /* TPZVec <int> numelconnected(fMesh->NEquations(),0);
                  // TPZFrontMatrix<TPZStackEqnStorage, TPZFrontNonSym> *mat = new TPZFrontMatrix<TPZStackEqnStorage, TPZFrontNonSym>(fMesh->NEquations());

      GetNumElConnected(numelconnected);
      //mat->SetNumElConnected(numelconnected);
      return mat;
      */
                 return 0;
 }

 template<class front>
 TPZStructMatrix * TPZFrontStructMatrix<front>::Clone(){

                 TPZFrontStructMatrix<front>* result =  new TPZFrontStructMatrix<front>(*this);
                 return result;
 }
 template<class front>
 void TPZFrontStructMatrix<front>::OrderElement()//TPZVec<int> &elorder)
 {
                 int64_t numelconnected = 0;
                 int64_t nconnect = fMesh->ConnectVec().NElements();
                 int64_t ic;
                 //firstelconnect contains the first element index in the elconnect vector
                 TPZVec<int64_t> firstelconnect(nconnect+1);
                 firstelconnect[0] = 0;
                 for(ic=0; ic<nconnect; ic++) {
                                 numelconnected += fMesh->ConnectVec()[ic].NElConnected();
                                 firstelconnect[ic+1] = firstelconnect[ic]+fMesh->ConnectVec()[ic].NElConnected();
                 }

 #ifdef LOG4CXX
     if (logger->isDebugEnabled())
                 {
                                 std::stringstream sout;
                                 sout<<"numelconnected " << numelconnected << endl;
                                 sout<< "firstelconnect "<< firstelconnect;
                                 LOGPZ_DEBUG(logger,sout.str())
                 }
 #endif
                 //cout << "numelconnected " << numelconnected << endl;
                 //cout << "firstelconnect ";
                 //  for(ic=0; ic<nconnect; ic++) cout << firstelconnect[ic] << ' ';
                 TPZVec<int64_t> elconnect(numelconnected,-1);
                 int64_t el;
                 TPZCompEl *cel;
                 for(el=0; el<fMesh->ElementVec().NElements(); el++) {
                                 cel = fMesh->ElementVec()[el];
                                 if(!cel) continue;
                                 TPZStack<int64_t> connectlist;
                                 cel->BuildConnectList(connectlist);
                                 int64_t nc = connectlist.NElements();
                                 int64_t ic;
                                 for(ic=0; ic<nc; ic++) {
                                                 int64_t cindex = connectlist[ic];
                                                 elconnect[firstelconnect[cindex]] = el;
                                                 firstelconnect[cindex]++;
                                 }
                 }
                 //  for(ic=0; ic<numelconnected; ic++) cout << elconnect[ic] << endl;
 #ifdef LOG4CXX
     if (logger->isDebugEnabled())
                 {
                                 std::stringstream sout;
                                 sout<< "elconnect "<< elconnect;
                                 LOGPZ_DEBUG(logger,sout.str())
                 }
 #endif
                 firstelconnect[0] = 0;
                 for(ic=0; ic<nconnect; ic++) {
                                 firstelconnect[ic+1] = firstelconnect[ic]+fMesh->ConnectVec()[ic].NElConnected();
                 }
                 //cout << "elconnect\n";
                 //  int no;
                 for(int64_t no=0; no< fMesh->ConnectVec().NElements(); no++) {
 #ifdef LOG4CXX
         if (logger->isDebugEnabled())
                                 {
                                                 std::stringstream sout;
                                                 sout<< "Node index " << no << ' ' << " seq num " << fMesh->ConnectVec()[no].SequenceNumber() << ' ';
                                                 LOGPZ_DEBUG(logger,sout.str())
                                 }
 #endif
                                 //cout << "no numero " << no << ' ' << " seq num " << fMesh->ConnectVec()[no].SequenceNumber() << ' ';
                                 //       for(ic=firstelconnect[no]; ic<firstelconnect[no+1];ic++) cout << elconnect[ic] << ' ';
                                 //cout << endl;
                 }


                 fElementOrder.Resize(fMesh->ElementVec().NElements(),-1);
                 fElementOrder.Fill(-1);
                 TPZVec<int> nodeorder(fMesh->ConnectVec().NElements(),-1);
                 firstelconnect[0] = 0;
                 for(ic=0; ic<nconnect; ic++) {
                                 int64_t seqnum = fMesh->ConnectVec()[ic].SequenceNumber();
                                 if(seqnum >= 0) nodeorder[seqnum] = ic;
                 }
                 //  cout << "nodeorder ";
                 /*for(ic=0; ic<fMesh->ConnectVec().NElements(); ic++) cout << nodeorder[ic] << ' ';
                  cout << endl;
                  cout.flush();*/
                 int64_t seq;
                 int64_t elsequence = 0;
                 TPZVec<int64_t> elorderinv(fMesh->ElementVec().NElements(),-1);
                 for(seq=0; seq<nconnect; seq++) {
                                 ic = nodeorder[seq];
                                 if(ic == -1) continue;
                                 int64_t firstind = firstelconnect[ic];
                                 int64_t lastind = firstelconnect[ic+1];
                                 int64_t ind;
                                 for(ind=firstind; ind<lastind; ind++) {
                                                 el = elconnect[ind];
                                                 if(el == -1) {
                                                                 continue;
                                                 }
                                                 if(elorderinv[el]==-1) elorderinv[el] = elsequence++;
                                 }
                 }
                 //  cout << "elorderinv ";
                 //  for(seq=0;seq<fMesh->ElementVec().NElements();seq++) cout << elorderinv[seq] << ' ';
                 //  cout << endl;
                 elsequence = 0;
                 for(seq=0;seq<fMesh->ElementVec().NElements();seq++) {
                                 if(elorderinv[seq] == -1) continue;
                                 fElementOrder[elorderinv[seq]] = seq;
                 }
 #ifdef LOG4CXX
     if (logger->isDebugEnabled())
                 {
                                 std::stringstream sout;
         sout << "element order " << fElementOrder << std::endl;
                                 sout<< "elorderinv " << elorderinv << std::endl;
                                 LOGPZ_DEBUG(logger,sout.str())
                 }
 #endif
                 //  cout << "elorder" << endl;
                 //  for(ic=0; ic<fMesh->ElementVec().NElements(); ic++) cout << elorder[ic] << endl;

 }

 template<class front>
 TPZMatrix<STATE> * TPZFrontStructMatrix<front>::CreateAssemble(TPZFMatrix<STATE> &rhs, TPZAutoPointer<TPZGuiInterface> guiInterface){

     int64_t neq = fEquationFilter.NActiveEquations();
                 TPZManVector <int> numelconnected(neq,0);
                 TPZFrontMatrix<STATE,TPZStackEqnStorage<STATE>, front> *mat = new TPZFrontMatrix<STATE,TPZStackEqnStorage<STATE>, front>(neq);//(fMesh->NEquations());

 //              TPZFrontMatrix<STATE,TPZFileEqnStorage<STATE>, front> *mat = new TPZFrontMatrix<STATE,TPZFileEqnStorage<STATE>, front>(neq);
     mat->GetFront().SetDecomposeType(fDecomposeType);
                 // if the frontal matrix is applied to a submesh, we assume there may be rigid body modes
                 TPZSubCompMesh *subcmesh = dynamic_cast<TPZSubCompMesh *> (fMesh);
                 if (subcmesh) {
                                 int nrigid = subcmesh->NumberRigidBodyModes();
                                 if (nrigid > 0) {
                                                 mat->GetFront().SetNumRigidBodyModes(nrigid);

                                 }
                 }

                 GetNumElConnected(numelconnected);
                 mat->SetNumElConnected(numelconnected);

                 OrderElement();

                 Assemble(*mat,rhs,guiInterface);

 #ifdef LOG4CXX
     if (logger->isDebugEnabled())
                 {
                                 std::stringstream sout;
         mat->FinishWriting();
         mat->ReOpen();
 //                              mat->Print("Frontal matrix", sout);
                                 LOGPZ_DEBUG(logger,sout.str())
                 }
 #endif

                 mat->FinishWriting();
                 mat->ReOpen();
                 return mat;
 }

 template<class front>
 void TPZFrontStructMatrix<front>::AssembleNew(TPZMatrix<STATE> & stiffness, TPZFMatrix<STATE> & rhs,TPZAutoPointer<TPZGuiInterface> guiInterface){

                 int64_t iel;
                 int64_t numel = 0, nelem = fMesh->NElements();
                 TPZElementMatrix ek(fMesh,TPZElementMatrix::EK),ef(fMesh,TPZElementMatrix::EF);
                 TPZManVector<int64_t> destinationindex(0);
                 TPZManVector<int64_t> sourceindex(0);

                 TPZAdmChunkVector<TPZCompEl *> &elementvec = fMesh->ElementVec();


                 TPZVec<int> elorder(fMesh->NEquations(),0);

                 OrderElement();


                 for(iel=0; iel < nelem; iel++) {

                                 if(guiInterface) if(guiInterface->AmIKilled()){
                                                 break;
                                 }

                                 if(fElementOrder[iel] < 0) continue;
                                 TPZCompEl *el = elementvec[fElementOrder[iel]];
                                 if(!el) continue;
                                 //                              int dim = el->NumNodes();

                                 //Builds elements stiffness matrix
                                 el->CalcStiff(ek,ef);
                                 ek.ComputeDestinationIndices();
                                 FilterEquations(ek.fSourceIndex,ek.fDestinationIndex);
                                 //ek.fMat->Print(out);
                                 //ef.fMat->Print();
                                 if(!f_quiet)
                                 {
                                                 if(!(numel%20)) cout << endl << numel;
                                                 //    if(!(numel%20)) cout << endl;
                                                 cout << '*';
                                                 cout.flush();
                                 }
                                 numel++;

                                 if(!el->HasDependency()) {
                                                 stiffness.AddKel(ek.fMat,ek.fSourceIndex,ek.fDestinationIndex);
                                                 rhs.AddFel(ef.fMat,ek.fSourceIndex, ek.fDestinationIndex);
                                 }
                                 else {
                                                 //ek.Print(*fMesh,cout);
                                                 ek.ApplyConstraints();
                                                 ef.ApplyConstraints();
                                                 stiffness.AddKel(ek.fConstrMat,ek.fSourceIndex,ek.fDestinationIndex);
                                                 rhs.AddFel(ef.fConstrMat,ek.fSourceIndex,ek.fDestinationIndex);
                                                 /*
                                                  if(ek.fConstrMat->Decompose_LU() != -1) {
                                                  el->ApplyConstraints(ek,ef);
                                                  ek.Print(*this,check);
                                                  check.flush();
                                                  }
                                                  */
                                 }

                 }//fim for iel
                 if(!f_quiet)
                 {
                                 cout << endl;
                 }
 }


 template<class front>
 void TPZFrontStructMatrix<front>::Assemble(TPZMatrix<STATE> & stiffness, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface){

                 int64_t iel;
                 int64_t numel = 0, nelem = fMesh->NElements();
                 TPZElementMatrix ek(fMesh,TPZElementMatrix::EK),ef(fMesh,TPZElementMatrix::EF);

                 TPZAdmChunkVector<TPZCompEl *> &elementvec = fMesh->ElementVec();


                 TPZVec<int> elorder(fMesh->NEquations(),0);

                 OrderElement();

                 for(iel=0; iel < nelem; iel++) {

         int64_t elindex = fElementOrder[iel];
                                 if(elindex < 0) continue;
                                 TPZCompEl *el = elementvec[elindex];
                                 if(!el) continue;
                                 TPZMaterial * mat = el->Material();
                                 if(mat)
                                 {
                                                 int matid = mat->Id();
                                                 if(this->ShouldCompute(matid) == false)
                                                 {
                                                                 continue;
                                                 }
                                 }
                                 else
                                 {
                                 }

                                 //                              int dim = el->NumNodes();

                                 //Builds elements stiffness matrix
                                 el->CalcStiff(ek,ef);


                                 std::cout<< " assemblando elemento frontal " << iel <<std::endl;

 #ifdef LOG4CXX
         if (logger->isDebugEnabled())
                                 {
                                                 std::stringstream sout;
                                                 ek.fMat.Print("Element stiffness Frontal",sout);
                                                 LOGPZ_DEBUG(logger,sout.str())
                                 }
 #endif

                                 AssembleElement(el, ek, ef, stiffness, rhs);
 #ifdef LOG4CXX
                                 if(loggerel->isDebugEnabled())
                                 {
                                                 std::stringstream sout;
                                                 ek.fMat.Print("Element stiffness depois de assemblada ",sout);
                                                 LOGPZ_DEBUG(loggerel,sout.str())
                                 }
 #endif

                                 if(!f_quiet)
                                 {
                                                 cout << '*';
                                                 if(!(numel%20)) {
                                                                 cout << " " << (100*iel/nelem) << "% Elements assembled " << endl;
                                                                 cout.flush();
                                                 }
                                 }
                                 numel++;

                 }//fim for iel

 }

 //Verificar declaracao dos parametros !!!!!
 template<class front>
 void TPZFrontStructMatrix<front>::AssembleElement(TPZCompEl * el, TPZElementMatrix & ek, TPZElementMatrix & ef, TPZMatrix<STATE> & stiffness, TPZFMatrix<STATE> & rhs){


                 if(!el->HasDependency()) {
                                 //ek.fMat->Print("stiff has no constraint",test);
                                 //ef.fMat->Print("rhs has no constraint",test);
                                 //test.flush();
                                 ek.ComputeDestinationIndices();
                                 this->FilterEquations(ek.fSourceIndex,ek.fDestinationIndex);
 #ifdef LOG4CXX
         if (logger->isDebugEnabled())
                                 {
             std::stringstream sout;
             sout << "Element index " << el->Index() << " Unconstrained destination index " << ek.fDestinationIndex;
             LOGPZ_DEBUG(logger,sout.str())
                                 }
 #endif
                                 //ek.Print(*fMesh,cout);
                                 stiffness.AddKel(ek.fMat,ek.fSourceIndex,ek.fDestinationIndex);
                                 rhs.AddFel(ef.fMat,ek.fSourceIndex, ek.fDestinationIndex);                 //  ??????????? Erro
                 }
                 else
                 {
         ek.ApplyConstraints();
         ef.ApplyConstraints();
         ek.ComputeDestinationIndices();
         FilterEquations(ek.fSourceIndex,ek.fDestinationIndex);
 #ifdef LOG4CXX
         if (logger->isDebugEnabled())
         {
                                                 std::stringstream sout;
                                                 sout << "Element index " << el->Index() << " Constrained destination index " << ek.fDestinationIndex;
                                                 LOGPZ_DEBUG(logger,sout.str())
         }
 #endif
         stiffness.AddKel(ek.fConstrMat,ek.fSourceIndex,ek.fDestinationIndex);
         rhs.AddFel(ef.fConstrMat,ek.fSourceIndex,ek.fDestinationIndex);
                 }
 }


 template<class front>
 void TPZFrontStructMatrix<front>::SetQuiet(int quiet)
 {
                 this->f_quiet = quiet;
 }

 #ifndef STATE_COMPLEX
 #include "pzmat2dlin.h"

 template<class front>
 int TPZFrontStructMatrix<front>::main() {
                 int refine = 5;
                 int order = 2;

                 TPZGeoMesh gmesh;
                 TPZCompMesh cmesh(&gmesh);
                 double coordstore[4][3] = {{0.,0.,0.},{1.,0.,0.},{1.,1.,0.},
                                 {0.,1.,0.}};

                 int i,j;
                 TPZVec<REAL> coord(3,0.);
                 for(i=0; i<4; i++) {
                                 // initializar as coordenadas do no em um vetor
                                 for (j=0; j<3; j++) coord[j] = coordstore[i][j];

                                 // identificar um espa�o no vetor onde podemos armazenar
                                 // este vetor

                                 // initializar os dados do n�
                                 gmesh.NodeVec ()[i].Initialize (i,coord,gmesh);
                 }
                 int el;
                 //TPZGeoEl *gel;
                 for(el=0; el<1; el++) {

                                 // initializar os indices dos n�s
                                 TPZVec<int64_t> indices(4);
                                 for(i=0; i<4; i++) indices[i] = i;
                                 // O proprio construtor vai inserir o elemento na malha
                                 int64_t index;
                                 /*gel = */gmesh.CreateGeoElement(EQuadrilateral, indices, 1, index);
                 }
                 gmesh.BuildConnectivity ();

                 TPZVec<TPZGeoEl *> subel;
                 //gel->Divide(subel);


                 cout << "Refinement ";
                 cin >> refine;
                 cout << endl;
     DebugStop();
 //              UniformRefine(refine,gmesh);


                 TPZMat2dLin *meumat = new TPZMat2dLin(1);
                 TPZFMatrix<STATE> xk(1,1,1.),xc(1,2,0.),xf(1,1,1.);
                 meumat->SetMaterial (xk,xc,xf);
                 TPZMaterial * meumatptr(meumat);
                 cmesh.InsertMaterialObject(meumatptr);

                 TPZFMatrix<STATE> val1(1,1,0.),val2(1,1,0.);
                 TPZMaterial * bnd = meumat->CreateBC (meumatptr,-4,0,val1,val2);
                 cmesh.InsertMaterialObject(bnd);


                 cout << "Interpolation order ";
                 cin >> order;
                 cout << endl;

                 //              TPZCompEl::gOrder = order;
                 cmesh.SetDefaultOrder(order);

                 cmesh.AutoBuild();
                 //              cmesh.AdjustBoundaryElements();
                 cmesh.InitializeBlock();

                 ofstream output("outputNon.dat");
                 //              ofstream output2("outputNon.dat");
                 cmesh.Print(output);
                 TPZAnalysis an(&cmesh,true,output);
                 //              TPZAnalysis an2(&cmesh,output);

                 TPZVec<int> numelconnected(cmesh.NEquations(),0);
                 int64_t ic;
                 cout << "Numero de Equacoes -> " << cmesh.NEquations() << endl;
                 cout.flush();

                 ofstream out("cmeshBlock_out.txt");
                 //              cmesh.Print(out);
                 //              cmesh.Block().Print("Block",out);
                 for(ic=0; ic<cmesh.ConnectVec().NElements(); ic++) {
                                 TPZConnect &cn = cmesh.ConnectVec()[ic];
                                 if(cn.HasDependency()) continue;
                                 int64_t seqn = cn.SequenceNumber();
                                 if(seqn < 0) continue;
                                 int64_t firsteq = cmesh.Block().Position(seqn);
                                 int64_t lasteq = firsteq+cmesh.Block().Size(seqn);
                                 int64_t ind;
                                 int temp = cmesh.ConnectVec()[ic].NElConnected();
                                 for(ind=firsteq;ind<lasteq;ind++) {
                                                 numelconnected[ind] = temp;//cmesh.ConnectVec()[ic].NElConnected();
                                 }
                 }
                 //               << "nequations " << numelconnected.NElements();
                 //              for(ic=0;ic<numelconnected.NElements(); ic++) cout << numelconnected[ic] <<' ';
                 //              cout << endl;
                 //              cout.flush();

                 //              TPZFrontMatrix<TPZFileEqnStorage, TPZFrontNonSym> *mat = new TPZFrontMatrix<TPZFileEqnStorage, TPZFrontNonSym>(cmesh.NEquations());
                 //TPZFrontMatrix<TPZStackEqnStorage, TPZFrontNonSym> *mat = new TPZFrontMatrix<TPZStackEqnStorage, TPZFrontNonSym>(cmesh.NEquations());
                 //TPZFrontMatrix<TPZStackEqnStorage> *mat = new TPZFrontMatrix<TPZStackEqnStorage>(cmesh.NEquations());

                 TPZFrontStructMatrix<TPZFrontSym<STATE> > mat(&cmesh);

                 //   TPZFStructMatrix mat2(&cmesh);
                 //  mat->SetNumElConnected(numelconnected);
                 //mat = CreateAssemble();


                 an.SetStructuralMatrix(mat);
                 //              an2.SetStructuralMatrix(mat2);

                 TPZStepSolver<STATE> sol;
                 sol.SetDirect(ECholesky);
                 //              TPZStepSolver sol2;
                 //              sol2.SetDirect(ECholesky);
                 //              sol.SetDirect(ELU);


                 an.SetSolver(sol);
                 //     an2.SetSolver(sol2);
                 //              mat->SetNumElConnected(numelconnected);
                 //              mat->SetFileName("longhin.bin");
                 //              an.Solver().SetDirect(ELU);
                 //              mat->FinishWriting();
                 //  mat->SetFileName('r',"longhin.bin");
                 //              cout << "******************************************************************************************************AQUI 1" << endl;
                 an.Run(output);
                 an.Print("solution of frontal solver", output);
                 //              cout << "******************************************************************************************************AQUI 2" << endl;
                 //              an2.Run(output2);
                 //              an2.Print("solution of frontal solver", output2);
                 /*
                  TPZVec<char *> scalnames(1);
                  scalnames[0] = "state";

                  TPZVec<char *> vecnames(0);

                  TPZDXGraphMesh graph(&cmesh,2,meumat,vecnames,scalnames);
                  ofstream *dxout = new ofstream("poisson.dx");
                  graph.SetOutFile(*dxout);
                  graph.SetResolution(0);

                  //an.DefineGraphMesh(2, scalnames, vecnames, plotfile);
                  //an.Print("FEM SOLUTION ",output);
                  //an.PostProcess(1);
                  int istep = 0,numstep=1;

                  graph.DrawMesh(numstep+1);
                  graph.DrawSolution(0,0);

                  TPZAnalysis an2(&cmesh,output);
                  TPZFMatrix<STATE> *full = new TPZFMatrix(cmesh.NEquations(),cmesh.NEquations(),0.);
                  an2.SetMatrix(full);
                  an2.Solver().SetDirect(ELU);
                  an2.Run(output);
                  an2.Print("solution of full matrix", output);

                  //             full->Print("full decomposed matrix");
                  */
                 output.flush();
                 cout.flush();
                 return 0;

 }
 #endif

 template<class front>
 void TPZFrontStructMatrix<front>::AdjustSequenceNumbering()
 {
                 int64_t nconnect = this->fMesh->ConnectVec().NElements();
                 TPZManVector<int64_t> permute(nconnect);
                 fMesh->ComputeNodElCon();
                 int64_t i;
                 for(i=0; i<nconnect; i++)
                 {
                                 permute[i] = i;
                 }
                 TPZCompEl *cel;
                 int64_t nelem = fElementOrder.NElements();
                 int64_t el;
                 int64_t connectcount = 0;
                 for(i=0; i<nelem; i++)
                 {
                                 el = fElementOrder[i];
         if(el<0) continue;
                                 cel = fMesh->ElementVec()[el];
                                 if(!cel) continue;
                                 std::set<int64_t> indepconnects, depconnects;
                                 cel->BuildConnectList(indepconnects,depconnects);
                                 std::set<int64_t>::iterator it;
                                 for(it=indepconnects.begin(); it != indepconnects.end(); it++)
                                 {
                                                 TPZConnect &nod = fMesh->ConnectVec()[*it];
                                                 int nelcon = nod.NElConnected()-1;
                                                 int64_t seqnum = nod.SequenceNumber();
                                                 if(nelcon == 0) permute[seqnum]= connectcount++;
                                                 nod.DecrementElConnected();
                                 }
                 }
                 for(i=0; i<nconnect; i++)
                 {
                                 TPZConnect &nod = fMesh->ConnectVec()[i];
                                 if(nod.SequenceNumber() < 0 || nod.NElConnected() <= 0) continue;
                                 if(permute[nod.SequenceNumber()] < connectcount)
                                 {
                                                 std::cout << __PRETTY_FUNCTION__ << " very fishy\n";
                                                 DebugStop();
                                 }
                 }
 #ifdef LOG4CXX
     if (logger->isDebugEnabled())
                 {
                                 std::stringstream sout;
                                 sout << __PRETTY_FUNCTION__ << " permutation " << permute;
                                 LOGPZ_DEBUG(logger,sout.str())
                 }
 #endif
                 fMesh->Permute(permute);
 }

 template<class TVar>
 class TPZFrontSym;
 template<class TVar>
 class TPZFrontNonSym;

 template class TPZFrontStructMatrix<TPZFrontSym<STATE> >;
 template class TPZFrontStructMatrix<TPZFrontNonSym<STATE> >;

TPZFrontStructMatrix::GetNumElConnected
void GetNumElConnected(TPZVec< int > &numelconnected)
Returns a vector containing all elements connected to a degree of freedom.
Definition: TPZFrontStructMatrix.cpp:42

TPZCompMesh::NElements
int64_t NElements() const
Number of computational elements allocated.
Definition: pzcmesh.h:169

EQuadrilateral
Definition: pzeltype.h:57

TPZFrontStructMatrix::OrderElement
void OrderElement()
It is applied over fElementOrder putting it in the correct order.
Definition: TPZFrontStructMatrix.cpp:104

pzanalysis.h
Contains TPZAnalysis class which implements the sequence of actions to perform a finite element analy...

numel
const int64_t numel
Number of elements to test.
Definition: pzsubcmesh.cpp:47

TPZBlock::Position
int Position(const int block_diagonal) const
Returns the position of first element block dependent on matrix diagonal.
Definition: pzblock.h:177

TPZConnect
Represents a set of shape functions associated with a computational element/side. Computational Eleme...
Definition: pzconnect.h:30

pzlog.h
Contains definitions to LOGPZ_DEBUG, LOGPZ_INFO, LOGPZ_WARN, LOGPZ_ERROR and LOGPZ_FATAL, and the implementation of the inline InitializePZLOG(string) function using log4cxx library or not. It must to be called out of "#ifdef LOG4CXX" scope.

TPZAnalysis::SetStructuralMatrix
void SetStructuralMatrix(TPZAutoPointer< TPZStructMatrix > strmatrix)
Set structural matrix as auto pointer for analysis.
Definition: pzanalysis.cpp:82

TPZManVector< int64_t >

TPZFrontStructMatrix::main
static int main()
Definition: TPZFrontStructMatrix.cpp:471

ENoDecompose
Definition: pzmatrix.h:52

TPZAnalysis::Print
void Print(const std::string &name, std::ostream &out)
Print connect and solution information.
Definition: pzanalysis.cpp:447

TPZFrontMatrix
Responsible for the frontal method as a whole. Frontal.
Definition: TPZFrontMatrix.h:59

TPZFrontStructMatrix::Assemble
void Assemble(TPZMatrix< STATE > &stiffness, TPZFMatrix< STATE > &rhs, TPZAutoPointer< TPZGuiInterface > guiInterface)
Assemble a stiffness matrix.
Definition: TPZFrontStructMatrix.cpp:340

TPZConnect::DecrementElConnected
void DecrementElConnected()
Decrement fNElConnected.
Definition: pzconnect.h:262

TPZGeoMesh::CreateGeoElement
virtual TPZGeoEl * CreateGeoElement(MElementType type, TPZVec< int64_t > &cornerindexes, int matid, int64_t &index, int reftype=1)
Generic method for creating a geometric element. Putting this method centrally facilitates the modifi...
Definition: pzgmesh.cpp:1296

TPZCompEl::BuildConnectList
virtual void BuildConnectList(std::set< int64_t > &indepconnectlist, std::set< int64_t > &depconnectlist)
Builds the list of all connectivities related to the element including the connects pointed to by dep...
Definition: pzcompel.cpp:435

TPZFrontStructMatrix.h
Contains the TPZFrontStructMatrix class which responsible for a interface among Finite Element Packag...

TPZFrontStructMatrix::f_quiet
int f_quiet
Definition: TPZFrontStructMatrix.h:36

TPZFrontMatrix::GetFront
TPZFront< TVar > & GetFront() override
returns a pointer to the front matrix
Definition: TPZFrontMatrix.h:80

TPZCompMesh::NEquations
int64_t NEquations()
This computes the number of equations associated with non-restrained nodes.
Definition: pzcmesh.cpp:721

TPZFMatrix::AddFel
void AddFel(TPZFMatrix< TVar > &rhs, TPZVec< int64_t > &destination)
Performs a right hand side assemblage.
Definition: pzfmatrix.cpp:209

TPZElementMatrix::fMat
TPZFNMatrix< 1000, STATE > fMat
Pointer to a blocked matrix object.
Definition: pzelmat.h:41

TPZStepSolver
Defines step solvers class. Solver.
Definition: pzmganalysis.h:17

TPZAnalysis::SetSolver
void SetSolver(TPZMatrixSolver< STATE > &solver)
Set solver matrix.
Definition: pzanalysis.cpp:1202

TPZElementMatrix::EF
Definition: pzelmat.h:32

TPZCompEl::CalcStiff
virtual void CalcStiff(TPZElementMatrix &ek, TPZElementMatrix &ef)
Computes the element stifness matrix and right hand side.
Definition: pzcompel.h:794

std

TPZStructMatrixBase::fEquationFilter
TPZEquationFilter fEquationFilter
Object which will determine which equations will be assembled.
Definition: TPZStructMatrixBase.h:104

TPZFrontSym
Abstract class implements storage and decomposition process of the frontal matrix involving simmetry ...
Definition: TPZFrontMatrix.cpp:390

pzadmchunk.h
Declarates the TPZBlock<REAL>class which implements block matrices.

TPZSubCompMesh::NumberRigidBodyModes
int NumberRigidBodyModes()
Return the number of rigid body modes associated with the internal degrees of freedom.
Definition: pzsubcmesh.cpp:2064

TPZVec< int >

TPZChunkVector::NElements
int64_t NElements() const
Access method to query the number of elements of the vector.
Definition: TPZChunkVector.h:236

TPZAdmChunkVector
Implements a chunk vector with free store administration. Utility.
Definition: TPZStream.h:39

pzstrmatrix.h
Contains the TPZStructMatrixOR class which responsible for a interface among Matrix and Finite Elemen...

TPZElementMatrix::fDestinationIndex
TPZManVector< int64_t > fDestinationIndex
Definition: pzelmat.h:53

TPZElementMatrix::ComputeDestinationIndices
void ComputeDestinationIndices()
Definition: pzelmat.cpp:126

TPZFrontStructMatrix::~TPZFrontStructMatrix
virtual ~TPZFrontStructMatrix()
Class destructor.
Definition: TPZFrontStructMatrix.cpp:80

pzfstrmatrix.h
Contains the TPZFStructMatrix class which implements Full Structural Matrices.

TPZCompMesh::SetDefaultOrder
void SetDefaultOrder(int order)
Definition: pzcmesh.h:403

TPZStructMatrixOR
Refines geometrical mesh (all the elements) num times.
Definition: pzstrmatrix.h:35

TPZMaterial
This abstract class defines the behaviour which each derived class needs to implement.
Definition: TPZMaterial.h:39

pzelmat.h
Contains declaration of TPZElementMatrix struct which associates an element matrix with the coeficien...

TPZStructMatrixBase::fMesh
TPZCompMesh * fMesh
Pointer to the computational mesh from which the matrix will be generated.
Definition: TPZStructMatrixBase.h:100

TPZFrontStructMatrix::fDecomposeType
DecomposeType fDecomposeType
Used Decomposition method.
Definition: TPZFrontStructMatrix.h:51

TPZFrontStructMatrix::AdjustSequenceNumbering
void AdjustSequenceNumbering()
Resequence the connects according to the element order.
Definition: TPZFrontStructMatrix.cpp:645

pzbndcond.h
Contains the TPZBndCond class which implements a boundary condition for TPZMaterial objects...

TPZCompEl::Material
virtual TPZMaterial * Material() const
Identify the material object associated with the element.
Definition: pzcompel.cpp:959

TPZFrontStructMatrix::TPZFrontStructMatrix
TPZFrontStructMatrix()
Definition: TPZFrontStructMatrix.cpp:71

TPZFrontStructMatrix::fElementOrder
TPZVec< int > fElementOrder
This vector contains an ordered list.
Definition: TPZFrontStructMatrix.h:35

TPZVec::size
int64_t size() const
Returns the number of elements of the vector.
Definition: pzvec.h:196

TPZVec::Resize
virtual void Resize(const int64_t newsize, const T &object)
Resizes the vector object reallocating the necessary storage, copying the existing objects to the new...
Definition: pzvec.h:373

pzgmesh.h
Contains declaration of TPZMesh class which defines a geometrical mesh and contains a corresponding l...

TPZConnect::SequenceNumber
int64_t SequenceNumber() const
Returns the Sequence number of the connect object.
Definition: pzconnect.h:158

TPZFrontStructMatrix::AssembleElement
void AssembleElement(TPZCompEl *el, TPZElementMatrix &ek, TPZElementMatrix &ef, TPZMatrix< STATE > &stiffness, TPZFMatrix< STATE > &rhs)
Computes element matrices.
Definition: TPZFrontStructMatrix.cpp:416

TPZAnalysis
Implements the sequence of actions to perform a finite element analysis. Analysis.
Definition: pzanalysis.h:32

TPZEquationFilter::NActiveEquations
int64_t NActiveEquations() const
Retorna o numero de equacoes ativas do sistema.
Definition: TPZEquationFilter.h:151

TPZSubCompMesh
Implements a group of computational elements as a mesh and an element. Computational Mesh...
Definition: pzsubcmesh.h:36

DebugStop
#define DebugStop()
Returns a message to user put a breakpoint in.
Definition: pzerror.h:20

TPZFrontMatrix::FinishWriting
void FinishWriting()
Finishes writing of a binary file and closes it.
Definition: TPZFrontMatrix.cpp:368

TPZElementMatrix::EK
Definition: pzelmat.h:32

LOGPZ_DEBUG
#define LOGPZ_DEBUG(A, B)
Define log for debug info.
Definition: pzlog.h:87

TPZFrontMatrix::SetNumElConnected
void SetNumElConnected(TPZVec< int > &numelconnected)
Initializes the number of elements connected to each equation.
Definition: TPZFrontMatrix.cpp:58

pzconnect.h
Contains declaration of TPZConnect class which represents a set of shape functions associated with a ...

TPZCompMesh::ComputeNodElCon
virtual void ComputeNodElCon()
Compute the number of elements connected to each connect object.
Definition: pzcmesh.cpp:668

TPZFrontStructMatrix::AssembleNew
void AssembleNew(TPZMatrix< STATE > &stiffness, TPZFMatrix< STATE > &rhs, TPZAutoPointer< TPZGuiInterface > guiInterface)
Assemble a stiffness matrix according to rhs.
Definition: TPZFrontStructMatrix.cpp:269

TPZGuiInterface::AmIKilled
bool AmIKilled()
Definition: TPZGuiInterface.cpp:85

TPZGeoMesh::NodeVec
TPZAdmChunkVector< TPZGeoNode > & NodeVec()
Definition: pzgmesh.h:140

TPZCompMesh::AutoBuild
virtual void AutoBuild(const std::set< int > *MaterialIDs)
Creates the computational elements, and the degree of freedom nodes.
Definition: pzcmesh.cpp:308

TPZConnect::HasDependency
int HasDependency() const
Returns whether exist dependecy information.
Definition: pzconnect.h:292

TPZMatrix::AddKel
virtual void AddKel(TPZFMatrix< TVar > &elmat, TPZVec< int64_t > &destinationindex)
Add a contribution of a stiffness matrix.
Definition: pzmatrix.cpp:506

TPZCompMesh::Block
const TPZBlock< STATE > & Block() const
Access the block structure of the solution vector.
Definition: pzcmesh.h:213

TPZFrontStructMatrix
Responsible for a interface among Finite Element Package and Matrices package to frontal method...
Definition: TPZFrontStructMatrix.h:30

TPZFront::SetNumRigidBodyModes
void SetNumRigidBodyModes(int nrigid)
Indicate the first equation dedicated to rigid body modes.
Definition: TPZFront.h:63

pzmat2dlin.h
Contains the TPZMat2dLin class which implements a bi-dimensional linear problem.

TPZCompMesh::ConnectVec
TPZAdmChunkVector< TPZConnect > & ConnectVec()
Return a reference to the connect pointers vector.
Definition: pzcmesh.h:198

TPZCompEl::Index
int64_t Index() const
Returns element index of the mesh fELementVec list.
Definition: pzcompel.h:821

TPZFrontMatrix::ReOpen
void ReOpen()
Reopen the binary file.
Definition: TPZFrontMatrix.cpp:372

TPZStructMatrixBase::ShouldCompute
virtual bool ShouldCompute(int matid) const
Establish whether the element should be computed.
Definition: TPZStructMatrixBase.h:75

TPZElementMatrix::fSourceIndex
TPZManVector< int64_t > fSourceIndex
Definition: pzelmat.h:53

pzcmesh.h
Contains declaration of TPZCompMesh class which is a repository for computational elements...

TPZFMatrix< STATE >

TPZFrontStructMatrix::Clone
TPZStructMatrix * Clone()
Clones a TPZFrontStructMatrix.
Definition: TPZFrontStructMatrix.cpp:98

TPZMat2dLin::SetMaterial
void SetMaterial(TPZFMatrix< STATE > &xkin, TPZFMatrix< STATE > &xcin, TPZFMatrix< STATE > &xfin)
Definition: pzmat2dlin.h:44

TPZFrontStructMatrix::Create
TPZMatrix< STATE > * Create()
Returns a pointer to TPZMatrix<STATE>
Definition: TPZFrontStructMatrix.cpp:85

TPZAnalysis::Run
virtual void Run(std::ostream &out=std::cout)
Calls the appropriate sequence of methods to build a solution or a time stepping sequence.
Definition: pzanalysis.cpp:920

TPZElementMatrix
This class associates an element matrix with the coeficients of its contribution in the global stiffn...
Definition: pzelmat.h:30

TPZElementMatrix::fConstrMat
TPZFNMatrix< 1000, STATE > fConstrMat
Pointer to the constrained matrix object.
Definition: pzelmat.h:48

TPZFront::SetDecomposeType
virtual void SetDecomposeType(DecomposeType dectype)=0
Set the decomposition type.

TPZElementMatrix::ApplyConstraints
void ApplyConstraints()
Apply the constraints applied to the nodes by transforming the tangent matrix and right hand side...
Definition: pzelmat.cpp:186

TPZGeoMesh::BuildConnectivity
void BuildConnectivity()
Build the connectivity of the grid.
Definition: pzgmesh.cpp:967

TPZMaterial::CreateBC
virtual TPZBndCond * CreateBC(TPZMaterial *reference, int id, int typ, TPZFMatrix< STATE > &val1, TPZFMatrix< STATE > &val2)
Creates an object TPZBndCond derived of TPZMaterial.
Definition: TPZMaterial.cpp:282

pzsubcmesh.h
Contains declaration of TPZSubCompMesh class which implements a group of computational elements as a ...

TPZCompMesh::InsertMaterialObject
int InsertMaterialObject(TPZMaterial *mat)
Insert a material object in the datastructure.
Definition: pzcmesh.cpp:287

TPZGeoMesh
This class implements a geometric mesh for the pz environment. Geometry.
Definition: pzgmesh.h:48

TPZMat2dLin
Implements a bi-dimensional linear problem.
Definition: pzmat2dlin.h:22

TPZStack< int64_t >

pzsmfrontalanal.h
Contains TPZSubMeshFrontalAnalysis class which implements the analysis for substructuring.

TPZCompMesh
Implements computational mesh. Computational Mesh.
Definition: pzcmesh.h:47

TPZBlock::Size
int Size(const int block_diagonal) const
Returns block dimension.
Definition: pzblock.h:171

TPZFrontMatrix.h
Contains the TPZAbstractFrontMatrix class which implements a matrix stored in a frontal decomposition...

TPZCompMesh::ElementVec
TPZAdmChunkVector< TPZCompEl * > & ElementVec()
Returns a reference to the element pointers vector.
Definition: pzcmesh.h:183

pzsolve.h
Contains TPZSolver class which defines a abstract class of solvers which will be used by matrix class...

TPZConnect::NElConnected
int NElConnected() const
Returns fNElConnected.
Definition: pzconnect.h:264

TPZMaterial::Id
int Id() const
Definition: TPZMaterial.h:170

TPZVec::Fill
void Fill(const T &copy, const int64_t from=0, const int64_t numelem=-1)
Will fill the elements of the vector with a copy object.
Definition: pzvec.h:460

pzstepsolver.h
Contains TPZStepSolver class which defines step solvers class.

TPZStructMatrixBase::FilterEquations
virtual void FilterEquations(TPZVec< int64_t > &origindex, TPZVec< int64_t > &destindex) const
Filter out the equations which are out of the range.
Definition: TPZStructMatrixBase.cpp:79

TPZVec::NElements
int64_t NElements() const
Returns the number of elements of the vector.
Definition: pzvec.h:190

TPZStepSolver::SetDirect
void SetDirect(const DecomposeType decomp)
Definition: pzstepsolver.cpp:184

pzdxmesh.h
Contains the TPZDXGraphMesh class which implements the interface of the graphmesh to the OpenDX graph...

TPZCompMesh::InitializeBlock
void InitializeBlock()
Resequence the block object, remove unconnected connect objects and reset the dimension of the soluti...
Definition: pzcmesh.cpp:391

ECholesky
Definition: pzmatrix.h:52

TPZCompEl
Defines the interface of a computational element. Computational Element.
Definition: pzcompel.h:59

TPZConnect::IsCondensed
bool IsCondensed() const
Access method to return the indication whether the connect is condensed or not.
Definition: pzconnect.h:223

TPZCompEl::HasDependency
virtual int HasDependency()
Returns 1 if the element has at least one dependent node. Returns 0 otherwise.
Definition: pzcompel.cpp:565

TPZFrontStructMatrix::SetQuiet
void SetQuiet(int quiet)
Definition: TPZFrontStructMatrix.cpp:462

TPZFrontNonSym
Abstract class implements storage and decomposition process of the frontal matrix involving non-simet...
Definition: TPZFrontMatrix.cpp:392

TPZCompMesh::Print
virtual void Print(std::ostream &out=std::cout) const
Prints mesh data.
Definition: pzcmesh.cpp:236

TPZMatrix< STATE >

TPZCompMesh::Permute
void Permute(TPZVec< int64_t > &permute)
Permute the sequence number of the connect objects It is a permute gather operation.
Definition: pzcmesh.cpp:1321

TPZAutoPointer< TPZGuiInterface >