/[escript]/trunk/finley/src/CPPAdapter/MeshAdapter.cpp
ViewVC logotype

Diff of /trunk/finley/src/CPPAdapter/MeshAdapter.cpp

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

revision 532 by gross, Wed Feb 15 09:45:53 2006 UTC revision 757 by woo409, Mon Jun 26 13:12:56 2006 UTC
# Line 15  Line 15 
15    
16  #include "MeshAdapter.h"  #include "MeshAdapter.h"
17    
18  #include "Data.h"  #include "escript/Data.h"
19  #include "DataFactory.h"  #include "escript/DataFactory.h"
20    
21  using namespace std;  using namespace std;
22  using namespace escript;  using namespace escript;
# Line 70  Finley_Mesh* MeshAdapter::getFinley_Mesh Line 70  Finley_Mesh* MeshAdapter::getFinley_Mesh
70    
71  void MeshAdapter::write(const std::string& fileName) const  void MeshAdapter::write(const std::string& fileName) const
72  {  {
73    char fName[fileName.size()+1];    char *fName = (fileName.size()+1>0) ? TMPMEMALLOC(fileName.size()+1,char) : (char*)NULL;
74    strcpy(fName,fileName.c_str());    strcpy(fName,fileName.c_str());
75    Finley_Mesh_write(m_finleyMesh.get(),fName);    Finley_Mesh_write(m_finleyMesh.get(),fName);
76    checkFinleyError();    checkFinleyError();
77      TMPMEMFREE(fName);
78  }  }
79    
 // void MeshAdapter::getTagList(int functionSpaceType,  
 //                  int* numTags) const  
 // {  
 //   Finley_Mesh_tagList(m_finleyMesh.get(),functionSpaceType,tagList,numTags);  
 //   return;  
 // }  
   
