source: issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp@ 8303

Last change on this file since 8303 was 8303, checked in by seroussi, 14 years ago

changed from grid to node in c
File size: 17.4 KB
Line 
1/*!\file PentaVertexInput.c
2 * \brief: implementation of the PentaVertexInput object
3 */
4
5#ifdef HAVE_CONFIG_H
6 #include "config.h"
7#else
8#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
9#endif
10
11#include "stdio.h"
12#include <string.h>
13#include "../objects.h"
14#include "../../EnumDefinitions/EnumDefinitions.h"
15#include "../../shared/shared.h"
16#include "../../Container/Container.h"
17#include "../../include/include.h"
18
19/*PentaVertexInput constructors and destructor*/
20/*FUNCTION PentaVertexInput::PentaVertexInput(){{{1*/
21PentaVertexInput::PentaVertexInput(){
22 return;
23}
24/*}}}*/
25/*FUNCTION PentaVertexInput::PentaVertexInput(int in_enum_type,double* values){{{1*/
26PentaVertexInput::PentaVertexInput(int in_enum_type,double* in_values)
27 :PentaRef(1)
28{
29
30 /*Set PentaRef*/
31 this->SetElementType(P1Enum,0);
32 this->element_type=P1Enum;
33
34 enum_type=in_enum_type;
35 values[0]=in_values[0];
36 values[1]=in_values[1];
37 values[2]=in_values[2];
38 values[3]=in_values[3];
39 values[4]=in_values[4];
40 values[5]=in_values[5];
41}
42/*}}}*/
43/*FUNCTION PentaVertexInput::~PentaVertexInput(){{{1*/
44PentaVertexInput::~PentaVertexInput(){
45 return;
46}
47/*}}}*/
48
49/*Object virtual functions definitions:*/
50/*FUNCTION PentaVertexInput::Echo {{{1*/
51void PentaVertexInput::Echo(void){
52 this->DeepEcho();
53}
54/*}}}*/
55/*FUNCTION PentaVertexInput::DeepEcho{{{1*/
56void PentaVertexInput::DeepEcho(void){
57
58 printf("PentaVertexInput:\n");
59 printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
60 printf(" values: [%g %g %g %g %g %g]\n",this->values[0],this->values[1],this->values[2],this->values[3],this->values[4],this->values[5]);
61}
62/*}}}*/
63/*FUNCTION PentaVertexInput::Id{{{1*/
64int PentaVertexInput::Id(void){ return -1; }
65/*}}}*/
66/*FUNCTION PentaVertexInput::MyRank{{{1*/
67int PentaVertexInput::MyRank(void){
68 extern int my_rank;
69 return my_rank;
70}
71/*}}}*/
72/*FUNCTION PentaVertexInput::Marshall{{{1*/
73void PentaVertexInput::Marshall(char** pmarshalled_dataset){
74
75 char* marshalled_dataset=NULL;
76 int enum_value=0;
77
78 /*recover marshalled_dataset: */
79 marshalled_dataset=*pmarshalled_dataset;
80
81 /*get enum value of PentaVertexInput: */
82 enum_value=PentaVertexInputEnum;
83
84 /*marshall enum: */
85 memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
86
87 /*marshall PentaVertexInput data: */
88 memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
89 memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values);
90
91 *pmarshalled_dataset=marshalled_dataset;
92}
93/*}}}*/
94/*FUNCTION PentaVertexInput::MarshallSize{{{1*/
95int PentaVertexInput::MarshallSize(){
96
97 return sizeof(values)+
98 +sizeof(enum_type)+
99 +sizeof(int); //sizeof(int) for enum value
100}
101/*}}}*/
102/*FUNCTION PentaVertexInput::Demarshall{{{1*/
103void PentaVertexInput::Demarshall(char** pmarshalled_dataset){
104
105 char* marshalled_dataset=NULL;
106 int i;
107
108 /*recover marshalled_dataset: */
109 marshalled_dataset=*pmarshalled_dataset;
110
111 /*this time, no need to get enum type, the pointer directly points to the beginning of the
112 *object data (thanks to DataSet::Demarshall):*/
113 memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
114 memcpy(&values,marshalled_dataset,sizeof(values));marshalled_dataset+=sizeof(values);
115
116 /*return: */
117 *pmarshalled_dataset=marshalled_dataset;
118 return;
119}
120/*}}}*/
121/*FUNCTION PentaVertexInput::Enum{{{1*/
122int PentaVertexInput::Enum(void){
123
124 return PentaVertexInputEnum;
125
126}
127/*}}}*/
128
129/*PentaVertexInput management*/
130/*FUNCTION PentaVertexInput::copy{{{1*/
131Object* PentaVertexInput::copy() {
132
133 return new PentaVertexInput(this->enum_type,this->values);
134
135}
136/*}}}*/
137/*FUNCTION PentaVertexInput::EnumType{{{1*/
138int PentaVertexInput::EnumType(void){
139
140 return this->enum_type;
141
142}
143/*}}}*/
144/*FUNCTION PentaVertexInput::SpawnTriaInput{{{1*/
145Input* PentaVertexInput::SpawnTriaInput(int* indices){
146
147 /*output*/
148 TriaVertexInput* outinput=NULL;
149 double newvalues[3];
150
151 /*Loop over the new indices*/
152 for(int i=0;i<3;i++){
153
154 /*Check index value*/
155 _assert_(indices[i]>=0 && indices[i]<6);
156
157 /*Assign value to new input*/
158 newvalues[i]=this->values[indices[i]];
159 }
160
161 /*Create new Tria input*/
162 outinput=new TriaVertexInput(this->enum_type,&newvalues[0]);
163
164 /*Assign output*/
165 return outinput;
166
167}
168/*}}}*/
169/*FUNCTION PentaVertexInput::SpawnResult{{{1*/
170ElementResult* PentaVertexInput::SpawnResult(int step, double time){
171
172 return new PentaVertexElementResult(this->enum_type,this->values,step,time);
173
174}
175/*}}}*/
176
177/*Object functions*/
178/*FUNCTION PentaVertexInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
179void PentaVertexInput::GetParameterValue(double* pvalue,GaussPenta* gauss){
180
181 /*Call PentaRef function*/
182 PentaRef::GetParameterValue(pvalue,&values[0],gauss);
183
184}
185/*}}}*/
186/*FUNCTION PentaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/
187void PentaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){
188
189 /*Call PentaRef function*/
190 PentaRef::GetParameterDerivativeValue(p,&values[0],xyz_list,gauss);
191}
192/*}}}*/
193/*FUNCTION PentaVertexInput::GetVxStrainRate3d{{{1*/
194void PentaVertexInput::GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
195 int i,j;
196
197 const int numnodes=6;
198 const int DOFVELOCITY=3;
199 double B[8][27];
200 double B_reduced[6][DOFVELOCITY*numnodes];
201 double velocity[numnodes][DOFVELOCITY];
202
203 /*Get B matrix: */
204 GetBStokes(&B[0][0], xyz_list, gauss);
205 /*Create a reduced matrix of B to get rid of pressure */
206 for (i=0;i<6;i++){
207 for (j=0;j<3;j++){
208 B_reduced[i][j]=B[i][j];
209 }
210 for (j=4;j<7;j++){
211 B_reduced[i][j-1]=B[i][j];
212 }
213 for (j=8;j<11;j++){
214 B_reduced[i][j-2]=B[i][j];
215 }
216 for (j=12;j<15;j++){
217 B_reduced[i][j-3]=B[i][j];
218 }
219 for (j=16;j<19;j++){
220 B_reduced[i][j-4]=B[i][j];
221 }
222 for (j=20;j<23;j++){
223 B_reduced[i][j-5]=B[i][j];
224 }
225 }
226
227 /*Here, we are computing the strain rate of (vx,0,0)*/
228 for(i=0;i<numnodes;i++){
229 velocity[i][0]=this->values[i];
230 velocity[i][1]=0.0;
231 velocity[i][2]=0.0;
232 }
233 /*Multiply B by velocity, to get strain rate: */
234 MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvx,0);
235
236}
237/*}}}*/
238/*FUNCTION PentaVertexInput::GetVyStrainRate3d{{{1*/
239void PentaVertexInput::GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
240 int i,j;
241
242 const int numnodes=6;
243 const int DOFVELOCITY=3;
244 double B[8][27];
245 double B_reduced[6][DOFVELOCITY*numnodes];
246 double velocity[numnodes][DOFVELOCITY];
247
248 /*Get B matrix: */
249 GetBStokes(&B[0][0], xyz_list, gauss);
250 /*Create a reduced matrix of B to get rid of pressure */
251 for (i=0;i<6;i++){
252 for (j=0;j<3;j++){
253 B_reduced[i][j]=B[i][j];
254 }
255 for (j=4;j<7;j++){
256 B_reduced[i][j-1]=B[i][j];
257 }
258 for (j=8;j<11;j++){
259 B_reduced[i][j-2]=B[i][j];
260 }
261 for (j=12;j<15;j++){
262 B_reduced[i][j-3]=B[i][j];
263 }
264 for (j=16;j<19;j++){
265 B_reduced[i][j-4]=B[i][j];
266 }
267 for (j=20;j<23;j++){
268 B_reduced[i][j-5]=B[i][j];
269 }
270 }
271
272 /*Here, we are computing the strain rate of (0,vy,0)*/
273 for(i=0;i<numnodes;i++){
274 velocity[i][0]=0.0;
275 velocity[i][1]=this->values[i];
276 velocity[i][2]=0.0;
277 }
278 /*Multiply B by velocity, to get strain rate: */
279 MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvy,0);
280
281}
282/*}}}*/
283/*FUNCTION PentaVertexInput::GetVzStrainRate3d{{{1*/
284void PentaVertexInput::GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){
285 int i,j;
286
287 const int numnodes=6;
288 const int DOFVELOCITY=3;
289 double B[8][27];
290 double B_reduced[6][DOFVELOCITY*numnodes];
291 double velocity[numnodes][DOFVELOCITY];
292
293 /*Get B matrix: */
294 GetBStokes(&B[0][0], xyz_list, gauss);
295 /*Create a reduced matrix of B to get rid of pressure */
296 for (i=0;i<6;i++){
297 for (j=0;j<3;j++){
298 B_reduced[i][j]=B[i][j];
299 }
300 for (j=4;j<7;j++){
301 B_reduced[i][j-1]=B[i][j];
302 }
303 for (j=8;j<11;j++){
304 B_reduced[i][j-2]=B[i][j];
305 }
306 for (j=12;j<15;j++){
307 B_reduced[i][j-3]=B[i][j];
308 }
309 for (j=16;j<19;j++){
310 B_reduced[i][j-4]=B[i][j];
311 }
312 for (j=20;j<23;j++){
313 B_reduced[i][j-5]=B[i][j];
314 }
315 }
316
317 /*Here, we are computing the strain rate of (0,0,vz)*/
318 for(i=0;i<numnodes;i++){
319 velocity[i][0]=0.0;
320 velocity[i][1]=0.0;
321 velocity[i][2]=this->values[i];
322 }
323
324 /*Multiply B by velocity, to get strain rate: */
325 MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvz,0);
326
327}
328/*}}}*/
329/*FUNCTION PentaVertexInput::GetVxStrainRate3dPattyn{{{1*/
330void PentaVertexInput::GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
331
332 int i;
333 const int numnodes=6;
334 double B[5][NDOF2*numnodes];
335 double velocity[numnodes][NDOF2];
336
337 /*Get B matrix: */
338 GetBPattyn(&B[0][0], xyz_list, gauss);
339
340 /*Here, we are computing the strain rate of (vx,0)*/
341 for(i=0;i<numnodes;i++){
342 velocity[i][0]=this->values[i];
343 velocity[i][1]=0.0;
344 }
345
346 /*Multiply B by velocity, to get strain rate: */
347 MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0,
348 &velocity[0][0],NDOF2*numnodes,1,0,
349 epsilonvx,0);
350
351}
352/*}}}*/
353/*FUNCTION PentaVertexInput::GetVyStrainRate3dPattyn{{{1*/
354void PentaVertexInput::GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
355
356 int i;
357 const int numnodes=6;
358 double B[5][NDOF2*numnodes];
359 double velocity[numnodes][NDOF2];
360
361 /*Get B matrix: */
362 GetBPattyn(&B[0][0], xyz_list, gauss);
363
364 /*Here, we are computing the strain rate of (0,vy)*/
365 for(i=0;i<numnodes;i++){
366 velocity[i][0]=0.0;
367 velocity[i][1]=this->values[i];
368 }
369
370 /*Multiply B by velocity, to get strain rate: */
371 MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0,
372 &velocity[0][0],NDOF2*numnodes,1,0,
373 epsilonvy,0);
374
375}
376/*}}}*/
377/*FUNCTION PentaVertexInput::ChangeEnum{{{1*/
378void PentaVertexInput::ChangeEnum(int newenumtype){
379 this->enum_type=newenumtype;
380}
381/*}}}*/
382/*FUNCTION PentaVertexInput::GetParameterAverage{{{1*/
383void PentaVertexInput::GetParameterAverage(double* pvalue){
384 *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]);
385}
386/*}}}*/
387
388/*Intermediary*/
389/*FUNCTION PentaVertexInput::SquareMin{{{1*/
390void PentaVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
391
392 int i;
393 const int numnodes=6;
394 double valuescopy[numnodes];
395 double squaremin;
396
397 /*First, copy values, to process units if requested: */
398 for(i=0;i<numnodes;i++)valuescopy[i]=this->values[i];
399
400 /*Process units if requested: */
401 if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type,parameters);
402
403 /*Now, figure out minimum of valuescopy: */
404 squaremin=pow(valuescopy[0],2);
405 for(i=1;i<numnodes;i++){
406 if(pow(valuescopy[i],2)<squaremin)squaremin=pow(valuescopy[i],2);
407 }
408 /*Assign output pointers:*/
409 *psquaremin=squaremin;
410}
411/*}}}*/
412/*FUNCTION PentaVertexInput::ConstrainMin{{{1*/
413void PentaVertexInput::ConstrainMin(double minimum){
414
415 int i;
416 const int numnodes=6;
417
418 for(i=0;i<numnodes;i++) if (values[i]<minimum) values[i]=minimum;
419}
420/*}}}*/
421/*FUNCTION PentaVertexInput::InfinityNorm{{{1*/
422double PentaVertexInput::InfinityNorm(void){
423
424 /*Output*/
425 const int numnodes=6;
426 double norm=0;
427
428 for(int i=0;i<numnodes;i++) if(fabs(values[i])>norm) norm=fabs(values[i]);
429 return norm;
430}
431/*}}}*/
432/*FUNCTION PentaVertexInput::Max{{{1*/
433double PentaVertexInput::Max(void){
434
435 const int numnodes=6;
436 double max=values[0];
437
438 for(int i=1;i<numnodes;i++){
439 if(values[i]>max) max=values[i];
440 }
441 return max;
442}
443/*}}}*/
444/*FUNCTION PentaVertexInput::MaxAbs{{{1*/
445double PentaVertexInput::MaxAbs(void){
446
447 const int numnodes=6;
448 double max=fabs(values[0]);
449
450 for(int i=1;i<numnodes;i++){
451 if(fabs(values[i])>max) max=fabs(values[i]);
452 }
453 return max;
454}
455/*}}}*/
456/*FUNCTION PentaVertexInput::Min{{{1*/
457double PentaVertexInput::Min(void){
458
459 const int numnodes=6;
460 double min=values[0];
461
462 for(int i=1;i<numnodes;i++){
463 if(values[i]<min) min=values[i];
464 }
465 return min;
466}
467/*}}}*/
468/*FUNCTION PentaVertexInput::MinAbs{{{1*/
469double PentaVertexInput::MinAbs(void){
470
471 const int numnodes=6;
472 double min=fabs(values[0]);
473
474 for(int i=1;i<numnodes;i++){
475 if(fabs(values[i])<min) min=fabs(values[i]);
476 }
477 return min;
478}
479/*}}}*/
480/*FUNCTION PentaVertexInput::Scale{{{1*/
481void PentaVertexInput::Scale(double scale_factor){
482
483 int i;
484 const int numnodes=6;
485
486 for(i=0;i<numnodes;i++)values[i]=values[i]*scale_factor;
487}
488/*}}}*/
489/*FUNCTION PentaVertexInput::AXPY{{{1*/
490void PentaVertexInput::AXPY(Input* xinput,double scalar){
491
492 int i;
493 const int numnodes=6;
494
495 /*xinput is of the same type, so cast it: */
496
497 /*Carry out the AXPY operation depending on type:*/
498 switch(xinput->Enum()){
499
500 case PentaVertexInputEnum:{
501 PentaVertexInput* cast_input=(PentaVertexInput*)xinput;
502 for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*(cast_input->values[i]);}
503 return;
504 case ControlInputEnum:{
505 ControlInput* cont_input=(ControlInput*)xinput;
506 if(cont_input->values->Enum()!=PentaVertexInputEnum) _error_("not supported yet");
507 PentaVertexInput* cast_input=(PentaVertexInput*)cont_input->values;
508 for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*(cast_input->values[i]);}
509 return;
510 default:
511 _error_("not implemented yet");
512 }
513
514}
515/*}}}*/
516/*FUNCTION PentaVertexInput::Constrain{{{1*/
517void PentaVertexInput::Constrain(double cm_min, double cm_max){
518
519 int i;
520 const int numnodes=6;
521
522 if(!isnan(cm_min)) for(i=0;i<numnodes;i++)if (this->values[i]<cm_min)this->values[i]=cm_min;
523 if(!isnan(cm_max)) for(i=0;i<numnodes;i++)if (this->values[i]>cm_max)this->values[i]=cm_max;
524
525}
526/*}}}*/
527/*FUNCTION PentaVertexInput::Extrude{{{1*/
528void PentaVertexInput::Extrude(void){
529
530 int i;
531
532 /*First 3 values copied on 3 last values*/
533 for(i=0;i<3;i++) this->values[3+i]=this->values[i];
534
535}
536/*}}}*/
537/*FUNCTION PentaVertexInput::VerticallyIntegrate{{{1*/
538void PentaVertexInput::VerticallyIntegrate(Input* thickness_input){
539
540 /*Intermediaries*/
541 int i;
542 const int numnodes = 6;
543 int num_thickness_values;
544 double *thickness_values = NULL;
545
546 /*Check that input provided is a thickness*/
547 if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToStringx(thickness_input->EnumType()));
548
549 /*Get Thickness value pointer*/
550 thickness_input->GetValuesPtr(&thickness_values,&num_thickness_values);
551
552 /*vertically integrate depending on type:*/
553 switch(thickness_input->Enum()){
554
555 case PentaVertexInputEnum:
556 for(i=0;i<3;i++){
557 this->values[i]=0.5*(this->values[i]+this->values[i+3]) * thickness_values[i];
558 this->values[i+3]=this->values[i];
559 }
560 return;
561
562 default:
563 _error_("not implemented yet");
564 }
565}
566/*}}}*/
567/*FUNCTION PentaVertexInput::PointwiseDivide{{{1*/
568Input* PentaVertexInput::PointwiseDivide(Input* inputB){
569
570 /*Ouput*/
571 PentaVertexInput* outinput=NULL;
572
573 /*Intermediaries*/
574 int i;
575 PentaVertexInput *xinputB = NULL;
576 int B_numvalues;
577 const int numnodes = 6;
578 double AdotBvalues[numnodes];
579
580 /*Check that inputB is of the same type*/
581 if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
582 xinputB=(PentaVertexInput*)inputB;
583
584 /*Create point wise sum*/
585 for(i=0;i<numnodes;i++){
586 _assert_(xinputB->values[i]!=0);
587 AdotBvalues[i]=this->values[i]/xinputB->values[i];
588 }
589
590 /*Create new Penta vertex input (copy of current input)*/
591 outinput=new PentaVertexInput(this->enum_type,&AdotBvalues[0]);
592
593 /*Return output pointer*/
594 return outinput;
595
596}
597/*}}}*/
598/*FUNCTION PentaVertexInput::PointwiseMin{{{1*/
599Input* PentaVertexInput::PointwiseMin(Input* inputB){
600
601 /*Ouput*/
602 PentaVertexInput* outinput=NULL;
603
604 /*Intermediaries*/
605 int i;
606 PentaVertexInput *xinputB = NULL;
607 int B_numvalues;
608 const int numnodes = 6;
609 double minvalues[numnodes];
610
611 /*Check that inputB is of the same type*/
612 if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
613 xinputB=(PentaVertexInput*)inputB;
614
615 /*Create point wise min*/
616 for(i=0;i<numnodes;i++){
617 if(this->values[i] > xinputB->values[i]) minvalues[i]=xinputB->values[i];
618 else minvalues[i]=this->values[i];
619 }
620
621 /*Create new Penta vertex input (copy of current input)*/
622 outinput=new PentaVertexInput(this->enum_type,&minvalues[0]);
623
624 /*Return output pointer*/
625 return outinput;
626
627}
628/*}}}*/
629/*FUNCTION PentaVertexInput::PointwiseMax{{{1*/
630Input* PentaVertexInput::PointwiseMax(Input* inputB){
631
632 /*Ouput*/
633 PentaVertexInput* outinput=NULL;
634
635 /*Intermediaries*/
636 int i;
637 PentaVertexInput *xinputB = NULL;
638 int B_numvalues;
639 const int numnodes = 6;
640 double maxvalues[numnodes];
641
642 /*Check that inputB is of the same type*/
643 if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
644 xinputB=(PentaVertexInput*)inputB;
645
646 /*Create point wise max*/
647 for(i=0;i<numnodes;i++){
648 if(this->values[i] < xinputB->values[i]) maxvalues[i]=xinputB->values[i];
649 else maxvalues[i]=this->values[i];
650 }
651
652 /*Create new Penta vertex input (copy of current input)*/
653 outinput=new PentaVertexInput(this->enum_type,&maxvalues[0]);
654
655 /*Return output pointer*/
656 return outinput;
657
658}
659/*}}}*/
660/*FUNCTION PentaVertexInput::GetVectorFromInputs{{{1*/
661void PentaVertexInput::GetVectorFromInputs(Vec vector,int* doflist){
662
663 const int numvertices=6;
664 VecSetValues(vector,numvertices,doflist,(const double*)this->values,INSERT_VALUES);
665
666} /*}}}*/
667/*FUNCTION PentaVertexInput::GetValuesPtr{{{1*/
668void PentaVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){
669
670 *pvalues=this->values;
671 *pnum_values=6;
672
673}
674/*}}}*/
Note: See TracBrowser for help on using the repository browser.