Epetra Package Browser (Single Doxygen Collection) Development
Loading...
Searching...
No Matches
Epetra_FEVector.cpp
Go to the documentation of this file.
1
2//@HEADER
3// ************************************************************************
4//
5// Epetra: Linear Algebra Services Package
6// Copyright 2011 Sandia Corporation
7//
8// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9// the U.S. Government retains certain rights in this software.
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17//
18// 2. Redistributions in binary form must reproduce the above copyright
19// notice, this list of conditions and the following disclaimer in the
20// documentation and/or other materials provided with the distribution.
21//
22// 3. Neither the name of the Corporation nor the names of the
23// contributors may be used to endorse or promote products derived from
24// this software without specific prior written permission.
25//
26// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37//
38// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
39//
40// ************************************************************************
41//@HEADER
42
43#include <Epetra_ConfigDefs.h>
44#include <Epetra_FEVector.h>
45
46#include <Epetra_LocalMap.h>
47#include <Epetra_Comm.h>
48#include <Epetra_Map.h>
49#include <Epetra_Import.h>
50#include <Epetra_Export.h>
51#include <Epetra_Util.h>
54
55#include <algorithm>
56
57//----------------------------------------------------------------------------
59 int numVectors,
60 bool ignoreNonLocalEntries)
61 : Epetra_MultiVector(map, numVectors),
62 myFirstID_(0),
63 myNumIDs_(0),
64#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
65 nonlocalIDs_int_(),
66#endif
67#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
68 nonlocalIDs_LL_(),
69#endif
70 nonlocalElementSize_(),
71 nonlocalCoefs_(),
72 nonlocalMap_(0),
73 exporter_(0),
74 nonlocalVector_(0),
75 ignoreNonLocalEntries_(ignoreNonLocalEntries)
76{
77 myFirstID_ = map.MinMyGID64();
79 nonlocalCoefs_.resize(numVectors);
80}
81
82//----------------------------------------------------------------------------
84 double *A, int MyLDA, int theNumVectors,
85 bool ignoreNonLocalEntries)
86 : Epetra_MultiVector(CV, theMap, A, MyLDA, theNumVectors),
87 myFirstID_(0),
88 myNumIDs_(0),
89#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
90 nonlocalIDs_int_(),
91#endif
92#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
93 nonlocalIDs_LL_(),
94#endif
95 nonlocalElementSize_(),
96 nonlocalCoefs_(),
97 nonlocalMap_(0),
98 exporter_(0),
99 nonlocalVector_(0),
100 ignoreNonLocalEntries_(ignoreNonLocalEntries)
101{
102 myFirstID_ = theMap.MinMyGID64();
103 myNumIDs_ = theMap.NumMyElements();
104 nonlocalCoefs_.resize(theNumVectors);
105}
106
107//----------------------------------------------------------------------------
109 double **ArrayOfPointers, int theNumVectors,
110 bool ignoreNonLocalEntries)
111 : Epetra_MultiVector(CV, theMap, ArrayOfPointers, theNumVectors),
112 myFirstID_(0),
113 myNumIDs_(0),
114#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
115 nonlocalIDs_int_(),
116#endif
117#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
118 nonlocalIDs_LL_(),
119#endif
120 nonlocalElementSize_(),
121 nonlocalCoefs_(),
122 nonlocalMap_(0),
123 exporter_(0),
124 nonlocalVector_(0),
125 ignoreNonLocalEntries_(ignoreNonLocalEntries)
126{
127 myFirstID_ = theMap.MinMyGID64();
128 myNumIDs_ = theMap.NumMyElements();
129 nonlocalCoefs_.resize(theNumVectors);
130}
131
132//----------------------------------------------------------------------------
134 : Epetra_MultiVector(source),
135 myFirstID_(0),
136 myNumIDs_(0),
137#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
138 nonlocalIDs_int_(),
139#endif
140#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
141 nonlocalIDs_LL_(),
142#endif
143 nonlocalElementSize_(),
144 nonlocalCoefs_(),
145 nonlocalMap_(0),
146 exporter_(0),
147 nonlocalVector_(0),
148 ignoreNonLocalEntries_(source.ignoreNonLocalEntries_)
149{
150 *this = source;
151}
152
153//----------------------------------------------------------------------------
161
162//----------------------------------------------------------------------------
163#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
164int Epetra_FEVector::SumIntoGlobalValues(int numIDs, const int* GIDs,
165 const double* values,
166 int vectorIndex)
167{
168 return( inputValues( numIDs, GIDs, values, true, vectorIndex) );
169}
170#endif
171#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
172int Epetra_FEVector::SumIntoGlobalValues(int numIDs, const long long* GIDs,
173 const double* values,
174 int vectorIndex)
175{
176 return( inputValues( numIDs, GIDs, values, true, vectorIndex) );
177}
178#endif
179//----------------------------------------------------------------------------
180#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
182 const Epetra_SerialDenseVector& values,
183 int vectorIndex)
184{
185 if (GIDs.Length() != values.Length()) {
186 return(-1);
187 }
188
189 return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), true,
190 vectorIndex ) );
191}
192#endif
193#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
195 const Epetra_SerialDenseVector& values,
196 int vectorIndex)
197{
198 if (GIDs.Length() != values.Length()) {
199 return(-1);
200 }
201
202 return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), true,
203 vectorIndex ) );
204}
205#endif
206//----------------------------------------------------------------------------
207#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
208int Epetra_FEVector::SumIntoGlobalValues(int numIDs, const int* GIDs,
209 const int* numValuesPerID,
210 const double* values,
211 int vectorIndex)
212{
213 return( inputValues( numIDs, GIDs, numValuesPerID, values, true,
214 vectorIndex) );
215}
216#endif
217#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
218int Epetra_FEVector::SumIntoGlobalValues(int numIDs, const long long* GIDs,
219 const int* numValuesPerID,
220 const double* values,
221 int vectorIndex)
222{
223 return( inputValues( numIDs, GIDs, numValuesPerID, values, true,
224 vectorIndex) );
225}
226#endif
227//----------------------------------------------------------------------------
228#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
229int Epetra_FEVector::ReplaceGlobalValues(int numIDs, const int* GIDs,
230 const double* values,
231 int vectorIndex)
232{
233 return( inputValues( numIDs, GIDs, values, false,
234 vectorIndex) );
235}
236#endif
237#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
238int Epetra_FEVector::ReplaceGlobalValues(int numIDs, const long long* GIDs,
239 const double* values,
240 int vectorIndex)
241{
242 return( inputValues( numIDs, GIDs, values, false,
243 vectorIndex) );
244}
245#endif
246//----------------------------------------------------------------------------
247#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
249 const Epetra_SerialDenseVector& values,
250 int vectorIndex)
251{
252 if (GIDs.Length() != values.Length()) {
253 return(-1);
254 }
255
256 return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), false,
257 vectorIndex) );
258}
259#endif
260#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
262 const Epetra_SerialDenseVector& values,
263 int vectorIndex)
264{
265 if (GIDs.Length() != values.Length()) {
266 return(-1);
267 }
268
269 return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), false,
270 vectorIndex) );
271}
272#endif
273//----------------------------------------------------------------------------
274template<typename int_type>
276 const int_type* GIDs,
277 const double* values,
278 bool suminto,
279 int vectorIndex)
280{
281 //Important note!! This method assumes that there is only 1 point
282 //associated with each element (GID), and writes to offset 0 in that
283 //GID's block.
284
285 for(int i=0; i<numIDs; ++i) {
286 if (Map().MyGID(GIDs[i])) {
287 if (suminto) {
288 SumIntoGlobalValue(GIDs[i], 0, vectorIndex, values[i]);
289 }
290 else {
291 ReplaceGlobalValue(GIDs[i], 0, vectorIndex, values[i]);
292 }
293 }
294 else {
296 EPETRA_CHK_ERR( inputNonlocalValue(GIDs[i], values[i], suminto,
297 vectorIndex) );
298 }
299 }
300 }
301
302 return(0);
303}
304
305//----------------------------------------------------------------------------
306#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
307int Epetra_FEVector::ReplaceGlobalValues(int numIDs, const int* GIDs,
308 const int* numValuesPerID,
309 const double* values,
310 int vectorIndex)
311{
312 return( inputValues( numIDs, GIDs, numValuesPerID, values, false,
313 vectorIndex) );
314}
315#endif
316#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
317int Epetra_FEVector::ReplaceGlobalValues(int numIDs, const long long* GIDs,
318 const int* numValuesPerID,
319 const double* values,
320 int vectorIndex)
321{
322 return( inputValues( numIDs, GIDs, numValuesPerID, values, false,
323 vectorIndex) );
324}
325#endif
326//----------------------------------------------------------------------------
327template<typename int_type>
329 const int_type* GIDs,
330 const int* numValuesPerID,
331 const double* values,
332 bool suminto,
333 int vectorIndex)
334{
335 if(!Map().template GlobalIndicesIsType<int_type>())
336 throw ReportError("Epetra_FEVector::inputValues mismatch between argument types (int/long long) and map type.", -1);
337
338 int offset=0;
339 for(int i=0; i<numIDs; ++i) {
340 int numValues = numValuesPerID[i];
341 if (Map().MyGID(GIDs[i])) {
342 if (suminto) {
343 for(int j=0; j<numValues; ++j) {
344 SumIntoGlobalValue(GIDs[i], j, vectorIndex, values[offset+j]);
345 }
346 }
347 else {
348 for(int j=0; j<numValues; ++j) {
349 ReplaceGlobalValue(GIDs[i], j, vectorIndex, values[offset+j]);
350 }
351 }
352 }
353 else {
355 EPETRA_CHK_ERR( inputNonlocalValues(GIDs[i], numValues,
356 &(values[offset]), suminto,
357 vectorIndex) );
358 }
359 }
360 offset += numValues;
361 }
362
363 return(0);
364}
365
366//----------------------------------------------------------------------------
367template<typename int_type>
368int Epetra_FEVector::inputNonlocalValue(int_type GID, double value, bool suminto,
369 int vectorIndex)
370{
371 return inputNonlocalValues(GID, 1, &value, suminto, vectorIndex);
372}
373
374//----------------------------------------------------------------------------
375template<typename int_type>
376int Epetra_FEVector::inputNonlocalValues(int_type GID, int numValues,
377 const double* values, bool suminto,
378 int vectorIndex)
379{
380 if(!Map().template GlobalIndicesIsType<int_type>())
381 throw ReportError("Epetra_FEVector::inputValues mismatch between argument types (int/long long) and map type.", -1);
382
383
384 //find offset of GID in nonlocalIDs_var
385
386 std::vector<int_type>& nonlocalIDs_var = nonlocalIDs<int_type>();
387
388 typename std::vector<int_type>::iterator it = std::lower_bound(nonlocalIDs_var.begin(), nonlocalIDs_var.end(), GID);
389 int offset = (int) (it - nonlocalIDs_var.begin());
390 int insertPoint = offset;
391 if (it == nonlocalIDs_var.end() || *it != GID) {
392 offset = -1;
393 }
394
395 int elemSize = Map().MaxElementSize();
396 if (offset >= 0) {
397 //if offset >= 0 (meaning GID was found)
398 // put value in nonlocalCoefs_[vectorIndex][offset*elemSize]
399
400 if (numValues != nonlocalElementSize_[offset]) {
401 std::cerr << "Epetra_FEVector ERROR: block-size for GID " << GID << " is "
402 << numValues<<" which doesn't match previously set block-size of "
403 << nonlocalElementSize_[offset] << std::endl;
404 return(-1);
405 }
406
407 offset = offset*elemSize;
408
409 if (suminto) {
410 for(int j=0; j<numValues; ++j) {
411 nonlocalCoefs_[vectorIndex][offset+j] += values[j];
412 }
413 }
414 else {
415 for(int j=0; j<numValues; ++j) {
416 nonlocalCoefs_[vectorIndex][offset+j] = values[j];
417 }
418 }
419 }
420 else {
421 //else
422 // insert GID in nonlocalIDs_
423 // insert numValues in nonlocalElementSize_
424 // insert values in nonlocalCoefs_
425
426 nonlocalIDs_var.insert(it, GID);
427 nonlocalElementSize_.insert(nonlocalElementSize_.begin()+insertPoint, numValues);
428
429 //to keep nonlocalCoefs_[i] the same length for each vector in the multi-
430 //vector, we'll insert positions for each vector even though values are
431 //only being set for one of them...
432 for(int i=0; i<NumVectors(); ++i) {
433 for(int ii=0; ii<elemSize; ++ii) {
434 nonlocalCoefs_[i].insert(nonlocalCoefs_[i].begin()+insertPoint*elemSize+ii, 0.0);
435 }
436 }
437
438 for(int j=0; j<numValues; ++j) {
439 nonlocalCoefs_[vectorIndex][insertPoint*elemSize+j] = values[j];
440 }
441 }
442
443 return(0);
444}
445
446//----------------------------------------------------------------------------
447template<typename int_type>
449 bool reuse_map_and_exporter)
450{
451 //In this method we need to gather all the non-local (overlapping) data
452 //that's been input on each processor, into the (probably) non-overlapping
453 //distribution defined by the map that 'this' vector was constructed with.
454
455 //We don't need to do anything if there's only one processor or if
456 //ignoreNonLocalEntries_ is true.
457 if (Map().Comm().NumProc() < 2 || ignoreNonLocalEntries_) {
458 return(0);
459 }
460
461 if (nonlocalMap_ == 0 || !reuse_map_and_exporter) {
462 createNonlocalMapAndExporter<int_type>();
463 }
464
465 Epetra_MultiVector& nonlocalVector = *nonlocalVector_;
466 nonlocalVector.PutScalar(0.0);
467
468 int elemSize = Map().MaxElementSize();
469 for(int vi=0; vi<NumVectors(); ++vi) {
470 for(size_t i=0; i<nonlocalIDs<int_type>().size(); ++i) {
471 for(int j=0; j<nonlocalElementSize_[i]; ++j) {
472 nonlocalVector.ReplaceGlobalValue(nonlocalIDs<int_type>()[i], j, vi,
473 nonlocalCoefs_[vi][i*elemSize+j]);
474 }
475 }
476 }
477
478 EPETRA_CHK_ERR( Export(nonlocalVector, *exporter_, mode) );
479
480 if (reuse_map_and_exporter) {
481 zeroNonlocalData<int_type>();
482 }
483 else {
485 }
486
487 return(0);
488}
489
491 bool reuse_map_and_exporter)
492{
493 if(Map().GlobalIndicesInt())
494#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
495 return GlobalAssemble<int>(mode, reuse_map_and_exporter);
496#else
497 throw ReportError("Epetra_FEVector::GlobalAssemble: ERROR, GlobalIndicesInt but no API for it.",-1);
498#endif
499
500 if(Map().GlobalIndicesLongLong())
501#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
502 return GlobalAssemble<long long>(mode, reuse_map_and_exporter);
503#else
504 throw ReportError("Epetra_FEVector::GlobalAssemble: ERROR, GlobalIndicesLongLong but no API for it.",-1);
505#endif
506
507 throw ReportError("Epetra_FEVector::GlobalAssemble: Internal error, unable to determine global index type of maps", -1);
508}
509//----------------------------------------------------------------------------
510template<typename int_type>
512{
513 std::vector<int_type>& nonlocalIDs_var = nonlocalIDs<int_type>();
514 delete nonlocalMap_;
515 int_type* nlIDptr = Epetra_Util_data_ptr(nonlocalIDs_var);
517 nonlocalMap_ = new Epetra_BlockMap ((int_type) -1, (int) nonlocalIDs_var.size(), nlIDptr,
518 nlElSzptr, (int_type) Map().IndexBase64(), Map().Comm());
519 delete exporter_;
521
522 delete nonlocalVector_;
524}
525
526//----------------------------------------------------------------------------
533
534//----------------------------------------------------------------------------
536{
537 if (this == &source) {
538 // Don't allow self-assignment, since the allocations and
539 // deallocations in the code below assume that source is a
540 // different object than *this.
541 return *this;
542 }
543 // This redundantly checks for self-assignment, but the check is
544 // inexpensive (just a pointer comparison).
546
547#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
549#endif
550#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
552#endif
555
556 return(*this);
557}
558
559//----------------------------------------------------------------------------
560template<typename int_type>
562{
563 if (nonlocalIDs<int_type>().size() > 0) {
564 int maxelemSize = Map().MaxElementSize();
565 for(int vi=0; vi<NumVectors(); ++vi) {
566 for(size_t i=0; i<nonlocalIDs<int_type>().size(); ++i) {
567 int elemSize = nonlocalElementSize_[i];
568 for(int j=0; j<elemSize; ++j) {
569 nonlocalCoefs_[vi][i*maxelemSize+j] = 0.0;
570 }
571 }
572 }
573 }
574}
575
576//----------------------------------------------------------------------------
578{
579#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
580 nonlocalIDs_int_.clear();
581#endif
582#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
583 nonlocalIDs_LL_.clear();
584#endif
585 nonlocalElementSize_.clear();
586
587 if (nonlocalCoefs_.size() > 0) {
588 for(int i=0; i<NumVectors(); ++i) {
589 nonlocalCoefs_[i].clear();
590 }
591 }
592}
593
Epetra_CombineMode
#define EPETRA_CHK_ERR(a)
Epetra_DataAccess
T * Epetra_Util_data_ptr(std::vector< T > &vec)
Function that returns either a pointer to the first entry in the vector or, if the vector is empty,...
Epetra_BlockMap: A class for partitioning block element vectors and matrices.
int MaxElementSize() const
Maximum element size across all processors.
long long MinMyGID64() const
int NumMyElements() const
Number of elements on the calling processor.
const Epetra_BlockMap & Map() const
Returns the address of the Epetra_BlockMap for this multi-vector.
int Export(const Epetra_SrcDistObject &A, const Epetra_Import &Importer, Epetra_CombineMode CombineMode, const Epetra_OffsetIndex *Indexor=0)
Exports an Epetra_DistObject using the Epetra_Import object.
const Epetra_Comm & Comm() const
Returns the address of the Epetra_Comm for this multi-vector.
Epetra_Export: This class builds an export object for efficient exporting of off-processor elements.
Epetra Finite-Element Vector.
int SumIntoGlobalValues(int numIDs, const int *GIDs, const double *values, int vectorIndex=0)
Accumulate values into the vector, adding them to any values that already exist for the specified ind...
Epetra_BlockMap * nonlocalMap_
Map describing distribution of nonlocal data.
void destroyNonlocalData()
Deallocate storage for nonlocal data.
int inputNonlocalValues(int_type GID, int numValues, const double *values, bool suminto, int vectorIndex)
std::vector< int > nonlocalElementSize_
Epetra_MultiVector * nonlocalVector_
Multivector that holds nonlocal data; source for the Export operation.
Epetra_FEVector(const Epetra_BlockMap &Map, int numVectors=1, bool ignoreNonLocalEntries=false)
Constructor that requires a map specifying a non-overlapping data layout.
void destroyNonlocalMapAndExporter()
Deallocate the Map, Export object, and MultiVector for nonlocal data.
std::vector< std::vector< double > > nonlocalCoefs_
Array of arrays (one per column) of nonlocal coefficients.
Epetra_Export * exporter_
Export object that sums nonlocal data into a nonoverlapping distribution.
virtual ~Epetra_FEVector()
Destructor.
Epetra_FEVector & operator=(const Epetra_FEVector &source)
std::vector< long long > nonlocalIDs_LL_
int GlobalAssemble(Epetra_CombineMode mode=Add, bool reuse_map_and_exporter=false)
Gather any overlapping/shared data into the non-overlapping partitioning defined by the Map that was ...
int inputNonlocalValue(int_type GID, double value, bool suminto, int vectorIndex)
void createNonlocalMapAndExporter()
Allocate the Map, Export object, and MultiVector for nonlocal data.
int ReplaceGlobalValues(int numIDs, const int *GIDs, const double *values, int vectorIndex=0)
Copy values into the vector overwriting any values that already exist for the specified indices.
std::vector< int > nonlocalIDs_int_
void zeroNonlocalData()
Make all the nonlocal multivector entries zero.
int inputValues(int numIDs, const int_type *GIDs, const double *values, bool suminto, int vectorIndex)
Epetra_IntSerialDenseVector: A class for constructing and using dense vectors.
int Length() const
Returns length of vector.
int * Values()
Returns pointer to the values in vector.
Epetra_LongLongSerialDenseVector: A class for constructing and using dense vectors.
int Length() const
Returns length of vector.
long long * Values()
Returns pointer to the values in vector.
Epetra_MultiVector: A class for constructing and using dense multi-vectors, vectors and matrices in p...
int NumVectors() const
Returns the number of vectors in the multi-vector.
int SumIntoGlobalValue(int GlobalRow, int VectorIndex, double ScalarValue)
Adds ScalarValue to existing value at the specified (GlobalRow, VectorIndex) location.
int ReplaceGlobalValue(int GlobalRow, int VectorIndex, double ScalarValue)
Replace current value at the specified (GlobalRow, VectorIndex) location with ScalarValue.
void Assign(const Epetra_MultiVector &rhs)
int PutScalar(double ScalarConstant)
Initialize all values in a multi-vector with constant value.
Epetra_MultiVector(const Epetra_BlockMap &Map, int NumVectors, bool zeroOut=true)
Basic Epetra_MultiVector constuctor.
virtual int ReportError(const std::string Message, int ErrorCode) const
Error reporting method.
Epetra_SerialDenseVector: A class for constructing and using dense vectors.
double * Values() const
Returns pointer to the values in vector.
int Length() const
Returns length of vector.