/[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 757 by woo409, Mon Jun 26 13:12:56 2006 UTC revision 1062 by gross, Mon Mar 26 06:17:53 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 "escript/Data.h"  #include "escript/Data.h"
# 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 109  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 184  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 208  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;
# Line 252  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();     escriptDataC _rhs=rhs.getDataC();
324    escriptDataC _A  =A.getDataC();     escriptDataC _A  =A.getDataC();
325    escriptDataC _B=B.getDataC();     escriptDataC _B=B.getDataC();
326    escriptDataC _C=C.getDataC();     escriptDataC _C=C.getDataC();
327    escriptDataC _D=D.getDataC();     escriptDataC _D=D.getDataC();
328    escriptDataC _X=X.getDataC();     escriptDataC _X=X.getDataC();
329    escriptDataC _Y=Y.getDataC();     escriptDataC _Y=Y.getDataC();
330    escriptDataC _d=d.getDataC();     escriptDataC _d=d.getDataC();
331    escriptDataC _y=y.getDataC();     escriptDataC _y=y.getDataC();
332    escriptDataC _d_contact=d_contact.getDataC();     escriptDataC _d_contact=d_contact.getDataC();
333    escriptDataC _y_contact=y_contact.getDataC();     escriptDataC _y_contact=y_contact.getDataC();
334    
335     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
    Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(), &_rhs, &_A, &_B, &_C, &_D, &_X, &_Y );  
336    
337       Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(), &_rhs, &_A, &_B, &_C, &_D, &_X, &_Y );
338     checkFinleyError();     checkFinleyError();
339    
340     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements, mat.getPaso_SystemMatrix(), &_rhs, &_d, &_y, Finley_Assemble_handelShapeMissMatch_Mean_out);     Finley_Assemble_PDE(mesh->Nodes,mesh->FaceElements, mat.getPaso_SystemMatrix(), &_rhs, 0, 0, 0, &_d, 0, &_y );
341     checkFinleyError();     checkFinleyError();
342    
343     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->ContactElements, mat.getPaso_SystemMatrix(), &_rhs , &_d_contact, &_y_contact ,             Finley_Assemble_handelShapeMissMatch_Step_out);     Finley_Assemble_PDE(mesh->Nodes,mesh->ContactElements, mat.getPaso_SystemMatrix(), &_rhs , 0, 0, 0, &_d_contact, 0, &_y_contact );
344     checkFinleyError();     checkFinleyError();
345  }  }
346    
# Line 283  void MeshAdapter::addPDEToRHS( escript:: Line 351  void MeshAdapter::addPDEToRHS( escript::
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 309  void MeshAdapter::interpolateOnDomain(es Line 380  void MeshAdapter::interpolateOnDomain(es
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 341  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 {          } else {
458             throw FinleyAdapterException("Error - No interpolation with data on elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on elements possible.");
459          }          }
460          break;          break;
461         case(ReducedElements):
462            if (target.getFunctionSpace().getTypeCode()==ReducedElements) {
463               Finley_Assemble_CopyElementData(mesh->Elements,&_target,&_in);
464            } else {
465               throw FinleyAdapterException("Error - No interpolation with data on elements with reduced integration order possible.");
466            }
467            break;
468       case(FaceElements):       case(FaceElements):
469          if (target.getFunctionSpace().getTypeCode()==FaceElements) {          if (target.getFunctionSpace().getTypeCode()==FaceElements) {
470             Finley_Assemble_CopyElementData(mesh->FaceElements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);
471          } else {          } else {
472             throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");
            break;  
473         }         }
474           break;
475         case(ReducedFaceElements):
476            if (target.getFunctionSpace().getTypeCode()==FaceElements) {
477               Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);
478            } else {
479               throw FinleyAdapterException("Error - No interpolation with data on face elements with reduced integration order possible.");
480           }
481           break;
482       case(Points):       case(Points):
483          if (target.getFunctionSpace().getTypeCode()==Points) {          if (target.getFunctionSpace().getTypeCode()==Points) {
484             Finley_Assemble_CopyElementData(mesh->Points,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->Points,&_target,&_in);
485          } else {          } else {
486             throw FinleyAdapterException("Error - No interpolation with data on points possible.");             throw FinleyAdapterException("Error - No interpolation with data on points possible.");
            break;  
487          }          }
488          break;          break;
489       case(ContactElementsZero):       case(ContactElementsZero):
490       case(ContactElementsOne):       case(ContactElementsOne):
491          if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {          if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {
492             Finley_Assemble_CopyElementData(mesh->ContactElements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);
493          } else {          } else {
494             throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");
495             break;             break;
496          }          }
497          break;          break;
498         case(ReducedContactElementsZero):
499         case(ReducedContactElementsOne):
500            if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {
501               Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);
502            } else {
503               throw FinleyAdapterException("Error - No interpolation with data on contact elements with reduced integration order possible.");
504               break;
505            }
506            break;
507       case(DegreesOfFreedom):             case(DegreesOfFreedom):      
508          switch(target.getFunctionSpace().getTypeCode()) {          switch(target.getFunctionSpace().getTypeCode()) {
509             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
510             case(DegreesOfFreedom):             case(DegreesOfFreedom):
511             case(Nodes):             case(Nodes):
512                Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));             case(ReducedNodes):
513                  Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
514                break;                break;
515  #ifndef PASO_MPI  #ifndef PASO_MPI
516             case(Elements):             case(Elements):
517                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));             case(ReducedElements):
518                  Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
519                break;                break;
520             case(FaceElements):             case(FaceElements):
521                Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedFaceElements):
522                  Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
523                break;                break;
524             case(Points):             case(Points):
525                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
526                break;                break;
527             case(ContactElementsZero):             case(ContactElementsZero):
528             case(ContactElementsOne):             case(ContactElementsOne):
529                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedContactElementsZero):
530               case(ReducedContactElementsOne):
531                  Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
532               break;               break;
533  #else  #else
534             /* need to copy Degrees of freedom data to nodal data so that the external values are available */             /* need to copy Degrees of freedom data to nodal data so that the external values are available */
535             case(Elements):             case(Elements):
536             {             case(ReducedElements):
537                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
538                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(nodeTemp.getDataC()),&(target.getDataC()));                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(nodeTemp.getDataC()),&_target);
539                break;                break;
            }  
