/// <summary> /// Dispatcher to determine the correct sub-class of /// <see cref="BoundaryConditionSource"/> when creating a source term /// for a specific equation component. /// </summary> public static BoundaryConditionSource CreateBoundaryConditionSource( this IEquationComponent equationComponent, CNSControl control, ISpeciesMap speciesMap, BoundaryCondition boundaryCondition) { BoundaryConditionSource result; if (equationComponent is INonlinearFlux) { result = new BoundaryConditionSourceFromINonlinearFlux( control, speciesMap, boundaryCondition, (INonlinearFlux)equationComponent); } else if (equationComponent is SIPGFlux) { result = new BoundaryConditionSourceFromSIPGFlux( control, speciesMap, boundaryCondition, (SIPGFlux)equationComponent); } else if (equationComponent is INonlinear2ndOrderForm) { result = new BoundaryConditionSourceFromINonlinear2ndOrderForm( control, speciesMap, boundaryCondition, (INonlinear2ndOrderForm)equationComponent); } else { throw new NotImplementedException("To do"); } return(result); }
/// <summary> /// % /// </summary> protected FormDifferentiatorCommon(IEquationComponent vf, TermActivationFlags __Terms, int SpatialDimension) { m_OrgForm = vf; m_eps = Math.Sqrt(BLAS.MachineEps); m_SpatialDimension = SpatialDimension; Terms = __Terms; if ((Terms & (TermActivationFlags.GradUxV | TermActivationFlags.UxV)) != 0) { Terms |= TermActivationFlags.V; } if ((Terms & (TermActivationFlags.GradUxGradV | TermActivationFlags.UxGradV)) != 0) { Terms |= TermActivationFlags.GradV; } // Parameters for form derivative // ============================== ParamUreq = (Terms & (TermActivationFlags.UxGradV | TermActivationFlags.UxV)) != 0; ParamGradUreq = (Terms & (TermActivationFlags.GradUxGradV | TermActivationFlags.GradUxV)) != 0; m_ParameterOrdering = new string[0]; // original parameters OffsetOrgParams = m_ParameterOrdering.Length; if (vf.ParameterOrdering != null && vf.ParameterOrdering.Count > 0) { m_ParameterOrdering = m_ParameterOrdering.Cat(vf.ParameterOrdering); NoOfOrgParams = vf.ParameterOrdering.Count; } else { NoOfOrgParams = 0; } // U in linearization point OffsetUparams = m_ParameterOrdering.Length; if (ParamUreq && vf.ArgumentOrdering != null && vf.ArgumentOrdering.Count > 0) { m_ParameterOrdering = m_ParameterOrdering.Cat(vf.ArgumentOrdering.Select(fn => fn + "_lin")); } // derivatives in linearization point OffsetGradUparams = m_ParameterOrdering.Length; if (ParamGradUreq && vf.ArgumentOrdering != null && vf.ArgumentOrdering.Count > 0) { foreach (string arg in vf.ArgumentOrdering) { m_ParameterOrdering = m_ParameterOrdering.Cat(SpatialDimension.ForLoop(d => arg + "_lin_d[" + d + "]")); } } }
/// <summary> /// creates the spatial operator that consists only of component <paramref name="c"/> /// </summary> public static SpatialOperator Operator(this IEquationComponent c, Func <int[], int[], int[], int> quadOrderFunc) { string[] Codomain = new string[] { "v1" }; string[] Domain = c.ArgumentOrdering.ToArray(); string[] Param = (c.ParameterOrdering != null) ? c.ParameterOrdering.ToArray() : new string[0]; SpatialOperator ret = new SpatialOperator(Domain, Param, Codomain, quadOrderFunc); ret.EquationComponents[Codomain[0]].Add(c); ret.Commit(); return(ret); }
/// <summary> /// creates the spatial operator that consists only of component <paramref name="c"/> /// </summary> public static XSpatialOperatorMk2 XOperator(this IEquationComponent c, IEnumerable <string> species, Func <int[], int[], int[], int> quadOrderFunc) { string[] Codomain = new string[] { "v1" }; string[] Domain = c.ArgumentOrdering.ToArray(); string[] Param = (c.ParameterOrdering != null) ? c.ParameterOrdering.ToArray() : new string[0]; XSpatialOperatorMk2 ret = new XSpatialOperatorMk2(Domain, Param, Codomain, quadOrderFunc, species); ret.EquationComponents[Codomain[0]].Add(c); ret.Commit(); return(ret); }
private bool Compfilter(IEquationComponent c) { ILevelSetComponent b = (ILevelSetComponent)c; if (this.m_LevSetIdx != b.LevelSetIndex) { // component is not relevant for this level-set return(false); } if (!(this.m_SpeciesPair.Contains(b.PositiveSpecies) && this.m_SpeciesPair.Contains(b.NegativeSpecies))) { // component is not relevant for this level-set return(false); } // filter passed return(true); }
private bool Compfilter(IEquationComponent c) { ILevelSetForm b = (ILevelSetForm)c; if (this.m_LevSetIdx != b.LevelSetIndex) { // component is not relevant for this level-set return(false); } if (!(this.SpeciesA == b.NegativeSpecies && this.SpeciesB == b.PositiveSpecies)) { // component is not relevant for this level-set return(false); } // filter passed return(true); }
/// <summary> /// creates the spatial operator that consists only of component <paramref name="c"/> /// </summary> public static SpatialOperator Operator(this IEquationComponent c, Func <int[], int[], int[], int> quadOrderFunc, Func <IGridData, EdgeQuadratureScheme> edgeSchemeProvider = null, Func <IGridData, CellQuadratureScheme> cellSchemeProvider = null) { string[] Codomain = new string[] { "v1" }; string[] Domain = c.ArgumentOrdering.ToArray(); string[] Param = (c.ParameterOrdering != null) ? c.ParameterOrdering.ToArray() : new string[0]; SpatialOperator ret = new SpatialOperator(Domain, Param, Codomain, quadOrderFunc); if (edgeSchemeProvider != null) { ret.EdgeQuadraturSchemeProvider = edgeSchemeProvider; } if (cellSchemeProvider != null) { ret.VolumeQuadraturSchemeProvider = cellSchemeProvider; } ret.EquationComponents[Codomain[0]].Add(c); ret.Commit(); return(ret); }
/// <summary> /// /// </summary> /// <param name="DiffOp"></param> /// <param name="CoDomVarName"> /// the name of the variable in the codomain (<see cref="SpatialOperator.CodomainVar"/>-member /// of <paramref name="DiffOp"/>, for which this object should be defined; /// </param> /// <param name="_fieldList"> /// list of domain variable names /// </param> /// <param name="_fieldList2"> /// optional (i.e. can be null) /// list of parameter variable names; /// will be concatenated with <paramref name="_fieldList"/> /// </param> /// <param name="F">optional filter, can be null.</param> /// <param name="vectorizer"> /// Function for the vectorization of the evaluation of <paramref name="F"/> /// </param> internal EquationComponentArgMapping(SpatialOperator DiffOp, string CoDomVarName, IList <string> _fieldList, IList <string> _fieldList2, Func <T, bool> F, Func <IEquationComponent, IEquationComponent> vectorizer) { m_CoDomVarName = CoDomVarName; //m_DomainFields = DomainMapping.Fields; // ================= // concat field list // ================= IList <string> fieldList; if (_fieldList2 != null) { fieldList = Enumerable.Concat(_fieldList, _fieldList2).ToList(); } else { fieldList = _fieldList; } // ========================================= // collect all equation components of type T // ========================================= ICollection <IEquationComponent> eqCompS = DiffOp.EquationComponents[CoDomVarName]; List <T> AllComponentsofMyType = new List <T>(); foreach (IEquationComponent eqComp in eqCompS) { if (eqComp is T) { T _eqComp = (T)eqComp; if (F == null || F(_eqComp)) { AllComponentsofMyType.Add(_eqComp); } } else if (vectorizer != null) { IEquationComponent VeqComp = vectorizer(eqComp); if (VeqComp != null && VeqComp is T) { T _VeqComp = (T)VeqComp; if (F == null || F(_VeqComp)) { AllComponentsofMyType.Add(_VeqComp); } } } } m_AllComponentsOfMyType = AllComponentsofMyType.ToArray(); // ====================== // build argument mapping // ====================== int argMapMaxCount = 0; foreach (var w in m_AllComponentsOfMyType) { int c = w.ArgumentOrdering.Count; if (w.ParameterOrdering != null) { c += w.ParameterOrdering.Count; } argMapMaxCount = Math.Max(argMapMaxCount, c); } AllToSub = new int[m_AllComponentsOfMyType.Length, argMapMaxCount]; NoOfArguments = new int[m_AllComponentsOfMyType.Length]; NoOfParameters = new int[m_AllComponentsOfMyType.Length]; //ArrayTools.SetAll(AllToSub, int.MinValue); AllToSub.SetAll(int.MinValue); //IList<string> fieldList = DiffOp.DomainVar; for (int i = 0; i < AllToSub.GetLength(0); i++) { // arguments... IList <string> argMap = m_AllComponentsOfMyType[i].ArgumentOrdering; NoOfArguments[i] = argMap.Count; for (int j = 0; j < NoOfArguments[i]; j++) { int ifound = fieldList.IndexOf(argMap[j]); AllToSub[i, j] = ifound; Debug.Assert(AllToSub[i, j] >= 0); } // parameters... IList <string> paramMap = m_AllComponentsOfMyType[i].ParameterOrdering; if (paramMap != null) { NoOfParameters[i] = paramMap.Count; for (int j = 0; j < NoOfParameters[i]; j++) { AllToSub[i, j + NoOfArguments[i]] = fieldList.IndexOf(paramMap[j]); Debug.Assert(AllToSub[i, j + NoOfArguments[i]] >= 0); } } } }
/// <summary> /// creates the spatial operator that consists only of component <paramref name="c"/> /// </summary> public static SpatialOperator Operator(this IEquationComponent c, int DegreeOfNonlinearity = 1) { return(Operator(c, QuadOrderFunc.NonLinear(DegreeOfNonlinearity))); }
/// <summary> /// creates the spatial operator that consists only of component <paramref name="c"/> /// </summary> public static XSpatialOperatorMk2 XOperator(this IEquationComponent c, IEnumerable <string> species, int DegreeOfNonlinearity = 1) { return(XOperator(c, species, QuadOrderFunc.NonLinear(DegreeOfNonlinearity))); }
/// <summary> /// creates the spatial operator that consists only of component <paramref name="c"/> /// </summary> public static SpatialOperator Operator(this IEquationComponent c, int DegreeOfNonlinearity = 1, Func <IGridData, EdgeQuadratureScheme> edgeSchemeProvider = null, Func <IGridData, CellQuadratureScheme> cellSchemeProvider = null) { return(Operator(c, QuadOrderFunc.NonLinear(DegreeOfNonlinearity), edgeSchemeProvider, cellSchemeProvider)); }