80  string MeshAdapter::getDescription() const  string MeshAdapter::getDescription() const
81  {  {
82    return "FinleyMesh";    return "FinleyMesh";
# Line 167  int MeshAdapter::getDiracDeltaFunctionCo Line 161  int MeshAdapter::getDiracDeltaFunctionCo
161  }  }
162    
163  //  //
 // returns a pointer to the tag list of samples of functionSpaceType  
 //  
 void MeshAdapter::getTagList(int functionSpaceType, int** tagList,  
                  int* numTags) const  
 {  
   *tagList=NULL;  
   *numTags=0;  
   Finley_Mesh* mesh=m_finleyMesh.get();  
   switch (functionSpaceType) {  
   case(Nodes):  
     if (mesh->Nodes!=NULL) {  
       *tagList=mesh->Nodes->Tag;  
       *numTags=mesh->Nodes->numNodes;  
     }  
     break;  
   case(Elements):  
     if (mesh->Elements!=NULL) {  
       *tagList=mesh->Elements->Tag;  
       *numTags=mesh->Elements->numElements;  
     }  
     break;  
   case(FaceElements):  
     if (mesh->FaceElements!=NULL) {  
       *tagList=mesh->FaceElements->Tag;  
       *numTags=mesh->FaceElements->numElements;  
     }  
     break;  
   case(Points):  
     if (mesh->Points!=NULL) {  
       *tagList=mesh->Points->Tag;  
       *numTags=mesh->Points->numElements;  
     }  
     break;  
   case(ContactElementsZero):  
     if (mesh->ContactElements!=NULL) {  
       *tagList=mesh->ContactElements->Tag;  
       *numTags=mesh->ContactElements->numElements;  
     }  
     break;  
   case(ContactElementsOne):  
     if (mesh->ContactElements!=NULL) {  
       *tagList=mesh->ContactElements->Tag;  
       *numTags=mesh->ContactElements->numElements;  
     }  
     break;  
   case(DegreesOfFreedom):  
     if (mesh->Nodes!=NULL) {  
       *tagList=NULL;  
       *numTags=0;  
     }  
     break;  
   case(ReducedDegreesOfFreedom):  
     if (mesh->Nodes!=NULL) {  
       *tagList=NULL;  
       *numTags=0;  
     }  
     break;  
   default:  
     stringstream temp;  
     temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();  
     throw FinleyAdapterException(temp.str());  
     break;  
   }  
   if (*tagList==NULL) {  
     stringstream temp;  
     temp << "Error - no tags available for " << functionSpaceType << " for domain: " << getDescription();  
     throw FinleyAdapterException(temp.str());  
   }  
   return;  
 }  
   
 //  
 // returns a pointer to the reference no list of samples of functionSpaceType  
 //  
 void MeshAdapter::getReferenceNoList(int functionSpaceType, int** referenceNoList,  
                  int* numReferenceNo) const  
 {  
   *referenceNoList=NULL;  
   *numReferenceNo=0;  
   Finley_Mesh* mesh=m_finleyMesh.get();  
   switch (functionSpaceType) {  
   case(Nodes):  
     if (mesh->Nodes!=NULL) {  
       *referenceNoList=mesh->Nodes->Id;  
       *numReferenceNo=mesh->Nodes->numNodes;  
     }  
     break;  
   case(Elements):  
     if (mesh->Elements!=NULL) {  
       *referenceNoList=mesh->Elements->Id;  
       *numReferenceNo=mesh->Elements->numElements;  
     }  
     break;  
   case(FaceElements):  
     if (mesh->FaceElements!=NULL) {  
       *referenceNoList=mesh->FaceElements->Id;  
       *numReferenceNo=mesh->FaceElements->numElements;  
     }  
     break;  
   case(Points):  
     if (mesh->Points!=NULL) {  
       *referenceNoList=mesh->Points->Id;  
       *numReferenceNo=mesh->Points->numElements;  
     }  
     break;  
   case(ContactElementsZero):  
     if (mesh->ContactElements!=NULL) {  
       *referenceNoList=mesh->ContactElements->Id;  
       *numReferenceNo=mesh->ContactElements->numElements;  
     }  
     break;  
   case(ContactElementsOne):  
     if (mesh->ContactElements!=NULL) {  
       *referenceNoList=mesh->ContactElements->Id;  
       *numReferenceNo=mesh->ContactElements->numElements;  
     }  
     break;  
   case(DegreesOfFreedom):  
     if (mesh->Nodes!=NULL) {  
       *referenceNoList=NULL;  
       *numReferenceNo=0;  
     }  
     break;  
   case(ReducedDegreesOfFreedom):  
     if (mesh->Nodes!=NULL) {  
       *referenceNoList=NULL;  
       *numReferenceNo=0;  
     }  
     break;  
   default:  
     stringstream temp;  
     temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();  
     throw FinleyAdapterException(temp.str());  
     break;  
   }  
   if (*referenceNoList==NULL) {  
     stringstream temp;  
     temp << "Error - reference number list available for " << functionSpaceType << " for domain: " << getDescription();  
     throw FinleyAdapterException(temp.str());  
   }  
   return;  
 }  
   
 //  