540             case(FaceElements):             case(FaceElements):
541             {             case(ReducedFaceElements):
542                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
543                Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(nodeTemp.getDataC()),&(target.getDataC()));                Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(nodeTemp.getDataC()),&_target);
544                break;                break;
            }  
545             case(Points):             case(Points):
            {  
546                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
547                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(nodeTemp.getDataC()),&(target.getDataC()));                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(nodeTemp.getDataC()),&_target);
548                break;                break;
            }  
549             case(ContactElementsZero):             case(ContactElementsZero):
550             case(ContactElementsOne):             case(ContactElementsOne):
551             {             case(ReducedContactElementsZero):
552               case(ReducedContactElementsOne):
553                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );
554                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(nodeTemp.getDataC()),&(target.getDataC()));                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(nodeTemp.getDataC()),&_target);
555               break;               break;
            }  
556  #endif  #endif
557             default:             default:
558               stringstream temp;               stringstream temp;
# Line 428  void MeshAdapter::interpolateOnDomain(es Line 563  void MeshAdapter::interpolateOnDomain(es
563          break;          break;
564       case(ReducedDegreesOfFreedom):       case(ReducedDegreesOfFreedom):
565         switch(target.getFunctionSpace().getTypeCode()) {         switch(target.getFunctionSpace().getTypeCode()) {
566              case(Nodes):
567                 throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to mesh nodes.");
568                 break;
569              case(ReducedNodes):
570                 Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
571                 break;
572              case(DegreesOfFreedom):
573                 throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to degrees of freedom");
574                 break;
575            case(ReducedDegreesOfFreedom):            case(ReducedDegreesOfFreedom):
576               Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));               Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
577               break;               break;
578            case(Elements):            case(Elements):
579               Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));            case(ReducedElements):
580                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
581               break;               break;
582            case(FaceElements):            case(FaceElements):
583               Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));            case(ReducedFaceElements):
584                 Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
585               break;               break;
586            case(Points):            case(Points):
587               Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));               Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
588               break;               break;
589            case(ContactElementsZero):            case(ContactElementsZero):
590            case(ContactElementsOne):            case(ContactElementsOne):
591               Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));            case(ReducedContactElementsZero):
592               break;            case(ReducedContactElementsOne):
593            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");  
594               break;               break;
595            default:            default:
596               stringstream temp;               stringstream temp;
# Line 477  void MeshAdapter::setToX(escript::Data& Line 619  void MeshAdapter::setToX(escript::Data&
619    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
620    // in case of values node coordinates we can do the job directly:    // in case of values node coordinates we can do the job directly:
621    if (arg.getFunctionSpace().getTypeCode()==Nodes) {    if (arg.getFunctionSpace().getTypeCode()==Nodes) {
622       Finley_Assemble_NodeCoordinates(mesh->Nodes,&(arg.getDataC()));       escriptDataC _arg=arg.getDataC();
623         Finley_Assemble_NodeCoordinates(mesh->Nodes,&_arg);
624    } else {    } else {
625       escript::Data tmp_data=Vector(0.0,continuousFunction(asAbstractContinuousDomain()),true);       escript::Data tmp_data=Vector(0.0,continuousFunction(asAbstractContinuousDomain()),true);
626       Finley_Assemble_NodeCoordinates(mesh->Nodes,&(tmp_data.getDataC()));       escriptDataC _tmp_data=tmp_data.getDataC();
627         Finley_Assemble_NodeCoordinates(mesh->Nodes,&_tmp_data);
628       // this is then interpolated onto arg:       // this is then interpolated onto arg:
629       interpolateOnDomain(arg,tmp_data);       interpolateOnDomain(arg,tmp_data);
630    }    }
# Line 496  void MeshAdapter::setToNormal(escript::D Line 640  void MeshAdapter::setToNormal(escript::D
640    if (normalDomain!=*this)    if (normalDomain!=*this)
641       throw FinleyAdapterException("Error - Illegal domain of normal locations");       throw FinleyAdapterException("Error - Illegal domain of normal locations");
642    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
643      escriptDataC _normal=normal.getDataC();
644    switch(normal.getFunctionSpace().getTypeCode()) {    switch(normal.getFunctionSpace().getTypeCode()) {
645      case(Nodes):      case(Nodes):
646        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");
647        break;        break;
648        case(ReducedNodes):
649          throw FinleyAdapterException("Error - Finley does not support surface normal vectors for reduced nodes");
650          break;
651      case(Elements):      case(Elements):
652        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements");
653        break;        break;
654        case(ReducedElements):
655          throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements with reduced integration order");
656          break;
657      case (FaceElements):      case (FaceElements):
658        Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&(normal.getDataC()));        Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&_normal);
659          break;
660        case (ReducedFaceElements):
661          Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&_normal);
662        break;        break;
663      case(Points):      case(Points):
664        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");
665        break;        break;
666      case (ContactElementsOne):      case (ContactElementsOne):
667      case (ContactElementsZero):      case (ContactElementsZero):
668        Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&(normal.getDataC()));        Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&_normal);
669          break;
670        case (ReducedContactElementsOne):
671        case (ReducedContactElementsZero):
672          Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&_normal);
673        break;        break;
674      case(DegreesOfFreedom):      case(DegreesOfFreedom):
675        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 550  void MeshAdapter::setToIntegrals(std::ve Line 708  void MeshAdapter::setToIntegrals(std::ve
708       throw FinleyAdapterException("Error - Illegal domain of integration kernel");       throw FinleyAdapterException("Error - Illegal domain of integration kernel");
709    
710    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
711      escriptDataC _arg=arg.getDataC();
712    switch(arg.getFunctionSpace().getTypeCode()) {    switch(arg.getFunctionSpace().getTypeCode()) {
713       case(Nodes):       case(Nodes):
714            /* TODO */
715          throw FinleyAdapterException("Error - Integral of data on nodes is not supported.");          throw FinleyAdapterException("Error - Integral of data on nodes is not supported.");
716          break;          break;
717         case(ReducedNodes):
718            /* TODO */
719            throw FinleyAdapterException("Error - Integral of data on reduced nodes is not supported.");
720            break;
721       case(Elements):       case(Elements):
722          Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);
723          break;          break;
724         case(ReducedElements):
725            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);
726       case(FaceElements):       case(FaceElements):
727          Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&_arg,&integrals[0]);
728            break;
729         case(ReducedFaceElements):
730            Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&_arg,&integrals[0]);
731          break;          break;
732       case(Points):       case(Points):
733          throw FinleyAdapterException("Error - Integral of data on points is not supported.");          throw FinleyAdapterException("Error - Integral of data on points is not supported.");
734          break;          break;
735       case(ContactElementsZero):       case(ContactElementsZero):
736          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
737            break;
738         case(ReducedContactElementsZero):
739            Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
740          break;          break;
741       case(ContactElementsOne):       case(ContactElementsOne):
742          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
743            break;
744         case(ReducedContactElementsOne):
745            Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
746          break;          break;
747       case(DegreesOfFreedom):       case(DegreesOfFreedom):
748          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 597  void MeshAdapter::setToGradient(escript: Line 772  void MeshAdapter::setToGradient(escript:
772       throw FinleyAdapterException("Error - Illegal domain of gradient");       throw FinleyAdapterException("Error - Illegal domain of gradient");
773    
774    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
775      escriptDataC _grad=grad.getDataC();
776    escriptDataC nodeDataC;    escriptDataC nodeDataC;
777  #ifdef PASO_MPI  #ifdef PASO_MPI
778    escript::Data nodeTemp( arg, continuousFunction(asAbstractContinuousDomain()) );    escript::Data nodeTemp( arg, continuousFunction(asAbstractContinuousDomain()) );
# Line 614  void MeshAdapter::setToGradient(escript: Line 790  void MeshAdapter::setToGradient(escript:
790         case(Nodes):         case(Nodes):
791            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");
792            break;            break;
793           case(ReducedNodes):
794              throw FinleyAdapterException("Error - Gradient at reduced nodes is not supported.");
795              break;
796         case(Elements):         case(Elements):
797            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&_grad,&nodeDataC);
798              break;
799           case(ReducedElements):
800              Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&_grad,&nodeDataC);
801            break;            break;
802         case(FaceElements):         case(FaceElements):
803            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&_grad,&nodeDataC);
804              break;
805           case(ReducedFaceElements):
806              Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&_grad,&nodeDataC);
807            break;            break;
808         case(Points):         case(Points):
809            throw FinleyAdapterException("Error - Gradient at points is not supported.");            throw FinleyAdapterException("Error - Gradient at points is not supported.");
810            break;            break;
811         case(ContactElementsZero):         case(ContactElementsZero):
812            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
813              break;
814           case(ReducedContactElementsZero):
815              Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
816            break;            break;
817         case(ContactElementsOne):         case(ContactElementsOne):
818            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
819              break;
820           case(ReducedContactElementsOne):
821              Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
822            break;            break;
823         case(DegreesOfFreedom):         case(DegreesOfFreedom):
824            throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");            throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");
# Line 655  void MeshAdapter::setToSize(escript::Dat Line 846  void MeshAdapter::setToSize(escript::Dat
846         case(Nodes):         case(Nodes):
847            throw FinleyAdapterException("Error - Size of nodes is not supported.");            throw FinleyAdapterException("Error - Size of nodes is not supported.");
848            break;            break;
849           case(ReducedNodes):
850              throw FinleyAdapterException("Error - Size of reduced nodes is not supported.");
851              break;
852         case(Elements):         case(Elements):
853            Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);
854            break;            break;
855           case(ReducedElements):
856              Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);
857              break;
858         case(FaceElements):         case(FaceElements):
859            Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);
860            break;            break;
861           case(ReducedFaceElements):
862              Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);
863              break;
864         case(Points):         case(Points):
865            throw FinleyAdapterException("Error - Size of point elements is not supported.");            throw FinleyAdapterException("Error - Size of point elements is not supported.");
866            break;            break;
# Line 668  void MeshAdapter::setToSize(escript::Dat Line 868  void MeshAdapter::setToSize(escript::Dat
868         case(ContactElementsOne):         case(ContactElementsOne):
869            Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);
870            break;            break;
871           case(ReducedContactElementsZero):
872           case(ReducedContactElementsOne):
873              Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);
874              break;
875         case(DegreesOfFreedom):         case(DegreesOfFreedom):
876            throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");            throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");
877            break;            break;
# Line 716  void MeshAdapter::saveDX(const std::stri Line 920  void MeshAdapter::saveDX(const std::stri
920      for (int i=0;i<num_data;++i) {      for (int i=0;i<num_data;++i) {
921           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);
922           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)
923               throw FinleyAdapterException("Error  in saveVTK: Data must be defined on same Domain");               throw FinleyAdapterException("Error  in saveDX: Data must be defined on same Domain");
924           data[i]=d.getDataC();           data[i]=d.getDataC();
925           ptr_data[i]=&(data[i]);           ptr_data[i]=&(data[i]);
926           std::string n=boost::python::extract<std::string>(keys[i]);           std::string n=boost::python::extract<std::string>(keys[i]);
# Line 776  void MeshAdapter::saveVTK(const std::str Line 980  void MeshAdapter::saveVTK(const std::str
980              strcpy(c_names[i],n.c_str());              strcpy(c_names[i],n.c_str());
981           }           }
982      }      }
983    #ifndef PASO_MPI    
984      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);
985      checkFinleyError();  #else
986        Finley_Mesh_saveVTK_MPIO(filename.c_str(),m_finleyMesh.get(),num_data,c_names,ptr_data);
987    #endif
988    
989    checkFinleyError();
990    /* win32 refactor */    /* win32 refactor */
991    TMPMEMFREE(c_names);    TMPMEMFREE(c_names);
992    TMPMEMFREE(data);    TMPMEMFREE(data);
# Line 854  bool MeshAdapter::isCellOriented(int fun Line 1063  bool MeshAdapter::isCellOriented(int fun
1063         case(Points):         case(Points):
1064         case(ContactElementsZero):         case(ContactElementsZero):
1065         case(ContactElementsOne):         case(ContactElementsOne):
1066           case(ReducedElements):
1067           case(ReducedFaceElements):
1068           case(ReducedContactElementsZero):
1069           case(ReducedContactElementsOne):
1070            return true;            return true;
1071            break;            break;
1072         default:         default:
# Line 872  bool MeshAdapter::probeInterpolationOnDo Line 1085  bool MeshAdapter::probeInterpolationOnDo
1085       case(Nodes):       case(Nodes):
1086          switch(functionSpaceType_target) {          switch(functionSpaceType_target) {
1087             case(Nodes):             case(Nodes):
1088               case(ReducedNodes):
1089             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
1090             case(DegreesOfFreedom):             case(DegreesOfFreedom):
1091             case(Elements):             case(Elements):
1092               case(ReducedElements):
1093               case(FaceElements):
1094               case(ReducedFaceElements):
1095               case(Points):
1096               case(ContactElementsZero):
1097               case(ReducedContactElementsZero):
1098               case(ContactElementsOne):
1099               case(ReducedContactElementsOne):
1100                   return true;
1101               default:
1102                   stringstream temp;
1103                   temp << "Error - Interpolation On Domain: Finley does not know anything about function space type " << functionSpaceType_target;
1104                   throw FinleyAdapterException(temp.str());
1105            }
1106            break;
1107         case(ReducedNodes):
1108            switch(functionSpaceType_target) {
1109               case(ReducedNodes):
1110               case(ReducedDegreesOfFreedom):
1111               case(Elements):
1112               case(ReducedElements):
1113             case(FaceElements):             case(FaceElements):
1114               case(ReducedFaceElements):
1115             case(Points):             case(Points):
1116             case(ContactElementsZero):             case(ContactElementsZero):
1117               case(ReducedContactElementsZero):
1118             case(ContactElementsOne):             case(ContactElementsOne):
1119               case(ReducedContactElementsOne):
1120                 return true;                 return true;
1121              case(Nodes):
1122              case(DegreesOfFreedom):
1123                 return false;
1124             default:             default:
1125                 stringstream temp;                 stringstream temp;
1126                 temp << "Error - Interpolation On Domain: Finley does not know anything about function space type " << functionSpaceType_target;                 temp << "Error - Interpolation On Domain: Finley does not know anything about function space type " << functionSpaceType_target;
# Line 892  bool MeshAdapter::probeInterpolationOnDo Line 1133  bool MeshAdapter::probeInterpolationOnDo
1133          } else {          } else {
1134             return false;             return false;
1135          }          }
1136         case(ReducedElements):
1137            if (functionSpaceType_target==ReducedElements) {
1138               return true;
1139            } else {
1140               return false;
1141            }
1142       case(FaceElements):       case(FaceElements):
1143          if (functionSpaceType_target==FaceElements) {          if (functionSpaceType_target==FaceElements) {
1144             return true;             return true;
1145          } else {          } else {
1146             return false;             return false;
1147          }          }
1148         case(ReducedFaceElements):
1149            if (functionSpaceType_target==ReducedFaceElements) {
1150               return true;
1151            } else {
1152               return false;
1153            }
1154       case(Points):       case(Points):
1155          if (functionSpaceType_target==Points) {          if (functionSpaceType_target==Points) {
1156             return true;             return true;
# Line 911  bool MeshAdapter::probeInterpolationOnDo Line 1164  bool MeshAdapter::probeInterpolationOnDo
1164          } else {          } else {
1165             return false;             return false;
1166          }          }
1167         case(ReducedContactElementsZero):
1168         case(ReducedContactElementsOne):
1169            if (functionSpaceType_target==ReducedContactElementsZero || functionSpaceType_target==ReducedContactElementsOne) {
1170               return true;
1171            } else {
1172               return false;
1173            }
1174       case(DegreesOfFreedom):       case(DegreesOfFreedom):
1175          switch(functionSpaceType_target) {          switch(functionSpaceType_target) {
1176             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
1177             case(DegreesOfFreedom):             case(DegreesOfFreedom):
1178             case(Nodes):             case(Nodes):
1179               case(ReducedNodes):
1180             case(Elements):             case(Elements):
1181             case(FaceElements):             case(ReducedElements):
1182             case(Points):             case(Points):
1183               case(FaceElements):
1184               case(ReducedFaceElements):
1185             case(ContactElementsZero):             case(ContactElementsZero):
1186               case(ReducedContactElementsZero):
1187             case(ContactElementsOne):             case(ContactElementsOne):
1188               case(ReducedContactElementsOne):
1189                return true;                return true;
1190             default:             default:
1191               stringstream temp;               stringstream temp;
# Line 931  bool MeshAdapter::probeInterpolationOnDo Line 1196  bool MeshAdapter::probeInterpolationOnDo
1196       case(ReducedDegreesOfFreedom):       case(ReducedDegreesOfFreedom):
1197         switch(functionSpaceType_target) {         switch(functionSpaceType_target) {
1198            case(ReducedDegreesOfFreedom):            case(ReducedDegreesOfFreedom):
1199              case(ReducedNodes):
1200            case(Elements):            case(Elements):
1201              case(ReducedElements):
1202            case(FaceElements):            case(FaceElements):
1203              case(ReducedFaceElements):
1204            case(Points):            case(Points):
1205            case(ContactElementsZero):            case(ContactElementsZero):
1206              case(ReducedContactElementsZero):
1207            case(ContactElementsOne):            case(ContactElementsOne):
1208              case(ReducedContactElementsOne):
1209                return true;                return true;
1210            case(Nodes):            case(Nodes):
1211            case(DegreesOfFreedom):            case(DegreesOfFreedom):
# Line 998  escript::Data MeshAdapter::getSize() con Line 1268  escript::Data MeshAdapter::getSize() con
1268    return function(asAbstractContinuousDomain()).getSize();    return function(asAbstractContinuousDomain()).getSize();
1269  }  }
1270    
1271    int* MeshAdapter::borrowSampleReferenceIDs(int functionSpaceType) const
1272    {
1273      int *out=0,i;
1274      Finley_Mesh* mesh=m_finleyMesh.get();
1275      switch (functionSpaceType) {
1276        case(Nodes):
1277          if (mesh->Nodes!=NULL) {
1278            out=mesh->Nodes->Id;
1279            break;
1280          }
1281        case(ReducedNodes):
1282          throw FinleyAdapterException("Error -  ReducedNodes not supported yet.");
1283          break;
1284        case(Elements):
1285          out=mesh->FaceElements->Id;
1286          break;
1287        case(ReducedElements):
1288          out=mesh->Elements->Id;
1289          break;
1290        case(FaceElements):
1291          out=mesh->FaceElements->Id;
1292          break;
1293        case(ReducedFaceElements):
1294          out=mesh->FaceElements->Id;
1295          break;
1296        case(Points):
1297          out=mesh->Points->Id;
1298          break;
1299        case(ContactElementsZero):
1300          out=mesh->ContactElements->Id;
1301          break;
1302        case(ReducedContactElementsZero):
1303          out=mesh->ContactElements->Id;
1304          break;
1305        case(ContactElementsOne):
1306          out=mesh->ContactElements->Id;
1307          break;
1308        case(ReducedContactElementsOne):
1309          out=mesh->ContactElements->Id;
1310          break;
1311        case(DegreesOfFreedom):
1312          out=mesh->Nodes->degreeOfFreedomId;
1313          break;
1314        case(ReducedDegreesOfFreedom):
1315          out=mesh->Nodes->reducedDegreeOfFreedomId;
1316          break;
1317        default:
1318          stringstream temp;
1319          temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();
1320          throw FinleyAdapterException(temp.str());
1321          break;
1322      }
1323      return out;
1324    }
1325  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const
1326  {  {
1327    int out=0;    int out=0;
# Line 1006  int MeshAdapter::getTagFromSampleNo(int Line 1330  int MeshAdapter::getTagFromSampleNo(int
1330    case(Nodes):    case(Nodes):
1331      out=mesh->Nodes->Tag[sampleNo];      out=mesh->Nodes->Tag[sampleNo];
1332      break;      break;
1333      case(ReducedNodes):
1334        throw FinleyAdapterException(" Error - ReducedNodes does not support tags.");
1335        break;
1336    case(Elements):    case(Elements):
1337      out=mesh->Elements->Tag[sampleNo];      out=mesh->Elements->Tag[sampleNo];
1338      break;      break;
1339      case(ReducedElements):
1340        out=mesh->Elements->Tag[sampleNo];
1341        break;
1342    case(FaceElements):    case(FaceElements):
1343      out=mesh->FaceElements->Tag[sampleNo];      out=mesh->FaceElements->Tag[sampleNo];
1344      break;      break;
1345      case(ReducedFaceElements):
1346        out=mesh->FaceElements->Tag[sampleNo];
1347        break;
1348    case(Points):    case(Points):
1349      out=mesh->Points->Tag[sampleNo];      out=mesh->Points->Tag[sampleNo];
1350      break;      break;
1351    case(ContactElementsZero):    case(ContactElementsZero):
1352      out=mesh->ContactElements->Tag[sampleNo];      out=mesh->ContactElements->Tag[sampleNo];
1353      break;      break;
1354      case(ReducedContactElementsZero):
1355        out=mesh->ContactElements->Tag[sampleNo];
1356        break;
1357    case(ContactElementsOne):    case(ContactElementsOne):
1358      out=mesh->ContactElements->Tag[sampleNo];      out=mesh->ContactElements->Tag[sampleNo];
1359      break;      break;
1360      case(ReducedContactElementsOne):
1361        out=mesh->ContactElements->Tag[sampleNo];
1362        break;
1363    case(DegreesOfFreedom):    case(DegreesOfFreedom):
1364        throw FinleyAdapterException(" Error - DegreesOfFreedom does not support tags.");
1365      break;      break;
1366    case(ReducedDegreesOfFreedom):    case(ReducedDegreesOfFreedom):
1367        throw FinleyAdapterException(" Error - ReducedDegreesOfFreedom does not support tags.");
1368      break;      break;
1369    default:    default:
1370      stringstream temp;      stringstream temp;
# Line 1033  int MeshAdapter::getTagFromSampleNo(int Line 1374  int MeshAdapter::getTagFromSampleNo(int
1374    }    }
1375    return out;    return out;
1376  }  }
1377  int MeshAdapter::getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const  
1378    
1379    void MeshAdapter::setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const
1380  {  {
   int out=0,i;  
1381    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
1382    switch (functionSpaceType) {    escriptDataC tmp=mask.getDataC();
1383    case(Nodes):    switch(functionSpaceType) {
1384      if (mesh->Nodes!=NULL) {         case(Nodes):
1385        out=mesh->Nodes->Id[sampleNo];            Finley_NodeFile_setTags(mesh->Nodes,newTag,&tmp);
       break;  
     }  
   case(Elements):  
     out=mesh->Elements->Id[sampleNo];  
     break;  
   case(FaceElements):  
     out=mesh->FaceElements->Id[sampleNo];  
     break;  
   case(Points):  
     out=mesh->Points->Id[sampleNo];  
     break;  
   case(ContactElementsZero):  
     out=mesh->ContactElements->Id[sampleNo];  
     break;  
   case(ContactElementsOne):  
     out=mesh->ContactElements->Id[sampleNo];  
     break;  
   case(DegreesOfFreedom):  
     for (i=0;i<mesh->Nodes->numNodes; ++i) {  
        if (mesh->Nodes->degreeOfFreedom[i]==sampleNo) {  
           out=mesh->Nodes->Id[i];  
1386            break;            break;
1387         }         case(ReducedNodes):
1388      }            throw FinleyAdapterException("Error - ReducedNodes does not support tags");
     break;  
   case(ReducedDegreesOfFreedom):  
     for (i=0;i<mesh->Nodes->numNodes; ++i) {  
        if (mesh->Nodes->reducedDegreeOfFreedom[i]==sampleNo) {  
           out=mesh->Nodes->Id[i];  
1389            break;            break;
1390         }         case(DegreesOfFreedom):
1391      }            throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");
1392      break;            break;
1393    default:         case(ReducedDegreesOfFreedom):
1394      stringstream temp;            throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");
1395      temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();            break;
1396      throw FinleyAdapterException(temp.str());         case(Elements):
1397      break;            Finley_ElementFile_setTags(mesh->Elements,newTag,&tmp);
1398              break;
1399           case(ReducedElements):
1400              Finley_ElementFile_setTags(mesh->Elements,newTag,&tmp);
1401              break;
1402           case(FaceElements):
1403              Finley_ElementFile_setTags(mesh->FaceElements,newTag,&tmp);
1404              break;
1405           case(ReducedFaceElements):
1406              Finley_ElementFile_setTags(mesh->FaceElements,newTag,&tmp);
1407              break;
1408           case(Points):
1409              Finley_ElementFile_setTags(mesh->Points,newTag,&tmp);
1410              break;
1411           case(ContactElementsZero):
1412              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1413              break;
1414           case(ReducedContactElementsZero):
1415              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1416              break;
1417           case(ContactElementsOne):
1418              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1419              break;
1420           case(ReducedContactElementsOne):
1421              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1422              break;
1423           default:
1424              stringstream temp;
1425              temp << "Error - Finley does not know anything about function space type " << functionSpaceType;
1426              throw FinleyAdapterException(temp.str());
1427    }    }
1428    return out;    checkFinleyError();
1429      return;
1430    }
1431    
1432    void MeshAdapter::setTagMap(const std::string& name,  int tag)
1433    {
1434      Finley_Mesh* mesh=m_finleyMesh.get();
1435      Finley_Mesh_addTagMap(mesh, name.c_str(),tag);
1436      checkPasoError();
1437      // throwStandardException("MeshAdapter::set TagMap is not implemented.");
1438    }
1439    
1440    int MeshAdapter::getTag(const std::string& name) const
1441    {
1442      Finley_Mesh* mesh=m_finleyMesh.get();
1443      int tag=0;
1444      tag=Finley_Mesh_getTag(mesh, name.c_str());
1445      checkPasoError();
1446      // throwStandardException("MeshAdapter::getTag is not implemented.");
1447      return tag;
1448    }
1449    
1450    bool MeshAdapter::isValidTagName(const std::string& name) const
1451    {
1452      Finley_Mesh* mesh=m_finleyMesh.get();
1453      return Finley_Mesh_isValidTagName(mesh,name.c_str());
1454    }
1455    
1456    std::string MeshAdapter::showTagNames() const
1457    {
1458      stringstream temp;
1459      Finley_Mesh* mesh=m_finleyMesh.get();
1460      Finley_TagMap* tag_map=mesh->TagMap;
1461      while (tag_map) {
1462         temp << tag_map->name;
1463         tag_map=tag_map->next;
1464         if (tag_map) temp << ", ";
1465      }
1466      return temp.str();
1467  }  }
1468    
1469  }  // end of namespace  }  // end of namespace

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

  ViewVC Help
Powered by ViewVC 1.1.26