public IBMAdamsBashforth(
SpatialOperator standardOperator,
SpatialOperator boundaryOperator,
CoordinateMapping fieldsMap,
CoordinateMapping parametersMap,
ISpeciesMap ibmSpeciesMap,
IBMControl control,
IList <TimeStepConstraint> timeStepConstraints)
: base(standardOperator, fieldsMap, parametersMap, control.ExplicitOrder, timeStepConstraints, ibmSpeciesMap.SubGrid) // TO DO: I SIMPLY REMOVED PARAMETERMAP HERE; MAKE THIS MORE PRETTY
{
speciesMap = ibmSpeciesMap as ImmersedSpeciesMap;
if (this.speciesMap == null)
{
throw new ArgumentException(
"Only supported for species maps of type 'ImmersedSpeciesMap'",
"speciesMap");
}
this.boundaryOperator = boundaryOperator;
this.boundaryParameterMap = parametersMap;
agglomerationPatternHasChanged = true;
// StarUp Phase needs also an IBM time stepper
RungeKuttaScheme = new IBMSplitRungeKutta(
standardOperator,
boundaryOperator,
fieldsMap,
parametersMap,
speciesMap,
timeStepConstraints);
}
/// <summary>
/// L2 error with respect to given reference solution. The quadrature
/// is determined from the settings in <see cref="IBMControl"/>
/// </summary>
/// <param name="fieldName"></param>
/// <param name="referenceSolution"></param>
/// <returns></returns>
public static Query L2Error(string fieldName, Func <double[], double, double> referenceSolution)
{
return(delegate(IApplication <AppControl> app, double time) {
IProgram <CNSControl> program = app as IProgram <CNSControl>;
if (program == null)
{
throw new Exception();
}
ImmersedSpeciesMap speciesMap = program.SpeciesMap as ImmersedSpeciesMap;
IBMControl control = program.Control as IBMControl;
if (speciesMap == null || control == null)
{
throw new Exception(
"Query is only valid for immersed boundary runs");
}
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
int order = control.LevelSetQuadratureOrder;
CellQuadratureScheme scheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, speciesMap.SubGrid.VolumeMask);
DGField dgField = app.IOFields.Single(f => f.Identification == fieldName);
return dgField.L2Error(referenceSolution.Vectorize(time), order, scheme);
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="gridData"></param>
/// <param name="config"></param>
public IBMFieldSet(IGridData gridData, IBMControl config)
: base(gridData, config)
{
this.config = config;
if (config.RestartInfo == null && !config.FieldOptions.ContainsKey(IBMVariables.LevelSet))
{
throw new Exception(
"Field 'levelSet' is required for IBM applications");
}
LevelSet = new LevelSet(
new Basis(gridData, config.FieldOptions[IBMVariables.LevelSet].Degree),
IBMVariables.LevelSet);
if (config.ContinuousLevelSet)
{
SpecFemBasis specFEMBasis = new SpecFemBasis((GridData)gridData, LevelSet.Basis.Degree);
SpecFemField specFemField = new SpecFemField(specFEMBasis);
specFemField.ProjectDGFieldMaximum(1.0, LevelSet);
LevelSet.Clear();
specFemField.AccToDGField(1.0, LevelSet);
}
LevelSetGradient = new DGField[CompressibleEnvironment.NumberOfDimensions];
for (int d = 0; d < CompressibleEnvironment.NumberOfDimensions; d++)
{
LevelSetGradient[d] = DerivedFields[IBMVariables.LevelSetGradient[d]];
}
}
public static Query Integral(string fieldName)
{
return(delegate(IApplication <AppControl> app, double time) {
IProgram <CNSControl> program = app as IProgram <CNSControl>;
if (program == null)
{
throw new Exception();
}
ImmersedSpeciesMap speciesMap = program.SpeciesMap as ImmersedSpeciesMap;
IBMControl control = program.Control as IBMControl;
if (speciesMap == null || control == null)
{
throw new Exception(
"Query is only valid for immersed boundary runs");
}
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
int order = control.LevelSetQuadratureOrder;
CellQuadratureScheme scheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, speciesMap.SubGrid.VolumeMask);
DGField dgField = app.IOFields.Single(f => f.Identification == fieldName);
return DGField.IntegralOverEx(scheme, new Func((X, U, j) => (U[0])), 2, dgField);
});
}
/// <summary>
/// Calculates a force along the zero iso surface of the Level-Set
/// </summary>
/// <param name="direction">Direction of the force projection, e.g. 0=x-axis, 1=y-axis</param>
/// <returns></returns>
static Query LiftOrDragForce(int direction)
{
return(delegate(IApplication <AppControl> app, double time) {
IProgram <CNSControl> program = app as IProgram <CNSControl>;
if (program == null)
{
throw new Exception();
}
ImmersedSpeciesMap speciesMap = program.SpeciesMap as ImmersedSpeciesMap;
IBMControl control = program.Control as IBMControl;
if (speciesMap == null || control == null)
{
throw new Exception(
"Query is only valid for immersed boundary runs");
}
DGField density = program.WorkingSet.Density;
VectorField <DGField> momentum = program.WorkingSet.Momentum;
DGField energy = program.WorkingSet.Energy;
return XDGUtils.GetIntegralOverZeroLevelSet(
speciesMap.Tracker,
GetSurfaceForce(
density,
momentum,
energy,
speciesMap,
direction,
speciesMap.Tracker.Regions.GetCutCellMask()),
control.LevelSetQuadratureOrder,
speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName));
});
}
/// <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 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 new species map using the level set information
/// provided by <paramref name="levelSet"/>.
/// </summary>
/// <param name="control"></param>
/// <param name="levelSet"></param>
/// <param name="material"></param>
public ImmersedSpeciesMap(IBMControl control, LevelSet levelSet, Material material)
{
this.Control = control;
this.material = material;
this.tracker = new LevelSetTracker(
(GridData)levelSet.GridDat,
Control.CutCellQuadratureType,
0,
new string[] { Control.VoidSpeciesName, Control.FluidSpeciesName },
levelSet);
tracker.Subscribe(this);
}
public IBMAdamsBashforthLTS(SpatialOperator standardOperator, SpatialOperator boundaryOperator, CoordinateMapping fieldsMap, CoordinateMapping boundaryParameterMap, ISpeciesMap ibmSpeciesMap, IBMControl control, IList <TimeStepConstraint> timeStepConstraints, int reclusteringInterval, bool fluxCorrection)
: base(standardOperator, fieldsMap, boundaryParameterMap, control.ExplicitOrder, control.NumberOfSubGrids, true, timeStepConstraints, reclusteringInterval: reclusteringInterval, fluxCorrection: fluxCorrection, subGrid: ibmSpeciesMap.SubGrid)
{
this.speciesMap = ibmSpeciesMap as ImmersedSpeciesMap;
if (this.speciesMap == null)
{
throw new ArgumentException(
"Only supported for species maps of type 'ImmersedSpeciesMap'",
"speciesMap");
}
this.standardOperator = standardOperator;
this.boundaryOperator = boundaryOperator;
this.boundaryParameterMap = boundaryParameterMap;
this.fieldsMap = fieldsMap;
this.control = control;
agglomerationPatternHasChanged = true;
cutCells = speciesMap.Tracker.Regions.GetCutCellMask();
cutAndTargetCells = cutCells.Union(speciesMap.Agglomerator.AggInfo.TargetCells);
// Normal LTS constructor
NumberOfLocalTimeSteps = new List <int>(control.NumberOfSubGrids);
clusterer = new Clusterer(this.gridData, this.TimeStepConstraints);
CurrentClustering = clusterer.CreateClustering(control.NumberOfSubGrids, speciesMap.SubGrid);
CurrentClustering = CalculateNumberOfLocalTS(CurrentClustering); // Might remove sub-grids when time step sizes are too similar
ABevolver = new IBMABevolve[CurrentClustering.NumberOfClusters];
for (int i = 0; i < ABevolver.Length; i++)
{
ABevolver[i] = new IBMABevolve(standardOperator, boundaryOperator, fieldsMap, boundaryParameterMap, speciesMap, control.ExplicitOrder, control.LevelSetQuadratureOrder, control.CutCellQuadratureType, sgrd: CurrentClustering.Clusters[i], adaptive: this.adaptive);
ABevolver[i].OnBeforeComputeChangeRate += (t1, t2) => this.RaiseOnBeforeComputechangeRate(t1, t2);
}
GetBoundaryTopology();
#if DEBUG
for (int i = 0; i < CurrentClustering.NumberOfClusters; i++)
{
Console.WriteLine("IBM AB LTS ctor: id=" + i + " -> sub-steps=" + NumberOfLocalTimeSteps[i] + " and elements=" + CurrentClustering.Clusters[i].GlobalNoOfCells);
}
#endif
// Start-up phase needs an IBM Runge-Kutta time stepper
RungeKuttaScheme = new IBMSplitRungeKutta(standardOperator, boundaryOperator, fieldsMap, boundaryParameterMap, speciesMap, timeStepConstraints);
}
internal void BuildEvaluatorsAndMasks()
{
CellMask fluidCells = speciesMap.SubGrid.VolumeMask.Intersect(ABSubGrid.VolumeMask);
cutCells = speciesMap.Tracker.Regions.GetCutCellMask().Intersect(ABSubGrid.VolumeMask);
cutAndTargetCells = cutCells.Union(speciesMap.Agglomerator.AggInfo.TargetCells).Intersect(ABSubGrid.VolumeMask);
IBMControl control = speciesMap.Control;
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
CellQuadratureScheme volumeScheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, fluidCells, control.LevelSetQuadratureOrder);
// Does _not_ include agglomerated edges
EdgeMask nonVoidEdges = speciesMap.QuadSchemeHelper.GetEdgeMask(species);
nonVoidEdges = nonVoidEdges.Intersect(ABSubGrid.AllEdgesMask.ToGeometicalMask());
EdgeQuadratureScheme edgeScheme = speciesMap.QuadSchemeHelper.GetEdgeQuadScheme(
species, true, nonVoidEdges, control.LevelSetQuadratureOrder);
this.m_Evaluator = new Lazy <IEvaluatorNonLin>(delegate() {
this.Operator.EdgeQuadraturSchemeProvider = g => edgeScheme;
this.Operator.VolumeQuadraturSchemeProvider = g => volumeScheme;
var opi = this.Operator.GetEvaluatorEx(
Mapping,
boundaryParameterMap,
Mapping);
opi.ActivateSubgridBoundary(ABSubGrid.VolumeMask, subGridBoundaryTreatment: SubGridBoundaryModes.InnerEdgeLTS);
return(opi);
});
// Evaluator for boundary conditions at level set zero contour
CellQuadratureScheme boundaryVolumeScheme = speciesMap.QuadSchemeHelper.GetLevelSetquadScheme(
0, cutCells, control.LevelSetQuadratureOrder);
this.boundaryEvaluator = new Lazy <IEvaluatorNonLin>(delegate() {
boundaryOperator.EdgeQuadraturSchemeProvider = g => null; // Contains no boundary terms --> PROBLEM??????????
boundaryOperator.VolumeQuadraturSchemeProvider = g => boundaryVolumeScheme;
return(boundaryOperator.GetEvaluatorEx(
Mapping,
boundaryParameterMap,
Mapping));
});
}
internal void BuildEvaluatorsAndMasks()
{
CellMask fluidCells = speciesMap.SubGrid.VolumeMask.Intersect(ABSubGrid.VolumeMask);
cutCells = speciesMap.Tracker.Regions.GetCutCellMask().Intersect(ABSubGrid.VolumeMask);
cutAndTargetCells = cutCells.Union(speciesMap.Agglomerator.AggInfo.TargetCells).Intersect(ABSubGrid.VolumeMask);
IBMControl control = speciesMap.Control;
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
CellQuadratureScheme volumeScheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, fluidCells, control.LevelSetQuadratureOrder);
// Does _not_ include agglomerated edges
EdgeMask nonVoidEdges = speciesMap.QuadSchemeHelper.GetEdgeMask(species);
nonVoidEdges = nonVoidEdges.Intersect(ABSubGrid.AllEdgesMask);
EdgeQuadratureScheme edgeScheme = speciesMap.QuadSchemeHelper.GetEdgeQuadScheme(
species, true, nonVoidEdges, control.LevelSetQuadratureOrder);
this.m_Evaluator = new Lazy <SpatialOperator.Evaluator>(() =>
this.Operator.GetEvaluatorEx(
Mapping,
boundaryParameterMap,
Mapping,
edgeScheme,
volumeScheme,
ABSubGrid,
subGridBoundaryTreatment: SpatialOperator.SubGridBoundaryModes.InnerEdgeLTS));
// Evaluator for boundary conditions at level set zero contour
CellQuadratureScheme boundaryVolumeScheme = speciesMap.QuadSchemeHelper.GetLevelSetquadScheme(
0, cutCells, control.LevelSetQuadratureOrder);
this.boundaryEvaluator = new Lazy <SpatialOperator.Evaluator>(() =>
boundaryOperator.GetEvaluatorEx(
Mapping,
boundaryParameterMap,
Mapping,
null, // Contains no boundary terms --> PROBLEM??????????
boundaryVolumeScheme));
}
private void BuildEvaluatorsAndMasks()
{
CellMask fluidCells = speciesMap.SubGrid.VolumeMask;
cutCells = speciesMap.Tracker.Regions.GetCutCellMask();
cutAndTargetCells = cutCells.Union(speciesMap.Agglomerator.AggInfo.TargetCells);
IBMControl control = speciesMap.Control;
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
CellQuadratureScheme volumeScheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, fluidCells, control.LevelSetQuadratureOrder);
// Does _not_ include agglomerated edges
EdgeMask nonVoidEdges = speciesMap.QuadSchemeHelper.GetEdgeMask(species);
EdgeQuadratureScheme edgeScheme = speciesMap.QuadSchemeHelper.GetEdgeQuadScheme(
species, true, nonVoidEdges, control.LevelSetQuadratureOrder);
this.m_Evaluator = new Lazy <IEvaluatorNonLin>(delegate() {
this.Operator.EdgeQuadraturSchemeProvider = g => edgeScheme;
this.Operator.VolumeQuadraturSchemeProvider = g => volumeScheme;
var opi = this.Operator.GetEvaluatorEx(
Mapping,
null, // TO DO: I SIMPLY REMOVE PARAMETERMAP HERE; MAKE THIS MORE PRETTY
//this.boundaryParameterMap, // TO DO: I SIMPLY REMOVE PARAMETERMAP HERE; MAKE THIS MORE PRETTY
Mapping);
opi.ActivateSubgridBoundary(volumeScheme.Domain, subGridBoundaryTreatment: SubGridBoundaryModes.InnerEdgeLTS);
//opi.ActivateSubgridBoundary(fluidCells, subGridBoundaryTreatment: SubGridBoundaryModes.InnerEdgeLTS);
return(opi);
});
// Evaluator for boundary conditions at level set zero contour
CellQuadratureScheme boundaryVolumeScheme = speciesMap.QuadSchemeHelper.GetLevelSetquadScheme(
0, cutCells, control.LevelSetQuadratureOrder);
this.boundaryEvaluator = new Lazy <IEvaluatorNonLin>(delegate() {
boundaryOperator.EdgeQuadraturSchemeProvider = g => null; // Contains no boundary terms
boundaryOperator.VolumeQuadraturSchemeProvider = g => boundaryVolumeScheme;
return(boundaryOperator.GetEvaluatorEx(
Mapping,
boundaryParameterMap,
Mapping));
});
}
/// <summary>
/// Constructs a new flux builder where the boundary conditions are
/// evaluated using the convective fluxes defined by
/// <paramref name="convectiveBuilder"/>.
/// </summary>
/// <param name="control"></param>
/// <param name="boundaryMap"></param>
/// <param name="speciesMap"></param>
/// <param name="convectiveBuilder"></param>
/// <param name="diffusiveBuilder"></param>
public BoundaryConditionSourceFluxBuilder(
IBMControl control, BoundaryConditionMap boundaryMap, ISpeciesMap speciesMap, FluxBuilder convectiveBuilder, FluxBuilder diffusiveBuilder)
: base(control, boundaryMap, speciesMap)
{
standardOperator = new Operator(control);
if (convectiveBuilder != null)
{
convectiveBuilder.BuildFluxes(standardOperator);
}
if (diffusiveBuilder != null)
{
diffusiveBuilder.BuildFluxes(standardOperator);
}
string levelSetBoundaryType = control.LevelSetBoundaryTag;
boundaryCondition = boundaryMap.GetBoundaryCondition(levelSetBoundaryType);
}
protected void UpdateEvaluatorsAndMasks()
{
CellMask fluidCells = speciesMap.SubGrid.VolumeMask;
cutCells = speciesMap.Tracker.Regions.GetCutCellMask();
cutAndTargetCells = cutCells.Union(speciesMap.Agglomerator.AggInfo.TargetCells);
IBMControl control = speciesMap.Control;
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
CellQuadratureScheme volumeScheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, fluidCells, control.LevelSetQuadratureOrder);
// Does _not_ include agglomerated edges
EdgeMask nonVoidEdges = speciesMap.QuadSchemeHelper.GetEdgeMask(species);
EdgeQuadratureScheme edgeScheme = speciesMap.QuadSchemeHelper.GetEdgeQuadScheme(
species, true, nonVoidEdges, control.LevelSetQuadratureOrder);
this.m_Evaluator = new Lazy <IEvaluatorNonLin>(delegate() {
var opi = this.Operator.GetEvaluatorEx(
Mapping,
boundaryParameterMap,
Mapping,
edgeScheme,
volumeScheme);
opi.ActivateSubgridBoundary(volumeScheme.Domain.ToLogicalMask(), subGridBoundaryTreatment: SpatialOperator.SubGridBoundaryModes.InnerEdgeLTS);
return(opi);
});
// Evaluator for boundary conditions at level set zero contour
CellQuadratureScheme boundaryVolumeScheme = speciesMap.QuadSchemeHelper.GetLevelSetquadScheme(
0, cutCells, control.LevelSetQuadratureOrder);
this.boundaryEvaluator = new Lazy <IEvaluatorNonLin>(() =>
boundaryOperator.GetEvaluatorEx(
Mapping,
boundaryParameterMap,
Mapping,
null, // Contains no boundary terms
boundaryVolumeScheme));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="gridData"></param>
/// <param name="config"></param>
public IBMFieldSet(GridData gridData, IBMControl config)
: base(gridData, config)
{
this.config = config;
if (config.RestartInfo == null && !config.FieldOptions.ContainsKey(IBMVariables.LevelSet))
{
throw new Exception(
"Field 'levelSet' is required for IBM applications");
}
LevelSet = new LevelSet(
new Basis(gridData, config.FieldOptions[IBMVariables.LevelSet].Degree),
IBMVariables.LevelSet);
LevelSetGradient = new DGField[CNSEnvironment.NumberOfDimensions];
for (int d = 0; d < CNSEnvironment.NumberOfDimensions; d++)
{
LevelSetGradient[d] = DerivedFields[IBMVariables.LevelSetGradient[d]];
}
}
/// <summary>
/// L2 error of some quantity derived from the state vector (e.g.,
/// entropy) with respect to given reference solution. The quadrature
/// is determined from the settings in <see cref="IBMControl"/>
/// </summary>
/// <param name="quantityOfInterest"></param>
/// <param name="referenceSolution"></param>
/// <returns></returns>
public static Query L2Error(Func <StateVector, double> quantityOfInterest, Func <double[], double, double> referenceSolution)
{
return(delegate(IApplication <AppControl> app, double time) {
IProgram <CNSControl> program = app as IProgram <CNSControl>;
if (program == null)
{
throw new Exception();
}
ImmersedSpeciesMap speciesMap = program.SpeciesMap as ImmersedSpeciesMap;
IBMControl control = program.Control as IBMControl;
if (speciesMap == null || control == null)
{
throw new Exception(
"Query is only valid for immersed boundary runs");
}
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
int order = control.LevelSetQuadratureOrder;
CellQuadratureScheme scheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, speciesMap.SubGrid.VolumeMask);
var composititeRule = scheme.Compile(program.GridData, order);
IChunkRulePair <QuadRule>[] chunkRulePairs = composititeRule.ToArray();
DGField density = program.WorkingSet.Density;
VectorField <DGField> momentum = program.WorkingSet.Momentum;
DGField energy = program.WorkingSet.Energy;
// Construct dummy field since L2Error is currently only supported
// for Field's; However, _avoid_ a projection.
DGField dummy = new SinglePhaseField(new Basis(program.GridData, 0));
Material material = speciesMap.GetMaterial(double.NaN);
int index = 0;
double value = dummy.LxError(
(ScalarFunctionEx) delegate(int j0, int Len, NodeSet nodes, MultidimensionalArray result) {
MultidimensionalArray input = program.GridData.GlobalNodes.GetValue_Cell(nodes, j0, Len);
Chunk chunk = chunkRulePairs[index].Chunk;
QuadRule rule = chunkRulePairs[index].Rule;
if (chunk.i0 != j0 || chunk.Len != Len)
{
throw new Exception();
}
if (rule.NoOfNodes != nodes.GetLength(0))
{
throw new Exception();
}
MultidimensionalArray rho = MultidimensionalArray.Create(chunk.Len, rule.NoOfNodes);
density.Evaluate(chunk.i0, chunk.Len, nodes, rho);
MultidimensionalArray[] m = new MultidimensionalArray[CNSEnvironment.NumberOfDimensions];
for (int d = 0; d < CNSEnvironment.NumberOfDimensions; d++)
{
m[d] = MultidimensionalArray.Create(chunk.Len, rule.NoOfNodes);
momentum[d].Evaluate(chunk.i0, chunk.Len, nodes, m[d]);
}
MultidimensionalArray rhoE = MultidimensionalArray.Create(chunk.Len, rule.NoOfNodes);
energy.Evaluate(chunk.i0, chunk.Len, nodes, rhoE);
double[] X = new double[CNSEnvironment.NumberOfDimensions];
Vector3D mVec = new Vector3D();
for (int i = 0; i < chunk.Len; i++)
{
for (int j = 0; j < rule.NoOfNodes; j++)
{
for (int d = 0; d < CNSEnvironment.NumberOfDimensions; d++)
{
X[d] = input[i, j, d];
mVec[d] = m[d][i, j];
}
StateVector state = new StateVector(material, rho[i, j], mVec, rhoE[i, j]);
double qoi = quantityOfInterest(state);
Debug.Assert(
!double.IsNaN(qoi),
"Encountered node with unphysical state"
+ " (not able to determine quantity of interest)");
result[i, j] = qoi - referenceSolution(X, time);
}
}
index++;
},
(X, a, b) => (a - b) * (a - b),
composititeRule);
// No value is NaN, but the results. How can this be?
// => All values around 0, but values in void region are a little
// farther away from the exact solution
// => weights in the void zone sum up to something slightly negative
Debug.Assert(
value >= 0,
"Encountered unphysical norm even though individual values where valid."
+ " This indicates a problem with cut-cell quadrature.");
return Math.Sqrt(value);
});
}