void SymCompCol :: times(const FloatArray &x, FloatArray &answer) const
{
int M = dim_ [ 0 ];
int N = dim_ [ 1 ];
// Check for compatible dimensions:
if ( x.giveSize() != N ) {
OOFEM_ERROR("SymCompCol::times: Error in CompCol -- incompatible dimensions");
}
answer.resize(M);
answer.zero();
int j, t;
double rhs, sum;
for ( j = 0; j < N; j++ ) {
rhs = x(j);
sum = 0.0;
for ( t = colptr_(j) + 1; t < colptr_(j + 1); t++ ) {
answer( rowind_(t) ) += val_(t) * rhs; // column loop
sum += val_(t) * x( rowind_(t) ); // row loop
}
answer(j) += sum;
answer(j) += val_( colptr_(j) ) * rhs; // diagonal
}
}
double &CompCol :: operator() (int i, int j)
{
// increment version
this->version++;
for ( int t = colptr_(j); t < colptr_(j + 1); t++ ) {
if ( rowind_(t) == i ) {
return val_(t);
}
}
OOFEM_ERROR("Array element (%d,%d) not in sparse structure -- cannot assign", i, j);
return val_(0); // return to suppress compiler warning message
}
double &CompCol :: at(int i, int j)
{
// increment version
this->version++;
for ( int t = colptr_(j - 1); t < colptr_(j); t++ ) {
if ( rowind_(t) == i - 1 ) {
return val_(t);
}
}
OOFEM_ERROR("Array accessing exception -- (%d,%d) out of bounds", i, j);
return val_(0); // return to suppress compiler warning message
}
double CompCol :: operator() (int i, int j) const
{
for ( int t = colptr_(j); t < colptr_(j + 1); t++ ) {
if ( rowind_(t) == i ) {
return val_(t);
}
}
if ( i < dim_ [ 0 ] && j < dim_ [ 1 ] ) {
return 0.0;
} else {
OOFEM_ERROR("Array accessing exception -- (%d,%d) out of bounds", i, j);
return ( 0 ); // return to suppress compiler warning message
}
}
double &SymCompCol :: at(int i, int j)
{
int ii = i, jj = j;
if ( ii < jj ) {
ii = j;
jj = i;
}
// increment version
this->version++;
for ( int t = colptr_(jj - 1); t < colptr_(jj); t++ ) {
if ( rowind_(t) == ( ii - 1 ) ) {
return val_(t);
}
}
OOFEM_ERROR("SymCompCol::operator(): Array accessing exception -- out of bounds");
return val_(0); // return to suppress compiler warning message
}
double SymCompCol :: operator() (int i, int j) const
{
int ii = i, jj = j;
if ( ii < jj ) {
ii = j;
jj = i;
}
for ( int t = colptr_(jj); t < colptr_(jj + 1); t++ ) {
if ( rowind_(t) == ii ) {
return val_(t);
}
}
if ( i < dim_ [ 0 ] && j < dim_ [ 1 ] ) {
return 0.0;
} else {
OOFEM_ERROR3("SymCompCol::operator(): Array accessing exception, index out of bounds (%d,%d)", i, j);
return ( 0 ); // return to suppress compiler warning message
}
}
void CompCol :: times(const FloatArray &x, FloatArray &answer) const
{
int M = dim_ [ 0 ];
int N = dim_ [ 1 ];
// Check for compatible dimensions:
if ( x.giveSize() != N ) {
OOFEM_ERROR("incompatible dimensions");
}
answer.resize(M);
answer.zero();
int j, t;
double rhs;
for ( j = 0; j < N; j++ ) {
rhs = x(j);
for ( t = colptr_(j); t < colptr_(j + 1); t++ ) {
answer( rowind_(t) ) += val_(t) * rhs;
}
}
}
void CompCol :: timesT(const FloatArray &x, FloatArray &answer) const
{
int M = dim_ [ 0 ];
int N = dim_ [ 1 ];
// Check for compatible dimensions:
if ( x.giveSize() != M ) {
OOFEM_ERROR("Error in CompCol -- incompatible dimensions");
}
answer.resize(N);
answer.zero();
int i, t;
double r;
for ( i = 0; i < N; i++ ) {
r = 0.0;
for ( t = colptr_(i); t < colptr_(i + 1); t++ ) {
r += val_(t) * x( rowind_(t) );
}
answer(i) = r;
}
}
int SymCompCol :: buildInternalStructure(EngngModel *eModel, int di, EquationID ut, 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
* int nmap = neq*neq-neq*(neq-1)/2;
* char* map = new char[nmap];
* if (map == NULL) {
* printf ("CompCol::buildInternalStructure - map creation failed");
* exit (1);
* }
*
* for (i=0; i<nmap; 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)) && (ii>=jj)) {
* if (MAP(ii-1,jj-1) == 0) {
* MAP(ii-1,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=j; i<neq; i++) { // row loop
* if (MAP(i,j)) {
* rowind_(indx) = i;
* indx++;
* }
* }
* }
* colptr_(neq) = indx;
*
* // delete map
* delete (map);
*
* // allocate value array
* val_.resize(nz_);
* val_.zero();
*
* printf ("\nSymCompCol 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, ut);
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, 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) ) && ( ii >= jj ) ) {
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;
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;
/*
* // 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_INFO("SymCompCol info: neq is %d, nwk is %d\n", neq, nz_);
dim_ [ 0 ] = dim_ [ 1 ] = nColumns = nRows = neq;
// 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;
}
