/[escript]/branches/ripleygmg_from_3668/ripley/src/RipleyDomain.cpp
ViewVC logotype

Contents of /branches/ripleygmg_from_3668/ripley/src/RipleyDomain.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3746 - (show annotations)
Thu Dec 15 00:02:22 2011 UTC (7 years, 11 months ago) by caltinay
File size: 26512 byte(s)
In Ripley Solution==ContinuousFunction and ReducedSolution==ReducedCF now.
Removed a test in escript that relied on failure when trying to tag Data on
Solution/ReducedSolution.

1
2 /*******************************************************
3 *
4 * Copyright (c) 2003-2011 by University of Queensland
5 * Earth Systems Science Computational Center (ESSCC)
6 * http://www.uq.edu.au/esscc
7 *
8 * Primary Business: Queensland, Australia
9 * Licensed under the Open Software License version 3.0
10 * http://www.opensource.org/licenses/osl-3.0.php
11 *
12 *******************************************************/
13
14 #include <ripley/RipleyDomain.h>
15 #include <escript/DataFactory.h>
16 #include <escript/FunctionSpaceFactory.h>
17 #include <pasowrap/SystemMatrixAdapter.h>
18 #include <pasowrap/TransportProblemAdapter.h>
19
20 #include <iomanip>
21
22 using namespace std;
23 using paso::SystemMatrixAdapter;
24 using paso::TransportProblemAdapter;
25
26 namespace ripley {
27
28 escript::Domain_ptr RipleyDomain::loadMesh(const string& filename)
29 {
30 throw RipleyException("loadMesh() not implemented");
31 }
32
33 escript::Domain_ptr RipleyDomain::readMesh(const string& filename)
34 {
35 throw RipleyException("readMesh() not implemented");
36 }
37
38 RipleyDomain::RipleyDomain(dim_t dim) :
39 m_numDim(dim),
40 m_status(0)
41 {
42 m_mpiInfo = Esys_MPIInfo_alloc(MPI_COMM_WORLD);
43 }
44
45 RipleyDomain::~RipleyDomain()
46 {
47 Esys_MPIInfo_free(m_mpiInfo);
48 }
49
50 bool RipleyDomain::operator==(const AbstractDomain& other) const
51 {
52 const RipleyDomain* o=dynamic_cast<const RipleyDomain*>(&other);
53 if (o) {
54 return (m_tagMap==o->m_tagMap && m_nodeTags==o->m_nodeTags
55 && m_elementTags==o->m_elementTags
56 && m_faceTags==o->m_faceTags);
57 }
58 return false;
59 }
60
61 bool RipleyDomain::isValidFunctionSpaceType(int fsType) const
62 {
63 switch (fsType) {
64 case Nodes:
65 case ReducedNodes:
66 case Elements:
67 case ReducedElements:
68 case FaceElements:
69 case ReducedFaceElements:
70 case Points:
71 return true;
72 default:
73 break;
74 }
75 return false;
76 }
77
78 string RipleyDomain::functionSpaceTypeAsString(int fsType) const
79 {
80 switch (fsType) {
81 case Nodes: return "Ripley_Nodes";
82 case ReducedNodes: return "Ripley_Reduced_Nodes";
83 case Elements: return "Ripley_Elements";
84 case ReducedElements: return "Ripley_Reduced_Elements";
85 case FaceElements: return "Ripley_Face_Elements";
86 case ReducedFaceElements: return "Ripley_Reduced_Face_Elements";
87 case Points: return "Ripley_Points";
88 default:
89 break;
90 }
91 return "Invalid function space type code";
92 }
93
94 pair<int,int> RipleyDomain::getDataShape(int fsType) const
95 {
96 const int ptsPerSample = (m_numDim==2 ? 4 : 8);
97 switch (fsType) {
98 case Nodes:
99 case ReducedNodes: //FIXME: reduced
100 return pair<int,int>(1, getNumNodes());
101 case Elements:
102 return pair<int,int>(ptsPerSample, getNumElements());
103 case FaceElements:
104 return pair<int,int>(ptsPerSample/2, getNumFaceElements());
105 case ReducedElements:
106 return pair<int,int>(1, getNumElements());
107 case ReducedFaceElements:
108 return pair<int,int>(1, getNumFaceElements());
109 case Points:
110 return pair<int,int>(1, 0); //FIXME: dirac
111 default:
112 break;
113 }
114
115 stringstream msg;
116 msg << "getDataShape(): Unsupported function space type " << fsType
117 << " for " << getDescription();
118 throw RipleyException(msg.str());
119 }
120
121 string RipleyDomain::showTagNames() const
122 {
123 stringstream ret;
124 TagMap::const_iterator it;
125 for (it=m_tagMap.begin(); it!=m_tagMap.end(); it++) {
126 if (it!=m_tagMap.begin()) ret << ", ";
127 ret << it->first;
128 }
129 return ret.str();
130 }
131
132 bool RipleyDomain::commonFunctionSpace(const vector<int>& fs, int& resultcode) const
133 {
134 /*
135 The idea is to use equivalence classes (i.e. types which can be
136 interpolated back and forth):
137 class 0: Nodes
138 class 1: ReducedNodes
139 class 2: Points
140 class 3: Elements
141 class 4: ReducedElements
142 class 5: FaceElements
143 class 6: ReducedFaceElements
144
145 There is also a set of lines. Interpolation is possible down a line but not
146 between lines.
147 class 0 and 1 belong to all lines so aren't considered.
148 line 0: class 2
149 line 1: class 3,4
150 line 2: class 5,6
151 */
152 if (fs.empty())
153 return false;
154 vector<bool> hasclass(7, false);
155 vector<int> hasline(3, 0);
156 for (size_t i=0; i<fs.size(); ++i) {
157 switch (fs[i]) {
158 case Nodes:
159 hasclass[0]=true;
160 break;
161 case ReducedNodes:
162 hasclass[1]=true;
163 break;
164 case Points:
165 hasline[0]=1;
166 hasclass[2]=true;
167 break;
168 case Elements:
169 hasline[1]=1;
170 break;
171 case ReducedElements:
172 hasclass[4]=true;
173 hasline[1]=1;
174 break;
175 case FaceElements:
176 hasline[2]=1;
177 break;
178 case ReducedFaceElements:
179 hasclass[6]=true;
180 hasline[2]=1;
181 break;
182 default:
183 return false;
184 }
185 }
186 int numLines=hasline[0]+hasline[1]+hasline[2];
187
188 // fail if we have more than one leaf group
189 // = there are at least two branches we can't interpolate between
190 if (numLines > 1)
191 return false;
192 else if (numLines==1) {
193 if (hasline[0]==1)
194 resultcode=Points;
195 else if (hasline[1]==1) {
196 if (hasclass[4])
197 resultcode=ReducedElements;
198 else
199 resultcode=Elements;
200 } else { // hasline[2]==1
201 if (hasclass[6])
202 resultcode=ReducedFaceElements;
203 else
204 resultcode=FaceElements;
205 }
206 } else { // numLines==0
207 if (hasclass[1])
208 resultcode=ReducedNodes;
209 else
210 resultcode=Nodes;
211 }
212 return true;
213 }
214
215 bool RipleyDomain::probeInterpolationOnDomain(int fsType_source,
216 int fsType_target) const
217 {
218 if (fsType_target != Nodes &&
219 fsType_target != ReducedNodes &&
220 fsType_target != Elements &&
221 fsType_target != ReducedElements &&
222 fsType_target != FaceElements &&
223 fsType_target != ReducedFaceElements &&
224 fsType_target != Points) {
225 stringstream msg;
226 msg << "probeInterpolationOnDomain(): Invalid functionspace type "
227 << fsType_target << " for " << getDescription();
228 throw RipleyException(msg.str());
229 }
230
231 switch (fsType_source) {
232 case Nodes:
233 return true;
234 case ReducedNodes:
235 return (fsType_target != Nodes);
236 case Elements:
237 return (fsType_target==Elements ||
238 fsType_target==ReducedElements);
239 case ReducedElements:
240 return (fsType_target==ReducedElements);
241 case FaceElements:
242 return (fsType_target==FaceElements ||
243 fsType_target==ReducedFaceElements);
244 case ReducedFaceElements:
245 return (fsType_target==ReducedFaceElements);
246 case Points:
247 return (fsType_target==Points);
248
249 default: {
250 stringstream msg;
251 msg << "probeInterpolationOnDomain(): Invalid functionspace type "
252 << fsType_source << " for " << getDescription();
253 throw RipleyException(msg.str());
254 }
255 }
256 }
257
258 void RipleyDomain::interpolateOnDomain(escript::Data& target,
259 const escript::Data& in) const
260 {
261 const RipleyDomain& inDomain=dynamic_cast<const RipleyDomain&>(*(in.getFunctionSpace().getDomain()));
262 const RipleyDomain& targetDomain=dynamic_cast<const RipleyDomain&>(*(target.getFunctionSpace().getDomain()));
263 if (inDomain != *this)
264 throw RipleyException("Illegal domain of interpolant");
265 if (targetDomain != *this)
266 throw RipleyException("Illegal domain of interpolation target");
267
268 stringstream msg;
269 msg << "interpolateOnDomain() not implemented for function space "
270 << functionSpaceTypeAsString(in.getFunctionSpace().getTypeCode())
271 << " -> "
272 << functionSpaceTypeAsString(target.getFunctionSpace().getTypeCode());
273
274 const int inFS = in.getFunctionSpace().getTypeCode();
275 const int outFS = target.getFunctionSpace().getTypeCode();
276
277 // simplest case: 1:1 copy
278 if (inFS==outFS) {
279 copyData(target, *const_cast<escript::Data*>(&in));
280 // not allowed: reduced->non-reduced
281 } else if (inFS==ReducedNodes && outFS==Nodes) {
282 throw RipleyException("interpolateOnDomain(): Cannot interpolate reduced data to non-reduced data.");
283 } else if ((inFS==Elements && outFS==ReducedElements)
284 || (inFS==FaceElements && outFS==ReducedFaceElements)) {
285 averageData(target, *const_cast<escript::Data*>(&in));
286 } else {
287 switch (inFS) {
288 case Nodes:
289 case ReducedNodes:
290 switch (outFS) {
291 case Nodes:
292 case ReducedNodes: //FIXME: reduced
293 copyData(target, *const_cast<escript::Data*>(&in));
294 break;
295
296 case Elements:
297 interpolateNodesOnElements(target, *const_cast<escript::Data*>(&in), false);
298 break;
299
300 case ReducedElements:
301 interpolateNodesOnElements(target, *const_cast<escript::Data*>(&in), true);
302 break;
303
304 case FaceElements:
305 interpolateNodesOnFaces(target, *const_cast<escript::Data*>(&in), false);
306 break;
307
308 case ReducedFaceElements:
309 interpolateNodesOnFaces(target, *const_cast<escript::Data*>(&in), true);
310 break;
311
312 default:
313 throw RipleyException(msg.str());
314 }
315 break;
316 default:
317 throw RipleyException(msg.str());
318 }
319 }
320 }
321
322 escript::Data RipleyDomain::getX() const
323 {
324 return escript::continuousFunction(*this).getX();
325 }
326
327 escript::Data RipleyDomain::getNormal() const
328 {
329 return escript::functionOnBoundary(*this).getNormal();
330 }
331
332 escript::Data RipleyDomain::getSize() const
333 {
334 return escript::function(*this).getSize();
335 }
336
337 void RipleyDomain::setToX(escript::Data& arg) const
338 {
339 const RipleyDomain& argDomain=dynamic_cast<const RipleyDomain&>(
340 *(arg.getFunctionSpace().getDomain()));
341 if (argDomain != *this)
342 throw RipleyException("setToX: Illegal domain of data point locations");
343 if (!arg.isExpanded())
344 throw RipleyException("setToX: Expanded Data object expected");
345
346 if (arg.getFunctionSpace().getTypeCode()==Nodes) {
347 assembleCoordinates(arg);
348 } else {
349 // interpolate the result
350 escript::Data contData=escript::Vector(0., escript::continuousFunction(*this), true);
351 assembleCoordinates(contData);
352 interpolateOnDomain(arg, contData);
353 }
354 }
355
356 bool RipleyDomain::isCellOriented(int fsType) const
357 {
358 switch(fsType) {
359 case Nodes:
360 return false;
361 case Elements:
362 case FaceElements:
363 case Points:
364 case ReducedElements:
365 case ReducedFaceElements:
366 return true;
367 default:
368 break;
369 }
370 stringstream msg;
371 msg << "isCellOriented(): Illegal function space type " << fsType
372 << " on " << getDescription();
373 throw RipleyException(msg.str());
374 }
375
376 bool RipleyDomain::canTag(int fsType) const
377 {
378 switch(fsType) {
379 case Nodes:
380 case Elements:
381 case ReducedElements:
382 case FaceElements:
383 case ReducedFaceElements:
384 return true;
385 case Points:
386 return false;
387 default:
388 break;
389 }
390 stringstream msg;
391 msg << "canTag(): Illegal function space type " << fsType << " on "
392 << getDescription();
393 throw RipleyException(msg.str());
394 }
395
396 void RipleyDomain::setTags(const int fsType, const int newTag, const escript::Data& cMask) const
397 {
398 IndexVector* target=NULL;
399 dim_t num=0;
400
401 switch(fsType) {
402 case Nodes:
403 num=getNumNodes();
404 target=&m_nodeTags;
405 break;
406 case Elements:
407 case ReducedElements:
408 num=getNumElements();
409 target=&m_elementTags;
410 break;
411 case FaceElements:
412 case ReducedFaceElements:
413 num=getNumFaceElements();
414 target=&m_faceTags;
415 break;
416 default: {
417 stringstream msg;
418 msg << "setTags(): not implemented for "
419 << functionSpaceTypeAsString(fsType);
420 throw RipleyException(msg.str());
421 }
422 }
423 if (target->size() != num) {
424 target->assign(num, -1);
425 }
426
427 escript::Data& mask=*const_cast<escript::Data*>(&cMask);
428 #pragma omp parallel for
429 for (index_t i=0; i<num; i++) {
430 if (mask.getSampleDataRO(i)[0] > 0) {
431 (*target)[i]=newTag;
432 }
433 }
434 updateTagsInUse(fsType);
435 }
436
437 int RipleyDomain::getTagFromSampleNo(int fsType, int sampleNo) const
438 {
439 switch(fsType) {
440 case Nodes:
441 if (m_nodeTags.size() > sampleNo)
442 return m_nodeTags[sampleNo];
443 break;
444 case Elements:
445 case ReducedElements:
446 if (m_elementTags.size() > sampleNo)
447 return m_elementTags[sampleNo];
448 break;
449 case FaceElements:
450 case ReducedFaceElements:
451 if (m_faceTags.size() > sampleNo)
452 return m_faceTags[sampleNo];
453 break;
454 default: {
455 stringstream msg;
456 msg << "getTagFromSampleNo(): not implemented for "
457 << functionSpaceTypeAsString(fsType);
458 throw RipleyException(msg.str());
459 }
460 }
461 return -1;
462 }
463
464 int RipleyDomain::getNumberOfTagsInUse(int fsType) const
465 {
466 switch(fsType) {
467 case Nodes:
468 return m_nodeTagsInUse.size();
469 case Elements:
470 case ReducedElements:
471 return m_elementTagsInUse.size();
472 case FaceElements:
473 case ReducedFaceElements:
474 return m_faceTagsInUse.size();
475 default: {
476 stringstream msg;
477 msg << "getNumberOfTagsInUse(): not implemented for "
478 << functionSpaceTypeAsString(fsType);
479 throw RipleyException(msg.str());
480 }
481 }
482 }
483
484 const int* RipleyDomain::borrowListOfTagsInUse(int fsType) const
485 {
486 switch(fsType) {
487 case Nodes:
488 return &m_nodeTagsInUse[0];
489 case Elements:
490 case ReducedElements:
491 return &m_elementTagsInUse[0];
492 case FaceElements:
493 case ReducedFaceElements:
494 return &m_faceTagsInUse[0];
495 default: {
496 stringstream msg;
497 msg << "borrowListOfTagsInUse(): not implemented for "
498 << functionSpaceTypeAsString(fsType);
499 throw RipleyException(msg.str());
500 }
501 }
502 }
503
504 void RipleyDomain::Print_Mesh_Info(const bool full) const
505 {
506 cout << "Print_Mesh_Info for " << getDescription() << " running on CPU "
507 << m_mpiInfo->rank << ". MPI size: " << m_mpiInfo->size << endl;
508 cout << "Number of dimensions: " << m_numDim << endl;
509
510 // write tags
511 if (m_tagMap.size() > 0) {
512 cout << "Tags:" << endl;
513 TagMap::const_iterator it;
514 for (it=m_tagMap.begin(); it!=m_tagMap.end(); it++) {
515 cout << " " << setw(5) << it->second << " "
516 << it->first << endl;
517 }
518 }
519 }
520
521 int RipleyDomain::getSystemMatrixTypeId(const int solver,
522 const int preconditioner, const int package, const bool symmetry) const
523 {
524 return SystemMatrixAdapter::getSystemMatrixTypeId(solver, preconditioner,
525 package, symmetry, m_mpiInfo);
526 }
527
528 int RipleyDomain::getTransportTypeId(const int solver, const int preconditioner,
529 const int package, const bool symmetry) const
530 {
531 return TransportProblemAdapter::getTransportTypeId(solver, preconditioner,
532 package, symmetry, m_mpiInfo);
533 }
534
535 escript::ASM_ptr RipleyDomain::newSystemMatrix(const int row_blocksize,
536 const escript::FunctionSpace& row_functionspace,
537 const int column_blocksize,
538 const escript::FunctionSpace& column_functionspace,
539 const int type) const
540 {
541 bool reduceRowOrder=false;
542 bool reduceColOrder=false;
543 // is the domain right?
544 const RipleyDomain& row_domain=dynamic_cast<const RipleyDomain&>(*(row_functionspace.getDomain()));
545 if (row_domain!=*this)
546 throw RipleyException("newSystemMatrix(): Domain of row function space does not match the domain of matrix generator");
547 const RipleyDomain& col_domain=dynamic_cast<const RipleyDomain&>(*(column_functionspace.getDomain()));
548 if (col_domain!=*this)
549 throw RipleyException("newSystemMatrix(): Domain of column function space does not match the domain of matrix generator");
550 // is the function space type right?
551 if (row_functionspace.getTypeCode()==ReducedNodes)
552 reduceRowOrder=true;
553 else if (row_functionspace.getTypeCode()!=Nodes)
554 throw RipleyException("newSystemMatrix(): Illegal function space type for system matrix rows");
555 if (column_functionspace.getTypeCode()==ReducedNodes)
556 reduceColOrder=true;
557 else if (column_functionspace.getTypeCode()!=Nodes)
558 throw RipleyException("newSystemMatrix(): Illegal function space type for system matrix columns");
559
560 // generate matrix
561 Paso_SystemMatrixPattern* pattern=getPattern(reduceRowOrder, reduceColOrder);
562 Paso_SystemMatrix* matrix = Paso_SystemMatrix_alloc(type, pattern,
563 row_blocksize, column_blocksize, FALSE);
564 paso::checkPasoError();
565 Paso_SystemMatrixPattern_free(pattern);
566 escript::ASM_ptr sma(new SystemMatrixAdapter(matrix, row_blocksize,
567 row_functionspace, column_blocksize, column_functionspace));
568 return sma;
569 }
570
571 void RipleyDomain::setNewX(const escript::Data& arg)
572 {
573 throw RipleyException("setNewX(): Operation not supported");
574 }
575
576 //protected
577 void RipleyDomain::averageData(escript::Data& out, escript::Data& in) const
578 {
579 const dim_t numComp = in.getDataPointSize();
580 const dim_t dpp = in.getNumDataPointsPerSample();
581 out.requireWrite();
582 #pragma omp parallel for
583 for (index_t i=0; i<in.getNumSamples(); i++) {
584 const double* src = in.getSampleDataRO(i);
585 double* dest = out.getSampleDataRW(i);
586 for (index_t c=0; c<numComp; c++) {
587 double res=0.;
588 for (index_t q=0; q<dpp; q++)
589 res+=src[c+q*numComp];
590 *dest++ = res/dpp;
591 }
592 }
593 }
594
595 //protected
596 void RipleyDomain::copyData(escript::Data& out, escript::Data& in) const
597 {
598 const dim_t numComp = in.getDataPointSize();
599 out.requireWrite();
600 #pragma omp parallel for
601 for (index_t i=0; i<in.getNumSamples(); i++) {
602 const double* src = in.getSampleDataRO(i);
603 copy(src, src+numComp, out.getSampleDataRW(i));
604 }
605 }
606
607 //protected
608 void RipleyDomain::updateTagsInUse(int fsType) const
609 {
610 IndexVector* tagsInUse=NULL;
611 const IndexVector* tags=NULL;
612 switch(fsType) {
613 case Nodes:
614 tags=&m_nodeTags;
615 tagsInUse=&m_nodeTagsInUse;
616 break;
617 case Elements:
618 case ReducedElements:
619 tags=&m_elementTags;
620 tagsInUse=&m_elementTagsInUse;
621 break;
622 case FaceElements:
623 case ReducedFaceElements:
624 tags=&m_faceTags;
625 tagsInUse=&m_faceTagsInUse;
626 break;
627 default:
628 return;
629 }
630
631 // gather global unique tag values from tags into tagsInUse
632 tagsInUse->clear();
633 index_t lastFoundValue = INDEX_T_MIN, minFoundValue, local_minFoundValue;
634
635 while (true) {
636 // find smallest value bigger than lastFoundValue
637 minFoundValue = INDEX_T_MAX;
638 #pragma omp parallel private(local_minFoundValue)
639 {
640 local_minFoundValue = minFoundValue;
641 #pragma omp for schedule(static) nowait
642 for (size_t i = 0; i < tags->size(); i++) {
643 const index_t v = (*tags)[i];
644 if ((v > lastFoundValue) && (v < local_minFoundValue))
645 local_minFoundValue = v;
646 }
647 #pragma omp critical
648 {
649 if (local_minFoundValue < minFoundValue)
650 minFoundValue = local_minFoundValue;
651 }
652 }
653 #ifdef ESYS_MPI
654 local_minFoundValue = minFoundValue;
655 MPI_Allreduce(&local_minFoundValue, &minFoundValue, 1, MPI_INT, MPI_MIN, m_mpiInfo->comm);
656 #endif
657
658 // if we found a new value add it to the tagsInUse vector
659 if (minFoundValue < INDEX_T_MAX) {
660 tagsInUse->push_back(minFoundValue);
661 lastFoundValue = minFoundValue;
662 } else
663 break;
664 }
665 }
666
667 //
668 // the methods that follow have to be implemented by the subclasses
669 //
670
671 string RipleyDomain::getDescription() const
672 {
673 throw RipleyException("getDescription() not implemented");
674 }
675
676 void RipleyDomain::write(const string& filename) const
677 {
678 throw RipleyException("write() not implemented");
679 }
680
681 void RipleyDomain::dump(const string& filename) const
682 {
683 throw RipleyException("dump() not implemented");
684 }
685
686 const int* RipleyDomain::borrowSampleReferenceIDs(int fsType) const
687 {
688 throw RipleyException("borrowSampleReferenceIDs() not implemented");
689 }
690
691 void RipleyDomain::interpolateACross(escript::Data& target, const escript::Data& source) const
692 {
693 throw RipleyException("interpolateACross() not implemented");
694 }
695
696 bool RipleyDomain::probeInterpolationACross(int fsType_source,
697 const escript::AbstractDomain&, int fsType_target) const
698 {
699 throw RipleyException("probeInterpolationACross() not implemented");
700 }
701
702 void RipleyDomain::setToNormal(escript::Data& normal) const
703 {
704 throw RipleyException("setToNormal() not implemented");
705 }
706
707 void RipleyDomain::setToSize(escript::Data& size) const
708 {
709 throw RipleyException("setToSize() not implemented");
710 }
711
712 void RipleyDomain::setToGradient(escript::Data& grad, const escript::Data& arg) const
713 {
714 throw RipleyException("setToGradient() not implemented");
715 }
716
717 void RipleyDomain::setToIntegrals(vector<double>& integrals, const escript::Data& arg) const
718 {
719 throw RipleyException("setToIntegrals() not implemented");
720 }
721
722 bool RipleyDomain::ownSample(int fsType, index_t id) const
723 {
724 throw RipleyException("ownSample() not implemented");
725 }
726
727 void RipleyDomain::addPDEToSystem(
728 escript::AbstractSystemMatrix& mat, escript::Data& rhs,
729 const escript::Data& A, const escript::Data& B, const escript::Data& C,
730 const escript::Data& D, const escript::Data& X, const escript::Data& Y,
731 const escript::Data& d, const escript::Data& y,
732 const escript::Data& d_contact, const escript::Data& y_contact,
733 const escript::Data& d_dirac,const escript::Data& y_dirac) const
734 {
735 throw RipleyException("addPDEToSystem() not implemented");
736 }
737
738 void RipleyDomain::addPDEToLumpedSystem(escript::Data& mat,
739 const escript::Data& D, const escript::Data& d,
740 const escript::Data& d_dirac, const bool useHRZ) const
741 {
742 throw RipleyException("addPDEToLumpedSystem() not implemented");
743 }
744
745 void RipleyDomain::addPDEToRHS(escript::Data& rhs, const escript::Data& X,
746 const escript::Data& Y, const escript::Data& y,
747 const escript::Data& y_contact, const escript::Data& y_dirac) const
748 {
749 throw RipleyException("addPDEToRHS() not implemented");
750 }
751
752 void RipleyDomain::addPDEToTransportProblem(
753 escript::AbstractTransportProblem& tp,
754 escript::Data& source, const escript::Data& M,
755 const escript::Data& A, const escript::Data& B, const escript::Data& C,
756 const escript::Data& D, const escript::Data& X, const escript::Data& Y,
757 const escript::Data& d, const escript::Data& y,
758 const escript::Data& d_contact, const escript::Data& y_contact,
759 const escript::Data& d_dirac, const escript::Data& y_dirac) const
760 {
761 throw RipleyException("addPDEToTransportProblem() not implemented");
762 }
763
764 escript::ATP_ptr RipleyDomain::newTransportProblem(const bool useBackwardEuler,
765 const int blocksize, const escript::FunctionSpace& functionspace,
766 const int type) const
767 {
768 throw RipleyException("newTransportProblem() not implemented");
769 }
770
771 Paso_SystemMatrixPattern* RipleyDomain::getPattern(bool reducedRowOrder,
772 bool reducedColOrder) const
773 {
774 throw RipleyException("getPattern() not implemented");
775 }
776
777 dim_t RipleyDomain::getNumDataPointsGlobal() const
778 {
779 throw RipleyException("getNumDataPointsGlobal() not implemented");
780 }
781
782 IndexVector RipleyDomain::getNumNodesPerDim() const
783 {
784 throw RipleyException("getNumNodesPerDim() not implemented");
785 }
786
787 IndexVector RipleyDomain::getNumElementsPerDim() const
788 {
789 throw RipleyException("getNumElementsPerDim() not implemented");
790 }
791
792 IndexVector RipleyDomain::getNumFacesPerBoundary() const
793 {
794 throw RipleyException("getNumFacesPerBoundary() not implemented");
795 }
796
797 IndexVector RipleyDomain::getNodeDistribution() const
798 {
799 throw RipleyException("getNodeDistribution() not implemented");
800 }
801
802 pair<double,double> RipleyDomain::getFirstCoordAndSpacing(dim_t dim) const
803 {
804 throw RipleyException("getFirstCoordAndSpacing() not implemented");
805 }
806
807 dim_t RipleyDomain::getNumFaceElements() const
808 {
809 throw RipleyException("getNumFaceElements() not implemented");
810 }
811
812 dim_t RipleyDomain::getNumElements() const
813 {
814 throw RipleyException("getNumElements() not implemented");
815 }
816
817 dim_t RipleyDomain::getNumNodes() const
818 {
819 throw RipleyException("getNumNodes() not implemented");
820 }
821
822 void RipleyDomain::assembleCoordinates(escript::Data& arg) const
823 {
824 throw RipleyException("assembleCoordinates() not implemented");
825 }
826
827 void RipleyDomain::interpolateNodesOnElements(escript::Data& out, escript::Data& in, bool reduced) const
828 {
829 throw RipleyException("interpolateNodesOnElements() not implemented");
830 }
831
832 void RipleyDomain::interpolateNodesOnFaces(escript::Data& out, escript::Data& in, bool reduced) const
833 {
834 throw RipleyException("interpolateNodesOnFaces() not implemented");
835 }
836
837
838 } // end of namespace ripley
839

  ViewVC Help
Powered by ViewVC 1.1.26