Ice Sheet System Model  4.18
Code documentation
Public Member Functions | Data Fields
Vector< doubletype > Class Template Reference

#include <Vector.h>

Public Member Functions

 Vector ()
 
 Vector (int M, bool fromlocalsize=false)
 
 Vector (int m, int M)
 
 Vector (doubletype *serial_vec, int M)
 
 ~Vector ()
 
void InitCheckAndSetType (void)
 
void Echo (void)
 
void Assemble (void)
 
void SetValues (int ssize, int *list, doubletype *values, InsMode mode)
 
void SetValue (int dof, doubletype value, InsMode mode)
 
void GetValue (doubletype *pvalue, int dof)
 
void GetSize (int *pM)
 
bool IsEmpty (void)
 
void GetLocalSize (int *pM)
 
void GetLocalVector (doubletype **pvector, int **pindices)
 
Vector< doubletype > * Duplicate (void)
 
void Set (doubletype value)
 
void AXPY (Vector *X, doubletype a)
 
void AYPX (Vector *X, doubletype a)
 
doubletype * ToMPISerial (void)
 
doubletype * ToMPISerial0 (void)
 
void Shift (doubletype shift)
 
void Copy (Vector *to)
 
doubletype Max (void)
 
doubletype Norm (NormMode norm_type)
 
void Scale (doubletype scale_factor)
 
doubletype Dot (Vector *vector)
 
void PointwiseDivide (Vector *x, Vector *y)
 

Data Fields

int type
 
IssmVec< doubletype > * ivector
 

Detailed Description

template<class doubletype>
class Vector< doubletype >

Definition at line 25 of file Vector.h.

Constructor & Destructor Documentation

◆ Vector() [1/4]

template<class doubletype >
Vector< doubletype >::Vector ( )
inline

Definition at line 36 of file Vector.h.

36  { /*{{{*/
37 
38  InitCheckAndSetType();
39  }

◆ Vector() [2/4]

template<class doubletype >
Vector< doubletype >::Vector ( int  M,
bool  fromlocalsize = false 
)
inline

Definition at line 41 of file Vector.h.

41  { /*{{{*/
42 
43  InitCheckAndSetType();
44 
45  if(type==PetscVecType){
46  #ifdef _HAVE_PETSC_
47  this->pvector=new PetscVec(M,fromlocalsize);
48  #endif
49  }
50  else this->ivector=new IssmVec<doubletype>(M,fromlocalsize);
51 
52  }

◆ Vector() [3/4]

template<class doubletype >
Vector< doubletype >::Vector ( int  m,
int  M 
)
inline

Definition at line 54 of file Vector.h.

54  { /*{{{*/
55 
56  InitCheckAndSetType();
57 
58  if(type==PetscVecType){
59  #ifdef _HAVE_PETSC_
60  this->pvector=new PetscVec(m,M);
61  #endif
62  }
63  else this->ivector=new IssmVec<doubletype>(m,M);
64  }

◆ Vector() [4/4]

template<class doubletype >
Vector< doubletype >::Vector ( doubletype *  serial_vec,
int  M 
)
inline

Definition at line 66 of file Vector.h.

66  { /*{{{*/
67 
68  InitCheckAndSetType();
69 
70  if(type==PetscVecType){
71  #ifdef _HAVE_PETSC_
72  this->pvector=new PetscVec(serial_vec,M);
73  #endif
74  }
75  else this->ivector=new IssmVec<doubletype>(serial_vec,M);
76  }

◆ ~Vector()

template<class doubletype >
Vector< doubletype >::~Vector ( )
inline

Definition at line 78 of file Vector.h.

78  { /*{{{*/
79 
80  if(type==PetscVecType){
81  #ifdef _HAVE_PETSC_
82  delete this->pvector;
83  #endif
84  }
85  else delete this->ivector;
86  }

Member Function Documentation

◆ InitCheckAndSetType()

template<class doubletype >
void Vector< doubletype >::InitCheckAndSetType ( void  )
inline

Definition at line 98 of file Vector.h.

