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();
}
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 Analyze(Model model, bool loadControl)
{
// 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
NonLinearAnalyzerBase childAnalyzer;
int increments = 10;
if (loadControl)
{
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments);
childAnalyzerBuilder.ResidualTolerance = 1E-3;
childAnalyzer = childAnalyzerBuilder.Build();
}
else
{
var childAnalyzerBuilder = new DisplacementControlAnalyzer.Builder(model, solver, provider, increments);
childAnalyzer = childAnalyzerBuilder.Build();
}
// Choose parent analyzer -> Parent: Static
var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);
// Request output
string outputFile = outputDirectory + "\\load_control_beam2D_corrotational.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();
}
public override void Solve()
{
InitializeLogs();
DateTime start = DateTime.Now;
UpdateInternalVectors();//TODOMaria this divides the externally applied load by the number of increments and scatters it to all subdomains and stores it in the class subdomain dictionary and total external load vector
for (int increment = 0; increment < numIncrements; increment++)
{
double errorNorm = 0;
ClearIncrementalSolutionVector(); //TODOMaria this sets du to 0
UpdateRhs(increment); //TODOMaria this copies the residuals stored in the class dictionary to the subdomains
double firstError = 0;
int iteration = 0;
for (iteration = 0; iteration < maxIterationsPerIncrement; iteration++)
{
if (iteration == 0)
{
var vecs = CalculateInternalRhs(increment, iteration);
UpdateResidualForcesAndNorm(increment, vecs);
}
if (iteration == maxIterationsPerIncrement - 1)
{
return;
}
if (Double.IsNaN(errorNorm))
{
return;
}
solver.Solve();
//double rhsNormIt = solver.LinearSystems.First().Value.RhsVector.Norm2();
//double xNormIt = solver.LinearSystems.First().Value.Solution.Norm2();
Dictionary <int, IVector> internalRhsVectors = CalculateInternalRhs(increment, iteration);
Console.WriteLine($"incre:{increment}, iter:{iteration}, total Solution Norm{uPlusdu[0].Norm2()}");
Debug.WriteLine($"incre:{increment}, iter:{iteration}, total Solution Norm{uPlusdu[0].Norm2()}");
double residualNormCurrent = UpdateResidualForcesAndNorm(increment, internalRhsVectors); // This also sets the rhs vectors in linear systems.
errorNorm = globalRhsNormInitial != 0 ? residualNormCurrent / globalRhsNormInitial : 0; // (rhsNorm*increment/increments) : 0;//TODOMaria this calculates the internal force vector and subtracts it from the external one (calculates the residual)
//Console.WriteLine($"Increment {increment}, iteration {iteration}: norm2(error) = {errorNorm}");
if (iteration == 0)
{
firstError = errorNorm;
}
if (TotalDisplacementsPerIterationLog != null)
{
TotalDisplacementsPerIterationLog.StoreDisplacements(uPlusdu);
}
if (errorNorm < residualTolerance)
{
previousConvergedUplusdUSolution = uPlusdu[0];
foreach (var subdomainLogPair in IncrementalLogs)
{
int subdomainID = subdomainLogPair.Key;
TotalLoadsDisplacementsPerIncrementLog log = subdomainLogPair.Value;
log.LogTotalDataForIncrement(increment, iteration, errorNorm,
uPlusdu[subdomainID], internalRhsVectors[subdomainID]);
}
break;
}
SplitResidualForcesToSubdomains(); //TODOMaria scatter residuals to subdomains
if ((iteration + 1) % numIterationsForMatrixRebuild == 0) // Matrix rebuilding should be handled in another way. E.g. in modified NR, it must be done at each increment.
{
provider.Reset();
BuildMatrices();
}
}
//double rhsNormInc = solver.LinearSystems.First().Value.RhsVector.Norm2();
//double xNormInc = solver.LinearSystems.First().Value.Solution.Norm2();
Debug.WriteLine("NR {0}, first error: {1}, exit error: {2}", iteration, firstError, errorNorm);
SaveMaterialStateAndUpdateSolution();
}
// ClearMaterialStresses();
// TODO: Logging should be done at each iteration. And it should be done using pull observers
DateTime end = DateTime.Now;
StoreLogResults(start, end);
}
public override void Solve()
{
InitializeLogs();
DateTime start = DateTime.Now;
UpdateInternalVectors();
for (int increment = 0; increment < numIncrements; increment++)
{
double errorNorm = 0;
ClearIncrementalSolutionVector();
UpdateRhs(increment);
ScaleSubdomainConstraints(increment);
double firstError = 0;
int iteration = 0;
for (iteration = 0; iteration < maxIterationsPerIncrement; iteration++)
{
AddEquivalentNodalLoadsToRHS(increment, iteration);
solver.Solve();
Dictionary <int, IVector> internalRhsVectors = CalculateInternalRhs(increment, iteration);
errorNorm = UpdateResidualForcesAndNorm(increment, internalRhsVectors); // This also sets the rhs vectors in linear systems.
//Console.WriteLine($"Increment {increment}, iteration {iteration}: norm2(error) = {errorNorm}");
if (iteration == 0)
{
firstError = errorNorm;
}
if (TotalDisplacementsPerIterationLog != null)
{
TotalDisplacementsPerIterationLog.StoreDisplacements(uPlusdu);
}
if (errorNorm < residualTolerance)
{
foreach (var subdomainLogPair in IncrementalLogs)
{
int subdomainID = subdomainLogPair.Key;
TotalLoadsDisplacementsPerIncrementLog log = subdomainLogPair.Value;
log.LogTotalDataForIncrement(increment, iteration, errorNorm,
uPlusdu[subdomainID], internalRhsVectors[subdomainID]);
}
break;
}
SplitResidualForcesToSubdomains();
if ((iteration + 1) % numIterationsForMatrixRebuild == 0)
{
provider.Reset();
BuildMatrices();
}
}
Debug.WriteLine("NR {0}, first error: {1}, exit error: {2}", iteration, firstError, errorNorm);
SaveMaterialStateAndUpdateSolution();
}
// TODO: Logging should be done at each iteration. And it should be done using pull observers
DateTime end = DateTime.Now;
StoreLogResults(start, end);
}
public static void EmbeddedCNTinMatrix_NewtonRaphson()
{
// No. of increments
int increments = 1000;
// 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 = 10001;
IDofType monitorDof = StructuralDof.TranslationZ;
// Choose model
EmbeddedModelBuilder.EmbeddedExample(model);
// Boundary Conditions - Left End [End-1]
for (int iNode = 1; iNode <= 100; iNode++)
{
model.NodesDictionary[iNode].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationZ
});
}
// Boundary Conditions - Bottom End [End-3]
for (int iNode = 1; iNode <= 10001; iNode += 100)
{
for (int j = 0; j < 10; j++)
{
model.NodesDictionary[iNode + j].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationY
});
}
}
// Boundary Conditions - Right End [End-5]
for (int iNode = 1; iNode <= 10091; iNode += 10)
{
model.NodesDictionary[iNode].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationX
});
}
//// Boundary Conditions - Left End [End-6]
//for (int iNode = 10; iNode <= 10100; iNode += 10)
//{
// model.NodesDictionary[iNode].Constraints.Add(new Constraint { DOF = DOFType.X });
//}
//Compression Loading
double nodalLoad = -1.0; //0.40;
for (int iNode = 10001; iNode <= 10100; iNode++) //[End-4]
{
model.Loads.Add(new Load()
{
Amount = nodalLoad, Node = model.NodesDictionary[iNode], DOF = StructuralDof.TranslationZ
});
}
// 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
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments)
{
ResidualTolerance = 1E-03
};
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();
}
/// <summary>
/// Solves the nonlinear equations and calculates the displacements vector.
/// </summary>
public override void Solve()
{
InitializeLogs();
DateTime start = DateTime.Now;
UpdateInternalVectors();
for (int increment = 0; increment < numIncrements; increment++)
{
double errorNorm = 0;
ClearIncrementalSolutionVector();
UpdateRhs(increment);
double firstError = 0;
int iteration = 0;
for (iteration = 0; iteration < maxIterationsPerIncrement; iteration++)
{
if (iteration == maxIterationsPerIncrement - 1)
{
return;
}
if (Double.IsNaN(errorNorm))
{
return;
}
solver.Solve();
Dictionary <int, IVector> internalRhsVectors = CalculateInternalRhs(increment, iteration);
double residualNormCurrent = UpdateResidualForcesAndNorm(increment, internalRhsVectors);
errorNorm = globalRhsNormInitial != 0 ? residualNormCurrent / globalRhsNormInitial : 0;
if (iteration == 0)
{
firstError = errorNorm;
}
if (TotalDisplacementsPerIterationLog != null)
{
TotalDisplacementsPerIterationLog.StoreDisplacements(uPlusdu);
}
if (errorNorm < residualTolerance)
{
foreach (var subdomainLogPair in IncrementalLogs)
{
int subdomainID = subdomainLogPair.Key;
TotalLoadsDisplacementsPerIncrementLog log = subdomainLogPair.Value;
log.LogTotalDataForIncrement(increment, iteration, errorNorm,
uPlusdu[subdomainID], internalRhsVectors[subdomainID]);
}
break;
}
SplitResidualForcesToSubdomains();
if ((iteration + 1) % numIterationsForMatrixRebuild == 0)
{
provider.Reset();
BuildMatrices();
}
}
Debug.WriteLine("NR {0}, first error: {1}, exit error: {2}", iteration, firstError, errorNorm);
SaveMaterialStateAndUpdateSolution();
}
DateTime end = DateTime.Now;
StoreLogResults(start, end);
}
public static void EmbeddedCNT_20_20_inMatrix_NewtonRaphson()
{
// No. of increments
int increments = 100;
// 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 = 1800;
IDofType monitorDof = StructuralDof.TranslationZ;
// Choose model
EmbeddedModelBuilder.EmbeddedExample(model);
// Boundary Conditions - Left End [End-1]
for (int iNode = 1; iNode <= 400; iNode++)
{
//model.NodesDictionary[iNode].Constraints.Add(new Constraint { DOF = DOFType.X });
//model.NodesDictionary[iNode].Constraints.Add(new Constraint { DOF = DOFType.Y });
model.NodesDictionary[iNode].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationZ
});
}
// Boundary Conditions - Bottom End [End-3] (y = -10)
for (int iNode = 1; iNode <= 17601; iNode = iNode + 400)
{
for (int jj = 0; jj <= 19; jj++)
{
model.NodesDictionary[iNode + jj].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationY
});
}
}
// Boundary Conditions - Bottom End [End-5] (x = -10)
for (int iNode = 1; iNode <= 17981; iNode = iNode + 20)
{
model.NodesDictionary[iNode].Constraints.Add(new Constraint {
DOF = StructuralDof.TranslationX
});
}
// Compressive Loading - [End-4]
double nodalLoad = -0.5; //-2.0; //
for (int iNode = 17601; iNode <= 18000; iNode++)
{
model.Loads.Add(new Load()
{
Amount = nodalLoad, Node = model.NodesDictionary[iNode], DOF = StructuralDof.TranslationZ
});
}
// 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
var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments)
{
MaxIterationsPerIncrement = 100,
NumIterationsForMatrixRebuild = 1,
ResidualTolerance = 5E-3
};
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_NewtonRaphson.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();
}
