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());
}
private NewmarkDynamicAnalyzer(IStructuralModel model, ISolver solver, IImplicitIntegrationProvider provider,
IChildAnalyzer childAnalyzer, double timeStep, double totalTime, double alpha, double delta)
{
this.model = model;
this.linearSystems = solver.LinearSystems;
this.solver = solver;
this.provider = provider;
this.ChildAnalyzer = childAnalyzer;
this.beta = alpha;
this.gamma = delta;
this.timeStep = timeStep;
this.totalTime = totalTime;
this.ChildAnalyzer.ParentAnalyzer = this;
// Initialize coefficients. It would make sense for them to be initialized in a different function, if they could
// change during the analysis
a0 = 1 / (alpha * timeStep * timeStep);
a1 = delta / (alpha * timeStep);
a2 = 1 / (alpha * timeStep);
a3 = 1 / (2 * alpha) - 1;
a4 = delta / alpha - 1;
a5 = timeStep * 0.5 * (delta / alpha - 2);
a6 = timeStep * (1 - delta);
a7 = delta * timeStep;
}
public void SolveTimestep(int i)
{
Debug.WriteLine("Newmark step: {0}", i);
if (CreateNewModel != null)
{
CreateNewModel(uu, uc, v, modelsForReplacement, solversForReplacement, providersForReplacement, childAnalyzersForReplacement);
model = modelsForReplacement[0];
solver = solversForReplacement[0];
linearSystems = solver.LinearSystems;
provider = providersForReplacement[0];
ChildAnalyzer = childAnalyzersForReplacement[0];
ChildAnalyzer.ParentAnalyzer = this;
InitializeInternal(true);
}
IDictionary <int, IVector> rhsVectors = provider.GetRhsFromHistoryLoad(i);
foreach (var l in linearSystems.Values)
{
l.RhsVector = rhsVectors[l.Subdomain.ID];
}
InitializeRhs();
CalculateRhsImplicit();
DateTime start = DateTime.Now;
ChildAnalyzer.Solve();
DateTime end = DateTime.Now;
UpdateVelocityAndAcceleration(i);
UpdateResultStorages(start, end);
// Print output results in *.txt file
string path0 = Path.Combine(Directory.GetCurrentDirectory(), "MsolveOutput");
var path2 = Path.Combine(path0, $"MSolveHyperelasticDynamicsImplicitResults.txt");
using (var fileName = new StreamWriter(path2, true))
{
double currentTime = ((i + 1) * timeStep);
string strTimeStep = currentTime.ToString();
var totalSolution = ChildAnalyzer.Responses[0][1];
string strTotalSolution = totalSolution.ToString();
fileName.WriteLine(strTimeStep + ", " + strTotalSolution);
}
//if (CreateNewModel != null)
//{
// CreateNewModel(uu, uc, v, modelsForReplacement, solversForReplacement, providersForReplacement, childAnalyzersForReplacement);
// model = modelsForReplacement[0];
// solver = solversForReplacement[0];
// linearSystems = solver.LinearSystems;
// provider = providersForReplacement[0];
// ChildAnalyzer = childAnalyzersForReplacement[0];
// ChildAnalyzer.ParentAnalyzer = this;
// InitializeInternal(true);
//}
}
public StaticAnalyzer(IStructuralModel model, ISolver solver, IStaticProvider provider,
IChildAnalyzer childAnalyzer)
{
this.model = model;
this.linearSystems = solver.LinearSystems;
this.solver = solver;
this.provider = provider;
this.ChildAnalyzer = childAnalyzer;
this.ChildAnalyzer.ParentAnalyzer = this;
}
private static IVectorView[] SolveModels(Model[] models, ComsolMeshReader2[] modelReaders)
{
Vector[] initialTemps = new Vector[models.Length];
var temp0 = new Dictionary <int, double[]>();
for (int i = 0; i < models.Length; i++)
{
double[] t0 = new double[models[i].Nodes.Count];
temp0.Add(i, t0);
}
int[] boundaryIDs = new int[] { 0 };
foreach (int boundaryID in boundaryIDs)
{
foreach (IList <Node> nodes in modelReaders[0].quadBoundaries[boundaryID])
{
foreach (Node node in nodes)
{
temp0[0][node.ID] = 0;
temp0[1][node.ID] = 0;
}
}
}
boundaryIDs = new int[] { 5 };
foreach (int boundaryID in boundaryIDs)
{
foreach (IList <Node> nodes in modelReaders[0].quadBoundaries[boundaryID])
{
foreach (Node node in nodes)
{
temp0[0][node.ID] = 1;
//temp0[1][node.ID] = 0;
}
}
}
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(temp0[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]);
}
var parentAnalyzer = new ConvectionDiffusionImplicitDynamicAnalyzerMultiModel(UpdateModels, models, solvers, providers, childAnalyzers, .25, 5, initialTemperature: initialTemps);
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
return(solvers.Select(x => x.LinearSystems[subdomainID].Solution).ToArray());
}
private double beta = 0.25, gamma = 0.5; // constant acceleration is the default
public Builder(IStructuralModel model, ISolver solver, IImplicitIntegrationProvider provider,
IChildAnalyzer childAnalyzer, double timeStep, double totalTime)
{
this.model = model;
this.solver = solver;
this.provider = provider;
this.childAnalyzer = childAnalyzer;
this.timeStep = timeStep;
this.totalTime = totalTime;
}
/// <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="model">Instance of the model to be solved</param>
/// <param name="solver">Instance of the solver that will handle the solution of the system of equations</param>
/// <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="beta">Instance of parameter "beta" of the method that will be initialized</param>
/// <param name="timeStep">Instance of the time step of the method that will be initialized</param>
/// <param name="totalTime">Instance of the total time of the method that will be initialized</param>
public ThermalDynamicAnalyzer(IModel model, ISolver solver, IImplicitIntegrationProvider provider,
IChildAnalyzer childAnalyzer, double beta, double timeStep, double totalTime)
{
this.model = model;
this.linearSystems = solver.LinearSystems;
this.solver = solver;
this.provider = provider;
this.ChildAnalyzer = childAnalyzer;
this.beta = beta;
this.timeStep = timeStep;
this.totalTime = totalTime;
this.ChildAnalyzer.ParentAnalyzer = this;
}
public ODEDynamicAnalyzer(IStructuralModel model, ISolver solver, IImplicitIntegrationProvider provider,
IChildAnalyzer childAnalyzer, double beta, double timeStep, double totalTime, IVector initialValue = null)
{
this.model = model;
this.linearSystems = solver.LinearSystems;
this.solver = solver;
//solver.PreventFromOverwrittingSystemMatrices(); //TODO: If the scheme is purely implicit we can overwrite the matrix.
this.provider = provider;
this.ChildAnalyzer = childAnalyzer;
this.beta = beta;
this.timeStep = timeStep;
this.totalTime = totalTime;
this.ChildAnalyzer.ParentAnalyzer = this;
}
public ConvectionDiffusionImplicitDynamicAnalyzer_Beta(IStructuralModel model, ISolver solver, IConvectionDiffusionIntegrationProvider provider,
IChildAnalyzer childAnalyzer, double timeStep, double totalTime, IVector initialTemperature = null)
{
this.model = model;
this.linearSystems = solver.LinearSystems;
this.solver = solver;
//solver.PreventFromOverwrittingSystemMatrices(); //TODO: If the scheme is purely implicit we can overwrite the matrix.
this.provider = provider;
this.ChildAnalyzer = childAnalyzer;
this.timeStep = timeStep;
this.totalTime = totalTime;
this.ChildAnalyzer.ParentAnalyzer = this;
this.initialTemperature = initialTemperature;
}
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());
}
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 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());
}
public void SolveTimestep(int i)
{
Debug.WriteLine("Newmark step: {0}", i);
if (CreateNewModel != null)
{
CreateNewModel(uu, uc, v, modelsForReplacement, solversForReplacement, providersForReplacement, childAnalyzersForReplacement);
model = modelsForReplacement[0];
solver = solversForReplacement[0];
linearSystems = solver.LinearSystems;
provider = providersForReplacement[0];
ChildAnalyzer = childAnalyzersForReplacement[0];
ChildAnalyzer.ParentAnalyzer = this;
InitializeInternal(true);
}
IDictionary <int, IVector> rhsVectors = provider.GetRhsFromHistoryLoad(i);
foreach (var l in linearSystems.Values)
{
l.RhsVector = rhsVectors[l.Subdomain.ID];
}
InitializeRhs();
CalculateRhsImplicit();
DateTime start = DateTime.Now;
ChildAnalyzer.Solve();
DateTime end = DateTime.Now;
UpdateVelocityAndAcceleration(i);
UpdateResultStorages(start, end);
// Print output results in *.txt file
if (i == 0)
{
using (var fileName = new StreamWriter(path))
{
double currentTime = ((i + 1) * timeStep);
string strTimeStep = currentTime.ToString();
var totalSolution = ChildAnalyzer.Responses[0][62]; //mesh446elem
//var totalSolution = ChildAnalyzer.Responses[0][1]; //meshXXCoarse254elem
//var totalSolution = ChildAnalyzer.Responses[0][57]; //meshXXCoarse
//var totalSolution = ChildAnalyzer.Responses[0][0]; //106TetCube100m
//var totalSolution = ChildAnalyzer.Responses[0][19]; //261TetCube100m
//var totalSolution = ChildAnalyzer.Responses[0][1]; //125HexaHyperelasticCube100m
//var totalSolution = ChildAnalyzer.Responses[0][13]; //4HexaHyperelasticCube100m
//var totalSolution = ChildAnalyzer.Responses[0][0]; //1Hexa
string strTotalSolution = totalSolution.ToString();
fileName.WriteLine(strTimeStep + " " + strTotalSolution);
}
}
else
{
using (var fileName = new StreamWriter(path, true))
{
double currentTime = ((i + 1) * timeStep);
string strTimeStep = currentTime.ToString();
var totalSolution = ChildAnalyzer.Responses[0][62]; //mesh446elem
//var totalSolution = ChildAnalyzer.Responses[0][1]; //meshXXCoarse254elem
//var totalSolution = ChildAnalyzer.Responses[0][57]; //meshXXCoarse
//var totalSolution = ChildAnalyzer.Responses[0][0]; //106TetCube100m
//var totalSolution = ChildAnalyzer.Responses[0][19]; //261TetCube100m
//var totalSolution = ChildAnalyzer.Responses[0][1]; //125HexaHyperelasticCube100m
//var totalSolution = ChildAnalyzer.Responses[0][13]; //4HexaHyperelasticCube100m
//var totalSolution = ChildAnalyzer.Responses[0][0]; //1Hexa
string strTotalSolution = totalSolution.ToString();
fileName.WriteLine(strTimeStep + " " + strTotalSolution);
}
}
}
