Thyra_VectorDefaultBase.hpp

Go to the documentation of this file.
00001 // @HEADER
00002 // ***********************************************************************
00003 // 
00004 //    Thyra: Interfaces and Support for Abstract Numerical Algorithms
00005 //                 Copyright (2004) Sandia Corporation
00006 // 
00007 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
00008 // license for use of this work by or on behalf of the U.S. Government.
00009 // 
00010 // This library is free software; you can redistribute it and/or modify
00011 // it under the terms of the GNU Lesser General Public License as
00012 // published by the Free Software Foundation; either version 2.1 of the
00013 // License, or (at your option) any later version.
00014 //  
00015 // This library is distributed in the hope that it will be useful, but
00016 // WITHOUT ANY WARRANTY; without even the implied warranty of
00017 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018 // Lesser General Public License for more details.
00019 //  
00020 // You should have received a copy of the GNU Lesser General Public
00021 // License along with this library; if not, write to the Free Software
00022 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
00023 // USA
00024 // Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
00025 // 
00026 // ***********************************************************************
00027 // @HEADER
00028 
00029 #ifndef THYRA_VECTOR_DEFAULT_BASE_HPP
00030 #define THYRA_VECTOR_DEFAULT_BASE_HPP
00031 
00032 // Define to make some verbose output
00033 //#define THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00034 
00035 #include "Thyra_VectorDefaultBaseDecl.hpp"
00036 #include "Thyra_VectorBase.hpp"
00037 #include "Thyra_MultiVectorDefaultBase.hpp"
00038 #include "Thyra_SingleRhsLinearOpBase.hpp"
00039 #include "Thyra_VectorStdOps.hpp"
00040 #include "Thyra_AssertOp.hpp"
00041 #include "Thyra_DefaultSpmdVectorSpace.hpp"
00042 #include "Thyra_MultiVectorBase.hpp"
00043 #include "RTOpPack_ROpGetSubVector.hpp"
00044 #include "RTOpPack_TOpSetSubVector.hpp"
00045 #include "Teuchos_TestForException.hpp"
00046 
00047 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00048 #  include "Teuchos_VerboseObject.hpp"
00049 #  define THYRA_VECTOR_VERBOSE_OUT_STATEMENT \
00050      Teuchos::RefCountPtr<Teuchos::FancyOStream> dbgout = Teuchos::VerboseObjectBase::getDefaultOStream()
00051 #endif // THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00052 
00053 namespace Thyra {
00054 
00055 // Overridden from Teuchos::Describable
00056 
00057 template<class Scalar>
00058 void VectorDefaultBase<Scalar>::describe(
00059     Teuchos::FancyOStream                &out_arg
00060     ,const Teuchos::EVerbosityLevel      verbLevel
00061     ) const
00062 {
00063   using Teuchos::RefCountPtr;
00064   using Teuchos::FancyOStream;
00065   using Teuchos::OSTab;
00066   RefCountPtr<FancyOStream> out = rcp(&out_arg,false);
00067   OSTab tab(out);
00068   *out
00069     << this->description()
00070     << "{dim="<<this->space()->dim()<<"}\n";
00071   tab.incrTab();
00072   if(verbLevel >= Teuchos::VERB_HIGH) {
00073     RTOpPack::ConstSubVectorView<Scalar> sv;
00074     this->acquireDetachedView(Range1D(),&sv);
00075     for( Index i = 0; i < sv.subDim(); ++i )
00076       *out << i << ":" << sv(i) << std::endl;
00077     this->releaseDetachedView(&sv);
00078   }
00079 }
00080 
00081 // Overridden from LinearOpBase
00082 
00083 template<class Scalar>
00084 Teuchos::RefCountPtr< const VectorSpaceBase<Scalar> >
00085 VectorDefaultBase<Scalar>::range() const
00086 {
00087 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00088   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00089   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::range() called!\n";
00090 #endif
00091   return this->space();
00092 }
00093 
00094 template<class Scalar>
00095 Teuchos::RefCountPtr< const VectorSpaceBase<Scalar> >
00096 VectorDefaultBase<Scalar>::domain() const
00097 {
00098 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00099   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00100   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::domain() called!\n";
00101 #endif
00102   if(!domain_.get())
00103     const_cast<VectorDefaultBase<Scalar>*>(this)->domain_
00104       = Teuchos::rcp(new DefaultSpmdVectorSpace<Scalar>(1));
00105   return domain_;
00106 }
00107 
00108 // Overridden from SingleRhsLinearOpBase
00109 
00110 template<class Scalar>
00111 bool VectorDefaultBase<Scalar>::opSupported(ETransp M_trans) const
00112 {
00113   typedef Teuchos::ScalarTraits<Scalar> ST;
00114   return ( ST::isComplex ? ( M_trans==NOTRANS || M_trans==CONJTRANS ) : true );
00115 }
00116 
00117 template<class Scalar>
00118 void VectorDefaultBase<Scalar>::apply(
00119   const ETransp                M_trans
00120   ,const VectorBase<Scalar>    &x
00121   ,VectorBase<Scalar>          *y
00122   ,const Scalar                alpha
00123   ,const Scalar                beta
00124   ) const
00125 {
00126   typedef Teuchos::ScalarTraits<Scalar> ST;
00127   // Validate input
00128 #ifdef TEUCHOS_DEBUG
00129   THYRA_ASSERT_LINEAR_OP_VEC_APPLY_SPACES("VectorDefaultBase<Scalar>::apply()",*this,M_trans,x,y);
00130 #endif
00131   // Here M = m (where m is a column vector)
00132   if( M_trans == NOTRANS || (M_trans == CONJ && !ST::isComplex) ) {
00133     // y = beta*y + alpha*m*x  (x is a scalar!)
00134 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00135     THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00136     *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::apply(...) : y = beta*y + alpha*m*x  (x is a scalar!)\n";
00137 #endif
00138     Vt_S( y, beta );
00139     Vp_StV( y, Scalar(alpha*get_ele(x,0)), *this );
00140   }
00141   else if( M_trans == CONJTRANS || (M_trans == TRANS && !ST::isComplex) ) {
00142     // y = beta*y + alpha*m'*x  (y is a scalar!)
00143 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00144     THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00145     *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::apply(...) : y = beta*y + alpha*m'*x  (y is a scalar!)\n";
00146 #endif
00147     Scalar y_inout;
00148     if( beta == ST::zero() ) {
00149       y_inout = ST::zero();
00150     }
00151     else {
00152       y_inout = beta*get_ele(*y,0);
00153     }
00154 #if defined(THYRA_VECTOR_VERBOSE_TO_ERROR_OUT) && defined(RTOPPACK_SPMD_APPLY_OP_DUMP)
00155     RTOpPack::show_spmd_apply_op_dump = true;
00156 #endif
00157 #if defined(THYRA_VECTOR_VERBOSE_TO_ERROR_OUT) && defined(RTOPPACK_RTOPT_HELPER_DUMP_OUTPUT)
00158     RTOpPack::rtop_helpers_dump_all = true;
00159 #endif
00160     y_inout += alpha*this->space()->scalarProd(*this,x);
00161 #if defined(THYRA_VECTOR_VERBOSE_TO_ERROR_OUT) && defined(RTOPPACK_SPMD_APPLY_OP_DUMP)
00162     RTOpPack::show_spmd_apply_op_dump = false;
00163 #endif
00164 #if defined(THYRA_VECTOR_VERBOSE_TO_ERROR_OUT) && defined(RTOPPACK_RTOPT_HELPER_DUMP_OUTPUT)
00165     RTOpPack::rtop_helpers_dump_all = false;
00166 #endif
00167     set_ele(0,y_inout,y);
00168 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00169     *dbgout
00170       << "\nThyra::VectorDefaultBase<"<<ST::name()<<">::apply(...) : y_inout = "
00171       << y_inout << "\n";
00172 #endif
00173   }
00174   else {
00175     TEST_FOR_EXCEPTION(
00176       true,std::logic_error
00177       ,"VectorBase<"<<ST::name()<<">::apply(M_trans,...): Error, M_trans="<<toString(M_trans)<<" not supported!"
00178       );
00179   }
00180 }
00181 
00182 // Overridden from MultiVectorBase
00183 
00184 template<class Scalar>
00185 inline
00186 void VectorDefaultBase<Scalar>::validateColRng( const Range1D &col_rng ) const
00187 {
00188 #ifdef TEUCHOS_DEBUG
00189   TEST_FOR_EXCEPT( !( col_rng.full_range() || ( col_rng.lbound() == 0 && col_rng.ubound() == 0) ) );
00190 #endif
00191 }
00192 
00193 template<class Scalar>
00194 inline
00195 void VectorDefaultBase<Scalar>::validateColIndexes(  const int numCols, const int cols[] ) const
00196 {
00197 #ifdef TEUCHOS_DEBUG
00198   TEST_FOR_EXCEPT( numCols != 1 || cols == NULL || cols[0] != 0 );
00199 #endif
00200 }
00201 
00202 template<class Scalar>
00203 Teuchos::RefCountPtr<VectorBase<Scalar> >
00204 VectorDefaultBase<Scalar>::col(Index j)
00205 {
00206 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00207   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00208   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::col(j) called!\n";
00209 #endif
00210 #ifdef TEUCHOS_DEBUG
00211   TEST_FOR_EXCEPT( j != 0 );
00212 #endif
00213   return Teuchos::rcp(this,false);
00214 }
00215 
00216 template<class Scalar>
00217 Teuchos::RefCountPtr<MultiVectorBase<Scalar> >
00218 VectorDefaultBase<Scalar>::clone_mv() const
00219 {
00220 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00221   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00222   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::clone_mv() called!\n";
00223 #endif
00224   return this->clone_v();
00225 }
00226 
00227 template<class Scalar>
00228 Teuchos::RefCountPtr<const MultiVectorBase<Scalar> >
00229 VectorDefaultBase<Scalar>::subView( const Range1D& col_rng ) const
00230 {
00231 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00232   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00233   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::subView(col_rng) const called!\n";
00234 #endif
00235   validateColRng(col_rng);
00236   return Teuchos::rcp(this,false);
00237 }
00238 
00239 template<class Scalar>
00240 Teuchos::RefCountPtr<MultiVectorBase<Scalar> >
00241 VectorDefaultBase<Scalar>::subView( const Range1D& col_rng )
00242 {
00243 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00244   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00245   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::subView(col_rng) called!\n";
00246 #endif
00247   validateColRng(col_rng);
00248   return Teuchos::rcp(this,false);
00249 }
00250 
00251 template<class Scalar>
00252 Teuchos::RefCountPtr<const MultiVectorBase<Scalar> >
00253 VectorDefaultBase<Scalar>::subView( const int numCols, const int cols[] ) const
00254 {
00255 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00256   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00257   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::subView(numCols,cols) const called!\n";
00258 #endif
00259   validateColIndexes(numCols,cols);
00260   return Teuchos::rcp(this,false);
00261 }
00262 
00263 template<class Scalar>
00264 Teuchos::RefCountPtr<MultiVectorBase<Scalar> >
00265 VectorDefaultBase<Scalar>::subView( const int numCols, const int cols[] )
00266 {
00267 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00268   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00269   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::subView(numCols,cols) called!\n";
00270 #endif
00271   validateColIndexes(numCols,cols);
00272   return Teuchos::rcp(this,false);
00273 }
00274 
00275 template<class Scalar>
00276 void VectorDefaultBase<Scalar>::acquireDetachedView(
00277   const Range1D                       &rowRng
00278   ,const Range1D                      &colRng
00279   ,RTOpPack::ConstSubMultiVectorView<Scalar>  *sub_mv
00280   ) const
00281 {
00282 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00283   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00284   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::acquireDetachedView() const called!\n";
00285 #endif
00286 #ifdef TEUCHOS_DEBUG
00287   TEST_FOR_EXCEPT(sub_mv==NULL);
00288 #endif
00289   validateColRng(colRng);
00290   RTOpPack::ConstSubVectorView<Scalar> sv;
00291   acquireDetachedView(rowRng,&sv);
00292 #ifdef TEUCHOS_DEBUG
00293   TEST_FOR_EXCEPT( sv.stride() != 1 ); // Can't handle non-unit stride yet but we could
00294 #endif
00295   sub_mv->initialize( sv.globalOffset(), sv.subDim(), 0, 1, sv.values(), sv.subDim() );
00296 }
00297 
00298 template<class Scalar>
00299 void VectorDefaultBase<Scalar>::releaseDetachedView( RTOpPack::ConstSubMultiVectorView<Scalar>* sub_mv ) const
00300 {
00301 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00302   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00303   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::releaseDetachedView() const called!\n";
00304 #endif
00305 #ifdef TEUCHOS_DEBUG
00306   TEST_FOR_EXCEPT(sub_mv==NULL);
00307 #endif
00308   RTOpPack::ConstSubVectorView<Scalar> sv(sub_mv->globalOffset(),sub_mv->subDim(),sub_mv->values(),1);
00309   releaseDetachedView(&sv);
00310   sub_mv->set_uninitialized();
00311 }
00312 
00313 template<class Scalar>
00314 void VectorDefaultBase<Scalar>::acquireDetachedView(
00315   const Range1D                                &rowRng
00316   ,const Range1D                               &colRng
00317   ,RTOpPack::SubMultiVectorView<Scalar>    *sub_mv
00318   )
00319 {
00320 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00321   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00322   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::acquireDetachedView() called!\n";
00323 #endif
00324 #ifdef TEUCHOS_DEBUG
00325   TEST_FOR_EXCEPT(sub_mv==NULL);
00326 #endif
00327   validateColRng(colRng);
00328   RTOpPack::SubVectorView<Scalar> sv;
00329   acquireDetachedView(rowRng,&sv);
00330 #ifdef TEUCHOS_DEBUG
00331   TEST_FOR_EXCEPT( sv.stride() != 1 ); // Can't handle non-unit stride yet but we could
00332 #endif
00333   sub_mv->initialize( sv.globalOffset(), sv.subDim(), 0, 1, sv.values(), sv.subDim() );
00334 }
00335 
00336 template<class Scalar>
00337 void VectorDefaultBase<Scalar>::commitDetachedView( RTOpPack::SubMultiVectorView<Scalar>* sub_mv )
00338 {
00339 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00340   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00341   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::commitDetachedView() called!\n";
00342 #endif
00343 #ifdef TEUCHOS_DEBUG
00344   TEST_FOR_EXCEPT(sub_mv==NULL);
00345 #endif
00346   RTOpPack::SubVectorView<Scalar> sv(sub_mv->globalOffset(),sub_mv->subDim(),sub_mv->values(),1);
00347   commitDetachedView(&sv);
00348   sub_mv->set_uninitialized();
00349 }
00350 
00351 // Overridden from VectorBase
00352 
00353 template<class Scalar>
00354 Teuchos::RefCountPtr<VectorBase<Scalar> >
00355 VectorDefaultBase<Scalar>::clone_v() const
00356 {
00357 #ifdef THYRA_VECTOR_VERBOSE_TO_ERROR_OUT
00358   THYRA_VECTOR_VERBOSE_OUT_STATEMENT;
00359   *dbgout << "\nThyra::VectorDefaultBase<"<<Teuchos::ScalarTraits<Scalar>::name()<<">::clone_v() called!\n";
00360 #endif
00361   Teuchos::RefCountPtr<VectorBase<Scalar> > copy = createMember(this->space());
00362   assign( &*copy, *this );
00363   return copy;
00364 }
00365 
00366 template<class Scalar>
00367 void VectorDefaultBase<Scalar>::acquireDetachedView( const Range1D& rng_in, RTOpPack::ConstSubVectorView<Scalar>* sub_vec_inout ) const
00368 {
00369   using Teuchos::dyn_cast;
00370   const Range1D rng = rng_in.full_range() ? Range1D(0,this->space()->dim()-1) : rng_in;
00371 #ifdef TEUCHOS_DEBUG
00372   TEST_FOR_EXCEPTION(
00373     !(rng.ubound() < this->space()->dim()), std::out_of_range
00374     ,"VectorDefaultBase<Scalar>::acquireDetachedView(rng,...): Error, rng = ["<<rng.lbound()<<","<<rng.ubound()
00375     <<"] is not in range = [0,"<<(this->space()->dim()-1)<<"]" );
00376 #endif
00377   // Free sub_vec if needed (note this is dependent on the implementation of this operator class!)
00378   if( sub_vec_inout->values() ) {
00379     free( (void*)sub_vec_inout->values()  );
00380   }
00381   // Initialize the operator
00382   RTOpPack::ROpGetSubVector<Scalar> get_sub_vector_op(rng.lbound(),rng.ubound());
00383   // Create the reduction object (another sub_vec)
00384   Teuchos::RefCountPtr<RTOpPack::ReductTarget>
00385     reduct_obj = get_sub_vector_op.reduct_obj_create(); // This is really of type RTOpPack::ConstSubVectorView<Scalar>!
00386   // Perform the reduction (get the sub-vector requested)
00387   const VectorBase<Scalar>* sub_vecs[] = { this };
00388   ::Thyra::applyOp<Scalar>(
00389     get_sub_vector_op,1,sub_vecs,0,NULL,&*reduct_obj
00390     ,rng.lbound(),rng.size(),rng.lbound() // first_ele_offset,sub_dim,global_offset
00391     );
00392   // Get the sub-vector.  Note reduct_obj will go out of scope so the sub_vec parameter will
00393   // own the memory allocated within get_sub_vector_op.create_reduct_obj_raw(...).  This is okay
00394   // since the client is required to call release_sub_vector(...) so release memory!
00395   RTOpPack::ReductTargetSubVectorT<Scalar> &sub_vec_ro = get_sub_vector_op(*reduct_obj);
00396   sub_vec_ro.transfer(sub_vec_inout);
00397 }
00398 
00399 template<class Scalar>
00400 void VectorDefaultBase<Scalar>::releaseDetachedView( RTOpPack::ConstSubVectorView<Scalar>* sub_vec ) const
00401 {
00402   // Free sub_vec if needed (note this is dependent on the implementation of this operator class!)
00403   RTOpPack::ReductTargetSubVectorT<Scalar>::free(sub_vec);
00404 }
00405 
00406 template<class Scalar>
00407 void VectorDefaultBase<Scalar>::acquireDetachedView( const Range1D& rng, RTOpPack::SubVectorView<Scalar>* sub_vec_inout )
00408 {
00409   //
00410   // Here we get a copy of the data for the sub-vector that the
00411   // client will modify.  We must later commit these changes to the
00412   // actual vector when the client calls commitDetachedView(...).
00413   // Note, this implementation is very dependent on the behavior of
00414   // the default implementation of constant version of
00415   // VectorDefaultBase<Scalar>::acquireDetachedView(...) and the implementation of
00416   // VectorDefaultBase<Scalar>::setSubVector(...)!
00417   //
00418   RTOpPack::ConstSubVectorView<Scalar> sub_vec;
00419   VectorDefaultBase<Scalar>::acquireDetachedView( rng, &sub_vec );
00420   sub_vec_inout->initialize(
00421     sub_vec.globalOffset(),sub_vec.subDim(),const_cast<Scalar*>(sub_vec.values()),sub_vec.stride());
00422 }
00423 
00424 template<class Scalar>
00425 void VectorDefaultBase<Scalar>::commitDetachedView( RTOpPack::SubVectorView<Scalar>* sub_vec_inout )
00426 {
00427   RTOpPack::SparseSubVectorT<Scalar> spc_sub_vec(
00428     sub_vec_inout->globalOffset(), sub_vec_inout->subDim()
00429     ,sub_vec_inout->values(), sub_vec_inout->stride()
00430     );
00431   VectorDefaultBase<Scalar>::setSubVector( spc_sub_vec );       // Commit the changes!
00432   RTOpPack::ConstSubVectorView<Scalar> sub_vec(*sub_vec_inout);
00433   VectorDefaultBase<Scalar>::releaseDetachedView( &sub_vec );         // Free the memory!
00434   sub_vec_inout->set_uninitialized();                    // Make null as promised!
00435 }
00436 
00437 template<class Scalar>
00438 void VectorDefaultBase<Scalar>::setSubVector( const RTOpPack::SparseSubVectorT<Scalar>& sub_vec )
00439 {
00440   RTOpPack::TOpSetSubVector<Scalar> set_sub_vector_op(sub_vec);
00441   VectorBase<Scalar>* targ_vecs[1] = { this };
00442   ::Thyra::applyOp<Scalar>(
00443     set_sub_vector_op,0,NULL,1,targ_vecs,NULL
00444     ,sub_vec.globalOffset(),sub_vec.subDim(),sub_vec.globalOffset() // first_ele_offset,sub_dim,global_offset
00445     );
00446 }
00447 
00448 } // end namespace Thyra
00449 
00450 #endif  // THYRA_VECTOR_DEFAULT_BASE_HPP

Generated on Thu Sep 18 12:33:03 2008 for Thyra Package Browser (Single Doxygen Collection) by doxygen 1.3.9.1