FEI Version of the Day
Loading...
Searching...
No Matches
fei_Filter.hpp
1#ifndef _Filter_hpp_
2#define _Filter_hpp_
3
4/*--------------------------------------------------------------------*/
5/* Copyright 2005 Sandia Corporation. */
6/* Under the terms of Contract DE-AC04-94AL85000, there is a */
7/* non-exclusive license for use of this work by or on behalf */
8/* of the U.S. Government. Export of this program may require */
9/* a license from the United States Government. */
10/*--------------------------------------------------------------------*/
11
12#include <fei_fwd.hpp>
13#include <fei_defs.h>
14#include <fei_macros.hpp>
15#include <fei_iostream.hpp>
16
27class Filter {
28
29 public:
31 Filter(SNL_FEI_Structure* probStruct);
32
34 virtual ~Filter();
35
36 virtual int initialize() = 0;
37
38 // set a value (usually zeros) throughout the linear system
39 virtual int resetSystem(double s) = 0;
40 virtual int resetMatrix(double s) = 0;
41 virtual int resetRHSVector(double s) = 0;
42 virtual int resetInitialGuess(double s) = 0;
43
44 virtual int deleteMultCRs() = 0;
45
46 virtual int loadNodeBCs(int /*numNodes*/,
47 const GlobalID* /*nodeIDs*/,
48 int /*fieldID*/,
49 const int* /*offsetsIntoField*/,
50 const double* /*prescribedValues*/)
51 {
52 fei::console_out() << "fei ERROR, Filter::loadNodeBCs not overridden."<<FEI_ENDL;
53 return -1;
54 }
55
56 virtual int loadElemBCs(int numElems,
57 const GlobalID *elemIDs,
58 int fieldID,
59 const double *const *alpha,
60 const double *const *beta,
61 const double *const *gamma) = 0;
62
63 virtual int sumInElem(GlobalID /*elemBlockID*/,
64 GlobalID /*elemID*/,
65 const GlobalID* /*elemConn*/,
66 const double* const* /*elemStiffness*/,
67 const double* /*elemLoad*/,
68 int /*elemFormat*/) { return(0); }
69
70 virtual int sumInElemMatrix(GlobalID /*elemBlockID*/,
71 GlobalID /*elemID*/,
72 const GlobalID* /*elemConn*/,
73 const double* const* /*elemStiffness*/,
74 int /*elemFormat*/) { return(0); }
75
76 virtual int sumInElemRHS(GlobalID /*elemBlockID*/,
77 GlobalID /*elemID*/,
78 const GlobalID* /*elemConn*/,
79 const double* /*elemLoad*/) { return(0); }
80
81 virtual int loadCRMult(int CRMultID,
82 int numCRNodes,
83 const GlobalID* CRNodes,
84 const int* CRFields,
85 const double* CRWeights,
86 double CRValue) = 0;
87
88 virtual int loadCRPen(int CRPenID,
89 int numCRNodes,
90 const GlobalID* CRNodes,
91 const int *CRFields,
92 const double* CRWeights,
93 double CRValue,
94 double penValue) = 0;
95
96 virtual int putIntoRHS(int IDType,
97 int fieldID,
98 int numIDs,
99 const GlobalID* IDs,
100 const double* rhsEntries) = 0;
101
102 virtual int sumIntoRHS(int IDType,
103 int fieldID,
104 int numIDs,
105 const GlobalID* IDs,
106 const double* rhsEntries) = 0;
107
108 virtual int sumIntoMatrixDiagonal(int /* IDType*/,
109 int /* fieldID*/,
110 int /* numIDs*/,
111 const GlobalID* /* IDs*/,
112 const double* /* coefficients*/)
113 { return -1; }
114
115 virtual int loadComplete() = 0;
116
117 // set parameters associated with solver choice, etc.
118 virtual int parameters(int numParams, const char *const* paramStrings);
119
120 //get residual norms
121 virtual int residualNorm(int whichNorm, int numFields,
122 int* fieldIDs, double* norms, double& residTime) = 0;
123
124 // start iterative solution
125 virtual int solve(int& status, double& sTime) = 0;
126
127 // query function iterations performed.
128 virtual int iterations() const = 0;
129
130// Solution return services.......................................
131
132 // return all nodal solution params on a block-by-block basis
133 virtual int getBlockNodeSolution(GlobalID elemBlockID,
134 int numNodes,
135 const GlobalID *nodeIDs,
136 int *offsets,
137 double *results) = 0;
138
139 virtual int getNodalSolution(int numNodes,
140 const GlobalID *nodeIDs,
141 int *offsets,
142 double *results) = 0;
143
144 // return nodal solution for one field on a block-by-block basis
145 virtual int getBlockFieldNodeSolution(GlobalID elemBlockID,
146 int fieldID,
147 int numNodes,
148 const GlobalID *nodeIDs,
149 double *results) = 0;
150
151 // return element solution params on a block-by-block basis
152 virtual int getBlockElemSolution(GlobalID elemBlockID,
153 int numElems,
154 const GlobalID *elemIDs,
155 int& numElemDOFPerElement,
156 double *results) = 0;
157
158 virtual int getCRMultipliers(int numCRs, const int* CRIDs,
159 double* multipliers) = 0;
160
161// associated "puts" paralleling the solution return services.
162//
163// the int sizing parameters are passed for error-checking purposes, so
164// that the interface implementation can tell if the passed estimate
165// vectors make sense -before- an attempt is made to utilize them as
166// initial guesses by unpacking them into the solver's native solution
167// vector format (these parameters include lenNodeIDList, lenElemIDList,
168// numElemDOF, and numMultCRs -- all other passed params are either
169// vectors or block/constraint-set IDs)
170
171 // put nodal-based solution guess on a block-by-block basis
172 virtual int putBlockNodeSolution(GlobalID elemBlockID,
173 int numNodes,
174 const GlobalID *nodeIDs,
175 const int *offsets,
176 const double *estimates) = 0;
177
178 // put nodal-based guess for one field on a block-by-block basis
179 virtual int putBlockFieldNodeSolution(GlobalID elemBlockID,
180 int fieldID,
181 int numNodes,
182 const GlobalID *nodeIDs,
183 const double *estimates) = 0;
184
185 virtual int putBlockElemSolution(GlobalID elemBlockID,
186 int numElems,
187 const GlobalID *elemIDs,
188 int dofPerElem,
189 const double *estimates) = 0;
190
191 virtual int putCRMultipliers(int numMultCRs,
192 const int* CRIDs,
193 const double *multEstimates) = 0;
194
195//===== a couple of public non-FEI functions... ================================
196//These are intended to be used by an 'outer-layer' class like
197//FEI_Implementation.
198//
199 public:
200
201 virtual int getNodalFieldSolution(int fieldID,
202 int numNodes,
203 const GlobalID* nodeIDs,
204 double* results) = 0;
205
206 virtual int putNodalFieldData(int fieldID,
207 int numNodes,
208 const GlobalID* nodeIDs,
209 const double* nodeData) = 0;
210
211 virtual int putNodalFieldSolution(int fieldID,
212 int numNodes,
213 const GlobalID* nodeIDs,
214 const double* nodeData) = 0;
215
216 virtual int unpackSolution() = 0;
217
218 virtual void setEqnCommMgr(EqnCommMgr* eqnCommMgr) = 0;
219
220 virtual EqnCommMgr* getEqnCommMgr() = 0;
221
222 virtual int setNumRHSVectors(int numRHSs, int* rhsIDs) = 0;
223 virtual int setCurrentRHS(int rhsID) = 0;
224
225 virtual int exchangeRemoteEquations() { return 0; }
226
227 virtual int enforceEssentialBCs(const int* eqns, const double* alpha,
228 const double* gamma, int numEqns) = 0;
229
230 static void copyStiffness(const double* const* elemStiff, int numRows,
231 int elemFormat, double** copy);
232
233 void setLogStream(std::ostream* logstrm);
234 std::ostream* logStream();
235
236 protected:
237 virtual int generalElemInput(GlobalID /*elemBlockID*/,
238 GlobalID /*elemID*/,
239 const GlobalID* /*elemConn*/,
240 const double* const* /*elemStiffness*/,
241 const double* /*elemLoad*/,
242 int /*elemFormat*/) {return(-1);}
243
244 int generalCoefInput(int /*patternID*/,
245 const int* /*rowIDTypes*/,
246 const GlobalID* /*rowIDs*/,
247 const int* /*colIDTypes*/,
248 const GlobalID* /*colIDs*/,
249 const double* const* /*matrixEntries*/,
250 const double* /*vectorEntries*/,
251 int /*numRows*/, int /*numCols*/) {return(-1);}
252
253 int calculateResidualNorms(int whichNorm, int numFields,
254 int* fieldIDs, double* norms,
255 std::vector<double>& residValues);
256
257 const NodeDescriptor* findNode(GlobalID nodeID) const;
258 const NodeDescriptor& findNodeDescriptor(GlobalID nodeID) const;
259
260 SNL_FEI_Structure* problemStructure_;
261
262 bool logInput_;
263 std::ostream* logInputStream_;
264
265 int outputLevel_;
266
267 int numProcs_;
268 int localRank_;
269
270 private:
271 Filter(const Filter& /*src*/)
272 : problemStructure_(NULL), logInput_(false), logInputStream_(NULL),
273 outputLevel_(0), numProcs_(0), localRank_(0)
274 {}
275
276 Filter& operator=(const Filter& /*src*/)
277 {
278 return(*this);
279 }
280};
281
282#endif
283
virtual ~Filter()
Definition: fei_Filter.cpp:40
std::ostream & console_out()