/[escript]/branches/domexper/dudley/src/CPPAdapter/MeshAdapter.cpp
ViewVC logotype

Diff of /branches/domexper/dudley/src/CPPAdapter/MeshAdapter.cpp

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

revision 82 by jgs, Tue Oct 26 06:53:54 2004 UTC revision 110 by jgs, Mon Feb 14 04:14:42 2005 UTC
# Line 1  Line 1 
1    // $Id$
2  /*  /*
3   ******************************************************************************   ******************************************************************************
4   *                                                                            *   *                                                                            *
# Line 178  int MeshAdapter::getDiracDeltaFunctionCo Line 179  int MeshAdapter::getDiracDeltaFunctionCo
179  {  {
180    return Points;    return Points;
181  }  }
   
 int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const  
 {  
   //  
   // It is assumed the sampleNo has been checked  
   // before calling this function.  
   int* tagList;  
   int numTags;  
   getTagList(functionSpaceType, &tagList, &numTags);  
   return tagList[sampleNo];  
 }  
   
182  //  //
183  // returns a pointer to the tag list of samples of functionSpaceType  // returns a pointer to the tag list of samples of functionSpaceType
184  //  //
185  void MeshAdapter::getTagList(int functionSpaceType, int** tagList,  void MeshAdapter::getTagList(int functionSpaceType, int** tagList,
186                   int* numTags) const                   int* numTags) const
187  {  {
188    **tagList=0;    *tagList=NULL;
189    *numTags=0;    *numTags=0;
190    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
191    switch (functionSpaceType) {    switch (functionSpaceType) {
# Line 255  void MeshAdapter::getTagList(int functio Line 244  void MeshAdapter::getTagList(int functio
244      throw FinleyAdapterException(temp.str());      throw FinleyAdapterException(temp.str());
245      break;      break;
246    }    }
247      if (*tagList==NULL) {
248        stringstream temp;
249        temp << "Error - no tags available for " << functionSpaceType << " for domain: " << getDescription();
250        throw FinleyAdapterException(temp.str());
251      }
252      return;
253    }
254    //
255    // returns a pointer to the reference no list of samples of functionSpaceType
256    //
257    void MeshAdapter::getReferenceNoList(int functionSpaceType, int** referenceNoList,
258                     int* numReferenceNo) const
259    {
260      *referenceNoList=NULL;
261      *numReferenceNo=0;
262      Finley_Mesh* mesh=m_finleyMesh.get();
263      switch (functionSpaceType) {
264      case(Nodes):
265        if (mesh->Nodes!=NULL) {
266          *referenceNoList=mesh->Nodes->Id;
267          *numReferenceNo=mesh->Nodes->numNodes;
268        }
269        break;
270      case(Elements):
271        if (mesh->Elements!=NULL) {
272          *referenceNoList=mesh->Elements->Id;
273          *numReferenceNo=mesh->Elements->numElements;
274        }
275        break;
276      case(FaceElements):
277        if (mesh->FaceElements!=NULL) {
278          *referenceNoList=mesh->FaceElements->Id;
279          *numReferenceNo=mesh->FaceElements->numElements;
280        }
281        break;
282      case(Points):
283        if (mesh->Points!=NULL) {
284          *referenceNoList=mesh->Points->Id;
285          *numReferenceNo=mesh->Points->numElements;
286        }
287        break;
288      case(ContactElementsZero):
289        if (mesh->ContactElements!=NULL) {
290          *referenceNoList=mesh->ContactElements->Id;
291          *numReferenceNo=mesh->ContactElements->numElements;
292        }
293        break;
294      case(ContactElementsOne):
295        if (mesh->ContactElements!=NULL) {
296          *referenceNoList=mesh->ContactElements->Id;
297          *numReferenceNo=mesh->ContactElements->numElements;
298        }
299        break;
300      case(DegreesOfFreedom):
301        if (mesh->Nodes!=NULL) {
302          *referenceNoList=NULL;
303          *numReferenceNo=0;
304        }
305        break;
306      case(ReducedDegreesOfFreedom):
307        if (mesh->Nodes!=NULL) {
308          *referenceNoList=NULL;
309          *numReferenceNo=0;
310        }
311        break;
312      default:
313        stringstream temp;
314        temp << "Error - Invalid function space type: "
315         << functionSpaceType << " for domain: " << getDescription();
316        throw FinleyAdapterException(temp.str());
317        break;
318      }
319      if (*referenceNoList==NULL) {
320        stringstream temp;
321        temp << "Error - reference number list available for " << functionSpaceType << " for domain: " << getDescription();
322        throw FinleyAdapterException(temp.str());
323      }
324    return;    return;
325  }  }
326    
# Line 337  pair<int,int> MeshAdapter::getDataShape( Line 403  pair<int,int> MeshAdapter::getDataShape(
403  //  //
404  void MeshAdapter::addPDEToSystem(  void MeshAdapter::addPDEToSystem(
405                       SystemMatrixAdapter& mat, Data& rhs,                       SystemMatrixAdapter& mat, Data& rhs,
406                       const Data& A, const Data& B, const Data& C,const  Data& D,const  Data& X,const  Data& Y) const                       const Data& A, const Data& B, const Data& C,const  Data& D,const  Data& X,const  Data& Y,
407                         const Data& d, const Data& y,
408                         const Data& d_contact,const Data& y_contact) const
409  {  {
410     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
411     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getFinley_SystemMatrix(),&(rhs.getDataC()),     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getFinley_SystemMatrix(),&(rhs.getDataC()),
412                         &(A.getDataC()),&(B.getDataC()),&(C.getDataC()),&(D.getDataC()),&(X.getDataC()),&(Y.getDataC()));                         &(A.getDataC()),&(B.getDataC()),&(C.getDataC()),&(D.getDataC()),&(X.getDataC()),&(Y.getDataC()));
413     checkFinleyError();     checkFinleyError();
 }  
 //  
 // adds Robin boundary conditions as natural boundary condition into a given stiffness matrix and right hand side:  
 //  
 void MeshAdapter::addRobinConditionsToSystem(  
                      SystemMatrixAdapter& mat, Data& rhs,  
                      const Data& d, const Data& y) const  
 {  
    Finley_Mesh* mesh=m_finleyMesh.get();  
414     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,
415                    mat.getFinley_SystemMatrix(),                    mat.getFinley_SystemMatrix(),
416                    &(rhs.getDataC()),                    &(rhs.getDataC()),
417                                    &(d.getDataC()),&(y.getDataC()),                                    &(d.getDataC()),&(y.getDataC()),
418                                    Finley_Assemble_handelShapeMissMatch_Mean_out);                                    Finley_Assemble_handelShapeMissMatch_Mean_out);
419     checkFinleyError();     checkFinleyError();
 }  
 //  
 // adds contact conditions as natural boundary condition into a given stiffness matrix and right hand side:  
 //  
 void MeshAdapter::addContactToSystem(  
                      SystemMatrixAdapter& mat, Data& rhs,  
                      const Data& d_contact,const Data& y_contact) const  
 {  
    Finley_Mesh* mesh=m_finleyMesh.get();  
420     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,
421                    mat.getFinley_SystemMatrix(),                    mat.getFinley_SystemMatrix(),
422                    &(rhs.getDataC()),                    &(rhs.getDataC()),
# Line 376  void MeshAdapter::addContactToSystem( Line 426  void MeshAdapter::addContactToSystem(
426     checkFinleyError();     checkFinleyError();
427  }  }
428  //  //
429    // adds linear PDE of second order into the right hand side only
430    //
431    void MeshAdapter::addPDEToRHS( Data& rhs,
432                         const  Data& X,const  Data& Y, const Data& y, const Data& y_contact) const
433    {
434       Finley_Mesh* mesh=m_finleyMesh.get();
435       Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,0,&(rhs.getDataC()),0,0,0,0,&(X.getDataC()),&(Y.getDataC()));
436       checkFinleyError();
437       Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,0,&(rhs.getDataC()),0,&(y.getDataC()),
438                                      Finley_Assemble_handelShapeMissMatch_Mean_out);
439    // cout << "Calling :addPDEToRHS." << endl;
440       checkFinleyError();
441       Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,0,&(rhs.getDataC()),0,&(y_contact.getDataC()),
442                                      Finley_Assemble_handelShapeMissMatch_Step_out);
443    // cout << "Calling :addPDEToRHS." << endl;
444       checkFinleyError();
445    }
446    //
447  // interpolates data between different function spaces:  // interpolates data between different function spaces:
448  //  //
449  void MeshAdapter::interpolateOnDomain(Data& target,const Data& in) const  void MeshAdapter::interpolateOnDomain(Data& target,const Data& in) const
# Line 744  void MeshAdapter::saveDX(const std::stri Line 812  void MeshAdapter::saveDX(const std::stri
812    Finley_Mesh_saveDX(filename.c_str(),m_finleyMesh.get(),&(arg.getDataC()));    Finley_Mesh_saveDX(filename.c_str(),m_finleyMesh.get(),&(arg.getDataC()));
813    checkFinleyError();    checkFinleyError();
814  }  }
815    // saves a data array in openVTK format:
816    void MeshAdapter::saveVTK(const std::string& filename,const Data& arg) const
817    {
818      Finley_Mesh_saveVTK(filename.c_str(),m_finleyMesh.get(),&(arg.getDataC()));
819      checkFinleyError();
820    }
821  // creates a SystemMatrixAdapter stiffness matrix an initializes it with zeros:  // creates a SystemMatrixAdapter stiffness matrix an initializes it with zeros:
822  SystemMatrixAdapter MeshAdapter::newSystemMatrix(  SystemMatrixAdapter MeshAdapter::newSystemMatrix(
823                        const int row_blocksize,                        const int row_blocksize,
824                        const escript::FunctionSpace& row_functionspace,                        const escript::FunctionSpace& row_functionspace,
825                        const int column_blocksize,                        const int column_blocksize,
826                        const escript::FunctionSpace& column_functionspace,                        const escript::FunctionSpace& column_functionspace,
827                        const int type,                        const int type) const
                       const bool sym) const  
828  {  {
829      int reduceRowOrder=0;      int reduceRowOrder=0;
830      int reduceColOrder=0;      int reduceColOrder=0;
# Line 778  SystemMatrixAdapter MeshAdapter::newSyst Line 851  SystemMatrixAdapter MeshAdapter::newSyst
851          throw FinleyAdapterException("Error - illegal function space type for system matrix columns.");          throw FinleyAdapterException("Error - illegal function space type for system matrix columns.");
852      }      }
853      // generate matrix:      // generate matrix:
854      Finley_SystemMatrix* fsystemMatrix=Finley_SystemMatrix_alloc(getFinley_Mesh(),type,sym?1:0,      
855                                                                   row_blocksize,reduceRowOrder,      Finley_SystemMatrixPattern* fsystemMatrixPattern=Finley_getPattern(getFinley_Mesh(),reduceRowOrder,reduceColOrder);
856                                                                   column_blocksize,reduceColOrder);      checkFinleyError();
857        Finley_SystemMatrix* fsystemMatrix=Finley_SystemMatrix_alloc(type,fsystemMatrixPattern,row_blocksize,column_blocksize);
858      checkFinleyError();      checkFinleyError();
859      return SystemMatrixAdapter(fsystemMatrix,row_blocksize,row_functionspace,column_blocksize,column_functionspace);      return SystemMatrixAdapter(fsystemMatrix,row_blocksize,row_functionspace,column_blocksize,column_functionspace);
860  }  }
# Line 902  bool MeshAdapter::probeInterpolationACro Line 976  bool MeshAdapter::probeInterpolationACro
976  {  {
977      return false;      return false;
978  }  }
979    
980  bool MeshAdapter::operator==(const MeshAdapter& other) const  bool MeshAdapter::operator==(const MeshAdapter& other) const
981  {  {
982    return (m_finleyMesh==other.m_finleyMesh);    return (m_finleyMesh==other.m_finleyMesh);
# Line 911  bool MeshAdapter::operator!=(const MeshA Line 986  bool MeshAdapter::operator!=(const MeshA
986  {  {
987    return !operator==(other);    return !operator==(other);
988  }  }
989  // bool MeshAdapter::operator==(const AbstractDomain& other) const  
990  // {  int MeshAdapter::getSystemMatrixTypeId(const int solver, const bool symmetry) const
991    // try {  {
992      // const MeshAdapter& ref = dynamic_cast<const MeshAdapter&>(other);     int out=Finley_SystemMatrix_getSystemMatrixTypeId(solver,symmetry?1:0);
993      // return (operator==(ref));     checkFinleyError();
994    // }     return out;
995    // catch (bad_cast) {  }
996      // return false;  Data MeshAdapter::getX() const
997    // }  {
998  // }    return continuousFunction(asAbstractContinuousDomain()).getX();
999    }
1000    Data MeshAdapter::getNormal() const
1001    {
1002      return functionOnBoundary(asAbstractContinuousDomain()).getNormal();
1003    }
1004    Data MeshAdapter::getSize() const
1005    {
1006      return function(asAbstractContinuousDomain()).getSize();
1007    }
1008    
1009    int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const
1010    {
1011      int* tagList;
1012      int numTags;
1013      getTagList(functionSpaceType, &tagList, &numTags);
1014      return tagList[sampleNo];
1015    }
1016    
1017    int MeshAdapter::getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const
1018    {
1019      int* referenceNoList;
1020      int numReferenceNo;
1021      getReferenceNoList(functionSpaceType, &referenceNoList, &numReferenceNo);
1022      return referenceNoList[sampleNo];
1023    }
1024    
1025  }  // end of namespace  }  // end of namespace

Legend:
Removed from v.82  
changed lines
  Added in v.110

  ViewVC Help
Powered by ViewVC 1.1.26