/[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 480 by jgs, Wed Feb 1 05:15:12 2006 UTC revision 1116 by gross, Mon Apr 23 03:36:34 2007 UTC
# Line 13  Line 13 
13   ******************************************************************************   ******************************************************************************
14  */  */
15    
16    #ifdef PASO_MPI
17    #include <mpi.h>
18    #endif
19  #include "MeshAdapter.h"  #include "MeshAdapter.h"
20    
21  #include "Data.h"  #include "escript/Data.h"
22  #include "DataFactory.h"  #include "escript/DataFactory.h"
23    
24  using namespace std;  using namespace std;
25  using namespace escript;  using namespace escript;
# Line 29  MeshAdapter::FunctionSpaceNamesMapType M Line 32  MeshAdapter::FunctionSpaceNamesMapType M
32  const int MeshAdapter::DegreesOfFreedom=FINLEY_DEGREES_OF_FREEDOM;  const int MeshAdapter::DegreesOfFreedom=FINLEY_DEGREES_OF_FREEDOM;
33  const int MeshAdapter::ReducedDegreesOfFreedom=FINLEY_REDUCED_DEGREES_OF_FREEDOM;  const int MeshAdapter::ReducedDegreesOfFreedom=FINLEY_REDUCED_DEGREES_OF_FREEDOM;
34  const int MeshAdapter::Nodes=FINLEY_NODES;  const int MeshAdapter::Nodes=FINLEY_NODES;
35    const int MeshAdapter::ReducedNodes=FINLEY_REDUCED_NODES;
36  const int MeshAdapter::Elements=FINLEY_ELEMENTS;  const int MeshAdapter::Elements=FINLEY_ELEMENTS;
37    const int MeshAdapter::ReducedElements=FINLEY_REDUCED_ELEMENTS;
38  const int MeshAdapter::FaceElements=FINLEY_FACE_ELEMENTS;  const int MeshAdapter::FaceElements=FINLEY_FACE_ELEMENTS;
39    const int MeshAdapter::ReducedFaceElements=FINLEY_REDUCED_FACE_ELEMENTS;
40  const int MeshAdapter::Points=FINLEY_POINTS;  const int MeshAdapter::Points=FINLEY_POINTS;
41  const int MeshAdapter::ContactElementsZero=FINLEY_CONTACT_ELEMENTS_1;  const int MeshAdapter::ContactElementsZero=FINLEY_CONTACT_ELEMENTS_1;
42    const int MeshAdapter::ReducedContactElementsZero=FINLEY_REDUCED_CONTACT_ELEMENTS_1;
43  const int MeshAdapter::ContactElementsOne=FINLEY_CONTACT_ELEMENTS_2;  const int MeshAdapter::ContactElementsOne=FINLEY_CONTACT_ELEMENTS_2;
44    const int MeshAdapter::ReducedContactElementsOne=FINLEY_REDUCED_CONTACT_ELEMENTS_2;
45    
46  MeshAdapter::MeshAdapter(Finley_Mesh* finleyMesh)  MeshAdapter::MeshAdapter(Finley_Mesh* finleyMesh)
47  {  {
# Line 70  Finley_Mesh* MeshAdapter::getFinley_Mesh Line 78  Finley_Mesh* MeshAdapter::getFinley_Mesh
78    
79  void MeshAdapter::write(const std::string& fileName) const  void MeshAdapter::write(const std::string& fileName) const
80  {  {
81    char fName[fileName.size()+1];    char *fName = (fileName.size()+1>0) ? TMPMEMALLOC(fileName.size()+1,char) : (char*)NULL;
82    strcpy(fName,fileName.c_str());    strcpy(fName,fileName.c_str());
83    Finley_Mesh_write(m_finleyMesh.get(),fName);    Finley_Mesh_write(m_finleyMesh.get(),fName);
84    checkFinleyError();    checkFinleyError();
85      TMPMEMFREE(fName);
86  }  }
87    
 // void MeshAdapter::getTagList(int functionSpaceType,  
 //                  int* numTags) const  
 // {  
 //   Finley_Mesh_tagList(m_finleyMesh.get(),functionSpaceType,tagList,numTags);  
 //   return;  
 // }  
   
88  string MeshAdapter::getDescription() const  string MeshAdapter::getDescription() const
89  {  {
90    return "FinleyMesh";    return "FinleyMesh";
# Line 115  void MeshAdapter::setFunctionSpaceTypeNa Line 117  void MeshAdapter::setFunctionSpaceTypeNa
117    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
118      (FunctionSpaceNamesMapType::value_type(Nodes,"Finley_Nodes"));      (FunctionSpaceNamesMapType::value_type(Nodes,"Finley_Nodes"));
119    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
120        (FunctionSpaceNamesMapType::value_type(ReducedNodes,"Finley_Reduced_Nodes"));
121      m_functionSpaceTypeNames.insert
122      (FunctionSpaceNamesMapType::value_type(Elements,"Finley_Elements"));      (FunctionSpaceNamesMapType::value_type(Elements,"Finley_Elements"));
123    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
124        (FunctionSpaceNamesMapType::value_type(ReducedElements,"Finley_Reduced_Elements"));
125      m_functionSpaceTypeNames.insert
126      (FunctionSpaceNamesMapType::value_type(FaceElements,"Finley_Face_Elements"));      (FunctionSpaceNamesMapType::value_type(FaceElements,"Finley_Face_Elements"));
127    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
128        (FunctionSpaceNamesMapType::value_type(ReducedFaceElements,"Finley_Reduced_Face_Elements"));
129      m_functionSpaceTypeNames.insert
130      (FunctionSpaceNamesMapType::value_type(Points,"Finley_Points"));      (FunctionSpaceNamesMapType::value_type(Points,"Finley_Points"));
131    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
132      (FunctionSpaceNamesMapType::value_type(ContactElementsZero,"Finley_Contact_Elements_0"));      (FunctionSpaceNamesMapType::value_type(ContactElementsZero,"Finley_Contact_Elements_0"));
133    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
134        (FunctionSpaceNamesMapType::value_type(ReducedContactElementsZero,"Finley_Reduced_Contact_Elements_0"));
135      m_functionSpaceTypeNames.insert
136      (FunctionSpaceNamesMapType::value_type(ContactElementsOne,"Finley_Contact_Elements_1"));      (FunctionSpaceNamesMapType::value_type(ContactElementsOne,"Finley_Contact_Elements_1"));
137      m_functionSpaceTypeNames.insert
138        (FunctionSpaceNamesMapType::value_type(ReducedContactElementsOne,"Finley_Reduced_Contact_Elements_1"));
139  }  }
140    
141  int MeshAdapter::getContinuousFunctionCode() const  int MeshAdapter::getContinuousFunctionCode() const
142  {  {
143    return Nodes;    return Nodes;
144  }  }
145    int MeshAdapter::getReducedContinuousFunctionCode() const
146    {
147      return ReducedNodes;
148    }
149    
150  int MeshAdapter::getFunctionCode() const  int MeshAdapter::getFunctionCode() const
151  {  {
152    return Elements;    return Elements;
153  }  }
154    int MeshAdapter::getReducedFunctionCode() const
155    {
156      return ReducedElements;
157    }
158    
159  int MeshAdapter::getFunctionOnBoundaryCode() const  int MeshAdapter::getFunctionOnBoundaryCode() const
160  {  {
161    return FaceElements;    return FaceElements;
162  }  }
163    int MeshAdapter::getReducedFunctionOnBoundaryCode() const
164    {
165      return ReducedFaceElements;
166    }
167    
168  int MeshAdapter::getFunctionOnContactZeroCode() const  int MeshAdapter::getFunctionOnContactZeroCode() const
169  {  {
170    return ContactElementsZero;    return ContactElementsZero;
171  }  }
172    int MeshAdapter::getReducedFunctionOnContactZeroCode() const
173    {
174      return ReducedContactElementsZero;
175    }
176    
177  int MeshAdapter::getFunctionOnContactOneCode() const  int MeshAdapter::getFunctionOnContactOneCode() const
178  {  {
179    return ContactElementsOne;    return ContactElementsOne;
180  }  }
181    int MeshAdapter::getReducedFunctionOnContactOneCode() const
182    {
183      return ReducedContactElementsOne;
184    }
185    
186  int MeshAdapter::getSolutionCode() const  int MeshAdapter::getSolutionCode() const
187  {  {
# Line 167  int MeshAdapter::getDiracDeltaFunctionCo Line 199  int MeshAdapter::getDiracDeltaFunctionCo
199  }  }
200    
201  //  //
 // 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;  
 }  
   
 //  
202  // return the spatial dimension of the Mesh:  // return the spatial dimension of the Mesh:
203  //  //
204  int MeshAdapter::getDim() const  int MeshAdapter::getDim() const
# Line 334  pair<int,int> MeshAdapter::getDataShape( Line 222  pair<int,int> MeshAdapter::getDataShape(
222             numDataPointsPerSample=1;             numDataPointsPerSample=1;
223             if (mesh->Nodes!=NULL) numSamples=mesh->Nodes->numNodes;             if (mesh->Nodes!=NULL) numSamples=mesh->Nodes->numNodes;
224             break;             break;
225          case(ReducedNodes):
226               /* TODO: add ReducedNodes */
227               numDataPointsPerSample=1;
228               if (mesh->Nodes!=NULL) numSamples=mesh->Nodes->numNodes;
229               throw FinleyAdapterException("Error - ReducedNodes is not supported yet.");
230               break;
231        case(Elements):        case(Elements):
232             if (mesh->Elements!=NULL) {             if (mesh->Elements!=NULL) {
233               numSamples=mesh->Elements->numElements;               numSamples=mesh->Elements->numElements;
234               numDataPointsPerSample=mesh->Elements->ReferenceElement->numQuadNodes;               numDataPointsPerSample=mesh->Elements->ReferenceElement->numQuadNodes;
235             }             }
236             break;             break;
237          case(ReducedElements):
238               if (mesh->Elements!=NULL) {
239                 numSamples=mesh->Elements->numElements;
240                 numDataPointsPerSample=mesh->Elements->ReferenceElementReducedOrder->numQuadNodes;
241               }
242               break;
243        case(FaceElements):        case(FaceElements):
244             if (mesh->FaceElements!=NULL) {             if (mesh->FaceElements!=NULL) {
245                  numDataPointsPerSample=mesh->FaceElements->ReferenceElement->numQuadNodes;                  numDataPointsPerSample=mesh->FaceElements->ReferenceElement->numQuadNodes;
246                  numSamples=mesh->FaceElements->numElements;                  numSamples=mesh->FaceElements->numElements;
247             }             }
248             break;             break;
249          case(ReducedFaceElements):
250               if (mesh->FaceElements!=NULL) {
251                    numDataPointsPerSample=mesh->FaceElements->ReferenceElementReducedOrder->numQuadNodes;
252                    numSamples=mesh->FaceElements->numElements;
253               }
254               break;
255        case(Points):        case(Points):
256             if (mesh->Points!=NULL) {             if (mesh->Points!=NULL) {
257               numDataPointsPerSample=1;               numDataPointsPerSample=1;
# Line 358  pair<int,int> MeshAdapter::getDataShape( Line 264  pair<int,int> MeshAdapter::getDataShape(
264               numSamples=mesh->ContactElements->numElements;               numSamples=mesh->ContactElements->numElements;
265             }             }
266             break;             break;
267          case(ReducedContactElementsZero):
268               if (mesh->ContactElements!=NULL) {
269                 numDataPointsPerSample=mesh->ContactElements->ReferenceElementReducedOrder->numQuadNodes;
270                 numSamples=mesh->ContactElements->numElements;
271               }
272               break;
273        case(ContactElementsOne):        case(ContactElementsOne):
274             if (mesh->ContactElements!=NULL) {             if (mesh->ContactElements!=NULL) {
275               numDataPointsPerSample=mesh->ContactElements->ReferenceElement->numQuadNodes;               numDataPointsPerSample=mesh->ContactElements->ReferenceElement->numQuadNodes;
276               numSamples=mesh->ContactElements->numElements;               numSamples=mesh->ContactElements->numElements;
277             }             }
278             break;             break;
279          case(ReducedContactElementsOne):
280               if (mesh->ContactElements!=NULL) {
281                 numDataPointsPerSample=mesh->ContactElements->ReferenceElementReducedOrder->numQuadNodes;
282                 numSamples=mesh->ContactElements->numElements;
283               }
284               break;
285        case(DegreesOfFreedom):        case(DegreesOfFreedom):
286             if (mesh->Nodes!=NULL) {             if (mesh->Nodes!=NULL) {
287               numDataPointsPerSample=1;               numDataPointsPerSample=1;
288    #ifndef PASO_MPI
289               numSamples=mesh->Nodes->numDegreesOfFreedom;               numSamples=mesh->Nodes->numDegreesOfFreedom;
290    #else
291                 numSamples=mesh->Nodes->degreeOfFreedomDistribution->numLocal;
292    #endif
293             }             }
294             break;             break;
295        case(ReducedDegreesOfFreedom):        case(ReducedDegreesOfFreedom):
296             if (mesh->Nodes!=NULL) {             if (mesh->Nodes!=NULL) {
297               numDataPointsPerSample=1;               numDataPointsPerSample=1;
298    #ifndef PASO_MPI
299               numSamples=mesh->Nodes->reducedNumDegreesOfFreedom;               numSamples=mesh->Nodes->reducedNumDegreesOfFreedom;
300    #else
301                 numSamples=mesh->Nodes->reducedDegreeOfFreedomDistribution->numLocal;
302    #endif
303             }             }
304             break;             break;
305        default:        default:
# Line 394  void MeshAdapter::addPDEToSystem( Line 320  void MeshAdapter::addPDEToSystem(
320                       const escript::Data& d, const escript::Data& y,                       const escript::Data& d, const escript::Data& y,
321                       const escript::Data& d_contact,const escript::Data& y_contact) const                       const escript::Data& d_contact,const escript::Data& y_contact) const
322  {  {
323       escriptDataC _rhs=rhs.getDataC();
324       escriptDataC _A  =A.getDataC();
325       escriptDataC _B=B.getDataC();
326       escriptDataC _C=C.getDataC();
327       escriptDataC _D=D.getDataC();
328       escriptDataC _X=X.getDataC();
329       escriptDataC _Y=Y.getDataC();
330       escriptDataC _d=d.getDataC();
331       escriptDataC _y=y.getDataC();
332       escriptDataC _d_contact=d_contact.getDataC();
333       escriptDataC _y_contact=y_contact.getDataC();
334    
335     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
336     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(),&(rhs.getDataC()),  
337                         &(A.getDataC()),&(B.getDataC()),&(C.getDataC()),&(D.getDataC()),&(X.getDataC()),&(Y.getDataC()));     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(), &_rhs, &_A, &_B, &_C, &_D, &_X, &_Y );
338     checkFinleyError();     checkFinleyError();
339     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,  
340                    mat.getPaso_SystemMatrix(),     Finley_Assemble_PDE(mesh->Nodes,mesh->FaceElements, mat.getPaso_SystemMatrix(), &_rhs, 0, 0, 0, &_d, 0, &_y );
                   &(rhs.getDataC()),  
                                   &(d.getDataC()),&(y.getDataC()),  
                                   Finley_Assemble_handelShapeMissMatch_Mean_out);  
