/** \brief Rebuild this inverse from an Tpetra::Operator<ST,LO,GO,NT> passed
* in this to object.
*
* Rebuild this inverse from an Tpetra::Operator<ST,LO,GO,NT> passed
* in this to object. If <code>buildInverseOperator</code> has not been called
* the inverse operator will be built instead. Otherwise efforts are taken
* to only rebuild what is neccessary. Also, that this Tpetra::Operator<ST,LO,GO,NT>
* may be an EpetraOperatorWrapper object, so the block Thyra components
* can be extracted.
*
* \param[in] A The Epetra source operator. (Should be a EpetraOperatorWrapper!)
*/
void InverseFactoryOperator::rebuildInverseOperator(const Teuchos::RCP<const Tpetra::Operator<ST,LO,GO,NT> > & A)
{
Teko_DEBUG_SCOPE("InverseFactoryOperator::rebuildPreconditioner",10);
// if the inverse hasn't been built yet, rebuild from scratch
if(not firstBuildComplete_) {
buildInverseOperator(A,false);
return;
}
RCP<const Thyra::LinearOpBase<ST> > thyraA = extractLinearOp(A);
Teko::rebuildInverse(*inverseFactory_,thyraA,invOperator_);
if(setConstFwdOp_)
fwdOp_.initialize(A);
SetOperator(invOperator_,false);
setConstFwdOp_ = true;
TEUCHOS_ASSERT(getForwardOp()!=Teuchos::null);
TEUCHOS_ASSERT(invOperator_!=Teuchos::null);
TEUCHOS_ASSERT(getThyraOp()!=Teuchos::null);
TEUCHOS_ASSERT(firstBuildComplete_==true);
}
/** \brief Build this inverse operator from an Tpetra::Operator<ST,LO,GO,NT>
* passed in to this object.
*
* Build this inverse opeerator from an Tpetra::Operator<ST,LO,GO,NT>
* passed in to this object. If this Tpetra::Operator<ST,LO,GO,NT>
* is an EpetraOperatorWrapper object then the block Thyra components
* are extracted.
*
* \param[in] A The Epetra source operator.
* \param[in] clear If true, than any previous state saved by the operator
* is discarded.
*/
void InverseFactoryOperator::buildInverseOperator(const Teuchos::RCP<const Tpetra::Operator<ST,LO,GO,NT> > & A,bool clear)
{
Teko_DEBUG_SCOPE("InverseFactoryOperator::buildInverseOperator",10);
// extract EpetraOperatorWrapper (throw on failure) and corresponding thyra operator
RCP<const Thyra::LinearOpBase<ST> > thyraA = extractLinearOp(A);
// set the mapping strategy
SetMapStrategy(rcp(new InverseMappingStrategy(extractMappingStrategy(A))));
initInverse(clear);
// actually build the inverse operator
invOperator_ = Teko::buildInverse(*inverseFactory_,thyraA);
SetOperator(invOperator_,false);
firstBuildComplete_ = true;
if(setConstFwdOp_)
fwdOp_ = A;
setConstFwdOp_ = true;
TEUCHOS_ASSERT(invOperator_!=Teuchos::null);
TEUCHOS_ASSERT(getForwardOp()!=Teuchos::null);
TEUCHOS_ASSERT(getThyraOp()!=Teuchos::null);
TEUCHOS_ASSERT(getMapStrategy()!=Teuchos::null);
TEUCHOS_ASSERT(firstBuildComplete_==true);
}
void Driver::Event_Fallthrough(const EV::Event& event) {
int accepted = 0;
event.SetReturnPointer(&accepted);
if(!(_activeOp && DispatchSingleEvent(_activeOp, event))) {
if(_activeOp != _defaultOp) {
GEN::Pointer<EV::Event> ftevent(event.Clone());
ftevent->SetFallthrough(true);
if(DispatchSingleEvent(_defaultOp, *ftevent)) {
// default operator becomes active, implicit rebuild
SetOperator(_defaultOp, false, NULL);
// next, we have to resend the event without fallthrough flag
accepted = 0;
DispatchSingleEvent(_activeOp, event);
}
}
}
if(!accepted) {
// forward event
W::world.Send(event);
}
RebuildMeshes();
SignalCompletion();
}
static nsresult
InitOperators(void)
{
// Load the property file containing the Operator Dictionary
nsresult rv;
nsCOMPtr<nsIPersistentProperties> mathfontProp;
rv = NS_LoadPersistentPropertiesFromURISpec(
getter_AddRefs(mathfontProp),
NS_LITERAL_CSTRING("resource://gre/res/fonts/mathfont.properties"));
if (NS_FAILED(rv)) return rv;
// Parse the Operator Dictionary in two passes.
// The first pass is to count the number of operators; the second pass is to
// allocate the necessary space for them and to add them in the hash table.
for (int32_t pass = 1; pass <= 2; pass++) {
OperatorData dummyData;
OperatorData* operatorData = &dummyData;
nsCOMPtr<nsISimpleEnumerator> iterator;
if (NS_SUCCEEDED(mathfontProp->Enumerate(getter_AddRefs(iterator)))) {
bool more;
uint32_t index = 0;
nsAutoCString name;
nsAutoString attributes;
while ((NS_SUCCEEDED(iterator->HasMoreElements(&more))) && more) {
nsCOMPtr<nsISupports> supports;
nsCOMPtr<nsIPropertyElement> element;
if (NS_SUCCEEDED(iterator->GetNext(getter_AddRefs(supports)))) {
element = do_QueryInterface(supports);
if (NS_SUCCEEDED(element->GetKey(name)) &&
NS_SUCCEEDED(element->GetValue(attributes))) {
// expected key: operator.\uNNNN.{infix,postfix,prefix}
if ((21 <= name.Length()) && (0 == name.Find("operator.\\u"))) {
name.Cut(0, 9); // 9 is the length of "operator.";
int32_t len = name.Length();
nsOperatorFlags form = 0;
if (kNotFound != name.RFind(".infix")) {
form = NS_MATHML_OPERATOR_FORM_INFIX;
len -= 6; // 6 is the length of ".infix";
}
else if (kNotFound != name.RFind(".postfix")) {
form = NS_MATHML_OPERATOR_FORM_POSTFIX;
len -= 8; // 8 is the length of ".postfix";
}
else if (kNotFound != name.RFind(".prefix")) {
form = NS_MATHML_OPERATOR_FORM_PREFIX;
len -= 7; // 7 is the length of ".prefix";
}
else continue; // input is not applicable
name.SetLength(len);
if (2 == pass) { // allocate space and start the storage
if (!gOperatorArray) {
if (0 == gOperatorCount) return NS_ERROR_UNEXPECTED;
gOperatorArray = new OperatorData[gOperatorCount];
if (!gOperatorArray) return NS_ERROR_OUT_OF_MEMORY;
}
operatorData = &gOperatorArray[index];
}
else {
form = 0; // to quickly return from SetOperator() at pass 1
}
// See if the operator should be retained
if (SetOperator(operatorData, form, name, attributes)) {
index++;
if (1 == pass) gOperatorCount = index;
}
}
}
}
}
}
}
return NS_OK;
}
void
ALOperator::BuildALOperator()
{
TEUCHOS_ASSERT(blockedMapping_ != Teuchos::null);
// Get an Epetra_CrsMatrix.
const Teuchos::RCP<const Epetra_CrsMatrix> crsContent
= Teuchos::rcp_dynamic_cast<const Epetra_CrsMatrix>(fullContent_);
// Ask the strategy to build the Thyra operator for you.
if(blockedOperator_ == Teuchos::null)
{
blockedOperator_
= blockedMapping_->buildBlockedThyraOp(crsContent, label_);
}
else
{
const Teuchos::RCP<Thyra::BlockedLinearOpBase<double> > blkOp
= Teuchos::rcp_dynamic_cast<Thyra::BlockedLinearOpBase<double> >
(blockedOperator_, true);
blockedMapping_->rebuildBlockedThyraOp(crsContent, blkOp);
}
// Extract blocks.
const Teuchos::RCP<Thyra::BlockedLinearOpBase<double> > blkOp
= Teuchos::rcp_dynamic_cast<Thyra::BlockedLinearOpBase<double> >
(blockedOperator_, true);
numBlockRows_ = blkOp->productRange()->numBlocks();
Teuchos::RCP<const Thyra::LinearOpBase<double> > blockedOpBlocks[4][4];
for(int i = 0; i <= dim_; i++)
{
for(int j = 0; j <= dim_; j++)
{
blockedOpBlocks[i][j] = blkOp->getBlock(i, j);
}
}
// Pressure mass matrix.
if(pressureMassMatrix_ != Teuchos::null)
{
invPressureMassMatrix_ = getInvDiagonalOp(pressureMassMatrix_);
}
// We need the size of the sub-block to build the identity matrix.
else
{
std::cout << "Pressure mass matrix is null. Use identity." << std::endl;
pressureMassMatrix_
= Thyra::identity<double>(blockedOpBlocks[dim_][0]->range());
invPressureMassMatrix_
= Thyra::identity<double>(blockedOpBlocks[dim_][0]->range());
}
// Build the AL operator.
Teuchos::RCP<Thyra::DefaultBlockedLinearOp<double> > alOperator_
= Thyra::defaultBlockedLinearOp<double>();
alOperator_->beginBlockFill(dim_ + 1, dim_ + 1);
// Set blocks for the velocity parts and gradient.
for(int i = 0; i < dim_; i++)
{
for(int j = 0; j < dim_; j++)
{
// build the blocks and place it the right location
alOperator_->setBlock(i, j,
Thyra::add(blockedOpBlocks[i][j],
Thyra::scale(gamma_,
Thyra::multiply(blockedOpBlocks[i][dim_],
invPressureMassMatrix_, blockedOpBlocks[dim_][j]))));
} // end for j
} // end for i
// Last row. Divergence and (possible) stabilization matrix.
for(int j = 0; j <= dim_; j++)
{
alOperator_->setBlock(dim_, j, blockedOpBlocks[dim_][j]);
}
// Last column. Gradient.
for(int i = 0; i < dim_; i++)
{
alOperator_->setBlock(i, dim_,
Thyra::add(blockedOpBlocks[i][dim_],
Thyra::scale(gamma_,
Thyra::multiply(blockedOpBlocks[i][dim_],
invPressureMassMatrix_,blockedOpBlocks[dim_][dim_]))));
}
alOperator_->endBlockFill();
// Set whatever is returned.
SetOperator(alOperator_, false);
// Set operator for augmenting the right-hand side.
Teuchos::RCP<Thyra::DefaultBlockedLinearOp<double> > alOpRhs_
= Thyra::defaultBlockedLinearOp<double>();
alOpRhs_->beginBlockFill(dim_ + 1, dim_ + 1);
// Identity matrices on the main diagonal.
for(int i = 0; i < dim_; i++)
{
// build the blocks and place it the right location
alOpRhs_->setBlock(i, i,
Thyra::identity<double>(blockedOpBlocks[0][0]->range()));
} // end for i
alOpRhs_->setBlock(dim_, dim_,
Thyra::identity<double>(blockedOpBlocks[dim_][dim_]->range()));
// Last column.
for(int i = 0; i < dim_; i++)
{
alOpRhs_->setBlock(i, dim_,
Thyra::scale(gamma_,
Thyra::multiply(blockedOpBlocks[i][dim_], invPressureMassMatrix_)));
}
alOpRhs_->endBlockFill();
alOperatorRhs_ = alOpRhs_;
// reorder if necessary
if(reorderManager_ != Teuchos::null)
Reorder(*reorderManager_);
}
UMFPackSolver(SparseMatrix &A, bool _use_long_ints = false)
: use_long_ints(_use_long_ints) { Init(); SetOperator(A); }
void Driver::Event_SetOperator(const SetOperatorEvent& event) {
SetOperator(event.m_op, event.m_force, event.m_args);
SignalCompletion();
}
