/[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 3761 by caltinay, Mon Jan 9 06:50:33 2012 UTC revision 3785 by caltinay, Wed Jan 25 04:00:33 2012 UTC
# Line 1  Line 1 
1    
2  /*******************************************************  /*******************************************************
3  *  *
4  * Copyright (c) 2003-2011 by University of Queensland  * Copyright (c) 2003-2012 by University of Queensland
5  * Earth Systems Science Computational Center (ESSCC)  * Earth Systems Science Computational Center (ESSCC)
6  * http://www.uq.edu.au/esscc  * http://www.uq.edu.au/esscc
7  *  *
# Line 83  string RipleyDomain::functionSpaceTypeAs Line 83  string RipleyDomain::functionSpaceTypeAs
83          case DegreesOfFreedom: return "Ripley_DegreesOfFreedom";          case DegreesOfFreedom: return "Ripley_DegreesOfFreedom";
84          case ReducedDegreesOfFreedom: return "Ripley_ReducedDegreesOfFreedom";          case ReducedDegreesOfFreedom: return "Ripley_ReducedDegreesOfFreedom";
85          case Nodes: return "Ripley_Nodes";          case Nodes: return "Ripley_Nodes";
86          case ReducedNodes: return "Ripley_Reduced_Nodes";          case ReducedNodes: return "Ripley_ReducedNodes";
87          case Elements: return "Ripley_Elements";          case Elements: return "Ripley_Elements";
88          case ReducedElements: return "Ripley_Reduced_Elements";          case ReducedElements: return "Ripley_ReducedElements";
89          case FaceElements: return "Ripley_Face_Elements";          case FaceElements: return "Ripley_FaceElements";
90          case ReducedFaceElements: return "Ripley_Reduced_Face_Elements";          case ReducedFaceElements: return "Ripley_ReducedFaceElements";
91          case Points: return "Ripley_Points";          case Points: return "Ripley_Points";
92          default:          default:
93              break;              break;
# Line 234  bool RipleyDomain::commonFunctionSpace(c Line 234  bool RipleyDomain::commonFunctionSpace(c
234  bool RipleyDomain::probeInterpolationOnDomain(int fsType_source,  bool RipleyDomain::probeInterpolationOnDomain(int fsType_source,
235                                                int fsType_target) const                                                int fsType_target) const
236  {  {
237      if (fsType_target != Nodes &&      if (!isValidFunctionSpaceType(fsType_target)) {
             fsType_target != ReducedNodes &&  
             fsType_target != ReducedDegreesOfFreedom &&  
             fsType_target != DegreesOfFreedom &&  
             fsType_target != Elements &&  
             fsType_target != ReducedElements &&  
             fsType_target != FaceElements &&  
             fsType_target != ReducedFaceElements &&  
             fsType_target != Points) {  
238          stringstream msg;          stringstream msg;
239          msg << "probeInterpolationOnDomain(): Invalid functionspace type "          msg << "probeInterpolationOnDomain(): Invalid functionspace type "
240              << fsType_target << " for " << getDescription();              << fsType_target << " for " << getDescription();
# Line 260  bool RipleyDomain::probeInterpolationOnD Line 252  bool RipleyDomain::probeInterpolationOnD
252          case Elements:          case Elements:
253              return (fsType_target==Elements ||              return (fsType_target==Elements ||
254                      fsType_target==ReducedElements);                      fsType_target==ReducedElements);
         case ReducedElements:  
             return (fsType_target==ReducedElements);  
255          case FaceElements:          case FaceElements:
256              return (fsType_target==FaceElements ||              return (fsType_target==FaceElements ||
257                      fsType_target==ReducedFaceElements);                      fsType_target==ReducedFaceElements);
258            case ReducedElements:
259          case ReducedFaceElements:          case ReducedFaceElements:
             return (fsType_target==ReducedFaceElements);  
260          case Points:          case Points:
261              return (fsType_target==Points);              return (fsType_target==fsType_source);
262    
263          default: {          default: {
264              stringstream msg;              stringstream msg;
# Line 307  void RipleyDomain::interpolateOnDomain(e Line 297  void RipleyDomain::interpolateOnDomain(e
297          throw RipleyException("interpolateOnDomain(): Cannot interpolate reduced data to non-reduced data.");          throw RipleyException("interpolateOnDomain(): Cannot interpolate reduced data to non-reduced data.");
298      } else if ((inFS==Elements && outFS==ReducedElements)      } else if ((inFS==Elements && outFS==ReducedElements)
299              || (inFS==FaceElements && outFS==ReducedFaceElements)) {              || (inFS==FaceElements && outFS==ReducedFaceElements)) {
300          averageData(target, *const_cast<escript::Data*>(&in));          if (in.actsExpanded())
301                averageData(target, *const_cast<escript::Data*>(&in));
302            else
303                copyData(target, *const_cast<escript::Data*>(&in));
304      } else {      } else {
305          switch (inFS) {          switch (inFS) {
306              case Nodes:              case Nodes:
# Line 368  void RipleyDomain::interpolateOnDomain(e Line 361  void RipleyDomain::interpolateOnDomain(e
361                          if (getMPISize()==1) {                          if (getMPISize()==1) {
362                              interpolateNodesOnElements(target, *const_cast<escript::Data*>(&in), outFS==ReducedElements);                              interpolateNodesOnElements(target, *const_cast<escript::Data*>(&in), outFS==ReducedElements);
363                          } else {                          } else {
364                              escript::Data contIn=escript::Data(in, continuousFunction(*this));                              escript::Data contIn(in, (inFS==DegreesOfFreedom ?
365                                            escript::continuousFunction(*this) : escript::reducedContinuousFunction(*this)));
366                              interpolateNodesOnElements(target, contIn, outFS==ReducedElements);                              interpolateNodesOnElements(target, contIn, outFS==ReducedElements);
367                          }                          }
368                          break;                          break;
# Line 378  void RipleyDomain::interpolateOnDomain(e Line 372  void RipleyDomain::interpolateOnDomain(e
372                          if (getMPISize()==1) {                          if (getMPISize()==1) {
373                              interpolateNodesOnFaces(target, *const_cast<escript::Data*>(&in), outFS==ReducedFaceElements);                              interpolateNodesOnFaces(target, *const_cast<escript::Data*>(&in), outFS==ReducedFaceElements);
374                          } else {                          } else {
375                              escript::Data contIn=escript::Data(in, continuousFunction(*this));                              escript::Data contIn(in, (inFS==DegreesOfFreedom ?
376                              interpolateNodesOnElements(target, contIn, outFS==ReducedFaceElements);                                       escript::continuousFunction(*this) : escript::reducedContinuousFunction(*this)));
377                                interpolateNodesOnFaces(target, contIn, outFS==ReducedFaceElements);
378                          }                          }
379                          break;                          break;
380    
# Line 427  void RipleyDomain::setToX(escript::Data& Line 422  void RipleyDomain::setToX(escript::Data&
422      }      }
423  }  }
424    
425    void RipleyDomain::setToGradient(escript::Data& grad, const escript::Data& arg) const
426    {
427        const RipleyDomain& argDomain=dynamic_cast<const RipleyDomain&>(
428                *(arg.getFunctionSpace().getDomain()));
429        if (argDomain != *this)
430            throw RipleyException("setToGradient: Illegal domain of gradient argument");
431        const RipleyDomain& gradDomain=dynamic_cast<const RipleyDomain&>(
432                *(grad.getFunctionSpace().getDomain()));
433        if (gradDomain != *this)
434            throw RipleyException("setToGradient: Illegal domain of gradient");
435    
436        switch (grad.getFunctionSpace().getTypeCode()) {
437            case Elements:
438            case ReducedElements:
439            case FaceElements:
440            case ReducedFaceElements:
441                break;
442            default: {
443                stringstream msg;
444                msg << "setToGradient(): not supported for "
445                    << functionSpaceTypeAsString(grad.getFunctionSpace().getTypeCode());
446                throw RipleyException(msg.str());
447            }
448        }
449    
450        if (getMPISize()>1) {
451            if (arg.getFunctionSpace().getTypeCode()==DegreesOfFreedom) {
452                escript::Data contArg(arg, escript::continuousFunction(*this));
453                assembleGradient(grad, contArg);
454            } else if (arg.getFunctionSpace().getTypeCode()==ReducedDegreesOfFreedom) {
455                escript::Data contArg(arg, escript::reducedContinuousFunction(*this));
456                assembleGradient(grad, contArg);
457            } else {
458                assembleGradient(grad, *const_cast<escript::Data*>(&arg));
459            }
460        } else {
461            assembleGradient(grad, *const_cast<escript::Data*>(&arg));
462        }
463    }
464    
465    void RipleyDomain::setToIntegrals(vector<double>& integrals, const escript::Data& arg) const
466    {
467        const RipleyDomain& argDomain=dynamic_cast<const RipleyDomain&>(
468                *(arg.getFunctionSpace().getDomain()));
469        if (argDomain != *this)
470            throw RipleyException("setToIntegrals: Illegal domain of integration kernel");
471    
472        switch (arg.getFunctionSpace().getTypeCode()) {
473            case Nodes:
474            case ReducedNodes:
475            case DegreesOfFreedom:
476            case ReducedDegreesOfFreedom:
477                {
478                    escript::Data funcArg(arg, escript::function(*this));
479                    assembleIntegrate(integrals, funcArg);
480                }
481                break;
482            case Elements:
483            case ReducedElements:
484            case FaceElements:
485            case ReducedFaceElements:
486                assembleIntegrate(integrals, *const_cast<escript::Data*>(&arg));
487                break;
488            default: {
489                stringstream msg;
490                msg << "setToIntegrals(): not supported for "
491                    << functionSpaceTypeAsString(arg.getFunctionSpace().getTypeCode());
492                throw RipleyException(msg.str());
493            }
494        }
495    
496    }
497    
498  bool RipleyDomain::isCellOriented(int fsType) const  bool RipleyDomain::isCellOriented(int fsType) const
499  {  {
500      switch(fsType) {      switch(fsType) {
501          case Nodes:          case Nodes:
502            case ReducedNodes:
503          case DegreesOfFreedom:          case DegreesOfFreedom:
504          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
505              return false;              return false;
# Line 461  bool RipleyDomain::canTag(int fsType) co Line 530  bool RipleyDomain::canTag(int fsType) co
530          case DegreesOfFreedom:          case DegreesOfFreedom:
531          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
532          case Points:          case Points:
533            case ReducedNodes:
534              return false;              return false;
535          default:          default:
536              break;              break;
# Line 620  escript::ASM_ptr RipleyDomain::newSystem Line 690  escript::ASM_ptr RipleyDomain::newSystem
690      bool reduceColOrder=false;      bool reduceColOrder=false;
691      // is the domain right?      // is the domain right?
692      const RipleyDomain& row_domain=dynamic_cast<const RipleyDomain&>(*(row_functionspace.getDomain()));      const RipleyDomain& row_domain=dynamic_cast<const RipleyDomain&>(*(row_functionspace.getDomain()));
693      if (row_domain!=*this)      if (row_domain != *this)
694          throw RipleyException("newSystemMatrix(): 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");
695      const RipleyDomain& col_domain=dynamic_cast<const RipleyDomain&>(*(column_functionspace.getDomain()));      const RipleyDomain& col_domain=dynamic_cast<const RipleyDomain&>(*(column_functionspace.getDomain()));
696      if (col_domain!=*this)      if (col_domain != *this)
697          throw RipleyException("newSystemMatrix(): 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");
698      // is the function space type right?      // is the function space type right?
699      if (row_functionspace.getTypeCode()==ReducedDegreesOfFreedom)      if (row_functionspace.getTypeCode()==ReducedDegreesOfFreedom)
# Line 640  escript::ASM_ptr RipleyDomain::newSystem Line 710  escript::ASM_ptr RipleyDomain::newSystem
710      Paso_SystemMatrix* matrix = Paso_SystemMatrix_alloc(type, pattern,      Paso_SystemMatrix* matrix = Paso_SystemMatrix_alloc(type, pattern,
711              row_blocksize, column_blocksize, FALSE);              row_blocksize, column_blocksize, FALSE);
712      paso::checkPasoError();      paso::checkPasoError();
     Paso_SystemMatrixPattern_free(pattern);  
713      escript::ASM_ptr sma(new SystemMatrixAdapter(matrix, row_blocksize,      escript::ASM_ptr sma(new SystemMatrixAdapter(matrix, row_blocksize,
714                  row_functionspace, column_blocksize, column_functionspace));                  row_functionspace, column_blocksize, column_functionspace));
715      return sma;      return sma;
# Line 694  void RipleyDomain::addPDEToSystem( Line 763  void RipleyDomain::addPDEToSystem(
763          throw RipleyException("addPDEToSystem(): Number of equations and number of solutions don't match");          throw RipleyException("addPDEToSystem(): Number of equations and number of solutions don't match");
764      //TODO: more system matrix checks      //TODO: more system matrix checks
765    
766      if (numEq==1)      if (numEq==1) {
767          if (reducedOrder)          if (reducedOrder) {
768              assemblePDESingleReduced(S, rhs, A, B, C, D, X, Y, d, y);              assemblePDESingleReduced(S, rhs, A, B, C, D, X, Y);
769          else              assemblePDEBoundarySingleReduced(S, rhs, d, y);
770              assemblePDESingle(S, rhs, A, B, C, D, X, Y, d, y);          } else {
771      else              assemblePDESingle(S, rhs, A, B, C, D, X, Y);
772          if (reducedOrder)              assemblePDEBoundarySingle(S, rhs, d, y);
773              assemblePDESystemReduced(S, rhs, A, B, C, D, X, Y, d, y);          }
774          else      } else {
775              assemblePDESystem(S, rhs, A, B, C, D, X, Y, d, y);          if (reducedOrder) {
776                assemblePDESystemReduced(S, rhs, A, B, C, D, X, Y);
777                assemblePDEBoundarySystemReduced(S, rhs, d, y);
778            } else {
779                assemblePDESystem(S, rhs, A, B, C, D, X, Y);
780                assemblePDEBoundarySystem(S, rhs, d, y);
781            }
782        }
783  }  }
784    
785  void RipleyDomain::addPDEToRHS(escript::Data& rhs, const escript::Data& X,  void RipleyDomain::addPDEToRHS(escript::Data& rhs, const escript::Data& X,
# Line 720  void RipleyDomain::addPDEToRHS(escript:: Line 796  void RipleyDomain::addPDEToRHS(escript::
796              return;              return;
797      }      }
798    
799      if (rhs.getDataPointSize() == 1)      if (rhs.getDataPointSize() == 1) {
800          assemblePDESingle(NULL, rhs, escript::Data(), escript::Data(), escript::Data(), escript::Data(), X, Y, escript::Data(), y);          assemblePDESingle(NULL, rhs, escript::Data(), escript::Data(), escript::Data(), escript::Data(), X, Y);
801      else          assemblePDEBoundarySingle(NULL, rhs, escript::Data(), y);
802          assemblePDESystem(NULL, rhs, escript::Data(), escript::Data(), escript::Data(), escript::Data(), X, Y, escript::Data(), y);      } else {
803            assemblePDESystem(NULL, rhs, escript::Data(), escript::Data(), escript::Data(), escript::Data(), X, Y);
804            assemblePDEBoundarySystem(NULL, rhs, escript::Data(), y);
805        }
806  }  }
807    
808  void RipleyDomain::setNewX(const escript::Data& arg)  void RipleyDomain::setNewX(const escript::Data& arg)
# Line 908  void RipleyDomain::addToSystemMatrix(Pas Line 987  void RipleyDomain::addToSystemMatrix(Pas
987          // down columns of array          // down columns of array
988          for (dim_t l_row = 0; l_row < numSubblocks_Eq; ++l_row) {          for (dim_t l_row = 0; l_row < numSubblocks_Eq; ++l_row) {
989              const dim_t i_row = nodes_Eq[k_Eq]*numSubblocks_Eq+l_row;              const dim_t i_row = nodes_Eq[k_Eq]*numSubblocks_Eq+l_row;
             //printf("row:%d\n", i_row);  
990              // only look at the matrix rows stored on this processor              // only look at the matrix rows stored on this processor
991              if (i_row < numMyRows) {              if (i_row < numMyRows) {
992                  for (dim_t k_Sol = 0; k_Sol < nodes_Sol.size(); ++k_Sol) {                  for (dim_t k_Sol = 0; k_Sol < nodes_Sol.size(); ++k_Sol) {
# Line 929  void RipleyDomain::addToSystemMatrix(Pas Line 1007  void RipleyDomain::addToSystemMatrix(Pas
1007                              }                              }
1008                          } else {                          } else {
1009                              for (dim_t k = col_coupleBlock_ptr[i_row]; k < col_coupleBlock_ptr[i_row + 1]; ++k) {                              for (dim_t k = col_coupleBlock_ptr[i_row]; k < col_coupleBlock_ptr[i_row + 1]; ++k) {
         //cout << "col:" << i_col-numMyCols << " colIdx:" << col_coupleBlock_index[k] << endl;  
1010                                  if (col_coupleBlock_index[k] == i_col - numMyCols) {                                  if (col_coupleBlock_index[k] == i_col - numMyCols) {
1011                                      for (dim_t ic=0; ic<mat->col_block_size; ++ic) {                                      for (dim_t ic=0; ic<mat->col_block_size; ++ic) {
1012                                          const dim_t i_Sol=ic+mat->col_block_size*l_col;                                          const dim_t i_Sol=ic+mat->col_block_size*l_col;
# Line 953  void RipleyDomain::addToSystemMatrix(Pas Line 1030  void RipleyDomain::addToSystemMatrix(Pas
1030                              for (dim_t k = row_coupleBlock_ptr[i_row - numMyRows];                              for (dim_t k = row_coupleBlock_ptr[i_row - numMyRows];
1031                                   k < row_coupleBlock_ptr[i_row - numMyRows + 1]; ++k)                                   k < row_coupleBlock_ptr[i_row - numMyRows + 1]; ++k)
1032                              {                              {
         //cout << "col:" << i_col << " rowIdx:" << row_coupleBlock_index[k] << endl;  
1033                                  if (row_coupleBlock_index[k] == i_col) {                                  if (row_coupleBlock_index[k] == i_col) {
1034                                      for (dim_t ic=0; ic<mat->col_block_size; ++ic) {                                      for (dim_t ic=0; ic<mat->col_block_size; ++ic) {
1035                                          const dim_t i_Sol=ic+mat->col_block_size*l_col;                                          const dim_t i_Sol=ic+mat->col_block_size*l_col;
# Line 1018  void RipleyDomain::setToSize(escript::Da Line 1094  void RipleyDomain::setToSize(escript::Da
1094      throw RipleyException("setToSize() not implemented");      throw RipleyException("setToSize() not implemented");
1095  }  }
1096    
 void RipleyDomain::setToGradient(escript::Data& grad, const escript::Data& arg) const  
 {  
     throw RipleyException("setToGradient() not implemented");  
 }  
   
 void RipleyDomain::setToIntegrals(vector<double>& integrals, const escript::Data& arg) const  
 {  
     throw RipleyException("setToIntegrals() not implemented");  
 }  
   
1097  bool RipleyDomain::ownSample(int fsType, index_t id) const  bool RipleyDomain::ownSample(int fsType, index_t id) const
1098  {  {
1099      throw RipleyException("ownSample() not implemented");      throw RipleyException("ownSample() not implemented");
1100  }  }
1101    
 void RipleyDomain::addPDEToLumpedSystem(escript::Data& mat,  
         const escript::Data& D, const escript::Data& d,  
         const escript::Data& d_dirac, const bool useHRZ) const  
 {  
     throw RipleyException("addPDEToLumpedSystem() not implemented");  
 }  
   
1102  void RipleyDomain::addPDEToTransportProblem(  void RipleyDomain::addPDEToTransportProblem(
1103          escript::AbstractTransportProblem& tp,          escript::AbstractTransportProblem& tp,
1104          escript::Data& source, const escript::Data& M,          escript::Data& source, const escript::Data& M,
# Line 1090  IndexVector RipleyDomain::getNodeDistrib Line 1149  IndexVector RipleyDomain::getNodeDistrib
1149      throw RipleyException("getNodeDistribution() not implemented");      throw RipleyException("getNodeDistribution() not implemented");
1150  }  }
1151    
1152    IndexVector RipleyDomain::getNumSubdivisionsPerDim() const
1153    {
1154        throw RipleyException("getNumSubdivisionsPerDim() not implemented");
1155    }
1156    
1157  pair<double,double> RipleyDomain::getFirstCoordAndSpacing(dim_t dim) const  pair<double,double> RipleyDomain::getFirstCoordAndSpacing(dim_t dim) const
1158  {  {
1159      throw RipleyException("getFirstCoordAndSpacing() not implemented");      throw RipleyException("getFirstCoordAndSpacing() not implemented");
# Line 1125  void RipleyDomain::assembleCoordinates(e Line 1189  void RipleyDomain::assembleCoordinates(e
1189      throw RipleyException("assembleCoordinates() not implemented");      throw RipleyException("assembleCoordinates() not implemented");
1190  }  }
1191    
1192    void RipleyDomain::assembleGradient(escript::Data& out, escript::Data& in) const
1193    {
1194        throw RipleyException("assembleGradient() not implemented");
1195    }
1196    
1197    void RipleyDomain::assembleIntegrate(vector<double>& integrals, escript::Data& arg) const
1198    {
1199        throw RipleyException("assembleIntegrate() not implemented");
1200    }
1201    
1202  void RipleyDomain::assemblePDESingle(Paso_SystemMatrix* mat, escript::Data& rhs,  void RipleyDomain::assemblePDESingle(Paso_SystemMatrix* mat, escript::Data& rhs,
1203          const escript::Data& A, const escript::Data& B, const escript::Data& C,          const escript::Data& A, const escript::Data& B, const escript::Data& C,
1204          const escript::Data& D, const escript::Data& X, const escript::Data& Y,          const escript::Data& D, const escript::Data& X, const escript::Data& Y) const
         const escript::Data& d, const escript::Data& y) const  
1205  {  {
1206      throw RipleyException("assemblePDESingle() not implemented");      throw RipleyException("assemblePDESingle() not implemented");
1207  }  }
1208    
1209    void RipleyDomain::assemblePDEBoundarySingle(Paso_SystemMatrix* mat,
1210          escript::Data& rhs, const escript::Data& d, const escript::Data& y) const
1211    {
1212        throw RipleyException("assemblePDEBoundarySingle() not implemented");
1213    }
1214    
1215  void RipleyDomain::assemblePDESingleReduced(Paso_SystemMatrix* mat,  void RipleyDomain::assemblePDESingleReduced(Paso_SystemMatrix* mat,
1216          escript::Data& rhs, const escript::Data& A, const escript::Data& B,          escript::Data& rhs, const escript::Data& A, const escript::Data& B,
1217          const escript::Data& C, const escript::Data& D, const escript::Data& X,          const escript::Data& C, const escript::Data& D, const escript::Data& X,
1218          const escript::Data& Y, const escript::Data& d, const escript::Data& y) const          const escript::Data& Y) const
1219  {  {
1220      throw RipleyException("assemblePDESingleReduced() not implemented");      throw RipleyException("assemblePDESingleReduced() not implemented");
1221  }  }
1222    
1223    void RipleyDomain::assemblePDEBoundarySingleReduced(Paso_SystemMatrix* mat,
1224          escript::Data& rhs, const escript::Data& d, const escript::Data& y) const
1225    {
1226        throw RipleyException("assemblePDEBoundarySingleReduced() not implemented");
1227    }
1228    
1229  void RipleyDomain::assemblePDESystem(Paso_SystemMatrix* mat, escript::Data& rhs,  void RipleyDomain::assemblePDESystem(Paso_SystemMatrix* mat, escript::Data& rhs,
1230          const escript::Data& A, const escript::Data& B, const escript::Data& C,          const escript::Data& A, const escript::Data& B, const escript::Data& C,
1231          const escript::Data& D, const escript::Data& X, const escript::Data& Y,          const escript::Data& D, const escript::Data& X, const escript::Data& Y) const
         const escript::Data& d, const escript::Data& y) const  
1232  {  {
1233      throw RipleyException("assemblePDESystem() not implemented");      throw RipleyException("assemblePDESystem() not implemented");
1234  }  }
1235    
1236    void RipleyDomain::assemblePDEBoundarySystem(Paso_SystemMatrix* mat,
1237          escript::Data& rhs, const escript::Data& d, const escript::Data& y) const
1238    {
1239        throw RipleyException("assemblePDEBoundarySystem() not implemented");
1240    }
1241    
1242  void RipleyDomain::assemblePDESystemReduced(Paso_SystemMatrix* mat,  void RipleyDomain::assemblePDESystemReduced(Paso_SystemMatrix* mat,
1243          escript::Data& rhs, const escript::Data& A, const escript::Data& B,          escript::Data& rhs, const escript::Data& A, const escript::Data& B,
1244          const escript::Data& C, const escript::Data& D, const escript::Data& X,          const escript::Data& C, const escript::Data& D, const escript::Data& X,
1245          const escript::Data& Y, const escript::Data& d, const escript::Data& y) const          const escript::Data& Y) const
1246  {  {
1247      throw RipleyException("assemblePDESystemReduced() not implemented");      throw RipleyException("assemblePDESystemReduced() not implemented");
1248  }  }
1249    
1250    void RipleyDomain::assemblePDEBoundarySystemReduced(Paso_SystemMatrix* mat,
1251          escript::Data& rhs, const escript::Data& d, const escript::Data& y) const
1252    {
1253        throw RipleyException("assemblePDEBoundarySystemReduced() not implemented");
1254    }
1255    
1256  void RipleyDomain::interpolateNodesOnElements(escript::Data& out, escript::Data& in, bool reduced) const  void RipleyDomain::interpolateNodesOnElements(escript::Data& out, escript::Data& in, bool reduced) const
1257  {  {
1258      throw RipleyException("interpolateNodesOnElements() not implemented");      throw RipleyException("interpolateNodesOnElements() not implemented");

Legend:
Removed from v.3761  
changed lines
  Added in v.3785

  ViewVC Help
Powered by ViewVC 1.1.26