341     checkFinleyError();     checkFinleyError();
342     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->ContactElements,  
343                    mat.getPaso_SystemMatrix(),     Finley_Assemble_PDE(mesh->Nodes,mesh->ContactElements, mat.getPaso_SystemMatrix(), &_rhs , 0, 0, 0, &_d_contact, 0, &_y_contact );
                   &(rhs.getDataC()),  
                                   &(d_contact.getDataC()),  
                   &(y_contact.getDataC()),  
                                   Finley_Assemble_handelShapeMissMatch_Step_out);  
344     checkFinleyError();     checkFinleyError();
345  }  }
346    
347  //  //
348  // adds linear PDE of second order into the right hand side only  // adds linear PDE of second order into the right hand side only
349  //  //
350  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  
351  {  {
352     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
353    
354     // Finley_Assemble_PDE_RHS(mesh->Nodes,mesh->Elements,&(rhs.getDataC()),&(X.getDataC()),&(Y.getDataC()));     escriptDataC _rhs=rhs.getDataC();
355     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,0,&(rhs.getDataC()),0,0,0,0,&(X.getDataC()),&(Y.getDataC()));     escriptDataC _X=X.getDataC();
356     checkFinleyError();     escriptDataC _Y=Y.getDataC();
357       escriptDataC _y=y.getDataC();
358       escriptDataC _y_contact=y_contact.getDataC();
359    
360     // Finley_Assemble_RobinCondition_RHS(mesh->Nodes,mesh->FaceElements,&(rhs.getDataC()),&(y.getDataC()),Finley_Assemble_handelShapeMissMatch_Mean_out);     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements, 0, &_rhs, 0, 0, 0, 0, &_X, &_Y );
361     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,0,&(rhs.getDataC()),0,&(y.getDataC()),Finley_Assemble_handelShapeMissMatch_Mean_out);     checkFinleyError();
362    
363       Finley_Assemble_PDE(mesh->Nodes,mesh->FaceElements, 0, &_rhs, 0, 0, 0, 0, 0, &_y );
364     checkFinleyError();     checkFinleyError();
365     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->ContactElements,0,&(rhs.getDataC()),0,&(y_contact.getDataC()),Finley_Assemble_handelShapeMissMatch_Step_out);  
366     // Finley_Assemble_RobinCondition_RHS(mesh->Nodes,mesh->ContactElements,&(rhs.getDataC()),&(y_contact.getDataC()),Finley_Assemble_handelShapeMissMatch_Step_out);     Finley_Assemble_PDE(mesh->Nodes,mesh->ContactElements, 0, &_rhs , 0, 0, 0, 0, 0, &_y_contact );
367     checkFinleyError();     checkFinleyError();
368  }  }
369    
# Line 441  void MeshAdapter::interpolateOnDomain(es Line 374  void MeshAdapter::interpolateOnDomain(es
374  {  {
375    const MeshAdapter& inDomain=dynamic_cast<const MeshAdapter&>(in.getFunctionSpace().getDomain());    const MeshAdapter& inDomain=dynamic_cast<const MeshAdapter&>(in.getFunctionSpace().getDomain());
376    const MeshAdapter& targetDomain=dynamic_cast<const MeshAdapter&>(target.getFunctionSpace().getDomain());    const MeshAdapter& targetDomain=dynamic_cast<const MeshAdapter&>(target.getFunctionSpace().getDomain());
377    if (inDomain!=*this)    if (inDomain!=*this)  
378       throw FinleyAdapterException("Error - Illegal domain of interpolant.");      throw FinleyAdapterException("Error - Illegal domain of interpolant.");
379    if (targetDomain!=*this)    if (targetDomain!=*this)
380       throw FinleyAdapterException("Error - Illegal domain of interpolation target.");      throw FinleyAdapterException("Error - Illegal domain of interpolation target.");
381    
382    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
383      escriptDataC _target=target.getDataC();
384      escriptDataC _in=in.getDataC();
385    switch(in.getFunctionSpace().getTypeCode()) {    switch(in.getFunctionSpace().getTypeCode()) {
386       case(Nodes):       case(Nodes):
387          switch(target.getFunctionSpace().getTypeCode()) {          switch(target.getFunctionSpace().getTypeCode()) {
388             case(Nodes):             case(Nodes):
389               case(ReducedNodes):
390               case(DegreesOfFreedom):
391             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
392                   Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
393                   break;
394               case(Elements):
395               case(ReducedElements):
396                   Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
397                   break;
398               case(FaceElements):
399               case(ReducedFaceElements):
400                   Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
401                   break;
402               case(Points):
403                   Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
404                   break;
405               case(ContactElementsZero):
406               case(ReducedContactElementsZero):
407                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
408                   break;
409               case(ContactElementsOne):
410               case(ReducedContactElementsOne):
411                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
412                   break;
413               default:
414                   stringstream temp;
415                   temp << "Error - Interpolation on Domain: Finley does not know anything about function space type " << target.getFunctionSpace().getTypeCode();
416                   throw FinleyAdapterException(temp.str());
417                   break;
418            }
419            break;
420         case(ReducedNodes):
421            switch(target.getFunctionSpace().getTypeCode()) {
422               case(Nodes):
423               case(ReducedNodes):
424             case(DegreesOfFreedom):             case(DegreesOfFreedom):
425                 Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));             case(ReducedDegreesOfFreedom):
426                   Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
427                 break;                 break;
428             case(Elements):             case(Elements):
429                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));             case(ReducedElements):
430                   Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
431                 break;                 break;
432             case(FaceElements):             case(FaceElements):
433                 Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedFaceElements):
434                   Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
435                 break;                 break;
436             case(Points):             case(Points):
437                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
438                 break;                 break;
439             case(ContactElementsZero):             case(ContactElementsZero):
440                 Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedContactElementsZero):
441                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
442                 break;                 break;
443             case(ContactElementsOne):             case(ContactElementsOne):
444                 Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedContactElementsOne):
445                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
446                 break;                 break;
447             default:             default:
448                 stringstream temp;                 stringstream temp;
# Line 479  void MeshAdapter::interpolateOnDomain(es Line 453  void MeshAdapter::interpolateOnDomain(es
453          break;          break;
454       case(Elements):       case(Elements):
455          if (target.getFunctionSpace().getTypeCode()==Elements) {          if (target.getFunctionSpace().getTypeCode()==Elements) {
456             Finley_Assemble_CopyElementData(mesh->Elements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->Elements,&_target,&_in);
457            } else if (target.getFunctionSpace().getTypeCode()==ReducedElements) {
458               Finley_Assemble_AverageElementData(mesh->Elements,&_target,&_in);
459          } else {          } else {
460             throw FinleyAdapterException("Error - No interpolation with data on elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on elements possible.");
461          }          }
462          break;          break;
463         case(ReducedElements):
464            if (target.getFunctionSpace().getTypeCode()==ReducedElements) {
465               Finley_Assemble_CopyElementData(mesh->Elements,&_target,&_in);
466            } else {
467               throw FinleyAdapterException("Error - No interpolation with data on elements with reduced integration order possible.");
468            }
469            break;
470       case(FaceElements):       case(FaceElements):
471          if (target.getFunctionSpace().getTypeCode()==FaceElements) {          if (target.getFunctionSpace().getTypeCode()==FaceElements) {
472             Finley_Assemble_CopyElementData(mesh->FaceElements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);
473            } else if (target.getFunctionSpace().getTypeCode()==ReducedFaceElements) {
474               Finley_Assemble_AverageElementData(mesh->FaceElements,&_target,&_in);
475          } else {          } else {
476             throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");
            break;  
477         }         }
478           break;
479         case(ReducedFaceElements):
480            if (target.getFunctionSpace().getTypeCode()==FaceElements) {
481               Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);
482            } else {
483               throw FinleyAdapterException("Error - No interpolation with data on face elements with reduced integration order possible.");
484           }
485           break;
486       case(Points):       case(Points):
487          if (target.getFunctionSpace().getTypeCode()==Points) {          if (target.getFunctionSpace().getTypeCode()==Points) {
488             Finley_Assemble_CopyElementData(mesh->Points,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->Points,&_target,&_in);
489          } else {          } else {
490             throw FinleyAdapterException("Error - No interpolation with data on points possible.");             throw FinleyAdapterException("Error - No interpolation with data on points possible.");
            break;  
491          }          }
492          break;          break;
493       case(ContactElementsZero):       case(ContactElementsZero):
494       case(ContactElementsOne):       case(ContactElementsOne):
495          if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {          if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {
496             Finley_Assemble_CopyElementData(mesh->ContactElements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);
497            } else if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {
498               Finley_Assemble_AverageElementData(mesh->ContactElements,&_target,&_in);
499          } else {          } else {
500             throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");
501             break;             break;
502          }          }
503          break;          break;
504       case(DegreesOfFreedom):       case(ReducedContactElementsZero):
505         case(ReducedContactElementsOne):
506            if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {
507               Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);
508            } else {
509               throw FinleyAdapterException("Error - No interpolation with data on contact elements with reduced integration order possible.");
510               break;
511            }
512            break;
513         case(DegreesOfFreedom):      
514          switch(target.getFunctionSpace().getTypeCode()) {          switch(target.getFunctionSpace().getTypeCode()) {
515             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
516             case(DegreesOfFreedom):             case(DegreesOfFreedom):
517             case(Nodes):             case(Nodes):
518                Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));             case(ReducedNodes):
519                  Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
520                  break;
521    #ifndef PASO_MPI
522               case(Elements):
523               case(ReducedElements):
524                  Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
525                  break;
526               case(FaceElements):
527               case(ReducedFaceElements):
528                  Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
529                  break;
530               case(Points):
531                  Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
532                break;                break;
533               case(ContactElementsZero):
534               case(ContactElementsOne):
535               case(ReducedContactElementsZero):
536               case(ReducedContactElementsOne):
537                  Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
538                 break;
539    #else
540               /* need to copy Degrees of freedom data to nodal data so that the external values are available */
541             case(Elements):             case(Elements):
542                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));             case(ReducedElements):
543                  escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
544                  Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(nodeTemp.getDataC()),&_target);
545                break;                break;
546             case(FaceElements):             case(FaceElements):
547                Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedFaceElements):
548                  escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
549                  Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(nodeTemp.getDataC()),&_target);
550                break;                break;
551             case(Points):             case(Points):
552                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
553                  Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(nodeTemp.getDataC()),&_target);
554                break;                break;
555             case(ContactElementsZero):             case(ContactElementsZero):
556             case(ContactElementsOne):             case(ContactElementsOne):
557                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedContactElementsZero):
558               case(ReducedContactElementsOne):
559                  escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
560                  Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(nodeTemp.getDataC()),&_target);
561               break;               break;
562    #endif
563             default:             default:
564               stringstream temp;               stringstream temp;
565               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 537  void MeshAdapter::interpolateOnDomain(es Line 569  void MeshAdapter::interpolateOnDomain(es
569          break;          break;
570       case(ReducedDegreesOfFreedom):       case(ReducedDegreesOfFreedom):
571         switch(target.getFunctionSpace().getTypeCode()) {         switch(target.getFunctionSpace().getTypeCode()) {
572              case(Nodes):
573                 throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to mesh nodes.");
574                 break;
575              case(ReducedNodes):
576                 Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
577                 break;
578              case(DegreesOfFreedom):
579                 throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to degrees of freedom");
580                 break;
581            case(ReducedDegreesOfFreedom):            case(ReducedDegreesOfFreedom):
582               Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));               Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
583               break;               break;
584            case(Elements):            case(Elements):
585               Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));            case(ReducedElements):
586                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
587               break;               break;
588            case(FaceElements):            case(FaceElements):
589               Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));            case(ReducedFaceElements):
590                 Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
591               break;               break;
592            case(Points):            case(Points):
593               Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));               Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
594               break;               break;
595            case(ContactElementsZero):            case(ContactElementsZero):
596            case(ContactElementsOne):            case(ContactElementsOne):
597               Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));            case(ReducedContactElementsZero):
598               break;            case(ReducedContactElementsOne):
599            case(Nodes):               Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
              throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to mesh nodes.");  
              break;  
           case(DegreesOfFreedom):  
              throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to degrees of freedom");  