98  { /*{{{*/
99 
100  #ifdef _HAVE_PETSC_
101  pvector=NULL;
102  #endif
103  ivector=NULL;
104 
105  /*retrieve toolkittype: */
106  char* toolkittype=ToolkitOptions::GetToolkitType();
107  _assert_(toolkittype);
108 
109  /*set vector type: */
110  if(strcmp(toolkittype,"petsc")==0){
111  #ifdef _HAVE_PETSC_
112  type=PetscVecType;
113  #else
114  _error_("cannot create petsc vector without PETSC compiled!");
115  #endif
116  }
117  else if(strcmp(toolkittype,"issm")==0){
118  /*let this choice stand:*/
119  type=IssmVecType;
120  }
121  else{
122  _error_("unknow toolkit type ");
123  }
124 
125  /*Free ressources: */
126  xDelete<char>(toolkittype);
127  }

◆ Echo()

template<class doubletype >
void Vector< doubletype >::Echo ( void  )
inline

Definition at line 131 of file Vector.h.

131  {_assert_(this);/*{{{*/
132 
133  if(type==PetscVecType){
134  #ifdef _HAVE_PETSC_
135  this->pvector->Echo();
136  #endif
137  }
138  else this->ivector->Echo();
139 
140  }

◆ Assemble()

template<class doubletype >
void Vector< doubletype >::Assemble ( void  )
inline

Definition at line 142 of file Vector.h.

142  {_assert_(this);/*{{{*/
143 
144  if(type==PetscVecType){
145  #ifdef _HAVE_PETSC_
146  this->pvector->Assemble();
147  #endif
148  }
149  else this->ivector->Assemble();
150 
151  }

◆ SetValues()

template<class doubletype >
void Vector< doubletype >::SetValues ( int  ssize,
int *  list,
doubletype *  values,
InsMode  mode 
)
inline

Definition at line 153 of file Vector.h.

153  { _assert_(this);/*{{{*/
154  if(type==PetscVecType){
155  #ifdef _HAVE_PETSC_
156  this->pvector->SetValues(ssize,list,values,mode);
157  #endif
158  }
159  else this->ivector->SetValues(ssize,list,values,mode);
160 
161  }

◆ SetValue()

template<class doubletype >
void Vector< doubletype >::SetValue ( int  dof,
doubletype  value,
InsMode  mode 
)
inline

Definition at line 163 of file Vector.h.

163  {_assert_(this);/*{{{*/
164 
165  if(type==PetscVecType){
166  #ifdef _HAVE_PETSC_
167  this->pvector->SetValue(dof,value,mode);
168  #endif
169  }
170  else this->ivector->SetValue(dof,value,mode);
171 
172  }

◆ GetValue()

template<class doubletype >
void Vector< doubletype >::GetValue ( doubletype *  pvalue,
int  dof 
)
inline

Definition at line 174 of file Vector.h.

174  {_assert_(this);/*{{{*/
175 
176  if(type==PetscVecType){
177  #ifdef _HAVE_PETSC_
178  this->pvector->GetValue(pvalue,dof);
179  #endif
180  }
181  else this->ivector->GetValue(pvalue,dof);
182 
183  }

◆ GetSize()

template<class doubletype >
void Vector< doubletype >::GetSize ( int *  pM)
inline

Definition at line 185 of file Vector.h.

185  {_assert_(this);/*{{{*/
186 
187  if(type==PetscVecType){
188  #ifdef _HAVE_PETSC_
189  this->pvector->GetSize(pM);
190  #endif
191  }
192  else this->ivector->GetSize(pM);
193 
194  }

◆ IsEmpty()

template<class doubletype >
bool Vector< doubletype >::IsEmpty ( void  )
inline

Definition at line 196 of file Vector.h.

196  {/*{{{*/
197  int M;
198 
199  _assert_(this);
200  this->GetSize(&M);
201 
202  if(M==0)
203  return true;
204  else
205  return false;
206  }

◆ GetLocalSize()

template<class doubletype >
void Vector< doubletype >::GetLocalSize ( int *  pM)
inline

Definition at line 208 of file Vector.h.

208  {_assert_(this);/*{{{*/
209 
210  if(type==PetscVecType){
211  #ifdef _HAVE_PETSC_
212  this->pvector->GetLocalSize(pM);
213  #endif
214  }
215  else this->ivector->GetLocalSize(pM);
216 
217  }

