43 #ifndef THYRA_DEFAULT_BLOCKED_LINEAR_OP_DEF_HPP 44 #define THYRA_DEFAULT_BLOCKED_LINEAR_OP_DEF_HPP 47 #include "Thyra_DefaultBlockedLinearOp_decl.hpp" 48 #include "Thyra_DefaultProductVectorSpace.hpp" 49 #include "Thyra_DefaultProductVector.hpp" 50 #include "Thyra_DefaultProductMultiVector.hpp" 51 #include "Thyra_MultiVectorStdOps.hpp" 52 #include "Thyra_VectorStdOps.hpp" 53 #include "Thyra_AssertOp.hpp" 54 #include "Thyra_ScaledAdjointLinearOpBase.hpp" 63 template<
class Scalar>
65 :numRowBlocks_(0), numColBlocks_(0), blockFillIsActive_(false)
72 template<
class Scalar>
75 assertBlockFillIsActive(
false);
81 template<
class Scalar>
83 const int numRowBlocks,
const int numColBlocks
86 assertBlockFillIsActive(
false);
88 resetStorage(numRowBlocks,numColBlocks);
92 template<
class Scalar>
98 using Teuchos::rcp_dynamic_cast;
99 assertBlockFillIsActive(
false);
101 productRange_ = new_productRange.assert_not_null();
102 productDomain_ = new_productDomain.assert_not_null();
103 defaultProductRange_ =
105 defaultProductDomain_ =
108 resetStorage(productRange_->numBlocks(), productDomain_->numBlocks());
112 template<
class Scalar>
115 return blockFillIsActive_;
119 template<
class Scalar>
121 const int i,
const int j
124 assertBlockFillIsActive(
true);
125 assertBlockRowCol(i,j);
130 template<
class Scalar>
132 const int i,
const int j
136 setBlockImpl(i, j, block);
140 template<
class Scalar>
142 const int i,
const int j
146 setBlockImpl(i, j, block);
150 template<
class Scalar>
156 assertBlockFillIsActive(
true);
163 if (nonnull(productRange_)) {
164 numRowBlocks_ = productRange_->numBlocks();
165 numColBlocks_ = productDomain_->numBlocks();
168 numRowBlocks_ = rangeBlocks_.size();
169 numColBlocks_ = domainBlocks_.size();
178 if (is_null(productRange_)) {
179 for (
int i = 0; i < numRowBlocks_; ++i) {
180 TEUCHOS_TEST_FOR_EXCEPTION(
181 !rangeBlocks_[i].
get(), std::logic_error
182 ,
"DefaultBlockedLinearOp<Scalar>::endBlockFill():" 183 " Error, no linear operator block for the i="<<i<<
" block row was added" 184 " and we can not complete the block fill!" 187 for(
int j = 0; j < numColBlocks_; ++j) {
188 TEUCHOS_TEST_FOR_EXCEPTION(
189 !domainBlocks_[j].
get(), std::logic_error
190 ,
"DefaultBlockedLinearOp<Scalar>::endBlockFill():" 191 " Error, no linear operator block for the j=" 192 <<j<<
" block column was added" 193 " and we can not complete the block fill!" 200 if (Ops_stack_.size()) {
201 Ops_.resize(numRowBlocks_*numColBlocks_);
202 for (
int k = 0; k < as<int>(Ops_stack_.size()); ++k ) {
203 const BlockEntry<Scalar> &block_i_j = Ops_stack_[k];
204 Ops_[numRowBlocks_*block_i_j.j + block_i_j.i] = block_i_j.block;
206 Ops_stack_.resize(0);
210 if (is_null(productRange_)) {
212 defaultProductRange_ = productVectorSpace<Scalar>(rangeBlocks_());
213 defaultProductDomain_ = productVectorSpace<Scalar>(domainBlocks_());
214 productRange_ = defaultProductRange_;
215 productDomain_ = defaultProductDomain_;
218 rangeBlocks_.resize(0);
219 domainBlocks_.resize(0);
221 blockFillIsActive_ =
false;
226 template<
class Scalar>
229 productRange_ = Teuchos::null;
230 productDomain_ = Teuchos::null;
234 Ops_stack_.resize(0);
235 rangeBlocks_.resize(0);
236 domainBlocks_.resize(0);
237 blockFillIsActive_ =
false;
244 template<
class Scalar>
245 RCP<const ProductVectorSpaceBase<Scalar> >
248 return productRange_;
252 template<
class Scalar>
253 RCP<const ProductVectorSpaceBase<Scalar> >
256 return productDomain_;
260 template<
class Scalar>
262 const int i,
const int j
265 assertBlockFillIsActive(
false);
266 assertBlockRowCol(i,j);
271 template<
class Scalar>
273 const int i,
const int j
277 TEUCHOS_TEST_FOR_EXCEPT(!blockExists(i,j));
279 assertBlockFillIsActive(
false);
280 assertBlockRowCol(i,j);
281 return Ops_[numRowBlocks_*j+i].isConst();
285 template<
class Scalar>
286 RCP<LinearOpBase<Scalar> >
290 TEUCHOS_TEST_FOR_EXCEPT(!blockExists(i,j));
292 assertBlockFillIsActive(
false);
293 assertBlockRowCol(i,j);
294 return Ops_[numRowBlocks_*j+i].getNonconstObj();
298 template<
class Scalar>
299 RCP<const LinearOpBase<Scalar> >
303 TEUCHOS_TEST_FOR_EXCEPT(!blockExists(i,j));
305 assertBlockFillIsActive(
false);
306 assertBlockRowCol(i,j);
307 return Ops_[numRowBlocks_*j+i];
314 template<
class Scalar>
315 RCP< const VectorSpaceBase<Scalar> >
318 return productRange_;
322 template<
class Scalar>
323 RCP< const VectorSpaceBase<Scalar> >
326 return productDomain_;
330 template<
class Scalar>
331 RCP<const LinearOpBase<Scalar> >
334 return Teuchos::null;
341 template<
class Scalar>
344 assertBlockFillIsActive(
false);
345 std::ostringstream oss;
347 << Teuchos::Describable::description() <<
"{" 348 <<
"numRowBlocks="<<numRowBlocks_
349 <<
",numColBlocks="<<numColBlocks_
355 template<
class Scalar>
357 Teuchos::FancyOStream &out_arg
358 ,
const Teuchos::EVerbosityLevel verbLevel
361 using Teuchos::rcpFromRef;
362 using Teuchos::FancyOStream;
363 using Teuchos::OSTab;
364 assertBlockFillIsActive(
false);
365 RCP<FancyOStream> out = rcpFromRef(out_arg);
368 case Teuchos::VERB_DEFAULT:
369 case Teuchos::VERB_LOW:
370 *out << this->description() << std::endl;
372 case Teuchos::VERB_MEDIUM:
373 case Teuchos::VERB_HIGH:
374 case Teuchos::VERB_EXTREME:
377 << Teuchos::Describable::description() <<
"{" 378 <<
"rangeDim=" << this->range()->dim()
379 <<
",domainDim=" << this->domain()->dim()
380 <<
",numRowBlocks=" << numRowBlocks_
381 <<
",numColBlocks=" << numColBlocks_
385 <<
"Constituent LinearOpBase objects for M = [ Op[0,0] ..." 386 <<
" ; ... ; ... Op[numRowBlocks-1,numColBlocks-1] ]:\n";
388 for(
int i = 0; i < numRowBlocks_; ++i ) {
389 for(
int j = 0; j < numColBlocks_; ++j ) {
390 *out <<
"Op["<<i<<
","<<j<<
"] = ";
391 RCP<const LinearOpBase<Scalar> >
392 block_i_j = getBlock(i,j);
394 *out << Teuchos::describe(*getBlock(i,j),verbLevel);
402 TEUCHOS_TEST_FOR_EXCEPT(
true);
413 template<
class Scalar>
416 bool supported =
true;
417 for(
int i = 0; i < numRowBlocks_; ++i ) {
418 for(
int j = 0; j < numColBlocks_; ++j ) {
419 RCP<const LinearOpBase<Scalar> >
420 block_i_j = getBlock(i,j);
421 if( block_i_j.get() && !Thyra::opSupported(*block_i_j,M_trans) )
429 template<
class Scalar>
439 using Teuchos::rcpFromRef;
440 typedef Teuchos::ScalarTraits<Scalar> ST;
441 typedef RCP<MultiVectorBase<Scalar> > MultiVectorPtr;
442 typedef RCP<const MultiVectorBase<Scalar> > ConstMultiVectorPtr;
443 typedef RCP<const LinearOpBase<Scalar> > ConstLinearOpPtr;
447 "DefaultBlockedLinearOp<Scalar>::apply(...)", *
this, M_trans, X_in, &*Y_inout
449 #endif // TEUCHOS_DEBUG 454 opNumRowBlocks = ( !struct_transp ? numRowBlocks_ : numColBlocks_ ),
455 opNumColBlocks = ( !struct_transp ? numColBlocks_ : numRowBlocks_ );
467 const RCP<const DefaultProductVectorSpace<Scalar> >
469 ? defaultProductRange_ : defaultProductDomain_ ),
471 ? defaultProductDomain_ : defaultProductRange_ );
473 const RCP<const ProductMultiVectorBase<Scalar> >
474 X = castOrCreateSingleBlockProductMultiVector<Scalar>(
475 defaultProductDomain_op, rcpFromRef(X_in));
476 const RCP<ProductMultiVectorBase<Scalar> >
477 Y = nonconstCastOrCreateSingleBlockProductMultiVector<Scalar>(
478 defaultProductRange_op, rcpFromPtr(Y_inout));
480 for(
int i = 0; i < opNumRowBlocks; ++i ) {
481 MultiVectorPtr Y_i = Y->getNonconstMultiVectorBlock(i);
482 for(
int j = 0; j < opNumColBlocks; ++j ) {
484 Op_i_j = ( !struct_transp ? getBlock(i,j) : getBlock(j,i) );
486 X_j = X->getMultiVectorBlock(j);
489 Thyra::apply(*Op_i_j, M_trans,* X_j, Y_i.ptr(), alpha, beta);
491 scale(beta, Y_i.ptr());
495 Thyra::apply(*Op_i_j, M_trans, *X_j, Y_i.ptr(), alpha, ST::one());
503 template<
class Scalar>
506 const RowStatLinearOpBaseUtils::ERowStat row_stat)
const 508 using Teuchos::rcpFromRef;
509 using Teuchos::rcp_dynamic_cast;
510 using Teuchos::dyn_cast;
513 typedef RCP<const LinearOpBase<Scalar> > ConstLinearOpPtr;
518 RowStatLinearOpBaseUtils::ERowStat
519 subblk_stat = RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM,
520 subblk_trans_stat = RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM;
522 case RowStatLinearOpBaseUtils::ROW_STAT_INV_ROW_SUM:
523 case RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM:
524 subblk_stat = RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM;
525 subblk_trans_stat = RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM;
527 case RowStatLinearOpBaseUtils::ROW_STAT_INV_COL_SUM:
528 case RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM:
529 subblk_stat = RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM;
530 subblk_trans_stat = RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM;
533 TEUCHOS_TEST_FOR_EXCEPT(
true);
538 for(
int i = 0; i < numRowBlocks_; ++i ) {
539 for(
int j = 0; j < numColBlocks_; ++j ) {
540 ConstLinearOpPtr Op_i_j = getBlock(i,j);
542 if (nonnull(Op_i_j)) {
544 ConstLinearOp * Orig_i_j = 0;
549 const RowStatOp & row_stat_op = Teuchos::dyn_cast<
const RowStatOp>(*Orig_i_j);
552 RowStatLinearOpBaseUtils::ERowStat stat = subblk_stat;
556 stat = subblk_trans_stat;
558 if(!row_stat_op.rowStatIsSupported(stat))
568 template<
class Scalar>
571 const RowStatLinearOpBaseUtils::ERowStat row_stat,
574 using Teuchos::rcpFromRef;
575 using Teuchos::rcpFromPtr;
576 using Teuchos::rcp_dynamic_cast;
577 using Teuchos::dyn_cast;
578 typedef Teuchos::ScalarTraits<Scalar> ST;
580 typedef RCP<const LinearOpBase<Scalar> > ConstLinearOpPtr;
582 typedef RCP<VectorBase<Scalar> > VectorPtr;
586 RowStatLinearOpBaseUtils::ERowStat
587 subblk_stat = RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM,
588 subblk_trans_stat = RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM;
590 case RowStatLinearOpBaseUtils::ROW_STAT_INV_ROW_SUM:
591 case RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM:
592 subblk_stat = RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM;
593 subblk_trans_stat = RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM;
595 case RowStatLinearOpBaseUtils::ROW_STAT_INV_COL_SUM:
596 case RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM:
597 subblk_stat = RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM;
598 subblk_trans_stat = RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM;
601 TEUCHOS_TEST_FOR_EXCEPT(
true);
604 const RCP<ProductVectorBase<Scalar> >
609 for(
int i = 0; i < numRowBlocks_; ++i ) {
611 put_scalar (ST::zero (), blk_vec.ptr ());
613 for(
int j = 0; j < numColBlocks_; ++j ) {
614 ConstLinearOpPtr Op_i_j = getBlock(i,j);
616 VectorPtr tmp_vec = createMember(Op_i_j->range());
618 put_scalar (ST::zero (), tmp_vec.ptr ());
620 if (nonnull(Op_i_j)) {
622 ConstLinearOp * Orig_i_j = 0;
627 const RowStatOp & row_stat_op = Teuchos::dyn_cast<
const RowStatOp>(*Orig_i_j);
631 row_stat_op.getRowStat(subblk_stat,tmp_vec.ptr());
633 row_stat_op.getRowStat(subblk_trans_stat,tmp_vec.ptr());
635 { TEUCHOS_ASSERT(
false); }
638 Vp_V(blk_vec.ptr(),*tmp_vec);
645 case RowStatLinearOpBaseUtils::ROW_STAT_INV_ROW_SUM:
646 case RowStatLinearOpBaseUtils::ROW_STAT_INV_COL_SUM:
647 reciprocal(*rowStatVec,rowStatVec.ptr());
648 case RowStatLinearOpBaseUtils::ROW_STAT_ROW_SUM:
649 case RowStatLinearOpBaseUtils::ROW_STAT_COL_SUM:
652 TEUCHOS_TEST_FOR_EXCEPT(
true);
658 template<
class Scalar>
662 using Teuchos::rcp_dynamic_cast;
663 using Teuchos::dyn_cast;
664 typedef RCP<const LinearOpBase<Scalar> > LinearOpPtr;
668 bool supported =
true;
669 for(
int i = 0; i < numRowBlocks_; ++i ) {
670 for(
int j = 0; j < numColBlocks_; ++j ) {
671 LinearOpPtr Op_i_j = getBlock(i,j);
675 if (nonnull(Op_i_j)) {
677 LinearOp * Orig_i_j = 0;
681 ScaledOp & scaled_op = Teuchos::dyn_cast<ScaledOp>(*Orig_i_j);
684 supported &= scaled_op.supportsScaleLeft();
686 supported &= scaled_op.supportsScaleRight();
694 template<
class Scalar>
698 using Teuchos::rcp_dynamic_cast;
699 using Teuchos::dyn_cast;
700 typedef RCP<const LinearOpBase<Scalar> > LinearOpPtr;
704 bool supported =
true;
705 for(
int i = 0; i < numRowBlocks_; ++i ) {
706 for(
int j = 0; j < numColBlocks_; ++j ) {
707 LinearOpPtr Op_i_j = getBlock(i,j);
709 if (nonnull(Op_i_j)) {
711 LinearOp * Orig_i_j = 0;
716 ScaledOp & scaled_op = Teuchos::dyn_cast<ScaledOp>(*Orig_i_j);
719 supported &= scaled_op.supportsScaleRight();
721 supported &= scaled_op.supportsScaleLeft();
729 template<
class Scalar>
734 using Teuchos::dyn_cast;
735 using Teuchos::rcp_dynamic_cast;
737 typedef RCP<LinearOpBase<Scalar> > LinearOpPtr;
738 typedef RCP<const VectorBase<Scalar> > VectorPtr;
745 for(
int i = 0; i < numRowBlocks_; ++i ) {
748 for(
int j = 0; j < numColBlocks_; ++j ) {
749 LinearOpPtr Op_i_j = getNonconstBlock(i,j);
751 if (nonnull(Op_i_j)) {
753 LinearOpPtr Orig_i_j;
757 RCP<ScaledAdjointLinearOpBase<Scalar> > saOp
761 Orig_i_j = saOp->getNonconstOrigOp();
767 RCP<ScaledOp> scaled_op = rcp_dynamic_cast<ScaledOp>(Orig_i_j);
770 TEUCHOS_ASSERT(scaled_op!=Teuchos::null);
774 scaled_op->scaleLeft(*blk_vec);
776 scaled_op->scaleRight(*blk_vec);
782 template<
class Scalar>
787 using Teuchos::dyn_cast;
788 using Teuchos::rcp_dynamic_cast;
790 typedef RCP<LinearOpBase<Scalar> > LinearOpPtr;
791 typedef RCP<const VectorBase<Scalar> > VectorPtr;
798 for(
int j = 0; j < numColBlocks_; ++j ) {
801 for(
int i = 0; i < numRowBlocks_; ++i ) {
802 LinearOpPtr Op_i_j = getNonconstBlock(i,j);
804 if (nonnull(Op_i_j)) {
806 LinearOpPtr Orig_i_j;
810 RCP<ScaledAdjointLinearOpBase<Scalar> > saOp
814 Orig_i_j = saOp->getNonconstOrigOp();
820 RCP<ScaledOp> scaled_op = rcp_dynamic_cast<ScaledOp>(Orig_i_j);
823 TEUCHOS_ASSERT(scaled_op!=Teuchos::null);
827 scaled_op->scaleRight(*blk_vec);
829 scaled_op->scaleLeft(*blk_vec);
838 template<
class Scalar>
840 const int numRowBlocks,
const int numColBlocks
843 numRowBlocks_ = numRowBlocks;
844 numColBlocks_ = numColBlocks;
845 Ops_.resize(numRowBlocks_*numColBlocks_);
846 if (is_null(productRange_)) {
847 rangeBlocks_.resize(numRowBlocks);
848 domainBlocks_.resize(numColBlocks);
850 blockFillIsActive_ =
true;
854 template<
class Scalar>
855 void DefaultBlockedLinearOp<Scalar>::assertBlockFillIsActive(
860 TEUCHOS_TEST_FOR_EXCEPT(!(blockFillIsActive_==wantedValue));
865 template<
class Scalar>
866 void DefaultBlockedLinearOp<Scalar>::assertBlockRowCol(
867 const int i,
const int j
871 TEUCHOS_TEST_FOR_EXCEPTION(
872 !( 0 <= i ), std::logic_error
873 ,
"Error, i="<<i<<
" is invalid!" 875 TEUCHOS_TEST_FOR_EXCEPTION(
876 !( 0 <= j ), std::logic_error
877 ,
"Error, j="<<j<<
" is invalid!" 882 TEUCHOS_TEST_FOR_EXCEPTION(
883 !( 0 <= i && i < numRowBlocks_ ), std::logic_error
884 ,
"Error, i="<<i<<
" does not fall in the range [0,"<<numRowBlocks_-1<<
"]!" 886 TEUCHOS_TEST_FOR_EXCEPTION(
887 !( 0 <= j && j < numColBlocks_ ), std::logic_error
888 ,
"Error, j="<<j<<
" does not fall in the range [0,"<<numColBlocks_-1<<
"]!" 895 template<
class Scalar>
896 void DefaultBlockedLinearOp<Scalar>::setBlockSpaces(
897 const int i,
const int j,
const LinearOpBase<Scalar> &block
901 assertBlockFillIsActive(
true);
902 assertBlockRowCol(i,j);
906 if( i < numRowBlocks_ && j < numColBlocks_ ) {
908 RCP<const VectorSpaceBase<Scalar> >
911 ? productRange_->getBlock(i)
916 ? productDomain_->getBlock(j)
919 if(rangeBlock.get()) {
921 "DefaultBlockedLinearOp<Scalar>::setBlockSpaces(i,j,block):\n\n" 922 "Adding block: " + block.description(),
923 *rangeBlock,(
"(*productRange->getBlock("+
toString(i)+
"))"),
927 if(domainBlock.get()) {
929 "DefaultBlockedLinearOp<Scalar>::setBlockSpaces(i,j,block):\n\n" 930 "Adding block: " + block.description(),
931 *domainBlock,(
"(*productDomain->getBlock("+
toString(j)+
"))"),
935 #endif // TEUCHOS_DEBUG 940 for(
int k = numRowBlocks_; k <= i; ++k )
941 rangeBlocks_.push_back(Teuchos::null);
942 for(
int k = numColBlocks_; k <= j; ++k )
943 domainBlocks_.push_back(Teuchos::null);
946 if(!productRange_.get()) {
947 if(!rangeBlocks_[i].
get())
948 rangeBlocks_[i] = block.range().assert_not_null();
949 if(!domainBlocks_[j].
get()) {
950 domainBlocks_[j] = block.domain().assert_not_null();
957 numRowBlocks_ = rangeBlocks_.size();
958 numColBlocks_ = domainBlocks_.size();
964 template<
class Scalar>
965 template<
class LinearOpType>
966 void DefaultBlockedLinearOp<Scalar>::setBlockImpl(
967 const int i,
const int j,
968 const RCP<LinearOpType> &block
971 setBlockSpaces(i, j, *block);
975 Ops_[numRowBlocks_*j+i] = block;
980 bool foundBlock =
false;
981 for(
unsigned int k = 0; k < Ops_stack_.size(); ++k ) {
982 BlockEntry<Scalar> &block_i_j = Ops_stack_[k];
983 if( block_i_j.i == i && block_i_j.j == j ) {
984 block_i_j.block = block;
990 Ops_stack_.push_back(BlockEntry<Scalar>(i,j,block));
995 template<
class Scalar>
996 void DefaultBlockedLinearOp<Scalar>::adjustBlockSpaces()
1000 TEUCHOS_ASSERT_INEQUALITY(Ops_.size(), !=, 0);
1015 for (
int i = 0; i < numRowBlocks_; ++i) {
1016 for (
int j = 0; j < numColBlocks_; ++j) {
1017 const RCP<const LinearOpBase<Scalar> >
1018 op_i_j = Ops_[numRowBlocks_*j+i];
1019 if (is_null(op_i_j))
1021 const RCP<const VectorSpaceBase<Scalar> > range_i_j = op_i_j->range();
1022 if (is_null(productVectorSpaceBase<Scalar>(range_i_j,
false))) {
1023 rangeBlocks_[i] = range_i_j;
1030 for (
int j = 0; j < numColBlocks_; ++j) {
1031 for (
int i = 0; i < numRowBlocks_; ++i) {
1032 const RCP<const LinearOpBase<Scalar> >
1033 op_i_j = Ops_[numRowBlocks_*j+i];
1034 if (is_null(op_i_j))
1036 const RCP<const VectorSpaceBase<Scalar> >
1037 domain_i_j = op_i_j->domain();
1038 if (is_null(productVectorSpaceBase<Scalar>(domain_i_j,
false))) {
1039 domainBlocks_[j] = domain_i_j;
1051 template<
class Scalar>
1052 Teuchos::RCP<Thyra::DefaultBlockedLinearOp<Scalar> >
1053 Thyra::defaultBlockedLinearOp()
1055 return Teuchos::rcp(
new DefaultBlockedLinearOp<Scalar>());
1059 template<
class Scalar>
1060 Teuchos::RCP<const Thyra::LinearOpBase<Scalar> >
1062 const RCP<
const LinearOpBase<Scalar> > &A00,
1063 const std::string &label
1066 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1067 M = defaultBlockedLinearOp<Scalar>();
1068 M->beginBlockFill(1,1);
1069 M->setBlock(0, 0, A00);
1072 M->setObjectLabel(label);
1077 template<
class Scalar>
1078 Teuchos::RCP<const Thyra::LinearOpBase<Scalar> >
1080 const RCP<
const LinearOpBase<Scalar> > &A00,
1081 const RCP<
const LinearOpBase<Scalar> > &A01,
1082 const std::string &label
1085 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1086 M = defaultBlockedLinearOp<Scalar>();
1087 M->beginBlockFill(1,2);
1088 if(A00.get()) M->setBlock(0,0,A00);
1089 if(A01.get()) M->setBlock(0,1,A01);
1092 M->setObjectLabel(label);
1097 template<
class Scalar>
1098 Teuchos::RCP<const Thyra::LinearOpBase<Scalar> >
1100 const RCP<
const LinearOpBase<Scalar> > &A00,
1101 const RCP<
const LinearOpBase<Scalar> > &A10,
1102 const std::string &label
1105 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1106 M = defaultBlockedLinearOp<Scalar>();
1107 M->beginBlockFill(2,1);
1108 if(A00.get()) M->setBlock(0,0,A00);
1109 if(A10.get()) M->setBlock(1,0,A10);
1112 M->setObjectLabel(label);
1117 template<
class Scalar>
1118 Teuchos::RCP<const Thyra::LinearOpBase<Scalar> >
1120 const RCP<
const LinearOpBase<Scalar> > &A00,
1121 const RCP<
const LinearOpBase<Scalar> > &A01,
1122 const RCP<
const LinearOpBase<Scalar> > &A10,
1123 const RCP<
const LinearOpBase<Scalar> > &A11,
1124 const std::string &label
1127 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1128 M = defaultBlockedLinearOp<Scalar>();
1129 M->beginBlockFill(2,2);
1130 if(A00.get()) M->setBlock(0,0,A00);
1131 if(A01.get()) M->setBlock(0,1,A01);
1132 if(A10.get()) M->setBlock(1,0,A10);
1133 if(A11.get()) M->setBlock(1,1,A11);
1136 M->setObjectLabel(label);
1141 template<
class Scalar>
1142 Teuchos::RCP<Thyra::LinearOpBase<Scalar> >
1143 Thyra::nonconstBlock1x1(
1144 const RCP<LinearOpBase<Scalar> > &A00,
1145 const std::string &label
1148 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1149 M = defaultBlockedLinearOp<Scalar>();
1150 M->beginBlockFill(1, 1);
1151 M->setNonconstBlock(0, 0, A00);
1154 M->setObjectLabel(label);
1159 template<
class Scalar>
1160 Teuchos::RCP<Thyra::LinearOpBase<Scalar> >
1161 Thyra::nonconstBlock1x2(
1162 const RCP<LinearOpBase<Scalar> > &A00,
1163 const RCP<LinearOpBase<Scalar> > &A01,
1164 const std::string &label
1167 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1168 M = defaultBlockedLinearOp<Scalar>();
1169 M->beginBlockFill(1,2);
1170 if(A00.get()) M->setNonconstBlock(0,0,A00);
1171 if(A01.get()) M->setNonconstBlock(0,1,A01);
1174 M->setObjectLabel(label);
1179 template<
class Scalar>
1180 Teuchos::RCP<Thyra::LinearOpBase<Scalar> >
1181 Thyra::nonconstBlock2x1(
1182 const RCP<LinearOpBase<Scalar> > &A00,
1183 const RCP<LinearOpBase<Scalar> > &A10,
1184 const std::string &label
1187 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1188 M = defaultBlockedLinearOp<Scalar>();
1189 M->beginBlockFill(2,1);
1190 if(A00.get()) M->setNonconstBlock(0,0,A00);
1191 if(A10.get()) M->setNonconstBlock(1,0,A10);
1194 M->setObjectLabel(label);
1199 template<
class Scalar>
1200 Teuchos::RCP<Thyra::LinearOpBase<Scalar> >
1201 Thyra::nonconstBlock2x2(
1202 const RCP<LinearOpBase<Scalar> > &A00,
1203 const RCP<LinearOpBase<Scalar> > &A01,
1204 const RCP<LinearOpBase<Scalar> > &A10,
1205 const RCP<LinearOpBase<Scalar> > &A11,
1206 const std::string &label
1209 RCP<PhysicallyBlockedLinearOpBase<Scalar> >
1210 M = defaultBlockedLinearOp<Scalar>();
1211 M->beginBlockFill(2,2);
1212 if(A00.get()) M->setNonconstBlock(0,0,A00);
1213 if(A01.get()) M->setNonconstBlock(0,1,A01);
1214 if(A10.get()) M->setNonconstBlock(1,0,A10);
1215 if(A11.get()) M->setNonconstBlock(1,1,A11);
1218 M->setObjectLabel(label);
1230 #define THYRA_DEFAULT_BLOCKED_LINEAR_OP_INSTANT(SCALAR) \ 1232 template class DefaultBlockedLinearOp<SCALAR >; \ 1234 template RCP<DefaultBlockedLinearOp<SCALAR > > \ 1235 defaultBlockedLinearOp<SCALAR >(); \ 1237 template RCP<const LinearOpBase<SCALAR > > \ 1239 const RCP<const LinearOpBase<SCALAR > > &A00, \ 1240 const std::string &label \ 1243 template RCP<const LinearOpBase<SCALAR > > \ 1245 const RCP<const LinearOpBase<SCALAR > > &A00, \ 1246 const RCP<const LinearOpBase<SCALAR > > &A01, \ 1247 const std::string &label \ 1250 template RCP<const LinearOpBase<SCALAR > > \ 1252 const RCP<const LinearOpBase<SCALAR > > &A00, \ 1253 const RCP<const LinearOpBase<SCALAR > > &A10, \ 1254 const std::string &label \ 1257 template RCP<const LinearOpBase<SCALAR > > \ 1259 const RCP<const LinearOpBase<SCALAR > > &A00, \ 1260 const RCP<const LinearOpBase<SCALAR > > &A01, \ 1261 const RCP<const LinearOpBase<SCALAR > > &A10, \ 1262 const RCP<const LinearOpBase<SCALAR > > &A11, \ 1263 const std::string &label \ 1266 template RCP<LinearOpBase<SCALAR > > \ 1268 const RCP<LinearOpBase<SCALAR > > &A00, \ 1269 const std::string &label \ 1272 template RCP<LinearOpBase<SCALAR > > \ 1274 const RCP<LinearOpBase<SCALAR > > &A00, \ 1275 const RCP<LinearOpBase<SCALAR > > &A01, \ 1276 const std::string &label \ 1279 template RCP<LinearOpBase<SCALAR > > \ 1281 const RCP<LinearOpBase<SCALAR > > &A00, \ 1282 const RCP<LinearOpBase<SCALAR > > &A10, \ 1283 const std::string &label \ 1286 template RCP<LinearOpBase<SCALAR > > \ 1288 const RCP<LinearOpBase<SCALAR > > &A00, \ 1289 const RCP<LinearOpBase<SCALAR > > &A01, \ 1290 const RCP<LinearOpBase<SCALAR > > &A10, \ 1291 const RCP<LinearOpBase<SCALAR > > &A11, \ 1292 const std::string &label \ 1296 #endif // THYRA_DEFAULT_BLOCKED_LINEAR_OP_DEF_HPP virtual bool rowStatIsSupportedImpl(const RowStatLinearOpBaseUtils::ERowStat rowStat) const
Teuchos::RCP< const LinearOpBase< Scalar > > getBlock(const int i, const int j) const
void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Prints the details about the constituent linear operators.
EOpTransp
Enumeration for determining how a linear operator is applied. `*.
Base interface for product vectors.
std::string description() const
Prints just the name DefaultBlockedLinearOp along with the overall dimensions and the number of const...
Teuchos::RCP< const ProductVectorSpaceBase< Scalar > > productRange() const
void unwrap(const LinearOpBase< Scalar > &Op, Scalar *scalar, EOpTransp *transp, const LinearOpBase< Scalar > **origOp)
Extract the overallScalar, overallTransp and const origOp from a const LinearOpBase object...
bool blockIsConst(const int i, const int j) const
#define THYRA_ASSERT_LINEAR_OP_MULTIVEC_APPLY_SPACES(FUNC_NAME, M, M_T, X, Y)
This is a very useful macro that should be used to validate that the spaces for the multi-vector vers...
virtual RCP< const VectorBase< Scalar > > getVectorBlock(const int k) const =0
Returns a non-persisting const view of the (zero-based) kth block vector.
Use the non-transposed operator.
virtual RCP< VectorBase< Scalar > > getNonconstVectorBlock(const int k)=0
Returns a non-persisting non-const view of the (zero-based) kth block vector.
virtual bool supportsScaleRightImpl() const
bool blockExists(const int i, const int j) const
EOpTransp real_trans(EOpTransp transp)
Return NOTRANS or TRANS for real scalar valued operators and this also is used for determining struct...
Use the transposed operator with complex-conjugate clements (same as TRANS for real scalar types)...
Use the non-transposed operator with complex-conjugate elements (same as NOTRANS for real scalar type...
bool opSupportedImpl(EOpTransp M_trans) const
Returns true only if all constituent operators support M_trans.
void applyImpl(const EOpTransp M_trans, const MultiVectorBase< Scalar > &X, const Ptr< MultiVectorBase< Scalar > > &Y, const Scalar alpha, const Scalar beta) const
virtual bool supportsScaleLeftImpl() const
Use the transposed operator.
void setNonconstBlock(const int i, const int j, const Teuchos::RCP< LinearOpBase< Scalar > > &block)
Interface for a collection of column vectors called a multi-vector.
Teuchos::RCP< const VectorSpaceBase< Scalar > > range() const
Base class for LinearOpBase decorator subclasses that wrap a LinearOpBase object and adds on an extra...
bool blockFillIsActive() const
Abstract interface for finite-dimensional dense vectors.
virtual EOpTransp overallTransp() const =0
Return the overall transpose (adjoint) enum.
Teuchos::RCP< const LinearOpBase< Scalar > > clone() const
Teuchos::RCP< const ProductVectorSpaceBase< Scalar > > productDomain() const
Base class for all linear operators.
Applies left or right sclaing to the linear operator.
bool acceptsBlock(const int i, const int j) const
virtual void scaleLeftImpl(const VectorBase< Scalar > &row_scaling)
virtual void scaleRightImpl(const VectorBase< Scalar > &col_scaling)
Interface for exxtracting row statistics as a VectorBase from a supporting LinearOpBase object...
#define THYRA_ASSERT_VEC_SPACES_NAMES(FUNC_NAME, VS1, VS1_NAME, VS2, VS2_NAME)
Helper assertion macro.
virtual void getRowStatImpl(const RowStatLinearOpBaseUtils::ERowStat rowStat, const Teuchos::Ptr< VectorBase< Scalar > > &rowStatVec) const
Teuchos::RCP< const VectorSpaceBase< Scalar > > domain() const
Teuchos::RCP< LinearOpBase< Scalar > > getNonconstBlock(const int i, const int j)
const char * toString(EConj conj)
Return a string name for a EOpTransp value. `*.
void setBlock(const int i, const int j, const Teuchos::RCP< const LinearOpBase< Scalar > > &block)
Concrete composite LinearOpBase subclass that creates single linear operator object out of a set of c...