/// <summary>
/// Constructor
/// </summary>
internal LevelSetRegions(LevelSetTracker owner)
{
m_owner = owner;
}
protected override void ComputeValues(NodeSet NS, int j0, int Len, MultidimensionalArray output)
{
Debug.Assert(CheckAll(j0, Len), "basis length must be equal for all cells from j0 to j0+Len");
int l0 = m_Owner.GetLength(j0);
var trk = m_Owner.Tracker;
// evaluation of un-cut polynomials
// ================================
var BasisValues = NonXEval(NS, j0, Len);
// evaluation of XDG
// =================
if (l0 == m_Owner.NonX_Basis.Length)
{
// uncut region -> evaluation is equal to uncut basis
// ++++++++++++++++++++++++++++++++++++++++++++++++++
output.Set(BasisValues);
}
else
{
// modulated basis polynomials
// +++++++++++++++++++++++++++
int NoOfLevSets = trk.LevelSets.Count;
int M = output.GetLength(1); // number of nodes
output.Clear();
ReducedRegionCode rrc;
int NoOfSpecies = trk.Regions.GetNoOfSpecies(j0, out rrc);
int Nsep = m_Owner.DOFperSpeciesPerCell;
for (int j = 0; j < Len; j++) // loop over cells
{
int jCell = j + j0;
ushort RegionCode = trk.Regions.m_LevSetRegions[jCell];
int dist = 0;
for (int i = 0; i < NoOfLevSets; i++)
{
dist = LevelSetTracker.DecodeLevelSetDist(RegionCode, i);
if (dist == 0)
{
m_levSetVals[i] = trk.DataHistories[i].Current.GetLevSetValues(NS, jCell, 1);
}
else
{
//_levSetVals[i] = m_CCBasis.Tracker.GetLevSetValues(i, NodeSet, jCell, 1);
m_levSetVals[i] = null;
m_levSetSign[i] = dist;
}
}
LevelSetSignCode levset_bytecode;
int SpecInd;
if (dist != 0)
{
// near - field:
// Basis contains zero-entries
// ++++++++++++++++++++++++++++
levset_bytecode = LevelSetSignCode.ComputeLevelSetBytecode(m_levSetSign);
SpecInd = trk.GetSpeciesIndex(rrc, levset_bytecode);
}
else
{
levset_bytecode = default(LevelSetSignCode);
SpecInd = 0;
}
for (int m = 0; m < M; m++) // loop over nodes
{
if (dist == 0)
{
// cut cells
// Modulation necessary
// +++++++++++++++++++++
for (int i = 0; i < NoOfLevSets; i++)
{
if (m_levSetVals[i] != null)
{
m_levSetSign[i] = m_levSetVals[i][0, m];
}
}
// re-compute species index
levset_bytecode = LevelSetSignCode.ComputeLevelSetBytecode(m_levSetSign);
SpecInd = trk.GetSpeciesIndex(rrc, levset_bytecode);
}
// separate coordinates
{
int n0 = Nsep * SpecInd;
for (int n = 0; n < Nsep; n++) // loop over basis polynomials
//output[j, m, n0 + n] = BasisValues[m, n];
{
Operation(output, BasisValues, j, m, n0 + n, n);
}
}
}
}
}
}
/// <summary>
/// ctor.
/// </summary>
internal NECQuadratureLevelSet(IGridData context,
XSpatialOperator DiffOp,
V __ResultVector,
IList <DGField> __DomainFields,
IList <DGField> __Parameters,
UnsetteledCoordinateMapping CodomainMap,
LevelSetTracker lsTrk, int _iLevSet, Tuple <SpeciesId, SpeciesId> SpeciesPair,
ICompositeQuadRule <QuadRule> domAndRule) //
: base(new int[] { CodomainMap.MaxTotalNoOfCoordinatesPerCell },
context,
domAndRule) //
{
// -----------------------------------
// set members / check ctor parameters
// -----------------------------------
m_lsTrk = lsTrk;
this.m_LevSetIdx = _iLevSet;
this.m_SpeciesPair = SpeciesPair;
this.ResultVector = __ResultVector;
m_CodomainMap = CodomainMap;
var _Parameters = (__Parameters != null) ? __Parameters.ToArray() : new DGField[0];
if (__DomainFields.Count != DiffOp.DomainVar.Count)
{
throw new ArgumentException("mismatch between number of domain variables in spatial operator and given domain variables");
}
if (_Parameters.Length != DiffOp.ParameterVar.Count)
{
throw new ArgumentException("mismatch between number of parameter variables in spatial operator and given parameters");
}
if (m_CodomainMap.NoOfVariables != DiffOp.CodomainVar.Count)
{
throw new ArgumentException("mismatch between number of codomain variables in spatial operator and given codomain mapping");
}
m_DomainAndParamFields = ArrayTools.Cat(__DomainFields, _Parameters);
this.DELTA = __DomainFields.Count;
// ------------------------
// sort equation components
// ------------------------
int Gamma = m_CodomainMap.NoOfVariables;
m_NonlinLsForm_V = DiffOp.GetArgMapping <INonlinLevelSetForm_V>(true,
eq => ((eq.LevelSetTerms & (TermActivationFlags.V | TermActivationFlags.UxV | TermActivationFlags.GradUxV)) != 0) && Compfilter(eq),
eq => (eq is ILevelSetForm) ? new NonlinearLevelSetFormVectorizer((ILevelSetForm)eq) : null);
m_NonlinLsForm_GradV = DiffOp.GetArgMapping <INonlinLevelSetForm_GradV>(true,
eq => ((eq.LevelSetTerms & (TermActivationFlags.GradV | TermActivationFlags.UxGradV | TermActivationFlags.GradUxGradV)) != 0) && Compfilter(eq),
eq => (eq is ILevelSetForm) ? new NonlinearLevelSetFormVectorizer((ILevelSetForm)eq) : null);
m_ValueRequired = new bool[m_DomainAndParamFields.Length];
m_GradientRequired = new bool[m_DomainAndParamFields.Length];
m_NonlinLsForm_V.DetermineReqFields(m_GradientRequired,
comp => ((comp.LevelSetTerms & (TermActivationFlags.GradUxGradV | TermActivationFlags.GradUxV)) != 0));
m_NonlinLsForm_GradV.DetermineReqFields(m_GradientRequired,
comp => ((comp.LevelSetTerms & (TermActivationFlags.GradUxGradV | TermActivationFlags.GradUxV)) != 0));
m_NonlinLsForm_V.DetermineReqFields(m_ValueRequired,
comp => ((comp.LevelSetTerms & (TermActivationFlags.UxGradV | TermActivationFlags.UxV)) != 0));
m_NonlinLsForm_GradV.DetermineReqFields(m_ValueRequired,
comp => ((comp.LevelSetTerms & (TermActivationFlags.UxGradV | TermActivationFlags.UxV)) != 0));
for (int i = __DomainFields.Count; i < m_DomainAndParamFields.Length; i++)
{
m_ValueRequired[i] = true; // parameters are always required!
}
// -----
// alloc
// -----
Koeff_V = new MultidimensionalArray[Gamma];
Koeff_GradV = new MultidimensionalArray[Gamma];
for (int gamma = 0; gamma < Gamma; gamma++)
{
Koeff_V[gamma] = new MultidimensionalArray(3);
Koeff_GradV[gamma] = new MultidimensionalArray(4);
}
int L = m_DomainAndParamFields.Length;
m_FieldValuesPos = new MultidimensionalArray[L];
m_FieldValuesNeg = new MultidimensionalArray[L];
m_FieldGradientValuesPos = new MultidimensionalArray[L];
m_FieldGradientValuesNeg = new MultidimensionalArray[L];
for (int l = 0; l < L; l++)
{
if (m_ValueRequired[l])
{
m_FieldValuesPos[l] = new MultidimensionalArray(2);
m_FieldValuesNeg[l] = new MultidimensionalArray(2);
}
if (m_GradientRequired[l])
{
m_FieldGradientValuesPos[l] = new MultidimensionalArray(3);
m_FieldGradientValuesNeg[l] = new MultidimensionalArray(3);
}
}
// ------------------
// init custom timers
// ------------------
base.CustomTimers = new Stopwatch[] { new Stopwatch(), new Stopwatch(), new Stopwatch(), new Stopwatch(), new Stopwatch() };
base.CustomTimers_Names = new string[] { "Flux-Eval", "Basis-Eval", "Loops", "ParametersAndNormals", "Field-Eval" };
base.CustomTimers_RootPointer = new int[5];
ArrayTools.SetAll(base.CustomTimers_RootPointer, -1);
this.m_NonlinLsForm_V_Watches = this.m_NonlinLsForm_V.InitStopWatches(0, this);
this.m_NonlinLsForm_GradV_Watches = this.m_NonlinLsForm_GradV.InitStopWatches(0, this);
Flux_Eval = base.CustomTimers[0];
Basis_Eval = base.CustomTimers[1];
Loops = base.CustomTimers[2];
ParametersAndNormals = base.CustomTimers[3];
Field_Eval = base.CustomTimers[4];
}
/// <summary>
/// Legacy interface, preserved as static function.
/// </summary>
static public void ComputeMatrixEx <M, V>(
this XSpatialOperator xOp,
LevelSetTracker lsTrk,
UnsetteledCoordinateMapping DomainMap, IList <DGField> Parameters, UnsetteledCoordinateMapping CodomainMap,
M Matrix, V AffineOffset, bool OnlyAffine, double time, bool MPIParameterExchange,
IDictionary <SpeciesId, XSpatialOperator.QrSchemPair> SpeciesSchemes, IDictionary <SpeciesId, MultidimensionalArray> CellLengthScales,
IDictionary <SpeciesId, MultidimensionalArray> InterfaceLengthScales, MultidimensionalArray SlipLengths = null,
SubGrid SubGrid = null)
where M : IMutableMatrixEx
where V : IList <double> //
{
CellMask SubGridCellMask = null;
EdgeMask SubGridEdgeMask = null;
if (SubGrid != null)
{
SubGridCellMask = SubGrid.VolumeMask;
/// I don't know why, but this seems to work:
SubGridEdgeMask = SubGrid.AllEdgesMask;
/// And this does not:
//SubGridEdgeMask = SubGrid.InnerEdgesMask;
}
SpeciesId[] ReqSpecies = SpeciesSchemes.Keys.ToArray();
//int order = xOp.GetOrderFromQuadOrderFunction(DomainMap, Parameters, CodomainMap);
//var SchemeHelper = lsTrk.GetXDGSpaceMetrics(ReqSpecies, order, 1).XQuadSchemeHelper;
//var SpeciesSchemes_out = new Dictionary<SpeciesId, XSpatialOperator.QrSchemPair>();
//foreach(var SpeciesId in SpeciesSchemes.Keys) {
// EdgeQuadratureScheme edgeScheme;
// CellQuadratureScheme cellScheme;
// var qrSchemes = SpeciesSchemes[SpeciesId];
// bool AssembleOnFullGrid = (SubGrid == null);
// if(qrSchemes.EdgeScheme == null) {
// edgeScheme = SchemeHelper.GetEdgeQuadScheme(SpeciesId, AssembleOnFullGrid, SubGridEdgeMask);
// } else {
// //edgeScheme = qrSchemes.EdgeScheme;
// //throw new ArgumentException();
// }
// if(qrSchemes.CellScheme == null) {
// cellScheme = SchemeHelper.GetVolumeQuadScheme(SpeciesId, AssembleOnFullGrid, SubGridCellMask);
// } else {
// //cellScheme = qrSchemes.CellScheme;
// throw new ArgumentException();
// }
// SpeciesSchemes_out.Add(SpeciesId,
// new XSpatialOperator.QrSchemPair() {
// CellScheme = cellScheme,
// EdgeScheme = edgeScheme
// });
//}
var ev = xOp.GetMatrixBuilder(lsTrk, DomainMap, Parameters, CodomainMap, SpeciesSchemes);
ev.time = time;
ev.MPITtransceive = MPIParameterExchange;
foreach (var s in CellLengthScales.Keys)
{
if (ev.SpeciesOperatorCoefficients.ContainsKey(s))
{
ev.SpeciesOperatorCoefficients[s].CellLengthScales = CellLengthScales[s];
}
else
{
ev.SpeciesOperatorCoefficients.Add(s,
new CoefficientSet()
{
CellLengthScales = CellLengthScales[s],
GrdDat = lsTrk.GridDat
});
}
if (InterfaceLengthScales != null)
{
ev.SpeciesOperatorCoefficients[s].UserDefinedValues["InterfaceLengths"] = InterfaceLengthScales[s];
}
if (SlipLengths != null)
{
ev.SpeciesOperatorCoefficients[s].UserDefinedValues["SlipLengths"] = SlipLengths;
}
}
if (OnlyAffine)
{
ev.ComputeAffine(AffineOffset);
}
else
{
ev.ComputeMatrix(Matrix, AffineOffset);
}
}
