public IBMAdamsBashforth( SpatialOperator standardOperator, SpatialOperator boundaryOperator, CoordinateMapping fieldsMap, CoordinateMapping parametersMap, ISpeciesMap ibmSpeciesMap, IBMControl control, IList <TimeStepConstraint> timeStepConstraints) : base(standardOperator, fieldsMap, parametersMap, control.ExplicitOrder, timeStepConstraints, ibmSpeciesMap.SubGrid) // TO DO: I SIMPLY REMOVED PARAMETERMAP HERE; MAKE THIS MORE PRETTY { speciesMap = ibmSpeciesMap as ImmersedSpeciesMap; if (this.speciesMap == null) { throw new ArgumentException( "Only supported for species maps of type 'ImmersedSpeciesMap'", "speciesMap"); } this.boundaryOperator = boundaryOperator; this.boundaryParameterMap = parametersMap; agglomerationPatternHasChanged = true; // StarUp Phase needs also an IBM time stepper RungeKuttaScheme = new IBMSplitRungeKutta( standardOperator, boundaryOperator, fieldsMap, parametersMap, speciesMap, timeStepConstraints); }
/// <summary> /// Check whether Operator, Fields and Parameters fit toghether /// </summary> /// <param name="spatialOp"></param> /// <param name="Fieldsmap"></param> /// <param name="Parameters"></param> public static void VerifyInput(SpatialOperator spatialOp, CoordinateMapping Fieldsmap, CoordinateMapping Parameters) { if (!spatialOp.ContainsNonlinear && !(spatialOp.ContainsLinear())) { throw new ArgumentException("spatial differential operator seems to contain no components.", "spatialOp"); } if (spatialOp.DomainVar.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("spatial differential operator must have the same number of domain and codomain variables.", "spatialOp"); } if (Fieldsmap.Fields.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("the number of fields in the coordinate mapping must be equal to the number of domain/codomain variables of the spatial differential operator", "fields"); } if (Parameters == null) { if (spatialOp.ParameterVar.Count != 0) { throw new ArgumentException("the number of fields in the parameter mapping must be equal to the number of parameter variables of the spatial differential operator", "Parameters"); } } else { if (Parameters.Fields.Count != spatialOp.ParameterVar.Count) { throw new ArgumentException("the number of fields in the parameter mapping must be equal to the number of parameter variables of the spatial differential operator", "Parameters"); } } }
/// <summary> /// ctor. /// </summary> public LinearSolver(ISparseSolver solver, MsrMatrix spatialOpMtx, IList <double> spatialOpAffine, CoordinateMapping UnknownsMap) { // check operator and arguments // ---------------------------- if (spatialOpMtx.NoOfRows != spatialOpMtx.NoOfCols) { throw new ArgumentException("matrix must be quadratic.", "spatialOpMtx"); } if (spatialOpMtx.NoOfRows != UnknownsMap.GlobalCount) { throw new ArgumentException("matrix size must be equal to the GlobalCount of fields mapping", "fields,spatialOpMtx"); } if (spatialOpMtx.RowPartitioning.LocalLength != UnknownsMap.LocalLength) { throw new ArgumentException("number of locally stored matrix rows nust be equal to NUpdate of fields mapping.", "fields,spatialOpMtx"); } if (spatialOpAffine.Count < UnknownsMap.LocalLength) { throw new ArgumentException("length affine offset vector must be equal or larger than NUpdate of the mapping", "spatialOpAffine"); } m_Solver = solver; m_Mapping = UnknownsMap; // finish constructor // ------------------ m_AffineOffset = spatialOpAffine.ToArray(); ConstructorCommon(spatialOpMtx); }
/// <summary> /// Calculating the level set gradient using the specified scheme in a narrow band around the zero level set, therein the calculions are performed /// </summary> /// <param name="LS"> The level set function </param> /// <param name="LSG"> Gradient of the level set function </param> /// <param name="f"> Specifying the method of flux calculation </param> /// <param name="Restriction"> The narrow band around the zero level set wherein the calculations are performed </param> void CalculateLevelSetGradient(LevelSet LS, VectorField <SinglePhaseField> LSG, string f, SubGrid Restriction) { SpatialOperator SO; CoordinateMapping CoDom; if (m_ctx.SpatialDimension == 2) { SO = new SpatialOperator(1, 2, QuadOrderFunc.Linear(), new string[] { "LS", "LSG[0]", "LSG[1]" }); SO.EquationComponents["LSG[0]"].Add(CreateFlux(m_ctx, f, 0)); SO.EquationComponents["LSG[1]"].Add(CreateFlux(m_ctx, f, 1)); SO.Commit(); CoDom = new CoordinateMapping(LSG[0], LSG[1]); } else if (m_ctx.SpatialDimension == 3) { SO = new SpatialOperator(1, 3, QuadOrderFunc.Linear(), new string[] { "LS", "LSG[0]", "LSG[1]", "LSG[2]" }); SO.EquationComponents["LSG[0]"].Add(CreateFlux(m_ctx, f, 0)); SO.EquationComponents["LSG[1]"].Add(CreateFlux(m_ctx, f, 1)); SO.EquationComponents["LSG[2]"].Add(CreateFlux(m_ctx, f, 2)); SO.Commit(); CoDom = new CoordinateMapping(LSG[0], LSG[1], LSG[2]); } else { throw new NotSupportedException(); } SO.Evaluate(1.0, 0.0, LS.Mapping, null, CoDom, sgrd: Restriction, bndMode: SubGridBoundaryModes.OpenBoundary); }
/// <summary> /// /// </summary> /// <param name="spatialOp"></param> /// <param name="Fieldsmap"></param> /// <param name="Parameters"> /// optional parameter fields, can be null if /// <paramref name="spatialOp"/> contains no parameters; must match /// the parameter field list of <paramref name="spatialOp"/>, see /// <see cref="BoSSS.Foundation.SpatialOperator.ParameterVar"/> /// </param> /// <param name="sgrdBnd"> /// Options for the treatment of edges at the boundary of a SubGrid, /// <see cref="SubGridBoundaryModes"/></param> /// <param name="timeStepConstraints"> /// optional list of time step constraints <see cref="TimeStepConstraint"/> /// </param> /// <param name="sgrd"> /// optional restriction to computational domain /// </param> public ExplicitEuler(SpatialOperator spatialOp, CoordinateMapping Fieldsmap, CoordinateMapping Parameters, SubGridBoundaryModes sgrdBnd, IList <TimeStepConstraint> timeStepConstraints = null, SubGrid sgrd = null) { using (new ilPSP.Tracing.FuncTrace()) { // verify input // ============ TimeStepperCommon.VerifyInput(spatialOp, Fieldsmap, Parameters); Mapping = Fieldsmap; CurrentState = new CoordinateVector(Mapping); ParameterMapping = Parameters; IList <DGField> ParameterFields = (ParameterMapping == null) ? (new DGField[0]) : ParameterMapping.Fields; this.TimeStepConstraints = timeStepConstraints; SubGrid = sgrd ?? new SubGrid(CellMask.GetFullMask(Fieldsmap.First().GridDat)); // generate Evaluator // ================== CellMask cm = SubGrid.VolumeMask; EdgeMask em = SubGrid.AllEdgesMask; Operator = spatialOp; m_Evaluator = new Lazy <IEvaluatorNonLin>(delegate() { spatialOp.EdgeQuadraturSchemeProvider = g => new EdgeQuadratureScheme(true, em); spatialOp.VolumeQuadraturSchemeProvider = g => new CellQuadratureScheme(true, cm); var op = spatialOp.GetEvaluatorEx( Fieldsmap, ParameterFields, Fieldsmap); op.ActivateSubgridBoundary(SubGrid.VolumeMask, sgrdBnd); return(op); }); } }
/// <summary> /// In a vector <paramref name="vec"/>, this method performs a /// polynomial extrapolation from agglomeration target cells to agglomeration source cells. /// </summary> public void Extrapolate(CoordinateMapping Map) { //var vecS = GetFrameVectors(vec, Map); foreach (var kv in DictAgglomeration) { var Species = kv.Key; var m_Agglomerator = kv.Value; var DgFields = Map.Fields.ToArray(); DGField[] SubFields = new DGField[DgFields.Count()]; for (int iFld = 0; iFld < SubFields.Length; iFld++) { DGField f = DgFields[iFld]; if (f is ConventionalDGField) SubFields[iFld] = (ConventionalDGField)(f); else if (f is XDGField) SubFields[iFld] = ((XDGField)f).GetSpeciesShadowField(Species); else throw new NotImplementedException(); } if (m_Agglomerator != null) { m_Agglomerator.Extrapolate(new CoordinateMapping(SubFields)); } } }
public IBMABevolve( SpatialOperator standardOperator, SpatialOperator boundaryOperator, CoordinateMapping fieldsMap, CoordinateMapping parametersMap, ISpeciesMap ibmSpeciesMap, int explicitOrder, int levelSetQuadratureOrder, XQuadFactoryHelper.MomentFittingVariants momentFittingVariant, SubGrid sgrd, bool adaptive = false) : base(standardOperator, fieldsMap, parametersMap, explicitOrder, adaptive: adaptive, sgrd: sgrd) { speciesMap = ibmSpeciesMap as ImmersedSpeciesMap; if (speciesMap == null) { throw new ArgumentException( "Only supported for species maps of type 'ImmersedSpeciesMap'", "speciesMap"); } this.boundaryOperator = boundaryOperator; this.boundaryParameterMap = parametersMap; agglomerationPatternHasChanged = true; }
public ImagePanel2() { InitializeComponent(); currentDisplayOffsetPt = new Point(0, 0); originalDisplayOffsetPt = new Point(0, 0); BorderSize = 2; currentZoomFactor = 1.0F; originalZoomFactor = 1.0F; lastMousePosition = new Point(0, 0); // initialize MPR cursor this.m_mprCursor = new MPRCursor(); // initial coordinate system mapping this.m_coordinateMapping = new CoordinateMapping(); // cursor path cursorPath = new GraphicsPath(); cursorPath.Reset(); // testing objectPath = new GraphicsPath(); objectLocation = new Point(0, 0); objectPath.Reset(); objectPath.AddEllipse(objectLocation.X - 5.0F, objectLocation.Y - 5.0F, 10.0F, 10.0F); objectPath.CloseFigure(); // Set few control option. SetStyle(ControlStyles.UserPaint, true); SetStyle(ControlStyles.AllPaintingInWmPaint, true); SetStyle(ControlStyles.DoubleBuffer, true); SetStyle(ControlStyles.UserMouse, true); // handle resize this.Resize += new EventHandler(ImagePanel2_Resize); }
/// <summary> /// Initilializes the History-stack for the Unknown u and the Operator Matrix and Affine Part /// </summary> /// <param name="Mapping"></param> /// <param name="StackLength"></param> private void InitStacks(CoordinateMapping Mapping, int StackLength) { // operator matrix - stack // ----------------------- Stack_OpMatrix = new BlockMsrMatrix[2]; // only required for Crank.Nic. and Expl. Euler, Stack_OpAffine = new double[2][]; // in this case 'theta0' is unequal 0.0. Stack_OpMatrix[1] = new BlockMsrMatrix(Mapping); Stack_OpAffine[1] = new double[Mapping.LocalLength]; // Stack for the unknown field //---------------------------- Stack_u = new CoordinateVector[StackLength]; for (int i = 0; i < StackLength; i++) { Stack_u[i] = new CoordinateVector(Mapping.Fields.Select(dgf => dgf.CloneAs()).ToArray()); } Stack_u[0].Clear(); Stack_u[0].AccV(1.0, CurrentState); // Initialize the Operator Matrix for TimeStep 0, i.e. Calculate it and Push it to its Position UpdateOperatorMatrix(); PushStacks(); }
/// <summary> /// ctor. /// </summary> /// <param name="temporalOp"> /// Indicates, for each each equation whether it is /// <list type="bullet"> /// <item>(false) a auxiliary condition i.e. a variable where no time derivative occurs in the equation, or</item> /// <item>(true) a differential equation</item> /// </list> /// At least one equation must be time-dependent; /// Otherwise, the <see cref="BoSSS.Solution.Solvers.LinearSolver"/> should be used; /// </param> /// <param name="spatialOp"></param> /// <param name="fields"></param> /// <param name="solver"> /// </param> public ImplicitTimeStepper(ISparseSolverExt solver, bool[] temporalOp, SpatialOperator spatialOp, CoordinateMapping fields) { // check operator and arguments if (!spatialOp.IsCommited) { throw new ArgumentException("operator must be committed first.", "spatialOp"); } if (spatialOp.ContainsNonlinear) { throw new ArgumentException("spatial differential operator cannot contain nonlinear components for implicit euler.", "spatialOp"); } if (!spatialOp.ContainsLinear()) { throw new ArgumentException("spatial differential operator seems to contain no components.", "spatialOp"); } if (spatialOp.DomainVar.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("spatial differential operator must have the same number of domain and codomain variables.", "spatialOp"); } if (fields.Fields.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("the number of fields in the coordinate mapping must be equal to the number of domain/codomain variables of the spatial differential operator", "fields"); } m_Solver = solver; m_Mapping = fields; //m_AffineOffset1 = new double[fields.LocalLength]; MsrMatrix eM; ImplicitTimeStepper.ComputeMatrix(spatialOp, fields, false, out eM, out m_AffineOffset1); //Setup2(eM, temporalOp); Setup1(solver, temporalOp, eM, m_AffineOffset1, fields); }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { diffOp = new SpatialOperator( new string[] { "c" }, new string[] { "viscosity", "VelocityX", "VelocityY" }, new string[] { "codom1" }, QuadOrderFunc.Linear()); diffOp.EquationComponents["codom1"].Add(new ScalarTransportFlux2D(inflowDirichletValue)); diffOp.Commit(); CoordinateMapping coordMap; coordMap = new CoordinateMapping(viscosity, Velocity[0], Velocity[1]); // 3 sub-grids MultidimensionalArray metricOne = MultidimensionalArray.Create(numOfCellsX); MultidimensionalArray metricTwo = MultidimensionalArray.Create(numOfCellsX); // 3 cells //metricOne[0] = 2; //metricOne[1] = 1; //metricOne[2] = 0.5; //metricTwo[0] = 1; //metricTwo[1] = 0.5; //metricTwo[2] = 2; // 4 cells metricOne[0] = 2; metricOne[1] = 1; metricOne[2] = 0.5; metricOne[3] = 0.25; metricTwo[0] = 0.5; metricTwo[1] = 2; metricTwo[2] = 0.25; metricTwo[3] = 1; CustomTimestepConstraint = new SurrogateConstraint(GridData, dtFixed, dtFixed, double.MaxValue, endTime, metricOne, metricTwo); timeStepper = new AdamsBashforthLTS( diffOp, new CoordinateMapping(c), coordMap, order: ABOrder, numOfClusters: this.numOfSubgrids, timeStepConstraints: new List <TimeStepConstraint>() { CustomTimestepConstraint }, fluxCorrection: false, reclusteringInterval: 1); // Sub-grid visualization //AdamsBashforthLTS timeStepper2 = timeStepper as AdamsBashforthLTS; //timeStepper2.SubGridField.Identification = "clusterLTS"; //m_IOFields.Add(timeStepper2.SubGridField); //timeStepper = timeStepper2; }
/// <summary> /// ctor. /// </summary> public IBMMassMatrixFactory(ImmersedSpeciesMap speciesMap, CoordinateMapping mapping, string fluidSpeciesName, int quadOrder) { this.Mapping = mapping; this.SpeciesMap = speciesMap; this.m_FluidSpeciesName = fluidSpeciesName; this.m_quadOrder = quadOrder; speciesMap.Tracker.Subscribe(this); }
/// <summary> /// Creates an instance of <see cref="IBMMassMatrixFactory"/> that is /// appropriate for the given <paramref name="mapping"/> /// </summary> /// <param name="mapping"></param> /// <returns></returns> public IBMMassMatrixFactory GetMassMatrixFactory(CoordinateMapping mapping) { if (MassMatrixFactory == null || !mapping.Equals(MassMatrixFactory.Mapping)) { MassMatrixFactory = new IBMMassMatrixFactory(this, mapping, Control.FluidSpeciesName, Control.LevelSetQuadratureOrder); } return(MassMatrixFactory); }
/// <summary> /// /// </summary> /// <param name="spatialOp"></param> /// <param name="Fieldsmap"></param> /// <param name="Parameters"> /// optional parameter fields, can be null if /// <paramref name="spatialOp"/> contains no parameters; must match /// the parameter field list of <paramref name="spatialOp"/>, see /// <see cref="BoSSS.Foundation.SpatialOperator.ParameterVar"/> /// </param> /// <param name="sgrdBnd"> /// Options for the treatment of edges at the boundary of a SubGrid, /// <see cref="SpatialOperator.SubGridBoundaryModes"/></param> /// <param name="timeStepConstraints"> /// optional list of time step constraints <see cref="TimeStepConstraint"/> /// </param> /// <param name="sgrd"> /// optional restriction to computational domain /// </param> public ExplicitEuler(SpatialOperator spatialOp, CoordinateMapping Fieldsmap, CoordinateMapping Parameters, SpatialOperator.SubGridBoundaryModes sgrdBnd, IList <TimeStepConstraint> timeStepConstraints = null, SubGrid sgrd = null) { using (new ilPSP.Tracing.FuncTrace()) { // verify input // ============ if (!spatialOp.ContainsNonlinear && !(spatialOp.ContainsLinear())) { throw new ArgumentException("spatial differential operator seems to contain no components.", "spatialOp"); } if (spatialOp.DomainVar.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("spatial differential operator must have the same number of domain and codomain variables.", "spatialOp"); } if (Fieldsmap.Fields.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("the number of fields in the coordinate mapping must be equal to the number of domain/codomain variables of the spatial differential operator", "fields"); } if (Parameters == null) { if (spatialOp.ParameterVar.Count != 0) { throw new ArgumentException("the number of fields in the parameter mapping must be equal to the number of parameter variables of the spatial differential operator", "Parameters"); } } else { if (Parameters.Fields.Count != spatialOp.ParameterVar.Count) { throw new ArgumentException("the number of fields in the parameter mapping must be equal to the number of parameter variables of the spatial differential operator", "Parameters"); } } Mapping = Fieldsmap; DGCoordinates = new CoordinateVector(Mapping); ParameterMapping = Parameters; IList <DGField> ParameterFields = (ParameterMapping == null) ? (new DGField[0]) : ParameterMapping.Fields; this.TimeStepConstraints = timeStepConstraints; SubGrid = sgrd ?? new SubGrid(CellMask.GetFullMask(Fieldsmap.First().GridDat)); // generate Evaluator // ================== CellMask cm = SubGrid.VolumeMask; EdgeMask em = SubGrid.AllEdgesMask; Operator = spatialOp; m_Evaluator = new Lazy <SpatialOperator.Evaluator>(() => spatialOp.GetEvaluatorEx( Fieldsmap, ParameterFields, Fieldsmap, new EdgeQuadratureScheme(true, em), new CellQuadratureScheme(true, cm), SubGrid, sgrdBnd)); } }
/// <summary> /// ctor. /// </summary> public ROCK4(SpatialOperator op, CoordinateVector V, CoordinateMapping ParamFields) { this.CurrentState = V; this.OpEv = op.GetEvaluatorEx(this.Mapping, ParamFields != null ? ParamFields.Fields : new DGField[0], this.Mapping); this.nfevals = 0; this.nrejected = 0; }
/// <summary> /// Factory for residual loggers. The instantiated objects depend on the /// defined <paramref name="loggerType"/>. /// </summary> /// <param name="loggerType"> /// The type of logger to be instantiated /// </param> /// <param name="program"> /// The program requesting the residual logger. /// </param> /// <param name="config">Configuration options</param> /// <param name="differentialOperator"> /// The differential operator that defines the system of equations to /// be solved. May be null if <paramref name="loggerType"/> does /// <b>not</b> contain <see cref="ResidualLoggerTypes.Rigorous"/>. /// </param> /// <returns> /// A list of residual loggers, see <see cref="ResidualLogger"/>. /// </returns> public static IEnumerable <IResidualLogger> Instantiate <T>( this ResidualLoggerTypes loggerType, Application <T> program, CompressibleControl config, SpatialOperator differentialOperator, DGField[] consVars, CoordinateMapping paramMap) where T : CompressibleControl, new() { if (loggerType.HasFlag(ResidualLoggerTypes.ChangeRate) && loggerType.HasFlag(ResidualLoggerTypes.Rigorous)) { throw new Exception( "Residual types \"changeRate\" and \"rigorous\" are mutually exclusive"); } if (loggerType == ResidualLoggerTypes.None) { yield return(new NullResidualLogger( program.ResLogger, program.CurrentSessionInfo, consVars)); } else { if (loggerType.HasFlag(ResidualLoggerTypes.ChangeRate)) { loggerType ^= ResidualLoggerTypes.ChangeRate; yield return(new ChangeRateResidualLogger( program.ResLogger, program.CurrentSessionInfo, consVars, config.ResidualInterval)); } if (loggerType.HasFlag(ResidualLoggerTypes.Rigorous)) { loggerType ^= ResidualLoggerTypes.Rigorous; yield return(new RigorousResidualLogger <T>( program, consVars, paramMap, config.ResidualInterval, differentialOperator)); } if (loggerType.HasFlag(ResidualLoggerTypes.Query)) { loggerType ^= ResidualLoggerTypes.Query; yield return(new QueryLogger( program.ResLogger, program)); } if (loggerType != ResidualLoggerTypes.None) { throw new NotImplementedException( "Residual logging for residual type " + loggerType + " not implemented"); } } }
/// <summary> /// <see cref="ResidualLogger"/> /// </summary> /// <param name="program"></param> /// <param name="residualInterval"> /// <see cref="ResidualLogger"/> /// </param> /// <param name="differentialOperator"> /// The spatial differential operator defining (the spatial part of) /// the system of equations that are solved. /// </param> public RigorousResidualLogger(Application <T> program, DGField[] consVars, CoordinateMapping paramMap, int residualInterval, SpatialOperator differentialOperator) : base(program.ResLogger, program.CurrentSessionInfo, consVars, residualInterval) { CoordinateMapping domainMapping = new CoordinateMapping(consVars); UnsetteledCoordinateMapping codomainMapping = new UnsetteledCoordinateMapping( consVars.Select((field) => field.Basis).ToArray()); evaluator = differentialOperator.GetEvaluatorEx( domainMapping, paramMap, codomainMapping); }
/// <summary> /// Constructor for an explicit Euler scheme operating on subgrids supporting parameters. /// </summary> /// <param name="ctx"></param> /// <param name="subgridMapping">Coordinate Mapping on the subgrid</param> /// <param name="Parameters">Optional parameters which have to match the matrix dimensions</param> /// <param name="operatorMatrix">Matrix of the differential operator</param> /// <param name="affine">Affine part of the operator matrix</param> public ExplicitEulerSubgrid(Context ctx, SubgridCoordinateMapping subgridMapping, CoordinateMapping Parameters, MsrMatrix operatorMatrix, double[] affine) { using (new ilPSP.Tracing.FuncTrace()) { m_Context = ctx; m_SubgridMapping = subgridMapping; m_DGCoordinates = subgridMapping.subgridCoordinates; m_Parameters = Parameters; IList <Field> ParameterFields = (m_Parameters == null) ? (new Field[0]) : m_Parameters.Fields; m_SubgridMapping.SetupSubmatrix(affine, operatorMatrix, out subgridAffine, out subgridMatrix); } }
public static IBMRungeKutta CreateRungeKuttaTimeStepper( this TimesteppingStrategies strategy, IBMControl control, OperatorFactory equationSystem, CNSFieldSet fieldSet, CoordinateMapping parameterMap, ISpeciesMap speciesMap, IList <TimeStepConstraint> timeStepConstraints) { ImmersedSpeciesMap ibmSpeciesMap = speciesMap as ImmersedSpeciesMap; if (ibmSpeciesMap == null) { throw new ArgumentException( "Only supported for species maps of type 'ImmersedSpeciesMap'", "speciesMap"); } IBMOperatorFactory ibmFactory = equationSystem as IBMOperatorFactory; if (ibmFactory == null) { throw new Exception(); } CoordinateMapping variableMap = new CoordinateMapping(fieldSet.ConservativeVariables); switch (strategy) { case TimesteppingStrategies.LieSplitting: case TimesteppingStrategies.StrangSplitting: return(new IBMSplitRungeKutta( equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), ibmFactory.GetImmersedBoundaryOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, ibmSpeciesMap, timeStepConstraints)); case TimesteppingStrategies.MovingFrameFlux: return(new IBMMovingFrameRungeKutta( equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), ibmFactory.GetImmersedBoundaryOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, ibmSpeciesMap, timeStepConstraints)); default: throw new System.NotImplementedException(); } }
/// <summary> /// <see cref="ResidualLogger"/> /// </summary> /// <param name="program"></param> /// <param name="residualInterval"> /// <see cref="ResidualLogger"/> /// </param> /// <param name="differentialOperator"> /// The spatial differential operator defining (the spatial part of) /// the system of equations that are solved. /// </param> public RigorousResidualLogger(Program <T> program, int residualInterval, SpatialOperator differentialOperator) : base(program.ResLogger, program.CurrentSessionInfo, program.WorkingSet, residualInterval) { DGField[] primalFields = program.WorkingSet.ConservativeVariables; CoordinateMapping domainMapping = new CoordinateMapping(primalFields); UnsetteledCoordinateMapping codomainMapping = new UnsetteledCoordinateMapping( primalFields.Select((field) => field.Basis).ToArray()); evaluator = differentialOperator.GetEvaluatorEx( domainMapping, program.ParameterMapping, codomainMapping); }
/// <summary> /// /// </summary> /// <param name="spatialOp">Spatial operator</param> /// <param name="Fieldsmap"></param> /// <param name="scheme">Runge-Kutta scheme</param> /// <param name="Parameters"> /// Optional parameter fields, can be null if /// <paramref name="spatialOp"/> contains no parameters; /// must match the parameter field list of /// <paramref name="spatialOp"/>, see /// <see cref="BoSSS.Foundation.SpatialOperator.ParameterVar"/> /// </param> /// <param name="timeStepConstraints"> /// optional list of time step constraints <see cref="TimeStepConstraint"/> /// </param> /// <param name="sgrd"> /// optional restriction to computational domain /// </param> public RungeKutta(RungeKuttaScheme scheme, SpatialOperator spatialOp, CoordinateMapping Fieldsmap, CoordinateMapping Parameters, IList <TimeStepConstraint> timeStepConstraints, SubGrid sgrd = null) : base(spatialOp, Fieldsmap, Parameters, timeStepConstraints, sgrd) { using (new ilPSP.Tracing.FuncTrace()) { m_Scheme = scheme; m_Scheme.Verify(); if (!m_Scheme.IsExplicit) { throw new ArgumentException("Implicit Runge-Kutta -- schemes are not supported."); } } }
public IBMRungeKutta( SpatialOperator standardOperator, SpatialOperator boundaryOperator, CoordinateMapping fieldsMap, CoordinateMapping parametersMap, ImmersedSpeciesMap speciesMap, IList <TimeStepConstraint> timeStepConstraints) : base(RungeKutta.GetDefaultScheme(speciesMap.Control.ExplicitOrder), standardOperator, fieldsMap, parametersMap, timeStepConstraints, speciesMap.SubGrid) { this.speciesMap = speciesMap; this.boundaryOperator = boundaryOperator; this.boundaryParameterMap = parametersMap; }
/// <summary> /// /// </summary> /// <param name="spatialOp"></param> /// <param name="fields"></param> /// <param name="matrix"></param> /// <param name="affineOffset"></param> /// <param name="OnlyAffine"> /// if true, only the <paramref name="affineOffset"/> /// is computed and <paramref name="matrix"/> is null on exit. /// </param> public static void ComputeMatrix(SpatialOperator spatialOp, CoordinateMapping fields, bool OnlyAffine, out MsrMatrix matrix, out double[] affineOffset) { // Check operator and arguments if (!spatialOp.IsCommited) { throw new ArgumentException("operator must be committed first.", "spatialOp"); } if (spatialOp.ContainsNonlinear) { throw new ArgumentException("spatial differential operator cannot contain nonlinear components for implicit euler.", "spatialOp"); } if (!spatialOp.ContainsLinear()) { throw new ArgumentException("spatial differential operator seems to contain no components.", "spatialOp"); } if (spatialOp.DomainVar.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("spatial differential operator must have the same number of domain and codomain variables.", "spatialOp"); } if (fields.Fields.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("the number of fields in the coordinate mapping must be equal to the number of domain/codomain variables of the spatial differential operator", "fields"); } // Assemble matrix and affine offset IPartitioning matrixPartition = fields; if (!OnlyAffine) { matrix = new MsrMatrix(matrixPartition); } else { matrix = null; } affineOffset = new double[fields.LocalLength]; var b = spatialOp.GetMatrixBuilder(fields, null, fields); if (OnlyAffine) { b.ComputeAffine(affineOffset); } else { b.ComputeMatrix(matrix, affineOffset); } }
public IBMAdamsBashforthLTS(SpatialOperator standardOperator, SpatialOperator boundaryOperator, CoordinateMapping fieldsMap, CoordinateMapping boundaryParameterMap, ISpeciesMap ibmSpeciesMap, IBMControl control, IList <TimeStepConstraint> timeStepConstraints, int reclusteringInterval, bool fluxCorrection) : base(standardOperator, fieldsMap, boundaryParameterMap, control.ExplicitOrder, control.NumberOfSubGrids, true, timeStepConstraints, reclusteringInterval: reclusteringInterval, fluxCorrection: fluxCorrection, subGrid: ibmSpeciesMap.SubGrid) { this.speciesMap = ibmSpeciesMap as ImmersedSpeciesMap; if (this.speciesMap == null) { throw new ArgumentException( "Only supported for species maps of type 'ImmersedSpeciesMap'", "speciesMap"); } this.standardOperator = standardOperator; this.boundaryOperator = boundaryOperator; this.boundaryParameterMap = boundaryParameterMap; this.fieldsMap = fieldsMap; this.control = control; agglomerationPatternHasChanged = true; cutCells = speciesMap.Tracker.Regions.GetCutCellMask(); cutAndTargetCells = cutCells.Union(speciesMap.Agglomerator.AggInfo.TargetCells); // Normal LTS constructor NumberOfLocalTimeSteps = new List <int>(control.NumberOfSubGrids); clusterer = new Clusterer(this.gridData, this.TimeStepConstraints); CurrentClustering = clusterer.CreateClustering(control.NumberOfSubGrids, speciesMap.SubGrid); CurrentClustering = CalculateNumberOfLocalTS(CurrentClustering); // Might remove sub-grids when time step sizes are too similar ABevolver = new IBMABevolve[CurrentClustering.NumberOfClusters]; for (int i = 0; i < ABevolver.Length; i++) { ABevolver[i] = new IBMABevolve(standardOperator, boundaryOperator, fieldsMap, boundaryParameterMap, speciesMap, control.ExplicitOrder, control.LevelSetQuadratureOrder, control.CutCellQuadratureType, sgrd: CurrentClustering.Clusters[i], adaptive: this.adaptive); ABevolver[i].OnBeforeComputeChangeRate += (t1, t2) => this.RaiseOnBeforeComputechangeRate(t1, t2); } GetBoundaryTopology(); #if DEBUG for (int i = 0; i < CurrentClustering.NumberOfClusters; i++) { Console.WriteLine("IBM AB LTS ctor: id=" + i + " -> sub-steps=" + NumberOfLocalTimeSteps[i] + " and elements=" + CurrentClustering.Clusters[i].GlobalNoOfCells); } #endif // Start-up phase needs an IBM Runge-Kutta time stepper RungeKuttaScheme = new IBMSplitRungeKutta(standardOperator, boundaryOperator, fieldsMap, boundaryParameterMap, speciesMap, timeStepConstraints); }
/// <summary> /// common to more than one constructor /// </summary> protected void ConstructorCommon2(CoordinateMapping UnknownsMap, SpatialOperator rhsOperator, CoordinateMapping rhsDomainFields) { // verify input // ------------ if (m_Mapping.Fields.Count != rhsOperator.CodomainVar.Count) { throw new ArgumentException("spatial differential operator and RHS obperator must have the same number of domain variables.", "rhsOperator"); } // construct evaluator // ------------------- m_rhsEvaluator = rhsOperator.GetEvaluatorEx(rhsDomainFields, null, UnknownsMap); }
/// <summary> /// Constructor /// </summary> /// <param name="spatialOp">Spatial operator</param> /// <param name="Fieldsmap"><see cref="CoordinateMapping"/> of the fields</param> /// <param name="Parameters">Optional parameter fields, can be null if <paramref name="spatialOp"/> contains no parameters. Must match the parameter field list of <paramref name="spatialOp"/>, see <see cref="BoSSS.Foundation.SpatialOperator.ParameterVar"/> /// </param> /// <param name="order">Order of the LTS algorithm</param> /// <param name="adaptive"><see cref="adaptive"/></param> /// <param name="sgrd">Sub-grid in which the local Adams-Bashforth step is evaluated</param> /// <remarks>Result of the local sub-step is saved in historyDGC, not directly in m_DGCoordinates</remarks> public ABevolve(SpatialOperator spatialOp, CoordinateMapping Fieldsmap, CoordinateMapping Parameters, int order, bool adaptive = false, SubGrid sgrd = null) : base(spatialOp, Fieldsmap, Parameters, order, null, sgrd) { this.ABSubGrid = sgrd; HistoryDGCoordinate = new Queue <double[]>(order); RungeKuttaScheme = null; // Instance of RungeKutta not needed jSub2jCell = sgrd.SubgridIndex2LocalCellIndex; numOfEdges = Fieldsmap.Fields.First().GridDat.iGeomEdges.Count; HistoryBoundaryFluxes = new Queue <double[]>(order - 1); CompleteBoundaryFluxes = new double[numOfEdges * Fieldsmap.Count]; historyTimePerCell = new Queue <double[]>(order - 1); this.adaptive = adaptive; }
/// <summary> /// Constructor for (A)LTS with IBM /// </summary> public AdamsBashforthLTS(SpatialOperator spatialOp, CoordinateMapping Fieldsmap, CoordinateMapping Parameters, int order, int numOfClusters, bool IBM, IList <TimeStepConstraint> timeStepConstraints = null, SubGrid subGrid = null, bool fluxCorrection = true, int reclusteringInterval = 0) : base(spatialOp, Fieldsmap, Parameters, order, timeStepConstraints, subGrid) { this.gridData = Fieldsmap.Fields.First().GridDat; this.fluxCorrection = fluxCorrection; if (reclusteringInterval != 0) { numberOfClustersInitial = numOfClusters; this.adaptive = true; } this.reclusteringInterval = reclusteringInterval; // Add OnBeforeComputeChangeRate (AV) to start-up phase time stepper RungeKuttaScheme.OnBeforeComputeChangeRate += (t1, t2) => this.RaiseOnBeforeComputechangeRate(t1, t2); }
/// <summary> /// Creates an instance of <see cref="IBMMassMatrixFactory"/> that is /// appropriate for the given <paramref name="mapping"/> /// </summary> /// <param name="mapping"></param> /// <returns></returns> public IBMMassMatrixFactory GetMassMatrixFactory(CoordinateMapping mapping) { if (MaMaFactCache_TrackerVersion != Tracker.VersionCnt) { MaMaFactCache.Clear(); MaMaFactCache_TrackerVersion = Tracker.VersionCnt; } int[] degCodes = mapping.BasisS.Select(bs => bs.Degree).ToArray(); if (!MaMaFactCache.ContainsKey(degCodes)) { var mmf = new IBMMassMatrixFactory(this, mapping, Control.FluidSpeciesName, Control.LevelSetQuadratureOrder); MaMaFactCache.Add(degCodes, mmf); } return(MaMaFactCache[degCodes]); }
//################# Hack for saving to database in every (A)LTS sub-step /// <summary> /// Standard constructor for the (adaptive) local time stepping algorithm /// </summary> /// <param name="spatialOp">Spatial operator</param> /// <param name="Fieldsmap">Coordinate mapping for the variable fields</param> /// <param name="Parameters">optional parameter fields, can be null if <paramref name="spatialOp"/> contains no parameters; must match the parameter field list of <paramref name="spatialOp"/>, see <see cref="BoSSS.Foundation.SpatialOperator.ParameterVar"/></param> /// <param name="order">LTS/AB order</param> /// <param name="numOfClusters">Amount of sub-grids/clusters to be used for LTS</param> /// <param name="timeStepConstraints">Time step constraints for later usage as metric</param> /// <param name="subGrid">Sub-grids, e.g., from previous time steps</param> /// <param name="fluxCorrection">Bool for triggering the fluss correction</param> /// <param name="reclusteringInterval">Interval for potential reclustering</param> /// <param name="saveToDBCallback">Hack for plotting all sub-steps</param> /// <remarks>Uses the k-Mean clustering, see <see cref="BoSSS.Solution.Utils.Kmeans"/>, to generate the element groups</remarks> public AdamsBashforthLTS(SpatialOperator spatialOp, CoordinateMapping Fieldsmap, CoordinateMapping Parameters, int order, int numOfClusters, IList <TimeStepConstraint> timeStepConstraints = null, SubGrid subGrid = null, bool fluxCorrection = true, int reclusteringInterval = 0, Action <TimestepNumber, double> saveToDBCallback = null, int initialTimestepNumber = 1) : base(spatialOp, Fieldsmap, Parameters, order, timeStepConstraints, subGrid) { if (reclusteringInterval != 0) { numberOfClustersInitial = numOfClusters; this.timestepNumber = initialTimestepNumber; this.adaptive = true; } // Add OnBeforeComputeChangeRate (AV) to start-up phase time stepper RungeKuttaScheme.OnBeforeComputeChangeRate += (t1, t2) => this.RaiseOnBeforeComputechangeRate(t1, t2); this.reclusteringInterval = reclusteringInterval; this.gridData = Fieldsmap.Fields.First().GridDat; this.fluxCorrection = fluxCorrection; NumberOfLocalTimeSteps = new List <int>(numOfClusters); clusterer = new Clusterer(this.gridData, this.TimeStepConstraints); CurrentClustering = clusterer.CreateClustering(numOfClusters, this.SubGrid); // Might remove clusters when their centres are too close CurrentClustering = CalculateNumberOfLocalTS(CurrentClustering); // Might remove clusters when time step sizes are too similar ABevolver = new ABevolve[CurrentClustering.NumberOfClusters]; for (int i = 0; i < ABevolver.Length; i++) { ABevolver[i] = new ABevolve(spatialOp, Fieldsmap, Parameters, order, adaptive: this.adaptive, sgrd: CurrentClustering.Clusters[i]); ABevolver[i].OnBeforeComputeChangeRate += (t1, t2) => this.RaiseOnBeforeComputechangeRate(t1, t2); } GetBoundaryTopology(); #if DEBUG for (int i = 0; i < CurrentClustering.NumberOfClusters; i++) { Console.WriteLine("AB LTS Ctor: id=" + i + " -> sub-steps=" + NumberOfLocalTimeSteps[i] + " and elements=" + CurrentClustering.Clusters[i].GlobalNoOfCells); } #endif // Saving time steps in subgrids //this.saveToDBCallback = saveToDBCallback; }
/// <summary> /// ctor. /// </summary> public LinearSolver(ISparseSolver solver, SpatialOperator spatialOp, CoordinateMapping UnknownsMap) { // verify input // ------------ if (!spatialOp.IsCommited) { throw new ArgumentException("operator must be committed first.", "spatialOp"); } if (spatialOp.ContainsNonlinear) { throw new ArgumentException("spatial differential operator cannot contain nonlinear components for linear solver.", "spatialOp"); } if (!spatialOp.ContainsLinear()) { throw new ArgumentException("spatial differential operator seems to contain no components.", "spatialOp"); } if (spatialOp.DomainVar.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("spatial differential operator must have the same number of domain and codomain variables.", "spatialOp"); } if (UnknownsMap.Fields.Count != spatialOp.CodomainVar.Count) { throw new ArgumentException("the number of fields in the coordinate mapping must be equal to the number of domain/codomain variables of the spatial differential operator", "fields"); } m_Mapping = UnknownsMap; m_Solver = solver; // matrix assembly // --------------- MsrMatrix eM; { eM = new MsrMatrix(m_Mapping); m_AffineOffset = new double[m_Mapping.LocalLength]; //spatialOp.ComputeMatrixEx(m_Mapping, null, m_Mapping, eM, m_AffineOffset); spatialOp.GetMatrixBuilder(m_Mapping, null, m_Mapping).ComputeMatrix(eM, m_AffineOffset); } ConstructorCommon(eM); }