diff --git a/dune/faultnetworks/levelinterfacenetworkproblem.hh b/dune/faultnetworks/levelinterfacenetworkproblem.hh
index 2cc53f7088394423587b422edb34e987d65a234f..23b161912454e78c87162e19b213f535572e7ea6 100644
--- a/dune/faultnetworks/levelinterfacenetworkproblem.hh
+++ b/dune/faultnetworks/levelinterfacenetworkproblem.hh
@@ -30,6 +30,8 @@ class LevelInterfaceNetworkProblem
VectorType rhs_;
VectorType x_;
+ Dune::BitSetVector<1> boundaryDofs_;
+
bool requireAssemble_;
public:
@@ -55,12 +57,11 @@ class LevelInterfaceNetworkProblem
const GridView& gridView = levelInterfaceNetwork_.levelGridView();
// set boundary conditions
- Dune::BitSetVector<1> boundaryDofs;
BoundaryPatch<GridView> boundaryPatch(gridView, true);
- constructBoundaryDofs(boundaryPatch, *basis_, boundaryDofs);
+ constructBoundaryDofs(boundaryPatch, *basis_, boundaryDofs_);
- for(size_t i=0; i<boundaryDofs.size(); i++) {
- if(!boundaryDofs[i][0])
+ for(size_t i=0; i<boundaryDofs_.size(); i++) {
+ if(!boundaryDofs_[i][0])
continue;
RowType& row = matrix_[i];
@@ -132,6 +133,10 @@ class LevelInterfaceNetworkProblem
const LevelInterfaceNetwork<GridView>& levelInterfaceNetwork() const {
return levelInterfaceNetwork_;
}
+
+ const auto& boundaryNodes() const {
+ return boundaryDofs_;
+ }
};
#endif
diff --git a/dune/faultnetworks/preconditioners/cellpatchpreconditioner.hh b/dune/faultnetworks/preconditioners/cellpatchpreconditioner.hh
index c4c2b04fa72c2ee04a0c0e48140516f913575d7c..a14f005352084a4c1dd86aa6a47c6fa60e08b2c0 100644
--- a/dune/faultnetworks/preconditioners/cellpatchpreconditioner.hh
+++ b/dune/faultnetworks/preconditioners/cellpatchpreconditioner.hh
@@ -21,14 +21,14 @@ public:
const Mode mode = Mode::additive) :
Base(levelInterfaceNetwork, patchLevelBasis, localAssembler, localInterfaceAssemblers, mode) {}
- void build() {
+ void preprocess() {
const int patchLevel = this->patchLevelBasis_.faultNetwork().level();
CellPatchFactory<BasisType> patchFactory(this->patchLevelBasis_, this->basis_, patchLevel, this->level_);
const auto& localToGlobal = patchFactory.getLocalToGlobal();
const auto& boundaryDofs = patchFactory.getBoundaryDofs();
VectorType rhs;
- rhs.resize(this->matrix_.N());
+ rhs.resize(this->mat_->N());
rhs = 0;
std::cout << "CellPatchPreconditioner::build() level: " << this->level_ << std::endl;
@@ -38,7 +38,7 @@ public:
for (size_t i=0; i<cellCount; i++) {
using LocalProblemType = typename std::remove_reference<decltype(*(this->localProblems_[i]))>::type;
- this->localProblems_[i] = std::make_shared<LocalProblemType>(this->matrix_, rhs, localToGlobal[i], boundaryDofs[i]);
+ this->localProblems_[i] = std::make_shared<LocalProblemType>(*this->mat_, rhs, localToGlobal[i], boundaryDofs[i]);
}
}
};
diff --git a/dune/faultnetworks/preconditioners/levelglobalpreconditioner.hh b/dune/faultnetworks/preconditioners/levelglobalpreconditioner.hh
index 2b7b4e2bb80f6ad5ec302097654dbb5bc320deb4..af27254f0dfacbe4d9d86da136a43f9b1570fdfc 100644
--- a/dune/faultnetworks/preconditioners/levelglobalpreconditioner.hh
+++ b/dune/faultnetworks/preconditioners/levelglobalpreconditioner.hh
@@ -57,7 +57,7 @@ public:
assert(localInterfaceAssemblers_.size() == levelInterfaceNetwork_.size());
}
- void build() {
+ void setup() {
//printBasisDofLocation(basis_);
GlobalFaultAssembler<BasisType, BasisType> globalFaultAssembler(basis_, basis_, levelInterfaceNetwork_);
@@ -94,9 +94,10 @@ public:
virtual void setProblem(const MatrixType& mat, VectorType& x, const VectorType& rhs) {
+ //LinearIterationStep<MatrixType, VectorType>::setProblem(mat, x, rhs);
this->x_ = &x;
- updateRhs(rhs);
this->mat_ = Dune::stackobject_to_shared_ptr(mat); // mat will be set but not used
+ updateRhs(rhs);
}
virtual void iterate() {
@@ -105,21 +106,21 @@ public:
// compute solution directly
- if (requireBuild_)
- DUNE_THROW(Dune::Exception, "LevelGlobalPreconditioner::iterate() Call build() before solving the global problem!");
+ /* if (requireBuild_)
+ DUNE_THROW(Dune::Exception, "LevelGlobalPreconditioner::iterate() Call build() before solving the global problem!");*/
Dune::Timer timer;
timer.reset();
timer.start();
- this->x_->resize(matrix_.M());
+ this->x_->resize(this->mat_->M());
*(this->x_) = 0;
#if HAVE_UMFPACK
Dune::InverseOperatorResult res;
VectorType rhsCopy(rhs_);
- Dune::UMFPack<MatrixType> solver(matrix_);
+ Dune::UMFPack<MatrixType> solver(*this->mat_);
solver.apply(*(this->x_), rhsCopy, res);
#else
@@ -144,11 +145,11 @@ public:
private:
void updateRhs(const VectorType& rhs){
- rhs_.resize(matrix_.M());
+ rhs_.resize(this->mat_->M());
rhs_ = 0;
for (size_t i=0; i<rhs.size(); i++) {
- if (!boundaryDofs_[i][0])
+ if (!(*this->ignoreNodes_)[i][0])
rhs_[i] = rhs[i];
}
}
diff --git a/dune/faultnetworks/preconditioners/levelpatchpreconditioner.hh b/dune/faultnetworks/preconditioners/levelpatchpreconditioner.hh
index 1b672a5d8eca192dba959e2e56d03d018dca2219..9d1fc409ab4653639682344b8ac870afa9f2f9ca 100644
--- a/dune/faultnetworks/preconditioners/levelpatchpreconditioner.hh
+++ b/dune/faultnetworks/preconditioners/levelpatchpreconditioner.hh
@@ -66,11 +66,11 @@ public:
setPatchDepth();
setBoundaryMode();
setDirection();
- setup();
+ // setup();
}
// has to setup localProblems_
- virtual void build() = 0;
+ virtual void preprocess() = 0;
void setPatchDepth(const size_t patchDepth = 0) {
patchDepth_ = patchDepth;
@@ -182,13 +182,18 @@ private:
auto& localProblem = *localProblems_[i];
- VectorType localR;
- VectorType r = *(this->rhs_);
- Dune::MatrixVector::subtractProduct(r, matrix_, *(this->x_));
- localProblem.restrict(r, localR);
+ // compute residual
+ VectorType residual = *this->rhs_;
+ this->mat_->mmv(*this->x_, residual);
- localProblem.updateLocalRhs(localR);
+ // restrict residual
+ VectorType localResidual;
+ localProblem.restrict(residual, localResidual);
+ // solve local problem
+ localProblem.updateLocalRhs(localResidual);
+
+ // prolong
VectorType x, v;
localProblem.solve(x);
localProblem.prolong(x, v);
diff --git a/dune/faultnetworks/preconditioners/multilevelpatchpreconditioner.hh b/dune/faultnetworks/preconditioners/multilevelpatchpreconditioner.hh
index e4bf038e631ba11dc8f103e985b782ead0f786b6..8b7115c196c548110739557a458bb52e8505dd7e 100644
--- a/dune/faultnetworks/preconditioners/multilevelpatchpreconditioner.hh
+++ b/dune/faultnetworks/preconditioners/multilevelpatchpreconditioner.hh
@@ -10,6 +10,9 @@
#include <dune/solvers/iterationsteps/lineariterationstep.hh>
+#include <dune/matrix-vector/genericvectortools.hh>
+#include <dune/matrix-vector/resize.hh>
+
#include <dune/faultnetworks/preconditioners/levelglobalpreconditioner.hh>
#include <dune/faultnetworks/preconditioners/levelpatchpreconditioner.hh>
#include <dune/faultnetworks/preconditioners/cellpatchpreconditioner.hh>
@@ -45,19 +48,23 @@ private:
using MultDirection = typename LevelPatchPreconditionerType::Direction;
MultDirection multDirection_;
-
int itCounter_;
std::shared_ptr<LevelGlobalPreconditionerType> coarseGlobalPreconditioner_;
std::vector<std::shared_ptr<LevelPatchPreconditionerType>> levelPatchPreconditioners_;
- std::vector<VectorType> levelX_;
- std::vector<VectorType> levelRhs_;
std::shared_ptr<LevelInterfaceNetwork<GridView>> allFaultLevelInterfaceNetwork_;
std::shared_ptr<BasisType> allFaultBasis_;
+ // data hierarchy
+ std::vector<std::shared_ptr<const MatrixType> > matrixHierarchy_;
+ std::vector<std::shared_ptr<VectorType> > xHierarchy_;
+ std::vector<VectorType> rhsHierarchy_;
+ std::vector<BitVector*> ignoreNodesHierarchy_;
+
std::vector<std::shared_ptr<DGMGTransfer<BasisType>>> mgTransfer_;
+ bool preprocessCalled_;
public:
MultilevelPatchPreconditioner(const InterfaceNetwork<GridType>& interfaceNetwork,
const BitVector& activeLevels,
@@ -68,7 +75,8 @@ public:
activeLevels_(activeLevels),
localAssemblers_(localAssemblers),
localInterfaceAssemblers_(localInterfaceAssemblers),
- parset_(parset)
+ parset_(parset),
+ preprocessCalled_(false)
{
parseSettings();
@@ -92,54 +100,109 @@ public:
}
auto maxLevel = setupLevelPreconditioners();
-
- levelX_.resize(levelPatchPreconditioners_.size()+1);
- levelRhs_.resize(levelPatchPreconditioners_.size()+1);
-
allFaultBasis_ = std::make_shared<BasisType>(interfaceNetwork_.levelInterfaceNetwork(maxLevel));
- // init multigrid transfer
- for (size_t i=0; i<levelPatchPreconditioners_.size(); i++) {
- mgTransfer_.push_back(std::make_shared<DGMGTransfer<BasisType>>(levelPatchPreconditioners_[i]->basis(), *allFaultBasis_));
- }
- mgTransfer_.push_back(std::make_shared<DGMGTransfer<BasisType>>(coarseGlobalPreconditioner_->basis(), *allFaultBasis_));
-
itCounter_ = 0;
}
+ virtual ~MultilevelPatchPreconditioner()
+ {
+ for (int i=0; i<int(ignoreNodesHierarchy_.size()-1); i++)
+ {
+ if (ignoreNodesHierarchy_[i])
+ delete(ignoreNodesHierarchy_[i]);
+ }
+ }
virtual void setProblem(const MatrixType& mat, VectorType& x, const VectorType& rhs) {
- this->x_ = &x;
- this->rhs_ = &rhs;
- this->mat_ = Dune::stackobject_to_shared_ptr(mat);
-
- for (size_t i=0; i<levelPatchPreconditioners_.size(); i++) {
- mgTransfer_[i]->restrict(x, levelX_[i]);
- mgTransfer_[i]->restrict(rhs, levelRhs_[i]);
-
- levelPatchPreconditioners_[i]->setProblem(mat, levelX_[i], levelRhs_[i]);
- }
+ LinearIterationStep<MatrixType, VectorType>::setProblem(mat, x, rhs);
- size_t j = levelPatchPreconditioners_.size();
- mgTransfer_[j]->restrict(x, levelX_[j]);
- mgTransfer_[j]->restrict(rhs, levelRhs_[j]);
+ preprocessCalled_ = false;
+ }
- coarseGlobalPreconditioner_->setProblem(mat, levelX_[j], levelRhs_[j]);
+ void setRhs(const VectorType& rhs) {
+ this->rhs_ = &rhs;
+ rhsHierarchy_.back() = rhs;
}
virtual void iterate() {
+ *(this->x_) = 0;
+
if (mode_ == Mode::ADDITIVE)
iterateAdd();
else
iterateMult();
}
- void build() {
- coarseGlobalPreconditioner_->build();
+ virtual void preprocess() {
+ if (preprocessCalled_)
+ std::cout << "Warning: Preprocess has already been called without calling iterate afterwards!" << std::endl;
+
+ preprocessCalled_ = true;
+
+ const int numLevels = levelPatchPreconditioners_.size()+1;
+
+ // init transfer operators
+ mgTransfer_.resize(numLevels-1);
+ mgTransfer_[0] = std::make_shared<DGMGTransfer<BasisType>>(coarseGlobalPreconditioner_->basis(), levelPatchPreconditioners_[0]->basis());
+ for (size_t i=1; i<mgTransfer_.size(); i++) {
+ mgTransfer_[i] = std::make_shared<DGMGTransfer<BasisType>>(levelPatchPreconditioners_[i-1]->basis(), levelPatchPreconditioners_[i]->basis());
+ }
+
+ // resize hierarchy containers to number of levels
+ xHierarchy_.resize(numLevels);
+ rhsHierarchy_.resize(numLevels);
+ matrixHierarchy_.resize(numLevels);
+ ignoreNodesHierarchy_.resize(numLevels);
+
+ for (int i=0; i<numLevels-1; i++) {
+ matrixHierarchy_[i].reset();
+ xHierarchy_[i].reset();
+ }
+
+ matrixHierarchy_.back() = this->mat_;
+ xHierarchy_.back() = Dune::stackobject_to_shared_ptr(*(this->x_));
+ rhsHierarchy_.back() = *(this->rhs_);
+
+ // assemble hierarchy of matrices
+ for (int i=numLevels-2; i>=0; i--) {
+ matrixHierarchy_[i] = std::shared_ptr<MatrixType>(new MatrixType);
+ xHierarchy_[i] = std::shared_ptr<VectorType>(new VectorType);
+
+ mgTransfer_[i]->galerkinRestrictSetOccupation(*matrixHierarchy_[i+1], *std::const_pointer_cast<MatrixType>(matrixHierarchy_[i]));
+ mgTransfer_[i]->galerkinRestrict(*matrixHierarchy_[i+1], *std::const_pointer_cast<MatrixType>(matrixHierarchy_[i]));
+
+ // Set solution vector sizes for the lower levels
+ Dune::MatrixVector::resize(*xHierarchy_[i], *matrixHierarchy_[i]);
+ Dune::MatrixVector::resize(rhsHierarchy_[i], *matrixHierarchy_[i]);
+ }
+
+ // setup dirichlet bitfields
+ if (this->ignoreNodes_!=0)
+ {
+ ignoreNodesHierarchy_.back() = const_cast<BitVector*>(this->ignoreNodes_);
+ for (int i=numLevels-2; i>=0; --i)
+ {
+ ignoreNodesHierarchy_[i] = new BitVector();
+ mgTransfer_[i]->restrictToFathers(*ignoreNodesHierarchy_[i+1], *ignoreNodesHierarchy_[i]);
+ }
+ } else
+ DUNE_THROW(SolverError, "We need a set of nodes to ignore");
+
+ setDirichlet(*std::const_pointer_cast<MatrixType>(matrixHierarchy_[0]), *ignoreNodesHierarchy_[0]);
+ coarseGlobalPreconditioner_->setIgnore(*ignoreNodesHierarchy_[0]);
+ coarseGlobalPreconditioner_->setProblem(*matrixHierarchy_[0], *xHierarchy_[0], rhsHierarchy_[0]);
+ coarseGlobalPreconditioner_->preprocess();
for (size_t i=0; i<levelPatchPreconditioners_.size(); i++) {
- levelPatchPreconditioners_[i]->build();
+ setDirichlet(*std::const_pointer_cast<MatrixType>(matrixHierarchy_[i+1]), *ignoreNodesHierarchy_[i+1]);
+ levelPatchPreconditioners_[i]->setIgnore(*ignoreNodesHierarchy_[i+1]);
+ levelPatchPreconditioners_[i]->setProblem(*matrixHierarchy_[i+1], *xHierarchy_[i+1], rhsHierarchy_[i+1]);
+ levelPatchPreconditioners_[i]->preprocess();
}
+
+ //levelPatchPreconditioners_.back()->setProblem(*matrixHierarchy_.back(), *xHierarchy_.back(), rhsHierarchy_.back());
+ //levelPatchPreconditioners_.back()->preprocess();
}
std::shared_ptr<LevelPatchPreconditionerType> levelPatchPreconditioner(const int level) {
@@ -155,6 +218,20 @@ public:
}
private:
+ void setDirichlet(MatrixType& matrix, const BitVector& dirichletNodes) {
+ for(size_t i=0; i<dirichletNodes.size(); i++) {
+ if(!dirichletNodes[i][0])
+ continue;
+
+ auto& row = matrix[i];
+
+ for (auto& entry : row) {
+ entry = 0;
+ }
+ row[i] = 1;
+ }
+ }
+
void parseSettings() {
const auto mode = parset_.get<std::string>("mode");
if (mode == "ADDITIVE") {
@@ -178,7 +255,7 @@ private:
}
void iterateAdd() {
- VectorType x;
+ /*VectorType x;
for (size_t i=0; i<levelPatchPreconditioners_.size(); i++) {
levelPatchPreconditioners_[i]->iterate();
@@ -195,12 +272,33 @@ private:
const VectorType& it = coarseGlobalPreconditioner_->getSol();
mgTransfer_[levelPatchPreconditioners_.size()]->prolong(it, x);
- *(this->x_) += x;
+ *(this->x_) += x; */
+
+
+ for (int i=mgTransfer_.size()-1; i>=0; i--) {
+ *xHierarchy_[i] = 0;
+ mgTransfer_[i]->restrict(rhsHierarchy_[i+1], rhsHierarchy_[i]);
+ }
+
+ coarseGlobalPreconditioner_->setProblem(*matrixHierarchy_[0], *xHierarchy_[0], rhsHierarchy_[0]);
+ coarseGlobalPreconditioner_->iterate();
+
+ for (size_t i=0; i<levelPatchPreconditioners_.size(); i++) {
+ levelPatchPreconditioners_[i]->setProblem(*matrixHierarchy_[i+1], *xHierarchy_[i+1], rhsHierarchy_[i+1]);
+ levelPatchPreconditioners_[i]->iterate();
+
+ VectorType x(xHierarchy_[i+1]->size());
+ mgTransfer_[i]->prolong(*xHierarchy_[i], x);
+
+ *xHierarchy_[i+1] += x;
+ }
+
+ *(this->x_) = *xHierarchy_.back();
}
void iterateMult() {
-
+/*
if (multDirection_ != MultDirection::FORWARD)
for (size_t i=levelPatchPreconditioners_.size()-1; i>=0 && i<levelPatchPreconditioners_.size(); i--)
iterateStep(i, MultDirection::BACKWARD);
@@ -231,13 +329,13 @@ private:
iterateStep(i, MultDirection::FORWARD);
}
- itCounter_++;
+ itCounter_++;*/
}
void iterateStep(const size_t i, const MultDirection dir) {
//mgTransfer_[i]->restrict(*(this->x_), levelX_[i]);
- VectorType residual = *(this->rhs_);
+ /* VectorType residual = *(this->rhs_);
Dune::MatrixVector::subtractProduct(residual, *(this->mat_), *(this->x_));
VectorType localResidual;
@@ -254,7 +352,7 @@ private:
VectorType x;
mgTransfer_[i]->prolong(it, x);
- *(this->x_) += x;
+ *(this->x_) += x; */
//writeToVTK(*allFaultBasis_, x, "/storage/mi/podlesny/data/faultnetworks/fineIterates/multilevel", "exactvertexdata_step_"+std::to_string(itCounter_));
}
diff --git a/dune/faultnetworks/preconditioners/supportpatchpreconditioner.hh b/dune/faultnetworks/preconditioners/supportpatchpreconditioner.hh
index 68f544cabfcd176529da1164c9b1749f4a74389e..dc4064e81981890575975847ab157993829b3c0f 100644
--- a/dune/faultnetworks/preconditioners/supportpatchpreconditioner.hh
+++ b/dune/faultnetworks/preconditioners/supportpatchpreconditioner.hh
@@ -26,7 +26,7 @@ public:
Base(levelInterfaceNetwork, patchLevelBasis, localAssembler, localInterfaceAssemblers, mode)
{}
- void build() {
+ void preprocess() {
// init vertexInElements
const int dim = GridType::dimension;
using Element = typename GridType::template Codim<0>::Entity;
@@ -60,11 +60,11 @@ public:
const auto& boundaryDofs = patchFactory.getBoundaryDofs();
VectorType rhs;
- rhs.resize(this->matrix_.N());
+ rhs.resize(this->mat_->N());
rhs = 0;
using LocalProblemType = typename std::remove_reference<decltype(*(this->localProblems_[i]))>::type;
- this->localProblems_[i] = std::make_shared<LocalProblemType>(this->matrix_, rhs, localToGlobal, boundaryDofs);
+ this->localProblems_[i] = std::make_shared<LocalProblemType>(*this->mat_, rhs, localToGlobal, boundaryDofs);
}
}
};
diff --git a/src/cantorfaultnetworks/sparsecantorfaultnetwork.cc b/src/cantorfaultnetworks/sparsecantorfaultnetwork.cc
index 1849acf971fe97b4645faf214eef44998b340aa7..2f768eacf936043433aa69a2f6b76ab5b0ec5a42 100644
--- a/src/cantorfaultnetworks/sparsecantorfaultnetwork.cc
+++ b/src/cantorfaultnetworks/sparsecantorfaultnetwork.cc
@@ -272,6 +272,7 @@ int main(int argc, char** argv) { try
fineGlobalAssembler.assemble(fineLocalAssembler, fineLocalInterfaceAssemblers, l2FunctionalAssembler);
fineGlobalAssembler.solve();
+ const auto& fineBoundaryNodes = fineGlobalAssembler.boundaryNodes();
const VectorType& fineSol = fineGlobalAssembler.getSol();
const VectorType& fineRhs = fineGlobalAssembler.rhs();
std::shared_ptr<DGBasis> fineBasis = fineGlobalAssembler.basis();
@@ -304,6 +305,13 @@ int main(int argc, char** argv) { try
}
}
+ // set initial iterate
+ VectorType initialX;
+ DGMGTransfer<DGBasis> coarseFineTransfer(*coarseBasis, *fineBasis);
+ coarseFineTransfer.prolong(coarseSol, initialX);
+
+ VectorType rhs(fineRhs);
+
const auto& preconditionerParset = parameterSet.sub("preconditioner");
using MultilevelPatchPreconditioner = MultilevelPatchPreconditioner<DGBasis, LocalOscAssembler, LocalInterfaceAssembler, MatrixType, VectorType>;
@@ -314,18 +322,12 @@ int main(int argc, char** argv) { try
levelFaultPreconditioner.setPatchDepth(patchDepth);
levelFaultPreconditioner.setBoundaryMode(LevelPatchPreconditioner::BoundaryMode::homogeneous);
}*/
- preconditioner.build();
+ preconditioner.setIgnore(fineBoundaryNodes);
+ preconditioner.setProblem(fineGlobalAssembler.matrix(), initialX, rhs);
std::cout << "Setup complete, starting preconditioned cg iteration!" << std::endl;
std::cout << std::endl << std::endl;
- // set initial iterate
- VectorType initialX;
- DGMGTransfer<DGBasis> coarseFineTransfer(*coarseBasis, *fineBasis);
- coarseFineTransfer.prolong(coarseSol, initialX);
-
- VectorType rhs(fineRhs);
-
DGMGTransfer<DGBasis> discMGTransfer(*fineBasis, *exactBasis);
// solve
diff --git a/src/cantorfaultnetworks/sparsecantorfaultnetwork.parset b/src/cantorfaultnetworks/sparsecantorfaultnetwork.parset
index a5a180cfe892ec041aeb8fa0f176b5ecf3af0c5b..e8b5b26094f0e2cd91b3ae1d2adc76768ad0a8a3 100644
--- a/src/cantorfaultnetworks/sparsecantorfaultnetwork.parset
+++ b/src/cantorfaultnetworks/sparsecantorfaultnetwork.parset
@@ -39,18 +39,3 @@ nestedIteration = 0
tol = 1e-12
maxIterations = 8
-
-[problem2]
-oscDataFile = oscDataLaplace4.mat
-
-# level resolution in 2^(-...)
-coarseCantorLevel = 1
-fineCantorLevel = 4
-maxCantorLevel = 5
-
-penaltyFactor = 1
-
-# cg solver
-nestedIteration = 0
-tol = 1e-12
-maxIterations = 8
diff --git a/src/geofaultnetworks/rockfaultnetwork.parset b/src/geofaultnetworks/rockfaultnetwork.parset
index 283eb84f104b80f3808d9bcd3da76e838eb4cd9a..92d9c3884d2fc20a20d8089958612b0a7c9111a4 100644
--- a/src/geofaultnetworks/rockfaultnetwork.parset
+++ b/src/geofaultnetworks/rockfaultnetwork.parset
@@ -7,7 +7,7 @@ maxAngle = 2.0
[preconditioner]
patch = SUPPORT # CELL , SUPPORT
-mode = ADDITIVE # ADDITIVE , MULTIPLICATIVE
+mode = MULTIPLICATIVE # ADDITIVE , MULTIPLICATIVE
multDirection = SYMMETRIC # SYMMETRIC , FORWARD , BACKWARD
patchDepth = 1
@@ -17,75 +17,7 @@ patchDepth = 1
oscDataFile = oscDataLaplace4.mat
# level resolution in 2^(-...)
-coarseResolution = 4
-fineResolution = 9
-exactResolution = 10
-
-penaltyFactor = 1
-
-# cg solver
-nestedIteration = 0
-tol = 1e-12
-maxIterations = 8
-
-###########################################
-
-[problem1]
-oscDataFile = oscDataLaplace4.mat
-
-# level resolution in 2^(-...)
-coarseResolution = 4
-fineResolution = 8
-exactResolution = 9
-
-penaltyFactor = 1
-
-# cg solver
-nestedIteration = 0
-tol = 1e-12
-maxIterations = 8
-
-###########################################
-
-[problem2]
-oscDataFile = oscDataLaplace4.mat
-
-# level resolution in 2^(-...)
-coarseResolution = 4
-fineResolution = 7
-exactResolution = 8
-
-penaltyFactor = 1
-
-# cg solver
-nestedIteration = 0
-tol = 1e-12
-maxIterations = 8
-
-###########################################
-
-[problem3]
-oscDataFile = oscDataLaplace4.mat
-
-# level resolution in 2^(-...)
-coarseResolution = 4
-fineResolution = 6
-exactResolution = 7
-
-penaltyFactor = 1
-
-# cg solver
-nestedIteration = 0
-tol = 1e-12
-maxIterations = 8
-
-###########################################
-
-[problem4]
-oscDataFile = oscDataLaplace4.mat
-
-# level resolution in 2^(-...)
-coarseResolution = 4
+coarseResolution = 3
fineResolution = 5
exactResolution = 6
@@ -95,5 +27,3 @@ penaltyFactor = 1
nestedIteration = 0
tol = 1e-12
maxIterations = 8
-
-###########################################