int
ChangeGCXIDs(ClientPtr client, GC * pGC, BITS32 mask, CARD32 *pC32)
{
ChangeGCVal vals[GCLastBit + 1];
int i;
if (mask & ~GCAllBits) {
client->errorValue = mask;
return BadValue;
}
for (i = Ones(mask); i--;)
vals[i].val = pC32[i];
for (i = 0; i < ARRAY_SIZE(xidfields); ++i) {
int offset, rc;
if (!(mask & xidfields[i].mask))
continue;
offset = Ones(mask & (xidfields[i].mask - 1));
if (xidfields[i].mask == GCClipMask && vals[offset].val == None) {
vals[offset].ptr = NullPixmap;
continue;
}
rc = dixLookupResourceByType(&vals[offset].ptr, vals[offset].val,
xidfields[i].type, client,
xidfields[i].access_mode);
if (rc != Success) {
client->errorValue = vals[offset].val;
return rc;
}
}
return ChangeGC(client, pGC, mask, vals);
}
void
miRenderColorToPixel (PictFormatPtr format,
xRenderColor *color,
CARD32 *pixel)
{
CARD32 r, g, b, a;
miIndexedPtr pIndexed;
switch (format->type) {
case PictTypeDirect:
r = color->red >> (16 - Ones (format->direct.redMask));
g = color->green >> (16 - Ones (format->direct.greenMask));
b = color->blue >> (16 - Ones (format->direct.blueMask));
a = color->alpha >> (16 - Ones (format->direct.alphaMask));
r = r << format->direct.red;
g = g << format->direct.green;
b = b << format->direct.blue;
a = a << format->direct.alpha;
*pixel = r|g|b|a;
break;
case PictTypeIndexed:
pIndexed = (miIndexedPtr) (format->index.devPrivate);
if (pIndexed->color)
{
r = color->red >> 11;
g = color->green >> 11;
b = color->blue >> 11;
*pixel = miIndexToEnt15 (pIndexed, (r << 10) | (g << 5) | b);
}
else
{
void StackedRuizEquil
( DistSparseMatrix<Field>& A,
DistSparseMatrix<Field>& B,
DistMultiVec<Base<Field>>& dRowA,
DistMultiVec<Base<Field>>& dRowB,
DistMultiVec<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int mA = A.Height();
const Int mB = B.Height();
const Int n = A.Width();
mpi::Comm comm = A.Comm();
dRowA.SetComm( comm );
dRowB.SetComm( comm );
dCol.SetComm( comm );
Ones( dRowA, mA, 1 );
Ones( dRowB, mB, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose to control structure
// For, simply hard-code a small number of iterations
const Int maxIter = 4;
DistMultiVec<Real> scales(comm), maxAbsValsB(comm);
auto& scalesLoc = scales.Matrix();
auto& maxAbsValsBLoc = maxAbsValsB.Matrix();
const Int localHeight = scalesLoc.Height();
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, scales );
ColumnMaxNorms( B, maxAbsValsB );
for( Int jLoc=0; jLoc<localHeight; ++jLoc )
scalesLoc(jLoc) = Max(scalesLoc(jLoc),maxAbsValsBLoc(jLoc));
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dCol );
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( RIGHT, NORMAL, scales, B );
// Rescale the rows
// ----------------
RowMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowA );
DiagonalSolve( LEFT, NORMAL, scales, A );
RowMaxNorms( B, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowB );
DiagonalSolve( LEFT, NORMAL, scales, B );
}
SetIndent( indent );
}
void RuizEquil
( AbstractDistMatrix<Field>& APre,
AbstractDistMatrix<Base<Field>>& dRowPre,
AbstractDistMatrix<Base<Field>>& dColPre,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
ElementalProxyCtrl control;
control.colConstrain = true;
control.rowConstrain = true;
control.colAlign = 0;
control.rowAlign = 0;
DistMatrixReadWriteProxy<Field,Field,MC,MR> AProx( APre, control );
DistMatrixWriteProxy<Real,Real,MC,STAR> dRowProx( dRowPre, control );
DistMatrixWriteProxy<Real,Real,MR,STAR> dColProx( dColPre, control );
auto& A = AProx.Get();
auto& dRow = dRowProx.Get();
auto& dCol = dColProx.Get();
const Int m = A.Height();
const Int n = A.Width();
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
DistMatrix<Real,MC,STAR> rowScale(A.Grid());
DistMatrix<Real,MR,STAR> colScale(A.Grid());
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, colScale );
EntrywiseMap( colScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, colScale, dCol );
DiagonalSolve( RIGHT, NORMAL, colScale, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, rowScale );
EntrywiseMap( rowScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, rowScale, dRow );
DiagonalSolve( LEFT, NORMAL, rowScale, A );
}
SetIndent( indent );
}
void StackedRuizEquil
( SparseMatrix<Field>& A,
SparseMatrix<Field>& B,
Matrix<Base<Field>>& dRowA,
Matrix<Base<Field>>& dRowB,
Matrix<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int mA = A.Height();
const Int mB = B.Height();
const Int n = A.Width();
Ones( dRowA, mA, 1 );
Ones( dRowB, mB, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
Matrix<Real> scales, maxAbsValsB;
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, scales );
ColumnMaxNorms( B, maxAbsValsB );
for( Int j=0; j<n; ++j )
scales(j) = Max(scales(j),maxAbsValsB(j));
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dCol );
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( RIGHT, NORMAL, scales, B );
// Rescale the rows
// ----------------
RowMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowA );
DiagonalSolve( LEFT, NORMAL, scales, A );
RowMaxNorms( B, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowB );
DiagonalSolve( LEFT, NORMAL, scales, B );
}
SetIndent( indent );
}
void SymmetricRuizEquil
( Matrix<F>& A,
Matrix<Base<F>>& d,
Int maxIter, bool progress )
{
DEBUG_CSE
typedef Base<F> Real;
const Int n = A.Height();
Ones( d, n, 1 );
Matrix<Real> scales;
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns (and rows)
// ------------------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, function<Real(Real)>(DampScaling<Real>) );
EntrywiseMap( scales, function<Real(Real)>(SquareRootScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, d );
// TODO(poulson): Replace with SymmetricDiagonalSolve
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( LEFT, NORMAL, scales, A );
}
SetIndent( indent );
}
void SymmetricRuizEquil
( DistSparseMatrix<Field>& A,
DistMultiVec<Base<Field>>& d,
Int maxIter, bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int n = A.Height();
const Grid& grid = A.Grid();
d.SetGrid( grid );
Ones( d, n, 1 );
DistMultiVec<Real> scales(grid);
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns (and rows)
// ------------------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
EntrywiseMap( scales, MakeFunction(SquareRootScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, d );
SymmetricDiagonalSolve( scales, A );
}
SetIndent( indent );
}
void SymmetricRuizEquil
( DistSparseMatrix<F>& A,
DistMultiVec<Base<F>>& d,
Int maxIter, bool progress )
{
DEBUG_CSE
typedef Base<F> Real;
const Int n = A.Height();
mpi::Comm comm = A.Comm();
d.SetComm( comm );
Ones( d, n, 1 );
DistMultiVec<Real> scales(comm);
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns (and rows)
// ------------------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, function<Real(Real)>(DampScaling<Real>) );
EntrywiseMap( scales, function<Real(Real)>(SquareRootScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, d );
SymmetricDiagonalSolve( scales, A );
}
SetIndent( indent );
}
void DruinskyToledo( ElementalMatrix<F>& A, Int k )
{
EL_DEBUG_CSE
const Int n = 2*k;
Zeros( A, n, n );
if( k == 0 )
return;
if( k == 1 )
{
Ones( A, n, n );
return;
}
typedef Base<F> Real;
const Real phi = Real(1) + 4*limits::Epsilon<Real>();
const Real alphaPhi = LDLPivotConstant<Real>(BUNCH_KAUFMAN_A)*phi;
vector<Real> d( k-2 );
Real sigma(1);
for( Int i=0; i<k-2; ++i )
{
d[i] = -alphaPhi/sigma;
sigma -= 1/d[i];
}
unique_ptr<ElementalMatrix<F>> ASub( A.Construct(A.Grid(),A.Root()) );
View( *ASub, A, IR(k-2,k), IR(0,k) );
Ones( *ASub, 2, k );
View( *ASub, A, IR(0,k), IR(k-2,k) );
Ones( *ASub, k, 2 );
View( *ASub, A, IR(0,k-2), IR(0,k-2) );
Diagonal( *ASub, d );
View( *ASub, A, IR(k,n), IR(0,k) );
Identity( *ASub, k, k );
View( *ASub, A, IR(k,n), IR(k,n) );
Identity( *ASub, k, k );
View( *ASub, A, IR(0,k), IR(k,n) );
Identity( *ASub, k, k );
}
void DruinskyToledo( Matrix<F>& A, Int k )
{
EL_DEBUG_CSE
const Int n = 2*k;
Zeros( A, n, n );
if( k == 0 )
return;
if( k == 1 )
{
Ones( A, n, n );
return;
}
typedef Base<F> Real;
const Real phi = Real(1) + 4*limits::Epsilon<Real>();
const Real alphaPhi = LDLPivotConstant<Real>(BUNCH_KAUFMAN_A)*phi;
vector<Real> d( k-2 );
Real sigma(1);
for( Int i=0; i<k-2; ++i )
{
d[i] = -alphaPhi/sigma;
sigma -= 1/d[i];
}
auto GBL = A(IR(k-2,k),IR(0,k));
Ones( GBL, GBL.Height(), GBL.Width() );
auto GTR = A(IR(0,k),IR(k-2,k));
Ones( GTR, GTR.Height(), GTR.Width() );
auto GTL = A(IR(0,k-2),IR(0,k-2));
Diagonal( GTL, d );
auto ABL = A(IR(k,n),IR(0,k));
Identity( ABL, k, k );
auto ABR = A(IR(k,n),IR(k,n));
Identity( ABR, k, k );
auto ATR = A(IR(0,k),IR(k,n));
Identity( ATR, k, k );
}
void RuizEquil
( DistSparseMatrix<Field>& A,
DistMultiVec<Base<Field>>& dRow,
DistMultiVec<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int m = A.Height();
const Int n = A.Width();
mpi::Comm comm = A.Comm();
dRow.SetComm( comm );
dCol.SetComm( comm );
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose to control structure
// For, simply hard-code a small number of iterations
const Int maxIter = 4;
DistMultiVec<Real> scales(comm);
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dCol );
DiagonalSolve( RIGHT, NORMAL, scales, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRow );
DiagonalSolve( LEFT, NORMAL, scales, A );
}
SetIndent( indent );
}
void RuizEquil
( Matrix<Field>& A,
Matrix<Base<Field>>& dRow,
Matrix<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int m = A.Height();
const Int n = A.Width();
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
Matrix<Real> rowScale, colScale;
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, colScale );
EntrywiseMap( colScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, colScale, dCol );
DiagonalSolve( RIGHT, NORMAL, colScale, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, rowScale );
EntrywiseMap( rowScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, rowScale, dRow );
DiagonalSolve( LEFT, NORMAL, rowScale, A );
}
SetIndent( indent );
}
//---------------------------------------------------------
void MaxwellCurved2D::InitRun()
//---------------------------------------------------------
{
StartUp2D(); // construct grid and metric
#if (0)
umLOG(1, "before refine : K = %5d\n", K);
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
DMat Q2(Np*K, 1); IMat refineflag;
refineflag = Ones(K,Nfaces); Q2 = ConformingHrefine2D(refineflag, Q2);
umLOG(1, "after refine 1: K = %5d\n", K);
//refineflag = Ones(K,Nfaces); Q2 = ConformingHrefine2D(refineflag, Q2);
//umLOG(1, "after refine 1: K = %5d\n", K);
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
#endif
BuildBCMaps2D(); // build boundary condition maps
//OutputNodes(true); // face nodes
AdjustCylBC(1., 0.,0., BC_All); // Push all boundary faces to unit cylinder
//OutputNodes(true); // face nodes
Resize(); // allocate work arrays
SetIC(); // set initial conditions
SetStepSize(); // calculate step size (dt)
BuildCurvedOPS2D(3*N);
//---------------------------------------------
// base class version sets counters and flags
//---------------------------------------------
NDG2D::InitRun();
//---------------------------------------------
// Adjust reporting and render frequencies
//---------------------------------------------
Nreport = Nsteps/20;
//Nreport = 2; // set frequency of reporting (param)
//Nreport = 10; // set frequency of reporting (param)
//Nreport = 50; // set frequency of reporting (param)
Nrender = Nreport; // output frequency (param)
//Nrender = 10; // output frequency (param)
//Nrender = 100000; // output frequency (param)
NvtkInterp = 12; // set output resolution
//NvtkInterp = 6; // set output resolution
Summary(); // Show simulation details
}
//=============================================================================
int Ifpack_CrsIct::Condest(bool Trans, double & ConditionNumberEstimate) const {
if (Condest_>=0.0) {
ConditionNumberEstimate = Condest_;
return(0);
}
// Create a vector with all values equal to one
Epetra_Vector Ones(A_.RowMap());
Epetra_Vector OnesResult(Ones);
Ones.PutScalar(1.0);
EPETRA_CHK_ERR(Solve(Trans, Ones, OnesResult)); // Compute the effect of the solve on the vector of ones
EPETRA_CHK_ERR(OnesResult.Abs(OnesResult)); // Make all values non-negative
EPETRA_CHK_ERR(OnesResult.MaxValue(&ConditionNumberEstimate)); // Get the maximum value across all processors
Condest_ = ConditionNumberEstimate; // Save value for possible later calls
return(0);
}
//---------------------------------------------------------
void MaxwellNonCon2D::AdjustMesh_P()
//---------------------------------------------------------
{
umMSG(1, "Adjusting mesh for non-conforming (P) elements\n");
Nfaces = 3;
tiConnect2D(EToV, EToE,EToF);
// make boundary conditions all "Wall" type
BCType = int(BC_Wall) * EToE.eq(outer(Range(1,K),Ones(Nfaces)));
IVec Norder(K);
if (1) {
// generate a random order for each element
Norder = ceil(10.0*rand(K));
} else if (0) {
Norder = 5;
} else {
Norder(1) = 1;
Norder(2) = 1;
Norder(3) = 2;
Norder(4) = 2;
Norder(5) = 3;
Norder(6) = 3;
Norder(Range(7,K)) = 4;
}
// Build mesh, each element having arbitrary order
BuildPNonCon2D(Norder, K, VX, VY, EToV, BCType, m_PInfo);
xx.resize(max_pinf_id);
yy.resize(max_pinf_id);
for (int N1=1; N1<=Nmax; ++N1) {
const PInfo& pinf = (*m_PInfo[N1]);
if (pinf.K > 0) {
const IVec& pids = dynamic_cast<const IVec&>(pinf.ids);
xx(pids) = pinf.x;
yy(pids) = pinf.y;
}
}
}
void Covariance( const Matrix<F>& D, Matrix<F>& S )
{
DEBUG_CSE
const Int numObs = D.Height();
const Int n = D.Width();
// Compute the average column
Matrix<F> ones, xMean;
Ones( ones, numObs, 1 );
Gemv( TRANSPOSE, F(1)/F(numObs), D, ones, xMean );
// Subtract the mean from each column of D
Matrix<F> DDev( D );
for( Int i=0; i<numObs; ++i )
blas::Axpy
( n, F(-1), xMean.LockedBuffer(), 1, DDev.Buffer(i,0), DDev.LDim() );
// Form S := 1/(numObs-1) DDev DDev'
Herk( LOWER, ADJOINT, Base<F>(1)/Base<F>(numObs-1), DDev, S );
Conjugate( S );
MakeHermitian( LOWER, S );
}
void SymmetricRuizEquil
( ElementalMatrix<F>& APre,
ElementalMatrix<Base<F>>& dPre,
Int maxIter, bool progress )
{
DEBUG_CSE
typedef Base<F> Real;
ElementalProxyCtrl control;
control.colConstrain = true;
control.rowConstrain = true;
control.colAlign = 0;
control.rowAlign = 0;
DistMatrixReadWriteProxy<F,F,MC,MR> AProx( APre, control );
DistMatrixWriteProxy<Real,Real,MC,STAR> dProx( dPre, control );
auto& A = AProx.Get();
auto& d = dProx.Get();
const Int n = A.Height();
Ones( d, n, 1 );
DistMatrix<Real,MR,STAR> scales(A.Grid());
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns (and rows)
// ------------------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, function<Real(Real)>(DampScaling<Real>) );
EntrywiseMap( scales, function<Real(Real)>(SquareRootScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, d );
// TODO: Replace with SymmetricDiagonalSolve
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( LEFT, NORMAL, scales, A );
}
SetIndent( indent );
}
CRealVector CNoiseReduction::OptimalFilter(const CComplexVector& veccSigFreq,
const CRealVector& vecrSqMagSigFreq,
const CRealVector& vecrNoisePSD)
{
CRealVector vecrReturn(iBlockLenLong);
/* Calculate optimal filter coefficients in the frequency domain:
G_opt = max(1 - S_nn(n) / S_xx(n), 0) */
veccOptFilt = Max(Zeros(iFreqBlLen), Ones(iFreqBlLen) -
vecrNoisePSD / vecrSqMagSigFreq);
/* Constrain the optimal filter in time domain to avoid aliasing */
vecrOptFiltTime = rifft(veccOptFilt, FftPlan);
vecrOptFiltTime.Merge(vecrOptFiltTime(1, iBlockLen), Zeros(iBlockLen));
veccOptFilt = rfft(vecrOptFiltTime, FftPlan);
/* Actual filtering in frequency domain */
vecrReturn = rifft(veccSigFreq * veccOptFilt, FftPlan);
/* Cut out correct samples (to get from cyclic convolution to linear
convolution) */
return vecrReturn(iBlockLen + 1, iBlockLenLong);
}
/*
Returns a non-zero vector v such that v is perpendicular to every row of X,
except for the ith row. Use the LU decomposition of X. The vector is NOT
normalized to have length one.
*/
TDenseVector GetNullVector(const TDenseMatrix &X, int i)
{
int n=X.rows;
if ((i < 0) || (i >= n))
throw dw_exception("GetNullVector(): row index out of range");
if (n != X.cols)
throw dw_exception("GetNullVector(): matrix must be square");
TDenseVector v=Ones(n);
if (n > 1)
{
int j, k, m;
TDenseMatrix Y(X);
Y.UniqueMemory();
if (Y.column_major)
for (k=n*(n-1)+i; k >= 0; k-=n) Y.matrix[k]=0.0;
else
for (m=i*n, k=m+n-1; k >= m; k--) Y.matrix[k]=0.0;
TLapackLU LU(Y);
double sum, diag, scale;
for (m=n-2; m >= 0; m--)
{
diag=LU.LU[k=n*m+m];
if (diag == 0.0)
for (j=m+1; j < n; j++) v.vector[j]=0.0;
else
{
for (sum=LU.LU[k+=n]*v.vector[m+1], j=m+2; j < n; j++) sum+=LU.LU[k+=n]*v.vector[j];
if (fabs(diag) >= fabs(sum))
v.vector[m]=-sum/diag;
else
for (scale=-diag/sum, j=n-1; j > m; j--) v.vector[j]*=scale;
}
}
}
return v;
}
void Covariance
( const ElementalMatrix<F>& DPre, ElementalMatrix<F>& SPre )
{
DEBUG_CSE
DistMatrixReadProxy<F,F,MC,MR>
DProx( DPre );
DistMatrixWriteProxy<F,F,MC,MR>
SProx( SPre );
auto& D = DProx.GetLocked();
auto& S = SProx.Get();
const Grid& g = D.Grid();
const Int numObs = D.Height();
// Compute the average column
DistMatrix<F> ones(g), xMean(g);
Ones( ones, numObs, 1 );
Gemv( TRANSPOSE, F(1)/F(numObs), D, ones, xMean );
DistMatrix<F,MR,STAR> xMean_MR(g);
xMean_MR.AlignWith( D );
xMean_MR = xMean;
// Subtract the mean from each column of D
DistMatrix<F> DDev( D );
for( Int iLoc=0; iLoc<DDev.LocalHeight(); ++iLoc )
blas::Axpy
( DDev.LocalWidth(), F(-1),
xMean_MR.LockedBuffer(), 1,
DDev.Buffer(iLoc,0), DDev.LDim() );
// Form S := 1/(numObs-1) DDev DDev'
Herk( LOWER, ADJOINT, Base<F>(1)/Base<F>(numObs-1), DDev, S );
Conjugate( S );
MakeHermitian( LOWER, S );
}
static int
ProcSecurityGenerateAuthorization(
ClientPtr client)
{
REQUEST(xSecurityGenerateAuthorizationReq);
int len; /* request length in CARD32s*/
Bool removeAuth = FALSE; /* if bailout, call RemoveAuthorization? */
SecurityAuthorizationPtr pAuth = NULL; /* auth we are creating */
int err; /* error to return from this function */
XID authId; /* authorization ID assigned by os layer */
xSecurityGenerateAuthorizationReply rep; /* reply struct */
unsigned int trustLevel; /* trust level of new auth */
XID group; /* group of new auth */
CARD32 timeout; /* timeout of new auth */
CARD32 *values; /* list of supplied attributes */
char *protoname; /* auth proto name sent in request */
char *protodata; /* auth proto data sent in request */
unsigned int authdata_len; /* # bytes of generated auth data */
char *pAuthdata; /* generated auth data */
Mask eventMask; /* what events on this auth does client want */
/* check request length */
REQUEST_AT_LEAST_SIZE(xSecurityGenerateAuthorizationReq);
len = bytes_to_int32(SIZEOF(xSecurityGenerateAuthorizationReq));
len += bytes_to_int32(stuff->nbytesAuthProto);
len += bytes_to_int32(stuff->nbytesAuthData);
values = ((CARD32 *)stuff) + len;
len += Ones(stuff->valueMask);
if (client->req_len != len)
return BadLength;
/* check valuemask */
if (stuff->valueMask & ~XSecurityAllAuthorizationAttributes)
{
client->errorValue = stuff->valueMask;
return BadValue;
}
/* check timeout */
timeout = 60;
if (stuff->valueMask & XSecurityTimeout)
{
timeout = *values++;
}
/* check trustLevel */
trustLevel = XSecurityClientUntrusted;
if (stuff->valueMask & XSecurityTrustLevel)
{
trustLevel = *values++;
if (trustLevel != XSecurityClientTrusted &&
trustLevel != XSecurityClientUntrusted)
{
client->errorValue = trustLevel;
return BadValue;
}
}
/* check group */
group = None;
if (stuff->valueMask & XSecurityGroup)
{
group = *values++;
if (SecurityValidateGroupCallback)
{
SecurityValidateGroupInfoRec vgi;
vgi.group = group;
vgi.valid = FALSE;
CallCallbacks(&SecurityValidateGroupCallback, (pointer)&vgi);
/* if nobody said they recognized it, it's an error */
if (!vgi.valid)
{
client->errorValue = group;
return BadValue;
}
}
}
/* check event mask */
eventMask = 0;
if (stuff->valueMask & XSecurityEventMask)
{
eventMask = *values++;
if (eventMask & ~XSecurityAllEventMasks)
{
client->errorValue = eventMask;
return BadValue;
}
}
protoname = (char *)&stuff[1];
protodata = protoname + bytes_to_int32(stuff->nbytesAuthProto);
/* call os layer to generate the authorization */
authId = GenerateAuthorization(stuff->nbytesAuthProto, protoname,
stuff->nbytesAuthData, protodata,
&authdata_len, &pAuthdata);
if ((XID) ~0L == authId)
{
err = SecurityErrorBase + XSecurityBadAuthorizationProtocol;
goto bailout;
}
/* now that we've added the auth, remember to remove it if we have to
* abort the request for some reason (like allocation failure)
*/
removeAuth = TRUE;
/* associate additional information with this auth ID */
pAuth = malloc(sizeof(SecurityAuthorizationRec));
if (!pAuth)
{
err = BadAlloc;
goto bailout;
}
/* fill in the auth fields */
pAuth->id = authId;
pAuth->timeout = timeout;
pAuth->group = group;
pAuth->trustLevel = trustLevel;
pAuth->refcnt = 0; /* the auth was just created; nobody's using it yet */
pAuth->secondsRemaining = 0;
pAuth->timer = NULL;
pAuth->eventClients = NULL;
/* handle event selection */
if (eventMask)
{
err = SecurityEventSelectForAuthorization(pAuth, client, eventMask);
if (err != Success)
goto bailout;
}
if (!AddResource(authId, SecurityAuthorizationResType, pAuth))
{
err = BadAlloc;
goto bailout;
}
/* start the timer ticking */
if (pAuth->timeout != 0)
SecurityStartAuthorizationTimer(pAuth);
/* tell client the auth id and data */
rep.type = X_Reply;
rep.length = bytes_to_int32(authdata_len);
rep.sequenceNumber = client->sequence;
rep.authId = authId;
rep.dataLength = authdata_len;
if (client->swapped)
{
char n;
swapl(&rep.length, n);
swaps(&rep.sequenceNumber, n);
swapl(&rep.authId, n);
swaps(&rep.dataLength, n);
}
WriteToClient(client, SIZEOF(xSecurityGenerateAuthorizationReply),
(char *)&rep);
WriteToClient(client, authdata_len, pAuthdata);
SecurityAudit("client %d generated authorization %d trust %d timeout %d group %d events %d\n",
client->index, pAuth->id, pAuth->trustLevel, pAuth->timeout,
pAuth->group, eventMask);
/* the request succeeded; don't call RemoveAuthorization or free pAuth */
return Success;
bailout:
if (removeAuth)
RemoveAuthorization(stuff->nbytesAuthProto, protoname,
authdata_len, pAuthdata);
free(pAuth);
return err;
} /* ProcSecurityGenerateAuthorization */
void NDG2D::PoissonIPDGbc2D(
CSd& spOP //[out] sparse operator
)
{
// function [OP] = PoissonIPDGbc2D()
// Purpose: Set up the discrete Poisson matrix directly
// using LDG. The operator is set up in the weak form
// build DG derivative matrices
int max_OP = (K*Np*Np*(1+Nfaces));
//initialize parameters
DVec faceR("faceR"), faceS("faceS");
IVec Fm("Fm"), Fm1("Fm1"), fidM("fidM");
DMat V1D("V1D"); int i=0;
// build local face matrices
DMat massEdge[4]; // = zeros(Np,Np,Nfaces);
for (i=1; i<=Nfaces; ++i) {
massEdge[i].resize(Np,Np);
}
// face mass matrix 1
Fm = Fmask(All,1); faceR = r(Fm);
V1D = Vandermonde1D(N, faceR);
massEdge[1](Fm,Fm) = inv(V1D*trans(V1D));
// face mass matrix 2
Fm = Fmask(All,2); faceR = r(Fm);
V1D = Vandermonde1D(N, faceR);
massEdge[2](Fm,Fm) = inv(V1D*trans(V1D));
// face mass matrix 3
Fm = Fmask(All,3); faceS = s(Fm);
V1D = Vandermonde1D(N, faceS);
massEdge[3](Fm,Fm) = inv(V1D*trans(V1D));
//continue initialize parameters
DMat Dx("Dx"),Dy("Dy"), Dn1("Dn1"), mmE_Fm1("mmE(:,Fm1)");
double lnx=0.0,lny=0.0,lsJ=0.0,hinv=0.0,gtau=0.0;
int k1=0,f1=0,id=0;
IVec i1_Nfp = Range(1,Nfp);
double N1N1 = double((N+1)*(N+1));
// "OP" triplets (i,j,x), extracted to {Ai,Aj,Ax}
IVec OPi(max_OP),OPj(max_OP), Ai,Aj; DVec OPx(max_OP), Ax;
IMat rows1, cols1; Index1D entries; DMat OP11(Np,Nfp, 0.0);
// global node numbering
entries.reset(1,Np*Nfp);
cols1 = outer(Ones(Np), Range(1,Nfp));
umMSG(1, "\n ==> {OP} assembly [bc]: ");
for (k1=1; k1<=K; ++k1)
{
if (! (k1%100)) { umMSG(1, "%d, ",k1); }
rows1 = outer(Range((k1-1)*Np+1,k1*Np), Ones(Nfp));
// Build element-to-element parts of operator
for (f1=1; f1<=Nfaces; ++f1)
{
if (BCType(k1,f1))
{
////////////////////////added by Kevin ///////////////////////////////
Fm1 = Fmask(All,f1);
fidM = (k1-1)*Nfp*Nfaces + (f1-1)*Nfp + i1_Nfp;
id = 1+(f1-1)*Nfp + (k1-1)*Nfp*Nfaces;
lnx = nx(id); lny = ny(id);
lsJ = sJ(id); hinv = Fscale(id);
Dx = rx(1,k1)*Dr + sx(1,k1)*Ds;
Dy = ry(1,k1)*Dr + sy(1,k1)*Ds;
Dn1 = lnx*Dx + lny*Dy;
//mmE = lsJ*massEdge(:,:,f1);
//bc(All,k1) += (gtau*mmE(All,Fm1) - Dn1'*mmE(All,Fm1))*ubc(fidM);
mmE_Fm1 = massEdge[f1](All,Fm1); mmE_Fm1 *= lsJ;
gtau = 10*N1N1*hinv; // set penalty scaling
//bc(All,k1) += (gtau*mmE_Fm1 - trans(Dn1)*mmE_Fm1) * ubc(fidM);
switch(BCType(k1,f1)){
case BC_Dirichlet:
OP11 = gtau*mmE_Fm1 - trans(Dn1)*mmE_Fm1;
break;
case BC_Neuman:
OP11 = mmE_Fm1;
break;
default:
std::cout<<"warning: boundary condition is incorrect"<<std::endl;
}
OPi(entries)=rows1; OPj(entries)=cols1; OPx(entries)=OP11;
entries += (Np*Nfp);
}
cols1 += Nfp;
}
}
umMSG(1, "\n ==> {OPbc} to sparse\n");
entries.reset(1, entries.hi()-(Np*Nfp));
// extract triplets from large buffers
Ai=OPi(entries); Aj=OPj(entries); Ax=OPx(entries);
// These arrays can be HUGE, so force deallocation
OPi.Free(); OPj.Free(); OPx.Free();
// return 0-based sparse result
Ai -= 1; Aj -= 1;
//-------------------------------------------------------
// This operator is not symmetric, and will NOT be
// factorised, only used to create reference RHS's:
//
// refrhsbcPR = spOP1 * bcPR;
// refrhsbcUx = spOP2 * bcUx;
// refrhsbcUy = spOP2 * bcUy;
//
// Load ALL elements (both upper and lower triangles):
//-------------------------------------------------------
spOP.load(Np*K, Nfp*Nfaces*K, Ai,Aj,Ax, sp_All,false, 1e-15,true);
Ai.Free(); Aj.Free(); Ax.Free();
umMSG(1, " ==> {OPbc} ready.\n");
#if (1)
// check on original estimates for nnx
umMSG(1, " ==> max_OP: %12d\n", max_OP);
umMSG(1, " ==> nnz_OP: %12d\n", entries.hi());
#endif
}
static int
ProcPanoramiXShmGetImage(ClientPtr client)
{
PanoramiXRes *draw;
DrawablePtr *drawables;
DrawablePtr pDraw;
xShmGetImageReply xgi;
ShmDescPtr shmdesc;
int i, x, y, w, h, format, rc;
Mask plane = 0, planemask;
long lenPer = 0, length, widthBytesLine;
Bool isRoot;
REQUEST(xShmGetImageReq);
REQUEST_SIZE_MATCH(xShmGetImageReq);
if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap)) {
client->errorValue = stuff->format;
return BadValue;
}
rc = dixLookupResourceByClass((pointer *)&draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (rc != Success)
return (rc == BadValue) ? BadDrawable : rc;
if (draw->type == XRT_PIXMAP)
return ProcShmGetImage(client);
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
DixReadAccess);
if (rc != Success)
return rc;
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
x = stuff->x;
y = stuff->y;
w = stuff->width;
h = stuff->height;
format = stuff->format;
planemask = stuff->planeMask;
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
if(isRoot) {
if( /* check for being onscreen */
x < 0 || x + w > PanoramiXPixWidth ||
y < 0 || y + h > PanoramiXPixHeight )
return BadMatch;
} else {
if( /* check for being onscreen */
screenInfo.screens[0]->x + pDraw->x + x < 0 ||
screenInfo.screens[0]->x + pDraw->x + x + w > PanoramiXPixWidth ||
screenInfo.screens[0]->y + pDraw->y + y < 0 ||
screenInfo.screens[0]->y + pDraw->y + y + h > PanoramiXPixHeight ||
/* check for being inside of border */
x < - wBorderWidth((WindowPtr)pDraw) ||
x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
y < -wBorderWidth((WindowPtr)pDraw) ||
y + h > wBorderWidth ((WindowPtr)pDraw) + (int)pDraw->height)
return BadMatch;
}
drawables = calloc(PanoramiXNumScreens, sizeof(DrawablePtr));
if(!drawables)
return BadAlloc;
drawables[0] = pDraw;
for(i = 1; i < PanoramiXNumScreens; i++) {
rc = dixLookupDrawable(drawables+i, draw->info[i].id, client, 0,
DixReadAccess);
if (rc != Success)
{
free(drawables);
return rc;
}
}
xgi.visual = wVisual(((WindowPtr)pDraw));
xgi.type = X_Reply;
xgi.length = 0;
xgi.sequenceNumber = client->sequence;
xgi.depth = pDraw->depth;
if(format == ZPixmap) {
widthBytesLine = PixmapBytePad(w, pDraw->depth);
length = widthBytesLine * h;
} else {
widthBytesLine = PixmapBytePad(w, 1);
lenPer = widthBytesLine * h;
plane = ((Mask)1) << (pDraw->depth - 1);
length = lenPer * Ones(planemask & (plane | (plane - 1)));
}
VERIFY_SHMSIZE(shmdesc, stuff->offset, length, client);
xgi.size = length;
if (length == 0) {/* nothing to do */ }
else if (format == ZPixmap) {
XineramaGetImageData(drawables, x, y, w, h, format, planemask,
shmdesc->addr + stuff->offset,
widthBytesLine, isRoot);
} else {
length = stuff->offset;
for (; plane; plane >>= 1) {
if (planemask & plane) {
XineramaGetImageData(drawables, x, y, w, h,
format, plane, shmdesc->addr + length,
widthBytesLine, isRoot);
length += lenPer;
}
}
}
free(drawables);
if (client->swapped) {
int n;
swaps(&xgi.sequenceNumber, n);
swapl(&xgi.length, n);
swapl(&xgi.visual, n);
swapl(&xgi.size, n);
}
WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
return Success;
}
static int
ProcShmGetImage(ClientPtr client)
{
DrawablePtr pDraw;
long lenPer = 0, length;
Mask plane = 0;
xShmGetImageReply xgi;
ShmDescPtr shmdesc;
int n, rc;
REQUEST(xShmGetImageReq);
REQUEST_SIZE_MATCH(xShmGetImageReq);
if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap))
{
client->errorValue = stuff->format;
return BadValue;
}
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
DixReadAccess);
if (rc != Success)
return rc;
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
if (pDraw->type == DRAWABLE_WINDOW)
{
if( /* check for being viewable */
!((WindowPtr) pDraw)->realized ||
/* check for being on screen */
pDraw->x + stuff->x < 0 ||
pDraw->x + stuff->x + (int)stuff->width > pDraw->pScreen->width ||
pDraw->y + stuff->y < 0 ||
pDraw->y + stuff->y + (int)stuff->height > pDraw->pScreen->height ||
/* check for being inside of border */
stuff->x < - wBorderWidth((WindowPtr)pDraw) ||
stuff->x + (int)stuff->width >
wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
stuff->y < -wBorderWidth((WindowPtr)pDraw) ||
stuff->y + (int)stuff->height >
wBorderWidth((WindowPtr)pDraw) + (int)pDraw->height
)
return BadMatch;
xgi.visual = wVisual(((WindowPtr)pDraw));
}
else
{
if (stuff->x < 0 ||
stuff->x+(int)stuff->width > pDraw->width ||
stuff->y < 0 ||
stuff->y+(int)stuff->height > pDraw->height
)
return BadMatch;
xgi.visual = None;
}
xgi.type = X_Reply;
xgi.length = 0;
xgi.sequenceNumber = client->sequence;
xgi.depth = pDraw->depth;
if(stuff->format == ZPixmap)
{
length = PixmapBytePad(stuff->width, pDraw->depth) * stuff->height;
}
else
{
lenPer = PixmapBytePad(stuff->width, 1) * stuff->height;
plane = ((Mask)1) << (pDraw->depth - 1);
/* only planes asked for */
length = lenPer * Ones(stuff->planeMask & (plane | (plane - 1)));
}
VERIFY_SHMSIZE(shmdesc, stuff->offset, length, client);
xgi.size = length;
if (length == 0)
{
/* nothing to do */
}
else if (stuff->format == ZPixmap)
{
(*pDraw->pScreen->GetImage)(pDraw, stuff->x, stuff->y,
stuff->width, stuff->height,
stuff->format, stuff->planeMask,
shmdesc->addr + stuff->offset);
}
else
{
length = stuff->offset;
for (; plane; plane >>= 1)
{
if (stuff->planeMask & plane)
{
(*pDraw->pScreen->GetImage)(pDraw,
stuff->x, stuff->y,
stuff->width, stuff->height,
stuff->format, plane,
shmdesc->addr + length);
length += lenPer;
}
}
}
if (client->swapped) {
swaps(&xgi.sequenceNumber, n);
swapl(&xgi.length, n);
swapl(&xgi.visual, n);
swapl(&xgi.size, n);
}
WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
return Success;
}
int main(int argc, char *argv[])
{
// below some demonstration of the usage of the Matrix class
try
{
// create an empty matrix of 3x3 (will initially contain zeros)
int cols = 3;
int rows = 3;
Matrix A = Matrix(cols, rows);
// fill in some values in matrix a
int count = 0;
for (int r = 1; r <= rows; r++)
{
for (int c = 1; c <= cols; c++)
{
count ++;
A(r, c) = count;
}
}
// adjust a value in the matrix (indexes are one-based)
A(2,1) = 1.23;
// read a value from the matrix (indexes are one-based)
double centervalue = A(2,2);
printf("centervalue = %f \n", centervalue);
printf("\n");
// print the whole matrix
printf("A = \n");
A.Print();
printf("\n");
Matrix B = Ones(rows, cols) + Diag(rows);
printf("B = \n");
B.Print();
printf("\n");
Matrix B2 = Matrix(rows, 1); // a vector
count = 1;
for (int r = 1; r <= rows; r++)
{
count ++;
B2(r, 1) = count * 2;
}
printf("B2 = \n");
B2.Print();
printf("\n");
Matrix C;
C = A + B;
printf("A + B = \n");
C.Print();
printf("\n");
C = A - B;
printf("A - B = \n");
C.Print();
printf("\n");
C = A * B2;
printf("A * B2 = \n");
C.Print();
printf("\n");
// create a diagonal matrix
Matrix E = Diag(B2);
printf("E = \n");
E.Print();
printf("\n");
// calculate determinant
Matrix D = Matrix(2, 2);
D(1,1) = 2;
D(1,2) = 4;
D(2,1) = 1;
D(2,2) = -2;
printf("D = \n");
D.Print();
printf("Det(D) = %f\n\n", Det(D));
printf("A = \n");
A.Print();
printf("\n");
printf("Det(A) = %f\n\n", Det(A));
Matrix F;
F = 3 - A ;
printf("3 - A = \n");
F.Print();
printf("\n");
// test inverse
Matrix G = Matrix(2, 2);
G(1, 1) = 1;
G(1, 2) = 2;
G(2, 1) = 3;
G(2, 2) = 4;
printf("G = \n");
G.Print();
printf("\n");
Matrix G_inv = Inv(G);
printf("Inv(G) = \n");
G_inv.Print();
printf("\n");
Matrix A_inv = Inv(A);
printf("Inv(A) = \n");
A_inv.Print();
printf("\n");
Matrix A_A_inv = A * Inv(A);
printf("A * Inv(A) = \n");
A_A_inv.Print();
printf("\n");
Matrix B_A = B / A;
printf("B / A = \n");
B_A.Print();
printf("\n");
Matrix A_3 = A / 3;
printf("A / 3 = \n");
A_3.Print();
printf("\n");
rows = 2;
cols = 5;
Matrix H = Matrix(rows, cols);
for (int r = 1; r <= rows; r++)
{
for (int c = 1; c <= cols; c++)
{
count ++;
H(r, c) = count;
}
}
printf("H = \n");
H.Print();
printf("\n");
}
catch (Exception err)
{
printf("Error: %s\n", err.msg);
}
catch (...)
{
printf("An error occured...\n");
}
printf("\n");
PAUSE;
return EXIT_SUCCESS;
}
//---------------------------------------------------------
void CurvedINS2D::InitRun()
//---------------------------------------------------------
{
// construct grid and metric
StartUp2D();
// Optional mesh refinement: split each parent
// element into 4 conforming "child" elements
if (Nrefine>0) {
umLOG(1, "before refine : K = %5d\n", K);
DMat Q2(Np*K, 1); IMat refineflag;
refineflag = Ones(K,Nfaces);
for (int i=1; i<=Nrefine; ++i) {
Q2 = ConformingHrefine2D(refineflag, Q2);
umLOG(1, "after refine %d: K = %5d\n", i, K);
}
}
// Adjust faces on circular boundaries,
// and perform any sim-specific setup:
switch (sim_type) {
case eVolkerCylinder:
// move Cylinder bdry faces to radius 0.05
AdjustCylBC(0.05, 0.,0., BC_Cyl);
break;
default:
// set default maps for {straight,curved} elements
straight.range(1,K); curved.resize(0);
break;
}
Resize(); // allocate arrays
BuildBCMaps2D(); // build boundary condition maps
SetIC(); // set initial conditions
SetStepSize(); // calculate step size (dt)
// reset various work timers
time_setup = time_advection = 0.0;
time_viscous = time_viscous_sol = 0.0;
time_pressure = time_pressure_sol = 0.0;
//---------------------------------------------
// base class version sets counters and flags
//---------------------------------------------
NDG2D::InitRun();
//---------------------------------------------
// set frequency of reporting
//---------------------------------------------
//Nreport = Nsteps/150;
//Nreport = 10;
//Nreport = 2;
Nreport = 10;
//Nreport = 250;
//Nreport = 1000;
//Nreport = 10000;
//---------------------------------------------
// set frequency of rendering
//---------------------------------------------
Nrender = Nreport;
//Nrender = 250;
//Nrender = 1000;
//NvtkInterp = 12; // set output resolution
//NvtkInterp = 5; // set output resolution
NvtkInterp = this->N; // use original nodes
Summary(); // show simulation details
}
void Initialize
( const AffineLPProblem<Matrix<Real>,Matrix<Real>>& problem,
AffineLPSolution<Matrix<Real>>& solution,
bool primalInit,
bool dualInit,
bool standardShift )
{
EL_DEBUG_CSE
const Int m = problem.A.Height();
const Int n = problem.A.Width();
const Int k = problem.G.Height();
if( primalInit )
{
if( solution.x.Height() != n || solution.x.Width() != 1 )
LogicError("x was of the wrong size");
if( solution.s.Height() != k || solution.s.Width() != 1 )
LogicError("s was of the wrong size");
}
if( dualInit )
{
if( solution.y.Height() != m || solution.y.Width() != 1 )
LogicError("y was of the wrong size");
if( solution.z.Height() != k || solution.z.Width() != 1 )
LogicError("z was of the wrong size");
}
if( primalInit && dualInit )
{
// TODO(poulson): Perform a consistency check
return;
}
// Form the KKT matrix
// ===================
Matrix<Real> J, ones;
Ones( ones, k, 1 );
KKT( problem.A, problem.G, ones, ones, J );
// Factor the KKT matrix
// =====================
Matrix<Real> dSub;
Permutation p;
LDL( J, dSub, p, false );
AffineLPResidual<Matrix<Real>> residual;
Matrix<Real> u, d;
Zeros( residual.dualConic, k, 1 );
if( !primalInit )
{
// Minimize || G x - h ||^2, s.t. A x = b by solving
//
// | 0 A^T G^T | | x | | 0 |
// | A 0 0 | | u | = | b |,
// | G 0 -I | | -s | | h |
//
// where 'u' is an unused dummy variable.
Zeros( residual.dualEquality, n, 1 );
residual.primalEquality = problem.b;
residual.primalEquality *= -1;
residual.primalConic = problem.h;
residual.primalConic *= -1;
KKTRHS
( residual.dualEquality,
residual.primalEquality,
residual.primalConic,
residual.dualConic,
ones, d );
ldl::SolveAfter( J, dSub, p, d, false );
ExpandCoreSolution( m, n, k, d, solution.x, u, solution.s );
solution.s *= -1;
}
if( !dualInit )
{
// Minimize || z ||^2, s.t. A^T y + G^T z + c = 0 by solving
//
// | 0 A^T G^T | | u | | -c |
// | A 0 0 | | y | = | 0 |,
// | G 0 -I | | z | | 0 |
//
// where 'u' is an unused dummy variable.
residual.dualEquality = problem.c;
Zeros( residual.primalEquality, m, 1 );
Zeros( residual.primalConic, k, 1 );
KKTRHS
( residual.dualEquality,
residual.primalEquality,
residual.primalConic,
residual.dualConic,
ones, d );
ldl::SolveAfter( J, dSub, p, d, false );
ExpandCoreSolution( m, n, k, d, u, solution.y, solution.z );
}
const Real epsilon = limits::Epsilon<Real>();
const Real sNorm = Nrm2( solution.s );
const Real zNorm = Nrm2( solution.z );
const Real gammaPrimal = Sqrt(epsilon)*Max(sNorm,Real(1));
const Real gammaDual = Sqrt(epsilon)*Max(zNorm,Real(1));
if( standardShift )
{
// alpha_p := min { alpha : s + alpha*e >= 0 }
// -------------------------------------------
const auto sMinPair = VectorMinLoc( solution.s );
const Real alphaPrimal = -sMinPair.value;
if( alphaPrimal >= Real(0) && primalInit )
RuntimeError("initialized s was non-positive");
// alpha_d := min { alpha : z + alpha*e >= 0 }
// -------------------------------------------
const auto zMinPair = VectorMinLoc( solution.z );
const Real alphaDual = -zMinPair.value;
if( alphaDual >= Real(0) && dualInit )
RuntimeError("initialized z was non-positive");
if( alphaPrimal >= -gammaPrimal )
Shift( solution.s, alphaPrimal+1 );
if( alphaDual >= -gammaDual )
Shift( solution.z, alphaDual+1 );
}
else
{
LowerClip( solution.s, gammaPrimal );
LowerClip( solution.z, gammaDual );
}
}
//---------------------------------------------------------
void NDG3D::PoissonIPDG3D(CSd& spOP, CSd& spMM)
//---------------------------------------------------------
{
// function [OP,MM] = PoissonIPDG3D()
//
// Purpose: Set up the discrete Poisson matrix directly
// using LDG. The operator is set up in the weak form
DVec faceR("faceR"), faceS("faceS"), faceT("faceT");
DMat V2D; IVec Fm("Fm"); IVec i1_Nfp = Range(1,Nfp);
double opti1=0.0, opti2=0.0; int i=0;
umLOG(1, "\n ==> {OP,MM} assembly: ");
opti1 = timer.read(); // time assembly
// build local face matrices
DMat massEdge[5]; // = zeros(Np,Np,Nfaces);
for (i=1; i<=Nfaces; ++i) {
massEdge[i].resize(Np,Np);
}
// face mass matrix 1
Fm = Fmask(All,1); faceR=r(Fm); faceS=s(Fm);
V2D = Vandermonde2D(N, faceR, faceS);
massEdge[1](Fm,Fm) = inv(V2D*trans(V2D));
// face mass matrix 2
Fm = Fmask(All,2); faceR = r(Fm); faceT = t(Fm);
V2D = Vandermonde2D(N, faceR, faceT);
massEdge[2](Fm,Fm) = inv(V2D*trans(V2D));
// face mass matrix 3
Fm = Fmask(All,3); faceS = s(Fm); faceT = t(Fm);
V2D = Vandermonde2D(N, faceS, faceT);
massEdge[3](Fm,Fm) = inv(V2D*trans(V2D));
// face mass matrix 4
Fm = Fmask(All,4); faceS = s(Fm); faceT = t(Fm);
V2D = Vandermonde2D(N, faceS, faceT);
massEdge[4](Fm,Fm) = inv(V2D*trans(V2D));
// build local volume mass matrix
MassMatrix = trans(invV)*invV;
DMat Dx("Dx"),Dy("Dy"),Dz("Dz"), Dx2("Dx2"),Dy2("Dy2"),Dz2("Dz2");
DMat Dn1("Dn1"),Dn2("Dn2"), mmE("mmE"), OP11("OP11"), OP12("OP12");
DMat mmE_All_Fm1, mmE_Fm1_Fm1, Dn2_Fm2_All;
IMat rows1,cols1,rows2,cols2; int k1=0,f1=0,k2=0,f2=0,id=0;
Index1D entries, entriesMM, idsM; IVec fidM,vidM,Fm1,vidP,Fm2;
double lnx=0.0,lny=0.0,lnz=0.0,lsJ=0.0,hinv=0.0,gtau=0.0;
double N1N1 = double((N+1)*(N+1)); int NpNp = Np*Np;
// build DG derivative matrices
int max_OP = (K*Np*Np*(1+Nfaces));
int max_MM = (K*Np*Np);
// "OP" triplets (i,j,x), extracted to {Ai,Aj,Ax}
IVec OPi(max_OP), OPj(max_OP), Ai,Aj; DVec OPx(max_OP), Ax;
// "MM" triplets (i,j,x)
IVec MMi(max_MM), MMj(max_MM); DVec MMx(max_MM);
IVec OnesNp = Ones(Np);
// global node numbering
entries.reset(1,NpNp); entriesMM.reset(1,NpNp);
OP12.resize(Np,Np);
for (k1=1; k1<=K; ++k1)
{
if (! (k1%250)) { umLOG(1, "%d, ",k1); }
rows1 = outer( Range((k1-1)*Np+1,k1*Np), OnesNp );
cols1 = trans(rows1);
// Build local operators
Dx = rx(1,k1)*Dr + sx(1,k1)*Ds + tx(1,k1)*Dt;
Dy = ry(1,k1)*Dr + sy(1,k1)*Ds + ty(1,k1)*Dt;
Dz = rz(1,k1)*Dr + sz(1,k1)*Ds + tz(1,k1)*Dt;
OP11 = J(1,k1)*(trans(Dx)*MassMatrix*Dx +
trans(Dy)*MassMatrix*Dy +
trans(Dz)*MassMatrix*Dz);
// Build element-to-element parts of operator
for (f1=1; f1<=Nfaces; ++f1) {
k2 = EToE(k1,f1); f2 = EToF(k1,f1);
rows2 = outer( Range((k2-1)*Np+1, k2*Np), OnesNp );
cols2 = trans(rows2);
fidM = (k1-1)*Nfp*Nfaces + (f1-1)*Nfp + i1_Nfp;
vidM = vmapM(fidM); Fm1 = mod(vidM-1,Np)+1;
vidP = vmapP(fidM); Fm2 = mod(vidP-1,Np)+1;
id = 1+(f1-1)*Nfp + (k1-1)*Nfp*Nfaces;
lnx = nx(id); lny = ny(id); lnz = nz(id); lsJ = sJ(id);
hinv = std::max(Fscale(id), Fscale(1+(f2-1)*Nfp, k2));
Dx2 = rx(1,k2)*Dr + sx(1,k2)*Ds + tx(1,k2)*Dt;
Dy2 = ry(1,k2)*Dr + sy(1,k2)*Ds + ty(1,k2)*Dt;
Dz2 = rz(1,k2)*Dr + sz(1,k2)*Ds + tz(1,k2)*Dt;
Dn1 = lnx*Dx + lny*Dy + lnz*Dz;
Dn2 = lnx*Dx2 + lny*Dy2 + lnz*Dz2;
mmE = lsJ*massEdge[f1];
gtau = 2.0 * N1N1 * hinv; // set penalty scaling
if (EToE(k1,f1)==k1) {
OP11 += ( gtau*mmE - mmE*Dn1 - trans(Dn1)*mmE ); // ok
}
else
{
// interior face variational terms
OP11 += 0.5*( gtau*mmE - mmE*Dn1 - trans(Dn1)*mmE );
// extract mapped regions:
mmE_All_Fm1 = mmE(All,Fm1);
mmE_Fm1_Fm1 = mmE(Fm1,Fm1);
Dn2_Fm2_All = Dn2(Fm2,All);
OP12 = 0.0; // reset to zero
OP12(All,Fm2) = -0.5*( gtau*mmE_All_Fm1 );
OP12(Fm1,All) -= 0.5*( mmE_Fm1_Fm1*Dn2_Fm2_All );
//OP12(All,Fm2) -= 0.5*(-trans(Dn1)*mmE_All_Fm1 );
OP12(All,Fm2) += 0.5*( trans(Dn1)*mmE_All_Fm1 );
// load this set of triplets
#if (1)
OPi(entries)=rows1; OPj(entries)=cols2, OPx(entries)=OP12;
entries += (NpNp);
#else
//###########################################################
// load only the lower triangle (after droptol test?)
sk=0; start=entries(1);
for (int i=1; i<=NpNp; ++i) {
eid = start+i;
id=entries(eid); rid=rows1(i); cid=cols2(i);
if (rows1(rid) >= cid) { // take lower triangle
if ( fabs(OP12(id)) > 1e-15) { // drop small entries
++sk; OPi(id)=rid; OPj(id)=cid, OPx(id)=OP12(id);
}
}
}
entries += sk;
//###########################################################
#endif
}
}
OPi(entries )=rows1; OPj(entries )=cols1, OPx(entries )=OP11;
MMi(entriesMM)=rows1; MMj(entriesMM)=cols1; MMx(entriesMM)=J(1,k1)*MassMatrix;
entries += (NpNp); entriesMM += (NpNp);
}
umLOG(1, "\n ==> {OP,MM} to sparse\n");
entries.reset(1, entries.hi()-Np*Np);
// Extract triplets from the large buffers. Note: this
// requires copying each array, and since these arrays
// can be HUGE(!), we force immediate deallocation:
Ai=OPi(entries); OPi.Free();
Aj=OPj(entries); OPj.Free();
Ax=OPx(entries); OPx.Free();
umLOG(1, " ==> triplets ready (OP) nnz = %10d\n", entries.hi());
// adjust triplet indices for 0-based sparse operators
Ai -= 1; Aj -= 1; MMi -= 1; MMj -= 1; int npk=Np*K;
#if defined(NDG_USE_CHOLMOD) || defined(NDG_New_CHOLINC)
// load only the lower triangle tril(OP) free args?
spOP.load(npk,npk, Ai,Aj,Ax, sp_LT, false,1e-15, true); // {LT, false} -> TriL
#else
// select {upper,lower,both} triangles
//spOP.load(npk,npk, Ai,Aj,Ax, sp_LT, true,1e-15,true); // LT -> enforce symmetry
//spOP.load(npk,npk, Ai,Aj,Ax, sp_All,true,1e-15,true); // All-> includes "noise"
//spOP.load(npk,npk, Ai,Aj,Ax, sp_UT, false,1e-15,true); // UT -> triu(OP) only
#endif
Ai.Free(); Aj.Free(); Ax.Free();
umLOG(1, " ==> triplets ready (MM) nnz = %10d\n", entriesMM.hi());
//-------------------------------------------------------
// The mass matrix operator will NOT be factorised,
// Load ALL elements (both upper and lower triangles):
//-------------------------------------------------------
spMM.load(npk,npk, MMi,MMj,MMx, sp_All,false,1.00e-15,true);
MMi.Free(); MMj.Free(); MMx.Free();
opti2 = timer.read(); // time assembly
umLOG(1, " ==> {OP,MM} converted to csc. (%g secs)\n", opti2-opti1);
}
//---------------------------------------------------------
void EulerShock2D::InitRun()
//---------------------------------------------------------
{
// base class performs usual startup sequence
// CurvedEuler2D::InitRun();
//-------------------------------------
// construct grid and metric
//-------------------------------------
StartUp2D();
//-------------------------------------
// refine default mesh
//-------------------------------------
if (Nrefine>=1) {
umLOG(1, "before refinement K = %6d\n", K);
for (int i=1; i<=Nrefine; ++i) {
DMat Qtmp(Np*K, 1); IMat refineflag;
refineflag = Ones(K,Nfaces); Qtmp = ConformingHrefine2D(refineflag, Qtmp);
umLOG(1, "after h-refine %d: K = %6d\n", i,K);
}
}
// store original BC types before adjusting,
// (e.g. BC_Cyl faces may be set to BC_Wall)
saveBCType = BCType;
//-------------------------------------
// Adjust faces on circular boundaries
//-------------------------------------
switch (sim_type) {
case eForwardStep:
// no cylinder faces
straight.range(1,K); curved.resize(0);
break;
case eScramInlet:
// no cylinder faces
straight.range(1,K); curved.resize(0);
break;
default:
// set default maps for {straight,curved} elements
straight.range(1,K); curved.resize(0);
break;
}
BuildBCMaps2D(); // map faces subject to boundary conditions
Resize(); // allocate arrays
SetIC(); // set initial conditions
#if (1)
OutputNodes(false); // volume nodes
#endif
#if (0)
tstep = -1;
Report(true);
#endif
SetStepSize(); // compute initial timestep (using IC's)
// storage for residual at each time-step,
// allowing for variable step size
resid.resize(2*Nsteps);
// base class version sets counters and flags
NDG2D::InitRun();
// pre-calculate constant data for limiter routine
precalc_limiter_data();
//---------------------------------------------
// Adjust reporting and render frequencies
//---------------------------------------------
switch (sim_type) {
case eForwardStep:
Nreport = 100; // frequency of reporting
Nrender = 300; // frequency of rendering
NvtkInterp = 3; // resolution of vtk output
break;
case eScramInlet:
NvtkInterp = 2;
switch (mesh_level) {
case 1: Nreport = 100; Nrender = 100; break;
case 2: Nreport = 250; Nrender = 250; break;
case 3: Nreport = 500; Nrender = 500; break;
case 4: Nreport = 1000; Nrender = 1000; break;
default: Nreport = 1000; Nrender = 1000; break;
}
break;
}
// Show simulation details
Summary();
}
double Ifpack_Condest(const Ifpack_Preconditioner& IFP,
const Ifpack_CondestType CT,
const int MaxIters,
const double Tol,
Epetra_RowMatrix* Matrix)
{
double ConditionNumberEstimate = -1.0;
if (CT == Ifpack_Cheap) {
// Create a vector with all values equal to one
Epetra_Vector Ones(IFP.OperatorDomainMap());
Ones.PutScalar(1.0);
// Create the vector of results
Epetra_Vector OnesResult(IFP.OperatorRangeMap());
// Compute the effect of the solve on the vector of ones
IFPACK_CHK_ERR(IFP.ApplyInverse(Ones, OnesResult));
// Make all values non-negative
IFPACK_CHK_ERR(OnesResult.Abs(OnesResult));
// Get the maximum value across all processors
IFPACK_CHK_ERR(OnesResult.MaxValue(&ConditionNumberEstimate));
}
else if (CT == Ifpack_CG) {
#ifdef HAVE_IFPACK_AZTECOO
if (Matrix == 0)
Matrix = (Epetra_RowMatrix*)&(IFP.Matrix());
Epetra_Vector LHS(IFP.OperatorDomainMap());
LHS.PutScalar(0.0);
Epetra_Vector RHS(IFP.OperatorRangeMap());
RHS.Random();
Epetra_LinearProblem Problem;
Problem.SetOperator(Matrix);
Problem.SetLHS(&LHS);
Problem.SetRHS(&RHS);
AztecOO Solver(Problem);
Solver.SetAztecOption(AZ_output,AZ_none);
Solver.SetAztecOption(AZ_solver,AZ_cg_condnum);
Solver.Iterate(MaxIters,Tol);
const double* status = Solver.GetAztecStatus();
ConditionNumberEstimate = status[AZ_condnum];
#endif
} else if (CT == Ifpack_GMRES) {
#ifdef HAVE_IFPACK_AZTECOO
if (Matrix == 0)
Matrix = (Epetra_RowMatrix*)&(IFP.Matrix());
Epetra_Vector LHS(IFP.OperatorDomainMap());
LHS.PutScalar(0.0);
Epetra_Vector RHS(IFP.OperatorRangeMap());
RHS.Random();
Epetra_LinearProblem Problem;
Problem.SetOperator(Matrix);
Problem.SetLHS(&LHS);
Problem.SetRHS(&RHS);
AztecOO Solver(Problem);
Solver.SetAztecOption(AZ_solver,AZ_gmres_condnum);
Solver.SetAztecOption(AZ_output,AZ_none);
// the following can be problematic for large problems,
// but any restart would destroy useful information about
// the condition number.
Solver.SetAztecOption(AZ_kspace,MaxIters);
Solver.Iterate(MaxIters,Tol);
const double* status = Solver.GetAztecStatus();
ConditionNumberEstimate = status[AZ_condnum];
#endif
}
return(ConditionNumberEstimate);
}
