/[escript]/trunk/ripley/src/RipleyDomain.cpp
ViewVC logotype

Diff of /trunk/ripley/src/RipleyDomain.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3722 by caltinay, Wed Dec 7 05:53:22 2011 UTC revision 3748 by caltinay, Thu Dec 15 07:36:19 2011 UTC
# Line 47  RipleyDomain::~RipleyDomain() Line 47  RipleyDomain::~RipleyDomain()
47      Esys_MPIInfo_free(m_mpiInfo);      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  bool RipleyDomain::isValidFunctionSpaceType(int fsType) const
62  {  {
63      switch (fsType) {      switch (fsType) {
         case DegreesOfFreedom:  
         case ReducedDegreesOfFreedom:  
64          case Nodes:          case Nodes:
65          case ReducedNodes:          case ReducedNodes:
66          case Elements:          case Elements:
# Line 69  bool RipleyDomain::isValidFunctionSpaceT Line 78  bool RipleyDomain::isValidFunctionSpaceT
78  string RipleyDomain::functionSpaceTypeAsString(int fsType) const  string RipleyDomain::functionSpaceTypeAsString(int fsType) const
79  {  {
80      switch (fsType) {      switch (fsType) {
         case DegreesOfFreedom: return "Ripley_DegreesOfFreedom";  
         case ReducedDegreesOfFreedom: return "Ripley_ReducedDegreesOfFreedom";  
81          case Nodes: return "Ripley_Nodes";          case Nodes: return "Ripley_Nodes";
82          case ReducedNodes: return "Ripley_Reduced_Nodes";          case ReducedNodes: return "Ripley_Reduced_Nodes";
83          case Elements: return "Ripley_Elements";          case Elements: return "Ripley_Elements";
# Line 89  pair<int,int> RipleyDomain::getDataShape Line 96  pair<int,int> RipleyDomain::getDataShape
96      const int ptsPerSample = (m_numDim==2 ? 4 : 8);      const int ptsPerSample = (m_numDim==2 ? 4 : 8);
97      switch (fsType) {      switch (fsType) {
98          case Nodes:          case Nodes:
99          case ReducedNodes:          case ReducedNodes: //FIXME: reduced
         case DegreesOfFreedom:  
         case ReducedDegreesOfFreedom:  
100              return pair<int,int>(1, getNumNodes());              return pair<int,int>(1, getNumNodes());
101          case Elements:          case Elements:
102              return pair<int,int>(ptsPerSample, getNumElements());              return pair<int,int>(ptsPerSample, getNumElements());
# Line 101  pair<int,int> RipleyDomain::getDataShape Line 106  pair<int,int> RipleyDomain::getDataShape
106              return pair<int,int>(1, getNumElements());              return pair<int,int>(1, getNumElements());
107          case ReducedFaceElements:          case ReducedFaceElements:
108              return pair<int,int>(1, getNumFaceElements());              return pair<int,int>(1, getNumFaceElements());
             /*  
109          case Points:          case Points:
110              return pair<int,int>(1, getNumPoints());              return pair<int,int>(1, 0); //FIXME: dirac
             */  
111          default:          default:
112              break;              break;
113      }      }
114    
115      stringstream msg;      stringstream msg;
116      msg << "getDataShape(): Unsupported function space type "      msg << "getDataShape(): Unsupported function space type " << fsType
117          << functionSpaceTypeAsString(fsType) << " for " << getDescription();          << " for " << getDescription();
118      throw RipleyException(msg.str());      throw RipleyException(msg.str());
119  }  }
120    
# Line 131  bool RipleyDomain::commonFunctionSpace(c Line 134  bool RipleyDomain::commonFunctionSpace(c
134     /*     /*
135      The idea is to use equivalence classes (i.e. types which can be      The idea is to use equivalence classes (i.e. types which can be
136      interpolated back and forth):      interpolated back and forth):
137      class 1: DOF <-> Nodes      class 0: Nodes
138      class 2: ReducedDOF <-> ReducedNodes      class 1: ReducedNodes
139      class 3: Points      class 2: Points
140      class 4: Elements      class 3: Elements
141      class 5: ReducedElements      class 4: ReducedElements
142      class 6: FaceElements      class 5: FaceElements
143      class 7: ReducedFaceElements      class 6: ReducedFaceElements
     class 8: ContactElementZero <-> ContactElementOne  
     class 9: ReducedContactElementZero <-> ReducedContactElementOne  
144    
145      There is also a set of lines. Interpolation is possible down a line but not      There is also a set of lines. Interpolation is possible down a line but not
146      between lines.      between lines.
147      class 1 and 2 belong to all lines so aren't considered.      class 0 and 1 belong to all lines so aren't considered.
148      line 0: class 3      line 0: class 2
149      line 1: class 4,5      line 1: class 3,4
150      line 2: class 6,7      line 2: class 5,6
     line 3: class 8,9  
   
     For classes with multiple members (eg class 2) we have vars to record if  
     there is at least one instance. e.g. hasnodes is true if we have at least  
     one instance of Nodes.  
151      */      */
152      if (fs.empty())      if (fs.empty())
153          return false;          return false;
154      vector<int> hasclass(10);      vector<bool> hasclass(7, false);
155      vector<int> hasline(4);      vector<int> hasline(3, 0);
156      bool hasnodes=false;      for (size_t i=0; i<fs.size(); ++i) {
     bool hasrednodes=false;  
     for (int i=0;i<fs.size();++i) {  
157          switch (fs[i]) {          switch (fs[i]) {
158              case Nodes: hasnodes=true; // no break is deliberate              case Nodes:
159              case DegreesOfFreedom:                  hasclass[0]=true;
                 hasclass[1]=1;  
160                  break;                  break;
161              case ReducedNodes: hasrednodes=true; // no break is deliberate              case ReducedNodes:
162              case ReducedDegreesOfFreedom:                  hasclass[1]=true;
                 hasclass[2]=1;  
163                  break;                  break;
164              case Points:              case Points:
165                  hasline[0]=1;                  hasline[0]=1;
166                  hasclass[3]=1;                  hasclass[2]=true;
167                  break;                  break;
168              case Elements:              case Elements:
                 hasclass[4]=1;  
169                  hasline[1]=1;                  hasline[1]=1;
170                  break;                  break;
171              case ReducedElements:              case ReducedElements:
172                  hasclass[5]=1;                  hasclass[4]=true;
173                  hasline[1]=1;                  hasline[1]=1;
174                  break;                  break;
175              case FaceElements:              case FaceElements:
                 hasclass[6]=1;  
176                  hasline[2]=1;                  hasline[2]=1;
177                  break;                  break;
178              case ReducedFaceElements:              case ReducedFaceElements:
179                  hasclass[7]=1;                  hasclass[6]=true;
180                  hasline[2]=1;                  hasline[2]=1;
181                  break;                  break;
182              default:              default:
183                  return false;                  return false;
184          }          }
185      }      }
186      int totlines=hasline[0]+hasline[1]+hasline[2]+hasline[3];      int numLines=hasline[0]+hasline[1]+hasline[2];
187    
188      // fail if we have more than one leaf group      // fail if we have more than one leaf group
189      // = there are at least two branches we can't interpolate between      // = there are at least two branches we can't interpolate between
190      if (totlines>1)      if (numLines > 1)
191          return false;          return false;
192      else if (totlines==1) {      else if (numLines==1) {
         // we have points  
193          if (hasline[0]==1)          if (hasline[0]==1)
194              resultcode=Points;              resultcode=Points;
195          else if (hasline[1]==1) {          else if (hasline[1]==1) {
196              if (hasclass[5]==1)              if (hasclass[4])
197                  resultcode=ReducedElements;                  resultcode=ReducedElements;
198              else              else
199                  resultcode=Elements;                  resultcode=Elements;
200          } else if (hasline[2]==1) {          } else { // hasline[2]==1
201              if (hasclass[7]==1)              if (hasclass[6])
202                  resultcode=ReducedFaceElements;                  resultcode=ReducedFaceElements;
203              else              else
204                  resultcode=FaceElements;                  resultcode=FaceElements;
205          } else          }
206              throw RipleyException("Internal Ripley Error!");      } else { // numLines==0
207      } else { // totlines==0          if (hasclass[1])
208          if (hasclass[2]==1)              resultcode=ReducedNodes;
209              // something from class 2          else
210              resultcode=(hasrednodes ? ReducedNodes : ReducedDegreesOfFreedom);              resultcode=Nodes;
         else // something from class 1  
             resultcode=(hasnodes ? Nodes : DegreesOfFreedom);  
211      }      }
212      return true;      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,  void RipleyDomain::interpolateOnDomain(escript::Data& target,
259                                         const escript::Data& in) const                                         const escript::Data& in) const
260  {  {
# Line 241  void RipleyDomain::interpolateOnDomain(e Line 271  void RipleyDomain::interpolateOnDomain(e
271          << " -> "          << " -> "
272          << functionSpaceTypeAsString(target.getFunctionSpace().getTypeCode());          << functionSpaceTypeAsString(target.getFunctionSpace().getTypeCode());
273    
274      switch (in.getFunctionSpace().getTypeCode()) {      const int inFS = in.getFunctionSpace().getTypeCode();
275          case Nodes:      const int outFS = target.getFunctionSpace().getTypeCode();
         case ReducedNodes:  
         case DegreesOfFreedom:  
         case ReducedDegreesOfFreedom:  
             switch (target.getFunctionSpace().getTypeCode()) {  
                 case Nodes:  
                 case ReducedNodes:  
                 case DegreesOfFreedom:  
                 case ReducedDegreesOfFreedom:  
                     // FIXME  
                     copyNodalData(target, *const_cast<escript::Data*>(&in));  
                     break;  
   
                 case Elements:  
                     interpolateNodesOnElements(target, *const_cast<escript::Data*>(&in), false);  
                     break;  
   
                 case ReducedElements:  
                     interpolateNodesOnElements(target, *const_cast<escript::Data*>(&in), true);  
                     break;  
   
                 case FaceElements:  
                     interpolateNodesOnFaces(target, *const_cast<escript::Data*>(&in), false);  
                     break;  
   
                 case ReducedFaceElements:  
                     interpolateNodesOnFaces(target, *const_cast<escript::Data*>(&in), true);  
                     break;  
276    
277                  default:      // simplest case: 1:1 copy
278                      throw RipleyException(msg.str());      if (inFS==outFS) {
279              }          copyData(target, *const_cast<escript::Data*>(&in));
280              break;      // not allowed: reduced->non-reduced
281          default:      } else if (inFS==ReducedNodes && outFS==Nodes) {
282              throw RipleyException(msg.str());          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    
# Line 318  bool RipleyDomain::isCellOriented(int fs Line 357  bool RipleyDomain::isCellOriented(int fs
357  {  {
358      switch(fsType) {      switch(fsType) {
359          case Nodes:          case Nodes:
         case DegreesOfFreedom:  
         case ReducedDegreesOfFreedom:  
360              return false;              return false;
361          case Elements:          case Elements:
362          case FaceElements:          case FaceElements:
# Line 331  bool RipleyDomain::isCellOriented(int fs Line 368  bool RipleyDomain::isCellOriented(int fs
368              break;              break;
369      }      }
370      stringstream msg;      stringstream msg;
371      msg << "isCellOriented(): Illegal function space type " << fsType << " on " << getDescription();      msg << "isCellOriented(): Illegal function space type " << fsType
372            << " on " << getDescription();
373      throw RipleyException(msg.str());      throw RipleyException(msg.str());
374  }  }
375    
# Line 344  bool RipleyDomain::canTag(int fsType) co Line 382  bool RipleyDomain::canTag(int fsType) co
382          case FaceElements:          case FaceElements:
383          case ReducedFaceElements:          case ReducedFaceElements:
384              return true;              return true;
         case DegreesOfFreedom:  
         case ReducedDegreesOfFreedom:  
385          case Points:          case Points:
386              return false;              return false;
387          default:          default:
388              break;              break;
389      }      }
390      stringstream msg;      stringstream msg;
391      msg << "canTag(): Illegal function space type " << fsType << " on " << getDescription();      msg << "canTag(): Illegal function space type " << fsType << " on "
392            << getDescription();
393      throw RipleyException(msg.str());      throw RipleyException(msg.str());
394  }  }
395    
# Line 378  void RipleyDomain::setTags(const int fsT Line 415  void RipleyDomain::setTags(const int fsT
415              break;              break;
416          default: {          default: {
417              stringstream msg;              stringstream msg;
418              msg << "setTags(): not implemented for " << functionSpaceTypeAsString(fsType);              msg << "setTags(): not implemented for "
419                    << functionSpaceTypeAsString(fsType);
420              throw RipleyException(msg.str());              throw RipleyException(msg.str());
421          }          }
422      }      }
# Line 415  int RipleyDomain::getTagFromSampleNo(int Line 453  int RipleyDomain::getTagFromSampleNo(int
453              break;              break;
454          default: {          default: {
455              stringstream msg;              stringstream msg;
456              msg << "getTagFromSampleNo(): not implemented for " << functionSpaceTypeAsString(fsType);              msg << "getTagFromSampleNo(): not implemented for "
457                    << functionSpaceTypeAsString(fsType);
458              throw RipleyException(msg.str());              throw RipleyException(msg.str());
459          }          }
460      }      }
# Line 435  int RipleyDomain::getNumberOfTagsInUse(i Line 474  int RipleyDomain::getNumberOfTagsInUse(i
474              return m_faceTagsInUse.size();              return m_faceTagsInUse.size();
475          default: {          default: {
476              stringstream msg;              stringstream msg;
477              msg << "getNumberOfTagsInUse(): not implemented for " << functionSpaceTypeAsString(fsType);              msg << "getNumberOfTagsInUse(): not implemented for "
478                    << functionSpaceTypeAsString(fsType);
479              throw RipleyException(msg.str());              throw RipleyException(msg.str());
480          }          }
481      }      }
# Line 454  const int* RipleyDomain::borrowListOfTag Line 494  const int* RipleyDomain::borrowListOfTag
494              return &m_faceTagsInUse[0];              return &m_faceTagsInUse[0];
495          default: {          default: {
496              stringstream msg;              stringstream msg;
497              msg << "borrowListOfTagsInUse(): not implemented for " << functionSpaceTypeAsString(fsType);              msg << "borrowListOfTagsInUse(): not implemented for "
498                    << functionSpaceTypeAsString(fsType);
499              throw RipleyException(msg.str());              throw RipleyException(msg.str());
500          }          }
501      }      }
# Line 502  escript::ASM_ptr RipleyDomain::newSystem Line 543  escript::ASM_ptr RipleyDomain::newSystem
543      // is the domain right?      // is the domain right?
544      const RipleyDomain& row_domain=dynamic_cast<const RipleyDomain&>(*(row_functionspace.getDomain()));      const RipleyDomain& row_domain=dynamic_cast<const RipleyDomain&>(*(row_functionspace.getDomain()));
545      if (row_domain!=*this)      if (row_domain!=*this)
546          throw RipleyException("Domain of row function space does not match the domain of matrix generator");          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()));      const RipleyDomain& col_domain=dynamic_cast<const RipleyDomain&>(*(column_functionspace.getDomain()));
548      if (col_domain!=*this)      if (col_domain!=*this)
549          throw RipleyException("Domain of column function space does not match the domain of matrix generator");          throw RipleyException("newSystemMatrix(): Domain of column function space does not match the domain of matrix generator");
550      // is the function space type right?      // is the function space type right?
551      if (row_functionspace.getTypeCode()==ReducedDegreesOfFreedom)      if (row_functionspace.getTypeCode()==ReducedNodes)
552          reduceRowOrder=true;          reduceRowOrder=true;
553      else if (row_functionspace.getTypeCode()!=DegreesOfFreedom)      else if (row_functionspace.getTypeCode()!=Nodes)
554          throw RipleyException("Illegal function space type for system matrix rows");          throw RipleyException("newSystemMatrix(): Illegal function space type for system matrix rows");
555      if (column_functionspace.getTypeCode()==ReducedDegreesOfFreedom)      if (column_functionspace.getTypeCode()==ReducedNodes)
556          reduceColOrder=true;          reduceColOrder=true;
557      else if (column_functionspace.getTypeCode()!=DegreesOfFreedom)      else if (column_functionspace.getTypeCode()!=Nodes)
558          throw RipleyException("Illegal function space type for system matrix columns");          throw RipleyException("newSystemMatrix(): Illegal function space type for system matrix columns");
559    
560      // generate matrix      // generate matrix
561      Paso_SystemMatrixPattern* pattern=getPattern(reduceRowOrder, reduceColOrder);      Paso_SystemMatrixPattern* pattern=getPattern(reduceRowOrder, reduceColOrder);
# Line 527  escript::ASM_ptr RipleyDomain::newSystem Line 568  escript::ASM_ptr RipleyDomain::newSystem
568      return sma;      return sma;
569  }  }
570    
571    void RipleyDomain::addPDEToSystem(
572            escript::AbstractSystemMatrix& mat, escript::Data& rhs,
573            const escript::Data& A, const escript::Data& B, const escript::Data& C,
574            const escript::Data& D, const escript::Data& X, const escript::Data& Y,
575            const escript::Data& d, const escript::Data& y,
576            const escript::Data& d_contact, const escript::Data& y_contact,
577            const escript::Data& d_dirac,const escript::Data& y_dirac) const
578    {
579        if (!d_contact.isEmpty() || !y_contact.isEmpty())
580            throw RipleyException("addPDEToSystem(): Ripley does not support contact elements");
581    
582        paso::SystemMatrixAdapter* sma=dynamic_cast<paso::SystemMatrixAdapter*>(&mat);
583        if (!sma)
584            throw RipleyException("addPDEToSystem(): Ripley only accepts Paso system matrices");
585    
586        if (rhs.isEmpty() && (!X.isEmpty() || !Y.isEmpty()))
587            throw RipleyException("addPDEToSystem(): Right hand side coefficients are provided but no right hand side vector given");
588    
589        //TODO: more input param checks (shape, function space etc)
590    
591        Paso_SystemMatrix* S = sma->getPaso_SystemMatrix();
592    
593        if (!rhs.isEmpty() && rhs.getDataPointSize() != S->logical_row_block_size)
594            throw RipleyException("addPDEToSystem(): Matrix row block size and number of components of right hand side don't match");
595    
596        const int numEq=S->logical_row_block_size;
597        const int numComp=S->logical_col_block_size;
598    
599        if (numEq != numComp)
600            throw RipleyException("addPDEToSystem(): Number of equations and number of solutions don't match");
601        //TODO: more system matrix checks
602    
603        if (numEq==1)
604            assemblePDESingle(S, rhs, A, B, C, D, X, Y, d, y);
605        else
606            assemblePDESystem(S, rhs, A, B, C, D, X, Y, d, y);
607    }
608    
609  void RipleyDomain::setNewX(const escript::Data& arg)  void RipleyDomain::setNewX(const escript::Data& arg)
610  {  {
611      throw RipleyException("setNewX(): Operation not supported");      throw RipleyException("setNewX(): Operation not supported");
612  }  }
613    
614  //protected  //protected
615  void RipleyDomain::copyNodalData(escript::Data& out, escript::Data& in) const  void RipleyDomain::averageData(escript::Data& out, escript::Data& in) const
616    {
617        const dim_t numComp = in.getDataPointSize();
618        const dim_t dpp = in.getNumDataPointsPerSample();
619        out.requireWrite();
620    #pragma omp parallel for
621        for (index_t i=0; i<in.getNumSamples(); i++) {
622            const double* src = in.getSampleDataRO(i);
623            double* dest = out.getSampleDataRW(i);
624            for (index_t c=0; c<numComp; c++) {
625                double res=0.;
626                for (index_t q=0; q<dpp; q++)
627                    res+=src[c+q*numComp];
628                *dest++ = res/dpp;
629            }
630        }
631    }
632    
633    //protected
634    void RipleyDomain::copyData(escript::Data& out, escript::Data& in) const
635  {  {
636      const dim_t numComp = in.getDataPointSize();      const dim_t numComp = in.getDataPointSize();
637        out.requireWrite();
638  #pragma omp parallel for  #pragma omp parallel for
639      for (index_t i=0; i<in.getNumSamples(); i++) {      for (index_t i=0; i<in.getNumSamples(); i++) {
640          const double* src = in.getSampleDataRO(i);          const double* src = in.getSampleDataRO(i);
# Line 593  void RipleyDomain::updateTagsInUse(int f Line 692  void RipleyDomain::updateTagsInUse(int f
692          local_minFoundValue = minFoundValue;          local_minFoundValue = minFoundValue;
693          MPI_Allreduce(&local_minFoundValue, &minFoundValue, 1, MPI_INT, MPI_MIN, m_mpiInfo->comm);          MPI_Allreduce(&local_minFoundValue, &minFoundValue, 1, MPI_INT, MPI_MIN, m_mpiInfo->comm);
694  #endif  #endif
         // if we found a new value add it to the tagsInUse vector  
695    
696            // if we found a new value add it to the tagsInUse vector
697          if (minFoundValue < INDEX_T_MAX) {          if (minFoundValue < INDEX_T_MAX) {
698              tagsInUse->push_back(minFoundValue);              tagsInUse->push_back(minFoundValue);
699              lastFoundValue = minFoundValue;              lastFoundValue = minFoundValue;
# Line 612  string RipleyDomain::getDescription() co Line 711  string RipleyDomain::getDescription() co
711      throw RipleyException("getDescription() not implemented");      throw RipleyException("getDescription() not implemented");
712  }  }
713    
 bool RipleyDomain::operator==(const AbstractDomain& other) const  
 {  
     throw RipleyException("operator==() not implemented");  
 }  
   
714  void RipleyDomain::write(const string& filename) const  void RipleyDomain::write(const string& filename) const
715  {  {
716      throw RipleyException("write() not implemented");      throw RipleyException("write() not implemented");
# Line 632  const int* RipleyDomain::borrowSampleRef Line 726  const int* RipleyDomain::borrowSampleRef
726      throw RipleyException("borrowSampleReferenceIDs() not implemented");      throw RipleyException("borrowSampleReferenceIDs() not implemented");
727  }  }
728    
 bool RipleyDomain::probeInterpolationOnDomain(int fsType_source,  
                                              int fsType_target) const  
 {  
     throw RipleyException("probeInterpolationOnDomain() not implemented");  
 }  
   
729  void RipleyDomain::interpolateACross(escript::Data& target, const escript::Data& source) const  void RipleyDomain::interpolateACross(escript::Data& target, const escript::Data& source) const
730  {  {
731      throw RipleyException("interpolateACross() not implemented");      throw RipleyException("interpolateACross() not implemented");
# Line 674  bool RipleyDomain::ownSample(int fsType, Line 762  bool RipleyDomain::ownSample(int fsType,
762      throw RipleyException("ownSample() not implemented");      throw RipleyException("ownSample() not implemented");
763  }  }
764    
 void RipleyDomain::addPDEToSystem(  
         escript::AbstractSystemMatrix& mat, escript::Data& rhs,  
         const escript::Data& A, const escript::Data& B, const escript::Data& C,  
         const escript::Data& D, const escript::Data& X, const escript::Data& Y,  
         const escript::Data& d, const escript::Data& y,  
         const escript::Data& d_contact, const escript::Data& y_contact,  
         const escript::Data& d_dirac,const escript::Data& y_dirac) const  
 {  
     throw RipleyException("addPDEToSystem() not implemented");  
 }  
   
765  void RipleyDomain::addPDEToLumpedSystem(escript::Data& mat,  void RipleyDomain::addPDEToLumpedSystem(escript::Data& mat,
766          const escript::Data& D, const escript::Data& d,          const escript::Data& D, const escript::Data& d,
767          const escript::Data& d_dirac, const bool useHRZ) const          const escript::Data& d_dirac, const bool useHRZ) const
# Line 774  void RipleyDomain::assembleCoordinates(e Line 851  void RipleyDomain::assembleCoordinates(e
851      throw RipleyException("assembleCoordinates() not implemented");      throw RipleyException("assembleCoordinates() not implemented");
852  }  }
853    
854    void RipleyDomain::assemblePDESingle(Paso_SystemMatrix* mat, escript::Data& rhs,
855            const escript::Data& A, const escript::Data& B, const escript::Data& C,
856            const escript::Data& D, const escript::Data& X, const escript::Data& Y,
857            const escript::Data& d, const escript::Data& y) const
858    {
859        throw RipleyException("assemblePDESingle() not implemented");
860    }
861    
862    void RipleyDomain::assemblePDESystem(Paso_SystemMatrix* mat, escript::Data& rhs,
863            const escript::Data& A, const escript::Data& B, const escript::Data& C,
864            const escript::Data& D, const escript::Data& X, const escript::Data& Y,
865            const escript::Data& d, const escript::Data& y) const
866    {
867        throw RipleyException("assemblePDESystem() not implemented");
868    }
869    
870  void RipleyDomain::interpolateNodesOnElements(escript::Data& out, escript::Data& in, bool reduced) const  void RipleyDomain::interpolateNodesOnElements(escript::Data& out, escript::Data& in, bool reduced) const
871  {  {
872      throw RipleyException("interpolateNodesOnElements() not implemented");      throw RipleyException("interpolateNodesOnElements() not implemented");

Legend:
Removed from v.3722  
changed lines
  Added in v.3748

  ViewVC Help
Powered by ViewVC 1.1.26