/// <summary>
/// Prepares the construction of a new equation system
/// </summary>
/// <param name="control"></param>
/// <param name="gridData"></param>
/// <param name="workingSet"></param>
/// <param name="speciesMap"></param>
/// <param name="boundaryMap"></param>
/// <remarks>
/// Source terms are currently considered independent of the considered
/// equation system and are thus constructed automatically from the
/// control file (see <see cref="CustomSourceBuilder"/>).
/// </remarks>
public OperatorFactory(
CNSControl control,
GridData gridData,
CNSFieldSet workingSet,
ISpeciesMap speciesMap,
IBoundaryConditionMap boundaryMap)
{
bool hasConvection = control.ActiveOperators.HasFlag(Operators.Convection);
bool hasDiffusion = control.ActiveOperators.HasFlag(Operators.Diffusion);
if (!hasConvection && !hasDiffusion)
{
throw new Exception(
"Either convective or diffusive terms must be active");
}
if (hasConvection)
{
this.convectiveFluxBuilder = control.ConvectiveFluxType.GetBuilder(
control, boundaryMap, speciesMap);
}
if (hasDiffusion)
{
this.diffusiveFluxBuilder = control.DiffusiveFluxType.GetBuilder(
control, boundaryMap, speciesMap, gridData);
}
if (control.ActiveOperators.HasFlag(Operators.Gravity))
{
this.sourceTermBuilders.Add(
new GravityFluxBuilder(control, boundaryMap, speciesMap));
}
if (control.ActiveOperators.HasFlag(Operators.CustomSource))
{
this.sourceTermBuilders.Add(
new CustomSourceBuilder(control, boundaryMap, speciesMap));
}
if (control.ActiveOperators.HasFlag(Operators.SpongeLayer))
{
this.sourceTermBuilders.Add(
new SpongeLayerFluxBuilder(control, boundaryMap, speciesMap));
}
if (control.ActiveOperators.HasFlag(Operators.ArtificialViscosity))
{
this.sourceTermBuilders.Add(
new LaplacianArtificialViscosityFluxBuilder(control, boundaryMap, speciesMap));
}
this.control = control;
this.gridData = gridData;
this.workingSet = workingSet;
this.speciesMap = speciesMap;
}
/// <summary>
/// Constructs a new operator factory which additionally implements
/// the boundary conditions at immersed boundaries.
/// </summary>
/// <param name="control"></param>
/// <param name="gridData"></param>
/// <param name="workingSet"></param>
/// <param name="speciesMap"></param>
/// <param name="boundaryMap"></param>
public IBMOperatorFactory(
IBMControl control,
GridData gridData,
CNSFieldSet workingSet,
ISpeciesMap speciesMap,
IBoundaryConditionMap boundaryMap)
: base(control, gridData, workingSet, speciesMap, boundaryMap)
{
this.immersedBoundaryFluxBuilders.Add(new BoundaryConditionSourceFluxBuilder(
control, boundaryMap, speciesMap, convectiveFluxBuilder, diffusiveFluxBuilder));
}
public ArtificialViscosityCFLConstraint(
CNSControl config, IGridData gridData, CNSFieldSet workingSet, ISpeciesMap speciesMap)
: base(gridData, workingSet)
{
this.config = config;
this.speciesMap = speciesMap;
if (gridData.iGeomCells.RefElements.Length > 1)
{
throw new NotImplementedException();
}
}
/// <summary>
/// Creates a <see cref="SpatialOperator"/> with the equation
/// components that have been assigned to this operator.
/// </summary>
/// <returns></returns>
public SpatialOperator ToSpatialOperator(CNSFieldSet fieldSet)
{
SpatialOperator spatialOp = new SpatialOperator(
CompressibleEnvironment.PrimalArgumentOrdering,
GetParameterOrdering(fieldSet),
CompressibleEnvironment.PrimalArgumentOrdering,
QuadOrderFunc.NonLinearWithoutParameters(2));
MapComponents(spatialOp);
spatialOp.Commit();
return(spatialOp);
}
/// <summary>
/// Constructs a new constraint
/// </summary>
/// <param name="config"></param>
/// <param name="gridData"></param>
/// <param name="workingSet"></param>
/// <param name="speciesMap"></param>
public ConvectiveCFLConstraint(
CNSControl config, IGridData gridData, CNSFieldSet workingSet, ISpeciesMap speciesMap)
: base(gridData, workingSet)
{
this.control = config;
this.speciesMap = speciesMap;
if (gridData.iGeomCells.RefElements.Length > 1 || !(gridData is GridData))
{
throw new NotImplementedException();
}
}
/// <summary>
/// Constructs a new constraint
/// </summary>
/// <param name="config"></param>
/// <param name="gridData"></param>
/// <param name="workingSet"></param>
/// <param name="speciesMap"></param>
public DiffusiveCFLConstraint(
CNSControl config, GridData gridData, CNSFieldSet workingSet, ISpeciesMap speciesMap)
: base(gridData, workingSet)
{
this.config = config;
this.speciesMap = speciesMap;
if (gridData.Grid.RefElements.Length > 1)
{
throw new NotImplementedException();
}
}
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>
/// Constructs a constraint that respects the given
/// <paramref name="speciesMap"/>
/// </summary>
/// <param name="config"></param>
/// <param name="gridData"></param>
/// <param name="workingSet"></param>
/// <param name="speciesMap"></param>
public IBMConvectiveCFLConstraint(
CNSControl config, GridData gridData, CNSFieldSet workingSet, ISpeciesMap speciesMap)
: base(gridData, workingSet)
{
this.config = config;
this.speciesMap = speciesMap as ImmersedSpeciesMap;
if (speciesMap == null)
{
throw new ArgumentException(
"This type requires an instance of 'ImmersedSpeciesMap'",
"speciesMap");
}
}
/// <summary>
/// Returns the correct species map for the current domain type
/// </summary>
/// <param name="domainType">
/// The considered domain type
/// </param>
/// <param name="workingSet"></param>
/// <param name="control"></param>
/// <param name="gridData"></param>
/// <returns>
/// A species map that is suitable for the current application.
/// </returns>
public static ISpeciesMap CreateSpeciesMap(this DomainTypes domainType, CNSFieldSet workingSet, CNSControl control, GridData gridData)
{
Material material = new Material(control);
switch (domainType)
{
case DomainTypes.Standard:
return(new SingleSpeciesMap(gridData, material));
case DomainTypes.StaticImmersedBoundary:
case DomainTypes.MovingImmersedBoundary:
IBMFieldSet ibmWorkingSet = workingSet as IBMFieldSet;
return(new ImmersedSpeciesMap(
(IBMControl)control, ibmWorkingSet.LevelSet, material));
default:
throw new Exception();
}
}
/// <summary>
/// Returns the correct species map for the current domain type
/// </summary>
/// <param name="domainType">
/// The considered domain type
/// </param>
/// <param name="workingSet"></param>
/// <param name="control"></param>
/// <param name="gridData"></param>
/// <returns>
/// A species map that is suitable for the current application.
/// </returns>
public static ISpeciesMap CreateSpeciesMap(this DomainTypes domainType, CNSFieldSet workingSet, CNSControl control, IGridData gridData)
{
Material material = new Material(control.EquationOfState, control.ViscosityLaw, control.MachNumber, control.ReynoldsNumber, control.PrandtlNumber, control.FroudeNumber, control.ViscosityRatio);
switch (domainType)
{
case DomainTypes.Standard:
return(new SingleSpeciesMap(gridData, material));
case DomainTypes.StaticImmersedBoundary:
case DomainTypes.MovingImmersedBoundary:
IBMFieldSet ibmWorkingSet = workingSet as IBMFieldSet;
return(new ImmersedSpeciesMap(
(IBMControl)control, ibmWorkingSet.LevelSet, material));
default:
throw new Exception();
}
}
/// <summary>
/// Note: Only to be used if <paramref name="refResults"/> and
/// <paramref name="loadBalResults"/> have the same grid AND the same
/// grid partitioning
/// </summary>
/// <param name="refResults"></param>
/// <param name="loadBalResults"></param>
/// <param name="differenceThreshold"></param>
private static void CompareErrors(CNSFieldSet refResults, CNSFieldSet loadBalResults, double differenceThreshold)
{
List <Action> assertions = new List <Action>();
{
double densityDifference = refResults.Density.L2Error(loadBalResults.Density, overrideGridCheck: true);
string densityMessage = String.Format(
"Density: {0} (Threshold is {1})",
densityDifference,
differenceThreshold);
Console.WriteLine(densityMessage);
assertions.Add(() => Assert.IsTrue(densityDifference < differenceThreshold, densityMessage));
}
for (int d = 0; d < refResults.Density.GridDat.SpatialDimension; d++)
{
double momentumDifference = refResults.Momentum[d].L2Error(loadBalResults.Momentum[d], overrideGridCheck: true);
string momentumMessage = String.Format(
"Momentum[{0}]: {1} (Threshold is {2})",
d,
momentumDifference,
differenceThreshold);
Console.WriteLine(momentumMessage);
assertions.Add(() => Assert.IsTrue(momentumDifference < differenceThreshold, momentumMessage));
}
{
double energyDifference = refResults.Energy.L2Error(loadBalResults.Energy, overrideGridCheck: true);
string energyMessage = String.Format(
"Energy: {0} (Threshold is {1})",
energyDifference,
differenceThreshold);
Console.WriteLine(energyMessage);
assertions.Add(() => Assert.IsTrue(energyDifference < differenceThreshold, energyMessage));
}
assertions.ForEach(a => a());
}
public void LimitFieldValues(IProgram <CNSControl> program)
{
CNSFieldSet fieldSet = program.WorkingSet;
foreach (var chunkRulePair in quadRuleSet)
{
if (chunkRulePair.Chunk.Len > 1)
{
throw new System.Exception();
}
MultidimensionalArray densityValues = MultidimensionalArray.Create(chunkRulePair.Chunk.Len, chunkRulePair.Rule.NoOfNodes);
fieldSet.Density.Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, densityValues);
MultidimensionalArray m0Values = MultidimensionalArray.Create(chunkRulePair.Chunk.Len, chunkRulePair.Rule.NoOfNodes);
fieldSet.Momentum[0].Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, m0Values);
MultidimensionalArray m1Values = MultidimensionalArray.Create(chunkRulePair.Chunk.Len, chunkRulePair.Rule.NoOfNodes);
fieldSet.Momentum[1].Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, m1Values);
MultidimensionalArray energyValues = MultidimensionalArray.Create(chunkRulePair.Chunk.Len, chunkRulePair.Rule.NoOfNodes);
fieldSet.Energy.Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, energyValues);
for (int i = 0; i < chunkRulePair.Chunk.Len; i++)
{
int cell = i + chunkRulePair.Chunk.i0;
CellMask singleCellMask = new CellMask(speciesMap.Tracker.GridDat, chunkRulePair.Chunk);
CellQuadratureScheme singleCellScheme = new CellQuadratureScheme(
new FixedRuleFactory <QuadRule>(chunkRulePair.Rule), singleCellMask);
var singleCellRule = singleCellScheme.Compile(speciesMap.Tracker.GridDat, 99);
SpeciesId species = speciesMap.Tracker.GetSpeciesId(speciesMap.Control.FluidSpeciesName);
double volume = speciesMap.QuadSchemeHelper.NonAgglomeratedMetrics.CutCellVolumes[species][cell];
double integralDensity = fieldSet.Density.LxError((ScalarFunction)null, (X, a, b) => a, singleCellRule);
double meanDensity = integralDensity / volume;
if (meanDensity < epsilon)
{
throw new System.Exception();
}
double minDensity = double.MaxValue;
for (int j = 0; j < chunkRulePair.Rule.NoOfNodes; j++)
{
minDensity = Math.Min(minDensity, densityValues[i, j]);
}
double thetaDensity = Math.Min(1.0, (meanDensity - epsilon) / (meanDensity - minDensity));
if (thetaDensity < 1.0)
{
Console.WriteLine("Scaled density in cell {0}!", cell);
}
// Scale for positive density (Beware: Basis is not orthonormal on sub-volume!)
for (int j = 0; j < fieldSet.Density.Basis.Length; j++)
{
fieldSet.Density.Coordinates[cell, j] *= thetaDensity;
}
fieldSet.Density.AccConstant(meanDensity * (1.0 - thetaDensity), singleCellMask);
// Re-evaluate since inner energy has changed
densityValues.Clear();
fieldSet.Density.Evaluate(cell, 1, chunkRulePair.Rule.Nodes, densityValues);
#if DEBUG
// Probe 1
for (int j = 0; j < chunkRulePair.Rule.NoOfNodes; j++)
{
if (densityValues[i, j] - epsilon < -1e-15)
{
throw new System.Exception();
}
}
#endif
double integralMomentumX = fieldSet.Momentum[0].LxError((ScalarFunction)null, (X, a, b) => a, singleCellRule);
double meanMomentumX = integralMomentumX / volume;
double integralMomentumY = fieldSet.Momentum[1].LxError((ScalarFunction)null, (X, a, b) => a, singleCellRule);
double meanMomentumY = integralMomentumY / volume;
double integralEnergy = fieldSet.Energy.LxError((ScalarFunction)null, (X, a, b) => a, singleCellRule);
double meanEnergy = integralEnergy / volume;
double meanInnerEnergy = meanEnergy - 0.5 * (meanMomentumX * meanMomentumX + meanMomentumY * meanMomentumY) / meanDensity;
if (meanInnerEnergy < epsilon)
{
throw new System.Exception();
}
double minInnerEnergy = double.MaxValue;
for (int j = 0; j < chunkRulePair.Rule.NoOfNodes; j++)
{
double innerEnergy = energyValues[i, j] - 0.5 * (m0Values[i, j] * m0Values[i, j] + m1Values[i, j] * m1Values[i, j]) / densityValues[i, j];
minInnerEnergy = Math.Min(minInnerEnergy, innerEnergy);
}
// Scale for positive inner energy (Beware: Basis is not orthonormal on sub-volume!)
double thetaInnerEnergy = Math.Min(1.0, (meanInnerEnergy - epsilon) / (meanInnerEnergy - minInnerEnergy));
if (thetaInnerEnergy < 1.0)
{
Console.WriteLine("Scaled inner energy in cell {0}!", cell);
}
for (int j = 0; j < fieldSet.Density.Basis.Length; j++)
{
fieldSet.Density.Coordinates[chunkRulePair.Chunk.i0 + i, j] *= thetaInnerEnergy;
fieldSet.Momentum[0].Coordinates[chunkRulePair.Chunk.i0 + i, j] *= thetaInnerEnergy;
fieldSet.Momentum[1].Coordinates[chunkRulePair.Chunk.i0 + i, j] *= thetaInnerEnergy;
fieldSet.Energy.Coordinates[chunkRulePair.Chunk.i0 + i, j] *= thetaInnerEnergy;
}
fieldSet.Density.AccConstant(meanDensity * (1.0 - thetaInnerEnergy), singleCellMask);
fieldSet.Momentum[0].AccConstant(meanMomentumX * (1.0 - thetaInnerEnergy), singleCellMask);
fieldSet.Momentum[1].AccConstant(meanMomentumY * (1.0 - thetaInnerEnergy), singleCellMask);
fieldSet.Energy.AccConstant(meanEnergy * (1.0 - thetaInnerEnergy), singleCellMask);
#if DEBUG
// Probe 2
densityValues.Clear();
fieldSet.Density.Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, densityValues);
m0Values.Clear();
fieldSet.Momentum[0].Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, m0Values);
m1Values.Clear();
fieldSet.Momentum[1].Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, m1Values);
energyValues.Clear();
fieldSet.Energy.Evaluate(chunkRulePair.Chunk.i0, chunkRulePair.Chunk.Len, chunkRulePair.Rule.Nodes, energyValues);
for (int j = 0; j < chunkRulePair.Rule.NoOfNodes; j++)
{
StateVector state = new StateVector(
speciesMap.GetMaterial(1.0),
densityValues[i, j],
new Vector3D(m0Values[i, j], m1Values[i, j], 0.0),
energyValues[i, j]);
if (!state.IsValid)
{
throw new System.Exception();
}
}
#endif
}
}
}
public void UpdateSensorValues(CNSFieldSet fieldSet, ISpeciesMap speciesMap, CellMask cellMask)
{
DGField fieldToTest = fieldSet.ConservativeVariables.
Concat(fieldSet.DerivedFields.Values).
Where(f => f.Identification == sensorVariable.Name).
Single();
int degree = fieldToTest.Basis.Degree;
int noOfCells = fieldToTest.GridDat.iLogicalCells.NoOfLocalUpdatedCells;
if (sensorValues == null || sensorValues.Length != noOfCells)
{
sensorValues = new double[noOfCells];
}
IMatrix coordinatesTimesMassMatrix;
IMatrix coordinatesTruncatedTimesMassMatrix;
if (speciesMap is ImmersedSpeciesMap ibmMap)
{
// Note: This has to be the _non_-agglomerated mass matrix
// because we still live on the non-agglomerated mesh at this
// point
BlockMsrMatrix massMatrix = ibmMap.GetMassMatrixFactory(fieldToTest.Mapping).NonAgglomeratedMassMatrix;
// Old
DGField temp = fieldToTest.CloneAs();
massMatrix.SpMV(1.0, fieldToTest.CoordinateVector, 0.0, temp.CoordinateVector);
coordinatesTimesMassMatrix = temp.Coordinates;
// Neu
DGField uTruncated = fieldToTest.CloneAs();
// Set all coordinates to zero
for (int cell = 0; cell < uTruncated.Coordinates.NoOfRows; cell++)
{
for (int coordinate = 0; coordinate < uTruncated.Coordinates.NoOfCols; coordinate++)
{
uTruncated.Coordinates[cell, coordinate] = 0;
}
}
// Copy only the coordiantes that belong to the highest modes
foreach (int cell in cellMask.ItemEnum)
{
foreach (int coordinate in fieldToTest.Basis.GetPolynomialIndicesForDegree(cell, degree))
{
uTruncated.Coordinates[cell, coordinate] = fieldToTest.Coordinates[cell, coordinate];
}
}
// Calculate M times u
DGField vecF_Field = fieldToTest.CloneAs();
massMatrix.SpMV(1.0, uTruncated.CoordinateVector, 0.0, vecF_Field.CoordinateVector);
coordinatesTruncatedTimesMassMatrix = vecF_Field.Coordinates;
}
else
{
// Mass matrix is identity
coordinatesTimesMassMatrix = fieldToTest.Coordinates;
coordinatesTruncatedTimesMassMatrix = fieldToTest.Coordinates;
}
//IMatrix coordinatesTimesMassMatrix = fieldToTest.Coordinates;
//cellMask.SaveToTextFile("fluidCells.txt");
// This is equivalent to norm(restrictedField) / norm(originalField)
// Note: THIS WILL FAIL IN CUT CELLS
foreach (int cell in cellMask.ItemEnum)
{
double numerator = 0.0;
foreach (int coordinate in fieldToTest.Basis.GetPolynomialIndicesForDegree(cell, degree))
{
//numerator += fieldToTest.Coordinates[cell, coordinate] * fieldToTest.Coordinates[cell, coordinate];
numerator += fieldToTest.Coordinates[cell, coordinate] * coordinatesTruncatedTimesMassMatrix[cell, coordinate];
}
double denominator = 0.0;
for (int coordinate = 0; coordinate < fieldToTest.Basis.Length; coordinate++)
{
//denominator += fieldToTest.Coordinates[cell, coordinate] * fieldToTest.Coordinates[cell, coordinate];
denominator += fieldToTest.Coordinates[cell, coordinate] * coordinatesTimesMassMatrix[cell, coordinate];
}
double result;
if (denominator == 0.0)
{
result = 0.0;
}
else
{
result = numerator / denominator;
}
//Debug.Assert(denominator != 0, "Persson sensor: Denominator is zero!");
//Debug.Assert(!(numerator / denominator).IsNaN(), "Persson sensor: Sensor value is NaN!");
//Debug.Assert(numerator / denominator >= 0, "Persson sensor: Sensor value is negative!");
sensorValues[cell] = result;
}
}
/// <summary>
/// Constructs a new constraint
/// </summary>
/// <param name="gridData"></param>
/// <param name="workingSet"></param>
public CFLConstraint(GridData gridData, CNSFieldSet workingSet)
: base(gridData, workingSet.config.dtMin, workingSet.config.dtMax, workingSet.config.CFLFraction, workingSet.config.Endtime)
{
this.workingSet = workingSet;
}
/// <summary>
/// <see cref="ResidualLogger"/>
/// </summary>
public NullResidualLogger(BoSSS.Solution.ResidualLogger baseLogger, SessionInfo currentSession, CNSFieldSet workingSet)
: base(baseLogger, currentSession, workingSet, 0)
{
}
public void UpdateSensorValues(CNSFieldSet fieldSet, ISpeciesMap speciesMap, CellMask cellMask)
{
DGField fieldToTest = fieldSet.ConservativeVariables.
Concat(fieldSet.DerivedFields.Values).
Where(f => f.Identification == sensorVariable.Name).
Single();
sensorValues = new SinglePhaseField(
new Basis(fieldToTest.GridDat, 0));
var quadrature = EdgeQuadrature.GetQuadrature(
new int[] { 1 },
(GridData)fieldToTest.GridDat,
new EdgeQuadratureScheme().Compile(fieldToTest.GridDat, 2 * fieldToTest.Basis.Degree),
delegate(int e0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
MultidimensionalArray gIn = MultidimensionalArray.Create(Length, QR.NoOfNodes);
MultidimensionalArray gOut = MultidimensionalArray.Create(Length, QR.NoOfNodes);
fieldToTest.EvaluateEdge(
e0,
Length,
QR.Nodes,
gIn,
gOut,
MeanValueIN: null,
MeanValueOT: null,
GradientIN: null,
GradientOT: null,
ResultIndexOffset: 0,
ResultPreScale: 0.0);
for (int e = 0; e < Length; e++)
{
int edge = e + e0;
// Check if "out" neighbor exist; ignore boundary edges for now
int outCell = fieldToTest.GridDat.iLogicalEdges.CellIndices[edge, 1];
if (outCell < 0)
{
continue;
}
for (int node = 0; node < QR.NoOfNodes; node++)
{
double jump = gOut[e, node] - gIn[e, node];
double mean = 0.5 * (gOut[e, node] + gIn[e, node]);
double s = jump / mean;
if (!double.IsNaN(s))
{
EvalResult[e, node, 0] = s * s / (Math.Sign(s) * s + 0.001);
}
}
}
},
delegate(int e0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int e = 0; e < Length; e++)
{
int edge = e + e0;
for (int neighbor = 0; neighbor < 2; neighbor++) // loop over IN/OUT cells
{
int jCell = fieldToTest.GridDat.iLogicalEdges.CellIndices[edge, neighbor];
if (jCell < 0)
{
break;
}
sensorValues.Coordinates[jCell, 0] += ResultsOfIntegration[e, 0];
}
}
});
quadrature.Execute();
}
/// <summary>
/// Initializes <see cref="PreviousState"/>, <see cref="CurrentState"/>
/// and the log files.
/// </summary>
/// <param name="baseLogger">Access to the actual log file</param>
/// <param name="currentsession">The current session</param>
/// <param name="workingSet">
/// The initial working set ("0-th" iteration)
/// </param>
/// <param name="residualInterval">
/// Interval at which residuals are calculated
/// </param>
public ResidualLogger(BoSSS.Solution.ResidualLogger baseLogger, SessionInfo currentsession, CNSFieldSet workingSet, int residualInterval)
{
this.baseLogger = baseLogger;
this.residualInterval = residualInterval;
this.m_currentsession = currentsession;
CurrentState = new VectorField <DGField>(workingSet.ConservativeVariables);
PreviousState = CurrentState.CloneAs();
}
/// <summary>
/// <see cref="ResidualLogger"/>
/// </summary>
public ChangeRateResidualLogger(BoSSS.Solution.ResidualLogger baseLogger, SessionInfo currentSession, CNSFieldSet workingSet, int residualInterval)
: base(baseLogger, currentSession, workingSet, residualInterval)
{
}
/// <summary>
/// Creates an <see cref="OperatorFactory"/> with appropriate terms
/// (convective/diffusive) for the selected <paramref name="formulation"/>.
/// </summary>
/// <param name="formulation">
/// The chosen equation system
/// </param>
/// <param name="control"></param>
/// <param name="gridData"></param>
/// <param name="speciesMap"></param>
/// <param name="workingSet"></param>
/// <param name="boundaryMap">
/// Boundary information
/// </param>
/// <returns>
/// An instance of <see cref="OperatorFactory"/> that has been
/// configured with the fluxes defined by
/// <see cref="CNSControl.ConvectiveFluxType"/> and/or
/// <see cref="CNSControl.DiffusiveFluxType"/>.
/// </returns>
public static OperatorFactory GetOperatorFactory(
this DomainTypes formulation, CNSControl control, IGridData gridData, BoundaryConditionMap boundaryMap, CNSFieldSet workingSet, ISpeciesMap speciesMap)
{
switch (formulation)
{
case DomainTypes.Standard:
return(new OperatorFactory(
control, gridData, workingSet, speciesMap, boundaryMap));
case DomainTypes.StaticImmersedBoundary:
case DomainTypes.MovingImmersedBoundary:
FluxBuilder convectiveBuilder = control.ConvectiveFluxType.GetBuilder(
control, boundaryMap, speciesMap);
return(new IBMOperatorFactory(
(IBMControl)control,
gridData,
workingSet,
speciesMap,
boundaryMap));
default:
throw new Exception(
"Unknown formulation \"" + control.DomainType + "\"");
}
}
/// <summary>
/// The parameter ordering that is constructed from the the parameters
/// defined by the operator factory since it should know what the
/// operators need
/// </summary>
private IList <string> GetParameterOrdering(CNSFieldSet fieldSet)
{
return(fieldSet.ParameterFields.Select(f => f.Identification).ToList());
}