164  // return the spatial dimension of the Mesh:  // return the spatial dimension of the Mesh:
165  //  //
166  int MeshAdapter::getDim() const  int MeshAdapter::getDim() const
# Line 367  pair<int,int> MeshAdapter::getDataShape( Line 217  pair<int,int> MeshAdapter::getDataShape(
217        case(DegreesOfFreedom):        case(DegreesOfFreedom):
218             if (mesh->Nodes!=NULL) {             if (mesh->Nodes!=NULL) {
219               numDataPointsPerSample=1;               numDataPointsPerSample=1;
220    #ifndef PASO_MPI
221               numSamples=mesh->Nodes->numDegreesOfFreedom;               numSamples=mesh->Nodes->numDegreesOfFreedom;
222    #else
223                 numSamples=mesh->Nodes->degreeOfFreedomDistribution->numLocal;
224    #endif
225             }             }
226             break;             break;
227        case(ReducedDegreesOfFreedom):        case(ReducedDegreesOfFreedom):
228             if (mesh->Nodes!=NULL) {             if (mesh->Nodes!=NULL) {
229               numDataPointsPerSample=1;               numDataPointsPerSample=1;
230    #ifndef PASO_MPI
231               numSamples=mesh->Nodes->reducedNumDegreesOfFreedom;               numSamples=mesh->Nodes->reducedNumDegreesOfFreedom;
232    #else
233                 numSamples=mesh->Nodes->reducedDegreeOfFreedomDistribution->numLocal;
234    #endif
235             }             }
236             break;             break;
237        default:        default:
# Line 394  void MeshAdapter::addPDEToSystem( Line 252  void MeshAdapter::addPDEToSystem(
252                       const escript::Data& d, const escript::Data& y,                       const escript::Data& d, const escript::Data& y,
253                       const escript::Data& d_contact,const escript::Data& y_contact) const                       const escript::Data& d_contact,const escript::Data& y_contact) const
254  {  {
255      escriptDataC _rhs=rhs.getDataC();
256      escriptDataC _A  =A.getDataC();
257      escriptDataC _B=B.getDataC();
258      escriptDataC _C=C.getDataC();
259      escriptDataC _D=D.getDataC();
260      escriptDataC _X=X.getDataC();
261      escriptDataC _Y=Y.getDataC();
262      escriptDataC _d=d.getDataC();
263      escriptDataC _y=y.getDataC();
264      escriptDataC _d_contact=d_contact.getDataC();
265      escriptDataC _y_contact=y_contact.getDataC();
266    
267     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
268     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(),&(rhs.getDataC()),     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(), &_rhs, &_A, &_B, &_C, &_D, &_X, &_Y );
269                         &(A.getDataC()),&(B.getDataC()),&(C.getDataC()),&(D.getDataC()),&(X.getDataC()),&(Y.getDataC()));  
270     checkFinleyError();     checkFinleyError();
271     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,  
272                    mat.getPaso_SystemMatrix(),     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements, mat.getPaso_SystemMatrix(), &_rhs, &_d, &_y, Finley_Assemble_handelShapeMissMatch_Mean_out);
                   &(rhs.getDataC()),  
                                   &(d.getDataC()),&(y.getDataC()),  
                                   Finley_Assemble_handelShapeMissMatch_Mean_out);  
273     checkFinleyError();     checkFinleyError();
274     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->ContactElements,  
275                    mat.getPaso_SystemMatrix(),     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->ContactElements, mat.getPaso_SystemMatrix(), &_rhs , &_d_contact, &_y_contact ,             Finley_Assemble_handelShapeMissMatch_Step_out);
                   &(rhs.getDataC()),  
                                   &(d_contact.getDataC()),  
                   &(y_contact.getDataC()),  
                                   Finley_Assemble_handelShapeMissMatch_Step_out);  
276     checkFinleyError();     checkFinleyError();
277  }  }
278    
279  //  //
280  // adds linear PDE of second order into the right hand side only  // adds linear PDE of second order into the right hand side only
281  //  //
282  void MeshAdapter::addPDEToRHS( escript::Data& rhs,  void MeshAdapter::addPDEToRHS( escript::Data& rhs, const  escript::Data& X,const  escript::Data& Y, const escript::Data& y, const escript::Data& y_contact) const
                      const  escript::Data& X,const  escript::Data& Y, const escript::Data& y, const escript::Data& y_contact) const  
