Liebe Gitlab-Nutzer, lieber Gitlab-Nutzer, es ist nun möglich sich mittels des ZIH-Logins/LDAP an unserem Dienst anzumelden. Ein Anmelden über dieses erzeugt ein neues Konto. Das alte Konto ist über den Reiter "Standard" erreichbar. Die Administratoren

Dear Gitlab user, it is now possible to log in to our service using the ZIH login/LDAP. Logging in via this will create a new account. The old account can be accessed via the "Standard" tab. The administrators

Commit 99d00627 authored by Thomas Witkowski's avatar Thomas Witkowski
Browse files

* Added parameter for marker: max refinement level

parent c89c0012
......@@ -27,7 +27,7 @@ namespace AMDiS {
DOFMatrix::DOFMatrix(const FiniteElemSpace* rowFESpace_,
const FiniteElemSpace* colFESpace_,
::std::string name_)
std::string name_)
: rowFESpace(rowFESpace_),
colFESpace(colFESpace_),
name(name_),
......@@ -368,16 +368,16 @@ namespace AMDiS {
matrix[row].push_back(entry);
}
void DOFMatrix::addRow(::std::vector<MatEntry> row)
void DOFMatrix::addRow(std::vector<MatEntry> row)
{
matrix.push_back(row);
}
void DOFMatrix::compressDOFIndexed(int first, int last,
::std::vector<DegreeOfFreedom> &newDOF)
std::vector<DegreeOfFreedom> &newDOF)
{
int i, j, k, col;
::std::vector<MatEntry> *row;
std::vector<MatEntry> *row;
for(i = first; i <= last; i++) {
if((k = newDOF[i]) >= 0) {
......@@ -387,7 +387,7 @@ namespace AMDiS {
}
int usedSize = rowFESpace->getAdmin()->getUsedSize();
for(i=0; i < usedSize; i++) {
row = reinterpret_cast< ::std::vector<MatEntry>*>(&(matrix[i]));
row = reinterpret_cast< std::vector<MatEntry>*>(&(matrix[i]));
int rowSize = static_cast<int>(row->size());
for (j=0; j < rowSize; j++) {
col = (*row)[j].col;
......@@ -445,8 +445,8 @@ namespace AMDiS {
if (op) {
op->getElementMatrix(elInfo, elementMatrix);
} else {
::std::vector<Operator*>::iterator it;
::std::vector<double*>::iterator factorIt;
std::vector<Operator*>::iterator it;
std::vector<double*>::iterator factorIt;
for (it = operators.begin(), factorIt = operatorFactor.begin();
it != operators.end();
++it, ++factorIt) {
......@@ -462,7 +462,7 @@ namespace AMDiS {
Flag DOFMatrix::getAssembleFlag()
{
Flag fillFlag(0);
::std::vector<Operator*>::iterator op;
std::vector<Operator*>::iterator op;
for(op = operators.begin(); op != operators.end(); ++op) {
fillFlag |= (*op)->getFillFlag();
}
......@@ -519,8 +519,8 @@ namespace AMDiS {
!aIterator.end();
++aIterator, ++bIterator)
{
::std::vector<MatEntry>::const_iterator aRowIt;
::std::vector<MatEntry>::const_iterator bRowIt;
std::vector<MatEntry>::const_iterator aRowIt;
std::vector<MatEntry>::const_iterator bRowIt;
for(aRowIt = aIterator->begin(); aRowIt != aIterator->end(); ++aRowIt) {
int aCol = aRowIt->col;
if(aCol == UNUSED_ENTRY) continue;
......@@ -604,9 +604,9 @@ namespace AMDiS {
clear();
DOFMatrix::Iterator rhsIterator(const_cast<DOFMatrix*>(&rhs), USED_DOFS);
DOFMatrix::Iterator thisIterator(this, USED_DOFS);
::std::vector<MatEntry>::const_iterator colIt;
::std::vector<MatEntry>::const_iterator colBegin;
::std::vector<MatEntry>::const_iterator colEnd;
std::vector<MatEntry>::const_iterator colIt;
std::vector<MatEntry>::const_iterator colBegin;
std::vector<MatEntry>::const_iterator colEnd;
for(rhsIterator.reset(), thisIterator.reset();
!rhsIterator.end();
++rhsIterator, ++thisIterator)
......@@ -686,7 +686,7 @@ namespace AMDiS {
int DOFMatrix::memsize()
{
int sizeDOFMatrix = sizeof(DOFMatrix);
int sizeMatrix = sizeof(::std::vector<MatrixRow>);
int sizeMatrix = sizeof(std::vector<MatrixRow>);
for (int i = 0; i < static_cast<int>(matrix.size()); i++) {
sizeMatrix += sizeof(MatrixRow) + matrix[i].size() * sizeof(MatEntry);
}
......@@ -695,10 +695,10 @@ namespace AMDiS {
}
double norm(::std::vector<MatEntry> *row)
double norm(std::vector<MatEntry> *row)
{
double result = 0.0;
::std::vector<MatEntry>::iterator it;
std::vector<MatEntry>::iterator it;
for (it = row->begin(); it < row->end(); ++it) {
result += (*it).entry * (*it).entry;
}
......@@ -706,14 +706,14 @@ namespace AMDiS {
return(sqrt(result));
}
double min(::std::vector<MatEntry> *row)
double min(std::vector<MatEntry> *row)
{
double result = 0.0;
if (row->size() > 0) {
result = (*row)[0].entry;
}
::std::vector<MatEntry>::iterator it;
std::vector<MatEntry>::iterator it;
for (it = row->begin(); it < row->end(); ++it) {
if ((*it).entry < result) {
result = (*it).entry;
......@@ -723,14 +723,14 @@ namespace AMDiS {
return(result);
}
double max(::std::vector<MatEntry> *row)
double max(std::vector<MatEntry> *row)
{
double result = 0.0;
if (row->size() > 0) {
result = (*row)[0].entry;
}
::std::vector<MatEntry>::iterator it;
std::vector<MatEntry>::iterator it;
for (it = row->begin(); it < row->end(); ++it) {
if ((*it).entry > result) {
result = (*it).entry;
......
......@@ -81,7 +81,7 @@ namespace AMDiS {
* Is used to search for all entries of a matrix which column index is
* smaller than a given value.
*/
class MatEntryValueLess : public ::std::unary_function<MatEntry, bool> {
class MatEntryValueLess : public std::unary_function<MatEntry, bool> {
private:
const double value_;
public:
......@@ -99,7 +99,7 @@ namespace AMDiS {
* Is used to search for all entries of a matrix which value is smaller
* than a given value.
*/
class MatEntryColLess : public ::std::unary_function<MatEntry, bool> {
class MatEntryColLess : public std::unary_function<MatEntry, bool> {
private:
const int col_;
public:
......@@ -117,7 +117,7 @@ namespace AMDiS {
* This function is required if two MatEntries are compared by their col
* entry (for example when sorting a vector of MatEntries).
*/
struct CmpMatEntryCol : public ::std::binary_function<MatEntry, MatEntry, bool> {
struct CmpMatEntryCol : public std::binary_function<MatEntry, MatEntry, bool> {
bool operator()(const MatEntry& m1, const MatEntry m2) const {
return m1.col < m2.col;
};
......@@ -128,7 +128,7 @@ namespace AMDiS {
* This function compares two matrix entries by their values. It returns true,
* if the value of m2 is greater than the value of m1.
*/
struct CmpMatEntryValue : public ::std::binary_function<MatEntry, MatEntry, bool> {
struct CmpMatEntryValue : public std::binary_function<MatEntry, MatEntry, bool> {
bool operator()(const MatEntry& m1, const MatEntry m2) const {
return m1.entry < m2.entry;
};
......@@ -139,7 +139,7 @@ namespace AMDiS {
* This function compares two matrix entries by their values. It returns true,
* if the value of m2 is greater than the value of m1.
*/
struct CmpMatEntryAbsValueLess : public ::std::binary_function<MatEntry, MatEntry, bool> {
struct CmpMatEntryAbsValueLess : public std::binary_function<MatEntry, MatEntry, bool> {
bool operator()(const MatEntry& m1, const MatEntry m2) const {
return fabs(m1.entry) < fabs(m2.entry);
};
......@@ -149,7 +149,7 @@ namespace AMDiS {
* This function compares two matrix entries by their values. It returns true,
* if the value of m1 is greater than the value of m2.
*/
struct CmpMatEntryAbsValueGreater : public ::std::binary_function<MatEntry, MatEntry, bool> {
struct CmpMatEntryAbsValueGreater : public std::binary_function<MatEntry, MatEntry, bool> {
bool operator()(const MatEntry& m1, const MatEntry m2) const {
return fabs(m1.entry) > fabs(m2.entry);
};
......@@ -166,7 +166,7 @@ namespace AMDiS {
* objects. Each entry consists of a column DOF index and the corresponding
* double matrix entry. Unused entries are marked with a negative column index.
*/
class DOFMatrix : public DOFIndexed< ::std::vector<MatEntry> >,
class DOFMatrix : public DOFIndexed< std::vector<MatEntry> >,
public Serializable
{
public:
......@@ -174,14 +174,14 @@ namespace AMDiS {
/** \ingroup DOFAdministration
* \brief
* Alias for DOFIterator< ::std::vector<MatEntry<T> > >. So one can access an
* Alias for DOFIterator< std::vector<MatEntry<T> > >. So one can access an
* iterator working on a DOFMatrix via DOFMatrix::Iterator
*/
class Iterator : public DOFIterator< ::std::vector<MatEntry> > {
class Iterator : public DOFIterator< std::vector<MatEntry> > {
public:
Iterator(DOFIndexed< ::std::vector<MatEntry> > *c,
Iterator(DOFIndexed< std::vector<MatEntry> > *c,
DOFIteratorType type)
: DOFIterator< ::std::vector<MatEntry> >(c, type)
: DOFIterator< std::vector<MatEntry> >(c, type)
{};
};
......@@ -189,7 +189,7 @@ namespace AMDiS {
* A MatrixRow represents one row of the sparse matrix. It is realized by
* a STL vector of MatEntry<T> objects
*/
typedef ::std::vector<MatEntry> MatrixRow;
typedef std::vector<MatEntry> MatrixRow;
/** \brief
* Symbolic constant for an unused matrix entry
......@@ -211,7 +211,7 @@ namespace AMDiS {
*/
DOFMatrix(const FiniteElemSpace* rowFESpace,
const FiniteElemSpace* colFESpace,
::std::string n="");
std::string n="");
/** \brief
* Copy-Constructor
......@@ -234,14 +234,14 @@ namespace AMDiS {
/** \brief
* Returns an iterator to the begin of matrix rows (\ref matrix.begin())
*/
::std::vector< ::std::vector<MatEntry> >::iterator begin() {
std::vector< std::vector<MatEntry> >::iterator begin() {
return matrix.begin();
};
/** \brief
* Returns an iterator to the end of matrix rows (\ref matrix.end())
*/
::std::vector< ::std::vector<MatEntry> >::iterator end() {
std::vector< std::vector<MatEntry> >::iterator end() {
return matrix.end();
};
......@@ -249,7 +249,7 @@ namespace AMDiS {
* Used by DOFAdmin to compress the DOFMatrix
*/
virtual void compressDOFIndexed(int first, int last,
::std::vector<DegreeOfFreedom> &newDOF);
std::vector<DegreeOfFreedom> &newDOF);
/** \brief
* Implements DOFIndexedBase::freeDOFContent()
......@@ -307,27 +307,27 @@ namespace AMDiS {
operatorEstFactor.push_back(estFactor);
};
inline ::std::vector<double*>::iterator getOperatorFactorBegin() {
inline std::vector<double*>::iterator getOperatorFactorBegin() {
return operatorFactor.begin();
};
inline ::std::vector<double*>::iterator getOperatorFactorEnd() {
inline std::vector<double*>::iterator getOperatorFactorEnd() {
return operatorFactor.end();
};
inline ::std::vector<double*>::iterator getOperatorEstFactorBegin() {
inline std::vector<double*>::iterator getOperatorEstFactorBegin() {
return operatorEstFactor.begin();
};
inline ::std::vector<double*>::iterator getOperatorEstFactorEnd() {
inline std::vector<double*>::iterator getOperatorEstFactorEnd() {
return operatorEstFactor.end();
};
inline ::std::vector<Operator*>::iterator getOperatorsBegin() {
inline std::vector<Operator*>::iterator getOperatorsBegin() {
return operators.begin();
};
inline ::std::vector<Operator*>::iterator getOperatorsEnd() {
inline std::vector<Operator*>::iterator getOperatorsEnd() {
return operators.end();
};
......@@ -371,25 +371,25 @@ namespace AMDiS {
/** \brief
* Returns \ref matrix
*/
::std::vector< ::std::vector<MatEntry> >& getMatrix() {
std::vector< std::vector<MatEntry> >& getMatrix() {
return matrix;
};
void setMatrix(::std::vector< ::std::vector<MatEntry> > m) {
void setMatrix(std::vector< std::vector<MatEntry> > m) {
matrix = m;
};
/** \brief
* Returns \ref matrix[n]
*/
const ::std::vector<MatEntry>& getRow(int n) const {
const std::vector<MatEntry>& getRow(int n) const {
return matrix[n];
};
/** \brief
* Returns \ref matrix[n]
*/
::std::vector<MatEntry>& getRow(int n) {
std::vector<MatEntry>& getRow(int n) {
return matrix[n];
};
......@@ -437,10 +437,29 @@ namespace AMDiS {
return matrix.size();
};
/** \brief
* Returns number of cols. For that, the function iteratos over all
* rows and searchs for the entry with the highest col number.
*/
int getNumCols() const {
int max = 0;
int rowSize = static_cast<int>(matrix.size());
for (int i = 0; i < rowSize; i++) {
int colSize = static_cast<int>(matrix[i].size());
for (int j = 0; j < colSize; j++) {
if (matrix[i][j].col > max) {
max = matrix[i][j].col;
}
}
}
return max;
};
/** \brief
* Returns \ref name
*/
inline const ::std::string& getName() const {
inline const std::string& getName() const {
return name;
};
......@@ -455,7 +474,7 @@ namespace AMDiS {
/** \brief
* Returns \ref matrix[i] which is the i-th row
*/
inline const ::std::vector<MatEntry>& operator[](int i) const {
inline const std::vector<MatEntry>& operator[](int i) const {
TEST_EXIT_DBG((i >= 0) && (i < (static_cast<int>(matrix.size()))))
("Illegal matrix index %d.\n",i);
return matrix[i];
......@@ -464,7 +483,7 @@ namespace AMDiS {
/** \brief
* Returns \ref matrix[i] which is the i-th row
*/
inline ::std::vector<MatEntry>& operator[](int i) {
inline std::vector<MatEntry>& operator[](int i) {
TEST_EXIT_DBG((i >= 0) && (i < (static_cast<int>(matrix.size()))))
("Illegal vector index %d.\n", i);
return matrix[i];
......@@ -528,8 +547,8 @@ namespace AMDiS {
bool add = true);
inline double *hasSparseDOFEntry(int irow, int jcol) {
::std::vector<MatEntry>::iterator it;
::std::vector<MatEntry>::iterator end = matrix[irow].end();
std::vector<MatEntry>::iterator it;
std::vector<MatEntry>::iterator end = matrix[irow].end();
for (it = matrix[irow].begin(); it != end; ++it) {
if (it->col == NO_MORE_ENTRIES)
return NULL;
......@@ -543,7 +562,7 @@ namespace AMDiS {
void addMatEntry(int row, int DegreeOfFreedom, double value);
void addRow(::std::vector<MatEntry> row);
void addRow(std::vector<MatEntry> row);
/** \brief
* Prints \ref matrix to stdout
......@@ -567,15 +586,15 @@ namespace AMDiS {
bool symmetric();
inline ::std::vector<Operator*> getOperators() {
inline std::vector<Operator*> getOperators() {
return operators;
};
inline ::std::vector<double*> getOperatorFactor() {
inline std::vector<double*> getOperatorFactor() {
return operatorFactor;
};
inline ::std::vector<double*> getOperatorEstFactor() {
inline std::vector<double*> getOperatorEstFactor() {
return operatorEstFactor;
};
......@@ -591,7 +610,7 @@ namespace AMDiS {
// ===== Serializable implementation =====
void serialize(::std::ostream &out)
void serialize(std::ostream &out)
{
unsigned int matrixSize = matrix.size();
unsigned int vecSize = 0;
......@@ -604,7 +623,7 @@ namespace AMDiS {
}
};
void deserialize(::std::istream &in) {
void deserialize(std::istream &in) {
unsigned int matrixSize, vecSize;
in.read(reinterpret_cast<char*>(&matrixSize), sizeof(unsigned int));
......@@ -640,12 +659,12 @@ namespace AMDiS {
/** \brief
* Name of the DOFMatrix
*/
::std::string name;
std::string name;
/** \brief
* Sparse matrix stored in an STL vector of MatrixRow objects
*/
::std::vector<MatrixRow> matrix;
std::vector<MatrixRow> matrix;
/** \brief
* Used while mesh traversal
......@@ -656,18 +675,18 @@ namespace AMDiS {
* Pointers to all operators of the equation systems. Are used in the
* assembling process.
*/
::std::vector<Operator*> operators;
std::vector<Operator*> operators;
/** \brief
* Defines for each operator a factor which is used to scal the element
* matrix after the assembling process of the operator.
*/
::std::vector<double*> operatorFactor;
std::vector<double*> operatorFactor;
/** \brief
*
*/
::std::vector<double*> operatorEstFactor;
std::vector<double*> operatorEstFactor;
/** \brief
*
......@@ -697,11 +716,11 @@ namespace AMDiS {
return m->logToPhysIndex(a, b);
}
double norm(::std::vector<MatEntry> *row);
double norm(std::vector<MatEntry> *row);
double min(::std::vector<MatEntry> *row);
double min(std::vector<MatEntry> *row);
double max(::std::vector<MatEntry> *row);
double max(std::vector<MatEntry> *row);
}
......
......@@ -72,7 +72,11 @@ namespace AMDiS {
ElInfo *elInfo = NULL;
elInfo = stack.traverseFirst(mesh, -1, Mesh::CALL_LEAF_EL);
while (elInfo) {
markElement(adaptInfo, elInfo);
if ((maxRefineLevel > -1) &&
(static_cast<int>(elInfo->getLevel()) < maxRefineLevel)) {
markElement(adaptInfo, elInfo);
}
elInfo = stack.traverseNext(elInfo);
}
......
......@@ -59,10 +59,12 @@ namespace AMDiS {
row(row_),
maximumMarking(false),
p(2),
info(10)
info(10),
maxRefineLevel(-1)
{
GET_PARAMETER(0, name + "->p", "%f", &p);
GET_PARAMETER(0, name + "->info", "%d", &info);
GET_PARAMETER(0, name + "->max refinement level", "%d", &maxRefineLevel);
};
/** \brief
......@@ -196,6 +198,10 @@ namespace AMDiS {
*/
int elMarkCoarsen;
/** \brief
* Maximal depth for element refinement.
*/
int maxRefineLevel;
};
// ===========================================================================
......
......@@ -111,7 +111,7 @@ namespace AMDiS {
createMarker();
}
if (adoptProblem && adoptFlag.isSet(INIT_MARKER)) {
marker_ = adoptProblem->getMarker();
marker = adoptProblem->getMarker();
}
......@@ -436,11 +436,11 @@ namespace AMDiS {
for (int i = 0; i < nComponents; i++) {
sprintf(number, "[%d]", i);
numberedName = name_ + "->marker" + std::string(number);
marker_[i] = Marker::createMarker(numberedName, i);
if (marker_[i]) {
marker[i] = Marker::createMarker(numberedName, i);
if (marker[i]) {
numMarkersCreated++;
if (numMarkersCreated > 1)
marker_[i]->setMaximumMarking(true);
marker[i]->setMaximumMarking(true);
}
}
}
......@@ -584,13 +584,13 @@ namespace AMDiS {
Flag markFlag = 0;
for (int i = 0; i < nComponents; i++) {
if (marker_[i]) {
markFlag |= marker_[i]->markMesh(adaptInfo, componentMeshes_[i]);
if (marker[i]) {
markFlag |= marker[i]->markMesh(adaptInfo, componentMeshes_[i]);
} else {
WARNING("no marker for component %d\n", i);
}
}
return markFlag;
}
......@@ -598,9 +598,9 @@ namespace AMDiS {
{
FUNCNAME("ProblemVec::refineMesh()");
int numMeshes = static_cast<int>(meshes_.size());
int nMeshes = static_cast<int>(meshes_.size());
Flag refineFlag = 0;
for (int i = 0; i < numMeshes; i++) {
for (int i = 0; i < nMeshes; i++) {
refineFlag |= refinementManager_->refineMesh(meshes_[i]);
}
return refineFlag;
......@@ -610,10 +610,10 @@ namespace AMDiS {
{
FUNCNAME("ProblemVec::coarsenMesh()");
int i, numMeshes = static_cast<int>(meshes_.size());
int nMeshes = static_cast<int>(meshes_.size());
Flag coarsenFlag = 0;
for(i = 0; i < numMeshes; i++) {
if(adaptInfo->isCoarseningAllowed(i)) {
for (int i = 0; i < nMeshes; i++) {
if (adaptInfo->isCoarseningAllowed(i)) {
coarsenFlag |= coarseningManager_->coarsenMesh(meshes_[i]);
WARNING("coarsening for component %d no allowed\n", i);
......@@ -724,48 +724,43 @@ namespace AMDiS {
if (assembleMatrix && matrix->getBoundaryManager())
matrix->getBoundaryManager()->initMatrix(matrix);
BoundaryType *bound = NULL;
if (useGetBound_) {
bound = GET_MEMORY(BoundaryType, basisFcts->getNumber());
}
if (componentMeshes_[i] != componentMeshes_[j]) {
ERROR_EXIT("not yet\n");
} else {
BoundaryType *bound = NULL;
TraverseStack stack;
ElInfo *elInfo = stack.traverseFirst(componentMeshes_[i], -1, assembleFlag);
while (elInfo) {
if (useGetBound_) {
bound = GET_MEMORY(BoundaryType, basisFcts->getNumber());
basisFcts->getBound(elInfo, bound);
}
TraverseStack stack;
ElInfo *elInfo = stack.traverseFirst(componentMeshes_[i], -1, assembleFlag);
while (elInfo) {
if (useGetBound_) {
basisFcts->getBound(elInfo, bound);
}
if (assembleMatrix) {
matrix->assemble(1.0, elInfo, bound);
if (matrix->getBoundaryManager()) {
matrix->
getBoundaryManager()->
fillBoundaryConditions(elInfo, matrix);
}
}
if (i == j) {
rhs_->getDOFVector(i)->assemble(1.0, elInfo, bound);
}
if (assembleMatrix) {