/*
* /// <summary>
* /// base matrix assembly
* /// </summary>
* /// <typeparam name="T"></typeparam>
* /// <param name="OpMatrix"></param>
* /// <param name="OpAffine"></param>
* /// <param name="RowMapping"></param>
* /// <param name="ColMapping"></param>
* /// <param name="CurrentState"></param>
* /// <param name="ParamsMap"></param>
* /// <param name="AgglomeratedCellLengthScales"></param>
* /// <param name="time"></param>
* public void AssembleMatrix<T>(BlockMsrMatrix OpMatrix, double[] OpAffine,
* UnsetteledCoordinateMapping RowMapping, UnsetteledCoordinateMapping ColMapping,
* IEnumerable<T> CurrentState, IList<DGField> ParamsMap, Dictionary<SpeciesId, MultidimensionalArray> AgglomeratedCellLengthScales,
* double time) where T : DGField {
*
* // checks
* if(ColMapping.BasisS.Count != m_XOp.DomainVar.Count)
* throw new ArgumentException();
* if(RowMapping.BasisS.Count != m_XOp.CodomainVar.Count)
* throw new ArgumentException();
* if(OpMatrix == null && CurrentState == null)
* throw new ArgumentException();
*
* SpeciesId[] SpcToCompute = AgglomeratedCellLengthScales.Keys.ToArray();
* if(!m_XOp.Species.SetEquals(SpcToCompute.Select(spcId => LsTrk.GetSpeciesName(spcId)))) {
* throw new ArgumentException("mismatch between species of operator and length scales.");
* }
*
* if(OpMatrix != null) {
*
* XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = m_XOp.GetMatrixBuilder(LsTrk, ColMapping, ParamsMap, RowMapping);
*
* foreach(var kv in AgglomeratedCellLengthScales) {
* mtxBuilder.SpeciesOperatorCoefficients[kv.Key].CellLengthScales = kv.Value;
* }
*
* mtxBuilder.time = time;
*
* mtxBuilder.ComputeMatrix(OpMatrix, OpAffine);
*
* } else {
* XSpatialOperatorMk2.XEvaluatorNonlin eval = m_XOp.GetEvaluatorEx(this.LsTrk,
* CurrentState.ToArray(), ParamsMap, RowMapping);
*
* foreach(var kv in AgglomeratedCellLengthScales) {
* eval.SpeciesOperatorCoefficients[kv.Key].CellLengthScales = kv.Value;
* }
*
* eval.time = time;
*
* eval.Evaluate(1.0, 1.0, OpAffine);
*
* }
* }
*/
public void AssembleMatrix <T>(BlockMsrMatrix OpMatrix, double[] OpAffine,
UnsetteledCoordinateMapping RowMapping, UnsetteledCoordinateMapping ColMapping,
IEnumerable <T> CurrentState, Dictionary <SpeciesId, MultidimensionalArray> AgglomeratedCellLengthScales,
double time) where T : DGField
{
AssembleMatrix(OpMatrix, OpAffine, RowMapping, ColMapping, CurrentState, AgglomeratedCellLengthScales, time);
}
/// <summary>
/// Constructor for XDG solvers
/// </summary>
public OpAnalysisBase(LevelSetTracker LsTrk, BlockMsrMatrix Mtx, double[] RHS, UnsetteledCoordinateMapping Mapping, MultiphaseCellAgglomerator CurrentAgglomeration, BlockMsrMatrix _mass, IEnumerable <MultigridOperator.ChangeOfBasisConfig[]> OpConfig, ISpatialOperator abstractOperator)
{
int RHSlen = Mapping.TotalLength;
m_map = Mapping; // mapping
VarGroup = Mapping.BasisS.Count.ForLoop(i => i); //default: all dependent variables are included in operator matrix
m_LsTrk = LsTrk;
m_OpMtx = Mtx.CloneAs();
localRHS = RHS.CloneAs();
// create the Dummy XDG aggregation basis
var baseGrid = Mapping.GridDat;
var mgSeq = Foundation.Grid.Aggregation.CoarseningAlgorithms.CreateSequence(baseGrid, 1);
AggregationGridBasis[][] XAggB = AggregationGridBasis.CreateSequence(mgSeq, Mapping.BasisS);
//
XAggB.UpdateXdgAggregationBasis(CurrentAgglomeration);
// create multigrid operator
m_MultigridOp = new MultigridOperator(XAggB, Mapping,
m_OpMtx,
_mass,
OpConfig,
abstractOperator.DomainVar.Select(varName => abstractOperator.FreeMeanValue[varName]).ToArray());
}
private static void CheckMatrix(BlockMsrMatrix M, UnsetteledCoordinateMapping RowMapping, UnsetteledCoordinateMapping ColMapping, int J)
{
if (M._RowPartitioning.LocalNoOfBlocks != J)
{
throw new ArgumentException("Number of column blocks must be equal to number of cells.");
}
if (M._ColPartitioning.LocalNoOfBlocks != J)
{
throw new ArgumentException("Number of column blocks must be equal to number of cells.");
}
if (!M._RowPartitioning.EqualsPartition(RowMapping))
{
throw new ArgumentException("Mapping must match partitioning.");
}
if (!M._ColPartitioning.EqualsPartition(ColMapping))
{
throw new ArgumentException("Mapping must match partitioning.");
}
if (!M._RowPartitioning.AllBlockSizesEqual)
{
throw new NotSupportedException("Only mappings with constant frame blocks are supported.");
}
if (!M._ColPartitioning.AllBlockSizesEqual)
{
throw new NotSupportedException("Only mappings with constant frame blocks are supported.");
}
}
/// <summary>
/// Reload of some operator after before grid-redistribution.
/// </summary>
/// <param name="Mtx_new">
/// Output, matrix which should be restored.
/// </param>
/// <param name="Reference">
/// Unique string reference under which data has been stored before grid-redistribution.
/// </param>
/// <param name="RowMapping">
/// Coordinate mapping to correlate the matrix rows with cells of the computational grid.
/// </param>
/// <param name="ColMapping">
/// Coordinate mapping to correlate the matrix columns with cells of the computational grid.
/// </param>
public void RestoreMatrix(BlockMsrMatrix Mtx_new, string Reference, UnsetteledCoordinateMapping RowMapping, UnsetteledCoordinateMapping ColMapping)
{
int J = m_NewGrid.iLogicalCells.NoOfLocalUpdatedCells;
CheckMatrix(Mtx_new, RowMapping, ColMapping, J);
BlockMsrMatrix Mtx_old = m_Matrices[Reference].Item3;
int[] RowHash = GetDGBasisHash(RowMapping.BasisS);
int[] ColHash = GetDGBasisHash(ColMapping.BasisS);
if (!ArrayTools.AreEqual(RowHash, m_Matrices[Reference].Item1))
{
throw new ApplicationException();
}
if (!ArrayTools.AreEqual(ColHash, m_Matrices[Reference].Item2))
{
throw new ApplicationException();
}
BlockMsrMatrix P_Row = GetRowPermutationMatrix(Mtx_new, Mtx_old, RowHash);
BlockMsrMatrix P_Col = GetColPermutationMatrix(Mtx_new, Mtx_old, ColHash);
Debug.Assert(Mtx_new._RowPartitioning.LocalNoOfBlocks == m_newJ);
Debug.Assert(Mtx_new._ColPartitioning.LocalNoOfBlocks == m_newJ);
Debug.Assert(Mtx_old._RowPartitioning.LocalNoOfBlocks == m_oldJ);
Debug.Assert(Mtx_old._ColPartitioning.LocalNoOfBlocks == m_oldJ);
Debug.Assert(P_Row._RowPartitioning.LocalNoOfBlocks == m_newJ);
Debug.Assert(P_Row._ColPartitioning.LocalNoOfBlocks == m_oldJ);
Debug.Assert(P_Col._RowPartitioning.LocalNoOfBlocks == m_oldJ);
Debug.Assert(P_Col._ColPartitioning.LocalNoOfBlocks == m_newJ);
BlockMsrMatrix.Multiply(Mtx_new, BlockMsrMatrix.Multiply(P_Row, Mtx_old), P_Col);
}
public MiniMapping(UnsetteledCoordinateMapping Map, SpeciesId spId, LevelSetTracker.LevelSetRegions r)
{
m_Map = Map;
m_spId = spId;
m_LsRegion = r;
Basis[] BS = Map.BasisS.ToArray();
NS = new int[BS.Length];
VarIsXdg = new bool[BS.Length];
NoOfVars = BS.Length;
for (int iVar = 0; iVar < BS.Length; iVar++) {
XDGBasis xBasis = BS[iVar] as XDGBasis;
if (xBasis != null) {
NS[iVar] = xBasis.NonX_Basis.Length;
//m_LsTrk = xBasis.Tracker;
VarIsXdg[iVar] = true;
} else {
NS[iVar] = BS[iVar].Length;
VarIsXdg[iVar] = false;
}
MaxDeg = Math.Max(MaxDeg, BS[iVar].Degree);
}
}
/// <summary>
/// Ctor for low Mach number flows.
/// </summary>
/// <param name="VelocityMapping"></param>
/// <param name="Velocity0"></param>
/// <param name="Velocity0Mean"></param>
/// <param name="Phi0"></param>
/// <param name="Phi0Mean"></param>
/// <param name="SolverConf"></param>
/// <param name="SpatialComponent">
/// Spatial component index of velocity (i.e. u_i) for affine part of operator.
/// The operator matrix is the same for all spatial directions.
/// Therefore, if SpatialComponent!=0, only the affine part of the operator is calculated.
/// </param>
public MomentumConvectionVariableDensityOperator(UnsetteledCoordinateMapping VelocityMapping,
VectorField <SinglePhaseField> Velocity0, VectorField <SinglePhaseField> Velocity0Mean, SinglePhaseField Phi0, SinglePhaseField Phi0Mean, SolverConfiguration SolverConf, int SpatialComponent)
: base(VelocityMapping, VelocityMapping, ArrayTools.Cat <SinglePhaseField>(Velocity0.ToArray(), Velocity0Mean.ToArray(), Phi0, Phi0Mean),
SolverConf, false, SpatialComponent,
OnlyAffine: (SpatialComponent != 0), OnlyBoundaryEdges: true, MaxUsePerIterMatrix: SolverConf.SpatialDimension)
{
}
public ExtVelSolver_PDEbased(Basis ExtPropertyBasis)
{
var map = new UnsetteledCoordinateMapping(ExtPropertyBasis);
m_ExtvelMatrix = new MsrMatrix(map, map);
m_ExtvelAffine = new double[m_ExtvelMatrix.RowPartitioning.LocalLength];
}
/// <summary>
/// computes a local unique coordinate index ("local" means local on this processor);
/// this index is unique over all fields (in this mapping), over all cells, over all basis functions,
/// but it's only locally (on this processor) valid.
/// A local index in the update range (smaller than <see cref="NUpdate"/>) can be converted into
/// a global index by adding <see cref="Partitioning.i0"/>.
/// </summary>
/// <param name="find">
/// the field or basis index (see <see cref="BasisS"/>);
/// </param>
/// <param name="j">local cell index</param>
/// <param name="n">DG mode index</param>
/// <param name="lsTrk"></param>
/// <param name="map"></param>
/// <param name="spcIdx">species index</param>
public static int LocalUniqueCoordinateIndex(this UnsetteledCoordinateMapping map, LevelSetTracker lsTrk, int find, int j, int spcIdx, int n)
{
//;
int NoOfSpc = lsTrk.Regions.GetNoOfSpecies(j, out var rrc);
if (spcIdx < 0 || spcIdx >= NoOfSpc)
{
throw new IndexOutOfRangeException($"Species index out of range (species index is {spcIdx}, Number of species is {NoOfSpc}, cell {j})");
}
Basis b = map.BasisS[find];
XDGBasis xb = b as XDGBasis;
if (xb == null)
{
return(map.LocalUniqueCoordinateIndex(find, j, n));
}
else
{
int i0 = map.LocalUniqueCoordinateIndex(find, j, 0);
int Ns = xb.NonX_Basis.GetLength(j);
if (n < 0 || n >= Ns)
{
throw new IndexOutOfRangeException($"DG mode index (within species) of range (DG mode index is {n}, but non-XDG basis length is {Ns}, cell {j})");
}
return(i0 + Ns * spcIdx + n);
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="SolverConf"></param>
/// <param name="WorkingSet"></param>
public SIMPLEStepIncompressible(SolverConfiguration SolverConf, VariableSet WorkingSet)
{
m_SolverConf = SolverConf;
m_WorkingSet = WorkingSet;
// Construct BDF scheme for unsteady solver
if (SolverConf.Control.Algorithm == SolutionAlgorithms.Unsteady_SIMPLE)
{
m_BDF = new BDFScheme();
}
// Construct all SIMPLEOperators, which are needed for incompressible flows
UnsetteledCoordinateMapping VelocityMapping = new UnsetteledCoordinateMapping(WorkingSet.VelBasis);
UnsetteledCoordinateMapping PressureMapping = new UnsetteledCoordinateMapping(WorkingSet.PressureBasis);
m_IncompressibleOperators = new OperatorFactoryFlowFieldIncompressible(VelocityMapping,
PressureMapping,
SolverConf,
WorkingSet.Velocity.Current,
WorkingSet.VelocityMean);
// Construct matrix assemblies
m_IncompressibleMatrixAssemblies = new MatrixFactoryIncompressibleFlows(
SolverConf, m_IncompressibleOperators, PressureMapping, WorkingSet.Pressure, m_BDF);
}
public static void Init()
{
bool dummy;
ilPSP.Environment.Bootstrap(
new string[0],
BoSSS.Solution.Application.GetBoSSSInstallDir(),
out dummy);
//GridCommons grd = Grid2D.Cartesian2DGrid(RandomSpacing(), RandomSpacing());
//grid = new GridData(Grid2D.Cartesian2DGrid(GenericBlas.Linspace(-7, 7, 8), GenericBlas.Linspace(-1, 1, 2)));
//grid = new GridData(Grid2D.Cartesian2DGrid(new double[] { -6, -4, -2, 2, 4, 6 }, GenericBlas.Linspace(-1, 1, 2)));
grid = new GridData(Grid2D.Cartesian2DGrid(GenericBlas.Linspace(-1.5, 1.5, 17), GenericBlas.Linspace(-1.5, 1.5, 17)));
MgSeq = CoarseningAlgorithms.CreateSequence(grid);
for (int p = 0; p <= 3; p++) // loop over polynomial degrees...
{
var uMapping = new UnsetteledCoordinateMapping(new Basis(grid, p));
var MgMapSeq = new MultigridMapping[MgSeq.Length];
var BasisSeq = AggregationGridBasis.CreateSequence(MgSeq, uMapping.BasisS);
for (int iLevel = 0; iLevel < MgSeq.Length; iLevel++)
{
MgMapSeq[iLevel] = new MultigridMapping(uMapping, BasisSeq[iLevel], new int[] { p });
}
MultigrigMap.Add(p, MgMapSeq);
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="TemperatureMapping"></param>
/// <param name="Velocity0"></param>
/// <param name="Velocity0Mean"></param>
/// <param name="Temperature0"></param>
/// <param name="Temperature0Mean"></param>
/// <param name="SolverConf"></param>
public OperatorFactoryTemperature(UnsetteledCoordinateMapping TemperatureMapping, UnsetteledCoordinateMapping PressureMapping,
VectorField <SinglePhaseField> Velocity0, VectorField <SinglePhaseField> Velocity0Mean, SinglePhaseField Temperature0, SinglePhaseField Temperature0Mean,
SolverConfiguration SolverConf)
{
this.TemperatureConvection = new TemperatureConvectionOperator(TemperatureMapping, Velocity0, Velocity0Mean, Temperature0, Temperature0Mean, SolverConf);
this.HeatConduction = new HeatConductionOperator(TemperatureMapping, Temperature0, SolverConf);
}
public void Laplacian(OpenFOAMGrid grid, int DgDegree)
{
// grid, etc
// =========
GridData grd = grid.GridData;
var b = new Basis(grd, DgDegree);
var map = new UnsetteledCoordinateMapping(b);
var L = new Laplace(1.3, grd.Cells.cj);
var op = new SpatialOperator(1, 0, 1, QuadOrderFunc.Linear(), "T", "c1");
op.EquationComponents["c1"].Add(L);
op.Commit();
// evaluate operator
// =================
var Mtx = new BlockMsrMatrix(map, map);
double[] B = new double[map.LocalLength];
var eval = op.GetMatrixBuilder(map, null, map);
eval.ComputeMatrix(Mtx, B);
// return data
// ===========
throw new NotImplementedException("todo");
}
/// <summary>
/// Legacy interface, preserved as static function.
/// </summary>
public static void ComputeMatrixEx <M, V>(
this XSpatialOperator xOp,
LevelSetTracker lsTrk,
UnsetteledCoordinateMapping DomainMap, IList <DGField> Parameters, UnsetteledCoordinateMapping CodomainMap,
M Matrix, V AffineOffset, bool OnlyAffine, double time, bool ParameterMPIExchange,
IDictionary <SpeciesId, MultidimensionalArray> CellLengthScales,
IDictionary <SpeciesId, MultidimensionalArray> InterfaceLengthScales, MultidimensionalArray SlipLengths,
SubGrid SubGrid, params SpeciesId[] whichSpc)
where M : IMutableMatrixEx
where V : IList <double> //
{
var SpeciesDictionary = new Dictionary <SpeciesId, XSpatialOperator.QrSchemPair>();
foreach (var sp in whichSpc)
{
SpeciesDictionary.Add(sp, new XSpatialOperator.QrSchemPair());
}
ComputeMatrixEx <M, V>(
xOp,
lsTrk,
DomainMap, Parameters, CodomainMap,
Matrix, AffineOffset, OnlyAffine, time,
ParameterMPIExchange, SpeciesDictionary, CellLengthScales,
InterfaceLengthScales, SlipLengths,
//agg, out mass,
SubGrid);
}
public static void Init()
{
//GridCommons grd = Grid2D.Cartesian2DGrid(RandomSpacing(), RandomSpacing());
//grid = new GridData(Grid2D.Cartesian2DGrid(GenericBlas.Linspace(-7, 7, 8), GenericBlas.Linspace(-1, 1, 2)));
//grid = new GridData(Grid2D.Cartesian2DGrid(new double[] { -6, -4, -2, 2, 4, 6 }, GenericBlas.Linspace(-1, 1, 2)));
//if (curved)
//{
// grid = Grid2D.CurvedSquareGrid(GenericBlas.Linspace(1, 2, 5), GenericBlas.Linspace(0, 1, 17), CellType.Square_9, true).GridData;
//}
//else
//{
// grid = (Grid2D.Cartesian2DGrid(GenericBlas.Linspace(-1.5, 1.5, 17), GenericBlas.Linspace(-1.5, 1.5, 17))).GridData;
//}
grid = (Grid2D.Cartesian2DGrid(GenericBlas.Linspace(-1.5, 1.5, 17), GenericBlas.Linspace(-1.5, 1.5, 17))).GridData;
MgSeq = CoarseningAlgorithms.CreateSequence(grid);
for (int p = 0; p <= 3; p++) // loop over polynomial degrees...
{
var uMapping = new UnsetteledCoordinateMapping(new Basis(grid, p));
var MgMapSeq = new MultigridMapping[MgSeq.Length];
var BasisSeq = AggregationGridBasis.CreateSequence(MgSeq, uMapping.BasisS);
for (int iLevel = 0; iLevel < MgSeq.Length; iLevel++)
{
MgMapSeq[iLevel] = new MultigridMapping(uMapping, BasisSeq[iLevel], new int[] { p });
}
MultigrigMap.Add(p, MgMapSeq);
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="SolverConf"></param>
/// <param name="WorkingSet"></param>
/// <param name="WorkingSetMatrices"></param>
public BaseSIMPLEStepVariableDensity(SolverConfiguration SolverConf, VariableSet WorkingSet, VariableMatrices WorkingSetMatrices)
{
this.SolverConf = SolverConf;
this.WorkingSet = WorkingSet;
this.WorkingSetMatrices = WorkingSetMatrices;
// Construct BDF scheme for unsteady solver
if (SolverConf.Control.Algorithm == SolutionAlgorithms.Unsteady_SIMPLE)
{
BDF = new BDFScheme();
}
// Construct SIMPLEOperators
UnsetteledCoordinateMapping VelocityMapping = new UnsetteledCoordinateMapping(WorkingSet.VelBasis);
UnsetteledCoordinateMapping PressureMapping = new UnsetteledCoordinateMapping(WorkingSet.PressureBasis);
Basis[] VelBasisS = new Basis[SolverConf.SpatialDimension];
for (int d = 0; d < SolverConf.SpatialDimension; d++)
{
VelBasisS[d] = WorkingSet.VelBasis;
}
UnsetteledCoordinateMapping VelocityVectorMapping = new UnsetteledCoordinateMapping(VelBasisS);
OperatorsFlowField = GetOperatorsFlowField(VelocityMapping, VelocityVectorMapping, PressureMapping);
// Construct matrix assemblies
MatrixAssembliesFlowField = new MatrixFactoryVariableDensityFlowField(
SolverConf,
OperatorsFlowField,
WorkingSetMatrices.Rho.Matrix,
BDF,
VelocityMapping,
VelocityVectorMapping);
}
/// <summary>
/// Replaces all <see cref="XDGBasis"/>-objects in the mapping <paramref name="full"/>
/// with their non-cut counterparts (<see cref="XDGBasis.NonX_Basis"/>.
/// </summary>
static UnsetteledCoordinateMapping CreateMap(UnsetteledCoordinateMapping full)
{
var basisS = from b in full.BasisS
select((b is XDGBasis)?((XDGBasis)b).NonX_Basis : b);
return(new UnsetteledCoordinateMapping(basisS.ToArray <Basis>()));
}
/// <summary>
/// Recursive constructor, i.e. constructs operators on all multigrid levels which are provided by <paramref name="basisSeq"/>.
/// </summary>
/// <param name="basisSeq"></param>
/// <param name="_ProblemMapping">
/// DG coordinate mapping on the original grid, see <see cref="BaseGridProblemMapping"/>.
/// </param>
/// <param name="OperatorMatrix"></param>
/// <param name="MassMatrix">
/// Mass matrix on the original grid. If null, the identity matrix is assumed. It is only required if the
/// </param>
/// <param name="cobc">
/// Configuration of the cell-wise, explicit block-preconditioning for each multigrid level.
/// (Remark: this kind of preconditioning is mathematically equivalent to a change of the DG resp. XDG basis.)
/// </param>
public MultigridOperator(IEnumerable <AggregationGridBasis[]> basisSeq,
UnsetteledCoordinateMapping _ProblemMapping, BlockMsrMatrix OperatorMatrix, BlockMsrMatrix MassMatrix,
IEnumerable <ChangeOfBasisConfig[]> cobc)
: this(null, basisSeq, _ProblemMapping, cobc) //
{
if (!OperatorMatrix.RowPartitioning.EqualsPartition(_ProblemMapping))
{
throw new ArgumentException("Row partitioning mismatch.");
}
if (!OperatorMatrix.ColPartition.EqualsPartition(_ProblemMapping))
{
throw new ArgumentException("Column partitioning mismatch.");
}
if (MassMatrix != null)
{
if (!MassMatrix.RowPartitioning.Equals(_ProblemMapping))
{
throw new ArgumentException("Row partitioning mismatch.");
}
if (!MassMatrix.ColPartition.Equals(_ProblemMapping))
{
throw new ArgumentException("Column partitioning mismatch.");
}
}
if (this.LevelIndex == 0)
{
if (this.IndexIntoProblemMapping_Local == null)
{
this.m_RawOperatorMatrix = OperatorMatrix;
if (MassMatrix != null)
{
this.m_RawMassMatrix = MassMatrix; //is BlockMsrMatrix) ? ((BlockMsrMatrix)MassMatrix) : MassMatrix.ToMsrMatrix();
}
else
{
this.m_RawMassMatrix = null;
}
}
else
{
this.m_RawOperatorMatrix = new BlockMsrMatrix(this.Mapping, this.Mapping);
OperatorMatrix.WriteSubMatrixTo(this.m_RawOperatorMatrix, this.IndexIntoProblemMapping_Global, default(int[]), this.IndexIntoProblemMapping_Global, default(int[]));
if (MassMatrix != null)
{
this.m_RawMassMatrix = new BlockMsrMatrix(this.Mapping, this.Mapping);
BlockMsrMatrix MMR = MassMatrix;
MMR.WriteSubMatrixTo(this.m_RawMassMatrix, this.IndexIntoProblemMapping_Global, default(int[]), this.IndexIntoProblemMapping_Global, default(int[]));
}
else
{
this.m_RawMassMatrix = null;
}
}
}
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="RowMapping"></param>
/// <param name="ColMapping"></param>
/// <param name="ParameterFields">
/// Paramter fields for SpatialOperator - can be null.
/// </param>
/// <param name="SolverConf">
/// Solver configuration.
/// </param>
/// <param name="IsConstant">
/// If true, the operator is constant over time and SIMPLE iterations.
/// That is the case for most operatores.
/// Only operators like e.g. the <see cref="LinearizedConvection"/> are not constant.
/// </param>
/// <param name="ArgumentIndex">
/// Argument index of dependent variable, e.g. spatial component u_i, for SpatialOperator
/// - this parameter is optional.
/// </param>
/// <param name="SpatialDirection">
/// Spatial direction index of independent variable, e.g. diff(p, x_i), for SpatialOperator
/// - this parameter is optional.
/// </param>
/// <param name="OnlyAffine">
/// If true, only the affine part of the operator is calculated.
/// </param>
/// <param name="OnlyBoundaryEdges">
/// If true, the integration for calculating the affine part is carried out
/// only on the boundary edges. Can be set to true for most operators.
/// </param>
/// <param name="MaxUsePerIterMatrix">
/// For operators which are not constant the maximum number
/// the matrix can be called via <see cref="OperatorMatrix"/> in one SIMPLE iteration.
/// </param>
/// <param name="MaxUsePerIterAffine">
/// For operators which are not constant the maximum number
/// the affine part can be called via <see cref="OperatorAffine"/> in one SIMPLE iteration.
/// </param>
protected SIMPLEOperator(UnsetteledCoordinateMapping RowMapping, UnsetteledCoordinateMapping ColMapping, SinglePhaseField[] ParameterFields,
SolverConfiguration SolverConf, bool IsConstant, int ArgumentIndex = -1, int SpatialDirection = -1,
bool OnlyAffine = false, bool OnlyBoundaryEdges = true, int MaxUsePerIterMatrix = 1, int MaxUsePerIterAffine = 1)
{
m_RowMapping = RowMapping;
m_ColMapping = ColMapping;
m_ParameterFields = ParameterFields;
m_IsConstant = IsConstant;
m_OnlyAffine = OnlyAffine;
m_OnlyBoundaryEdges = OnlyBoundaryEdges;
m_MaxUsePerIterMatrix = MaxUsePerIterMatrix;
m_MaxUsePerIterAffine = MaxUsePerIterAffine;
// Get SpatialOperator
m_SpatialOperator = GetSpatialOperator(SolverConf, ArgumentIndex, SpatialDirection);
// Initialize and compute matrix of this operator
if (!m_OnlyAffine)
{
m_OperatorMatrix = new MsrMatrix(m_RowMapping, m_ColMapping);
ComputeMatrix();
}
// Initialize and compute affine part of this operator
m_OperatorAffine = new double[m_RowMapping.LocalLength];
ComputeAffine();
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="SolverConf"></param>
/// <param name="WorkingSet"></param>
/// <param name="WorkingSetMatrices"></param>
public SIMPLEStepLowMach(SolverConfiguration SolverConf, VariableSet WorkingSet, VariableMatrices WorkingSetMatrices)
: base(SolverConf, WorkingSet, WorkingSetMatrices)
{
this.LowMachControl = SolverConf.Control as LowMachSIMPLEControl;
if (this.LowMachControl == null)
{
throw new ArgumentException("Invalid config", nameof(SolverConf));
}
// Construct SIMPLEOperators
UnsetteledCoordinateMapping TemperatureMapping = new UnsetteledCoordinateMapping(WorkingSet.TemperatureBasis);
UnsetteledCoordinateMapping PressureMapping = new UnsetteledCoordinateMapping(WorkingSet.PressureBasis);
OperatorsTemperature = new OperatorFactoryTemperature(
TemperatureMapping,
PressureMapping,
base.WorkingSet.Velocity.Current,
base.WorkingSet.VelocityMean,
base.WorkingSet.Temperature.Current,
base.WorkingSet.TemperatureMean,
SolverConf);
// Construct matrix assemblies
MatrixAssembliesTemperature = new MatrixFactoryTemperature(
OperatorsTemperature, TemperatureMapping.GridDat.iLogicalCells.NoOfLocalUpdatedCells, WorkingSetMatrices.Rho.Matrix, SolverConf, base.BDF);
}
/// <summary>
/// Accumulates an identity matrix, but only for selected variabels
/// </summary>
/// <param name="M">matrix to be modified (input/output)</param>
/// <param name="factor"></param>
/// <param name="iVar"></param>
static public void AccEyeSp(this ISparseMatrix M, UnsetteledCoordinateMapping map, int[] iVar, double factor = 1.0)
{
using (new FuncTrace()) {
if (M.RowPartitioning.LocalLength != M.ColPartition.LocalLength)
{
throw new ArgumentException("supported only for quadratic matrices");
}
if (map.LocalLength != M.RowPartitioning.LocalLength)
{
throw new ArgumentException();
}
int J = map.GridDat.iLogicalCells.NoOfLocalUpdatedCells;
for (int j = 0; j < J; j++)
{
foreach (int f in iVar)
{
int Np = map.BasisS[f].GetLength(j);
for (int n = 0; n < Np; n++)
{
int idx = map.GlobalUniqueCoordinateIndex(f, j, n);
M.SetDiagonalElement(idx, M.GetDiagonalElement(idx) + factor);
}
}
}
}
}
internal InternalBla(ConstantXTemporalOperator __Owner, UnsetteledCoordinateMapping DomainVarMap, IList <DGField> ParameterMap, UnsetteledCoordinateMapping CodomainVarMap)
{
this.DomainMapping = DomainVarMap;
this.Parameters = ParameterMap;
this.CodomainMapping = CodomainVarMap;
m_Owner = __Owner;
if (DomainMapping.NoOfVariables != Owner.DomainVar.Count)
{
throw new ArgumentException("Mismatch in number of domain variables.");
}
if (CodomainMapping.NoOfVariables != Owner.CodomainVar.Count)
{
throw new ArgumentException("Mismatch in number of codomain variables.");
}
if (ParameterMap.Count != Owner.ParameterVar.Count)
{
throw new ArgumentException("Mismatch in number of parameter variables.");
}
if (!DomainVarMap.EqualsPartition(CodomainVarMap))
{
throw new ArgumentException("Only supported for square matrices - domain and codomain map are not compatible (e.g. different number of rows and columns.");
}
}
/// <summary>
/// Ctor for incompressible flows.
/// </summary>
/// <param name="VelocityMapping"></param>
/// <param name="Velocity"></param>
/// <param name="VelocityMean"></param>
/// <param name="SolverConf"></param>
/// <param name="SpatialComponent">
/// Spatial component index of velocity (i.e. u_i) for affine part of operator.
/// The operator matrix is the same for all spatial directions.
/// Therefore, if SpatialComponent!=0, only the affine part of the operator is calculated.
/// </param>
public MomentumConvectionOperator(UnsetteledCoordinateMapping VelocityMapping,
VectorField <SinglePhaseField> Velocity, VectorField <SinglePhaseField> VelocityMean,
SolverConfiguration SolverConf, int SpatialComponent)
: base(VelocityMapping, VelocityMapping, ArrayTools.Cat <SinglePhaseField>(Velocity.ToArray(), VelocityMean.ToArray()),
SolverConf, false, SpatialComponent, OnlyAffine: (SpatialComponent != 0))
{
}
static private void CompOffsets(int i0, int L, int[] offset, UnsetteledCoordinateMapping Map)
{
int DELTA = offset.Length;
Debug.Assert(DELTA == Map.BasisS.Count);
int _o0 = Map.LocalUniqueCoordinateIndex(0, i0, 0);
for (int delta = 0; delta < offset.Length; delta++)
{
offset[delta] = Map.LocalUniqueCoordinateIndex(delta, i0, 0) - _o0;
}
#if DEBUG
int[] Ns = new int[DELTA];
for (int delta = 0; delta < DELTA; delta++)
{
Ns[delta] = Map.BasisS[delta].GetLength(i0);
}
for (int i = 1; i < L; i++)
{
for (int delta = 0; delta < DELTA; delta++)
{
Debug.Assert(Ns[delta] == Map.BasisS[delta].GetLength(i0 + i));
}
}
#endif
}
void DelComputeOperatorMatrix(BlockMsrMatrix OpMtx, double[] OpAffine, UnsetteledCoordinateMapping Mapping, DGField[] CurrentState, Dictionary <SpeciesId, MultidimensionalArray> AgglomeratedCellLengthScales, double phystime)
{
DGField[] Params = null;
if (this.Control.Eq == Equation.ScalarTransport)
{
Params = this.V.ToArray();
}
else if (this.Control.Eq == Equation.HeatEq)
{
Params = null;
}
else if (this.Control.Eq == Equation.Burgers)
{
Params = CurrentState;
}
else
{
throw new NotImplementedException();
}
// compute operator
Debug.Assert(OpMtx.InfNorm() == 0.0);
Debug.Assert(OpAffine.L2Norm() == 0.0);
Operator.ComputeMatrixEx(this.LsTrk,
Mapping, Params, Mapping,
OpMtx, OpAffine, false, phystime, true,
AgglomeratedCellLengthScales, null, null,
AgglomeratedCellLengthScales.Keys.ToArray());
}
/// <summary>
/// ctor
/// </summary>
public LocalSolver_Iterative(Basis __LevelSetBasis, GradientModule __gm)
{
this.GridDat = (GridData)(__LevelSetBasis.GridDat);
this.LevelSetMapping = new UnsetteledCoordinateMapping(__LevelSetBasis);
this.LevelSetBasis = __LevelSetBasis;
this.gm = __gm;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="VelocityMapping"></param>
/// <param name="VelocityVectorMapping"></param>
/// <param name="PressureMapping"></param>
/// <param name="SolverConf"></param>
/// <param name="Velocity0"></param>
/// <param name="Velocity0Mean"></param>
/// <param name="Temperature0"></param>
/// <param name="Temperature0Mean"></param>
/// <param name="eta"></param>
public OperatorFactoryFlowFieldLowMach(UnsetteledCoordinateMapping VelocityMapping, UnsetteledCoordinateMapping VelocityVectorMapping,
UnsetteledCoordinateMapping PressureMapping,
SolverConfiguration SolverConf,
VectorField <SinglePhaseField> Velocity0, VectorField <SinglePhaseField> Velocity0Mean, SinglePhaseField Temperature0, SinglePhaseField Temperature0Mean,
SinglePhaseField eta)
: base(VelocityMapping, VelocityVectorMapping, PressureMapping, SolverConf, Velocity0, Velocity0Mean, Temperature0, Temperature0Mean, eta)
{
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="VelocityMapping"></param>
/// <param name="VelocityVectorMapping"></param>
/// <param name="PressureMapping"></param>
/// <param name="SolverConf"></param>
/// <param name="Velocity0"></param>
/// <param name="Velocity0Mean"></param>
/// <param name="Phi0"></param>
/// <param name="Phi0Mean"></param>
/// <param name="eta"></param>
public OperatorFactoryFlowFieldMultiphase(UnsetteledCoordinateMapping VelocityMapping, UnsetteledCoordinateMapping VelocityVectorMapping,
UnsetteledCoordinateMapping PressureMapping,
SolverConfiguration SolverConf,
VectorField <SinglePhaseField> Velocity0, VectorField <SinglePhaseField> Velocity0Mean, SinglePhaseField Phi0, SinglePhaseField Phi0Mean,
SinglePhaseField eta)
: base(VelocityMapping, VelocityVectorMapping, PressureMapping, SolverConf, Velocity0, Velocity0Mean, Phi0, Phi0Mean, eta)
{
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="TemperatureMapping"></param>
/// <param name="Velocity0"></param>
/// <param name="Velocity0Mean"></param>
/// <param name="Temperature0"></param>
/// <param name="Temperature0Mean"></param>
/// <param name="SolverConf"></param>
public TemperatureConvectionOperator(UnsetteledCoordinateMapping TemperatureMapping,
VectorField <SinglePhaseField> Velocity0, VectorField <SinglePhaseField> Velocity0Mean, SinglePhaseField Temperature0, SinglePhaseField Temperature0Mean,
SolverConfiguration SolverConf)
: base(TemperatureMapping, TemperatureMapping,
ArrayTools.Cat <SinglePhaseField>(Velocity0.ToArray(), Velocity0Mean.ToArray(), Temperature0, Temperature0Mean),
SolverConf, false)
{
}
/// <summary>
/// Prolongates/injects a vector from the full grid (<see cref="BoSSS.Foundation.Grid.GridData"/>)
/// to the aggregated grid (<see cref="AggGrid"/>).
/// </summary>
/// <param name="FullGridVector">output;</param>
/// <param name="AggGridVector">input;</param>
virtual public void ProlongateToFullGrid <T, V>(T FullGridVector, V AggGridVector)
where T : IList <double>
where V : IList <double> //
{
var fullMapping = new UnsetteledCoordinateMapping(this.DGBasis);
if (FullGridVector.Count != fullMapping.LocalLength)
{
throw new ArgumentException("mismatch in vector length", "FullGridVector");
}
int L = this.LocalDim;
if (AggGridVector.Count != L)
{
throw new ArgumentException("mismatch in vector length", "AggGridVector");
}
var ag = this.AggGrid;
var agCls = ag.iLogicalCells.AggregateCellToParts;
int JAGG = ag.iLogicalCells.NoOfLocalUpdatedCells;
int N = this.DGBasis.Length;
var FulCoords = new double[N];
var AggCoords = new double[N];
//MultidimensionalArray Trf = MultidimensionalArray.Create(N, N);
for (int jAgg = 0; jAgg < JAGG; jAgg++)
{
int[] agCl = agCls[jAgg];
int K = agCl.Length;
int i0 = jAgg * N;
for (int n = 0; n < N; n++)
{
AggCoords[n] = AggGridVector[n + i0];
}
for (int k = 0; k < K; k++) // loop over the cells wich form the aggregated cell...
{
int jCell = agCl[k];
int j0 = fullMapping.LocalUniqueCoordinateIndex(0, jCell, 0);
//Trf.Clear();
//Trf.Acc(1.0, this.CompositeBasis[jAgg].ExtractSubArrayShallow(k, -1, -1));
var Trf = this.CompositeBasis[jAgg].ExtractSubArrayShallow(k, -1, -1);
//Trf.Solve(FulCoords, AggCoords);
Trf.gemv(1.0, AggCoords, 0.0, FulCoords);
for (int n = 0; n < N; n++)
{
FullGridVector[j0 + n] = FulCoords[n];
}
}
}
}
/// <summary>
/// ctor
/// </summary>
public LocalSolver_Elliptic(Basis __LevelSetBasis)
{
this.GridDat = (GridData)(__LevelSetBasis.GridDat);
this.LevelSetMapping = new UnsetteledCoordinateMapping(__LevelSetBasis);
this.LevelSetBasis = __LevelSetBasis;
this.m_LaplaceMatrix = new MsrMatrix(this.LevelSetMapping, this.LevelSetMapping);
this.m_LaplaceAffine = new double[this.LevelSetMapping.LocalLength];
}