283  {  {
284     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
285    
# Line 441  void MeshAdapter::interpolateOnDomain(es Line 303  void MeshAdapter::interpolateOnDomain(es
303  {  {
304    const MeshAdapter& inDomain=dynamic_cast<const MeshAdapter&>(in.getFunctionSpace().getDomain());    const MeshAdapter& inDomain=dynamic_cast<const MeshAdapter&>(in.getFunctionSpace().getDomain());
305    const MeshAdapter& targetDomain=dynamic_cast<const MeshAdapter&>(target.getFunctionSpace().getDomain());    const MeshAdapter& targetDomain=dynamic_cast<const MeshAdapter&>(target.getFunctionSpace().getDomain());
306    if (inDomain!=*this)    if (inDomain!=*this)  
307       throw FinleyAdapterException("Error - Illegal domain of interpolant.");      throw FinleyAdapterException("Error - Illegal domain of interpolant.");
308    if (targetDomain!=*this)    if (targetDomain!=*this)
309       throw FinleyAdapterException("Error - Illegal domain of interpolation target.");      throw FinleyAdapterException("Error - Illegal domain of interpolation target.");
310    
311    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
312    switch(in.getFunctionSpace().getTypeCode()) {    switch(in.getFunctionSpace().getTypeCode()) {
# Line 508  void MeshAdapter::interpolateOnDomain(es Line 370  void MeshAdapter::interpolateOnDomain(es
370             break;             break;
371          }          }
372          break;          break;
373       case(DegreesOfFreedom):       case(DegreesOfFreedom):      
374          switch(target.getFunctionSpace().getTypeCode()) {          switch(target.getFunctionSpace().getTypeCode()) {
375             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
376             case(DegreesOfFreedom):             case(DegreesOfFreedom):
377             case(Nodes):             case(Nodes):
378                Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));                Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));
379                break;                break;
380    #ifndef PASO_MPI
381             case(Elements):             case(Elements):
382                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));
383                break;                break;
# Line 528  void MeshAdapter::interpolateOnDomain(es Line 391  void MeshAdapter::interpolateOnDomain(es
391             case(ContactElementsOne):             case(ContactElementsOne):
392                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));
393               break;               break;
394    #else
395               /* need to copy Degrees of freedom data to nodal data so that the external values are available */
396               case(Elements):
397               {
398                  escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
399                  Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(nodeTemp.getDataC()),&(target.getDataC()));
400                  break;
401               }
402               case(FaceElements):
403               {
404                  escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
405                  Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(nodeTemp.getDataC()),&(target.getDataC()));
406                  break;
407               }
408               case(Points):
409               {
410                  escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
411                  Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(nodeTemp.getDataC()),&(target.getDataC()));
412                  break;
413               }
414               case(ContactElementsZero):
415               case(ContactElementsOne):
416               {
417                  escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
418                  Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(nodeTemp.getDataC()),&(target.getDataC()));
419                 break;
420               }
421    #endif
422             default:             default:
423               stringstream temp;               stringstream temp;
424               temp << "Error - Interpolation On Domain: Finley does not know anything about function space type " << target.getFunctionSpace().getTypeCode();               temp << "Error - Interpolation On Domain: Finley does not know anything about function space type " << target.getFunctionSpace().getTypeCode();
# Line 706  void MeshAdapter::setToGradient(escript: Line 597  void MeshAdapter::setToGradient(escript:
597       throw FinleyAdapterException("Error - Illegal domain of gradient");       throw FinleyAdapterException("Error - Illegal domain of gradient");
598    
599    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
600      escriptDataC nodeDataC;
601    #ifdef PASO_MPI
602      escript::Data nodeTemp( arg, continuousFunction(asAbstractContinuousDomain()) );
603      if( arg.getFunctionSpace().getTypeCode() != Nodes )
604      {
605        Finley_Assemble_CopyNodalData(mesh->Nodes,&(nodeTemp.getDataC()),&(arg.getDataC()));
606        nodeDataC = nodeTemp.getDataC();
607      }
608      else
609        nodeDataC = arg.getDataC();
610    #else
611      nodeDataC = arg.getDataC();
612    #endif
613    switch(grad.getFunctionSpace().getTypeCode()) {    switch(grad.getFunctionSpace().getTypeCode()) {
614         case(Nodes):         case(Nodes):
615            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");
616            break;            break;
617         case(Elements):         case(Elements):
618            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&(grad.getDataC()),&nodeDataC);
619            break;            break;
620         case(FaceElements):         case(FaceElements):
621            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&(grad.getDataC()),&nodeDataC);
622            break;            break;
623         case(Points):         case(Points):
624            throw FinleyAdapterException("Error - Gradient at points is not supported.");            throw FinleyAdapterException("Error - Gradient at points is not supported.");
625            break;            break;
626         case(ContactElementsZero):         case(ContactElementsZero):
627            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&nodeDataC);
628            break;            break;
629         case(ContactElementsOne):         case(ContactElementsOne):
630            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&nodeDataC);
631            break;            break;
632         case(DegreesOfFreedom):         case(DegreesOfFreedom):
633            throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");            throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");
# Line 783  void MeshAdapter::setToSize(escript::Dat Line 687  void MeshAdapter::setToSize(escript::Dat
687  void MeshAdapter::setNewX(const escript::Data& new_x)  void MeshAdapter::setNewX(const escript::Data& new_x)
688  {  {
689    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
690      escriptDataC tmp;
691    const MeshAdapter& newDomain=dynamic_cast<const MeshAdapter&>(new_x.getFunctionSpace().getDomain());    const MeshAdapter& newDomain=dynamic_cast<const MeshAdapter&>(new_x.getFunctionSpace().getDomain());
692    if (newDomain!=*this)    if (newDomain!=*this)
693       throw FinleyAdapterException("Error - Illegal domain of new point locations");       throw FinleyAdapterException("Error - Illegal domain of new point locations");
694    Finley_Mesh_setCoordinates(mesh,&(new_x.getDataC()));    tmp = new_x.getDataC();
695      Finley_Mesh_setCoordinates(mesh,&tmp);
696    checkFinleyError();    checkFinleyError();
697  }  }
698    
# Line 795  void MeshAdapter::saveDX(const std::stri Line 701  void MeshAdapter::saveDX(const std::stri
701  {  {
702      int MAX_namelength=256;      int MAX_namelength=256;
703      const int num_data=boost::python::extract<int>(arg.attr("__len__")());      const int num_data=boost::python::extract<int>(arg.attr("__len__")());
704      char names[num_data][MAX_namelength];    /* win32 refactor */
705      char* c_names[num_data];    char* *names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
706      escriptDataC data[num_data];    for(int i=0;i<num_data;i++)
707      escriptDataC* ptr_data[num_data];    {
708        names[i] = (MAX_namelength>0) ? TMPMEMALLOC(MAX_namelength,char) : (char*)NULL;
709      }
710    
711      char* *c_names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
712      escriptDataC *data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC) : (escriptDataC*)NULL;
713      escriptDataC* *ptr_data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC*) : (escriptDataC**)NULL;
714    
715      boost::python::list keys=arg.keys();      boost::python::list keys=arg.keys();
716      for (int i=0;i<num_data;++i) {      for (int i=0;i<num_data;++i) {
# Line 818  void MeshAdapter::saveDX(const std::stri Line 730  void MeshAdapter::saveDX(const std::stri
730      }      }
731      Finley_Mesh_saveDX(filename.c_str(),m_finleyMesh.get(),num_data,c_names,ptr_data);      Finley_Mesh_saveDX(filename.c_str(),m_finleyMesh.get(),num_data,c_names,ptr_data);
732      checkFinleyError();      checkFinleyError();
733        
734          /* win32 refactor */
735      TMPMEMFREE(c_names);
736      TMPMEMFREE(data);
737      TMPMEMFREE(ptr_data);
738      for(int i=0;i<num_data;i++)
739      {
740        TMPMEMFREE(names[i]);
741      }
742      TMPMEMFREE(names);
743    
744      return;      return;
745  }  }
746    
# Line 826  void MeshAdapter::saveVTK(const std::str Line 749  void MeshAdapter::saveVTK(const std::str
749  {  {
750      int MAX_namelength=256;      int MAX_namelength=256;
751      const int num_data=boost::python::extract<int>(arg.attr("__len__")());      const int num_data=boost::python::extract<int>(arg.attr("__len__")());
752      char names[num_data][MAX_namelength];    /* win32 refactor */
753      char* c_names[num_data];    char* *names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
754      escriptDataC data[num_data];    for(int i=0;i<num_data;i++)
755      escriptDataC* ptr_data[num_data];    {
756        names[i] = (MAX_namelength>0) ? TMPMEMALLOC(MAX_namelength,char) : (char*)NULL;
757      }
758    
759      char* *c_names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
760      escriptDataC *data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC) : (escriptDataC*)NULL;
761      escriptDataC* *ptr_data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC*) : (escriptDataC**)NULL;
762    
763      boost::python::list keys=arg.keys();      boost::python::list keys=arg.keys();
764      for (int i=0;i<num_data;++i) {      for (int i=0;i<num_data;++i) {
# Line 849  void MeshAdapter::saveVTK(const std::str Line 778  void MeshAdapter::saveVTK(const std::str
778      }      }
779      Finley_Mesh_saveVTK(filename.c_str(),m_finleyMesh.get(),num_data,c_names,ptr_data);      Finley_Mesh_saveVTK(filename.c_str(),m_finleyMesh.get(),num_data,c_names,ptr_data);
780      checkFinleyError();      checkFinleyError();
781      /* win32 refactor */
782      TMPMEMFREE(c_names);
783      TMPMEMFREE(data);
784      TMPMEMFREE(ptr_data);
785      for(int i=0;i<num_data;i++)
786      {
787        TMPMEMFREE(names[i]);
788      }
789      TMPMEMFREE(names);
790    
791      return;      return;
792  }  }
793                                                                                                                                                                                                                                                                                                                                                    
# Line 1061  escript::Data MeshAdapter::getSize() con Line 1000  escript::Data MeshAdapter::getSize() con
1000    
1001  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const
1002  {  {
1003    int* tagList;    int out=0;
1004    int numTags;    Finley_Mesh* mesh=m_finleyMesh.get();
1005    getTagList(functionSpaceType, &tagList, &numTags);    switch (functionSpaceType) {
1006    return tagList[sampleNo];    case(Nodes):
1007        out=mesh->Nodes->Tag[sampleNo];
1008        break;
1009      case(Elements):
1010        out=mesh->Elements->Tag[sampleNo];
1011        break;
1012      case(FaceElements):
1013        out=mesh->FaceElements->Tag[sampleNo];
1014        break;
1015      case(Points):
1016        out=mesh->Points->Tag[sampleNo];
1017        break;
1018      case(ContactElementsZero):
1019        out=mesh->ContactElements->Tag[sampleNo];
1020        break;
1021      case(ContactElementsOne):
1022        out=mesh->ContactElements->Tag[sampleNo];
1023        break;
1024      case(DegreesOfFreedom):
1025        break;
1026      case(ReducedDegreesOfFreedom):
1027        break;
1028      default:
1029        stringstream temp;
1030        temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();
1031        throw FinleyAdapterException(temp.str());
1032        break;
1033      }
1034      return out;
1035  }  }
   