◆ GetLocalVector()

template<class doubletype >
void Vector< doubletype >::GetLocalVector ( doubletype **  pvector,
int **  pindices 
)
inline

Definition at line 219 of file Vector.h.

219  {_assert_(this);/*{{{*/
220 
221  if(type==PetscVecType){
222  #ifdef _HAVE_PETSC_
223  this->pvector->GetLocalVector(pvector,pindices);
224  #endif
225  }
226  else this->ivector->GetLocalVector(pvector,pindices);
227 
228  }

◆ Duplicate()

template<class doubletype >
Vector<doubletype>* Vector< doubletype >::Duplicate ( void  )
inline

Definition at line 230 of file Vector.h.

230  {_assert_(this);/*{{{*/
231 
232  Vector<doubletype>* output=NULL;
233 
234  output=new Vector<doubletype>();
235 
236  if(type==PetscVecType){
237  #ifdef _HAVE_PETSC_
238  output->pvector=this->pvector->Duplicate();
239  #endif
240  }
241  else output->ivector=this->ivector->Duplicate();
242 
243  return output;
244  } /*}}}*/

◆ Set()

template<class doubletype >
void Vector< doubletype >::Set ( doubletype  value)
inline

Definition at line 245 of file Vector.h.

245  {_assert_(this);/*{{{*/
246 
247  if(type==PetscVecType){
248  #ifdef _HAVE_PETSC_
249  this->pvector->Set(value);
250  #endif
251  }
252  else this->ivector->Set(value);
253 
254  }

◆ AXPY()

template<class doubletype >
void Vector< doubletype >::AXPY ( Vector< doubletype > *  X,
doubletype  a 
)
inline

Definition at line 256 of file Vector.h.

256  {_assert_(this);/*{{{*/
257 
258  if(type==PetscVecType){
259  #ifdef _HAVE_PETSC_
260  this->pvector->AXPY(X->pvector,a);
261  #endif
262  }
263  else this->ivector->AXPY(X->ivector,a);
264 
265  }

◆ AYPX()

template<class doubletype >
void Vector< doubletype >::AYPX ( Vector< doubletype > *  X,
doubletype  a 
)
inline

Definition at line 267 of file Vector.h.

267  {_assert_(this);/*{{{*/
268 
269  if(type==PetscVecType){
270  #ifdef _HAVE_PETSC_
271  this->pvector->AYPX(X->pvector,a);
272  #endif
273  }
274  else this->ivector->AYPX(X->ivector,a);
275  }

◆ ToMPISerial()

template<class doubletype >
doubletype* Vector< doubletype >::ToMPISerial ( void  )
inline

Definition at line 277 of file Vector.h.

277  {/*{{{*/
278 
279  doubletype* vec_serial=NULL;
280 
281  _assert_(this);
282  if(type==PetscVecType){
283  #ifdef _HAVE_PETSC_
284  vec_serial=this->pvector->ToMPISerial();
285  #endif
286  }
287  else vec_serial=this->ivector->ToMPISerial();
288 
289  return vec_serial;
290 
291  }

◆ ToMPISerial0()

template<class doubletype >
doubletype* Vector< doubletype >::ToMPISerial0 ( void  )
inline

Definition at line 293 of file Vector.h.

293  {/*{{{*/
294 
295  doubletype* vec_serial=NULL;
296 
297  _assert_(this);
298  if(type==PetscVecType){
299  #ifdef _HAVE_PETSC_
300  vec_serial=this->pvector->ToMPISerial0();
301  #endif
302  }
303  else vec_serial=this->ivector->ToMPISerial0();
304 
305  return vec_serial;
306 
307  }

◆ Shift()

template<class doubletype >
void Vector< doubletype >::Shift ( doubletype  shift)
inline

Definition at line 309 of file Vector.h.

309  {_assert_(this);/*{{{*/
310 
311  if(type==PetscVecType){
312  #ifdef _HAVE_PETSC_
313  this->pvector->Shift(shift);
314  #endif
315  }
316  else this->ivector->Shift(shift);
317  }

◆ Copy()

template<class doubletype >
void Vector< doubletype >::Copy ( Vector< doubletype > *  to)
inline

