private void Solve(double[] x, out Model model, out LinearAnalyzer childAnalyzer,
out Rod2DResults rodResults)
{
model = BuildModel(x);
SkylineSolver solver = new SkylineSolver.Builder().BuildSolver(model);
var provider = new ProblemStructural(model, solver);
childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
CreateLogs(model, childAnalyzer);
rodResults = new Rod2DResults(model.SubdomainsDictionary[subdomainID], solver.LinearSystems[subdomainID]); // Let's hope this is the one!
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
}
private static IVectorView SolveModelWithoutSubdomains(int numElementsX, int numElementsY)
{
Model model = CreateSingleSubdomainModel(numElementsX, numElementsY);
// Solver
SkylineSolver solver = (new SkylineSolver.Builder()).BuildSolver(model);
// Linear static analysis
var provider = new ProblemStructural(model, solver);
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(solver.LinearSystems[singleSubdomainID].Solution);
}
private static void UpdateModels(Dictionary <int, IVector>[] solutions, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace,
IConvectionDiffusionIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
{
Solutions = solutions;
double[] sol0 = solutions[0][0].CopyToArray();
double[] sol1 = solutions[1][0].CopyToArray();
var fluxLoad = sol0[39];// (sol0[39] + sol0[38] + sol0[37] + sol1[36])/8 ;
modelsToReplace[0] = CreateConvectionDiffusionModel1(1, new double[] { -2, -2, -2 }, 0, 0, 0, 0, 10).Item1;
modelsToReplace[1] = CreateConvectionDiffusionModel2(1, new double[] { 0, 0, 0 }, 0, 0, fluxLoad, new double[] { }).Item1;
for (int i = 0; i < modelsToReplace.Length; i++)
{
solversToReplace[i] = builder.BuildSolver(modelsToReplace[i]);
providersToReplace[i] = new ProblemConvectionDiffusion2((Model)modelsToReplace[i], solversToReplace[i]);
childAnalyzersToReplace[i] = new LinearAnalyzer(modelsToReplace[i], solversToReplace[i], providersToReplace[i]);
}
}
private static IVectorView SolveModel(Model model, ComsolMeshReader2 modelReader)
{
//var initialTemp = Vector.CreateZero(model.Nodes.Count);
double[] temp0 = new double[model.Nodes.Count];
int[] boundaryIDs = new int[] { 0 };
foreach (int boundaryID in boundaryIDs)
{
foreach (IList <Node> nodes in modelReader.triBoundaries[boundaryID])
{
foreach (Node node in nodes)
{
temp0[node.ID] = 1;
}
}
}
boundaryIDs = new int[] { 5 };
foreach (int boundaryID in boundaryIDs)
{
foreach (IList <Node> nodes in modelReader.triBoundaries[boundaryID])
{
foreach (Node node in nodes)
{
temp0[node.ID] = 0;
}
}
}
Vector initialTemp = Vector.CreateFromArray(temp0);
var builder = new DenseMatrixSolver.Builder();
builder.IsMatrixPositiveDefinite = false;
var solver = builder.BuildSolver(model);
var provider = new ProblemConvectionDiffusion(model, solver);
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
//var parentAnalyzer = new BDF(model, solver, provider, childAnalyzer, 1, 10, 1, initialTemp);
var parentAnalyzer = new ConvectionDiffusionExplicitDynamicAnalyzer(model, solver, provider, childAnalyzer, 2.5e-3, 5, initialTemp);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(parentAnalyzer.temperature[subdomainID]);
//return parentAnalyzer.temperature[1][subdomainID];
// return solver.LinearSystems[subdomainID].Solution;
}
private static IVectorView[] SolveModels(Model[] models, IModelReader[] modelReaders)
{
Vector[] initialValues = new Vector[models.Length];
var value0 = new Dictionary <int, double[]>();
for (int i = 0; i < models.Length; i++)
{
double[] v0 = new double[models[i].Nodes.Count];
value0.Add(i, v0);
}
foreach (Node node in models[0].Nodes)
{
value0[0][node.ID] = 0; /* 0.96733;*/
}
DenseMatrixSolver[] solvers = new DenseMatrixSolver[models.Length];
IConvectionDiffusionIntegrationProvider[] providers = new IConvectionDiffusionIntegrationProvider[models.Length];
IChildAnalyzer[] childAnalyzers = new IChildAnalyzer[models.Length];
for (int i = 0; i < models.Length; i++)
{
initialValues[i] = Vector.CreateFromArray(value0[i]);
//var builder = new DenseMatrixSolver.Builder();
builder.IsMatrixPositiveDefinite = false;
solvers[i] = builder.BuildSolver(models[i]);
providers[i] = new ProblemConvectionDiffusion2(models[i], solvers[i]);
childAnalyzers[i] = new LinearAnalyzer(models[i], solvers[i], providers[i]);
}
const double timestep = 1;
const double time = 3;
var parentAnalyzer = new ConvectionDiffusionImplicitDynamicAnalyzerMultiModel(UpdateModels, models, solvers,
providers, childAnalyzers, timestep, time, initialTemperature: initialValues);
parentAnalyzer.Initialize();
for (int i = 0; i < time / timestep; i++)
{
parentAnalyzer.SolveTimestep(i);
}
return(solvers.Select(x => x.LinearSystems[subdomainID].Solution).ToArray());
}
public (IVectorView globalU, IMatrixView globalK) SolveModel()
{
// Solver
SkylineSolver solver = new SkylineSolver.Builder().BuildSolver(Model);
solver.PreventFromOverwrittingSystemMatrices(); // Necessary to extract the stiffness matrix.
// Problem type
var provider = new ProblemStructural(Model, solver);
// Analyzers
var childAnalyzer = new LinearAnalyzer(Model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(Model, solver, provider, childAnalyzer);
// Run the anlaysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(solver.LinearSystems[0].Solution, solver.LinearSystems[0].Matrix);
}
private static IVectorView[] SolveModels(Model[] models)
{
SkylineSolver[] solvers = new SkylineSolver[models.Length];
IImplicitIntegrationProvider[] providers = new IImplicitIntegrationProvider[models.Length];
IChildAnalyzer[] childAnalyzers = new IChildAnalyzer[models.Length];
for (int i = 0; i < models.Length; i++)
{
//var builder = new DenseMatrixSolver.Builder();
solvers[i] = builder.BuildSolver(models[i]);
providers[i] = new ProblemStructural(models[i], solvers[i]);
childAnalyzers[i] = new LinearAnalyzer(models[i], solvers[i], providers[i]);
}
var parentAnalyzer = new NewmarkDynamicAnalyzerMultiModel(UpdateModels, models, solvers, providers, childAnalyzers, 0.28, 3.36, .25, .5);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(solvers.Select(x => x.LinearSystems[subdomainID].Solution).ToArray());
}
private void TestCollocationPointCreation()
{
var model = new CollocationModel();
ModelCreator modelCreator = new ModelCreator(model);
string filename = "..\\..\\..\\InputFiles\\PlateWithHole.txt";
IsogeometricReader modelReader = new IsogeometricReader(modelCreator, filename);
modelReader.CreateCollocationModelFromFile();
//var solverBuilder = new SuiteSparseSolver.Builder();
//solverBuilder.DofOrderer = new DofOrderer(
// new NodeMajorDofOrderingStrategy(), new NullReordering());
var solverBuilder = new GmresSolver.Builder();
ISolver solver = new GmresSolver(model,
new AsymmetricDofOrderer(new RowDofOrderingStrategy()),
new DofOrderer(new NodeMajorDofOrderingStrategy(), new NullReordering()));
// Structural problem provider
var provider = new ProblemStructural(model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.BuildMatrices();
var k = solver.LinearSystems[0].Matrix;
Matrix <double> kmatlab = MathNet.Numerics.LinearAlgebra.CreateMatrix.Dense <double>(k.NumRows, k.NumColumns);
for (int i = 0; i < k.NumRows; i++)
{
for (int j = 0; j < k.NumColumns; j++)
{
kmatlab[i, j] = k[i, j];
}
}
MatlabWriter.Write("..\\..\\..\\InputFiles\\KcolMsolve.mat", kmatlab, "Ktotal");
}
private static void UpdateModels(Dictionary <int, IVector>[] solutions, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace,
IConvectionDiffusionIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
{
c_oxNode = solversTo[0][0].CopyToArray();
lgNode = solutions[1][0].CopyToArray();
if (c_oxElement == null)
{
c_oxElement = new double[modelsToReplace[0].Elements.Count];
}
foreach (var e in modelsToReplace[0].Elements)
{
c_oxElement[e.ID] = 0;
for (int i = 0; i < e.Nodes.Count; i++)
{
c_oxElement[e.ID] += c_oxNode[i] / (e.Nodes.Count);
}
}
if (lgElement == null)
{
lgElement = new double[modelsToReplace[2].Elements.Count];
}
foreach (var e in modelsToReplace[2].Elements)
{
lgElement[e.ID] = 0;
for (int i = 0; i < e.Nodes.Count; i++)
{
lgElement[e.ID] += lgNode[i] / (e.Nodes.Count);
}
}
modelsToReplace[0] = CreateOxygenTransportModel(Dox, conv0, new double[] { Dox[0] / Lwv * 7e3 * 24 * 3600, Dox[1] / Lwv * 7e3 * 24 * 3600 }, c_oxElement).Item1;
modelsToReplace[1] = CreateCancerTransportModel(Dcell, conv0, new double[] { Dcell[0] / Lwv * 7e3 * 24 * 3600, Dcell[1] / Lwv * 7e3 * 24 * 3600 }, TumC_Element).Item1;
modelsToReplace[2] = CreateGrowthModel(0, new double[] { 0, 0, 0 }, 0, lgElement).Item1;
for (int i = 0; i < modelsToReplace.Length; i++)
{
solversToReplace[i] = builder.BuildSolver(modelsToReplace[i]);
providersToReplace[i] = new ProblemConvectionDiffusion2((Model)modelsToReplace[i], solversToReplace[i]);
childAnalyzersToReplace[i] = new LinearAnalyzer(modelsToReplace[i], solversToReplace[i], providersToReplace[i]);
}
}
private static void RunAnalysisAndCheck(CantileverBeam benchmark, ISolver solver)
{
// Structural problem provider
var provider = new ProblemStructural(benchmark.Model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(benchmark.Model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(benchmark.Model, solver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Check output
double endDeflectionExpected = benchmark.CalculateEndDeflectionWithEulerBeamTheory();
double endDeflectionComputed =
benchmark.CalculateAverageEndDeflectionFromSolution(solver.LinearSystems.First().Value.Solution);
var comparer = new ValueComparer(1E-2);
Assert.True(comparer.AreEqual(endDeflectionExpected, endDeflectionComputed));
}
private static IVectorView[] SolveModels(Model[] models)
{
Vector[] initialTemps = new Vector[models.Length];
DenseMatrixSolver[] solvers = new DenseMatrixSolver[models.Length];
IConvectionDiffusionIntegrationProvider[] providers = new IConvectionDiffusionIntegrationProvider[models.Length];
IChildAnalyzer[] childAnalyzers = new IChildAnalyzer[models.Length];
for (int i = 0; i < models.Length; i++)
{
initialTemps[i] = Vector.CreateFromArray(new double[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
solvers[i] = (new DenseMatrixSolver.Builder()).BuildSolver(models[i]);
providers[i] = new ProblemConvectionDiffusion(models[i], solvers[i]);
childAnalyzers[i] = new LinearAnalyzer(models[i], solvers[i], providers[i]);
}
var parentAnalyzer = new ConvectionDiffusionDynamicAnalyzerMultiModel_Beta(UpdateModels, models, solvers, providers, childAnalyzers, 0.05, 5, initialTemperature: initialTemps);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(solvers.Select(x => x.LinearSystems[subdomainID].Solution).ToArray());
}
private static IVectorView SolveModel(Model model)
{
double[] temp0 = new double[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
Vector initialTemp = Vector.CreateFromArray(temp0);
var builder = new DenseMatrixSolver.Builder();
builder.IsMatrixPositiveDefinite = false;
var solver = builder.BuildSolver(model);
//var solver = new DenseMatrixSolver.Builder().BuildSolver(model);
//Gmres solver = (new DenseMatrixSolver.Builder()).BuildSolver(model);
var provider = new ProblemConvectionDiffusion3(model, solver);
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new BDF(model, solver, provider, childAnalyzer, 1, 5, 6, initialTemp);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
//return solver.LinearSystems[subdomainID].Solution;
return(parentAnalyzer.temperature[5][subdomainID]);
}
private static IVectorView SolveModel(Model model, ComsolMeshReader3 modelReader)
{
//var initialTemp = Vector.CreateZero(model.Nodes.Count);
double[] value0 = new double[model.Nodes.Count];
int[] boundaryIDs = new int[] { 0 };
foreach (int boundaryID in boundaryIDs)
{
foreach (IList <Node> nodes in modelReader.quadBoundaries[boundaryID])
{
foreach (Node node in nodes)
{
value0[node.ID] = 0;
}
}
}
boundaryIDs = new int[] { 5 };
foreach (int boundaryID in boundaryIDs)
{
foreach (IList <Node> nodes in modelReader.quadBoundaries[boundaryID])
{
foreach (Node node in nodes)
{
value0[node.ID] = 0;
}
}
}
Vector initialValue = Vector.CreateFromArray(value0);
var builder = new SkylineSolver.Builder();
//builder.IsMatrixPositiveDefinite = false;
var solver = builder.BuildSolver(model);
var provider = new ProblemODE(model, solver);
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new ODEDynamicAnalyzer(model, solver, provider, childAnalyzer, .5, .1, 3, initialValue);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(solver.LinearSystems[subdomainID].Solution);
}
private double[] EvaluateConstraints(Model model, LinearAnalyzer childAnalyzer,
Rod2DResults rodResults)
{
var constraints = new LinkedList <double>();
// Displacements
const double maxDisplacement = 2;
double max = 0;
foreach (var displacement in ((DOFSLog)childAnalyzer.Logs[1][0]).DOFValues.Values)
{
if (Math.Abs(displacement) > max)
{
max = Math.Abs(displacement);
}
}
constraints.AddLast(max / maxDisplacement - 1.0);
// Stresses
double[] minStresses = new double[10];
minStresses = minStresses.Select(i => - 25.0).ToArray();
double[] maxStresses = new double[10];
maxStresses = maxStresses.Select(i => 25.0).ToArray();
double[] stresses = new double[10];
int counter = 0;
foreach (var element in model.Elements)
{
stresses[counter++] = rodResults.AxialRod2DStress(element);
}
for (int i = 0; i < stresses.Length; ++i)
{
constraints.AddLast(stresses[i] / maxStresses[i] - 1.0);
constraints.AddLast(stresses[i] / minStresses[i] - 1.0);
}
return(constraints.ToArray());
}
private static (IVectorView U, SolverLogger logger) SolveModelWithSubdomains(int numElementsX, int numElementsY,
double factorizationTolerance)
{
Model multiSubdomainModel = CreateModel(numElementsX, numElementsY);
// Solver
var factorizationTolerances = new Dictionary <int, double>();
foreach (Subdomain s in multiSubdomainModel.Subdomains)
{
factorizationTolerances[s.ID] = factorizationTolerance;
}
//var fetiMatrices = new DenseFeti1SubdomainMatrixManager.Factory();
//var fetiMatrices = new SkylineFeti1SubdomainMatrixManager.Factory();
var fetiMatrices = new SkylineFeti1SubdomainMatrixManager.Factory(new OrderingAmdCSparseNet());
var solverBuilder = new Feti1Solver.Builder(fetiMatrices, factorizationTolerances);
//solverBuilder.PreconditionerFactory = new LumpedPreconditioner.Factory();
solverBuilder.PreconditionerFactory = new DirichletPreconditioner.Factory();
solverBuilder.ProblemIsHomogeneous = true;
Feti1Solver fetiSolver = solverBuilder.BuildSolver(multiSubdomainModel);
// Linear static analysis
var provider = new ProblemStructural(multiSubdomainModel, fetiSolver);
var childAnalyzer = new LinearAnalyzer(multiSubdomainModel, fetiSolver, provider);
var parentAnalyzer = new StaticAnalyzer(multiSubdomainModel, fetiSolver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Gather the global displacements
var sudomainDisplacements = new Dictionary <int, IVectorView>();
foreach (var ls in fetiSolver.LinearSystems)
{
sudomainDisplacements[ls.Key] = ls.Value.Solution;
}
return(fetiSolver.GatherGlobalDisplacements(sudomainDisplacements), fetiSolver.Logger);
}
private static void SolveBuildingInNoSoilSmallDynamic()
{
var model = new Model();
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
BeamBuildingBuilder.MakeBeamBuilding(model, 20, 20, 20, 5, 4, model.NodesDictionary.Count + 1,
model.ElementsDictionary.Count + 1, subdomainID, 4, false, false);
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Structural problem provider
var provider = new ProblemStructural(model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 0.01, 0.1);
parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration(); // Not necessary. This is the default
NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();
// Request output
int monitorDof = 420;
childAnalyzer.LogFactories[subdomainID] = new LinearAnalyzerLogFactory(new int[] { monitorDof });
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Write output
DOFSLog log = (DOFSLog)childAnalyzer.Logs[subdomainID][0]; //There is a list of logs for each subdomain and we want the first one
Console.WriteLine($"dof = {monitorDof}, u = {log.DOFValues[monitorDof]}");
//TODO: No loads have been defined so the result is bound to be 0.
}
private static void SolveBuildingInNoSoilSmall()
{
var model = new Model();
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
BeamBuildingBuilder.MakeBeamBuilding(model, 20, 20, 20, 5, 4, model.NodesDictionary.Count + 1,
model.ElementsDictionary.Count + 1, subdomainID, 4, false, false);
model.Loads.Add(new Load()
{
Amount = -100, Node = model.Nodes[21], DOF = StructuralDof.TranslationX
});
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Structural problem provider
var provider = new ProblemStructural(model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Request output
int monitorDof = 420;
childAnalyzer.LogFactories[subdomainID] = new LinearAnalyzerLogFactory(new int[] { monitorDof });
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Write output
DOFSLog log = (DOFSLog)childAnalyzer.Logs[subdomainID][0]; //There is a list of logs for each subdomain and we want the first one
Console.WriteLine($"dof = {monitorDof}, u = {log.DOFValues[monitorDof]}");
}
public void CollocationPoint3DMatrix()
{
var model = new CollocationModel();
ModelCreator modelCreator = new ModelCreator(model);
string filename = "..\\..\\..\\InputFiles\\Collocation 3D.txt";
IsogeometricReader modelReader = new IsogeometricReader(modelCreator, filename);
modelReader.CreateCollocationModelFromFile();
var gmresBuilder = new GmresSolver.Builder();
ISolver solver = gmresBuilder.BuildSolver(model);
// Structural problem provider
var provider = new ProblemStructural(model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.BuildMatrices();
var k = solver.LinearSystems[0].Matrix;
Matrix <double> stiffnessMatrixExpected =
MatlabReader.Read <double>("..\\..\\..\\InputFiles\\Kcol3D.mat", "Ktotal");
for (int i = 0; i < k.NumRows; i++)
{
for (int j = 0; j < k.NumColumns; j++)
{
Utilities.AreValuesEqual(stiffnessMatrixExpected[i, j], k[i, j], 10e-9);
}
}
}
private static void SolveBuildingInNoSoilSmallDynamic()
{
VectorExtensions.AssignTotalAffinityCount();
Model model = new Model();
model.SubdomainsDictionary.Add(1, new Subdomain()
{
ID = 1
});
BeamBuildingBuilder.MakeBeamBuilding(model, 20, 20, 20, 5, 4, model.NodesDictionary.Count + 1,
model.ElementsDictionary.Count + 1, 1, 4, false, false);
model.ConnectDataStructures();
SolverSkyline solver = new SolverSkyline(model);
ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary);
LinearAnalyzer analyzer = new LinearAnalyzer(solver, solver.SubdomainsDictionary);
NewmarkDynamicAnalyzer parentAnalyzer = new NewmarkDynamicAnalyzer(provider, analyzer, solver.SubdomainsDictionary, 0.5, 0.25, 0.01, 0.1);
analyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 420 });
parentAnalyzer.BuildMatrices();
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
}
public void TestQuad4LinearCantileverExample()
{
// Model and node creation
var model = new Model();
model.NodesDictionary.Add(1, new Node {
ID = 1, X = 0.0, Y = 0.0, Z = 0.0
});
model.NodesDictionary.Add(2, new Node {
ID = 2, X = 10.0, Y = 0.0, Z = 0.0
});
model.NodesDictionary.Add(3, new Node {
ID = 3, X = 10.0, Y = 10.0, Z = 0.0
});
model.NodesDictionary.Add(4, new Node {
ID = 4, X = 0.0, Y = 10.0, Z = 0.0
});
// Constrain bottom nodes of the model and add loads
model.NodesDictionary[1].Constraints.AddRange(new[] { DOFType.X, DOFType.Y });
model.NodesDictionary[4].Constraints.AddRange(new[] { DOFType.X, DOFType.Y });
model.Loads.Add(new Load()
{
Amount = 500, Node = model.NodesDictionary[2], DOF = DOFType.X
});
model.Loads.Add(new Load()
{
Amount = 500, Node = model.NodesDictionary[3], DOF = DOFType.X
});
// Create Quad4 element and its material
var material = new ElasticMaterial2D(StressState2D.PlaneStress)
{
YoungModulus = 3.76, PoissonRatio = 0.3779
};
var quad = new Quad4(material)
{
Thickness = 1
};
// Create the element connectivity
var element = new Element()
{
ID = 1, ElementType = quad
};
element.AddNode(model.NodesDictionary[1]);
element.AddNode(model.NodesDictionary[2]);
element.AddNode(model.NodesDictionary[3]);
element.AddNode(model.NodesDictionary[4]);
// Add quad element to the element and subdomains dictionary of the model
model.ElementsDictionary.Add(element.ID, element);
model.ConnectDataStructures();
// Setup
var linearSystem = new SkylineLinearSystem(model.Forces);
var solver = new SolverSkyline(linearSystem);
var provider = new ProblemStructural(model);
var childAnalyzer = new LinearAnalyzer(solver);
var parentAnalyzer = new StaticAnalyzer(provider, childAnalyzer, linearSystem);
parentAnalyzer.BuildMatrices();
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
var expectedSolution = new double[] { 253.13237596153559, 66.567582057178811, 253.13237596153553, -66.567582057178811 };
for (int i = 0; i < expectedSolution.Length; i++)
{
Assert.Equal(expectedSolution[i], linearSystem.Solution[i], 12);
}
}
private static void TestBatheImplicitAnalysisExample()
{
var model = new Model();
int subdomainID = 0;
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
var n = new Node(id: 0, x: double.NaN);
var e = new Element()
{
ID = 0
};
e.NodesDictionary.Add(0, n);
var m = new Mock <IFiniteElement>();
m.Setup(x => x.StiffnessMatrix(e)).Returns(Matrix.CreateFromArray(new double[, ] {
{ 6, -2, }, { -2, 4 }
}));
m.Setup(x => x.MassMatrix(e)).Returns(Matrix.CreateFromArray(new double[, ] {
{ 2, 0, }, { 0, 1 }
}));
m.Setup(x => x.DampingMatrix(e)).Returns(Matrix.CreateFromArray(new double[, ] {
{ 0, 0, }, { 0, 0 }
}));
//m.Setup(x => x.StiffnessMatrix(e)).Returns(new Numerical.LinearAlgebra.SymmetricMatrix2D(new double[] { 6, -2, 4 }));
//m.Setup(x => x.MassMatrix(e)).Returns(new Numerical.LinearAlgebra.SymmetricMatrix2D(new double[] { 2, 0, 1 }));
//m.Setup(x => x.DampingMatrix(e)).Returns(new Numerical.LinearAlgebra.SymmetricMatrix2D(new double[] { 0, 0, 0 }));
m.Setup(x => x.GetElementDofTypes(e)).Returns(new[] { new[] { StructuralDof.TranslationX, StructuralDof.TranslationY } });
m.SetupGet(x => x.DofEnumerator).Returns(new GenericDofEnumerator());
e.ElementType = m.Object;
model.NodesDictionary.Add(0, n);
model.ElementsDictionary.Add(0, e);
model.SubdomainsDictionary[subdomainID].Elements.Add(e);
model.Loads.Add(new Load()
{
Amount = 10, Node = n, DOF = StructuralDof.TranslationY
});
var lX = new Mock <IMassAccelerationHistoryLoad>();
lX.SetupGet(x => x.DOF).Returns(StructuralDof.TranslationX);
lX.SetupGet(x => x[It.IsAny <int>()]).Returns(0);
var lY = new Mock <IMassAccelerationHistoryLoad>();
lY.SetupGet(x => x.DOF).Returns(StructuralDof.TranslationY);
lY.SetupGet(x => x[0]).Returns(10);
lY.SetupGet(x => x[It.IsInRange(1, 100, Range.Inclusive)]).Returns(0);
model.MassAccelerationHistoryLoads.Add(lX.Object);
model.MassAccelerationHistoryLoads.Add(lY.Object);
m.Setup(x => x.CalculateAccelerationForces(It.IsAny <Element>(), It.IsAny <IList <MassAccelerationLoad> >()))
.Returns <Element, IList <MassAccelerationLoad> >((element, loads) =>
{
double[] accelerations = { loads[0].Amount, loads[1].Amount };
var massMatrix = Matrix.CreateFromArray(new double[, ] {
{ 2, 0, }, { 0, 1 }
});
//var massMatrix = new Numerical.LinearAlgebra.SymmetricMatrix2D(new double[] { 2, 0, 1 });
return(massMatrix.Multiply(accelerations));
}
);
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
//TODO: These overwrite the corresponding data extracted by the Model. Either set up these or the Model.
//solver.LinearSystems[subdomainID].SetMatrix(
// SkylineMatrix.CreateFromArrays(2, new double[] { 6, 4, -2 }, new int[] { 0, 1, 3 }, true)); // K = [6 -2; -2 4]
//solver.LinearSystems[subdomainID].RhsVector = Vector.CreateFromArray(new double[] { 0, 10 });
// Problem type
var provider = new ProblemStructural(model, solver);
// Analyzers
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 0.28, 3.36);
parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration(); // Not necessary. This is the default
//parentAnalyzerBuilder.SetNewmarkParameters(0.25, 0.5); // Not necessary. This is the default
NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();
// Request output
childAnalyzer.LogFactories[subdomainID] = new LinearAnalyzerLogFactory(new int[] { 0, 1 });
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
//Check output
DOFSLog log = (DOFSLog)childAnalyzer.Logs[subdomainID][0]; //There is a list of logs for each subdomain and we want the first one
Assert.Equal(2.2840249264795207, log.DOFValues[0], 8);
Assert.Equal(2.4351921891904156, log.DOFValues[1], 8);
}
SolveModelWithSubdomains(double stiffnessRatio, InterfaceSolver interfaceSolver, Precond precond, MatrixQ q,
Residual residualConvergence, double factorizationTolerance, double pcgConvergenceTolerance)
{
// Model
Model multiSubdomainModel = CreateModel(stiffnessRatio);
// Solver
var factorizationTolerances = new Dictionary <int, double>();
foreach (Subdomain s in multiSubdomainModel.Subdomains)
{
factorizationTolerances[s.ID] = factorizationTolerance;
}
//var fetiMatrices = new DenseFeti1SubdomainMatrixManager.Factory();
//var fetiMatrices = new SkylineFeti1SubdomainMatrixManager.Factory();
var fetiMatrices = new SkylineFeti1SubdomainMatrixManager.Factory(new OrderingAmdCSparseNet());
var solverBuilder = new Feti1Solver.Builder(fetiMatrices, factorizationTolerances);
// Homogeneous/heterogeneous problem, matrix Q.
solverBuilder.ProblemIsHomogeneous = stiffnessRatio == 1.0;
if (q == MatrixQ.Identity)
{
solverBuilder.ProjectionMatrixQIsIdentity = true;
}
else
{
solverBuilder.ProjectionMatrixQIsIdentity = false;
}
// Preconditioner
if (precond == Precond.Lumped)
{
solverBuilder.PreconditionerFactory = new LumpedPreconditioner.Factory();
}
else if (precond == Precond.DirichletDiagonal)
{
solverBuilder.PreconditionerFactory = new DiagonalDirichletPreconditioner.Factory();
}
else
{
solverBuilder.PreconditionerFactory = new DirichletPreconditioner.Factory();
}
// PCG may need to use the exact residual for the comparison with the expected values
bool residualIsExact = residualConvergence == Residual.Exact;
ExactFeti1PcgConvergence.Factory exactResidualConvergence = null;
if (residualIsExact)
{
exactResidualConvergence = new ExactFeti1PcgConvergence.Factory(
CreateSingleSubdomainModel(stiffnessRatio), solverBuilder.DofOrderer,
(model, solver) => new ProblemStructural(model, solver));
}
// Lagrange separation method
if (interfaceSolver == InterfaceSolver.Method1)
{
var interfaceProblemSolverBuilder = new Feti1UnprojectedInterfaceProblemSolver.Builder();
interfaceProblemSolverBuilder.MaxIterationsProvider = new FixedMaxIterationsProvider(maxIterations);
interfaceProblemSolverBuilder.PcgConvergenceTolerance = pcgConvergenceTolerance;
if (residualIsExact)
{
interfaceProblemSolverBuilder.PcgConvergenceStrategyFactory = exactResidualConvergence;
}
Feti1UnprojectedInterfaceProblemSolver interfaceProblemSolver = interfaceProblemSolverBuilder.Build();
solverBuilder.InterfaceProblemSolver = interfaceProblemSolver;
}
else
{
var interfaceProblemSolverBuilder = new Feti1ProjectedInterfaceProblemSolver.Builder();
interfaceProblemSolverBuilder.MaxIterationsProvider = new FixedMaxIterationsProvider(maxIterations);
interfaceProblemSolverBuilder.PcgConvergenceTolerance = pcgConvergenceTolerance;
if (residualIsExact)
{
interfaceProblemSolverBuilder.PcgConvergenceStrategyFactory = exactResidualConvergence;
}
if (interfaceSolver == InterfaceSolver.Method2)
{
interfaceProblemSolverBuilder.LagrangeSeparation = Feti1ProjectedInterfaceProblemSolver.LagrangeMultiplierSeparation.Simple;
interfaceProblemSolverBuilder.ProjectionSideMatrix = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.Left;
interfaceProblemSolverBuilder.ProjectionSidePreconditioner = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.Left;
}
else if (interfaceSolver == InterfaceSolver.Method3)
{
interfaceProblemSolverBuilder.LagrangeSeparation = Feti1ProjectedInterfaceProblemSolver.LagrangeMultiplierSeparation.WithProjection;
interfaceProblemSolverBuilder.ProjectionSideMatrix = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.Both;
interfaceProblemSolverBuilder.ProjectionSidePreconditioner = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.None;
}
else if (interfaceSolver == InterfaceSolver.Method4)
{
interfaceProblemSolverBuilder.LagrangeSeparation = Feti1ProjectedInterfaceProblemSolver.LagrangeMultiplierSeparation.WithProjection;
interfaceProblemSolverBuilder.ProjectionSideMatrix = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.Both;
interfaceProblemSolverBuilder.ProjectionSidePreconditioner = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.Left;
}
else // default
{
interfaceProblemSolverBuilder.LagrangeSeparation = Feti1ProjectedInterfaceProblemSolver.LagrangeMultiplierSeparation.WithProjection;
interfaceProblemSolverBuilder.ProjectionSideMatrix = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.Both;
interfaceProblemSolverBuilder.ProjectionSidePreconditioner = Feti1ProjectedInterfaceProblemSolver.ProjectionSide.Both;
}
Feti1ProjectedInterfaceProblemSolver interfaceProblemSolver = interfaceProblemSolverBuilder.Build();
solverBuilder.InterfaceProblemSolver = interfaceProblemSolver;
// Only needed in methods 2,3,4, default (where there is lagrange separation)
if (residualIsExact)
{
exactResidualConvergence.InterfaceProblemSolver = interfaceProblemSolver;
}
}
Feti1Solver fetiSolver = solverBuilder.BuildSolver(multiSubdomainModel);
if (residualIsExact)
{
exactResidualConvergence.FetiSolver = fetiSolver;
}
// Structural problem provider
var provider = new ProblemStructural(multiSubdomainModel, fetiSolver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(multiSubdomainModel, fetiSolver, provider);
var parentAnalyzer = new StaticAnalyzer(multiSubdomainModel, fetiSolver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Gather the global displacements
var sudomainDisplacements = new Dictionary <int, IVectorView>();
foreach (var ls in fetiSolver.LinearSystems)
{
sudomainDisplacements[ls.Key] = ls.Value.Solution;
}
Vector globalDisplacements = fetiSolver.GatherGlobalDisplacements(sudomainDisplacements);
// Other stats
int numUniqueGlobalDofs = multiSubdomainModel.Nodes.Count * 2;
int numExtenedDomainDofs = 0;
foreach (var subdomain in multiSubdomainModel.Subdomains)
{
numExtenedDomainDofs += subdomain.Nodes.Count * 2;
}
return(globalDisplacements, fetiSolver.Logger, numUniqueGlobalDofs, numExtenedDomainDofs);
}
private static (IVectorView globalDisplacements, SolverLogger logger) SolveModelWithSubdomains(double stiffnessRatio,
Precond precond, Residual residualConvergence, double pcgConvergenceTolerance)
{
// Model
Model multiSubdomainModel = CreateModel(stiffnessRatio);
// Corner nodes
double meshTol = 1E-6;
var cornerNodesOfEachSubdomain = new Dictionary <int, HashSet <INode> >();
foreach (Subdomain subdomain in multiSubdomainModel.Subdomains)
{
subdomain.DefineNodesFromElements(); //TODO: This will also be called by the analyzer.
INode[] corners = CornerNodeUtilities.FindCornersOfRectangle2D(subdomain);
var cornerNodes = new HashSet <INode>();
foreach (INode node in corners)
{
if (node.Constraints.Count > 0)
{
continue;
}
if ((Math.Abs(node.X - domainLengthX) <= meshTol) && (Math.Abs(node.Y) <= meshTol))
{
continue;
}
if ((Math.Abs(node.X - domainLengthX) <= meshTol) && (Math.Abs(node.Y - domainLengthY) <= meshTol))
{
continue;
}
cornerNodes.Add(node);
}
cornerNodesOfEachSubdomain[subdomain.ID] = cornerNodes;
}
// Solver
var fetiMatrices = new SkylineFetiDPSubdomainMatrixManager.Factory(new OrderingAmdSuiteSparse());
//var fetiMatrices = new SkylineFetiDPSubdomainMatrixManager.Factory();
//var fetiMatrices = new DenseFetiDPSubdomainMatrixManager.Factory();
var cornerNodeSelection = new UsedDefinedCornerNodes(cornerNodesOfEachSubdomain);
var solverBuilder = new FetiDPSolver.Builder(cornerNodeSelection, fetiMatrices);
solverBuilder.ProblemIsHomogeneous = stiffnessRatio == 1.0;
//solverBuilder.ProblemIsHomogeneous = false;
// Preconditioner
if (precond == Precond.Lumped)
{
solverBuilder.PreconditionerFactory = new LumpedPreconditioner.Factory();
}
else if (precond == Precond.DirichletDiagonal)
{
solverBuilder.PreconditionerFactory = new DiagonalDirichletPreconditioner.Factory();
}
else
{
solverBuilder.PreconditionerFactory = new DirichletPreconditioner.Factory();
}
//TODO: This needs to be implemented for FETI-DP
//// PCG may need to use the exact residual for the comparison with the expected values
//bool residualIsExact = residualConvergence == Residual.Exact;
//ExactPcpgConvergence.Factory exactResidualConvergence = null;
//if (residualIsExact)
//{
// exactResidualConvergence = new ExactPcpgConvergence.Factory(
// CreateSingleSubdomainModel(stiffnessRatio), solverBuilder.DofOrderer,
// (model, solver) => new ProblemStructural(model, solver));
//}
//if (residualIsExact) exactResidualConvergence.InterfaceProblemSolver = interfaceProblemSolver;
// Specify solver for the interface problem
var interfaceSolverBuilder = new FetiDPInterfaceProblemSolver.Builder();
interfaceSolverBuilder.PcgConvergenceStrategyFactory = new ApproximateResidualConvergence.Factory();
interfaceSolverBuilder.PcgConvergenceTolerance = pcgConvergenceTolerance;
solverBuilder.InterfaceProblemSolver = interfaceSolverBuilder.Build();
FetiDPSolver fetiSolver = solverBuilder.BuildSolver(multiSubdomainModel);
//if (residualIsExact) exactResidualConvergence.FetiSolver = fetiSolver;
// Structural problem provider
var provider = new ProblemStructural(multiSubdomainModel, fetiSolver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(multiSubdomainModel, fetiSolver, provider);
var parentAnalyzer = new StaticAnalyzer(multiSubdomainModel, fetiSolver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Gather the global displacements
var sudomainDisplacements = new Dictionary <int, IVectorView>();
foreach (var ls in fetiSolver.LinearSystems)
{
sudomainDisplacements[ls.Key] = ls.Value.Solution;
}
Vector globalDisplacements = fetiSolver.GatherGlobalDisplacements(sudomainDisplacements);
return(globalDisplacements, fetiSolver.Logger);
}
public void TestEulerBeam2DLinearBendingExample()
{
double youngModulus = 21000.0;
double poissonRatio = 0.3;
double nodalLoad = 2000.0;
int nElems = 2;
int monitorNode = 3;
// Create new material
var material = new ElasticMaterial()
{
YoungModulus = youngModulus,
PoissonRatio = poissonRatio,
};
// Node creation
IList <Node> nodes = new List <Node>();
Node node1 = new Node(id: 1, x: 0.0, y: 0.0, z: 0.0);
Node node2 = new Node(id: 2, x: 100.0, y: 0.0, z: 0.0);
Node node3 = new Node(id: 3, x: 200.0, y: 0.0, z: 0.0);
nodes.Add(node1);
nodes.Add(node2);
nodes.Add(node3);
// Model creation
Model model = new Model();
// Add a single subdomain to the model
model.SubdomainsDictionary.Add(1, new Subdomain(1));
// Add nodes to the nodes dictonary of the model
for (int i = 0; i < nodes.Count; ++i)
{
model.NodesDictionary.Add(i + 1, nodes[i]);
}
// Constrain bottom nodes of the model
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationX
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationY
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationZ
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationX
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationY
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationZ
});
// Generate elements of the structure
int iNode = 1;
for (int iElem = 0; iElem < nElems; iElem++)
{
// Create new Beam2D section and element
var beam = new EulerBeam2D(youngModulus)
{
Density = 7.85,
SectionArea = 91.04,
MomentOfInertia = 8091.00,
};
// Create elements
var element = new Element()
{
ID = iElem + 1,
ElementType = beam
};
// Add nodes to the created element
element.AddNode(model.NodesDictionary[iNode]);
element.AddNode(model.NodesDictionary[iNode + 1]);
var a = beam.StiffnessMatrix(element);
// Add Hexa element to the element and subdomains dictionary of the model
model.ElementsDictionary.Add(element.ID, element);
model.SubdomainsDictionary[1].Elements.Add(element);
iNode++;
}
// Add nodal load values at the top nodes of the model
model.Loads.Add(new Load()
{
Amount = nodalLoad, Node = model.NodesDictionary[monitorNode], DOF = StructuralDof.TranslationY
});
// Solver
//var solverBuilder = new MSolve.Solvers.Iterative.PcgSolver.Builder(
// (new LinearAlgebra.Iterative.ConjugateGradient.PcgAlgorithm.Builder()).Build());
//var solver = solverBuilder.BuildSolver(model);
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Problem type
var provider = new ProblemStructural(model, solver);
// Analyzers
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Run the anlaysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
double solutionNorm = solver.LinearSystems[1].Solution.Norm2();
double rhsNorm = solver.LinearSystems[1].RhsVector.Norm2();
Assert.Equal(31.388982074929341, solver.LinearSystems[1].Solution[4], 12);
}
public static void Run()
{
double youngModulus = 200.0e06;
double poissonRatio = 0.3;
double nodalLoad = 25.0;
// Create a new elastic 3D material
var material = new ElasticMaterial()
{
YoungModulus = youngModulus,
PoissonRatio = poissonRatio,
};
// Node creation
IList <Node> nodes = CreateNodes();
// Model creation
Model model = new Model();
// Add a single subdomain to the model
model.SubdomainsDictionary.Add(0, new Subdomain(subdomainID));
// Add nodes to the nodes dictonary of the model
for (int i = 0; i < nodes.Count; ++i)
{
model.NodesDictionary.Add(i + 1, nodes[i]);
}
// Constrain bottom nodes of the model
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationX
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationY
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationZ
});
model.NodesDictionary[2].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationY, Amount = -4.16666666666667E-07
});
//Create a new Beam2D element
var beam = new EulerBeam2D(youngModulus)
{
SectionArea = 1,
MomentOfInertia = .1
};
var element = new Element()
{
ID = 1,
ElementType = beam
};
//// Add nodes to the created element
element.AddNode(model.NodesDictionary[1]);
element.AddNode(model.NodesDictionary[2]);
//var a = beam.StiffnessMatrix(element);
// Add Hexa element to the element and subdomains dictionary of the model
model.ElementsDictionary.Add(element.ID, element);
model.SubdomainsDictionary[subdomainID].Elements.Add(element);
// Add nodal load values at the top nodes of the model
//model.Loads.Add(new Load() { Amount = -nodalLoad, Node = model.NodesDictionary[2], DOF = DOFType.Y });
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Structural problem provider
var provider = new ProblemStructural(model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Output requests
var logFactory = new TotalDisplacementsLog.Factory(model.SubdomainsDictionary[subdomainID]);
logFactory.WatchDof(model.NodesDictionary[2], StructuralDof.TranslationX);
logFactory.WatchDof(model.NodesDictionary[2], StructuralDof.RotationZ);
childAnalyzer.LogFactories[subdomainID] = logFactory;
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Choose dof types X, Y, rotZ to log for node 5
var logger = (TotalDisplacementsLog)(childAnalyzer.Logs[subdomainID][0]); //There is a list of logs for each subdomain and we want the first one
double[] results =
{
logger.GetDisplacementAt(model.NodesDictionary[2], StructuralDof.TranslationX),
logger.GetDisplacementAt(model.NodesDictionary[2], StructuralDof.RotationZ)
};
double[] expected = new double[] { 0, -4.16666666666667E-07, -6.25E-07 };
for (int i = 0; i < expected.Length - 1; i++)
{
//if (Math.Abs(expected[i] - results[i]) > 1e-14)
//{
// throw new SystemException("Failed beam2D test, results don't coincide for dof no: " + i + ", expected displacement: " + expected[i] + ", calculated displacement: " + results[i]);
//}
Console.WriteLine(results[i]);
}
Console.WriteLine("ran beam2d2 test");
}
private static IVectorView[] SolveModelsWithNewmark(Model[] models, IModelReader[] modelReaders)
{
Vector[] initialValues = new Vector[models.Length];
var value0 = new Dictionary <int, double[]>();
for (int i = 0; i < models.Length; i++)
{
double[] v0 = new double[models[i].Nodes.Count];
value0.Add(i, v0);
}
foreach (Node node in models[0].Nodes)
{
value0[0][node.ID] = 1;
}
DenseMatrixSolver[] solvers = new DenseMatrixSolver[models.Length];
IConvectionDiffusionIntegrationProvider[] providers = new IConvectionDiffusionIntegrationProvider[models.Length];
IChildAnalyzer[] childAnalyzers = new IChildAnalyzer[models.Length];
for (int i = 0; i < models.Length; i++)
{
initialValues[i] = Vector.CreateFromArray(value0[i]);
//var builder = new DenseMatrixSolver.Builder();
builder.IsMatrixPositiveDefinite = false;
solvers[i] = builder.BuildSolver(models[i]);
providers[i] = new ProblemConvectionDiffusion2(models[i], solvers[i]);
childAnalyzers[i] = new LinearAnalyzer(models[i], solvers[i], providers[i]);
}
const double timestep = .1;
const double time = 3;
var parentAnalyzer = new ConvectionDiffusionImplicitDynamicAnalyzerMultiModel(UpdateModels, models, solvers,
providers, childAnalyzers, timestep, time, initialTemperature: initialValues);
parentAnalyzer.Initialize();
//var structuralModel = CreateStructuralModel(10.5e3, 0, new DynamicMaterial(.001, 0, 0, true), 0, new double[] { 0, 0, 25000 }, lambdag).Item1; // new Model();
DynamicMaterial[] dynamicMaterials = new DynamicMaterial[] { new DynamicMaterial(1000, 0, 0, true) };
var structuralModel = CreateStructuralModel(new double[] { 1 }, new double[] { 1 }, dynamicMaterials, 0, new double[] { 0, 0, 2500 }, lambdag).Item1; // new Model();
var structuralSolver = structuralBuilder.BuildSolver(structuralModel);
var structuralProvider = new ProblemStructural(structuralModel, structuralSolver);
//var structuralChildAnalyzer = new LinearAnalyzer(structuralModel, structuralSolver, structuralProvider);
var increments = 2;
var structuralChildAnalyzerBuilder = new LoadControlAnalyzer.Builder(structuralModel, structuralSolver, structuralProvider, increments);
structuralChildAnalyzerBuilder.ResidualTolerance = 1E-6;
structuralChildAnalyzerBuilder.MaxIterationsPerIncrement = 50;
structuralChildAnalyzerBuilder.NumIterationsForMatrixRebuild = 1;
//childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default
LoadControlAnalyzer structuralChildAnalyzer = structuralChildAnalyzerBuilder.Build();
var structuralParentAnalyzer = new NewmarkDynamicAnalyzer(UpdateNewmarkModel, structuralModel, structuralSolver,
structuralProvider, structuralChildAnalyzer, timestep, time, 0.25, 0.5);
structuralParentAnalyzer.Initialize();
for (int i = 0; i < time / timestep; i++)
{
parentAnalyzer.SolveTimestep(i);
structuralParentAnalyzer.SolveTimestep(i);
}
return(solvers.Select(x => x.LinearSystems[subdomainID].Solution).ToArray());
}
public void LinearElasticBeam2DNewmarkDynamicAnalysisTest()
{
double youngModulus = 21000;
double poissonRatio = 0.3;
double area = 91.04;
double inertiaY = 2843.0;
double inertiaZ = 8091.0;
double density = 7.85;
double nodalLoad = 1000.0;
int totalNodes = 2;
var material = new ElasticMaterial()
{
YoungModulus = youngModulus,
PoissonRatio = poissonRatio,
};
// Node creation
IList <Node> nodes = new List <Node>();
Node node1 = new Node(id: 1, x: 0.0, y: 0.0, z: 0.0);
Node node2 = new Node(id: 2, x: 300.0, y: 0.0, z: 0.0);
nodes.Add(node1);
nodes.Add(node2);
// Model creation
Model model = new Model();
// Add a single subdomain to the model
model.SubdomainsDictionary.Add(1, new Subdomain(1));
// Add nodes to the nodes dictonary of the model
for (int i = 0; i < nodes.Count; ++i)
{
model.NodesDictionary.Add(i + 1, nodes[i]);
}
// Constrain bottom nodes of the model
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationX
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationY
});
model.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationZ
});
// Create a new Beam2D element
var beam = new EulerBeam2D(youngModulus)
{
Density = density,
SectionArea = area,
MomentOfInertia = inertiaZ
};
var element = new Element()
{
ID = 1,
ElementType = beam
};
// Add nodes to the created element
element.AddNode(model.NodesDictionary[1]);
element.AddNode(model.NodesDictionary[2]);
// Element Stiffness Matrix
var a = beam.StiffnessMatrix(element);
var b = beam.MassMatrix(element);
// Add Hexa element to the element and subdomains dictionary of the model
model.ElementsDictionary.Add(element.ID, element);
model.SubdomainsDictionary[1].Elements.Add(element);
// define loads
model.Loads.Add(new Load {
Amount = nodalLoad, Node = model.NodesDictionary[totalNodes], DOF = StructuralDof.TranslationY
});
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Problem type
var provider = new ProblemStructural(model, solver);
// Analyzers
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 0.28, 3.36);
parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration(); // Not necessary. This is the default
NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
Assert.Equal(2.2840249264795207, solver.LinearSystems[1].Solution[1], 8);
}
public void IsogeometricCantileverShell()
{
Model model = new Model();
string filename = "..\\..\\..\\MGroup.IGA.Tests\\InputFiles\\CantileverShell.txt";
IsogeometricShellReader modelReader = new IsogeometricShellReader(model, filename);
modelReader.CreateShellModelFromFile();
model.Loads.Add(new Load()
{
Amount = -1,
Node = model.ControlPointsDictionary[9],
DOF = StructuralDof.TranslationZ
});
model.Loads.Add(new Load()
{
Amount = -1,
Node = model.ControlPointsDictionary[10],
DOF = StructuralDof.TranslationZ
});
model.Loads.Add(new Load()
{
Amount = -1,
Node = model.ControlPointsDictionary[11],
DOF = StructuralDof.TranslationZ
});
for (int i = 0; i < 6; i++)
{
model.ControlPointsDictionary[i].Constraints.Add(new Constraint()
{
DOF = StructuralDof.TranslationX
});
model.ControlPointsDictionary[i].Constraints.Add(new Constraint()
{
DOF = StructuralDof.TranslationY
});
model.ControlPointsDictionary[i].Constraints.Add(new Constraint()
{
DOF = StructuralDof.TranslationZ
});
}
// Solvers
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Structural problem provider
var provider = new ProblemStructural(model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
var expectedSolution = new double[18]
{
0.0, 0.0, -7499.999986865148, 0.0, 0.0, -7499.99998660616, 0.0, 0.0, -7499.999986347174, 0.0, 0.0,
-14999.999980230163, 0.0, 0.0, -14999.999980050825, 0.0, 0.0, -14999.999979871487
};
for (int i = 0; i < expectedSolution.Length; i++)
{
Utilities.AreValuesEqual(expectedSolution[i], solver.LinearSystems[0].Solution[i], 7);
}
}
public void TestEulerBeam2DLinearBendingExample()
{
// Model and node creation
var model = new Model();
model.NodesDictionary.Add(1, new Node {
ID = 1, X = 0.0, Y = 0.0, Z = 0.0
});
model.NodesDictionary.Add(2, new Node {
ID = 2, X = 100.0, Y = 0.0, Z = 0.0
});
model.NodesDictionary.Add(3, new Node {
ID = 3, X = 200.0, Y = 0.0, Z = 0.0
});
// Constrain bottom node and add nodal load value
model.NodesDictionary[1].Constraints.AddRange(new[] { DOFType.X, DOFType.Y, DOFType.Z, DOFType.RotZ });
model.Loads.Add(new Load()
{
Amount = 2000, Node = model.NodesDictionary[3], DOF = DOFType.Y
});
// Generate elements of the structure
for (int iElem = 0; iElem < 2; iElem++)
{
// Create new Beam2D section and element
var elementType = new EulerBeam2D(2.1e4)
{
Density = 7.85,
SectionArea = 91.04,
MomentOfInertia = 8091.00
};
// Create the element connectivity
var element = new Element()
{
ID = iElem + 1
};
element.AddNode(model.NodesDictionary[iElem + 1]);
element.AddNode(model.NodesDictionary[iElem + 2]);
element.ElementType = elementType;
// Add beam element to the element and subdomains dictionary of the model
model.ElementsDictionary.Add(element.ID, element);
}
// Needed in order to make all the required data structures
model.ConnectDataStructures();
// Setup
var linearSystem = new SkylineLinearSystem(model.Forces);
var solver = new SolverSkyline(linearSystem);
var provider = new ProblemStructural(model);
var childAnalyzer = new LinearAnalyzer(solver);
var parentAnalyzer = new StaticAnalyzer(provider, childAnalyzer, linearSystem);
parentAnalyzer.BuildMatrices();
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Tests if calculated solution meets expected
var expectedSolution = new double[] { 0, 9.80905689841542, 0.17656302417147754, 0, 31.388982074929341, 0.23541736556197002 };
for (int i = 0; i < expectedSolution.Length; i++)
{
Assert.Equal(expectedSolution[i], linearSystem.Solution[i], 12);
}
}
public void IsogeometricSquareShell()
{
Model model = new Model();
var filename = "SquareShell";
string filepath = $"..\\..\\..\\MGroup.IGA.Tests\\InputFiles\\{filename}.txt";
IsogeometricShellReader modelReader = new IsogeometricShellReader(model, filepath);
modelReader.CreateShellModelFromFile();
Matrix <double> loadVector =
MatlabReader.Read <double>("..\\..\\..\\MGroup.IGA.Tests\\InputFiles\\SquareShell.mat", "LoadVector");
for (int i = 0; i < loadVector.ColumnCount; i += 3)
{
var indexCP = i / 3;
model.Loads.Add(new Load()
{
Amount = loadVector.At(0, i),
Node = model.ControlPointsDictionary[indexCP],
DOF = StructuralDof.TranslationX
});
model.Loads.Add(new Load()
{
Amount = loadVector.At(0, i + 1),
Node = model.ControlPointsDictionary[indexCP],
DOF = StructuralDof.TranslationY
});
model.Loads.Add(new Load()
{
Amount = loadVector.At(0, i + 2),
Node = model.ControlPointsDictionary[indexCP],
DOF = StructuralDof.TranslationZ
});
}
foreach (var edge in model.PatchesDictionary[0].EdgesDictionary.Values)
{
foreach (var controlPoint in edge.ControlPointsDictionary.Values)
{
model.ControlPointsDictionary[controlPoint.ID].Constraints.Add(new Constraint()
{
DOF = StructuralDof.TranslationX
});
model.ControlPointsDictionary[controlPoint.ID].Constraints.Add(new Constraint()
{
DOF = StructuralDof.TranslationY
});
model.ControlPointsDictionary[controlPoint.ID].Constraints.Add(new Constraint()
{
DOF = StructuralDof.TranslationZ
});
}
}
// Solvers
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Structural problem provider
var provider = new ProblemStructural(model, solver);
// Linear static analysis
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
//var paraview = new ParaviewNurbsShells(model, solver.LinearSystems[0].Solution, filename);
//paraview.CreateParaview2DFile();
Matrix <double> solutionVectorExpected =
MatlabReader.Read <double>("..\\..\\..\\MGroup.IGA.Tests\\InputFiles\\SquareShell.mat", "SolutionVector");
for (int i = 0; i < solutionVectorExpected.ColumnCount; i++)
{
Assert.True(Utilities.AreValuesEqual(solutionVectorExpected.At(0, i), solver.LinearSystems[0].Solution[i],
1e-9));
}
}
