/// <summary>
/// passes the coefficients to original form
/// </summary>
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
if (m_OrgForm is IEquationComponentCoefficient eqc)
{
eqc.CoefficientUpdate(cs, DomainDGdeg, TestDGdeg);
}
}
/// <summary>
/// update the coefficient such as the current Weissenberg number
/// </summary>
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
if (cs.UserDefinedValues.Keys.Contains("Weissenbergnumber"))
{
weissenberg = (double)cs.UserDefinedValues["Weissenbergnumber"];
}
}
public void CoefficientUpdate(CoefficientSet csA, CoefficientSet csB, int[] DomainDGdeg, int TestDGdeg)
{
if (csA.UserDefinedValues.Keys.Contains("EvapMicroRegion"))
{
evapMicroRegion = (BitArray)csA.UserDefinedValues["EvapMicroRegion"];
}
}
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
if (cs.UserDefinedValues.Keys.Contains("time"))
{
time = (double)cs.UserDefinedValues["time"];
}
}
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
if (cs.UserDefinedValues.Keys.Contains("Weissenbergnumber")) {
m_Weissenberg = (double)cs.UserDefinedValues["Weissenbergnumber"];
//Console.WriteLine("Weissenbergnumber = {0}", m_Weissenberg);
}
}
/// <summary>
///
/// </summary>
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
if (cs.UserDefinedValues.Keys.Contains("Reynolds"))
{
m_Reynolds = (double)cs.UserDefinedValues["Reynolds"];
}
}
public override void CoefficientUpdate(CoefficientSet csA, CoefficientSet csB, int[] DomainDGdeg, int TestDGdeg)
{
base.CoefficientUpdate(csA, csB, DomainDGdeg, TestDGdeg);
NegLengthScaleS = csA.CellLengthScales;
PosLengthScaleS = csB.CellLengthScales;
}
/// <summary>
/// Da number used within the homotopie algorithm
/// </summary>
/// <param name="cs"></param>
/// <param name="DomainDGdeg"></param>
/// <param name="TestDGdeg"></param>
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
if (cs.UserDefinedValues.Keys.Contains("Damkoehler"))
{
m_Da = (double)cs.UserDefinedValues["Damkoehler"];
}
}
/// <summary>
/// Called by
/// <see cref="XSpatialOperatorMk2.XEvaluatorNonlin.Evaluate{Tout}(double, double, Tout, double[])"/>
/// resp.
/// <see cref="XSpatialOperatorMk2.XEvaluatorLinear.ComputeMatrix{M, V}(M, V)"/>.
/// </summary>
public void CoefficientUpdate(CoefficientSet csA, CoefficientSet csB, int[] DomainDGdeg, int TestDGdeg)
{
NegCellLengthScaleS = csA.CellLengthScales;
if (csB != null)
{
PosCellLengthScaleS = csB.CellLengthScales;
}
}
override public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
base.CoefficientUpdate(cs, DomainDGdeg, TestDGdeg);
if (cs.CellLengthScales == null)
{
throw new ArgumentException("Internal Error - no cell Lengths provided.");
}
this.m_LenScales = cs.CellLengthScales;
}
public void CoefficientUpdate(CoefficientSet csA, CoefficientSet csB, int[] DomainDGdeg, int TestDGdeg)
{
NegLengthScaleS = csA.CellLengthScales;
PosLengthScaleS = csB.CellLengthScales;
if (csA.UserDefinedValues.Keys.Contains("EvapMicroRegion"))
{
evapMicroRegion = (BitArray)csA.UserDefinedValues["EvapMicroRegion"];
}
}
public virtual void CoefficientUpdate(CoefficientSet csA, CoefficientSet csB, int[] DomainDGdeg, int TestDGdeg)
{
if (csA.UserDefinedValues.Keys.Contains("EvapMicroRegion"))
{
evapMicroRegion = (BitArray)csA.UserDefinedValues["EvapMicroRegion"];
}
if (csA.UserDefinedValues.Keys.Contains("prescribedMassflux"))
{
MEvapIsPrescribd = true;
prescrbMEvap = (double)csA.UserDefinedValues["prescribedMassflux"];
}
}
/// <summary>
/// Update of penalty length scales.
/// </summary>
/// <param name="cs"></param>
/// <param name="DomainDGdeg"></param>
/// <param name="TestDGdeg"></param>
public virtual void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
m_D = cs.GrdDat.SpatialDimension;
double _D = m_D;
double _p = DomainDGdeg.Max();
double penalty_deg_tri = (_p + 1) * (_p + _D) / _D; // formula for triangles/tetras
double penalty_deg_sqr = (_p + 1.0) * (_p + 1.0); // formula for squares/cubes
m_penalty = Math.Max(penalty_deg_tri, penalty_deg_sqr); // the conservative choice
cj = cs.CellLengthScales;
}
public void CoefficientUpdate(CoefficientSet csA, CoefficientSet csB, int[] DomainDGdeg, int TestDGdeg)
{
NegLengthScaleS = csA.CellLengthScales;
PosLengthScaleS = csB.CellLengthScales;
if (csA.UserDefinedValues.Keys.Contains("Weissenbergnumber"))
{
WeissenbergA = (double)csA.UserDefinedValues["Weissenbergnumber"];
}
if (csB.UserDefinedValues.Keys.Contains("Weissenbergnumber"))
{
WeissenbergB = (double)csB.UserDefinedValues["Weissenbergnumber"];
}
}
public async Task <Temps> ReadThermometer(int index)
{
if (index < 0 || index > 7)
{
throw new IndexOutOfRangeException("Index must be from 0-7");
}
using (await this.thermometerLock.LockAsync())
{
await this.initTask;
double sum = 0;
const int numSamples = 3;
for (int i = 0; i < numSamples; i++)
{
var reading = this.mcp.Read(Channels[index]);
sum += reading.NormalizedValue;
await Task.Delay(100);
}
double averageValue = sum / numSamples;
//Debug.WriteLine($"Reading for thermometer {index} is {reading.RawValue}, Normalized: {reading.NormalizedValue}");
double voltage = averageValue * InputVoltage;
double resistance = TempUtils.GetThermistorResistenceFromVoltage(3.3, voltage, BalancingResistorOhms);
//Debug.WriteLine($"Got Resistance {resistance} from voltage {voltage}");
CoefficientSet coefficients = Coefficients[0];
var temps = new Temps();
if (double.IsInfinity(resistance))
{
temps.Kelvin = 0;
}
else
{
temps.Kelvin = TempUtils.ResistanceToTemp(coefficients.A, coefficients.B, coefficients.C, resistance);
}
temps.Celcius = TempUtils.KelvinToCelcius(temps.Kelvin);
temps.Farenheight = TempUtils.CelciusToFarenheight(temps.Celcius);
return(temps);
}
}
/// <summary>
/// Update of penalty length scales.
/// </summary>
/// <param name="cs"></param>
/// <param name="DomainDGdeg"></param>
/// <param name="TestDGdeg"></param>
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
m_D = cs.GrdDat.SpatialDimension;
double _D = m_D;
double _p = DomainDGdeg.Max();
double penalty_deg_tri = (_p + 1) * (_p + _D) / _D; // formula for triangles/tetras
double penalty_deg_sqr = (_p + 1.0) * (_p + 1.0); // formula for squares/cubes
m_penalty = Math.Max(penalty_deg_tri, penalty_deg_sqr); // the conservative choice
cj = cs.CellLengthScales;
if (cs.UserDefinedValues.Keys.Contains("SlipLengths"))
{
Lslip = (MultidimensionalArray)cs.UserDefinedValues["SlipLengths"];
}
}
/// <summary>
/// Update of penalty length scales.
/// </summary>
/// <param name="cs"></param>
/// <param name="DomainDGdeg"></param>
/// <param name="TestDGdeg"></param>
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
m_D = cs.GrdDat.SpatialDimension;
double _D = m_D;
double _p = DomainDGdeg.Max();
double penalty_deg_tri = (_p + 1) * (_p + _D) / _D; // formula for triangles/tetras
double penalty_deg_sqr = (_p + 1.0) * (_p + 1.0); // formula for squares/cubes
m_penalty = Math.Max(penalty_deg_tri, penalty_deg_sqr); // the conservative choice
cj = cs.CellLengthScales;
// Set the Reynolds number to a user defined value contained in the CoefficientSet cs
// Useful in case that the Reynolds number changes during a simulation...
if (cs.UserDefinedValues.Keys.Contains("Reynolds"))
{
m_Reynolds = (double)cs.UserDefinedValues["Reynolds"];
}
}
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
owner.CoefficientUpdate(cs, DomainDGdeg, TestDGdeg);
}
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
h_max_Edge = cs.EdgeLengthScales;
}
/// <summary>
/// Create Spatial Operators and build the corresponding Matrices
/// </summary>
public void ComputeMatrices(IList <DGField> InterfaceParams, bool nearfield)
{
OpMatrix = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine = new double[OpMatrix.RowPartitioning.LocalLength];
OpMatrix_bulk = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine_bulk = new double[OpMatrix.RowPartitioning.LocalLength];
OpMatrix_interface = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine_interface = new double[OpMatrix.RowPartitioning.LocalLength];
//LevelSetTracker.GetLevelSetGradients(0,);
// bulk part of the matrix
//Operator_bulk.ComputeMatrix(
// Extension.Mapping,
// LevelSetGradient.ToArray(),
// Extension.Mapping,
// OpMatrix_bulk, OpAffine_bulk,
// OnlyAffine: false, sgrd: null);
switch (Control.FluxVariant)
{
case FluxVariant.GradientBased:
// Flux Direction based on Mean Level Set Gradient
BulkParams = new List <DGField> {
}; // Hack, to make ArrayTools.Cat produce a List of DGFields
// second Hack: Does only work, when InterfaceParams is according to a single component flux,
// else, we will have to change the boundary edge flux
BulkParams = ArrayTools.Cat(BulkParams, LevelSetGradient.ToArray(), Phi, MeanLevelSetGradient.ToArray(), InterfaceParams.ToArray());
MeanLevelSetGradient.Clear();
MeanLevelSetGradient.AccLaidBack(1.0, LevelSetGradient);
break;
case FluxVariant.ValueBased:
// Flux Direction Based on Cell-Averaged Level-Set Value
BulkParams = ArrayTools.Cat(LevelSetGradient.ToArray(), Phi, MeanLevelSet);
MeanLevelSet.Clear();
MeanLevelSet.AccLaidBack(1.0, Phi);
break;
case FluxVariant.SWIP:
BulkParams = LevelSetGradient.ToArray();
break;
default:
throw new Exception();
}
// Build Operator
Operator_bulk.ComputeMatrixEx(Extension.Mapping,
BulkParams,
Extension.Mapping,
OpMatrix_bulk, OpAffine_bulk,
OnlyAffine: false,
time: 0.0,
edgeQuadScheme: new EdgeQuadratureScheme(true, nearfield ? LevelSetTracker.Regions.GetNearFieldSubgrid(1).InnerEdgesMask : null),
volQuadScheme: new CellQuadratureScheme(true, nearfield ? LevelSetTracker.Regions.GetNearFieldSubgrid(1).VolumeMask : null)
);
//Operator_interface.ComputeMatrixEx(
// LevelSetTracker,
// Extension.Mapping,
// InterfaceParams,
// Extension.Mapping,
// OpMatrix_interface,
// OpAffine_interface,
// OnlyAffine: false,
// time: 0,
// MPIParameterExchange: false,
// whichSpc: LevelSetTracker.GetSpeciesId("A")
// );
Operator_interface.OperatorCoefficientsProvider =
delegate(LevelSetTracker lstrk, SpeciesId spc, int quadOrder, int TrackerHistoryIdx, double time) {
var r = new CoefficientSet()
{
};
//throw new NotImplementedException("todo");
return(r);
};
XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = Operator_interface.GetMatrixBuilder(LevelSetTracker,
Extension.Mapping, InterfaceParams, Extension.Mapping);
MultiphaseCellAgglomerator dummy = LevelSetTracker.GetAgglomerator(LevelSetTracker.SpeciesIdS.ToArray(), 2 * Extension.Basis.Degree + 2, 0.0);
mtxBuilder.CellLengthScales.Add(LevelSetTracker.GetSpeciesId("A"), dummy.CellLengthScales[LevelSetTracker.GetSpeciesId("A")]);
mtxBuilder.time = 0;
mtxBuilder.MPITtransceive = false;
mtxBuilder.ComputeMatrix(OpMatrix_interface, OpAffine_interface);
#if DEBUG
OpMatrix_bulk.CheckForNanOrInfM();
OpAffine_bulk.CheckForNanOrInfV();
OpMatrix_interface.CheckForNanOrInfM();
OpAffine_interface.CheckForNanOrInfV();
#endif
//Only for Debugging purposes
Debug.Assert(OpMatrix_interface.GetDiagVector().L2Norm() > 0, "L2-Norm of Diagonal of InterfaceOperator is 0");
Debug.Assert(OpMatrix_bulk.GetDiagVector().L2Norm() > 0, "L2-Norm of Diagonal of BulkOperator is 0");
#if DEBUG
//Console.WriteLine( "L2-Norm of Diagonal of InterfaceOperator is {0}", OpMatrix_interface.GetDiagVector().L2Norm() );
#endif
OpMatrix.Clear();
OpMatrix.Acc(1.0, OpMatrix_bulk);
OpMatrix.Acc(1.0, OpMatrix_interface);
//Console.WriteLine("Op-Matrix Symmetry-Deviation: {0}", OpMatrix.SymmetryDeviation());
OpMatrix.AssumeSymmetric = false;
OpAffine.Clear();
OpAffine.AccV(1.0, OpAffine_bulk);
OpAffine.AccV(1.0, OpAffine_interface);
#if DEBUG
//Console.WriteLine("Condition Number of Extension Operator {0}", OpMatrix.condest());
#endif
}
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
SubGrdMask = lsTrk.Regions.GetSpeciesSubGrid(m_spcId).VolumeMask.GetBitMaskWithExternal();
}
override public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
base.CoefficientUpdate(cs, DomainDGdeg, TestDGdeg);
this.m_LenScales = cs.CellLengthScales;
}
public void CoefficientUpdate(CoefficientSet csA, CoefficientSet csB, int[] DomainDGdeg, int TestDGdeg)
{
NegLengthScaleS = csA.CellLengthScales;
PosLengthScaleS = csB.CellLengthScales;
}
public void CoefficientUpdate(CoefficientSet cs, int[] DomainDGdeg, int TestDGdeg)
{
m_LengthScales = cs.CellLengthScales;
}