1036  int MeshAdapter::getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const  int MeshAdapter::getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const
1037  {  {
1038    int* referenceNoList;    int out=0,i;
1039    int numReferenceNo;    Finley_Mesh* mesh=m_finleyMesh.get();
1040    getReferenceNoList(functionSpaceType, &referenceNoList, &numReferenceNo);    switch (functionSpaceType) {
1041    return referenceNoList[sampleNo];    case(Nodes):
1042        if (mesh->Nodes!=NULL) {
1043          out=mesh->Nodes->Id[sampleNo];
1044          break;
1045        }
1046      case(Elements):
1047        out=mesh->Elements->Id[sampleNo];
1048        break;
1049      case(FaceElements):
1050        out=mesh->FaceElements->Id[sampleNo];
1051        break;
1052      case(Points):
1053        out=mesh->Points->Id[sampleNo];
1054        break;
1055      case(ContactElementsZero):
1056        out=mesh->ContactElements->Id[sampleNo];
1057        break;
1058      case(ContactElementsOne):
1059        out=mesh->ContactElements->Id[sampleNo];
1060        break;
1061      case(DegreesOfFreedom):
1062        for (i=0;i<mesh->Nodes->numNodes; ++i) {
1063           if (mesh->Nodes->degreeOfFreedom[i]==sampleNo) {
1064              out=mesh->Nodes->Id[i];
1065              break;
1066           }
1067        }
1068        break;
1069      case(ReducedDegreesOfFreedom):
1070        for (i=0;i<mesh->Nodes->numNodes; ++i) {
1071           if (mesh->Nodes->reducedDegreeOfFreedom[i]==sampleNo) {
1072              out=mesh->Nodes->Id[i];
1073              break;
1074           }
1075        }
1076        break;
1077      default:
1078        stringstream temp;
1079        temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();
1080        throw FinleyAdapterException(temp.str());
1081        break;
1082      }
1083      return out;
1084  }  }
1085    
1086  }  // end of namespace  }  // end of namespace

Legend:
Removed from v.532  
changed lines
  Added in v.757

  ViewVC Help
Powered by ViewVC 1.1.26