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());
        }
Exemple #2
0
        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());
        }
Exemple #3
0
 private static void UpdateModels(Dictionary <int, IVector>[] solutions, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace,
                                  IConvectionDiffusionIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
 {
     c_ox = solutions[0][0].CopyToArray();
     //double[] sol1 = solutions[1][0].CopyToArray();
     modelsToReplace[0] = CreateOxygenTransportModel(Dox, conv0, new double[] { Dox[0] / Lwv * 7e3 * 24 * 3600, Dox[1] / Lwv * 7e3 * 24 * 3600 }, c_ox).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]);
     }
 }
Exemple #4
0
        private static void UpdateModels(Dictionary <int, IVector>[] solutions, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace,
                                         IConvectionDiffusionIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
        {
            double[] sol0 = solutions[0][0].CopyToArray();
            double[] sol1 = solutions[1][0].CopyToArray();
            modelsToReplace[0] = CreateModel(1, new double[] { 2, 2, 2 }, 0, 0, 1, 0, 0, new double[40]).Item1;
            modelsToReplace[1] = CreateModel(1, new double[] { 0, 0, 0 }, 0, 0, 0, 0, 0, sol0).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 UpdateModels(Dictionary <int, IVector>[] solutions, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace,
                                         IConvectionDiffusionIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace)
        {
            Solutions = solutions;
            double[] lg = solutions[0][0].CopyToArray();
            //double[] sol1 = solutions[1][0].CopyToArray();
            lambdag            = lg[0];// (sol0[39] + sol0[38] + sol0[37] + sol1[36])/8 ;
            modelsToReplace[0] = CreateConvectionDiffusionModel2(0, new double[] { 0, 0, 0 }, 1, 0, 0, 1.5).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, 1, 2, 3, 4, 7 };
            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[] { 6, 8, 9 };
            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 ProblemConvectionDiffusion2(model, solver);

            var childAnalyzer  = new LinearAnalyzer(model, solver, provider);
            var BDForder       = 1;
            var parentAnalyzer = new BDF(model, solver, provider, childAnalyzer, .01, 2, BDForder, initialTemp);

            parentAnalyzer.Initialize();
            parentAnalyzer.Solve();

            return(parentAnalyzer.temperature[BDForder][subdomainID]);
            //           return solver.LinearSystems[subdomainID].Solution;
        }
Exemple #7
0
        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 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]);
            }
        }