FEI Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
snl_fei_Broker_LinSysCore.hpp
Go to the documentation of this file.
1/*--------------------------------------------------------------------*/
2/* Copyright 2005 Sandia Corporation. */
3/* Under the terms of Contract DE-AC04-94AL85000, there is a */
4/* non-exclusive license for use of this work by or on behalf */
5/* of the U.S. Government. Export of this program may require */
6/* a license from the United States Government. */
7/*--------------------------------------------------------------------*/
8
9#ifndef _snl_fei_Broker_LinSysCore_hpp_
10#define _snl_fei_Broker_LinSysCore_hpp_
11
12#include <fei_macros.hpp>
13#include <fei_mpi.h>
14#include <fei_CommUtils.hpp>
15#include <snl_fei_Broker.hpp>
17#include <fei_VectorSpace.hpp>
18#include <fei_Lookup_Impl.hpp>
19#include <fei_MatrixGraph.hpp>
21#include <fei_Vector_Impl.hpp>
22#include <fei_Matrix_Impl.hpp>
23#include <fei_MatrixReducer.hpp>
24#include <fei_VectorReducer.hpp>
25#include <fei_Reducer.hpp>
27
28#undef fei_file
29#define fei_file "snl_fei_Broker_LinSysCore.hpp"
30#include <fei_ErrMacros.hpp>
31
32namespace snl_fei {
33
38 public:
43 bool blockMatrix);
44
46 virtual ~Broker_LinSysCore();
47
57 fei::SharedPtr<fei::Vector> createVector(bool isSolutionVector=false)
58 {
60 if (matrixGraph_.get() == NULL) return(vptr);
61 if (setGlobalOffsets() != 0) return(vptr);
62
67 isSolutionVector));
68
70 if (reducer_.get() != NULL) {
71 vec.reset(new fei::VectorReducer(reducer_, tmpvec, isSolutionVector));
72 }
73 else {
74 vec = tmpvec;
75 }
76
77 return(vec);
78 }
79
83 {
85 if (matrixGraph_.get() == NULL) return(mptr);
86
87 if (setMatrixStructure() != 0) return(mptr);
88
89 bool zeroSharedRows = true;
90 if (reducer_.get() != NULL) {
91 zeroSharedRows = false;
92 }
93
96 numLocalEqns_, zeroSharedRows));
98 if (reducer_.get() != NULL) {
99 matptr.reset(new fei::MatrixReducer(reducer_, tmpmat));
100 }
101 else {
102 matptr = tmpmat;
103 }
104
105 return(matptr);
106 }
107
111 {
113 if (matrixGraph_.get() == NULL) return(lsptr);
114
115 if (setMatrixStructure() != 0) return(lsptr);
116
119 return(linSys);
120 }
121
124 { matrixGraph_ = matrixGraph; }
125
126 private:
128 {
129 //only set the global offsets once.
130 if (setGlobalOffsets_) return(0);
131
132 if (matrixGraph_.get() == NULL) return(-1);
133
135 int num_procs = fei::numProcs(comm);
136 int local_proc = fei::localProc(comm);
137
138 std::vector<int> globalOffsets;
139 std::vector<int> globalBlkOffsets;
140
141 if (reducer_.get() != NULL) {
142 int localsize = reducer_->getLocalReducedEqns().size();
143 numLocalEqns_ = localsize;
144 std::vector<int> lsizes(num_procs, 0);
145 std::vector<int> gsizes(num_procs, 0);
146 lsizes[local_proc] = localsize;
147 fei::GlobalMax(comm, lsizes, gsizes);
148 globalOffsets.resize(num_procs+1);
149 int offset = 0;
150 for(int p=0; p<num_procs; ++p) {
151 globalOffsets[p] = offset;
152 offset += gsizes[p];
153 }
154 globalOffsets[num_procs] = offset;
155 globalBlkOffsets = globalOffsets;
156 }
157 else {
160
161 vecSpace->getGlobalIndexOffsets(globalOffsets);
162 vecSpace->getGlobalBlkIndexOffsets(globalBlkOffsets);
163
164 numLocalEqns_ = globalOffsets[local_proc+1]-globalOffsets[local_proc];
165 }
166
168 &globalBlkOffsets[0],
169 &globalOffsets[0],
170 &globalBlkOffsets[0]));
171
172 setGlobalOffsets_ = true;
173 return(0);
174 }
175
177 {
178 //only set the matrix matrixGraph once.
179 if (setMatrixStructure_) return(0);
180
181 if (matrixGraph_.get() == NULL) return(-1);
182
184
186
188
190
193
194 std::vector<int>& rowNumbers = localSRGraph->rowNumbers;
195 int numLocalRows = rowNumbers.size();
196 int* rowOffsets = &(localSRGraph->rowOffsets[0]);
197 int numLocalNonzeros = localSRGraph->packedColumnIndices.size();
198 int* nonzeros = &(localSRGraph->packedColumnIndices[0]);
199
200 int numGlobalNonzeros = 0;
201 fei::GlobalSum(comm, numLocalNonzeros, numGlobalNonzeros);
202
203 std::vector<int*> colPtrs(numLocalRows);
204 std::vector<int> ptRowsPerBlkRow(numLocalRows, 1);
205 std::vector<int> rowLengths(numLocalRows);
206 int* rowLengthsPtr = &rowLengths[0];
207
208 for(int i=0; i<numLocalRows; ++i) {
209 colPtrs[i] = &(nonzeros[rowOffsets[i]]);
210 rowLengthsPtr[i] = rowOffsets[i+1]-rowOffsets[i];
211 if (blockMatrix_ == true) {
212 ptRowsPerBlkRow[i] = lookup_->getBlkEqnSize(rowNumbers[i]);
213 }
214 }
215
217 rowLengthsPtr,
218 &colPtrs[0],
219 rowLengthsPtr,
220 &ptRowsPerBlkRow[0]));
221
222 setMatrixStructure_ = true;
223
224 return(0);
225 }
226
227
232
237 };//class Broker_LinSysCore
238}//namespace snl_fei
239
240#endif // _snl_fei_Broker_LinSysCore_hpp_
virtual int setLookup(Lookup &lookup)=0
virtual int setGlobalOffsets(int len, int *nodeOffsets, int *eqnOffsets, int *blkEqnOffsets)=0
virtual int setMatrixStructure(int **ptColIndices, int *ptRrowLengths, int **blkColIndices, int *blkRowLengths, int *ptRowsPerBlkRow)=0
virtual int getBlkEqnSize(int blkEqn)=0
virtual fei::SharedPtr< fei::SparseRowGraph > createGraph(bool blockEntryGraph, bool localRowGraph_includeSharedRows=false)=0
virtual fei::SharedPtr< fei::VectorSpace > getRowSpace()=0
std::vector< int > & getLocalReducedEqns()
void reset(T *p=0)
T * get() const
MPI_Comm getCommunicator() const
fei::SharedPtr< fei::LinearSystem > createLinearSystem()
fei::SharedPtr< fei::Vector > createVector(bool isSolutionVector=false)
fei::SharedPtr< fei::Matrix > createMatrix()
fei::SharedPtr< fei::Reducer > reducer_
fei::SharedPtr< LinearSystemCore > linsyscore_
fei::SharedPtr< fei::MatrixGraph > matrixGraph_
void setMatrixGraph(fei::SharedPtr< fei::MatrixGraph > matrixGraph)
#define CHK_ERR(a)
#define MPI_Comm
Definition: fei_mpi.h:56
int localProc(MPI_Comm comm)
int GlobalMax(MPI_Comm comm, std::vector< T > &local, std::vector< T > &global)
int numProcs(MPI_Comm comm)
int GlobalSum(MPI_Comm comm, std::vector< T > &local, std::vector< T > &global)