/// <summary>
/// Constructs the quadrature rules all edges of all cells in
/// <paramref name="mask"/>. For edges that are not intersected by the
/// zero iso-contour, standard Gaussian quadrature rules of
/// sufficiently high order will be used.
/// </summary>
/// <param name="mask">
/// Cells for which quadrature rules shall be created
/// </param>
/// <param name="order">
/// Desired order of the moment-fitting system. Assuming that
/// <see cref="edgeSurfaceRuleFactory"/> integrates the basis
/// polynomials exactly over the zero iso-contour (which it usually
/// doesn't!), the resulting quadrature rules will be exact up to this
/// order.
/// </param>
/// <returns>A set of quadrature rules</returns>
/// <remarks>
/// Since the selected level set is generally discontinuous across cell
/// boundaries, this method does not make use of the fact that
/// neighboring cells share edges. That is, the optimization will be
/// performed twice for each inner edge in <paramref name="mask"/>.
/// </remarks>
public IEnumerable <IChunkRulePair <CellBoundaryQuadRule> > GetQuadRuleSet(ExecutionMask mask, int order)
{
using (var tr = new FuncTrace()) {
if (!(mask is CellMask))
{
throw new ArgumentException("CellMask required", "mask");
}
if (mask.MaskType != MaskType.Geometrical)
{
throw new ArgumentException("Expecting a geometrical mask.");
}
int noOfEdges = LevelSetData.GridDat.Grid.RefElements[0].NoOfFaces;
CellMask tmpLogicalMask = new CellMask(mask.GridData, mask.GetBitMask(), MaskType.Logical);
#if DEBUG
CellMask differingCells = tmpLogicalMask.Except(this.LevelSetData.Region.GetCutCellMask4LevSet(this.levelSetIndex));
if (differingCells.NoOfItemsLocally > 0)
{
throw new ArgumentException("The provided mask has to be a sub-set of the cut cells. " +
"Cells {0} are not in the CutCellMaks of this tracker.", differingCells.GetSummary());
}
#endif
subGrid = new SubGrid(tmpLogicalMask);
localCellIndex2SubgridIndex = subGrid.LocalCellIndex2SubgridIndex;
if (order != lastOrder)
{
cache.Clear();
SwitchOrder(order);
}
var result = new List <ChunkRulePair <CellBoundaryQuadRule> >(mask.NoOfItemsLocally);
CellBoundaryQuadRule[] optimizedRules = GetOptimizedRules((CellMask)mask, order);
int n = 0;
foreach (Chunk chunk in mask)
{
foreach (int cell in chunk.Elements)
{
if (cache.ContainsKey(cell))
{
result.Add(new ChunkRulePair <CellBoundaryQuadRule>(
Chunk.GetSingleElementChunk(cell), cache[cell]));
}
else
{
cache.Add(cell, optimizedRules[n]);
result.Add(new ChunkRulePair <CellBoundaryQuadRule>(
Chunk.GetSingleElementChunk(cell), optimizedRules[n]));
}
n++;
}
}
return(result);
}
}
/// <summary>
/// Sets the positive Far-field of the level-set to +1 and the negative side to -1
/// </summary>
/// <param name="LevelSet"></param>
/// <param name="Domain"></param>
/// <param name="PosMask"></param>
public void SetFarField(SinglePhaseField LevelSet, CellMask Domain, CellMask PosMask)
{
// set cells outside narrow band to +/- 1
var Pos = PosMask.Except(Domain);
var Neg = PosMask.Complement().Except(Domain);
LevelSet.Clear(Pos);
LevelSet.AccConstant(1, Pos);
LevelSet.Clear(Neg);
LevelSet.AccConstant(-1, Neg);
}
/// <summary>
/// Polynomial extrapolation between cells.
/// </summary>
/// <param name="ExtrapolateTo">contains all cells for which extrapolated values should be computed</param>
/// <param name="ExtrapolateFrom">contains all cells with "known values"</param>
/// <returns>
/// The number of cells (locally) for which the algorithm was not able to extrapolate a value
/// </returns>
virtual public int CellExtrapolation(CellMask ExtrapolateTo, CellMask ExtrapolateFrom)
{
MPICollectiveWatchDog.Watch();
int J = this.GridDat.iLogicalCells.NoOfLocalUpdatedCells;
int NoOfNeigh;
int[] NeighIdx;
int[][] CN = this.GridDat.iLogicalCells.CellNeighbours;
// mark all cells in which species 'Id' is known
// ---------------------------------------------
BitArray ValueIsKnown = ExtrapolateFrom.GetBitMaskWithExternal().CloneAs();
CellMask _ExtrapolateTo = ExtrapolateTo.Except(ExtrapolateFrom);
BitArray NeedToKnowValue = _ExtrapolateTo.GetBitMask();
this.Clear(_ExtrapolateTo);
// repeat until (for species 'Id' the DOF' of) all cells
// that contain (at least a fraction of) species 'Id' are known...
// ------------------------------------------------------------------
int NoOfCells_ToExtrapolate = _ExtrapolateTo.NoOfItemsLocally;
int NoOfCells_ExtrapolatedInSweep = 1;
int sweepcnt = 0;
List <double> scaling = new List <double>();
List <int[]> CellPairs = new List <int[]>();
BitArray cells_mod_in_sweep = new BitArray(J);
while (true)
{
// MPI-parallel evaluation of termination criterion
// ------------------------------------------------
int bool_LocalRun = ((NoOfCells_ToExtrapolate > 0) && (NoOfCells_ExtrapolatedInSweep > 0)) ? 1 : 0;
int bool_GlobalRun = 0;
unsafe
{
csMPI.Raw.Allreduce((IntPtr)(&bool_LocalRun), (IntPtr)(&bool_GlobalRun), 1, csMPI.Raw._DATATYPE.INT, csMPI.Raw._OP.MAX, csMPI.Raw._COMM.WORLD);
}
if (bool_GlobalRun <= 0)
{
// finished on all MPI processors
break;
}
// MPI-update before local sweep: necessary for consistent result of alg.
this.MPIExchange();
if (sweepcnt > 0)
{
ValueIsKnown.MPIExchange(this.GridDat);
}
// local work
// ----------
if (bool_LocalRun > 0)
{
sweepcnt++;
NoOfCells_ExtrapolatedInSweep = 0;
scaling.Clear();
CellPairs.Clear();
cells_mod_in_sweep.SetAll(false);
for (int j = 0; j < J; j++)
{
// determine whether there is something to do for cell 'j' or not ...
bool needToKnowSpecies = NeedToKnowValue[j];
bool _mustbeExtrapolated = needToKnowSpecies && !ValueIsKnown[j];
if (_mustbeExtrapolated)
{
// continuation for this cell is needed
// ++++++++++++++++++++++++++++++++++++
// try to find a neighbour
NeighIdx = CN[j].CloneAs();
NoOfNeigh = NeighIdx.Length;
int FoundNeighs = 0;
for (int nn = 0; nn < NoOfNeigh; nn++)
{
if (ValueIsKnown[NeighIdx[nn]])
{
// bingo
FoundNeighs++;
}
else
{
NeighIdx[nn] = -1; // not usable
}
}
if (FoundNeighs <= 0)
{
// hope for better luck in next sweep
continue;
}
//Array.Clear(u2, 0, N);
for (int nn = 0; nn < NoOfNeigh; nn++)
{
if (NeighIdx[nn] < 0)
{
continue;
}
int _2 = j; // cell to extrapolate TO
int _1 = NeighIdx[nn]; // cell to extrapolate FROM
CellPairs.Add(new int[] { _1, _2 });
double ooFoundNeighs = 1.0 / (double)FoundNeighs;
scaling.Add(ooFoundNeighs);
}
cells_mod_in_sweep[j] = true;
NoOfCells_ExtrapolatedInSweep++;
}
}
int E = CellPairs.Count;
int[,] _CellPairs = new int[E, 2];
for (int e = 0; e < E; e++)
{
_CellPairs.SetRow(e, CellPairs[e]);
}
double[] preScale = new double[scaling.Count];
preScale.SetAll(1.0);
this.CellExtrapolation(_CellPairs, scaling, preScale);
for (int j = 0; j < J; j++)
{
if (cells_mod_in_sweep[j] == true)
{
ValueIsKnown[j] = true;
}
}
NoOfCells_ToExtrapolate -= NoOfCells_ExtrapolatedInSweep;
}
}
// return
// ------
return(NoOfCells_ToExtrapolate);
}
/// <summary>
/// Reinit on un-cut cells.
/// </summary>
/// <param name="Phi">The level set</param>
/// <param name="ReInitSpecies">Cell mask wich is to be reinitialized</param>
/// <param name="sign">Sign of the level set for this <paramref name="ReInitSpecies"/></param>
/// <param name="_Accepted">CellMask which is taken as boundray values</param>
/// <param name="GradPhi">LEvel Set gradient</param>
/// <param name="callBack">A delegate, which might be called after the execution of the reinitialization</param>
public void Reinitialize(SinglePhaseField Phi, CellMask ReInitSpecies, double sign,
CellMask _Accepted,
//ConventionalDGField[] ExtProperty, double[][] ExtPropertyMin, double[][] ExtPropertyMax,
VectorField <SinglePhaseField> GradPhi, Action <int> callBack) //
{
using (new FuncTrace()) {
Tracer.InstrumentationSwitch = false; // lots of tracing on calls acting on singe cells causes massive overhead (up to 5x slower).
Stpw_total.Start();
SinglePhaseField DiffusionCoeff = new SinglePhaseField(new Basis(this.GridDat, 1), "DiffusionCoeff");
// check args and init
// ===================
/*
* ExtVelSolver extVelSlv = null;
* if(ExtProperty != null) {
* if(ExtProperty.Length != ExtPropertyMin.Length)
* throw new ArgumentException();
* if(ExtProperty.Length != ExtPropertyMax.Length)
* throw new ArgumentException();
*
* extVelSlv = new ExtVelSolver(ExtProperty[0].Basis);
* }
*/
BitArray Acceped_Mutuable = _Accepted.GetBitMask().CloneAs();
BitArray Trial_Mutuable = ((_Accepted.AllNeighbourCells().Intersect(ReInitSpecies)).Except(_Accepted)).GetBitMask().CloneAs();
BitArray Recalc_Mutuable = Trial_Mutuable.CloneAs();
BitArray PosSpecies_Bitmask = ReInitSpecies.GetBitMask();
int J = this.GridDat.Cells.NoOfCells;
int D = this.GridDat.SpatialDimension;
int N = this.LevelSetBasis.Length;
double _sign = sign >= 0 ? 1.0 : -1.0;
double[] PhiAvg = m_PhiAvg;
if (PhiAvg == null)
{
throw new ApplicationException();
}
foreach (int jCell in _Accepted.ItemEnum)
{
PhiAvg[jCell] = Phi.GetMeanValue(jCell);
}
int NoOfNew;
{
var Neu = ReInitSpecies.Except(_Accepted);
NoOfNew = Neu.NoOfItemsLocally;
Phi.Clear(Neu);
Phi.AccConstant(_sign, Neu);
foreach (int jCell in Neu.ItemEnum)
{
PhiAvg[jCell] = 1.0e10;
}
}
if (this.GridDat.MpiSize > 1)
{
throw new NotSupportedException("Currently not MPI parallel.");
}
for (int d = 0; d < this.GridDat.SpatialDimension; d++)
{
if (!GradPhi[d].Basis.Equals(Phi.Basis))
{
throw new ArgumentException("Level-set and level-set gradient field should have the same DG basis."); // ein grad niedriger wrürde auch genügen...
}
}
// perform marching...
// ===================
// update gradient for cut-cells
GradPhi.Clear(_Accepted);
GradPhi.Gradient(1.0, Phi, _Accepted);
// marching loop../
int cnt = 0;
while (true)
{
cnt++;
CellMask Recalc = new CellMask(this.GridDat, Recalc_Mutuable);
CellMask Accepted = new CellMask(this.GridDat, Acceped_Mutuable);
CellMask Trial = new CellMask(this.GridDat, Trial_Mutuable);
int NoOfTrial = Trial.NoOfItemsLocally;
int NoOfAccpt = Accepted.NoOfItemsLocally;
int NoOfRcalc = Recalc.NoOfItemsLocally;
if (Trial.NoOfItemsLocally <= 0)
{
//Ploti(Recalc, Accepted, Trial, Phi, Phi_gradient, optEikonalOut, cnt);
break;
}
// Local solver for all 'Recalc'-cells
// --------------------------------------
if (Recalc.NoOfItemsLocally > 0)
{
this.LocalSolve(Accepted, Recalc, Phi, GradPhi, _sign, DiffusionCoeff);
}
// find the next cell to accept
// ----------------------------
// get mean value in all cells
foreach (int jCell in Recalc.ItemEnum)
{
PhiAvg[jCell] = Phi.GetMeanValue(jCell);
Recalc_Mutuable[jCell] = false;
}
//Ploti(Recalc, Accepted, Trial, Phi, Phi_gradient, optEikonalOut, cnt);
// find trial-cell with minimum average value
// this should be done with heap-sort (see fast-marching algorithm)
int jCellAccpt = int.MaxValue;
double TrialMin = double.MaxValue;
foreach (int jCell in Trial.ItemEnum)
{
if (PhiAvg[jCell] * _sign < TrialMin)
{
TrialMin = PhiAvg[jCell] * _sign;
jCellAccpt = jCell;
}
}
if (callBack != null)
{
callBack(cnt);
}
/*
* // update the gradient
* // -------------------
*
* this.Stpw_gradientEval.Start();
* gradModule.GradientUpdate(jCellAccpt, Acceped_Mutuable, Phi, GradPhi);
* this.Stpw_gradientEval.Stop();
*
* /*
* // solve for the extension properties
* // ----------------------------------
*
* if(ExtProperty != null) {
* int[] Neight, dummy33;
* GridDat.Cells.GetCellNeighbours(jCellAccpt, GridData.CellData.GetCellNeighbours_Mode.ViaEdges, out Neight, out dummy33);
*
* for(int iComp = 0; iComp < ExtProperty.Length; iComp++) {
*
* ExtPropertyMax[iComp][jCellAccpt] = -double.MaxValue;
* ExtPropertyMin[iComp][jCellAccpt] = double.MaxValue;
*
* foreach(int jNeig in Neight) {
* if(Acceped_Mutuable[jNeig]) {
* ExtPropertyMax[iComp][jCellAccpt] = Math.Max(ExtPropertyMax[iComp][jCellAccpt], ExtPropertyMax[iComp][jNeig]);
* ExtPropertyMin[iComp][jCellAccpt] = Math.Min(ExtPropertyMin[iComp][jCellAccpt], ExtPropertyMin[iComp][jNeig]);
* }
* }
*
* this.Stpw_extVelSolver.Start();
* extVelSlv.ExtVelSolve_Far(Phi, GradPhi, ExtProperty[iComp], ref ExtPropertyMin[iComp][jCellAccpt], ref ExtPropertyMax[iComp][jCellAccpt], jCellAccpt, Accepted, _sign);
* this.Stpw_extVelSolver.Stop();
* }
* }
* /*
* {
* int[] Neight, dummy33;
* GridDat.Cells.GetCellNeighbours(jCellAccpt, GridData.CellData.GetCellNeighbours_Mode.ViaEdges, out Neight, out dummy33);
* foreach(int jNeig in Neight) {
* if(Acceped_Mutuable[jNeig]) {
* plotDependencyArrow(cnt, jCellAccpt, jNeig);
* }
* }
* }
*/
// the mimium is moved to accepted
// -------------------------------
Acceped_Mutuable[jCellAccpt] = true;
Trial_Mutuable[jCellAccpt] = false;
Recalc_Mutuable[jCellAccpt] = false;
NoOfNew--;
// recalc on all neighbours
// ------------------------
int[] Neighs, dummy;
this.GridDat.GetCellNeighbours(jCellAccpt, GetCellNeighbours_Mode.ViaEdges, out Neighs, out dummy);
foreach (int jNeig in Neighs)
{
if (!Acceped_Mutuable[jNeig] && PosSpecies_Bitmask[jNeig])
{
Trial_Mutuable[jNeig] = true;
Recalc_Mutuable[jNeig] = true;
}
}
}
if (NoOfNew > 0)
{
throw new ArithmeticException("Unable to perform reinitialization for all requested cells - maybe they are not reachable from the initialy 'accepted' domain?");
}
//PlottAlot("dependencies.csv");
Tracer.InstrumentationSwitch = true;
Stpw_total.Stop();
}
}
/// <summary>
/// Constructs suitable quadrature rules cells in
/// <paramref name="mask"/>.
/// </summary>
/// <param name="mask">
/// Cells for which quadrature rules shall be created
/// </param>
/// <param name="order">
/// Desired order of the moment-fitting system. Assuming that
/// <see cref="surfaceRuleFactory"/> integrates the basis polynomials
/// exactly over the zero iso-contour (which it usually
/// doesn't!), the resulting quadrature rules will be exact up to this
/// order.
/// </param>
/// <returns>A set of quadrature rules</returns>
/// <remarks>
/// Since the selected level set is generally discontinuous across cell
/// boundaries, this method does not make use of the fact that
/// neighboring cells share edges. That is, the optimization will be
/// performed twice for each inner edge in <paramref name="mask"/>.
/// </remarks>
public IEnumerable <IChunkRulePair <QuadRule> > GetQuadRuleSet(ExecutionMask mask, int order)
{
using (var tr = new FuncTrace()) {
CellMask cellMask = mask as CellMask;
if (cellMask == null)
{
throw new ArgumentException("Mask must be a volume mask", "mask");
}
// Note: This is a parallel call, so do this early to avoid parallel confusion
localCellIndex2SubgridIndex = new SubGrid(cellMask).LocalCellIndex2SubgridIndex;
int maxLambdaDegree = order + 1;
int noOfLambdas = GetNumberOfLambdas(maxLambdaDegree);
int noOfEdges = LevelSetData.GridDat.Grid.RefElements[0].NoOfFaces;
int D = RefElement.SpatialDimension;
// Get the basis polynomials and integrate them analytically
Polynomial[] basePolynomials = RefElement.GetOrthonormalPolynomials(order).ToArray();
Polynomial[] polynomials = new Polynomial[basePolynomials.Length * D];
for (int i = 0; i < basePolynomials.Length; i++)
{
Polynomial p = basePolynomials[i];
for (int d = 0; d < D; d++)
{
Polynomial pNew = p.CloneAs();
for (int j = 0; j < p.Coeff.Length; j++)
{
pNew.Exponents[j, d]++;
pNew.Coeff[j] /= pNew.Exponents[j, d];
pNew.Coeff[j] /= D; // Make sure divergence is Phi again
}
polynomials[i * D + d] = pNew;
}
}
// basePolynomials[i] == div(polynomials[i*D], ... , polynomials[i*D + D - 1])
lambdaBasis = new PolynomialList(polynomials);
if (RestrictNodes)
{
trafos = new AffineTrafo[mask.NoOfItemsLocally];
foreach (Chunk chunk in mask)
{
foreach (var cell in chunk.Elements.AsSmartEnumerable())
{
CellMask singleElementMask = new CellMask(
LevelSetData.GridDat, Chunk.GetSingleElementChunk(cell.Value));
LineAndPointQuadratureFactory.LineQRF lineFactory = this.edgeRuleFactory as LineAndPointQuadratureFactory.LineQRF;
if (lineFactory == null)
{
throw new Exception();
}
var lineRule = lineFactory.GetQuadRuleSet(singleElementMask, order).Single().Rule;
var pointRule = lineFactory.m_Owner.GetPointFactory().GetQuadRuleSet(singleElementMask, order).Single().Rule;
// Also add point rule points since line rule points
// are constructed from Gauss rules that do not include
// the end points
BoundingBox box = new BoundingBox(lineRule.Nodes);
box.AddPoints(pointRule.Nodes);
int noOfRoots = pointRule.Nodes.GetLength(0);
if (noOfRoots <= 1)
{
// Cell is considered cut because the level set
// is very close, but actually isn't. Note that
// we can NOT omit the cell (as in the surface
// case) as it will be missing in the list of
// uncut cells, i.e. this cell would be ignored
// completely
trafos[localCellIndex2SubgridIndex[cell.Value]] =
AffineTrafo.Identity(RefElement.SpatialDimension);
continue;
}
else if (noOfRoots == 2)
{
// Go a bit into the direction of the normal
// from the center between the nodes in order
// not to miss regions with strong curvature
double[] center = box.Min.CloneAs();
center.AccV(1.0, box.Max);
center.ScaleV(0.5);
NodeSet centerNode = new NodeSet(RefElement, center);
centerNode.LockForever();
MultidimensionalArray normal = LevelSetData.GetLevelSetReferenceNormals(centerNode, cell.Value, 1);
MultidimensionalArray dist = LevelSetData.GetLevSetValues(centerNode, cell.Value, 1);
double scaling = Math.Sqrt(LevelSetData.GridDat.Cells.JacobiDet[cell.Value]);
double[] newPoint = new double[D];
for (int d = 0; d < D; d++)
{
newPoint[d] = center[d] - normal[0, 0, d] * dist[0, 0] / scaling;
}
box.AddPoint(newPoint);
// Make sure points stay in box
for (int d = 0; d < D; d++)
{
box.Min[d] = Math.Max(box.Min[d], -1);
box.Max[d] = Math.Min(box.Max[d], 1);
}
}
MultidimensionalArray preImage = RefElement.Vertices.ExtractSubArrayShallow(
new int[] { 0, 0 }, new int[] { D, D - 1 });
MultidimensionalArray image = MultidimensionalArray.Create(D + 1, D);
image[0, 0] = box.Min[0]; // Top left
image[0, 1] = box.Max[1];
image[1, 0] = box.Max[0]; // Top right
image[1, 1] = box.Max[1];
image[2, 0] = box.Min[0]; // Bottom left;
image[2, 1] = box.Min[1];
AffineTrafo trafo = AffineTrafo.FromPoints(preImage, image);
trafos[localCellIndex2SubgridIndex[cell.Value]] = trafo;
}
}
}
LambdaCellBoundaryQuadrature cellBoundaryQuadrature =
new LambdaCellBoundaryQuadrature(this, edgeRuleFactory, cellMask);
cellBoundaryQuadrature.Execute();
LambdaLevelSetSurfaceQuadrature surfaceQuadrature =
new LambdaLevelSetSurfaceQuadrature(this, surfaceRuleFactory, cellMask);
surfaceQuadrature.Execute();
// Must happen _after_ all parallel calls (e.g., definition of
// the sub-grid or quadrature) in order to avoid problems in
// parallel runs
if (mask.NoOfItemsLocally == 0)
{
var empty = new ChunkRulePair <QuadRule> [0];
return(empty);
}
if (cachedRules.ContainsKey(order))
{
order = cachedRules.Keys.Where(cachedOrder => cachedOrder >= order).Min();
CellMask cachedMask = new CellMask(mask.GridData, cachedRules[order].Select(p => p.Chunk).ToArray());
if (cachedMask.Equals(mask))
{
return(cachedRules[order]);
}
else
{
throw new NotImplementedException(
"Case not yet covered yet in combination with caching; deactivate caching to get rid of this message");
}
}
double[,] quadResults = cellBoundaryQuadrature.Results;
foreach (Chunk chunk in mask)
{
for (int i = 0; i < chunk.Len; i++)
{
int iSubGrid = localCellIndex2SubgridIndex[chunk.i0 + i];
switch (jumpType)
{
case JumpTypes.Heaviside:
for (int k = 0; k < noOfLambdas; k++)
{
quadResults[iSubGrid, k] -= surfaceQuadrature.Results[iSubGrid, k];
}
break;
case JumpTypes.OneMinusHeaviside:
for (int k = 0; k < noOfLambdas; k++)
{
quadResults[iSubGrid, k] += surfaceQuadrature.Results[iSubGrid, k];
}
break;
case JumpTypes.Sign:
for (int k = 0; k < noOfLambdas; k++)
{
quadResults[iSubGrid, k] -= 2.0 * surfaceQuadrature.Results[iSubGrid, k];
}
break;
default:
throw new NotImplementedException();
}
}
}
BitArray voidCellsArray = new BitArray(LevelSetData.GridDat.Cells.NoOfLocalUpdatedCells);
BitArray fullCellsArray = new BitArray(LevelSetData.GridDat.Cells.NoOfLocalUpdatedCells);
foreach (Chunk chunk in cellMask)
{
foreach (var cell in chunk.Elements)
{
double rhsL2Norm = 0.0;
for (int k = 0; k < noOfLambdas; k++)
{
double entry = quadResults[localCellIndex2SubgridIndex[cell], k];
rhsL2Norm += entry * entry;
}
if (rhsL2Norm < 1e-14)
{
// All integrals are zero => cell not really cut
// (level set is tangent) and fully in void region
voidCellsArray[cell] = true;
continue;
}
double l2NormFirstIntegral = quadResults[localCellIndex2SubgridIndex[cell], 0];
l2NormFirstIntegral *= l2NormFirstIntegral;
double rhsL2NormWithoutFirst = rhsL2Norm - l2NormFirstIntegral;
// Beware: This check is only sensible if basis is orthonormal on RefElement!
if (rhsL2NormWithoutFirst < 1e-14 &&
Math.Abs(l2NormFirstIntegral - RefElement.Volume) < 1e-14)
{
// All integrals are zero except integral over first integrand
// If basis is orthonormal, this implies that cell is uncut and
// fully in non-void region since then
// \int_K \Phi_i dV = \int_A \Phi_i dV = \delta_{0,i}
// However, we have to compare RefElement.Volume since
// integration is performed in reference coordinates!
fullCellsArray[cell] = true;
}
}
}
var result = new List <ChunkRulePair <QuadRule> >(cellMask.NoOfItemsLocally);
CellMask emptyCells = new CellMask(LevelSetData.GridDat, voidCellsArray);
foreach (Chunk chunk in emptyCells)
{
foreach (int cell in chunk.Elements)
{
QuadRule emptyRule = QuadRule.CreateEmpty(RefElement, 1, RefElement.SpatialDimension);
emptyRule.Nodes.LockForever();
result.Add(new ChunkRulePair <QuadRule>(
Chunk.GetSingleElementChunk(cell), emptyRule));
}
}
CellMask fullCells = new CellMask(LevelSetData.GridDat, fullCellsArray);
foreach (Chunk chunk in fullCells)
{
foreach (int cell in chunk.Elements)
{
QuadRule fullRule = RefElement.GetQuadratureRule(order);
result.Add(new ChunkRulePair <QuadRule>(
Chunk.GetSingleElementChunk(cell), fullRule));
}
}
CellMask realCutCells = cellMask.Except(emptyCells).Except(fullCells);
if (RestrictNodes)
{
foreach (Chunk chunk in realCutCells)
{
foreach (int cell in chunk.Elements)
{
CellMask singleElementMask = new CellMask(
LevelSetData.GridDat, Chunk.GetSingleElementChunk(cell));
AffineTrafo trafo = trafos[localCellIndex2SubgridIndex[cell]];
Debug.Assert(Math.Abs(trafo.Matrix.Determinant()) > 1e-10);
NodeSet nodes = GetNodes(noOfLambdas).CloneAs();
NodeSet mappedNodes = new NodeSet(RefElement, trafo.Transform(nodes));
mappedNodes.LockForever();
// Remove nodes in negative part
MultidimensionalArray levelSetValues = LevelSetData.GetLevSetValues(mappedNodes, cell, 1);
List <int> nodesToBeCopied = new List <int>(mappedNodes.GetLength(0));
for (int n = 0; n < nodes.GetLength(0); n++)
{
if (levelSetValues[0, n] >= 0.0)
{
nodesToBeCopied.Add(n);
}
}
NodeSet reducedNodes = new NodeSet(
this.RefElement, nodesToBeCopied.Count, D);
for (int n = 0; n < nodesToBeCopied.Count; n++)
{
for (int d = 0; d < D; d++)
{
reducedNodes[n, d] = mappedNodes[nodesToBeCopied[n], d];
}
}
reducedNodes.LockForever();
QuadRule optimizedRule = GetOptimizedRule(
cell,
trafo,
reducedNodes,
quadResults,
order);
result.Add(new ChunkRulePair <QuadRule>(
singleElementMask.Single(), optimizedRule));
}
}
}
else
{
// Use same nodes in all cells
QuadRule[] optimizedRules = GetOptimizedRules(
realCutCells, GetNodes(noOfLambdas), quadResults, order);
int ruleIndex = 0;
foreach (Chunk chunk in realCutCells)
{
foreach (var cell in chunk.Elements)
{
result.Add(new ChunkRulePair <QuadRule>(
Chunk.GetSingleElementChunk(cell), optimizedRules[ruleIndex]));
ruleIndex++;
}
}
}
cachedRules[order] = result.OrderBy(p => p.Chunk.i0).ToArray();
return(cachedRules[order]);
}
}