int Skyline :: buildInternalStructure(EngngModel *eModel, int di, const UnknownNumberingScheme &s) { // first create array of // maximal column height for assembled characteristics matrix // int maxle; int ac1; int neq; if ( s.isDefault() ) { neq = eModel->giveNumberOfDomainEquations(di, s); } else { neq = s.giveRequiredNumberOfDomainEquation(); } if ( neq == 0 ) { if ( mtrx ) { delete mtrx; } mtrx = NULL; adr.clear(); return true; } IntArray loc; IntArray mht(neq); Domain *domain = eModel->giveDomain(di); for ( int j = 1; j <= neq; j++ ) { mht.at(j) = j; // initialize column height, maximum is line number (since it only stores upper triangular) } // loop over elements code numbers for ( auto &elem : domain->giveElements() ) { elem->giveLocationArray(loc, s); maxle = INT_MAX; for ( int ieq : loc ) { if ( ieq != 0 ) { maxle = min(maxle, ieq); } } for ( int ieq : loc ) { if ( ieq != 0 ) { mht.at(ieq) = min( maxle, mht.at(ieq) ); } } } // loop over active boundary conditions (e.g. relative kinematic constraints) std :: vector< IntArray >r_locs; std :: vector< IntArray >c_locs; for ( auto &gbc : domain->giveBcs() ) { ActiveBoundaryCondition *bc = dynamic_cast< ActiveBoundaryCondition * >( gbc.get() ); if ( bc != NULL ) { bc->giveLocationArrays(r_locs, c_locs, UnknownCharType, s, s); for ( std :: size_t k = 0; k < r_locs.size(); k++ ) { IntArray &krloc = r_locs [ k ]; IntArray &kcloc = c_locs [ k ]; maxle = INT_MAX; for ( int ii : krloc ) { if ( ii > 0 ) { maxle = min(maxle, ii); } } for ( int jj : kcloc ) { if ( jj > 0 ) { mht.at(jj) = min( maxle, mht.at(jj) ); } } } } } if ( domain->hasContactManager() ) { ContactManager *cMan = domain->giveContactManager(); for ( int i =1; i <= cMan->giveNumberOfContactDefinitions(); i++ ) { ContactDefinition *cDef = cMan->giveContactDefinition(i); for ( int k = 1; k <= cDef->giveNumbertOfContactElements(); k++ ) { ContactElement *cEl = cDef->giveContactElement(k); cEl->giveLocationArray(loc, s); maxle = INT_MAX; for ( int ieq : loc ) { if ( ieq != 0 ) { maxle = min(maxle, ieq); } } for ( int ieq : loc ) { if ( ieq != 0 ) { mht.at(ieq) = min( maxle, mht.at(ieq) ); } } } } } // NOTE // add there call to eModel if any possible additional equation added by // eModel // currently not supported // increases number of columns according to size of mht // mht is array containing minimal equation number per column // This method also increases column height. adr.resize(neq + 1); ac1 = 1; for ( int i = 1; i <= neq; i++ ) { adr.at(i) = ac1; ac1 += ( i - mht.at(i) + 1 ); } adr.at(neq + 1) = ac1; nRows = nColumns = neq; nwk = ac1; if ( mtrx ) { free(mtrx); } mtrx = ( double * ) calloc( ac1, sizeof( double ) ); if ( !mtrx ) { OOFEM_ERROR("Can't allocate: %d", ac1); } // increment version this->version++; return true; }
int DynCompCol :: buildInternalStructure(EngngModel *eModel, int di, const UnknownNumberingScheme &s) { /* * int neq = eModel -> giveNumberOfDomainEquations (di); * **#ifndef DynCompCol_USE_STL_SETS * IntArray loc; * Domain* domain = eModel->giveDomain(di); * int nelem = domain -> giveNumberOfElements() ; * int i,ii,j,jj,n, indx; * Element* elem; * IntArray colItems(neq); * // allocation map * char* map = new char[neq*neq]; * if (map == NULL) { * printf ("CompCol::buildInternalStructure - map creation failed"); * exit (1); * } * * for (i=0; i<neq*neq; i++) * map[i]=0; * * * for (n=1 ; n<=nelem ; n++) { * elem = domain -> giveElement(n); * elem -> giveLocationArray (loc) ; * * for (i=1 ; i <= loc.giveSize() ; i++) { * if ((ii = loc.at(i))) { * for (j=1; j <= loc.giveSize() ; j++) { * if ((jj=loc.at(j))) * if (map[(ii-1)*neq+jj-1] == 0) { * map[(ii-1)*neq+jj-1] = 1; * colItems.at(ii) ++; * } * } * } * } * } * * if (rowind_) { * for (i=0; i< nColumns; i++) delete this->rowind_[i]; * delete this->rowind_; * } * rowind_ = (IntArray**) new (IntArray*)[neq]; * for (j=0; j<neq; j++) rowind_[j] = new IntArray(colItems(j)); * * indx = 1; * for (j=0; j<neq; j++) { // column loop * indx = 1; * for (i=0; i<neq; i++) { // row loop * if (map[i*neq+j]) { * rowind_[j]->at(indx) = i; * indx++; * } * } * } * * // delete map * delete (map); * * // allocate value array * if (columns_) { * for (i=0; i< nColumns; i++) delete this->columns_[i]; * delete this->columns_; * } * columns_= (FloatArray**) new (FloatArray*)[neq]; * int nz_ = 0; * for (j=0; j<neq; j++) { * columns_[j] = new FloatArray (colItems(j)); * nz_ += colItems(j); * } * * printf ("\nDynCompCol info: neq is %d, nelem is %d\n",neq,nz_); **#else * int i,j; * if (columns) { * for (i=0; i< nColumns; i++) delete this->columns[i]; * delete this->columns; * } * columns= new std::map<int, double>*[neq]; * for (j=0; j<neq; j++) { * columns[j] = new std::map<int, double>; * } * **#endif * * nColumns = nRows = neq; * // increment version * this->version++; * * return true; */ int neq = eModel->giveNumberOfDomainEquations(di, s); #ifndef DynCompCol_USE_STL_SETS IntArray loc; Domain *domain = eModel->giveDomain(di); int nelem = domain->giveNumberOfElements(); int i, ii, j, jj, n; Element *elem; nColumns = nRows = neq; if ( rowind_ ) { for ( i = 0; i < nColumns; i++ ) { delete this->rowind_ [ i ]; } delete this->rowind_; } rowind_ = ( IntArray ** ) new IntArray * [ neq ]; for ( j = 0; j < neq; j++ ) { rowind_ [ j ] = new IntArray(); } // allocate value array if ( columns_ ) { for ( i = 0; i < nColumns; i++ ) { delete this->columns_ [ i ]; } delete this->columns_; } columns_ = ( FloatArray ** ) new FloatArray * [ neq ]; for ( j = 0; j < neq; j++ ) { columns_ [ j ] = new FloatArray(); } for ( n = 1; n <= nelem; n++ ) { elem = domain->giveElement(n); elem->giveLocationArray(loc, s); for ( i = 1; i <= loc.giveSize(); i++ ) { if ( ( ii = loc.at(i) ) ) { for ( j = 1; j <= loc.giveSize(); j++ ) { if ( ( jj = loc.at(j) ) ) { this->insertRowInColumn(ii - 1, jj - 1); } } } } } // loop over active boundary conditions int nbc = domain->giveNumberOfBoundaryConditions(); std :: vector< IntArray >r_locs; std :: vector< IntArray >c_locs; for ( int i = 1; i <= nbc; ++i ) { ActiveBoundaryCondition *bc = dynamic_cast< ActiveBoundaryCondition * >( domain->giveBc(i) ); if ( bc != NULL ) { bc->giveLocationArrays(r_locs, c_locs, UnknownCharType, s, s); for ( std :: size_t k = 0; k < r_locs.size(); k++ ) { IntArray &krloc = r_locs [ k ]; IntArray &kcloc = c_locs [ k ]; for ( int i = 1; i <= krloc.giveSize(); i++ ) { if ( ( ii = krloc.at(i) ) ) { for ( int j = 1; j <= kcloc.giveSize(); j++ ) { if ( ( jj = kcloc.at(j) ) ) { this->insertRowInColumn(jj - 1, ii - 1); } } } } } } } int nz_ = 0; for ( j = 0; j < neq; j++ ) { nz_ += this->rowind_ [ j ]->giveSize(); } OOFEM_LOG_DEBUG("DynCompCol info: neq is %d, nelem is %d\n", neq, nz_); #else nColumns = nRows = neq; columns.resize( neq ); for ( auto &col: columns ) { col.clear(); } #endif // increment version this->version++; return true; }
int CompCol :: buildInternalStructure(EngngModel *eModel, int di, const UnknownNumberingScheme &s) { /* * IntArray loc; * Domain* domain = eModel->giveDomain(di); * int neq = eModel -> giveNumberOfDomainEquations (di); * int nelem = domain -> giveNumberOfElements() ; * int i,ii,j,jj,n, indx; * Element* elem; * // allocation map * char* map = new char[neq*neq]; * if (map == NULL) { * printf ("CompCol::buildInternalStructure - map creation failed"); * exit (1); * } * * for (i=0; i<neq*neq; i++) * map[i]=0; * * * this->nz_ = 0; * * for (n=1 ; n<=nelem ; n++) { * elem = domain -> giveElement(n); * elem -> giveLocationArray (loc) ; * * for (i=1 ; i <= loc.giveSize() ; i++) { * if ((ii = loc.at(i))) { * for (j=1; j <= loc.giveSize() ; j++) { * if ((jj=loc.at(j))) { * if (map[(ii-1)*neq+jj-1] == 0) { * map[(ii-1)*neq+jj-1] = 1; * this->nz_ ++; * } * } * } * } * } * } * * rowind_.resize (nz_); * colptr_.resize (neq+1); * indx = 0; * for (j=0; j<neq; j++) { // column loop * colptr_(j) = indx; * for (i=0; i<neq; i++) { // row loop * if (map[i*neq+j]) { * rowind_(indx) = i; * indx++; * } * } * } * colptr_(neq) = indx; * * // delete map * delete (map); * * // allocate value array * val_.resize(nz_); * val_.zero(); * * printf ("\nCompCol info: neq is %d, nwk is %d\n",neq,nz_); * * dim_[0] = dim_[1] = nColumns = nRows = neq; * * // increment version * this->version++; * * return true; */ IntArray loc; Domain *domain = eModel->giveDomain(di); int neq = eModel->giveNumberOfDomainEquations(di, s); int nelem = domain->giveNumberOfElements(); int i, ii, j, jj, n, indx; Element *elem; // allocation map std :: vector< std :: set< int > > columns(neq); /* * std::set<int> **columns = new std::set<int>*[neq]; * for (j=0; j<neq; j++) { * columns[j] = new std::set<int>; * } */ this->nz_ = 0; for ( n = 1; n <= nelem; n++ ) { elem = domain->giveElement(n); elem->giveLocationArray(loc, s); for ( i = 1; i <= loc.giveSize(); i++ ) { if ( ( ii = loc.at(i) ) ) { for ( j = 1; j <= loc.giveSize(); j++ ) { if ( ( jj = loc.at(j) ) ) { columns [ jj - 1 ].insert(ii - 1); } } } } } // loop over active boundary conditions int nbc = domain->giveNumberOfBoundaryConditions(); std :: vector< IntArray >r_locs; std :: vector< IntArray >c_locs; for ( int i = 1; i <= nbc; ++i ) { ActiveBoundaryCondition *bc = dynamic_cast< ActiveBoundaryCondition * >( domain->giveBc(i) ); if ( bc != NULL ) { bc->giveLocationArrays(r_locs, c_locs, UnknownCharType, s, s); for ( std :: size_t k = 0; k < r_locs.size(); k++ ) { IntArray &krloc = r_locs [ k ]; IntArray &kcloc = c_locs [ k ]; for ( int i = 1; i <= krloc.giveSize(); i++ ) { if ( ( ii = krloc.at(i) ) ) { for ( int j = 1; j <= kcloc.giveSize(); j++ ) { if ( ( jj = kcloc.at(j) ) ) { columns [ jj - 1 ].insert(ii - 1); } } } } } } } for ( i = 0; i < neq; i++ ) { this->nz_ += columns [ i ].size(); } rowind_.resize(nz_); colptr_.resize(neq + 1); indx = 0; for ( j = 0; j < neq; j++ ) { // column loop colptr_(j) = indx; for ( int row: columns [ j ] ) { // row loop rowind_(indx++) = row; } } colptr_(neq) = indx; /* * // delete map * for (i=0; i< neq; i++) {columns[i]->clear(); delete columns[i];} * delete columns; */ // allocate value array val_.resize(nz_); val_.zero(); OOFEM_LOG_DEBUG("CompCol info: neq is %d, nwk is %d\n", neq, nz_); dim_ [ 0 ] = dim_ [ 1 ] = nColumns = nRows = neq; // increment version this->version++; return true; }
int DSSMatrix :: buildInternalStructure(EngngModel *eModel, int di, const UnknownNumberingScheme &s) { IntArray loc; Domain *domain = eModel->giveDomain(di); int neq = eModel->giveNumberOfDomainEquations(di, s); unsigned long indx; // allocation map std :: vector< std :: set< int > >columns(neq); unsigned long nz_ = 0; for ( auto &elem : domain->giveElements() ) { elem->giveLocationArray(loc, s); for ( int ii : loc ) { if ( ii > 0 ) { for ( int jj : loc ) { if ( jj > 0 ) { columns [ jj - 1 ].insert(ii - 1); } } } } } // loop over active boundary conditions std::vector<IntArray> r_locs; std::vector<IntArray> c_locs; for ( auto &gbc : domain->giveBcs() ) { ActiveBoundaryCondition *bc = dynamic_cast< ActiveBoundaryCondition * >( gbc.get() ); if ( bc != NULL ) { bc->giveLocationArrays(r_locs, c_locs, UnknownCharType, s, s); for (std::size_t k = 0; k < r_locs.size(); k++) { IntArray &krloc = r_locs[k]; IntArray &kcloc = c_locs[k]; for ( int ii : krloc ) { if ( ii > 0 ) { for ( int jj : kcloc ) { if ( jj > 0 ) { columns [ jj - 1 ].insert(ii - 1); } } } } } } } for ( int i = 0; i < neq; i++ ) { nz_ += columns [ i ].size(); } unsigned long *rowind_ = new unsigned long [ nz_ ]; unsigned long *colptr_ = new unsigned long [ neq + 1 ]; if ( ( rowind_ == NULL ) || ( colptr_ == NULL ) ) { OOFEM_ERROR("free store exhausted, exiting"); } indx = 0; for ( int j = 0; j < neq; j++ ) { // column loop colptr_ [ j ] = indx; for ( auto &val : columns [ j ] ) { // row loop rowind_ [ indx++ ] = val; } } colptr_ [ neq ] = indx; _sm.reset( new SparseMatrixF(neq, NULL, rowind_, colptr_, 0, 0, true) ); if ( !_sm ) { OOFEM_FATAL("free store exhausted, exiting"); } /* * Assemble block to equation mapping information */ bool _succ = true; int _ndofs, _neq, ndofmans = domain->giveNumberOfDofManagers(); int ndofmansbc = 0; ///@todo This still misses element internal dofs. // count number of internal dofmans on active bc for ( auto &bc : domain->giveBcs() ) { ndofmansbc += bc->giveNumberOfInternalDofManagers(); } int bsize = 0; if ( ndofmans > 0 ) { bsize = domain->giveDofManager(1)->giveNumberOfDofs(); } long *mcn = new long [ (ndofmans+ndofmansbc) * bsize ]; long _c = 0; if ( mcn == NULL ) { OOFEM_FATAL("free store exhausted, exiting"); } for ( auto &dman : domain->giveDofManagers() ) { _ndofs = dman->giveNumberOfDofs(); if ( _ndofs > bsize ) { _succ = false; break; } for ( Dof *dof: *dman ) { if ( dof->isPrimaryDof() ) { _neq = dof->giveEquationNumber(s); if ( _neq > 0 ) { mcn [ _c++ ] = _neq - 1; } else { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } else { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } for ( int i = _ndofs + 1; i <= bsize; i++ ) { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } // loop over internal dofmans of active bc for ( auto &bc : domain->giveBcs() ) { int ndman = bc->giveNumberOfInternalDofManagers(); for (int idman = 1; idman <= ndman; idman ++) { DofManager *dman = bc->giveInternalDofManager(idman); _ndofs = dman->giveNumberOfDofs(); if ( _ndofs > bsize ) { _succ = false; break; } for ( Dof *dof: *dman ) { if ( dof->isPrimaryDof() ) { _neq = dof->giveEquationNumber(s); if ( _neq > 0 ) { mcn [ _c++ ] = _neq - 1; } else { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } } for ( int i = _ndofs + 1; i <= bsize; i++ ) { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } } if ( _succ ) { _dss->SetMatrixPattern(_sm.get(), bsize); _dss->LoadMCN(ndofmans+ndofmansbc, bsize, mcn); } else { OOFEM_LOG_INFO("DSSMatrix: using assumed block structure"); _dss->SetMatrixPattern(_sm.get(), bsize); } _dss->PreFactorize(); // zero matrix, put unity on diagonal with supported dofs _dss->LoadZeros(); delete[] mcn; OOFEM_LOG_DEBUG("DSSMatrix info: neq is %d, bsize is %d\n", neq, nz_); // increment version this->version++; return true; }
int PetscSparseMtrx :: buildInternalStructure(EngngModel *eModel, int di, EquationID ut, const UnknownNumberingScheme &s) { IntArray loc; Domain *domain = eModel->giveDomain(di); int nelem; if ( mtrx ) { MatDestroy(&mtrx); } if ( this->kspInit ) { KSPDestroy(&ksp); this->kspInit = false; // force ksp to be initialized } this->ut = ut; this->emodel = eModel; this->di = di; #ifdef __PARALLEL_MODE if ( eModel->isParallel() ) { int rank; PetscNatural2GlobalOrdering *n2g; PetscNatural2LocalOrdering *n2l; rank = eModel->giveRank(); n2g = eModel->givePetscContext(di, ut)->giveN2Gmap(); n2l = eModel->givePetscContext(di, ut)->giveN2Lmap(); n2l->init(eModel, ut, di); n2g->init(eModel, ut, di); #ifdef __VERBOSE_PARALLEL VERBOSEPARALLEL_PRINT("PetscSparseMtrx:: buildInternalStructure", "", rank); #endif leqs = n2g->giveNumberOfLocalEqs(); geqs = n2g->giveNumberOfGlobalEqs(); //printf("%d, leqs = %d, geqs = %d\n", this->emodel->giveRank(), leqs, geqs); #ifdef __VERBOSE_PARALLEL OOFEM_LOG_INFO( "[%d]PetscSparseMtrx:: buildInternalStructure: l_eqs = %d, g_eqs = %d, n_eqs = %d\n", rank, leqs, geqs, eModel->giveNumberOfEquations(ut) ); #endif // determine nonzero structure of a "local (maintained)" part of matrix, and the off-diagonal part int i, ii, j, jj, n; Element *elem; // allocation map std :: vector< std :: set< int > >d_rows(leqs); // diagonal sub-matrix allocation std :: vector< std :: set< int > >o_rows(leqs); // off-diagonal allocation IntArray d_nnz(leqs), o_nnz(leqs), lloc, gloc; //fprintf (stderr,"[%d] n2l map: ",rank); //for (n=1; n<=n2l.giveN2Lmap()->giveSize(); n++) fprintf (stderr, "%d ", n2l.giveN2Lmap()->at(n)); nelem = domain->giveNumberOfElements(); for ( n = 1; n <= nelem; n++ ) { //fprintf (stderr, "(elem %d) ", n); elem = domain->giveElement(n); elem->giveLocationArray(loc, ut, s); n2l->map2New(lloc, loc, 0); // translate natural->local numbering (remark, 1-based indexing) n2g->map2New(gloc, loc, 0); // translate natural->global numbering (remark, 0-based indexing) // See the petsc manual for details on how this allocation is constructed. for ( i = 1; i <= lloc.giveSize(); i++ ) { if ( ( ii = lloc.at(i) ) ) { for ( j = 1; j <= lloc.giveSize(); j++ ) { if ( ( jj = gloc.at(j) ) >= 0 ) { // if negative, then it is prescribed if ( lloc.at(j) ) { // if true, then its the local part (the diagonal block matrix) d_rows [ ii - 1 ].insert(jj); } else { // Otherwise it must be off-diagonal o_rows [ ii - 1 ].insert(jj); } } } } } //fprintf (stderr, "\n"); } // Diagonal must always be allocated; this code ensures that for every local line, it adds the global column number IntArray *n2gmap = n2g->giveN2Gmap(); IntArray *n2lmap = n2l->giveN2Lmap(); for ( int n = 1; n <= n2lmap->giveSize(); ++n ) { if ( n2lmap->at(n) ) { d_rows [ n2lmap->at(n)-1 ].insert( n2gmap->at(n) ); } } for ( i = 0; i < leqs; i++ ) { d_nnz(i) = d_rows [ i ].size(); o_nnz(i) = o_rows [ i ].size(); } //fprintf (stderr,"\n[%d]PetscSparseMtrx: Profile ...",rank); //for (i=0; i<leqs; i++) fprintf(stderr, "%d ", d_nnz(i)); //fprintf (stderr,"\n[%d]PetscSparseMtrx: Creating MPIAIJ Matrix ...\n",rank); // create PETSc mat MatCreate(PETSC_COMM_WORLD, & mtrx); MatSetSizes(mtrx, leqs, leqs, geqs, geqs); MatSetType(mtrx, MATMPIAIJ); MatSetFromOptions(mtrx); MatSetUp(mtrx); MatMPIAIJSetPreallocation(mtrx, 0, d_nnz.givePointer(), 0, o_nnz.givePointer()); //MatMPIBAIJSetPreallocation( mtrx, PETSC_DECIDE, 0, d_nnz.givePointer(), onz, onnz ); //MatMPISBAIJSetPreallocation( mtrx, PETSC_DECIDE, 0, d_nnz_sym.givePointer(), onz, onnz ); MatSetOption(mtrx, MAT_ROW_ORIENTED, PETSC_FALSE); // To allow the insertion of values using MatSetValues in column major order MatSetOption(mtrx, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE); #ifdef __VERBOSE_PARALLEL VERBOSEPARALLEL_PRINT("PetscSparseMtrx:: buildInternalStructure", "done", rank); #endif } else { #endif leqs = geqs = eModel->giveNumberOfEquations(ut); int i, ii, j, jj, n; Element *elem; // allocation map std :: vector< std :: set< int > >rows(leqs); std :: vector< std :: set< int > >rows_sym(leqs); nelem = domain->giveNumberOfElements(); for ( n = 1; n <= nelem; n++ ) { elem = domain->giveElement(n); elem->giveLocationArray(loc, ut, s); for ( i = 1; i <= loc.giveSize(); i++ ) { if ( ( ii = loc.at(i) ) ) { for ( j = 1; j <= loc.giveSize(); j++ ) { jj = loc.at(j); if ( jj ) { rows [ ii - 1 ].insert(jj - 1); if ( jj >= ii ) { rows_sym [ ii - 1 ].insert(jj - 1); } } } } } } // Structure from active boundary conditions. AList<IntArray> locs, temp; for ( n = 1; n <= domain->giveNumberOfBoundaryConditions(); n++ ) { ActiveBoundaryCondition *activebc = dynamic_cast<ActiveBoundaryCondition*>(domain->giveBc(n)); if (activebc) { ///@todo Deal with the CharType here. activebc->giveLocationArrays(locs, temp, ut, TangentStiffnessMatrix, s, s, domain); for (int k = 1; k < locs.giveSize(); k++) { IntArray *kloc = locs.at(k); for ( i = 1; i <= kloc->giveSize(); i++ ) { if ( ( ii = kloc->at(i) ) ) { for ( j = 1; j <= kloc->giveSize(); j++ ) { jj = kloc->at(j); if ( jj ) { rows [ ii - 1 ].insert(jj - 1); if ( jj >= ii ) { rows_sym [ ii - 1 ].insert(jj - 1); } } } } } } } } IntArray d_nnz(leqs); IntArray d_nnz_sym(leqs); for ( i = 0; i < leqs; i++ ) { d_nnz(i) = rows [ i ].size(); d_nnz_sym(i) = rows_sym [ i ].size(); } MatCreate(PETSC_COMM_SELF, & mtrx); MatSetSizes(mtrx, leqs, leqs, geqs, geqs); MatSetType(mtrx, MATSEQAIJ); //MatSetType(mtrx, MATSBAIJ); //MatSetType(mtrx, MATDENSE); MatSetFromOptions(mtrx); MatSetUp(mtrx); MatSeqAIJSetPreallocation( mtrx, 0, d_nnz.givePointer() ); MatSeqBAIJSetPreallocation( mtrx, PETSC_DECIDE, 0, d_nnz.givePointer() ); MatSeqSBAIJSetPreallocation( mtrx, PETSC_DECIDE, 0, d_nnz_sym.givePointer() ); MatSetOption(mtrx, MAT_ROW_ORIENTED, PETSC_FALSE); // To allow the insertion of values using MatSetValues in column major order MatSetOption(mtrx, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE); #ifdef __PARALLEL_MODE } #endif nRows = nColumns = geqs; this->newValues = true; return true; }
///@todo I haven't looked at the parallel code yet (lack of time right now, and i want to see it work first). / Mikael int PetscSparseMtrx :: buildInternalStructure(EngngModel *eModel, int di, EquationID ut, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s) { IntArray loc; Domain *domain = eModel->giveDomain(di); int nelem; if ( mtrx ) { MatDestroy(&mtrx); } if ( this->kspInit ) { KSPDestroy(&ksp); this->kspInit = false; // force ksp to be initialized } this->ut = ut; this->emodel = eModel; this->di = di; #ifdef __PARALLEL_MODE if ( eModel->isParallel() ) { OOFEM_ERROR("PetscSparseMtrx :: buildInternalStructure - Not implemented"); } #endif // This should be based on the numberingscheme. Also, geqs seems redundant. // This could simplify things. int npeqs = eModel->giveNumberOfPrescribedEquations(ut); int neqs = eModel->giveNumberOfEquations(ut); nRows = r_s.isDefault() ? neqs : npeqs; nColumns = c_s.isDefault() ? neqs : npeqs; int totalEquations = eModel->giveNumberOfEquations(ut) + eModel->giveNumberOfPrescribedEquations(ut); //determine nonzero structure of matrix int ii, jj; Element *elem; IntArray r_loc, c_loc; std :: vector< std :: set< int > >rows(totalEquations); std :: vector< std :: set< int > >rows_sym(totalEquations); // Only the symmetric part nelem = domain->giveNumberOfElements(); for ( int n = 1; n <= nelem; n++ ) { elem = domain->giveElement(n); elem->giveLocationArray(r_loc, ut, r_s); elem->giveLocationArray(c_loc, ut, c_s); for ( int i = 1; i <= r_loc.giveSize(); i++ ) { if ( ( ii = r_loc.at(i) ) ) { for ( int j = 1; j <= c_loc.giveSize(); j++ ) { jj = c_loc.at(j); if ( jj ) { rows [ ii - 1 ].insert(jj - 1); if ( jj >= ii ) { rows_sym [ ii - 1 ].insert(jj - 1); } } } } } } // Structure from active boundary conditions. AList<IntArray> r_locs, c_locs; for ( int n = 1; n <= domain->giveNumberOfBoundaryConditions(); n++ ) { ActiveBoundaryCondition *activebc = dynamic_cast<ActiveBoundaryCondition*>(domain->giveBc(n)); if (activebc) { ///@todo Deal with the CharType here. activebc->giveLocationArrays(r_locs, c_locs, ut, TangentStiffnessMatrix, r_s, c_s, domain); for (int k = 1; k < r_locs.giveSize(); k++) { IntArray *krloc = r_locs.at(k); IntArray *kcloc = c_locs.at(k); for ( int i = 1; i <= krloc->giveSize(); i++ ) { if ( ( ii = krloc->at(i) ) ) { for ( int j = 1; j <= kcloc->giveSize(); j++ ) { jj = kcloc->at(j); if ( jj ) { rows [ ii - 1 ].insert(jj - 1); if ( jj >= ii ) { rows_sym [ ii - 1 ].insert(jj - 1); } } } } } } } } geqs = leqs = nRows; IntArray d_nnz(leqs); IntArray d_nnz_sym(leqs); for ( int i = 0; i < leqs; i++ ) { d_nnz(i) = rows [ i ].size(); d_nnz_sym(i) = rows_sym [ i ].size(); } // create PETSc mat MatCreate(PETSC_COMM_SELF, & mtrx); MatSetSizes(mtrx, nRows, nColumns, nRows, nColumns); //MatSetType(mtrx, MATSEQAIJ); MatSetType(mtrx, MATSEQSBAIJ); MatSetFromOptions(mtrx); //The incompatible preallocations are ignored automatically. MatSetUp(mtrx); MatSeqAIJSetPreallocation( mtrx, 0, d_nnz.givePointer() ); MatSeqBAIJSetPreallocation( mtrx, PETSC_DECIDE, 0, d_nnz.givePointer() ); ///@todo Not sure about PETSC_DECIDE here. //MatSeqSBAIJSetPreallocation( mtrx, PETSC_DECIDE, 0, d_nnz_sym.givePointer() ); // Symmetry should practically never apply here. MatSetOption(mtrx, MAT_ROW_ORIENTED, PETSC_FALSE); // To allow the insertion of values using MatSetValues in column major order MatSetOption(mtrx, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE); this->newValues = true; return true; }
int DSSMatrix :: buildInternalStructure(EngngModel *eModel, int di, EquationID ut, const UnknownNumberingScheme &s) { IntArray loc; Domain *domain = eModel->giveDomain(di); int neq = eModel->giveNumberOfDomainEquations(di, s); int nelem = domain->giveNumberOfElements(); int i, ii, j, jj, n; unsigned long indx; Element *elem; // allocation map std :: vector< std :: set< int > >columns(neq); unsigned long nz_ = 0; for ( n = 1; n <= nelem; n++ ) { elem = domain->giveElement(n); elem->giveLocationArray(loc, ut, s); for ( i = 1; i <= loc.giveSize(); i++ ) { if ( ( ii = loc.at(i) ) ) { for ( j = 1; j <= loc.giveSize(); j++ ) { if ( ( jj = loc.at(j) ) ) { columns [ jj - 1 ].insert(ii - 1); } } } } } // loop over active boundary conditions int nbc = domain->giveNumberOfBoundaryConditions(); std::vector<IntArray> r_locs; std::vector<IntArray> c_locs; for ( i = 1; i <= nbc; ++i ) { ActiveBoundaryCondition *bc = dynamic_cast< ActiveBoundaryCondition * >( domain->giveBc(i) ); if ( bc != NULL ) { bc->giveLocationArrays(r_locs, c_locs, ut, UnknownCharType, s, s); for (std::size_t k = 0; k < r_locs.size(); k++) { IntArray &krloc = r_locs[k]; IntArray &kcloc = c_locs[k]; for ( int ri = 1; ri <= krloc.giveSize(); ri++ ) { if ( ( ii = krloc.at(ri) ) ) { for ( j = 1; j <= kcloc.giveSize(); j++ ) { if ( (jj = kcloc.at(j) ) ) { columns [ jj - 1 ].insert(ii - 1); } } } } } } } for ( i = 0; i < neq; i++ ) { nz_ += columns [ i ].size(); } unsigned long *rowind_ = new unsigned long [ nz_ ]; unsigned long *colptr_ = new unsigned long [ neq + 1 ]; if ( ( rowind_ == NULL ) || ( colptr_ == NULL ) ) { OOFEM_ERROR("DSSMatrix::buildInternalStructure: free store exhausted, exiting"); } indx = 0; std :: set< int > :: iterator pos; for ( j = 0; j < neq; j++ ) { // column loop colptr_ [ j ] = indx; for ( pos = columns [ j ].begin(); pos != columns [ j ].end(); ++pos ) { // row loop rowind_ [ indx++ ] = * pos; } } colptr_ [ neq ] = indx; if ( _sm ) { delete _sm; } if ( ( _sm = new SparseMatrixF(neq, NULL, rowind_, colptr_, 0, 0, true) ) == NULL ) { OOFEM_ERROR("DSSMatrix::buildInternalStructure: free store exhausted, exiting"); } int bsize = eModel->giveDomain(1)->giveDefaultNodeDofIDArry().giveSize(); /* * Assemble block to equation mapping information */ bool _succ = true; int _ndofs, _neq, ndofmans = domain->giveNumberOfDofManagers(); int ndofmansbc = 0; // count number of internal dofmans on active bc for (n=1; n<=nbc; n++) { ndofmansbc+=domain->giveBc(n)->giveNumberOfInternalDofManagers(); } long *mcn = new long [ (ndofmans+ndofmansbc) * bsize ]; long _c = 0; DofManager *dman; if ( mcn == NULL ) { OOFEM_ERROR("DSSMatrix::buildInternalStructure: free store exhausted, exiting"); } for ( n = 1; n <= ndofmans; n++ ) { dman = domain->giveDofManager(n); _ndofs = dman->giveNumberOfDofs(); if ( _ndofs > bsize ) { _succ = false; break; } for ( i = 1; i <= _ndofs; i++ ) { if ( dman->giveDof(i)->isPrimaryDof() ) { _neq = dman->giveDof(i)->giveEquationNumber(s); if ( _neq > 0 ) { mcn [ _c++ ] = _neq - 1; } else { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } } for ( i = _ndofs + 1; i <= bsize; i++ ) { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } // loop over internal dofmans of active bc for (int ibc=1; ibc<=nbc; ibc++) { int ndman = domain->giveBc(ibc)->giveNumberOfInternalDofManagers(); for (int idman = 1; idman <= ndman; idman ++) { dman = domain->giveBc(ibc)->giveInternalDofManager(idman); _ndofs = dman->giveNumberOfDofs(); if ( _ndofs > bsize ) { _succ = false; break; } for ( i = 1; i <= _ndofs; i++ ) { if ( dman->giveDof(i)->isPrimaryDof() ) { _neq = dman->giveDof(i)->giveEquationNumber(s); if ( _neq > 0 ) { mcn [ _c++ ] = _neq - 1; } else { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } } for ( i = _ndofs + 1; i <= bsize; i++ ) { mcn [ _c++ ] = -1; // no corresponding row in sparse mtrx structure } } } if ( _succ ) { _dss->SetMatrixPattern(_sm, bsize); _dss->LoadMCN(ndofmans+ndofmansbc, bsize, mcn); } else { OOFEM_LOG_INFO("DSSMatrix: using assumed block structure"); _dss->SetMatrixPattern(_sm, bsize); } _dss->PreFactorize(); // zero matrix, put unity on diagonal with supported dofs _dss->LoadZeros(); delete[] mcn; OOFEM_LOG_DEBUG("DSSMatrix info: neq is %d, bsize is %d\n", neq, nz_); // increment version this->version++; return true; }