Definition at line 319 of file Vector.h.

319  {_assert_(this);/*{{{*/
320 
321  if(type==PetscVecType){
322  #ifdef _HAVE_PETSC_
323  this->pvector->Copy(to->pvector);
324  #endif
325  }
326  else this->ivector->Copy(to->ivector);
327  }

◆ Max()

template<class doubletype >
doubletype Vector< doubletype >::Max ( void  )
inline

Definition at line 329 of file Vector.h.

329  {_assert_(this);/*{{{*/
330 
331  doubletype max=0;
332 
333  if(type==PetscVecType){
334  #ifdef _HAVE_PETSC_
335  max=this->pvector->Max();
336  #endif
337  }
338  else _error_("operation not supported yet");
339  return max;
340  }

◆ Norm()

template<class doubletype >
doubletype Vector< doubletype >::Norm ( NormMode  norm_type)
inline

Definition at line 342 of file Vector.h.

342  {_assert_(this);/*{{{*/
343 
344  doubletype norm=0;
345 
346  if(type==PetscVecType){
347  #ifdef _HAVE_PETSC_
348  norm=this->pvector->Norm(norm_type);
349  #endif
350  }
351  else norm=this->ivector->Norm(norm_type);
352  return norm;
353  }

◆ Scale()

template<class doubletype >
void Vector< doubletype >::Scale ( doubletype  scale_factor)
inline

Definition at line 355 of file Vector.h.

355  {_assert_(this);/*{{{*/
356 
357  if(type==PetscVecType){
358  #ifdef _HAVE_PETSC_
359  this->pvector->Scale(scale_factor);
360  #endif
361  }
362  else this->ivector->Scale(scale_factor);
363  }

◆ Dot()

template<class doubletype >
doubletype Vector< doubletype >::Dot ( Vector< doubletype > *  vector)
inline

Definition at line 365 of file Vector.h.

365  {_assert_(this);/*{{{*/
366 
367  doubletype dot;
368 
369  if(type==PetscVecType){
370  #ifdef _HAVE_PETSC_
371  dot=this->pvector->Dot(vector->pvector);
372  #endif
373  }
374  else dot=this->ivector->Dot(vector->ivector);
375  return dot;
376  }

◆ PointwiseDivide()

template<class doubletype >
void Vector< doubletype >::PointwiseDivide ( Vector< doubletype > *  x,
Vector< doubletype > *  y 
)
inline

Definition at line 378 of file Vector.h.

378  {_assert_(this);/*{{{*/
379 
380  if(type==PetscVecType){
381  #ifdef _HAVE_PETSC_
382  this->pvector->PointwiseDivide(x->pvector,y->pvector);
383  #endif
384  }
385  else this->ivector->PointwiseDivide(x->ivector,y->ivector);
386  }

Field Documentation

◆ type

template<class doubletype >
int Vector< doubletype >::type

Definition at line 29 of file Vector.h.

◆ ivector

template<class doubletype >
IssmVec<doubletype>* Vector< doubletype >::ivector

Definition at line 33 of file Vector.h.

The documentation for this class was generated from the following files:
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
ToolkitOptions::GetToolkitType
static char * GetToolkitType(void)
Definition: ToolkitOptions.cpp:29
Vector::Duplicate
Vector< doubletype > * Duplicate(void)
Definition: Vector.h:230
IssmVecType
@ IssmVecType
Definition: Vector.h:22
Vector::GetSize
void GetSize(int *pM)
Definition: Vector.h:185
PetscVecType
@ PetscVecType
Definition: Vector.h:22
IssmVec
Definition: IssmVec.h:34
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Vector::ivector
IssmVec< doubletype > * ivector
Definition: Vector.h:33
PetscVec
Definition: PetscVec.h:22
Vector::type
int type
Definition: Vector.h:29
max
IssmDouble max(IssmDouble a, IssmDouble b)
Definition: extrema.cpp:24
Vector
Definition: Vector.h:25
Vector::InitCheckAndSetType
void InitCheckAndSetType(void)
Definition: Vector.h:98
Generated on Thu Jul 2 2020 08:09:31 for Ice Sheet System Model by   doxygen 1.8.19