private IMatrix2D <double> PorousMatrix(Element element)
{
IPorousFiniteElement elementType = (IPorousFiniteElement)element.ElementType;
int dofs = 0;
foreach (IList <DOFType> dofTypes in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofType in dofTypes)
{
dofs++;
}
}
SymmetricMatrix2D <double> poreMass = new SymmetricMatrix2D <double>(dofs);
IMatrix2D <double> mass = solidMassProvider.Matrix(element);
int matrixRow = 0;
int solidRow = 0;
foreach (IList <DOFType> dofTypesRow in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofTypeRow in dofTypesRow)
{
int matrixCol = 0;
int solidCol = 0;
foreach (IList <DOFType> dofTypesCol in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofTypeCol in dofTypesCol)
{
if (dofTypeCol == DOFType.Pore)
{
}
else
{
if (dofTypeRow != DOFType.Pore)
{
poreMass[matrixRow, matrixCol] = mass[solidRow, solidCol] * massCoefficient;
}
solidCol++;
}
matrixCol++;
}
}
if (dofTypeRow != DOFType.Pore)
{
solidRow++;
}
matrixRow++;
}
}
return(poreMass);
}
private IMatrix PorousMatrix(IElement element)
{
IPorousFiniteElement elementType = (IPorousFiniteElement)element.ElementType;
int dofs = 0;
foreach (IList <IDofType> dofTypes in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofType in dofTypes)
{
dofs++;
}
}
var poreMass = SymmetricMatrix.CreateZero(dofs);
IMatrix mass = solidMassProvider.Matrix(element);
int matrixRow = 0;
int solidRow = 0;
foreach (IList <IDofType> dofTypesRow in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofTypeRow in dofTypesRow)
{
int matrixCol = 0;
int solidCol = 0;
foreach (IList <IDofType> dofTypesCol in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofTypeCol in dofTypesCol)
{
if (dofTypeCol == PorousMediaDof.Pressure)
{
}
else
{
if (dofTypeRow != PorousMediaDof.Pressure)
{
poreMass[matrixRow, matrixCol] = mass[solidRow, solidCol] * massCoefficient;
}
solidCol++;
}
matrixCol++;
}
}
if (dofTypeRow != PorousMediaDof.Pressure)
{
solidRow++;
}
matrixRow++;
}
}
return(poreMass);
}
public CsrMatrix BuildGlobalMatrix(ISubdomainFreeDofOrdering dofOrdering, IEnumerable <IElement> elements,
IElementMatrixProvider matrixProvider)
{
int numFreeDofs = dofOrdering.NumFreeDofs;
var subdomainMatrix = DokRowMajor.CreateEmpty(numFreeDofs, numFreeDofs);
foreach (IElement element in elements)
{
(int[] elementDofIndices, int[] subdomainDofIndices) = dofOrdering.MapFreeDofsElementToSubdomain(element);
IMatrix elementMatrix = matrixProvider.Matrix(element);
subdomainMatrix.AddSubmatrixSymmetric(elementMatrix, elementDofIndices, subdomainDofIndices);
}
(double[] values, int[] colIndices, int[] rowOffsets) = subdomainMatrix.BuildCsrArrays(sortColsOfEachRow);
if (!isIndexerCached)
{
cachedColIndices = colIndices;
cachedRowOffsets = rowOffsets;
isIndexerCached = true;
}
else
{
Debug.Assert(Utilities.AreEqual(cachedColIndices, colIndices));
Debug.Assert(Utilities.AreEqual(cachedRowOffsets, rowOffsets));
}
return(CsrMatrix.CreateFromArrays(numFreeDofs, numFreeDofs, values, cachedColIndices, cachedRowOffsets, false));
}
public SymmetricCscMatrix BuildGlobalMatrix(ISubdomainFreeDofOrdering dofOrdering, IEnumerable <IElement> elements,
IElementMatrixProvider matrixProvider)
{
int numFreeDofs = dofOrdering.NumFreeDofs;
var subdomainMatrix = DokSymmetric.CreateEmpty(numFreeDofs);
foreach (IElement element in elements)
{
// TODO: perhaps that could be done and cached during the dof enumeration to avoid iterating over the dofs twice
(int[] elementDofIndices, int[] subdomainDofIndices) = dofOrdering.MapFreeDofsElementToSubdomain(element);
IMatrix elementMatrix = matrixProvider.Matrix(element);
subdomainMatrix.AddSubmatrixSymmetric(elementMatrix, elementDofIndices, subdomainDofIndices);
}
(double[] values, int[] rowIndices, int[] colOffsets) = subdomainMatrix.BuildSymmetricCscArrays(sortColsOfEachRow);
if (!isIndexerCached)
{
cachedRowIndices = rowIndices;
cachedColOffsets = colOffsets;
isIndexerCached = true;
}
else
{
Debug.Assert(Utilities.AreEqual(cachedRowIndices, rowIndices));
Debug.Assert(Utilities.AreEqual(cachedColOffsets, colOffsets));
}
return(SymmetricCscMatrix.CreateFromArrays(numFreeDofs, values, cachedRowIndices, cachedColOffsets, false));
}
IMatrixView matrixConstrConstr) BuildGlobalSubmatrices(
ISubdomainFreeDofOrdering freeDofOrdering, ISubdomainConstrainedDofOrdering constrainedDofOrdering,
IEnumerable <IElement> elements, IElementMatrixProvider matrixProvider)
{
int numFreeDofs = freeDofOrdering.NumFreeDofs;
var subdomainMatrix = Matrix.CreateZero(numFreeDofs, numFreeDofs);
//TODO: also reuse the indexers of the constrained matrices.
constrainedAssembler.InitializeNewMatrices(freeDofOrdering.NumFreeDofs, constrainedDofOrdering.NumConstrainedDofs);
// Process the stiffness of each element
foreach (IElement element in elements)
{
(int[] elementDofsFree, int[] subdomainDofsFree) = freeDofOrdering.MapFreeDofsElementToSubdomain(element);
//IReadOnlyDictionary<int, int> elementToGlobalDofs = dofOrdering.MapFreeDofsElementToSubdomain(element);
(int[] elementDofsConstrained, int[] subdomainDofsConstrained) =
constrainedDofOrdering.MapConstrainedDofsElementToSubdomain(element);
IMatrix elementMatrix = matrixProvider.Matrix(element);
AddElementToGlobalMatrix(subdomainMatrix, elementMatrix, elementDofsFree, subdomainDofsFree);
constrainedAssembler.AddElementMatrix(elementMatrix, elementDofsFree, subdomainDofsFree,
elementDofsConstrained, subdomainDofsConstrained);
}
(CsrMatrix matrixConstrFree, CsrMatrix matrixConstrConstr) = constrainedAssembler.BuildMatrices();
return(subdomainMatrix, matrixConstrFree.TransposeToCSC(false), matrixConstrFree, matrixConstrConstr);
}
public SkylineMatrix BuildGlobalMatrix(ISubdomainFreeDofOrdering dofOrdering, IEnumerable <IElement> elements,
IElementMatrixProvider matrixProvider)
{
if (!areIndexersCached)
{
skylineBuilder = SkylineBuilder.Create(dofOrdering.NumFreeDofs,
FindSkylineColumnHeights(elements, dofOrdering.NumFreeDofs, dofOrdering.FreeDofs));
areIndexersCached = true;
}
else
{
skylineBuilder.ClearValues();
}
foreach (IElement element in elements)
{
//if (element.ID != 2) continue;
// TODO: perhaps that could be done and cached during the dof enumeration to avoid iterating over the dofs twice
(int[] elementDofIndices, int[] subdomainDofIndices) = dofOrdering.MapFreeDofsElementToSubdomain(element);
IMatrix elementMatrix = matrixProvider.Matrix(element);
skylineBuilder.AddSubmatrixSymmetric(elementMatrix, elementDofIndices, subdomainDofIndices);
}
//// Print matrix
//var writer = new LinearAlgebra.Output.FullMatrixWriter();
////writer.NumericFormat = new FixedPointFormat() { NumDecimalDigits = 2 };
//writer.ArrayFormat = new LinearAlgebra.Output.Formatting.Array2DFormat("", "", "", "\n", ",");
//writer.WriteToFile(skylineBuilder.BuildSkylineMatrix()/*.DoToAllEntries(x => Math.Round(x * 1E-6, 3))*/, @"C:\Users\Serafeim\Desktop\xfem.txt");
return(skylineBuilder.BuildSkylineMatrix());
}
public IVector GetEquivalentNodalLoads(ISubdomain subdomain, IVectorView solution, double constraintScalingFactor)
{
//var times = new Dictionary<string, TimeSpan>();
//var totalStart = DateTime.Now;
//times.Add("rowIndexCalculation", DateTime.Now - totalStart);
//times.Add("element", TimeSpan.Zero);
//times.Add("addition", TimeSpan.Zero);
var subdomainEquivalentForces = Vector.CreateZero(subdomain.FreeDofOrdering.NumFreeDofs);
foreach (IElement element in subdomain.Elements) //TODO: why go through all the elements? Most of them will not have Dirichlet bc.
{
//var elStart = DateTime.Now;
IMatrix elementK = elementProvider.Matrix(element);
//double[] localSolution = subdomain.CalculateElementNodalDisplacements(element, solution);
//double[] localdSolution = subdomain.CalculateElementIcrementalConstraintDisplacements(element, constraintScalingFactor);
double[] localdSolution =
subdomain.CalculateElementIncrementalConstraintDisplacements(element, constraintScalingFactor);
var elementEquivalentForces = elementK.Multiply(localdSolution);
subdomain.FreeDofOrdering.AddVectorElementToSubdomain(element, elementEquivalentForces, subdomainEquivalentForces);
//times["addition"] += DateTime.Now - elStart;
}
//var totalTime = DateTime.Now - totalStart;
return(subdomainEquivalentForces);
}
//private static int[] CalculateRowIndex(Subdomain subdomain)
//{
// return CalculateRowIndex(subdomain, subdomain.NodalDOFsDictionary);
//}
public static SkylineMatrix2D <double> CalculateGlobalMatrix(Subdomain subdomain, Dictionary <int, Dictionary <DOFType, int> > nodalDOFsDictionary, IElementMatrixProvider elementProvider)
{
// TODO: should encapsulate DOF logic into a separate entity that will manage things if embedded or not (should return element matrix and globaldofs correspondence list
var times = new Dictionary <string, TimeSpan>();
var totalStart = DateTime.Now;
SkylineMatrix2D <double> K = new SkylineMatrix2D <double>(GlobalMatrixAssemblerSkyline.CalculateRowIndex(subdomain, nodalDOFsDictionary));
times.Add("rowIndexCalculation", DateTime.Now - totalStart);
times.Add("element", TimeSpan.Zero);
times.Add("addition", TimeSpan.Zero);
foreach (Element element in subdomain.ElementsDictionary.Values)
{
var isEmbeddedElement = element.ElementType is IEmbeddedElement;
var elStart = DateTime.Now;
IMatrix2D <double> ElementK = elementProvider.Matrix(element);
times["element"] += DateTime.Now - elStart;
elStart = DateTime.Now;
var elementDOFTypes = element.ElementType.DOFEnumerator.GetDOFTypes(element);
var matrixAssemblyNodes = element.ElementType.DOFEnumerator.GetNodesForMatrixAssembly(element);
int iElementMatrixRow = 0;
for (int i = 0; i < elementDOFTypes.Count; i++)
{
Node nodeRow = matrixAssemblyNodes[i];
foreach (DOFType dofTypeRow in elementDOFTypes[i])
{
int dofRow = nodalDOFsDictionary.ContainsKey(nodeRow.ID) == false && isEmbeddedElement ? -1 : nodalDOFsDictionary[nodeRow.ID][dofTypeRow];
if (dofRow != -1)
{
int iElementMatrixColumn = 0;
for (int j = 0; j < elementDOFTypes.Count; j++)
{
Node nodeColumn = matrixAssemblyNodes[j];
foreach (DOFType dofTypeColumn in elementDOFTypes[j])
{
int dofColumn = nodalDOFsDictionary.ContainsKey(nodeColumn.ID) == false && isEmbeddedElement ? -1 : nodalDOFsDictionary[nodeColumn.ID][dofTypeColumn];
if (dofColumn != -1)
{
int height = dofRow - dofColumn;
if (height >= 0)
{
K.Data[K.RowIndex[dofRow] + height] += ElementK[iElementMatrixRow, iElementMatrixColumn];
}
}
iElementMatrixColumn++;
}
}
}
iElementMatrixRow++;
}
}
times["addition"] += DateTime.Now - elStart;
}
var totalTime = DateTime.Now - totalStart;
return(K);
}
matrixConstrConstr) BuildGlobalSubmatrices(ISubdomainFreeDofOrdering freeDofRowOrdering,
ISubdomainFreeDofOrdering freeDofColOrdering,
ISubdomainConstrainedDofOrdering constrainedDofRowOrdering,
ISubdomainConstrainedDofOrdering constrainedDofColOrdering, IEnumerable <IElement> elements,
IElementMatrixProvider matrixProvider)
{
int numFreeRowDofs = freeDofRowOrdering.NumFreeDofs;
int numFreeColDofs = freeDofColOrdering.NumFreeDofs;
var subdomainMatrix = DokRowMajor.CreateEmpty(numFreeRowDofs, numFreeColDofs);
constrainedAssembler.InitializeNewMatrices(freeDofRowOrdering.NumFreeDofs,
constrainedDofRowOrdering.NumConstrainedDofs);
foreach (var element in elements)
{
(int[] elementRowDofsFree, int[] subdomainRowDofsFree) =
freeDofRowOrdering.MapFreeDofsElementToSubdomain(element);
(int[] elementColDofsFree, int[] subdomainColDofsFree) =
freeDofColOrdering.MapFreeDofsElementToSubdomain(element);
(int[] elementRowDofsConstrained, int[] subdomainRowDofsConstrained) =
constrainedDofRowOrdering.MapConstrainedDofsElementToSubdomain(element);
(int[] elementColDofsConstrained, int[] subdomainColDofsConstrained) =
constrainedDofColOrdering.MapConstrainedDofsElementToSubdomain(element);
IMatrix elementMatrix = matrixProvider.Matrix(element);
subdomainMatrix.AddSubmatrix(elementMatrix, elementRowDofsFree, subdomainRowDofsFree,
elementColDofsFree, subdomainColDofsFree);
constrainedAssembler.AddElementMatrix(elementMatrix, elementRowDofsFree, subdomainRowDofsFree,
elementRowDofsConstrained, subdomainRowDofsConstrained); //TODO: check validity
}
(double[] values, int[] colIndices, int[] rowOffsets) = subdomainMatrix.BuildCsrArrays(sortColsOfEachRow);
if (!isIndexerCached)
{
cachedColIndices = colIndices;
cachedRowOffsets = rowOffsets;
isIndexerCached = true;
}
else
{
Debug.Assert(Utilities.AreEqual(cachedColIndices, colIndices));
Debug.Assert(Utilities.AreEqual(cachedRowOffsets, rowOffsets));
}
subdomainMatrix = null;
var matrixFreeFree =
CsrMatrix.CreateFromArrays(numFreeRowDofs, numFreeColDofs, values, cachedColIndices, cachedRowOffsets,
false);
(CsrMatrix matrixConstrFree, CsrMatrix matrixConstrConstr) =
constrainedAssembler.BuildMatrices(); // TODO: see if this work
return(matrixFreeFree, matrixConstrFree, matrixConstrFree.TransposeToCSC(false), matrixConstrConstr);
}
public IMatrixView GetElementStiffnessForUnitMaterial(int elementIdx)
{
//TODO: It would be nice to have a GetOriginalMatrix() method in the dofEnumerator class and a way to call it.
double currentModulus = penalizers[elementIdx].ScaleFactor;
penalizers[elementIdx].ScaleFactor = 1.0;
IMatrix unitStiffness = problemMatrixProvider.Matrix(elementWrappers[elementIdx]);
penalizers[elementIdx].ScaleFactor = currentModulus;
return(unitStiffness);
}
IMatrixView matrixConstrConstr) BuildGlobalSubmatrices(
ISubdomainFreeDofOrdering freeDofOrdering, ISubdomainConstrainedDofOrdering constrainedDofOrdering,
IEnumerable <IElement> elements, IElementMatrixProvider matrixProvider)
{
int numFreeDofs = freeDofOrdering.NumFreeDofs;
var subdomainMatrix = DokSymmetric.CreateEmpty(numFreeDofs);
//TODO: also reuse the indexers of the constrained matrices.
constrainedAssembler.InitializeNewMatrices(freeDofOrdering.NumFreeDofs, constrainedDofOrdering.NumConstrainedDofs);
// Process the stiffness of each element
foreach (IElement element in elements)
{
// TODO: perhaps that could be done and cached during the dof enumeration to avoid iterating over the dofs twice
(int[] elementDofsFree, int[] subdomainDofsFree) = freeDofOrdering.MapFreeDofsElementToSubdomain(element);
(int[] elementDofsConstrained, int[] subdomainDofsConstrained) =
constrainedDofOrdering.MapConstrainedDofsElementToSubdomain(element);
IMatrix elementMatrix = matrixProvider.Matrix(element);
subdomainMatrix.AddSubmatrixSymmetric(elementMatrix, elementDofsFree, subdomainDofsFree);
constrainedAssembler.AddElementMatrix(elementMatrix, elementDofsFree, subdomainDofsFree,
elementDofsConstrained, subdomainDofsConstrained);
}
// Create and cache the CSC arrays for the free dofs.
(double[] values, int[] rowIndices, int[] colOffsets) = subdomainMatrix.BuildSymmetricCscArrays(sortColsOfEachRow);
if (!isIndexerCached)
{
cachedRowIndices = rowIndices;
cachedColOffsets = colOffsets;
isIndexerCached = true;
}
else
{
Debug.Assert(Utilities.AreEqual(cachedRowIndices, rowIndices));
Debug.Assert(Utilities.AreEqual(cachedColOffsets, colOffsets));
}
// Create the free and constrained matrices.
subdomainMatrix = null; // Let the DOK be garbaged collected early, in case there isn't sufficient memory.
var matrixFreeFree =
SymmetricCscMatrix.CreateFromArrays(numFreeDofs, values, cachedRowIndices, cachedColOffsets, false);
(CsrMatrix matrixConstrFree, CsrMatrix matrixConstrConstr) = constrainedAssembler.BuildMatrices();
return(matrixFreeFree, matrixConstrFree.TransposeToCSC(false), matrixConstrFree, matrixConstrConstr);
}
public Matrix BuildGlobalMatrix(ISubdomainFreeDofOrdering dofOrdering, IEnumerable <IElement> elements,
IElementMatrixProvider elementMatrixProvider)
{
int numFreeDofs = dofOrdering.NumFreeDofs;
var subdomainMatrix = Matrix.CreateZero(numFreeDofs, numFreeDofs);
// Process the stiffness of each element
foreach (IElement element in elements)
{
// TODO: perhaps that could be done and cached during the dof enumeration to avoid iterating over the dofs twice
(int[] elementDofIndices, int[] subdomainDofIndices) = dofOrdering.MapFreeDofsElementToSubdomain(element);
//IReadOnlyDictionary<int, int> elementToGlobalDofs = dofOrdering.MapFreeDofsElementToSubdomain(element);
IMatrix elementMatrix = elementMatrixProvider.Matrix(element);
AddElementToGlobalMatrix(subdomainMatrix, elementMatrix, elementDofIndices, subdomainDofIndices);
}
return(subdomainMatrix);
}
IMatrixView matrixConstrConstr) BuildGlobalSubmatrices(
ISubdomainFreeDofOrdering freeDofOrdering, ISubdomainConstrainedDofOrdering constrainedDofOrdering,
IEnumerable <IElement> elements, IElementMatrixProvider matrixProvider)
{
if (!areIndexersCached)
{
skylineBuilder = SkylineBuilder.Create(freeDofOrdering.NumFreeDofs,
FindSkylineColumnHeights(elements, freeDofOrdering.NumFreeDofs, freeDofOrdering.FreeDofs));
areIndexersCached = true;
}
else
{
skylineBuilder.ClearValues();
}
//TODO: also reuse the indexers of the constrained matrices.
constrainedAssembler.InitializeNewMatrices(freeDofOrdering.NumFreeDofs, constrainedDofOrdering.NumConstrainedDofs);
// Process the stiffness of each element
foreach (IElement element in elements)
{
// TODO: perhaps that could be done and cached during the dof enumeration to avoid iterating over the dofs twice
(int[] elementDofsFree, int[] subdomainDofsFree) = freeDofOrdering.MapFreeDofsElementToSubdomain(element);
(int[] elementDofsConstrained, int[] subdomainDofsConstrained) =
constrainedDofOrdering.MapConstrainedDofsElementToSubdomain(element);
IMatrix elementMatrix = matrixProvider.Matrix(element);
skylineBuilder.AddSubmatrixSymmetric(elementMatrix, elementDofsFree, subdomainDofsFree);
constrainedAssembler.AddElementMatrix(elementMatrix, elementDofsFree, subdomainDofsFree,
elementDofsConstrained, subdomainDofsConstrained);
}
// Create the free and constrained matrices.
SkylineMatrix matrixFreeFree = skylineBuilder.BuildSkylineMatrix();
(CsrMatrix matrixConstrFree, CsrMatrix matrixConstrConstr) = constrainedAssembler.BuildMatrices();
return(matrixFreeFree, matrixConstrFree.TransposeToCSC(false), matrixConstrFree, matrixConstrConstr);
}
private IMatrix PorousMatrix(IElement element)
{
IPorousFiniteElement elementType = (IPorousFiniteElement)element.ElementType;
int dofs = 0;
foreach (IList <IDofType> dofTypes in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofType in dofTypes)
{
dofs++;
}
}
var poreStiffness = SymmetricMatrix.CreateZero(dofs);
IMatrix stiffness = solidStiffnessProvider.Matrix(element);
IMatrix permeability = elementType.PermeabilityMatrix(element);
int matrixRow = 0;
int solidRow = 0;
int fluidRow = 0;
foreach (IList <IDofType> dofTypesRow in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofTypeRow in dofTypesRow)
{
int matrixCol = 0;
int solidCol = 0;
int fluidCol = 0;
foreach (IList <IDofType> dofTypesCol in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofTypeCol in dofTypesCol)
{
if (dofTypeCol == PorousMediaDof.Pressure)
{
if (dofTypeRow == PorousMediaDof.Pressure)
{
// H correction
poreStiffness[matrixRow, matrixCol] = -permeability[fluidRow, fluidCol];
}
//poreStiffness[matrixRow, matrixCol] = permeability[fluidRow, fluidCol];
fluidCol++;
}
else
{
if (dofTypeRow != PorousMediaDof.Pressure)
{
poreStiffness[matrixRow, matrixCol] = stiffness[solidRow, solidCol] * stiffnessCoefficient;
}
solidCol++;
}
matrixCol++;
}
}
if (dofTypeRow == PorousMediaDof.Pressure)
{
fluidRow++;
}
else
{
solidRow++;
}
matrixRow++;
}
}
return(poreStiffness);
}
private IMatrix2D <double> PorousMatrix(Element element)
{
IPorousFiniteElement elementType = (IPorousFiniteElement)element.ElementType;
int dofs = 0;
foreach (IList <DOFType> dofTypes in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofType in dofTypes)
{
dofs++;
}
}
SymmetricMatrix2D <double> poreDamping = new SymmetricMatrix2D <double>(dofs);
IMatrix2D <double> damping = solidDampingProvider.Matrix(element);
IMatrix2D <double> saturation = elementType.SaturationMatrix(element);
IMatrix2D <double> coupling = elementType.CouplingMatrix(element);
int matrixRow = 0;
int solidRow = 0;
int fluidRow = 0;
foreach (IList <DOFType> dofTypesRow in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofTypeRow in dofTypesRow)
{
int matrixCol = 0;
int solidCol = 0;
int fluidCol = 0;
foreach (IList <DOFType> dofTypesCol in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofTypeCol in dofTypesCol)
{
if (dofTypeCol == DOFType.Pore)
{
if (dofTypeRow == DOFType.Pore)
{
poreDamping[matrixRow, matrixCol] = -saturation[fluidRow, fluidCol];
}
else
{
poreDamping[matrixRow, matrixCol] = coupling[fluidCol, solidRow];
}
fluidCol++;
}
else
{
if (dofTypeRow != DOFType.Pore)
{
poreDamping[matrixRow, matrixCol] = damping[solidRow, solidCol] * dampingCoefficient;
}
else
{
poreDamping[matrixRow, matrixCol] = coupling[fluidRow, solidCol];
}
solidCol++;
}
matrixCol++;
}
}
if (dofTypeRow == DOFType.Pore)
{
fluidRow++;
}
else
{
solidRow++;
}
matrixRow++;
}
}
return(poreDamping);
}
public Vector CalculateKfreeprescribedUpMultiplicationForSubdRHSContribution(Dictionary <int, INode> boundaryNodes,
Dictionary <int, Dictionary <IDofType, double> > initialConvergedBoundaryDisplacements, Dictionary <int, Dictionary <IDofType, double> > totalBoundaryDisplacements,
int nIncrement, int totalIncrements)
{
var dofOrdering = subdomain.FreeDofOrdering; //.1
var FreeDofs = subdomain.FreeDofOrdering.FreeDofs; //.1 Dictionary<int, Dictionary<DOFType, int>> nodalDOFsDictionary = subdomain.NodalDOFsDictionary;
double[] Kfp_Ustep = new double[subdomain.FreeDofOrdering.NumFreeDofs]; //.2 subdomain.TotalDOFs];
var times = new Dictionary <string, TimeSpan>();
var totalStart = DateTime.Now;
times.Add("rowIndexCalculation", DateTime.Now - totalStart);
times.Add("element", TimeSpan.Zero);
times.Add("addition", TimeSpan.Zero);
foreach (Element element in subdomain.Elements) //.3 ElementsDictionary.Values) // TODOGerasimos edw mporei na xrhsimopoihthei to dictionary twn eleement pou exoun fp nodes
{
var isEmbeddedElement = element.ElementType is IEmbeddedElement;
var elStart = DateTime.Now;
IMatrix ElementK = elementProvider.Matrix(element);
times["element"] += DateTime.Now - elStart;
elStart = DateTime.Now;
var elementDOFTypes = element.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(element);
var matrixAssemblyNodes = element.ElementType.DofEnumerator.GetNodesForMatrixAssembly(element);
int iElementMatrixRow = 0;
for (int i = 0; i < elementDOFTypes.Count; i++)
{
INode nodeRow = matrixAssemblyNodes[i];
int dofTypeRowToNumber = -1;
foreach (IDofType dofTypeRow in elementDOFTypes[i])
{
dofTypeRowToNumber++;
bool isFree = FreeDofs.TryGetValue(matrixAssemblyNodes[i], elementDOFTypes[i][dofTypeRowToNumber],
out int dofRow);
//.4 int dofRow = nodalDOFsDictionary.ContainsKey(nodeRow.ID) == false && isEmbeddedElement ? -1 : nodalDOFsDictionary[nodeRow.ID][dofTypeRow];
if (isFree) // TODOGerasimos edw pithanws thelei kai elegxo alliws an den ta exoume afhsei constrained ta p kai einai elefthera px me to an anhkoun sto baoundary nodes
{ // alla etsi einai oti akrivws thewritai kai sto assembly tou Kff opote ok
int iElementMatrixColumn = 0;
for (int j = 0; j < elementDOFTypes.Count; j++)
{
INode nodeColumn = matrixAssemblyNodes[j];
//foreach (DOFType dofTypeColumn in elementDOFTypes[j])
//{
// int dofColumn = nodalDOFsDictionary.ContainsKey(nodeColumn.ID) == false && isEmbeddedElement ? -1 : nodalDOFsDictionary[nodeColumn.ID][dofTypeColumn];
// if (dofColumn != -1)
// {
// int height = dofRow - dofColumn;
// if (height >= 0)
// K.Data[K.RowIndex[dofRow] + height] += ElementK[iElementMatrixRow, iElementMatrixColumn];
// }
// iElementMatrixColumn++;
//}
int nodalDofsNumber = elementDOFTypes[j].Count; //TODOGerasimos elegxos oti edw oi ginetai prosvash apo 0:1:megethos
if (boundaryNodes.ContainsKey(nodeColumn.ID))
{
//foreach(KeyValuePair< DOFType,double> prescribedDOFtype in totalBoundaryDisplacements[nodeColumn.ID])
//{
// prescribedDOFtype.Key
//}
double[] element_Kfp_triplette = new double[nodalDofsNumber]; //nodalDofsNumber: giati oxi scaleTransitions.PrescribedDofsPerNode()? Dioti tou ta pairname ola(triplette) kai dialegei to
for (int j1 = 0; j1 < nodalDofsNumber; j1++) //scaleTransitions.MicroToMacroTransition ti tha xrhsimopoihsei apo afta analoga pws einai implemented
{
element_Kfp_triplette[j1] = ElementK[iElementMatrixRow, iElementMatrixColumn + j1];
}
Dictionary <IDofType, double> nodalConvergedDisplacements = initialConvergedBoundaryDisplacements[nodeColumn.ID];
Dictionary <IDofType, double> nodalTotalDisplacements = totalBoundaryDisplacements[nodeColumn.ID];
double[] uStep_values_orZero_for_free = new double[nodalDofsNumber];
int positionOfDof = 0;
foreach (IDofType doftype1 in elementDOFTypes[j])
{
if (nodalConvergedDisplacements.ContainsKey(doftype1))
{
uStep_values_orZero_for_free[positionOfDof] = (nodalTotalDisplacements[doftype1] - nodalConvergedDisplacements[doftype1]) * ((double)nIncrement / (double)totalIncrements);
// TODO: this can be done faster: create a dictionary<...,dictionary> with the difference of the two values and use that and precalculate coefficient for scaling
}
positionOfDof += 1;
}
double contribution = 0;
for (int j2 = 0; j2 < nodalDofsNumber; j2++)
{
contribution += element_Kfp_triplette[j2] * uStep_values_orZero_for_free[j2];
}
Kfp_Ustep[dofRow] += contribution;
}
iElementMatrixColumn += nodalDofsNumber;
}
}
iElementMatrixRow++;
}
}
times["addition"] += DateTime.Now - elStart;
}
var totalTime = DateTime.Now - totalStart;
return(Vector.CreateFromArray(Kfp_Ustep));
}
private IMatrix PorousMatrix(IElement element)
{
IPorousFiniteElement elementType = (IPorousFiniteElement)element.ElementType;
int dofs = 0;
foreach (IList <IDofType> dofTypes in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofType in dofTypes)
{
dofs++;
}
}
var poreDamping = SymmetricMatrix.CreateZero(dofs);
IMatrix damping = solidDampingProvider.Matrix(element);
IMatrix saturation = elementType.SaturationMatrix(element);
IMatrix coupling = elementType.CouplingMatrix(element);
int matrixRow = 0;
int solidRow = 0;
int fluidRow = 0;
foreach (IList <IDofType> dofTypesRow in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofTypeRow in dofTypesRow)
{
int matrixCol = 0;
int solidCol = 0;
int fluidCol = 0;
foreach (IList <IDofType> dofTypesCol in elementType.DofEnumerator.GetDofTypesForMatrixAssembly(element))
{
foreach (IDofType dofTypeCol in dofTypesCol)
{
if (dofTypeCol == PorousMediaDof.Pressure)
{
if (dofTypeRow == PorousMediaDof.Pressure)
{
poreDamping[matrixRow, matrixCol] = -saturation[fluidRow, fluidCol];
}
else
{
poreDamping[matrixRow, matrixCol] = coupling[fluidCol, solidRow];
}
fluidCol++;
}
else
{
if (dofTypeRow != PorousMediaDof.Pressure)
{
poreDamping[matrixRow, matrixCol] = damping[solidRow, solidCol] * dampingCoefficient;
}
else
{
poreDamping[matrixRow, matrixCol] = coupling[fluidRow, solidCol];
}
solidCol++;
}
matrixCol++;
}
}
if (dofTypeRow == PorousMediaDof.Pressure)
{
fluidRow++;
}
else
{
solidRow++;
}
matrixRow++;
}
}
return(poreDamping);
}
public static double[][] CalculateKpfKffinverseKfpDq(double[][] f2_vectors, Subdomain subdomain, IElementMatrixProvider elementProvider, IScaleTransitions scaleTransitions, Dictionary <int, INode> boundaryNodes)
{
var dofOrdering = subdomain.FreeDofOrdering; //.1
var FreeDofs = subdomain.FreeDofOrdering.FreeDofs; //.1Dictionary<int, Dictionary<DOFType, int>> nodalDOFsDictionary = subdomain.NodalDOFsDictionary;
double[][] f3_vectors = new double[f2_vectors.GetLength(0)][];
for (int i1 = 0; i1 < f2_vectors.GetLength(0); i1++)
{
f3_vectors[i1] = new double[scaleTransitions.PrescribedDofsPerNode() * boundaryNodes.Count];
}
Dictionary <int, int> boundaryNodesOrder = GetNodesOrderInDictionary(boundaryNodes);
var times = new Dictionary <string, TimeSpan>();
var totalStart = DateTime.Now;
times.Add("rowIndexCalculation", DateTime.Now - totalStart);
times.Add("element", TimeSpan.Zero);
times.Add("addition", TimeSpan.Zero);
foreach (Element element in subdomain.Elements) //.3 ElementsDictionary.Values)
{
var isEmbeddedElement = element.ElementType is IEmbeddedElement;
var elStart = DateTime.Now;
IMatrix ElementK = elementProvider.Matrix(element);
times["element"] += DateTime.Now - elStart;
elStart = DateTime.Now;
var elementDOFTypes = element.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(element);
var matrixAssemblyNodes = element.ElementType.DofEnumerator.GetNodesForMatrixAssembly(element);
int iElementMatrixRow = 0;
for (int i = 0; i < elementDOFTypes.Count; i++)
{
INode nodeRow = matrixAssemblyNodes[i];
if (boundaryNodes.ContainsKey(nodeRow.ID))
{
for (int i1 = 0; i1 < scaleTransitions.PrescribedDofsPerNode(); i1++)
{
int dofrow_p = scaleTransitions.PrescribedDofsPerNode() * (boundaryNodesOrder[nodeRow.ID] - 1) + i1;
int iElementMatrixColumn = 0;
for (int j = 0; j < elementDOFTypes.Count; j++)
{
INode nodeColumn = matrixAssemblyNodes[j];
int dofTypeColumnToNumber = -1;
foreach (IDofType dofTypeColumn in elementDOFTypes[j])
{
dofTypeColumnToNumber++;
bool isFree = FreeDofs.TryGetValue(matrixAssemblyNodes[j], elementDOFTypes[j][dofTypeColumnToNumber],
out int dofColumn); // v2.4 int dofColumn = nodalDOFsDictionary.ContainsKey(nodeColumn.ID) == false && isEmbeddedElement ? -1 : nodalDOFsDictionary[nodeColumn.ID][dofTypeColumn];
if (isFree) // TODOGerasimos edw pithanws thelei kai elegxo alliws an den ta exoume afhsei constrained ta p kai einai elefthera px me to an anhkoun sto baoundary nodes
{ // alla etsi einai oti akrivws thewritai kai sto assembly tou Kff opote ok
for (int i2 = 0; i2 < f2_vectors.GetLength(0); i2++)
{
f3_vectors[i2][dofrow_p] += ElementK[iElementMatrixRow + i1, iElementMatrixColumn] * f2_vectors[i2][dofColumn];
}
}
iElementMatrixColumn++;
}
}
}
}
iElementMatrixRow += elementDOFTypes[i].Count;
}
times["addition"] += DateTime.Now - elStart;
}
var totalTime = DateTime.Now - totalStart;
return(f3_vectors);
}
private IMatrix2D <double> PorousMatrix(Element element)
{
IPorousFiniteElement elementType = (IPorousFiniteElement)element.ElementType;
int dofs = 0;
foreach (IList <DOFType> dofTypes in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofType in dofTypes)
{
dofs++;
}
}
SymmetricMatrix2D <double> poreStiffness = new SymmetricMatrix2D <double>(dofs);
IMatrix2D <double> stiffness = solidStiffnessProvider.Matrix(element);
IMatrix2D <double> permeability = elementType.PermeabilityMatrix(element);
int matrixRow = 0;
int solidRow = 0;
int fluidRow = 0;
foreach (IList <DOFType> dofTypesRow in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofTypeRow in dofTypesRow)
{
int matrixCol = 0;
int solidCol = 0;
int fluidCol = 0;
foreach (IList <DOFType> dofTypesCol in elementType.DOFEnumerator.GetDOFTypes(element))
{
foreach (DOFType dofTypeCol in dofTypesCol)
{
if (dofTypeCol == DOFType.Pore)
{
if (dofTypeRow == DOFType.Pore)
{
// H correction
poreStiffness[matrixRow, matrixCol] = -permeability[fluidRow, fluidCol];
}
//poreStiffness[matrixRow, matrixCol] = permeability[fluidRow, fluidCol];
fluidCol++;
}
else
{
if (dofTypeRow != DOFType.Pore)
{
poreStiffness[matrixRow, matrixCol] = stiffness[solidRow, solidCol] * stiffnessCoefficient;
}
solidCol++;
}
matrixCol++;
}
}
if (dofTypeRow == DOFType.Pore)
{
fluidRow++;
}
else
{
solidRow++;
}
matrixRow++;
}
}
return(poreStiffness);
}
