/// <summary>
/// [VariableDensity] Ctor.
/// </summary>
/// <param name="SolverConf"></param>
/// <param name="Src"></param>
/// <param name="BDF"></param>
/// <param name="Rho"></param>
/// <param name="MaxUseMatrix"></param>
public MatrixAssemblyApprox(SolverConfiguration SolverConf, int NoOfCells, SIMPLEMatrixAssembly Src, BDFScheme BDF, BlockDiagonalMatrix Rho, int MaxUseMatrix = 1)
: base(SolverConf.Control.PredictorApproximationIsConstant, false, MaxUsePerIterMatrix: MaxUseMatrix)
{
m_SolverConf = SolverConf;
m_Src = Src;
m_BDF = BDF;
m_NoOfCells = NoOfCells;
if (Rho != null)
{
// VariableDensity
m_Rho = Rho;
if (m_Src.i0 != m_Rho.RowPartitioning.i0)
{
throw new NotImplementedException("Different row partitions, which should be equal.");
}
}
else
{
// Incompressible
m_Rho = new BlockDiagonalMatrix(m_Src.LocalLength, 1);
m_Rho.AccEyeSp();
}
base.Initialize();
}
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix Approx = m_Approx.AssemblyMatrix;
MsrMatrix ApproxInv = new MsrMatrix(Approx.RowPartitioning, Approx.ColPartition);
switch (m_SolverConf.PredictorApproximation)
{
case PredictorApproximations.Identity:
case PredictorApproximations.Identity_IP1:
case PredictorApproximations.Diagonal:
int i0 = Approx.RowPartitioning.i0;
int LocalLength = Approx.RowPartitioning.LocalLength;
for (int row = 0; row < LocalLength; row++)
{
double Approx_ii = Approx[row + i0, row + i0];
ApproxInv[row + i0, row + i0] = 1.0 / Approx_ii;
}
break;
case PredictorApproximations.BlockDiagonal:
BlockDiagonalMatrix ApproxBlock = new BlockDiagonalMatrix(Approx, Approx.RowPartitioning.LocalLength / m_LocalNoOfCells, Approx.ColPartition.LocalLength / m_LocalNoOfCells);
BlockDiagonalMatrix ApproxBlockInv = ApproxBlock.Invert();
ApproxInv.Acc(1.0, ApproxBlockInv);
break;
default:
throw new ArgumentException();
}
return(ApproxInv);
}
static void Main(string[] args)
{
Application.InitMPI();
MultidimensionalArray myMultidimensionalArray = MultidimensionalArray.Create(3, 6);
myMultidimensionalArray[1, 2] = 3.0;
myMultidimensionalArray[2, 5] = 2.0;
TestShowVisualizer(myMultidimensionalArray);
BlockDiagonalMatrix myBlockDiagonalMatrix = new BlockDiagonalMatrix(15, 3);
myBlockDiagonalMatrix[1, 1] = 1.0;
TestShowVisualizer(myBlockDiagonalMatrix);
MsrMatrix myMsrMatrix = new MsrMatrix(4, 1);
myMsrMatrix[1, 1] = 3.0;
TestShowVisualizer(myMsrMatrix);
MultidimensionalArray myNodeSet = MultidimensionalArray.Create(3, 2);
myNodeSet[0, 0] = 1.0;
myNodeSet[0, 1] = 2.0;
myNodeSet[1, 0] = 3.0;
myNodeSet[1, 1] = 4.0;
myNodeSet[2, 0] = 5.0;
myNodeSet[2, 1] = 6.0;
NodeSet nodeSet = new NodeSet(null, myNodeSet);
TestShowVisualizer(nodeSet);
}
static void Main(string[] args)
{
bool dummy;
ilPSP.Environment.Bootstrap(args, Application.GetBoSSSInstallDir(), out dummy);
MultidimensionalArray myMultidimensionalArray = MultidimensionalArray.Create(3, 6);
myMultidimensionalArray[1, 2] = 3.0;
myMultidimensionalArray[2, 5] = 2.0;
TestShowVisualizer(myMultidimensionalArray);
BlockDiagonalMatrix myBlockDiagonalMatrix = new BlockDiagonalMatrix(15, 3);
myBlockDiagonalMatrix[1, 1] = 1.0;
TestShowVisualizer(myBlockDiagonalMatrix);
MsrMatrix myMsrMatrix = new MsrMatrix(4, 1);
myMsrMatrix[1, 1] = 3.0;
TestShowVisualizer(myMsrMatrix);
MultidimensionalArray myNodeSet = MultidimensionalArray.Create(3, 2);
myNodeSet[0, 0] = 1.0;
myNodeSet[0, 1] = 2.0;
myNodeSet[1, 0] = 3.0;
myNodeSet[1, 1] = 4.0;
myNodeSet[2, 0] = 5.0;
myNodeSet[2, 1] = 6.0;
NodeSet nodeSet = new NodeSet(null, myNodeSet);
TestShowVisualizer(nodeSet);
}
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix Src = m_Src.AssemblyMatrix;
MsrMatrix Approx = new MsrMatrix(Src.RowPartitioning, Src.ColPartition);
int i0 = Src.RowPartitioning.i0;
int LocalLength = Src.RowPartitioning.LocalLength;
double BDFfactor;
switch (m_SolverConf.Control.Algorithm)
{
case SolutionAlgorithms.Steady_SIMPLE:
BDFfactor = 0.0;
break;
case SolutionAlgorithms.Unsteady_SIMPLE:
int BDFOrder = m_SolverConf.BDFOrder;
double dt = m_SolverConf.dt;
BDFfactor = m_BDF.beta[BDFOrder - 1][0] / (m_BDF.gamma[BDFOrder - 1] * dt);
break;
default:
throw new ArgumentException();
}
switch (m_SolverConf.Control.PredictorApproximation)
{
case PredictorApproximations.Identity:
case PredictorApproximations.Identity_IP1:
Approx.AccEyeSp();
Approx.AccEyeSp(BDFfactor);
break;
case PredictorApproximations.Diagonal:
for (int row = 0; row < LocalLength; row++)
{
double Src_ii = Src[row + i0, row + i0];
double Rho_ii = m_Rho[row + i0, row + i0];
Approx[row + i0, row + i0] = BDFfactor * Rho_ii + Src_ii;
}
break;
case PredictorApproximations.BlockDiagonal:
BlockDiagonalMatrix SrcBlock = new BlockDiagonalMatrix(Src, Src.RowPartitioning.LocalLength / m_NoOfCells, Src.ColPartition.LocalLength / m_NoOfCells);
Approx.Acc(1.0, SrcBlock);
Approx.Acc(BDFfactor, m_Rho);
break;
default:
throw new ArgumentException();
}
return(Approx);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="Basis"></param>
/// <param name="GridDat"></param>
/// <param name="Fields"></param>
public QuadratureMatrix(Basis Basis, IGridData GridDat, params SinglePhaseField[] Fields)
: base(new int[] { Basis.MaximalLength *Basis.MaximalLength },
GridDat,
(new CellQuadratureScheme()).Compile(GridDat, Fields[0].Basis.Degree + 2 * Basis.Degree)) //
{
m_Basis = Basis;
m_Fields = Fields;
UnsetteledCoordinateMapping map = new UnsetteledCoordinateMapping(Basis);
m_Matrix = new BlockDiagonalMatrix(map.LocalLength, Basis.MaximalLength);
FieldVals = new MultidimensionalArray[Fields.Length];
}
public void Init(MultigridOperator op)
{
BlockMsrMatrix M = op.OperatorMatrix;
var MgMap = op.Mapping;
this.m_MultigridOp = op;
if (!M.RowPartitioning.Equals(MgMap.Partitioning))
{
throw new ArgumentException("Row partitioning mismatch.");
}
if (!M.ColPartition.Equals(MgMap.Partitioning))
{
throw new ArgumentException("Column partitioning mismatch.");
}
Mtx = M;
int L = M.RowPartitioning.LocalLength;
/*
* diag = new double[L];
* int i0 = Mtx.RowPartitioning.i0;
*
* for(int i = 0; i < L; i++) {
* diag[i] = Mtx[i0 + i, i0 + i];
* }
*/
if (op.Mapping.MaximalLength != op.Mapping.MinimalLength)
{
// 'BlockDiagonalMatrix' should be completely replaced by 'BlockMsrMatrix'
throw new NotImplementedException("todo - Block Jacobi for variable block Sizes");
}
int Nblk = op.Mapping.MaximalLength;
Diag = new BlockDiagonalMatrix(M.ToMsrMatrix(), Nblk, Nblk);
invDiag = Diag.Invert();
invDiag.CheckForNanOrInfM();
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="solverConfig"></param>
/// <param name="_sparseSolver"></param>
/// <param name="DensityMatrix"></param>
/// <param name="MatAsmblyTemperature"></param>
/// <param name="MatAsmblyTemperatureApprox"></param>
/// <param name="Temperature"></param>
/// <param name="BDF"></param>
/// <param name="EoS"></param>
/// <param name="ThermodynamicPressure"></param>
public LowMachSolverTemperature(SolverConfiguration solverConfig, ISparseSolver _sparseSolver,
BlockDiagonalMatrix DensityMatrix, SIMPLEMatrixAssembly MatAsmblyTemperature, SIMPLEMatrixAssembly MatAsmblyTemperatureApprox,
ScalarFieldHistory <SinglePhaseField> Temperature,
BDFScheme BDF, MaterialLaw EoS,
ScalarFieldHistory <SinglePhaseField> ThermodynamicPressure)
: base(solverConfig, _sparseSolver)
{
this.DensityMatrix = DensityMatrix;
this.MatAsmblyTemperature = MatAsmblyTemperature;
this.MatAsmblyTemperatureApprox = MatAsmblyTemperatureApprox;
LowMachSIMPLEControl lowMachControl = solverConfig.Control as LowMachSIMPLEControl;
this.ModeRelaxTemperature = lowMachControl.RelaxationModeTemperature;
this.RelaxFactor = (1.0 - lowMachControl.RelexationFactorTemperature) / lowMachControl.RelexationFactorTemperature;
this.Temperature = Temperature;
this.BDF = BDF;
this.EoS = EoS;
this.gamma = lowMachControl.Gamma;
this.ThermodynamicPressure = ThermodynamicPressure;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="solverConf"></param>
/// <param name="_sparseSolver"></param>
/// <param name="DensityMatrix"></param>
/// <param name="MatAsmblyPredictor"></param>
/// <param name="MatAsmblyPredictorApprox"></param>
/// <param name="PressureGradient"></param>
/// <param name="Pressure"></param>
/// <param name="MatAsmblyViscSplit"></param>
/// <param name="BuoyantForce"></param>
/// <param name="Velocity"></param>
/// <param name="Scalar"></param>
/// <param name="EoS"></param>
/// <param name="BDF"></param>
public VariableDensitySolverPredictor(SolverConfiguration solverConf, ISparseSolver _sparseSolver,
BlockDiagonalMatrix DensityMatrix, SIMPLEMatrixAssembly MatAsmblyPredictor, SIMPLEMatrixAssembly MatAsmblyPredictorApprox,
SIMPLEOperator[] PressureGradient, SinglePhaseField Pressure,
SIMPLEMatrixAssembly[,] MatAsmblyViscSplit, IEvaluatorNonLin[] BuoyantForce,
VectorFieldHistory <SinglePhaseField> Velocity, ScalarFieldHistory <SinglePhaseField> Scalar, MaterialLaw EoS, BDFScheme BDF)
: base(solverConf, _sparseSolver)
{
m_DensityMatrix = DensityMatrix;
m_MatAsmblyPredictor = MatAsmblyPredictor;
m_MatAsmblyPredictorApprox = MatAsmblyPredictorApprox;
m_PressureGradient = PressureGradient;
m_Pressure = Pressure;
m_MatAsmblyViscSplit = MatAsmblyViscSplit;
m_BuoyantForceEvaluator = BuoyantForce;
m_Velocity = Velocity;
m_Scalar = Scalar;
m_EoS = EoS;
m_RelaxFactor = (1.0 - base.m_solverConf.Control.RelexationFactorVelocity) / base.m_solverConf.Control.RelexationFactorVelocity;
m_BDF = BDF;
}
/// <summary>
/// Ctor.
/// </summary>
public MatrixFactoryTemperature(OperatorFactoryTemperature TemperatureOperators, int LocalNoOfCells, BlockDiagonalMatrix Rho,
SolverConfiguration solverConf, BDFScheme BDF)
{
Temperature = new MatrixAssemblyTemperature(TemperatureOperators.TemperatureConvection, TemperatureOperators.HeatConduction);
LowMachSIMPLEControl lowMachControl = solverConf.Control as LowMachSIMPLEControl;
if (lowMachControl.RelaxationModeTemperature == RelaxationTypes.Implicit)
{
TemperatureApprox = new MatrixAssemblyApprox(
solverConf, LocalNoOfCells, Temperature, BDF, Rho, 2 * lowMachControl.PredictorApproximationUpdateCycle);
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="SolverConf"></param>
/// <param name="OperatorsFlowField"></param>
/// <param name="Rho"></param>
/// <param name="BDF"></param>
/// <param name="VelocityMapping"></param>
/// <param name="VelocityVectorMapping"></param>
public MatrixFactoryVariableDensityFlowField(SolverConfiguration SolverConf, OperatorFactoryFlowFieldVariableDensity OperatorsFlowField,
BlockDiagonalMatrix Rho, BDFScheme BDF,
UnsetteledCoordinateMapping VelocityMapping, UnsetteledCoordinateMapping VelocityVectorMapping)
{
// Initialize Predictor
// ====================
ViscSplit = new SIMPLEMatrixAssembly[SolverConf.SpatialDimension, SolverConf.SpatialDimension];
for (int i = 0; i < SolverConf.SpatialDimension; i++)
{
for (int j = 0; j < SolverConf.SpatialDimension; j++)
{
switch (SolverConf.Control.PhysicsMode)
{
case PhysicsMode.LowMach:
ViscSplit[i, j] = new MatrixAssemblyViscSplit(OperatorsFlowField.Swip2[i], OperatorsFlowField.Swip3[i],
j, VelocityMapping, VelocityVectorMapping);
break;
case PhysicsMode.Multiphase:
ViscSplit[i, j] = new MatrixAssemblyViscSplit(OperatorsFlowField.Swip2[i], null,
j, VelocityMapping, VelocityVectorMapping);
break;
case PhysicsMode.Incompressible:
throw new ApplicationException("Using wrong matrix factory for incompressible flows");
default:
throw new NotImplementedException();
}
}
}
//SaveMatricesToTextFile(OperatorsFlowField, VelocityMapping, VelocityVectorMapping);
Predictor = new SIMPLEMatrixAssembly[SolverConf.SpatialDimension];
PredictorApprox = new SIMPLEMatrixAssembly[SolverConf.SpatialDimension];
PredictorApproxInv = new SIMPLEMatrixAssembly[SolverConf.SpatialDimension];
for (int comp = 0; comp < SolverConf.SpatialDimension; comp++)
{
Predictor[comp] = new MatrixAssemblyVariableDensityPredictor(comp, OperatorsFlowField.Convection, OperatorsFlowField.Visc, ViscSplit);
PredictorApprox[comp] = new MatrixAssemblyApprox(SolverConf, VelocityMapping.GridDat.iLogicalCells.NoOfLocalUpdatedCells, Predictor[comp], BDF, Rho, 1 + 2 * SolverConf.Control.PredictorApproximationUpdateCycle);
PredictorApproxInv[comp] = new MatrixAssemblyApproxInv(SolverConf.Control, VelocityMapping.GridDat.iLogicalCells.NoOfLocalUpdatedCells, PredictorApprox[comp], 1 + SolverConf.Control.PredictorApproximationUpdateCycle);
}
// Initialize Corrector
// ====================
switch (SolverConf.Control.PhysicsMode)
{
case PhysicsMode.LowMach:
Corrector = new MatrixAssemblyVariableDensityCorrector(OperatorsFlowField.DivergenceConti, PredictorApproxInv, OperatorsFlowField.PressureGradient);
break;
case PhysicsMode.Multiphase:
Corrector = new MatrixAssemblyVariableDensityCorrector(OperatorsFlowField.DivergenceConti, PredictorApproxInv, OperatorsFlowField.PressureGradient, SolverConf.Control.PredictorApproximationUpdateCycle);
break;
case PhysicsMode.Incompressible:
throw new ApplicationException("Using wrong matrix factory for incompressible flows");
default:
throw new NotImplementedException();
}
}