600               break;               break;
601            default:            default:
602               stringstream temp;               stringstream temp;
# Line 586  void MeshAdapter::setToX(escript::Data& Line 625  void MeshAdapter::setToX(escript::Data&
625    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
626    // in case of values node coordinates we can do the job directly:    // in case of values node coordinates we can do the job directly:
627    if (arg.getFunctionSpace().getTypeCode()==Nodes) {    if (arg.getFunctionSpace().getTypeCode()==Nodes) {
628       Finley_Assemble_NodeCoordinates(mesh->Nodes,&(arg.getDataC()));       escriptDataC _arg=arg.getDataC();
629         Finley_Assemble_NodeCoordinates(mesh->Nodes,&_arg);
630    } else {    } else {
631       escript::Data tmp_data=Vector(0.0,continuousFunction(asAbstractContinuousDomain()),true);       escript::Data tmp_data=Vector(0.0,continuousFunction(asAbstractContinuousDomain()),true);
632       Finley_Assemble_NodeCoordinates(mesh->Nodes,&(tmp_data.getDataC()));       escriptDataC _tmp_data=tmp_data.getDataC();
633         Finley_Assemble_NodeCoordinates(mesh->Nodes,&_tmp_data);
634       // this is then interpolated onto arg:       // this is then interpolated onto arg:
635       interpolateOnDomain(arg,tmp_data);       interpolateOnDomain(arg,tmp_data);
636    }    }
# Line 605  void MeshAdapter::setToNormal(escript::D Line 646  void MeshAdapter::setToNormal(escript::D
646    if (normalDomain!=*this)    if (normalDomain!=*this)
647       throw FinleyAdapterException("Error - Illegal domain of normal locations");       throw FinleyAdapterException("Error - Illegal domain of normal locations");
648    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
649      escriptDataC _normal=normal.getDataC();
650    switch(normal.getFunctionSpace().getTypeCode()) {    switch(normal.getFunctionSpace().getTypeCode()) {
651      case(Nodes):      case(Nodes):
652        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");
653        break;        break;
654        case(ReducedNodes):
655          throw FinleyAdapterException("Error - Finley does not support surface normal vectors for reduced nodes");
656          break;
657      case(Elements):      case(Elements):
658        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements");
659        break;        break;
660        case(ReducedElements):
661          throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements with reduced integration order");
662          break;
663      case (FaceElements):      case (FaceElements):
664        Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&(normal.getDataC()));        Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&_normal);
665          break;
666        case (ReducedFaceElements):
667          Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&_normal);
668        break;        break;
669      case(Points):      case(Points):
670        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for point elements");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for point elements");
671        break;        break;
672      case (ContactElementsOne):      case (ContactElementsOne):
673      case (ContactElementsZero):      case (ContactElementsZero):
674        Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&(normal.getDataC()));        Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&_normal);
675          break;
676        case (ReducedContactElementsOne):
677        case (ReducedContactElementsZero):
678          Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&_normal);
679        break;        break;
680      case(DegreesOfFreedom):      case(DegreesOfFreedom):
681        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for degrees of freedom.");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for degrees of freedom.");
# Line 659  void MeshAdapter::setToIntegrals(std::ve Line 714  void MeshAdapter::setToIntegrals(std::ve
714       throw FinleyAdapterException("Error - Illegal domain of integration kernel");       throw FinleyAdapterException("Error - Illegal domain of integration kernel");
715    
716    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
717      escriptDataC _arg=arg.getDataC();
718    switch(arg.getFunctionSpace().getTypeCode()) {    switch(arg.getFunctionSpace().getTypeCode()) {
719       case(Nodes):       case(Nodes):
720            /* TODO */
721          throw FinleyAdapterException("Error - Integral of data on nodes is not supported.");          throw FinleyAdapterException("Error - Integral of data on nodes is not supported.");
722          break;          break;
723         case(ReducedNodes):
724            /* TODO */
725            throw FinleyAdapterException("Error - Integral of data on reduced nodes is not supported.");
726            break;
727       case(Elements):       case(Elements):
728          Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);
729            break;
730         case(ReducedElements):
731            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);
732          break;          break;
733       case(FaceElements):       case(FaceElements):
734          Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&_arg,&integrals[0]);
735            break;
736         case(ReducedFaceElements):
737            Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&_arg,&integrals[0]);
738          break;          break;
739       case(Points):       case(Points):
740          throw FinleyAdapterException("Error - Integral of data on points is not supported.");          throw FinleyAdapterException("Error - Integral of data on points is not supported.");
741          break;          break;
742       case(ContactElementsZero):       case(ContactElementsZero):
743          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
744            break;
745         case(ReducedContactElementsZero):
746            Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
747          break;          break;
748       case(ContactElementsOne):       case(ContactElementsOne):
749          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
750            break;
751         case(ReducedContactElementsOne):
752            Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
753          break;          break;
754       case(DegreesOfFreedom):       case(DegreesOfFreedom):
755          throw FinleyAdapterException("Error - Integral of data on degrees of freedom is not supported.");          throw FinleyAdapterException("Error - Integral of data on degrees of freedom is not supported.");
# Line 706  void MeshAdapter::setToGradient(escript: Line 779  void MeshAdapter::setToGradient(escript:
779       throw FinleyAdapterException("Error - Illegal domain of gradient");       throw FinleyAdapterException("Error - Illegal domain of gradient");
780    
781    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
782      escriptDataC _grad=grad.getDataC();
783      escriptDataC nodeDataC;
784    #ifdef PASO_MPI
785      escript::Data nodeTemp( arg, continuousFunction(asAbstractContinuousDomain()) );
786      if( arg.getFunctionSpace().getTypeCode() != Nodes )
787      {
788        Finley_Assemble_CopyNodalData(mesh->Nodes,&(nodeTemp.getDataC()),&(arg.getDataC()));
789        nodeDataC = nodeTemp.getDataC();
790      }
791      else
792        nodeDataC = arg.getDataC();
793    #else
794      nodeDataC = arg.getDataC();
795    #endif
796    switch(grad.getFunctionSpace().getTypeCode()) {    switch(grad.getFunctionSpace().getTypeCode()) {
797         case(Nodes):         case(Nodes):
798            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");
799            break;            break;
800           case(ReducedNodes):
801              throw FinleyAdapterException("Error - Gradient at reduced nodes is not supported.");
802              break;
803         case(Elements):         case(Elements):
804            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&_grad,&nodeDataC);
805              break;
806           case(ReducedElements):
807              Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&_grad,&nodeDataC);
808            break;            break;
809         case(FaceElements):         case(FaceElements):
810            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&_grad,&nodeDataC);
811              break;
812           case(ReducedFaceElements):
813              Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&_grad,&nodeDataC);
814            break;            break;
815         case(Points):         case(Points):
816            throw FinleyAdapterException("Error - Gradient at points is not supported.");            throw FinleyAdapterException("Error - Gradient at points is not supported.");
817            break;            break;
818         case(ContactElementsZero):         case(ContactElementsZero):
819            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
820              break;
821           case(ReducedContactElementsZero):
822              Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
823            break;            break;
824         case(ContactElementsOne):         case(ContactElementsOne):
825            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&(arg.getDataC()));            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
826              break;
827           case(ReducedContactElementsOne):
828              Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
829            break;            break;
830         case(DegreesOfFreedom):         case(DegreesOfFreedom):
831            throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");            throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");
# Line 751  void MeshAdapter::setToSize(escript::Dat Line 853  void MeshAdapter::setToSize(escript::Dat
853         case(Nodes):         case(Nodes):
854            throw FinleyAdapterException("Error - Size of nodes is not supported.");            throw FinleyAdapterException("Error - Size of nodes is not supported.");
855            break;            break;
856           case(ReducedNodes):
857              throw FinleyAdapterException("Error - Size of reduced nodes is not supported.");
858              break;
859         case(Elements):         case(Elements):
860            Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);
861            break;            break;
862           case(ReducedElements):
863              Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);
864              break;
865         case(FaceElements):         case(FaceElements):
866            Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);
867            break;            break;
868           case(ReducedFaceElements):
869              Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);
870              break;
871         case(Points):         case(Points):
872            throw FinleyAdapterException("Error - Size of point elements is not supported.");            throw FinleyAdapterException("Error - Size of point elements is not supported.");
873            break;            break;
# Line 764  void MeshAdapter::setToSize(escript::Dat Line 875  void MeshAdapter::setToSize(escript::Dat
875         case(ContactElementsOne):         case(ContactElementsOne):
876            Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);
877            break;            break;
878           case(ReducedContactElementsZero):
879           case(ReducedContactElementsOne):
880              Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);
881              break;
882         case(DegreesOfFreedom):         case(DegreesOfFreedom):
883            throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");            throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");
884            break;            break;
# Line 783  void MeshAdapter::setToSize(escript::Dat Line 898  void MeshAdapter::setToSize(escript::Dat
898  void MeshAdapter::setNewX(const escript::Data& new_x)  void MeshAdapter::setNewX(const escript::Data& new_x)
899  {  {
900    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
901      escriptDataC tmp;
902    const MeshAdapter& newDomain=dynamic_cast<const MeshAdapter&>(new_x.getFunctionSpace().getDomain());    const MeshAdapter& newDomain=dynamic_cast<const MeshAdapter&>(new_x.getFunctionSpace().getDomain());
903    if (newDomain!=*this)    if (newDomain!=*this)
904       throw FinleyAdapterException("Error - Illegal domain of new point locations");       throw FinleyAdapterException("Error - Illegal domain of new point locations");
905    Finley_NodeFile_setCoordinates(mesh->Nodes,&(new_x.getDataC()));    tmp = new_x.getDataC();
906      Finley_Mesh_setCoordinates(mesh,&tmp);
907    checkFinleyError();    checkFinleyError();
908  }  }
909    
# Line 795  void MeshAdapter::saveDX(const std::stri Line 912  void MeshAdapter::saveDX(const std::stri
912  {  {
913      int MAX_namelength=256;      int MAX_namelength=256;
914      const int num_data=boost::python::extract<int>(arg.attr("__len__")());      const int num_data=boost::python::extract<int>(arg.attr("__len__")());
915      char names[num_data][MAX_namelength];    /* win32 refactor */
916      char* c_names[num_data];    char* *names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
917      escriptDataC data[num_data];    for(int i=0;i<num_data;i++)
918      escriptDataC* ptr_data[num_data];    {
919        names[i] = (MAX_namelength>0) ? TMPMEMALLOC(MAX_namelength,char) : (char*)NULL;
920      }
921    
922      char* *c_names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
923      escriptDataC *data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC) : (escriptDataC*)NULL;
924      escriptDataC* *ptr_data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC*) : (escriptDataC**)NULL;
925    
926      boost::python::list keys=arg.keys();      boost::python::list keys=arg.keys();
927      for (int i=0;i<num_data;++i) {      for (int i=0;i<num_data;++i) {
928           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);
929           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)
930               throw FinleyAdapterException("Error  in saveVTK: Data must be defined on same Domain");               throw FinleyAdapterException("Error  in saveDX: Data must be defined on same Domain");
931           data[i]=d.getDataC();           data[i]=d.getDataC();
932           ptr_data[i]=&(data[i]);           ptr_data[i]=&(data[i]);
933           std::string n=boost::python::extract<std::string>(keys[i]);           std::string n=boost::python::extract<std::string>(keys[i]);
# Line 818  void MeshAdapter::saveDX(const std::stri Line 941  void MeshAdapter::saveDX(const std::stri
941      }      }
942      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);
943      checkFinleyError();      checkFinleyError();
944        
945          /* win32 refactor */
946      TMPMEMFREE(c_names);
947      TMPMEMFREE(data);
948      TMPMEMFREE(ptr_data);
949      for(int i=0;i<num_data;i++)
950      {
951        TMPMEMFREE(names[i]);
952      }
953      TMPMEMFREE(names);
954    
955      return;      return;
956  }  }
957    
# Line 826  void MeshAdapter::saveVTK(const std::str Line 960  void MeshAdapter::saveVTK(const std::str
960  {  {
961      int MAX_namelength=256;      int MAX_namelength=256;
962      const int num_data=boost::python::extract<int>(arg.attr("__len__")());      const int num_data=boost::python::extract<int>(arg.attr("__len__")());
963      char names[num_data][MAX_namelength];    /* win32 refactor */
964      char* c_names[num_data];    char* *names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
965      escriptDataC data[num_data];    for(int i=0;i<num_data;i++)
966      escriptDataC* ptr_data[num_data];    {
967        names[i] = (MAX_namelength>0) ? TMPMEMALLOC(MAX_namelength,char) : (char*)NULL;
968      }
969    
970      char* *c_names = (num_data>0) ? TMPMEMALLOC(num_data,char*) : (char**)NULL;
971      escriptDataC *data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC) : (escriptDataC*)NULL;
972      escriptDataC* *ptr_data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC*) : (escriptDataC**)NULL;
973    
974      boost::python::list keys=arg.keys();      boost::python::list keys=arg.keys();
975      for (int i=0;i<num_data;++i) {      for (int i=0;i<num_data;++i) {
# Line 847  void MeshAdapter::saveVTK(const std::str Line 987  void MeshAdapter::saveVTK(const std::str
987              strcpy(c_names[i],n.c_str());              strcpy(c_names[i],n.c_str());
988           }           }
989      }      }
990    #ifndef PASO_MPI    
991      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);
992      checkFinleyError();  #else
993        Finley_Mesh_saveVTK_MPIO(filename.c_str(),m_finleyMesh.get(),num_data,c_names,ptr_data);
994    #endif
995    
996    checkFinleyError();
997      /* win32 refactor */
998      TMPMEMFREE(c_names);
999      TMPMEMFREE(data);
1000      TMPMEMFREE(ptr_data);
1001      for(int i=0;i<num_data;i++)
1002      {
1003        TMPMEMFREE(names[i]);
1004      }
1005      TMPMEMFREE(names);
1006    
1007      return;      return;
1008  }  }
1009                                                                                                                                                                                                                                                                                                                                                    
# Line 915  bool MeshAdapter::isCellOriented(int fun Line 1070  bool MeshAdapter::isCellOriented(int fun
1070         case(Points):         case(Points):
1071         case(ContactElementsZero):         case(ContactElementsZero):
1072         case(ContactElementsOne):         case(ContactElementsOne):
1073           case(ReducedElements):
1074           case(ReducedFaceElements):
1075           case(ReducedContactElementsZero):
1076           case(ReducedContactElementsOne):
1077            return true;            return true;
1078            break;            break;
1079         default:         default:
# Line 933  bool MeshAdapter::probeInterpolationOnDo Line 1092  bool MeshAdapter::probeInterpolationOnDo
1092       case(Nodes):       case(Nodes):
1093          switch(functionSpaceType_target) {          switch(functionSpaceType_target) {
1094             case(Nodes):             case(Nodes):
1095               case(ReducedNodes):
1096             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
1097             case(DegreesOfFreedom):             case(DegreesOfFreedom):
1098             case(Elements):             case(Elements):
1099               case(ReducedElements):
1100             case(FaceElements):             case(FaceElements):
1101               case(ReducedFaceElements):
1102             case(Points):             case(Points):
1103             case(ContactElementsZero):             case(ContactElementsZero):
1104               case(ReducedContactElementsZero):
1105             case(ContactElementsOne):             case(ContactElementsOne):
1106               case(ReducedContactElementsOne):
1107                 return true;                 return true;
1108             default:             default:
1109                 stringstream temp;                 stringstream temp;
# Line 947  bool MeshAdapter::probeInterpolationOnDo Line 1111  bool MeshAdapter::probeInterpolationOnDo
1111                 throw FinleyAdapterException(temp.str());                 throw FinleyAdapterException(temp.str());
1112          }          }
1113          break;          break;
1114         case(ReducedNodes):
1115            switch(functionSpaceType_target) {
1116               case(ReducedNodes):
1117               case(ReducedDegreesOfFreedom):
1118               case(Elements):
1119               case(ReducedElements):
1120               case(FaceElements):
1121               case(ReducedFaceElements):
1122               case(Points):
1123               case(ContactElementsZero):
1124               case(ReducedContactElementsZero):
1125               case(ContactElementsOne):
1126               case(ReducedContactElementsOne):
1127                   return true;
1128              case(Nodes):
1129              case(DegreesOfFreedom):
1130                 return false;
1131               default:
1132                   stringstream temp;
1133                   temp << "Error - Interpolation On Domain: Finley does not know anything about function space type " << functionSpaceType_target;
1134                   throw FinleyAdapterException(temp.str());
1135            }
1136            break;
1137       case(Elements):       case(Elements):
1138          if (functionSpaceType_target==Elements) {          if (functionSpaceType_target==Elements) {
1139             return true;             return true;
1140            } else if (functionSpaceType_target==ReducedElements) {
1141               return true;
1142            } else {
1143               return false;
1144            }
1145         case(ReducedElements):
1146            if (functionSpaceType_target==ReducedElements) {
1147               return true;
1148          } else {          } else {
1149             return false;             return false;
1150          }          }
1151       case(FaceElements):       case(FaceElements):
1152          if (functionSpaceType_target==FaceElements) {          if (functionSpaceType_target==FaceElements) {
1153             return true;             return true;
1154            } else if (functionSpaceType_target==ReducedFaceElements) {
1155               return true;
1156            } else {
1157               return false;
1158            }
1159         case(ReducedFaceElements):
1160            if (functionSpaceType_target==ReducedFaceElements) {
1161               return true;
1162          } else {          } else {
1163             return false;             return false;
1164          }          }
# Line 969  bool MeshAdapter::probeInterpolationOnDo Line 1172  bool MeshAdapter::probeInterpolationOnDo
1172       case(ContactElementsOne):       case(ContactElementsOne):
1173          if (functionSpaceType_target==ContactElementsZero || functionSpaceType_target==ContactElementsOne) {          if (functionSpaceType_target==ContactElementsZero || functionSpaceType_target==ContactElementsOne) {
1174             return true;             return true;
1175            } else if (functionSpaceType_target==ReducedContactElementsZero || functionSpaceType_target==ReducedContactElementsOne) {
1176               return true;
1177            } else {
1178               return false;
1179            }
1180         case(ReducedContactElementsZero):
1181         case(ReducedContactElementsOne):
1182            if (functionSpaceType_target==ReducedContactElementsZero || functionSpaceType_target==ReducedContactElementsOne) {
1183               return true;
1184          } else {          } else {
1185             return false;             return false;
1186          }          }
# Line 977  bool MeshAdapter::probeInterpolationOnDo Line 1189  bool MeshAdapter::probeInterpolationOnDo
1189             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
1190             case(DegreesOfFreedom):             case(DegreesOfFreedom):
1191             case(Nodes):             case(Nodes):
1192               case(ReducedNodes):
1193             case(Elements):             case(Elements):
1194             case(FaceElements):             case(ReducedElements):
1195             case(Points):             case(Points):
1196               case(FaceElements):
1197               case(ReducedFaceElements):
1198             case(ContactElementsZero):             case(ContactElementsZero):
1199               case(ReducedContactElementsZero):
1200             case(ContactElementsOne):             case(ContactElementsOne):
1201               case(ReducedContactElementsOne):
1202                return true;                return true;
1203             default:             default:
1204               stringstream temp;               stringstream temp;
# Line 992  bool MeshAdapter::probeInterpolationOnDo Line 1209  bool MeshAdapter::probeInterpolationOnDo
1209       case(ReducedDegreesOfFreedom):       case(ReducedDegreesOfFreedom):
1210         switch(functionSpaceType_target) {         switch(functionSpaceType_target) {
1211            case(ReducedDegreesOfFreedom):            case(ReducedDegreesOfFreedom):
1212              case(ReducedNodes):
1213            case(Elements):            case(Elements):
1214              case(ReducedElements):
1215            case(FaceElements):            case(FaceElements):
1216              case(ReducedFaceElements):
1217            case(Points):            case(Points):
1218            case(ContactElementsZero):            case(ContactElementsZero):
1219              case(ReducedContactElementsZero):
1220            case(ContactElementsOne):            case(ContactElementsOne):
1221              case(ReducedContactElementsOne):
1222                return true;                return true;
1223            case(Nodes):            case(Nodes):
1224            case(DegreesOfFreedom):            case(DegreesOfFreedom):
# Line 1059  escript::Data MeshAdapter::getSize() con Line 1281  escript::Data MeshAdapter::getSize() con
1281    return function(asAbstractContinuousDomain()).getSize();    return function(asAbstractContinuousDomain()).getSize();
1282  }  }
1283    
1284    int* MeshAdapter::borrowSampleReferenceIDs(int functionSpaceType) const
1285    {
1286      int *out=0,i;
1287      Finley_Mesh* mesh=m_finleyMesh.get();
1288      switch (functionSpaceType) {
1289        case(Nodes):
1290          if (mesh->Nodes!=NULL) {
1291            out=mesh->Nodes->Id;
1292            break;
1293          }
1294        case(ReducedNodes):
1295          throw FinleyAdapterException("Error -  ReducedNodes not supported yet.");
1296          break;
1297        case(Elements):
1298          out=mesh->Elements->Id;
1299          break;
1300        case(ReducedElements):
1301          out=mesh->Elements->Id;
1302          break;
1303        case(FaceElements):
1304          out=mesh->FaceElements->Id;
1305          break;
1306        case(ReducedFaceElements):
1307          out=mesh->FaceElements->Id;
1308          break;
1309        case(Points):
1310          out=mesh->Points->Id;
1311          break;
1312        case(ContactElementsZero):
1313          out=mesh->ContactElements->Id;
1314          break;
1315        case(ReducedContactElementsZero):
1316          out=mesh->ContactElements->Id;
1317          break;
1318        case(ContactElementsOne):
1319          out=mesh->ContactElements->Id;
1320          break;
1321        case(ReducedContactElementsOne):
1322          out=mesh->ContactElements->Id;
1323          break;
1324        case(DegreesOfFreedom):
1325          out=mesh->Nodes->degreeOfFreedomId;
1326          break;
1327        case(ReducedDegreesOfFreedom):
1328          out=mesh->Nodes->reducedDegreeOfFreedomId;
1329          break;
1330        default:
1331          stringstream temp;
1332          temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();
1333          throw FinleyAdapterException(temp.str());
1334          break;
1335      }
1336      return out;
1337    }
1338  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const
1339  {  {
1340    int* tagList;    int out=0;
1341    int numTags;    Finley_Mesh* mesh=m_finleyMesh.get();
1342    getTagList(functionSpaceType, &tagList, &numTags);    switch (functionSpaceType) {
1343    return tagList[sampleNo];    case(Nodes):
1344        out=mesh->Nodes->Tag[sampleNo];
1345        break;
1346      case(ReducedNodes):
1347        throw FinleyAdapterException(" Error - ReducedNodes does not support tags.");
1348        break;
1349      case(Elements):
1350        out=mesh->Elements->Tag[sampleNo];
1351        break;
1352      case(ReducedElements):
1353        out=mesh->Elements->Tag[sampleNo];
1354        break;
1355      case(FaceElements):
1356        out=mesh->FaceElements->Tag[sampleNo];
1357        break;
1358      case(ReducedFaceElements):
1359        out=mesh->FaceElements->Tag[sampleNo];
1360        break;
1361      case(Points):
1362        out=mesh->Points->Tag[sampleNo];
1363        break;
1364      case(ContactElementsZero):
1365        out=mesh->ContactElements->Tag[sampleNo];
1366        break;
1367      case(ReducedContactElementsZero):
1368        out=mesh->ContactElements->Tag[sampleNo];
1369        break;
1370      case(ContactElementsOne):
1371        out=mesh->ContactElements->Tag[sampleNo];
1372        break;
1373      case(ReducedContactElementsOne):
1374        out=mesh->ContactElements->Tag[sampleNo];
1375        break;
1376      case(DegreesOfFreedom):
1377        throw FinleyAdapterException(" Error - DegreesOfFreedom does not support tags.");
1378        break;
1379      case(ReducedDegreesOfFreedom):
1380        throw FinleyAdapterException(" Error - ReducedDegreesOfFreedom does not support tags.");
1381        break;
1382      default:
1383        stringstream temp;
1384        temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();
1385        throw FinleyAdapterException(temp.str());
1386        break;
1387      }
1388      return out;
1389    }
1390    
1391    
1392    void MeshAdapter::setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const
1393    {
1394      Finley_Mesh* mesh=m_finleyMesh.get();
1395      escriptDataC tmp=mask.getDataC();
1396      switch(functionSpaceType) {
1397           case(Nodes):
1398              Finley_NodeFile_setTags(mesh->Nodes,newTag,&tmp);
1399              break;
1400           case(ReducedNodes):
1401              throw FinleyAdapterException("Error - ReducedNodes does not support tags");
1402              break;
1403           case(DegreesOfFreedom):
1404              throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");
1405              break;
1406           case(ReducedDegreesOfFreedom):
1407              throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");
1408              break;
1409           case(Elements):
1410              Finley_ElementFile_setTags(mesh->Elements,newTag,&tmp);
1411              break;
1412           case(ReducedElements):
1413              Finley_ElementFile_setTags(mesh->Elements,newTag,&tmp);
1414              break;
1415           case(FaceElements):
1416              Finley_ElementFile_setTags(mesh->FaceElements,newTag,&tmp);
1417              break;
1418           case(ReducedFaceElements):
1419              Finley_ElementFile_setTags(mesh->FaceElements,newTag,&tmp);
1420              break;
1421           case(Points):
1422              Finley_ElementFile_setTags(mesh->Points,newTag,&tmp);
1423              break;
1424           case(ContactElementsZero):
1425              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1426              break;
1427           case(ReducedContactElementsZero):
1428              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1429              break;
1430           case(ContactElementsOne):
1431              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1432              break;
1433           case(ReducedContactElementsOne):
1434              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1435              break;
1436           default:
1437              stringstream temp;
1438              temp << "Error - Finley does not know anything about function space type " << functionSpaceType;
1439              throw FinleyAdapterException(temp.str());
1440      }
1441      checkFinleyError();
1442      return;
1443    }
1444    
1445    void MeshAdapter::setTagMap(const std::string& name,  int tag)
1446    {
1447      Finley_Mesh* mesh=m_finleyMesh.get();
1448      Finley_Mesh_addTagMap(mesh, name.c_str(),tag);
1449      checkPasoError();
1450      // throwStandardException("MeshAdapter::set TagMap is not implemented.");
1451    }
1452    
1453    int MeshAdapter::getTag(const std::string& name) const
1454    {
1455      Finley_Mesh* mesh=m_finleyMesh.get();
1456      int tag=0;
1457      tag=Finley_Mesh_getTag(mesh, name.c_str());
1458      checkPasoError();
1459      // throwStandardException("MeshAdapter::getTag is not implemented.");
1460      return tag;
1461  }  }
1462    
1463  int MeshAdapter::getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const  bool MeshAdapter::isValidTagName(const std::string& name) const
1464  {  {
1465    int* referenceNoList;    Finley_Mesh* mesh=m_finleyMesh.get();
1466    int numReferenceNo;    return Finley_Mesh_isValidTagName(mesh,name.c_str());
1467    getReferenceNoList(functionSpaceType, &referenceNoList, &numReferenceNo);  }
1468    return referenceNoList[sampleNo];  
1469    std::string MeshAdapter::showTagNames() const
1470    {
1471      stringstream temp;
1472      Finley_Mesh* mesh=m_finleyMesh.get();
1473      Finley_TagMap* tag_map=mesh->TagMap;
1474      while (tag_map) {
1475         temp << tag_map->name;
1476         tag_map=tag_map->next;
1477         if (tag_map) temp << ", ";
1478      }
1479      return temp.str();
1480  }  }
1481    
1482  }  // end of namespace  }  // end of namespace

Legend:
Removed from v.480  
changed lines
  Added in v.1116

  ViewVC Help
Powered by ViewVC 1.1.26