public FetiDPSubdomainGlobalMapping(IStructuralModel model, FetiDPDofSeparator dofSeparator,
IStiffnessDistribution distribution)
{
this.model = model;
this.dofSeparator = dofSeparator;
this.distribution = distribution;
}
public override IFetiPreconditioner CreatePreconditioner(IStructuralModel model,
IStiffnessDistribution stiffnessDistribution, IDofSeparator dofSeparator,
ILagrangeMultipliersEnumerator lagrangeEnumerator, Dictionary <int, IFetiSubdomainMatrixManager> matrixManagers)
{
IReadOnlyList <ISubdomain> subdomains = model.Subdomains;
int[] subdomainIDs = dofSeparator.BoundaryDofIndices.Keys.ToArray();
Dictionary <int, IMappingMatrix> boundaryBooleans = CalcBoundaryPreconditioningBooleanMatrices(
stiffnessDistribution, dofSeparator, lagrangeEnumerator);
foreach (int s in subdomainIDs)
{
if (!subdomains[s].StiffnessModified)
{
continue;
}
Debug.WriteLine($"{typeof(DiagonalDirichletPreconditioner).Name}.{this.GetType().Name}:"
+ $" Extracting boundary/internal submatrices of subdomain {s} for preconditioning");
IFetiSubdomainMatrixManager matrixManager = matrixManagers[s];
int[] boundaryDofs = dofSeparator.BoundaryDofIndices[s];
int[] internalDofs = dofSeparator.InternalDofIndices[s];
matrixManager.ExtractKbb(boundaryDofs);
matrixManager.ExtractKbiKib(boundaryDofs, internalDofs);
matrixManager.ExtractAndInvertKiiDiagonal(internalDofs);
}
return(new DiagonalDirichletPreconditioner(subdomainIDs, matrixManagers, boundaryBooleans));
}
public abstract IFetiPreconditioner CreatePreconditioner(IModel model,
IStiffnessDistribution stiffnessDistribution, IDofSeparator dofSeparator,
ILagrangeMultipliersEnumerator lagrangeEnumerator, Dictionary <int, IFetiSubdomainMatrixManager> matrixManagers);
protected Dictionary <int, IMappingMatrix> CalcBoundaryPreconditioningBooleanMatrices(IStiffnessDistribution stiffnessDistribution,
IDofSeparator dofSeparator, ILagrangeMultipliersEnumerator lagrangeEnumerator)
{
int numContinuityEquations = lagrangeEnumerator.NumLagrangeMultipliers;
var matricesBb = new Dictionary <int, SignedBooleanMatrixColMajor>();
foreach (int s in dofSeparator.BoundaryDofIndices.Keys)
{
SignedBooleanMatrixColMajor B = lagrangeEnumerator.BooleanMatrices[s];
SignedBooleanMatrixColMajor Bb = B.GetColumns(dofSeparator.BoundaryDofIndices[s], false);
matricesBb[s] = Bb;
}
Dictionary <int, IMappingMatrix> matricesBpb = stiffnessDistribution.CalcBoundaryPreconditioningSignedBooleanMatrices(
lagrangeEnumerator, matricesBb);
return(matricesBpb);
}
private Feti1Solver(IStructuralModel model, IFeti1SubdomainMatrixManagerFactory matrixManagerFactory,
IDofOrderer dofOrderer, Dictionary <int, double> factorPivotTolerances,
IFetiPreconditionerFactory preconditionerFactory, IFeti1InterfaceProblemSolver interfaceProblemSolver,
bool problemIsHomogeneous, bool projectionMatrixQIsIdentity)
{
// Model
if (model.Subdomains.Count == 1)
{
throw new InvalidSolverException(
$"{name} cannot be used if there is only 1 subdomain");
}
this.model = model;
// Subdomains
subdomains = new Dictionary <int, ISubdomain>();
foreach (ISubdomain subdomain in model.Subdomains)
{
subdomains[subdomain.ID] = subdomain;
}
// Matrix managers and linear systems
matrixManagers = new Dictionary <int, IFeti1SubdomainMatrixManager>();
matrixManagersGeneral = new Dictionary <int, IFetiSubdomainMatrixManager>();
this.linearSystems = new Dictionary <int, ISingleSubdomainLinearSystem>();
var externalLinearSystems = new Dictionary <int, ILinearSystem>();
foreach (ISubdomain subdomain in model.Subdomains)
{
int s = subdomain.ID;
var matrixManager = matrixManagerFactory.CreateMatricesManager(subdomain);
matrixManagers[s] = matrixManager;
matrixManagersGeneral[s] = matrixManager;
this.linearSystems[s] = matrixManager.LinearSystem;
externalLinearSystems[s] = matrixManager.LinearSystem;
//TODO: This will call HandleMatrixWillBeSet() once for each subdomain. For now I will clear the data when
// BuildMatrices() is called. Redesign this.
//matrixManager.LinearSystem.MatrixObservers.Add(this);
}
LinearSystems = externalLinearSystems;
this.dofOrderer = dofOrderer;
this.dofSeparator = new Feti1DofSeparator();
this.factorPivotTolerances = factorPivotTolerances;
this.preconditionerFactory = preconditionerFactory;
// Interface problem
this.interfaceProblemSolver = interfaceProblemSolver;
// Homogeneous/heterogeneous problems
this.problemIsHomogeneous = problemIsHomogeneous;
this.projectionMatrixQIsIdentity = projectionMatrixQIsIdentity;
if (problemIsHomogeneous)
{
this.stiffnessDistribution = new HomogeneousStiffnessDistribution(model, dofSeparator);
}
else
{
this.stiffnessDistribution = new HeterogeneousStiffnessDistribution(model, dofSeparator);
}
}
