/// <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();
}
}