private static IVectorView SolveModel(Model model, IModelReader modelReader)
{
var builder = new SkylineSolver.Builder();
//builder.IsMatrixPositiveDefinite = false;
var solver = builder.BuildSolver(model);
const double timestep = 1;
const double time = 100;
var provider = new ProblemStructural(model, solver);
var increments = 2;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments);
childAnalyzerBuilder.ResidualTolerance = 1E-6;
childAnalyzerBuilder.MaxIterationsPerIncrement = 50;
childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1;
LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
//var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, timestep, time);
//parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration();
//NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();
var parentAnalyzer = new NewmarkDynamicAnalyzer(UpdateNewmarkModel, model, solver,
provider, childAnalyzer, timestep, time, .25, .5);
parentAnalyzer.Initialize();
for (int i = 0; i < time / timestep; i++)
{
//lambdag = .01 * i + 1;
parentAnalyzer.SolveTimestep(i);
}
return(solver.LinearSystems[subdomainID].Solution);
}
private static void SolveLinearStatic(Model model)
{
// Choose linear equation system 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);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Logging displacement, strain, and stress fields.
string outputDirectory = workingDirectory + "\\Plots";
childAnalyzer.LogFactories[0] = new VtkLogFactory(model, outputDirectory)
{
LogDisplacements = true,
LogStrains = true,
LogStresses = true,
VonMisesStressCalculator = new PlaneStressVonMises()
};
// Run the analysis
parentAnalyzer.BuildMatrices();
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
}
private static void SolveBuildingInNoSoilSmall()
{
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.Loads.Add(new Load()
{
Amount = -100, Node = model.Nodes[21], DOF = DOFType.X
});
model.ConnectDataStructures();
SolverSkyline solver = new SolverSkyline(model);
ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary);
LinearAnalyzer analyzer = new LinearAnalyzer(solver, solver.SubdomainsDictionary);
StaticAnalyzer parentAnalyzer = new StaticAnalyzer(provider, analyzer, solver.SubdomainsDictionary);
analyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 420 });
parentAnalyzer.BuildMatrices();
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
}
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(3e4, 0, new DynamicMaterial(.001, 0, 0, true), 0, new double[] { 1000, 0, 0 }, 1).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, .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 static void SuiteSparseMemoryConsumptionDebugging()
{
for (int rep = 0; rep < 10; ++rep)
{
var benchmarkBuilder = new CantileverBeam.Builder();
//benchmarkBuilder.Length = 5.0;
CantileverBeam benchmark = benchmarkBuilder.BuildWithQuad4Elements(2000, 100);
// Solver
var solverBuilder = new SuiteSparseSolver.Builder();
using (SuiteSparseSolver solver = solverBuilder.BuildSolver(benchmark.Model))
{
// 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();
}
}
}
public static void CheckSubmatrices()
{
double tolerance = 1E-10;
Model model = CreateModel();
int id = model.Subdomains.First().ID;
var solver = (new SkylineSolver.Builder()).BuildSolver(model);
var problem = new ProblemStructural(model, solver);
// Prepare model
model.ConnectDataStructures();
// Order dofs and initialize linear system
solver.OrderDofs(true);
ILinearSystem linearSystem = solver.LinearSystems.First().Value;
linearSystem.Reset(); // Necessary to define the linear system's size
// Build and assign global matrices
(IMatrixView Kff, IMatrixView Kfc, IMatrixView Kcf, IMatrixView Kcc) =
problem.CalculateSubMatrices(model.Subdomains.First());
// Checks
Assert.True(expectedKff.Equals(Kff, tolerance));
Assert.True(expectedKcf.Transpose().Equals(Kfc, tolerance));
Assert.True(expectedKcf.Equals(Kcf, tolerance));
Assert.True(expectedKcc.Equals(Kcc, tolerance));
}
public static void CheckStaticCondensation()
{
double tolerance = 1E-10;
Model model = CreateModel();
int id = model.Subdomains.First().ID;
var solver = (new SkylineSolver.Builder()).BuildSolver(model);
var problem = new ProblemStructural(model, solver);
// Prepare model
model.ConnectDataStructures();
// Order dofs and initialize linear system
solver.OrderDofs(true);
ILinearSystem linearSystem = solver.LinearSystems.First().Value;
linearSystem.Reset(); // Necessary to define the linear system's size
// Build and assign global matrices
(IMatrixView Kff, IMatrixView Kfc, IMatrixView Kcf, IMatrixView Kcc) =
problem.CalculateSubMatrices(model.Subdomains.First());
linearSystem.Matrix = Kff;
// Static condensation: Kcondensed = Kcc - Kcf * inv(Kff) * Kfc
Dictionary <int, Matrix> invKffTimesKfc = solver.InverseSystemMatrixTimesOtherMatrix(
new Dictionary <int, IMatrixView>()
{
{ id, Kfc }
});
IMatrixView condensedK = Kcc.Subtract(Kcf.MultiplyRight(invKffTimesKfc[id]));
// Checks
Assert.True(expectedCondensedK.Equals(condensedK, tolerance));
}
private static void SolveBuildingInNoSoilSmallVRFStochastic()
{
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.Loads.Add(new Load()
{
Amount = -100, Node = model.Nodes[21], DOF = DOFType.X
});
model.ConnectDataStructures();
PowerSpectrumTargetEvaluatorCoefficientsProvider stochasticProvider = new PowerSpectrumTargetEvaluatorCoefficientsProvider(10, 0.1, 1.2, 20, 200, DOFType.X,
0.1, 200, 1e-10);
SolverSkyline solver = new SolverSkyline(model);
ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary);
LinearAnalyzer analyzer = new LinearAnalyzer(solver, solver.SubdomainsDictionary);
StaticAnalyzer childAnalyzer = new StaticAnalyzer(provider, analyzer, solver.SubdomainsDictionary);
VRFMonteCarloAnalyzerWithStochasticMaterial stochasticAnalyzer = new VRFMonteCarloAnalyzerWithStochasticMaterial(model, provider, childAnalyzer, solver.SubdomainsDictionary,
stochasticProvider, stochasticProvider, 1, 20, "monteCarlo");
analyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 420 });
//stochasticAnalyzer.BuildMatrices();
//childAnalyzer.Initialize();
stochasticAnalyzer.Solve();
}
/// <summary>
/// Creates an instance that uses a specific problem type and an appropriate child analyzer for the construction of the system of equations arising from the actual physical problem
/// </summary>
/// <param name="provider">Instance of the problem type to be solver</param>
/// <param name="childAnalyzer">Instance of the child analyzer that will handle the solution of the system of equations</param>
/// <param name="linearSystem">Instance of the linear system that will be initialized</param>
public StaticAnalyzer(ProblemStructural provider, LinearAnalyzer childAnalyzer, SkylineLinearSystem linearSystem)
{
this.provider = provider;
this.ChildAnalyzer = childAnalyzer;
this.ChildAnalyzer.ParentAnalyzer = this;
this.linearSystem = linearSystem;
}
public static void TestSolver()
{
// Setup the model and solver
Model model = Quads4x4MappingMatricesTests.CreateModel();
Dictionary <int, HashSet <INode> > cornerNodes = Quads4x4MappingMatricesTests.DefineCornerNodes(model);
var fetiMatrices = new DenseFetiDPSubdomainMatrixManager.Factory();
var cornerNodeSelection = new UsedDefinedCornerNodes(cornerNodes);
var solver = new FetiDPSolver.Builder(cornerNodeSelection, fetiMatrices).BuildSolver(model);
var problem = new ProblemStructural(model, solver);
var linearAnalyzer = new LinearAnalyzer(model, solver, problem);
var staticAnalyzer = new StaticAnalyzer(model, solver, problem, linearAnalyzer);
// Run the analysis
staticAnalyzer.Initialize();
staticAnalyzer.Solve();
// Gather the global displacements
var sudomainDisplacements = new Dictionary <int, IVectorView>();
foreach (var ls in solver.LinearSystems)
{
sudomainDisplacements[ls.Key] = ls.Value.Solution;
}
Vector globalU = solver.GatherGlobalDisplacements(sudomainDisplacements);
// Check against expected solution
double tol = 1E-7;
Assert.True(SolutionGlobalDisplacements.Equals(globalU, tol));
}
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 element = new EulerBeam2D(2.1e4)
{
ID = iElem + 1, Density = 7.85, SectionArea = 91.04, MomentOfInertia = 8091.00
};
element.ElementType = element;
// Add nodes to the created element
element.AddNode(model.NodesDictionary[iElem + 1]);
element.AddNode(model.NodesDictionary[iElem + 2]);
// Add Hexa 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 SolveNLBeam()
{
var m = new Model();
m.NodesDictionary.Add(1, new Node(id: 1, x: 0, y: 0, z: 0));
m.NodesDictionary.Add(2, new Node(id: 2, x: 5, y: 0, z: 0));
m.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationX
});
m.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationY
});
m.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationZ
});
m.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationX
});
m.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationY
});
m.NodesDictionary[1].Constraints.Add(new Constraint {
DOF = StructuralDof.RotationZ
});
m.ElementsDictionary.Add(1, new Element()
{
ID = 1,
ElementType = new Beam3DCorotationalQuaternion(m.Nodes, new ElasticMaterial3D()
{
YoungModulus = 2.1e6, PoissonRatio = 0.2
}, 1,
new BeamSection3D(0.06, 0.0002, 0.00045, 0.000818, 0.05, 0.05))
});
m.ElementsDictionary[1].AddNodes(m.Nodes);
m.SubdomainsDictionary.Add(1, new Subdomain(1));
m.SubdomainsDictionary[1].Elements.Add(m.ElementsDictionary[1]);
m.Loads.Add(new Load()
{
Node = m.NodesDictionary[2], Amount = 100, DOF = StructuralDof.TranslationY
});
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(m);
// Problem type
var provider = new ProblemStructural(m, solver);
// Analyzers
int increments = 10;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(m, solver, provider, increments);
//childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default
LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
var parentAnalyzer = new StaticAnalyzer(m, solver, provider, childAnalyzer);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
}
public void ContinuumElement3DNonLinearVonMisesMaterialDynamicConsistent()
{
IList <Node> nodes = new List <Node>();
// Create Model
var model = new Model();
// Create Subdomain
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
// Create von Mises Plastic Material
var solidMaterial = new VonMisesMaterial3D(youngModulus, poissonRatio, yieldStress, plasticModulus);
// Create Dynamic Material
var dynamicMaterial = new DynamicMaterial(density, 0, 0, true);
DefineContinuumElement3DNonLinear(model, solidMaterial, dynamicMaterial);
BoundaryConditionsNLM(model);
// Choose linear equation system solver
var solverBuilder = new SkylineSolver.Builder();
SkylineSolver solver = solverBuilder.BuildSolver(model);
// Choose the provider of the problem -> here a structural problem
var provider = new ProblemStructural(model, solver);
// Choose child analyzer -> Child: NewtonRaphson - LoadControl
var subdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) };
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments)
{
MaxIterationsPerIncrement = 50,
NumIterationsForMatrixRebuild = 1,
ResidualTolerance = 1E-06,
};
var childAnalyzer = childAnalyzerBuilder.Build();
// Choose parent analyzer -> Parent: Static
var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 1.0, 100.0);
parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration();
NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();
// Request output
childAnalyzer.LogFactories[subdomainID] = new LinearAnalyzerLogFactory(new int[] { monitorDof });
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Check output
DOFSLog log = (DOFSLog)childAnalyzer.Logs[subdomainID][0];
double computedValue = log.DOFValues[monitorDof];
double expectedValue = 1.93737;
Assert.Equal(expectedValue, computedValue, 2);
}
public void TestSolveHexaCantileverBeam()
{
var model = new Model();
model.SubdomainsDictionary.Add(1, new Subdomain(1));
HexaSimpleCantileverBeam.MakeCantileverBeam(model, 0, 0, 0, model.NodesDictionary.Count + 1, model.ElementsDictionary.Count + 1, 1);
model.Loads.Add(new Load()
{
Amount = -0.25, Node = model.Nodes[16], DOF = StructuralDof.TranslationZ
});
model.Loads.Add(new Load()
{
Amount = -0.25, Node = model.Nodes[17], DOF = StructuralDof.TranslationZ
});
model.Loads.Add(new Load()
{
Amount = -0.25, Node = model.Nodes[18], DOF = StructuralDof.TranslationZ
});
model.Loads.Add(new Load()
{
Amount = -0.25, Node = model.Nodes[19], DOF = StructuralDof.TranslationZ
});
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
var provider = new ProblemStructural(model, solver);
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
//childAnalyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 47 });
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
double[] expectedDisplacements = new double[]
{
-0.0000025899520106, -0.0000004898560318, -0.0000031099520106, -0.0000025899520106, 0.0000004898560318,
-0.0000031099520106, 0.0000025899520106, 0.0000004898560318, -0.0000031099520106, 0.0000025899520106,
-0.0000004898560318, -0.0000031099520106, -0.0000045673419128, -0.0000002423136749, -0.0000107872459340,
-0.0000045673419128, 0.0000002423136749, -0.0000107872459340, 0.0000045673419128, 0.0000002423136749,
-0.0000107872459340, 0.0000045673419128, -0.0000002423136749, -0.0000107872459340, -0.0000057299058132,
-0.0000001253780263, -0.0000216044936601, -0.0000057299058132, 0.0000001253780263, -0.0000216044936601,
0.0000057299058132, 0.0000001253780263, -0.0000216044936601, 0.0000057299058132, -0.0000001253780263,
-0.0000216044936601, -0.0000061325564473, -0.0000000425738760, -0.0000339869559207, -0.0000061325564473,
0.0000000425738760, -0.0000339869559207, 0.0000061325564473, 0.0000000425738760, -0.0000339869559207,
0.0000061325564473, -0.0000000425738760, -0.0000339869559207
};
for (int i = 0; i < expectedDisplacements.Length; i++)
{
Assert.Equal(expectedDisplacements[i], solver.LinearSystems[1].Solution[i], 10);
}
}
public static void EmbeddedEBEinMatrix_NewtonRaphson()
{
// Model creation
var model = new Model();
// Subdomains
//model.SubdomainsDictionary.Add(subdomainID, new Subdomain() { ID = 1 });
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
// Variables
int monitorNode = 41;
IDofType monitorDof = StructuralDof.TranslationZ;
// Choose model
EmbeddedEBEModelBuilder.EmbeddedExampleBuilder(model);
//-----------------------------------------------------------------------------------------------------------
// Model
// Choose linear equation system solver
//var solverBuilder = new SkylineSolver.Builder();
//SkylineSolver solver = solverBuilder.BuildSolver(model);
var solverBuilder = new SuiteSparseSolver.Builder();
SuiteSparseSolver solver = solverBuilder.BuildSolver(model);
// Choose the provider of the problem -> here a structural problem
var provider = new ProblemStructural(model, solver);
// Choose child analyzer -> Child: NewtonRaphsonNonLinearAnalyzer
int increments = 100;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments)
{
ResidualTolerance = 1E-03, MaxIterationsPerIncrement = 10
};
LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
// Choose parent analyzer -> Parent: Static
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Request output
string outputFile = outputDirectory + "\\CNT-Embedded-3D_Results.txt";
var logger = new TotalLoadsDisplacementsPerIncrementLog(model.SubdomainsDictionary[subdomainID], increments,
model.NodesDictionary[monitorNode], monitorDof, outputFile);
childAnalyzer.IncrementalLogs.Add(subdomainID, logger);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Create Paraview File
var paraview = new ParaviewEmbedded3D(model, solver.LinearSystems[0].Solution, "test");
paraview.CreateParaviewFile();
}
/// <summary>Evaluates the specified iteration.</summary>
/// <param name="iteration">The iteration.</param>
/// <returns></returns>
public double[] Evaluate(int iteration)
{
var solver = new SkylineSolver.Builder().BuildSolver(currentModel);
var provider = new ProblemStructural(currentModel, solver);
var childAnalyzer = new LinearAnalyzer(currentModel, solver, provider);
var parentAnalyzer = new StaticAnalyzer(currentModel, solver, provider, childAnalyzer);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(new[] { solver.LinearSystems[0].Solution[56], solver.LinearSystems[0].Solution[58] });
}
public static void TestSolver()
{
// Setup the model
double stiffnessRatio = 1E-2; // Do not change this! The expected solution is taken for this value
Model model = CreateModel(stiffnessRatio);
Dictionary <int, HashSet <INode> > cornerNodes = Quads4x4MappingMatricesTests.DefineCornerNodes(model);
// Setup solver
var interfaceSolverBuilder = new FetiDPInterfaceProblemSolver.Builder();
interfaceSolverBuilder.PcgConvergenceTolerance = 1E-7;
//var fetiMatrices = new SkylineFetiDPSubdomainMatrixManager.Factory();
var fetiMatrices = new DenseFetiDPSubdomainMatrixManager.Factory();
var cornerNodeSelection = new UsedDefinedCornerNodes(cornerNodes);
var fetiSolverBuilder = new FetiDPSolver.Builder(cornerNodeSelection, fetiMatrices);
fetiSolverBuilder.InterfaceProblemSolver = interfaceSolverBuilder.Build();
fetiSolverBuilder.ProblemIsHomogeneous = false;
fetiSolverBuilder.PreconditionerFactory = new DirichletPreconditioner.Factory();
FetiDPSolver fetiSolver = fetiSolverBuilder.BuildSolver(model);
// Run the analysis
var problem = new ProblemStructural(model, fetiSolver);
var linearAnalyzer = new LinearAnalyzer(model, fetiSolver, problem);
var staticAnalyzer = new StaticAnalyzer(model, fetiSolver, problem, linearAnalyzer);
staticAnalyzer.Initialize();
staticAnalyzer.Solve();
// Gather the global displacements
var sudomainDisplacements = new Dictionary <int, IVectorView>();
foreach (var ls in fetiSolver.LinearSystems)
{
sudomainDisplacements[ls.Key] = ls.Value.Solution;
}
Vector globalU = fetiSolver.GatherGlobalDisplacements(sudomainDisplacements);
// Check against expected solution
double tol = 1E-7;
var globalUExpected = Vector.CreateFromArray(new double[]
{
17.623494584618864, 12.564560593215612, 31.832863897135404, 34.496634608059082, 40.255481382985629,
66.49190654178912, 42.572002358887204, 99.798764204232072, 4.267568672307144, 9.00506902466324,
9.100928263505315, 31.107370029452451, 12.1615036308774, 66.065492717632239, 11.510673148931499,
102.06649895017948, -3.0529124682202156, 9.24107474483673, -7.8531777412741217, 26.728892403726846,
-16.890006178831449, 70.602493468916791, -21.80233265288679, 109.39882637058051, -4.7311061272016808,
10.030926199331375, -5.6722429958962142, 18.837815470700932, 146.94209278892487, 392.04674590737193,
-35.619167413693908, 1407.200332011206, -9.9609496807814057, 10.46574373452243, -17.603838651152756,
20.760800663270086, -843.13592713307355, 371.10700308359418, -1666.2547486301742, 3714.1637893447919
});
Assert.True(globalUExpected.Equals(globalU, tol));
}
public void ContinuumElement3DElasticMaterialDynamicConsistent()
{
IList <Node> nodes = new List <Node>();
// Create Model
var model = new Model();
// Create Subdomain
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
// Create Elastic Material
var solidMaterial = new ElasticMaterial3D()
{
YoungModulus = youngModulus,
PoissonRatio = poissonRatio,
};
// Create Dynamic Material
var dynamicMaterial = new DynamicMaterial(density, 0, 0, true);
DefineContinuumElement3DLinear(model, solidMaterial, dynamicMaterial);
BoundaryConditions(model);
// Choose linear equation system solver
var solverBuilder = new SkylineSolver.Builder();
SkylineSolver solver = solverBuilder.BuildSolver(model);
// Choose the provider of the problem -> here a structural problem
var provider = new ProblemStructural(model, solver);
// Choose child analyzer -> Linear
var childAnalyzer = new LinearAnalyzer(model, solver, provider);
// Choose parent analyzer -> Parent: Static
var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 1.0, 100.0);
parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration();
NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();
// Request output
childAnalyzer.LogFactories[subdomainID] = new LinearAnalyzerLogFactory(new int[] { monitorDof });
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Check output
DOFSLog log = (DOFSLog)childAnalyzer.Logs[subdomainID][0];
double computedValue = log.DOFValues[monitorDof];
double expectedValue = 0.531178; // consistent: 0.531178 // lumped: 0.894201
Assert.Equal(expectedValue, computedValue, 3);
}
private static double[] SolveModel()
{
var model = new Model();
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
BuildCantileverModel(model, 850);
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Problem type
var provider = new ProblemStructural(model, solver);
// Analyzers
int increments = 2;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments);
childAnalyzerBuilder.ResidualTolerance = 1E-8;
childAnalyzerBuilder.MaxIterationsPerIncrement = 100;
childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1;
//childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default
LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// initialize the anlaysis
parentAnalyzer.Initialize();
// Output
int[] monitoredNodes = new int[] { 6, 8 };
int[] monitoredDofs = monitoredNodes.Select(x => model.GlobalDofOrdering.GlobalFreeDofs[model.NodesDictionary[x], StructuralDof.TranslationX]).ToArray();
var watchDofs = new Dictionary <int, int[]>();
watchDofs.Add(subdomainID, monitoredDofs);
var log1 = new TotalDisplacementsPerIterationLog(watchDofs);
childAnalyzer.TotalDisplacementsPerIterationLog = log1;
//run the analysis and give output
parentAnalyzer.Solve();
var solutionOfIters5And12 = new double[] { log1.GetTotalDisplacement(5, 0, 3), log1.GetTotalDisplacement(12, 0, 3),
log1.GetTotalDisplacement(5, 0, 9), log1.GetTotalDisplacement(12, 0, 9) };
return(solutionOfIters5And12);
}
//public string PlotDirectory { get { return lsmPlotDirectory; } }
public void Analyze(ISolver solver)
{
var problem = new ProblemStructural(Model, solver);
var analyzer = new QuasiStaticCrackPropagationAnalyzer(Model, solver, /*problem,*/ crack, fractureToughness,
maxIterations);
// Subdomain plots
if (subdomainPlotDirectory != null)
{
if (solver is FetiDPSolver fetiDP)
{
analyzer.DDLogger = new DomainDecompositionLoggerFetiDP(fetiDP, subdomainPlotDirectory);
}
else
{
analyzer.DDLogger = new DomainDecompositionLogger(subdomainPlotDirectory);
}
}
analyzer.Initialize();
analyzer.Analyze();
#region crack propagation output
// Write crack path
//Console.WriteLine("Crack path:");
//foreach (var point in crack.CrackPath)
//{
// Console.WriteLine("{0} {1}", point.X, point.Y);
//}
//Console.WriteLine();
// Write growth angles, lengths and SIFs if necessary
//if (writePropagation)
//{
// using (var writer = new StreamWriter(propagationPath))
// {
// PropagationLogger logger = crack.CrackTipPropagators[crack.CrackTips[0]].Logger;
// int numIterations = logger.GrowthAngles.Count;
// writer.WriteLine(numIterations);
// for (int i = 0; i < numIterations; ++i)
// {
// writer.Write(logger.GrowthAngles[i]);
// writer.Write(" " + logger.GrowthLengths[i]);
// writer.Write(" " + logger.SIFsMode1[i]);
// writer.Write(" " + logger.SIFsMode2[i]);
// writer.WriteLine();
// }
// }
//}
#endregion
}
public void Initialize()
{
elementVolumes = CalcElementVolumes();
//TODO: does this work with embedding? What if someone else overwrites the element's property?
for (int e = 0; e < NumElements; ++e)
{
elementTypes[e].DofEnumerator = penalizers[e];
}
problem = new ProblemStructural(model, solver);
linearAnalyzer = new LinearAnalyzer(model, solver, problem);
staticAnalyzer = new StaticAnalyzer(model, solver, problem, linearAnalyzer);
}
//checked: apotelesmata C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\APOTELESMATA_MS_hexa8_cantilever_nea\IntegrationElasticCantileverBenchmark RunExample
//Origin opou htan checked branch example/ms_development_nl_elements_merge
//modifications: egine v2
public static TotalDisplacementsPerIterationLog RunExample()
{
//VectorExtensions.AssignTotalAffinityCount();
Model model = new Model();
int subdomainID = 1; model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
HexaCantileverBuilder_copyMS_222(model, 0.00219881744271988174427);
//model.ConnectDataStructures();
//var linearSystems = new Dictionary<int, ILinearSystem>(); //I think this should be done automatically
//linearSystems[subdomainID] = new SkylineLinearSystem(subdomainID, model.Subdomains[0].Forces);
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Problem type
var provider = new ProblemStructural(model, solver);
//var solver = new SolverSkyline(linearSystems[subdomainID]);
//var linearSystemsArray = new[] { linearSystems[subdomainID] };
//var subdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.Subdomains[0]) };
//var subdomainMappers = new[] { new SubdomainGlobalMapping(model.Subdomains[0]) };
var increments = 2;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments);
childAnalyzerBuilder.MaxIterationsPerIncrement = 100;
childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1;
//childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default
LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
var watchDofs = new Dictionary <int, int[]>();
watchDofs.Add(subdomainID, new int[5] {
0, 11, 23, 35, 47
});
var log1 = new TotalDisplacementsPerIterationLog(watchDofs);
childAnalyzer.TotalDisplacementsPerIterationLog = log1;
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(log1);
}
private static Vector RunAnalysis(Model model)
{
// Setup analysis
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();
return(linearSystem.Solution);
}
/// <summary>Evaluates the specified iteration.</summary>
/// <param name="iteration">The iteration.</param>
/// <returns></returns>
public double[] Evaluate(int iteration)
{
//TODO: Perhaps the analyzer, solver, etc should be reused throughout the MonteCarlo, to avoid recalculating
// connectivity and indexing structures.
var solver = new SkylineSolver.Builder().BuildSolver(currentModel);
var provider = new ProblemStructural(currentModel, solver);
var childAnalyzer = new LinearAnalyzer(currentModel, solver, provider);
var parentAnalyzer = new StaticAnalyzer(currentModel, solver, provider, childAnalyzer);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
//return new[] { linearSystems[0].RHS[0] };
return(new[] { solver.LinearSystems[0].Solution[56], solver.LinearSystems[0].Solution[58] });
}
public static void EmbeddedEBEinMatrix_DisplacementControl()
{
// Model creation
var model = new Model();
// Subdomains
//model.SubdomainsDictionary.Add(subdomainID, new Subdomain() { ID = 1 });
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
// Variables
int monitorNode = 161;
IDofType monitorDof = StructuralDof.TranslationZ;
// Choose model
EmbeddedEBEModelBuilder.EmbeddedExampleBuilder(model);
//-----------------------------------------------------------------------------------------------------------
// Model
// Choose linear equation system solver
//var solverBuilder = new SkylineSolver.Builder();
//SkylineSolver solver = solverBuilder.BuildSolver(model);
var solverBuilder = new SuiteSparseSolver.Builder();
SuiteSparseSolver solver = solverBuilder.BuildSolver(model);
// Choose the provider of the problem -> here a structural problem
var provider = new ProblemStructural(model, solver);
// Choose child analyzer -> Child: DisplacementControl
var subdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) };
int increments = 100;
var childAnalyzerBuilder = new DisplacementControlAnalyzer.Builder(model, solver, provider, increments);
DisplacementControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
// Choose parent analyzer -> Parent: Static
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Request output
string outputFile = outputDirectory + "\\CNT-Embedded-3D_Results.txt";
var logger = new TotalLoadsDisplacementsPerIncrementLog(model.SubdomainsDictionary[subdomainID], increments,
model.NodesDictionary[monitorNode], monitorDof, outputFile);
childAnalyzer.IncrementalLogs.Add(subdomainID, logger);
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
}
private static void UpdateNewmarkModel(Dictionary <int, IVector> accelerations, Dictionary <int, IVector> velocities, Dictionary <int, IVector> displacements, IStructuralModel[] modelsToReplace,
ISolver[] solversToReplace, IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
{
ReplaceLambdaGInModel(modelsToReplace[0], lgElement);
solversToReplace[0] = structuralBuilder.BuildSolver(modelsToReplace[0]);
providersToReplace[0] = new ProblemStructural(modelsToReplace[0], solversToReplace[0]);
//solversToReplace[0].HandleMatrixWillBeSet();
//childAnalyzersToReplace[0] = new LinearAnalyzer(modelsToReplace[0], solversToReplace[0], providersToReplace[0]);
var increments = 2;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(modelsToReplace[0], solversToReplace[0], (INonLinearProvider)providersToReplace[0], increments);
childAnalyzerBuilder.ResidualTolerance = 1E-6;
childAnalyzerBuilder.MaxIterationsPerIncrement = 50;
childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1;
childAnalyzersToReplace[0] = childAnalyzerBuilder.Build();
}
private static void UpdateModels(Dictionary <int, IVector>[] solutions, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace,
IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
{
double[] sol0 = solutions[0][0].CopyToArray();
double[] sol1 = solutions[1][0].CopyToArray();
modelsToReplace[0] = CreateModel(21000, 91.04, 1000.0);
modelsToReplace[1] = CreateModel(21000, 91.04, 1000.0);
for (int i = 0; i < modelsToReplace.Length; i++)
{
//providersToReplace[i].
solversToReplace[i] = builder.BuildSolver(modelsToReplace[i]);
providersToReplace[i] = new ProblemStructural((Model)modelsToReplace[i], solversToReplace[i]);
childAnalyzersToReplace[i] = new LinearAnalyzer(modelsToReplace[i], solversToReplace[i], providersToReplace[i]);
}
}
private static void UpdateNewmarkModel(Dictionary <int, IVector> accelerations, Dictionary <int, IVector> velocities, Dictionary <int, IVector> displacements, IStructuralModel[] modelsToReplace,
ISolver[] solversToReplace, IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
{
double[] sol0 = Solutions[0][0].CopyToArray();
double[] sol1 = Solutions[1][0].CopyToArray();
var load = new double[] { sol1[39], sol1[39], sol1[39] };
IDynamicMaterial commonDynamicMaterialProperties = new DynamicMaterial(.001, 0, 0, true);
Accelerations = accelerations;
Velocities = velocities;
Displacements = displacements;
modelsToReplace[0] = CreateStructuralModel(10e4, 0, commonDynamicMaterialProperties, 0, load).Item1;
solversToReplace[0] = builder.BuildSolver(modelsToReplace[0]);
providersToReplace[0] = new ProblemStructural(modelsToReplace[0], solversToReplace[0]);
childAnalyzersToReplace[0] = new LinearAnalyzer(modelsToReplace[0], solversToReplace[0], providersToReplace[0]);
}
private static void UpdateNewmarkModel(Dictionary <int, IVector> accelerations, Dictionary <int, IVector> velocities, Dictionary <int, IVector> displacements, IStructuralModel[] modelsToReplace,
ISolver[] solversToReplace, IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
{
//double[] disp = displacements[0].CopyToArray();
//Displacements = Vector.CreateFromArray(disp);
IDynamicMaterial commonDynamicMaterialProperties = new DynamicMaterial(.001, 0, 0, true);
//modelsToReplace[0] = CreateModel1(1, 1, new DynamicMaterial(.001, 0, 0, true), 0, new double[] { 0, 0, 200 }, lambdag).Item1;
ReplaceLambdaGInModel(modelsToReplace[0], lambdag);
solversToReplace[0] = builder.BuildSolver(modelsToReplace[0]);
providersToReplace[0] = new ProblemStructural(modelsToReplace[0], solversToReplace[0]);
var increments = 2;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(modelsToReplace[0], solversToReplace[0], (INonLinearProvider)providersToReplace[0], increments);
childAnalyzersToReplace[0] = childAnalyzerBuilder.Build();
}
private static void SolveModel()
{
var model = new Model();
model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));
var load = 850;
BuildCantileverModel(model, load);
// Solver
var solverBuilder = new SkylineSolver.Builder();
ISolver solver = solverBuilder.BuildSolver(model);
// Problem type
var provider = new ProblemStructural(model, solver);
// Analyzers
int increments = 10;
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments);
childAnalyzerBuilder.ResidualTolerance = 1E-5;
childAnalyzerBuilder.MaxIterationsPerIncrement = 100;
childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1;
//childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default
LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Setup displacements log
var watchDof = new Dictionary <int, int[]>();
//watchDof.Add(subdomainID, new int[1] { 46 });
watchDof.Add(subdomainID, new int[1] {
94
});
var log1 = new IncrementalDisplacementsLog(watchDof);
childAnalyzer.IncrementalDisplacementsLog = log1;
// Run the analysis
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
// Write log data to file
WriteDisplacementsToFile(log1, watchDof, load);
}
