/[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 1312 by ksteube, Mon Sep 24 06:18:44 2007 UTC
# Line 1  Line 1 
 // $Id$  
 /*  
  ******************************************************************************  
  *                                                                            *  
  *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *  
  *                                                                            *  
  * This software is the property of ACcESS. No part of this code              *  
  * may be copied in any form or by any means without the expressed written    *  
  * consent of ACcESS.  Copying, use or modification of this software          *  
  * by any unauthorised person is illegal unless that person has a software    *  
  * license agreement with ACcESS.                                             *  
  *                                                                            *  
  ******************************************************************************  
 */  
1    
2  #include "MeshAdapter.h"  /* $Id$ */
3    
4    /*******************************************************
5     *
6     *           Copyright 2003-2007 by ACceSS MNRF
7     *       Copyright 2007 by University of Queensland
8     *
9     *                http://esscc.uq.edu.au
10     *        Primary Business: Queensland, Australia
11     *  Licensed under the Open Software License version 3.0
12     *     http://www.opensource.org/licenses/osl-3.0.php
13     *
14     *******************************************************/
15    
16    #include "MeshAdapter.h"
17  #include "escript/Data.h"  #include "escript/Data.h"
18  #include "escript/DataFactory.h"  #include "escript/DataFactory.h"
19    extern "C" {
20    #include "escript/blocktimer.h"
21    }
22    #include <vector>
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  {  {
48    setFunctionSpaceTypeNames();    setFunctionSpaceTypeNames();
49    //    //
50    // need to use a null_deleter as Finley_Mesh_dealloc deletes the pointer    // need to use a null_deleter as Finley_Mesh_free deletes the pointer
51    // for us.    // for us.
52    m_finleyMesh.reset(finleyMesh,null_deleter());    m_finleyMesh.reset(finleyMesh,null_deleter());
53  }  }
# Line 58  MeshAdapter::~MeshAdapter() Line 66  MeshAdapter::~MeshAdapter()
66    // I hope the case for the pointer being zero has been taken care of.    // I hope the case for the pointer being zero has been taken care of.
67    //  cout << "In MeshAdapter destructor." << endl;    //  cout << "In MeshAdapter destructor." << endl;
68    if (m_finleyMesh.unique()) {    if (m_finleyMesh.unique()) {
69      //   cout << "Calling dealloc." << endl;      Finley_Mesh_free(m_finleyMesh.get());
     Finley_Mesh_dealloc(m_finleyMesh.get());  
     //   cout << "Finished dealloc." << endl;  
70    }    }
71  }  }
72    
73    int MeshAdapter::getMPISize() const
74    {
75       return m_finleyMesh.get()->MPIInfo->size;
76    }
77    int MeshAdapter::getMPIRank() const
78    {
79       return m_finleyMesh.get()->MPIInfo->rank;
80    }
81    
82    
83  Finley_Mesh* MeshAdapter::getFinley_Mesh() const {  Finley_Mesh* MeshAdapter::getFinley_Mesh() const {
84     return m_finleyMesh.get();     return m_finleyMesh.get();
85  }  }
# Line 77  void MeshAdapter::write(const std::strin Line 93  void MeshAdapter::write(const std::strin
93    TMPMEMFREE(fName);    TMPMEMFREE(fName);
94  }  }
95    
96    void MeshAdapter::dump(const std::string& fileName) const
97    {
98      char *fName = (fileName.size()+1>0) ? TMPMEMALLOC(fileName.size()+1,char) : (char*)NULL;
99      strcpy(fName,fileName.c_str());
100      Finley_Mesh_dump(m_finleyMesh.get(),fName);
101      checkFinleyError();
102      TMPMEMFREE(fName);
103    }
104    
105  string MeshAdapter::getDescription() const  string MeshAdapter::getDescription() const
106  {  {
107    return "FinleyMesh";    return "FinleyMesh";
# Line 109  void MeshAdapter::setFunctionSpaceTypeNa Line 134  void MeshAdapter::setFunctionSpaceTypeNa
134    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
135      (FunctionSpaceNamesMapType::value_type(Nodes,"Finley_Nodes"));      (FunctionSpaceNamesMapType::value_type(Nodes,"Finley_Nodes"));
136    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
137        (FunctionSpaceNamesMapType::value_type(ReducedNodes,"Finley_Reduced_Nodes"));
138      m_functionSpaceTypeNames.insert
139      (FunctionSpaceNamesMapType::value_type(Elements,"Finley_Elements"));      (FunctionSpaceNamesMapType::value_type(Elements,"Finley_Elements"));
140    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
141        (FunctionSpaceNamesMapType::value_type(ReducedElements,"Finley_Reduced_Elements"));
142      m_functionSpaceTypeNames.insert
143      (FunctionSpaceNamesMapType::value_type(FaceElements,"Finley_Face_Elements"));      (FunctionSpaceNamesMapType::value_type(FaceElements,"Finley_Face_Elements"));
144    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
145        (FunctionSpaceNamesMapType::value_type(ReducedFaceElements,"Finley_Reduced_Face_Elements"));
146      m_functionSpaceTypeNames.insert
147      (FunctionSpaceNamesMapType::value_type(Points,"Finley_Points"));      (FunctionSpaceNamesMapType::value_type(Points,"Finley_Points"));
148    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
149      (FunctionSpaceNamesMapType::value_type(ContactElementsZero,"Finley_Contact_Elements_0"));      (FunctionSpaceNamesMapType::value_type(ContactElementsZero,"Finley_Contact_Elements_0"));
150    m_functionSpaceTypeNames.insert    m_functionSpaceTypeNames.insert
151        (FunctionSpaceNamesMapType::value_type(ReducedContactElementsZero,"Finley_Reduced_Contact_Elements_0"));
152      m_functionSpaceTypeNames.insert
153      (FunctionSpaceNamesMapType::value_type(ContactElementsOne,"Finley_Contact_Elements_1"));      (FunctionSpaceNamesMapType::value_type(ContactElementsOne,"Finley_Contact_Elements_1"));
154      m_functionSpaceTypeNames.insert
155        (FunctionSpaceNamesMapType::value_type(ReducedContactElementsOne,"Finley_Reduced_Contact_Elements_1"));
156  }  }
157    
158  int MeshAdapter::getContinuousFunctionCode() const  int MeshAdapter::getContinuousFunctionCode() const
159  {  {
160    return Nodes;    return Nodes;
161  }  }
162    int MeshAdapter::getReducedContinuousFunctionCode() const
163    {
164      return ReducedNodes;
165    }
166    
167  int MeshAdapter::getFunctionCode() const  int MeshAdapter::getFunctionCode() const
168  {  {
169    return Elements;    return Elements;
170  }  }
171    int MeshAdapter::getReducedFunctionCode() const
172    {
173      return ReducedElements;
174    }
175    
176  int MeshAdapter::getFunctionOnBoundaryCode() const  int MeshAdapter::getFunctionOnBoundaryCode() const
177  {  {
178    return FaceElements;    return FaceElements;
179  }  }
180    int MeshAdapter::getReducedFunctionOnBoundaryCode() const
181    {
182      return ReducedFaceElements;
183    }
184    
185  int MeshAdapter::getFunctionOnContactZeroCode() const  int MeshAdapter::getFunctionOnContactZeroCode() const
186  {  {
187    return ContactElementsZero;    return ContactElementsZero;
188  }  }
189    int MeshAdapter::getReducedFunctionOnContactZeroCode() const
190    {
191      return ReducedContactElementsZero;
192    }
193    
194  int MeshAdapter::getFunctionOnContactOneCode() const  int MeshAdapter::getFunctionOnContactOneCode() const
195  {  {
196    return ContactElementsOne;    return ContactElementsOne;
197  }  }
198    int MeshAdapter::getReducedFunctionOnContactOneCode() const
199    {
200      return ReducedContactElementsOne;
201    }
202    
203  int MeshAdapter::getSolutionCode() const  int MeshAdapter::getSolutionCode() const
204  {  {
# Line 182  pair<int,int> MeshAdapter::getDataShape( Line 237  pair<int,int> MeshAdapter::getDataShape(
237     switch (functionSpaceCode) {     switch (functionSpaceCode) {
238        case(Nodes):        case(Nodes):
239             numDataPointsPerSample=1;             numDataPointsPerSample=1;
240             if (mesh->Nodes!=NULL) numSamples=mesh->Nodes->numNodes;             numSamples=Finley_NodeFile_getNumNodes(mesh->Nodes);
241               break;
242          case(ReducedNodes):
243               numDataPointsPerSample=1;
244               numSamples=Finley_NodeFile_getNumReducedNodes(mesh->Nodes);
245             break;             break;
246        case(Elements):        case(Elements):
247             if (mesh->Elements!=NULL) {             if (mesh->Elements!=NULL) {
# Line 190  pair<int,int> MeshAdapter::getDataShape( Line 249  pair<int,int> MeshAdapter::getDataShape(
249               numDataPointsPerSample=mesh->Elements->ReferenceElement->numQuadNodes;               numDataPointsPerSample=mesh->Elements->ReferenceElement->numQuadNodes;
250             }             }
251             break;             break;
252          case(ReducedElements):
253               if (mesh->Elements!=NULL) {
254                 numSamples=mesh->Elements->numElements;
255                 numDataPointsPerSample=mesh->Elements->ReferenceElementReducedOrder->numQuadNodes;
256               }
257               break;
258        case(FaceElements):        case(FaceElements):
259             if (mesh->FaceElements!=NULL) {             if (mesh->FaceElements!=NULL) {
260                  numDataPointsPerSample=mesh->FaceElements->ReferenceElement->numQuadNodes;                  numDataPointsPerSample=mesh->FaceElements->ReferenceElement->numQuadNodes;
261                  numSamples=mesh->FaceElements->numElements;                  numSamples=mesh->FaceElements->numElements;
262             }             }
263             break;             break;
264          case(ReducedFaceElements):
265               if (mesh->FaceElements!=NULL) {
266                    numDataPointsPerSample=mesh->FaceElements->ReferenceElementReducedOrder->numQuadNodes;
267                    numSamples=mesh->FaceElements->numElements;
268               }
269               break;
270        case(Points):        case(Points):
271             if (mesh->Points!=NULL) {             if (mesh->Points!=NULL) {
272               numDataPointsPerSample=1;               numDataPointsPerSample=1;
# Line 208  pair<int,int> MeshAdapter::getDataShape( Line 279  pair<int,int> MeshAdapter::getDataShape(
279               numSamples=mesh->ContactElements->numElements;               numSamples=mesh->ContactElements->numElements;
280             }             }
281             break;             break;
282          case(ReducedContactElementsZero):
283               if (mesh->ContactElements!=NULL) {
284                 numDataPointsPerSample=mesh->ContactElements->ReferenceElementReducedOrder->numQuadNodes;
285                 numSamples=mesh->ContactElements->numElements;
286               }
287               break;
288        case(ContactElementsOne):        case(ContactElementsOne):
289             if (mesh->ContactElements!=NULL) {             if (mesh->ContactElements!=NULL) {
290               numDataPointsPerSample=mesh->ContactElements->ReferenceElement->numQuadNodes;               numDataPointsPerSample=mesh->ContactElements->ReferenceElement->numQuadNodes;
291               numSamples=mesh->ContactElements->numElements;               numSamples=mesh->ContactElements->numElements;
292             }             }
293             break;             break;
294          case(ReducedContactElementsOne):
295               if (mesh->ContactElements!=NULL) {
296                 numDataPointsPerSample=mesh->ContactElements->ReferenceElementReducedOrder->numQuadNodes;
297                 numSamples=mesh->ContactElements->numElements;
298               }
299               break;
300        case(DegreesOfFreedom):        case(DegreesOfFreedom):
301             if (mesh->Nodes!=NULL) {             if (mesh->Nodes!=NULL) {
302               numDataPointsPerSample=1;               numDataPointsPerSample=1;
303  #ifndef PASO_MPI               numSamples=Finley_NodeFile_getNumDegreesOfFreedom(mesh->Nodes);
              numSamples=mesh->Nodes->numDegreesOfFreedom;  
 #else  
              numSamples=mesh->Nodes->degreeOfFreedomDistribution->numLocal;  
 #endif  
304             }             }
305             break;             break;
306        case(ReducedDegreesOfFreedom):        case(ReducedDegreesOfFreedom):
307             if (mesh->Nodes!=NULL) {             if (mesh->Nodes!=NULL) {
308               numDataPointsPerSample=1;               numDataPointsPerSample=1;
309  #ifndef PASO_MPI               numSamples=Finley_NodeFile_getNumReducedDegreesOfFreedom(mesh->Nodes);
              numSamples=mesh->Nodes->reducedNumDegreesOfFreedom;  
 #else  
              numSamples=mesh->Nodes->reducedDegreeOfFreedomDistribution->numLocal;  
 #endif  
310             }             }
311             break;             break;
312        default:        default:
# Line 252  void MeshAdapter::addPDEToSystem( Line 327  void MeshAdapter::addPDEToSystem(
327                       const escript::Data& d, const escript::Data& y,                       const escript::Data& d, const escript::Data& y,
328                       const escript::Data& d_contact,const escript::Data& y_contact) const                       const escript::Data& d_contact,const escript::Data& y_contact) const
329  {  {
330    escriptDataC _rhs=rhs.getDataC();     escriptDataC _rhs=rhs.getDataC();
331    escriptDataC _A  =A.getDataC();     escriptDataC _A  =A.getDataC();
332    escriptDataC _B=B.getDataC();     escriptDataC _B=B.getDataC();
333    escriptDataC _C=C.getDataC();     escriptDataC _C=C.getDataC();
334    escriptDataC _D=D.getDataC();     escriptDataC _D=D.getDataC();
335    escriptDataC _X=X.getDataC();     escriptDataC _X=X.getDataC();
336    escriptDataC _Y=Y.getDataC();     escriptDataC _Y=Y.getDataC();
337    escriptDataC _d=d.getDataC();     escriptDataC _d=d.getDataC();
338    escriptDataC _y=y.getDataC();     escriptDataC _y=y.getDataC();
339    escriptDataC _d_contact=d_contact.getDataC();     escriptDataC _d_contact=d_contact.getDataC();
340    escriptDataC _y_contact=y_contact.getDataC();     escriptDataC _y_contact=y_contact.getDataC();
341    
342     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
343    
344     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(), &_rhs, &_A, &_B, &_C, &_D, &_X, &_Y );     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,mat.getPaso_SystemMatrix(), &_rhs, &_A, &_B, &_C, &_D, &_X, &_Y );
345       checkFinleyError();
346    
347       Finley_Assemble_PDE(mesh->Nodes,mesh->FaceElements, mat.getPaso_SystemMatrix(), &_rhs, 0, 0, 0, &_d, 0, &_y );
348     checkFinleyError();     checkFinleyError();
349    
350     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements, mat.getPaso_SystemMatrix(), &_rhs, &_d, &_y, Finley_Assemble_handelShapeMissMatch_Mean_out);     Finley_Assemble_PDE(mesh->Nodes,mesh->ContactElements, mat.getPaso_SystemMatrix(), &_rhs , 0, 0, 0, &_d_contact, 0, &_y_contact );
351     checkFinleyError();     checkFinleyError();
352    }
353    
354    void  MeshAdapter::addPDEToLumpedSystem(
355                         escript::Data& mat,
356                         const escript::Data& D,
357                         const escript::Data& d) const
358    {
359       escriptDataC _mat=mat.getDataC();
360       escriptDataC _D=D.getDataC();
361       escriptDataC _d=d.getDataC();
362    
363       Finley_Mesh* mesh=m_finleyMesh.get();
364    
365       Finley_Assemble_LumpedSystem(mesh->Nodes,mesh->Elements,&_mat, &_D);
366       Finley_Assemble_LumpedSystem(mesh->Nodes,mesh->FaceElements,&_mat, &_d);
367    
    Finley_Assemble_RobinCondition(mesh->Nodes,mesh->ContactElements, mat.getPaso_SystemMatrix(), &_rhs , &_d_contact, &_y_contact ,             Finley_Assemble_handelShapeMissMatch_Step_out);  
368     checkFinleyError();     checkFinleyError();
369  }  }
370    
371    
372  //  //
373  // adds linear PDE of second order into the right hand side only  // adds linear PDE of second order into the right hand side only
374  //  //
# Line 283  void MeshAdapter::addPDEToRHS( escript:: Line 376  void MeshAdapter::addPDEToRHS( escript::
376  {  {
377     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
378    
379     // Finley_Assemble_PDE_RHS(mesh->Nodes,mesh->Elements,&(rhs.getDataC()),&(X.getDataC()),&(Y.getDataC()));     escriptDataC _rhs=rhs.getDataC();
380     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements,0,&(rhs.getDataC()),0,0,0,0,&(X.getDataC()),&(Y.getDataC()));     escriptDataC _X=X.getDataC();
381     checkFinleyError();     escriptDataC _Y=Y.getDataC();
382       escriptDataC _y=y.getDataC();
383       escriptDataC _y_contact=y_contact.getDataC();
384    
385     // 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 );
386     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->FaceElements,0,&(rhs.getDataC()),0,&(y.getDataC()),Finley_Assemble_handelShapeMissMatch_Mean_out);     checkFinleyError();
387    
388       Finley_Assemble_PDE(mesh->Nodes,mesh->FaceElements, 0, &_rhs, 0, 0, 0, 0, 0, &_y );
389     checkFinleyError();     checkFinleyError();
390     Finley_Assemble_RobinCondition(mesh->Nodes,mesh->ContactElements,0,&(rhs.getDataC()),0,&(y_contact.getDataC()),Finley_Assemble_handelShapeMissMatch_Step_out);  
391     // 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 );
392     checkFinleyError();     checkFinleyError();
393  }  }
394    
# Line 309  void MeshAdapter::interpolateOnDomain(es Line 405  void MeshAdapter::interpolateOnDomain(es
405      throw FinleyAdapterException("Error - Illegal domain of interpolation target.");      throw FinleyAdapterException("Error - Illegal domain of interpolation target.");
406    
407    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
408      escriptDataC _target=target.getDataC();
409      escriptDataC _in=in.getDataC();
410    switch(in.getFunctionSpace().getTypeCode()) {    switch(in.getFunctionSpace().getTypeCode()) {
411       case(Nodes):       case(Nodes):
412          switch(target.getFunctionSpace().getTypeCode()) {          switch(target.getFunctionSpace().getTypeCode()) {
413             case(Nodes):             case(Nodes):
414               case(ReducedNodes):
415               case(DegreesOfFreedom):
416             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
417                   Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
418                   break;
419               case(Elements):
420               case(ReducedElements):
421                   Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
422                   break;
423               case(FaceElements):
424               case(ReducedFaceElements):
425                   Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
426                   break;
427               case(Points):
428                   Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
429                   break;
430               case(ContactElementsZero):
431               case(ReducedContactElementsZero):
432                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
433                   break;
434               case(ContactElementsOne):
435               case(ReducedContactElementsOne):
436                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
437                   break;
438               default:
439                   stringstream temp;
440                   temp << "Error - Interpolation on Domain: Finley does not know anything about function space type " << target.getFunctionSpace().getTypeCode();
441                   throw FinleyAdapterException(temp.str());
442                   break;
443            }
444            break;
445         case(ReducedNodes):
446            switch(target.getFunctionSpace().getTypeCode()) {
447               case(Nodes):
448               case(ReducedNodes):
449             case(DegreesOfFreedom):             case(DegreesOfFreedom):
450                 Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));             case(ReducedDegreesOfFreedom):
451                   Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
452                 break;                 break;
453             case(Elements):             case(Elements):
454                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));             case(ReducedElements):
455                   Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
456                 break;                 break;
457             case(FaceElements):             case(FaceElements):
458                 Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedFaceElements):
459                   Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
460                 break;                 break;
461             case(Points):             case(Points):
462                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));                 Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
463                 break;                 break;
464             case(ContactElementsZero):             case(ContactElementsZero):
465                 Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedContactElementsZero):
466                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
467                 break;                 break;
468             case(ContactElementsOne):             case(ContactElementsOne):
469                 Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));             case(ReducedContactElementsOne):
470                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
471                 break;                 break;
472             default:             default:
473                 stringstream temp;                 stringstream temp;
# Line 341  void MeshAdapter::interpolateOnDomain(es Line 478  void MeshAdapter::interpolateOnDomain(es
478          break;          break;
479       case(Elements):       case(Elements):
480          if (target.getFunctionSpace().getTypeCode()==Elements) {          if (target.getFunctionSpace().getTypeCode()==Elements) {
481             Finley_Assemble_CopyElementData(mesh->Elements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->Elements,&_target,&_in);
482            } else if (target.getFunctionSpace().getTypeCode()==ReducedElements) {
483               Finley_Assemble_AverageElementData(mesh->Elements,&_target,&_in);
484          } else {          } else {
485             throw FinleyAdapterException("Error - No interpolation with data on elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on elements possible.");
486          }          }
487          break;          break;
488         case(ReducedElements):
489            if (target.getFunctionSpace().getTypeCode()==ReducedElements) {
490               Finley_Assemble_CopyElementData(mesh->Elements,&_target,&_in);
491            } else {
492               throw FinleyAdapterException("Error - No interpolation with data on elements with reduced integration order possible.");
493            }
494            break;
495       case(FaceElements):       case(FaceElements):
496          if (target.getFunctionSpace().getTypeCode()==FaceElements) {          if (target.getFunctionSpace().getTypeCode()==FaceElements) {
497             Finley_Assemble_CopyElementData(mesh->FaceElements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);
498            } else if (target.getFunctionSpace().getTypeCode()==ReducedFaceElements) {
499               Finley_Assemble_AverageElementData(mesh->FaceElements,&_target,&_in);
500          } else {          } else {
501             throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");
            break;  
502         }         }
503           break;
504         case(ReducedFaceElements):
505            if (target.getFunctionSpace().getTypeCode()==FaceElements) {
506               Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);
507            } else {
508               throw FinleyAdapterException("Error - No interpolation with data on face elements with reduced integration order possible.");
509           }
510           break;
511       case(Points):       case(Points):
512          if (target.getFunctionSpace().getTypeCode()==Points) {          if (target.getFunctionSpace().getTypeCode()==Points) {
513             Finley_Assemble_CopyElementData(mesh->Points,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->Points,&_target,&_in);
514          } else {          } else {
515             throw FinleyAdapterException("Error - No interpolation with data on points possible.");             throw FinleyAdapterException("Error - No interpolation with data on points possible.");
            break;  
516          }          }
517          break;          break;
518       case(ContactElementsZero):       case(ContactElementsZero):
519       case(ContactElementsOne):       case(ContactElementsOne):
520          if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {          if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {
521             Finley_Assemble_CopyElementData(mesh->ContactElements,&(target.getDataC()),&(in.getDataC()));             Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);
522            } else if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {
523               Finley_Assemble_AverageElementData(mesh->ContactElements,&_target,&_in);
524          } else {          } else {
525             throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");             throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");
526             break;             break;
527          }          }
528          break;          break;
529         case(ReducedContactElementsZero):
530         case(ReducedContactElementsOne):
531            if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {
532               Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);
533            } else {
534               throw FinleyAdapterException("Error - No interpolation with data on contact elements with reduced integration order possible.");
535               break;
536            }
537            break;
538       case(DegreesOfFreedom):             case(DegreesOfFreedom):      
539          switch(target.getFunctionSpace().getTypeCode()) {          switch(target.getFunctionSpace().getTypeCode()) {
540             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
541             case(DegreesOfFreedom):             case(DegreesOfFreedom):
542             case(Nodes):                Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
               Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));  
               break;  
 #ifndef PASO_MPI  
            case(Elements):  
               Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));  
               break;  
            case(FaceElements):  
               Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));  
543                break;                break;
544             case(Points):  
545                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));             case(Nodes):
546               case(ReducedNodes):
547                  if (getMPISize()>1) {
548                      escript::Data temp=escript::Data(in);
549                      temp.expand();
550                      escriptDataC _in2 = temp.getDataC();
551                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in2);
552                  } else {
553                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
554                  }
555                break;                break;
            case(ContactElementsZero):  
            case(ContactElementsOne):  
               Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));  
              break;  
 #else  
            /* need to copy Degrees of freedom data to nodal data so that the external values are available */  
556             case(Elements):             case(Elements):
557             {             case(ReducedElements):
558                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                if (getMPISize()>1) {
559                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(nodeTemp.getDataC()),&(target.getDataC()));                   escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
560                     escriptDataC _in2 = temp.getDataC();
561                     Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in2,&_target);
562                  } else {
563                     Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
564                  }
565                break;                break;
            }  
566             case(FaceElements):             case(FaceElements):
567             {             case(ReducedFaceElements):
568                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                if (getMPISize()>1) {
569                Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(nodeTemp.getDataC()),&(target.getDataC()));                   escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
570                     escriptDataC _in2 = temp.getDataC();
571                     Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in2,&_target);
572    
573                  } else {
574                     Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
575                  }
576                break;                break;
            }  
577             case(Points):             case(Points):
578             {                if (getMPISize()>1) {
579                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                   escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
580                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(nodeTemp.getDataC()),&(target.getDataC()));                   escriptDataC _in2 = temp.getDataC();
581                  } else {
582                     Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
583                  }
584                break;                break;
            }  
585             case(ContactElementsZero):             case(ContactElementsZero):
586             case(ContactElementsOne):             case(ContactElementsOne):
587             {             case(ReducedContactElementsZero):
588                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );             case(ReducedContactElementsOne):
589                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(nodeTemp.getDataC()),&(target.getDataC()));                if (getMPISize()>1) {
590                     escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
591                     escriptDataC _in2 = temp.getDataC();
592                     Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in2,&_target);
593                  } else {
594                     Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
595                  }
596               break;               break;
            }  
 #endif  
597             default:             default:
598               stringstream temp;               stringstream temp;
599               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 428  void MeshAdapter::interpolateOnDomain(es Line 603  void MeshAdapter::interpolateOnDomain(es
603          break;          break;
604       case(ReducedDegreesOfFreedom):       case(ReducedDegreesOfFreedom):
605         switch(target.getFunctionSpace().getTypeCode()) {         switch(target.getFunctionSpace().getTypeCode()) {
606              case(Nodes):
607                 throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to mesh nodes.");
608                 break;
609              case(ReducedNodes):
610                  if (getMPISize()>1) {
611                      escript::Data temp=escript::Data(in);
612                      temp.expand();
613                      escriptDataC _in2 = temp.getDataC();
614                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in2);
615                  } else {
616                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
617                  }
618                  break;
619              case(DegreesOfFreedom):
620                 throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to degrees of freedom");
621                 break;
622            case(ReducedDegreesOfFreedom):            case(ReducedDegreesOfFreedom):
623               Finley_Assemble_CopyNodalData(mesh->Nodes,&(target.getDataC()),&(in.getDataC()));               Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
624               break;               break;
625            case(Elements):            case(Elements):
626               Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(in.getDataC()),&(target.getDataC()));            case(ReducedElements):
627                  if (getMPISize()>1) {
628                     escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
629                     escriptDataC _in2 = temp.getDataC();
630                     Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in2,&_target);
631                  } else {
632                     Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);
633                 }
634               break;               break;
635            case(FaceElements):            case(FaceElements):
636               Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(in.getDataC()),&(target.getDataC()));            case(ReducedFaceElements):
637                  if (getMPISize()>1) {
638                     escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
639                     escriptDataC _in2 = temp.getDataC();
640                     Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in2,&_target);
641                  } else {
642                     Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);
643                  }
644               break;               break;
645            case(Points):            case(Points):
646               Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(in.getDataC()),&(target.getDataC()));                if (getMPISize()>1) {
647                     escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
648                     escriptDataC _in2 = temp.getDataC();
649                     Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in2,&_target);
650                  } else {
651                     Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);
652                 }
653               break;               break;
654            case(ContactElementsZero):            case(ContactElementsZero):
655            case(ContactElementsOne):            case(ContactElementsOne):
656               Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(in.getDataC()),&(target.getDataC()));            case(ReducedContactElementsZero):
657               break;            case(ReducedContactElementsOne):
658            case(Nodes):                if (getMPISize()>1) {
659               throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to mesh nodes.");                   escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
660               break;                   escriptDataC _in2 = temp.getDataC();
661            case(DegreesOfFreedom):                   Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in2,&_target);
662               throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to degrees of freedom");                } else {
663                     Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
664                 }
665               break;               break;
666            default:            default:
667               stringstream temp;               stringstream temp;
# Line 477  void MeshAdapter::setToX(escript::Data& Line 690  void MeshAdapter::setToX(escript::Data&
690    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
691    // in case of values node coordinates we can do the job directly:    // in case of values node coordinates we can do the job directly:
692    if (arg.getFunctionSpace().getTypeCode()==Nodes) {    if (arg.getFunctionSpace().getTypeCode()==Nodes) {
693       Finley_Assemble_NodeCoordinates(mesh->Nodes,&(arg.getDataC()));       escriptDataC _arg=arg.getDataC();
694         Finley_Assemble_NodeCoordinates(mesh->Nodes,&_arg);
695    } else {    } else {
696       escript::Data tmp_data=Vector(0.0,continuousFunction(asAbstractContinuousDomain()),true);       escript::Data tmp_data=Vector(0.0,continuousFunction(asAbstractContinuousDomain()),true);
697       Finley_Assemble_NodeCoordinates(mesh->Nodes,&(tmp_data.getDataC()));       escriptDataC _tmp_data=tmp_data.getDataC();
698         Finley_Assemble_NodeCoordinates(mesh->Nodes,&_tmp_data);
699       // this is then interpolated onto arg:       // this is then interpolated onto arg:
700       interpolateOnDomain(arg,tmp_data);       interpolateOnDomain(arg,tmp_data);
701    }    }
# Line 496  void MeshAdapter::setToNormal(escript::D Line 711  void MeshAdapter::setToNormal(escript::D
711    if (normalDomain!=*this)    if (normalDomain!=*this)
712       throw FinleyAdapterException("Error - Illegal domain of normal locations");       throw FinleyAdapterException("Error - Illegal domain of normal locations");
713    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
714      escriptDataC _normal=normal.getDataC();
715    switch(normal.getFunctionSpace().getTypeCode()) {    switch(normal.getFunctionSpace().getTypeCode()) {
716      case(Nodes):      case(Nodes):
717        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");
718        break;        break;
719        case(ReducedNodes):
720          throw FinleyAdapterException("Error - Finley does not support surface normal vectors for reduced nodes");
721          break;
722      case(Elements):      case(Elements):
723        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements");        throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements");
724        break;        break;
725        case(ReducedElements):
726          throw FinleyAdapterException("Error - Finley does not support surface normal vectors for elements with reduced integration order");
727          break;
728      case (FaceElements):      case (FaceElements):
729        Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&(normal.getDataC()));        Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&_normal);
730          break;
731        case (ReducedFaceElements):
732          Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&_normal);
733        break;        break;
734      case(Points):      case(Points):
735        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");
736        break;        break;
737      case (ContactElementsOne):      case (ContactElementsOne):
738      case (ContactElementsZero):      case (ContactElementsZero):
739        Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&(normal.getDataC()));        Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&_normal);
740          break;
741        case (ReducedContactElementsOne):
742        case (ReducedContactElementsZero):
743          Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&_normal);
744        break;        break;
745      case(DegreesOfFreedom):      case(DegreesOfFreedom):
746        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 549  void MeshAdapter::setToIntegrals(std::ve Line 778  void MeshAdapter::setToIntegrals(std::ve
778    if (argDomain!=*this)    if (argDomain!=*this)
779       throw FinleyAdapterException("Error - Illegal domain of integration kernel");       throw FinleyAdapterException("Error - Illegal domain of integration kernel");
780    
781      double blocktimer_start = blocktimer_time();
782    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
783      escriptDataC _temp;
784      escript::Data temp;
785      escriptDataC _arg=arg.getDataC();
786    switch(arg.getFunctionSpace().getTypeCode()) {    switch(arg.getFunctionSpace().getTypeCode()) {
787       case(Nodes):       case(Nodes):
788          throw FinleyAdapterException("Error - Integral of data on nodes is not supported.");          temp=escript::Data( arg, function(asAbstractContinuousDomain()) );
789            _temp=temp.getDataC();
790            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_temp,&integrals[0]);
791            break;
792         case(ReducedNodes):
793            temp=escript::Data( arg, function(asAbstractContinuousDomain()) );
794            _temp=temp.getDataC();
795            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_temp,&integrals[0]);
796          break;          break;
797       case(Elements):       case(Elements):
798          Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);
799            break;
800         case(ReducedElements):
801            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);
802          break;          break;
803       case(FaceElements):       case(FaceElements):
804          Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&_arg,&integrals[0]);
805            break;
806         case(ReducedFaceElements):
807            Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&_arg,&integrals[0]);
808          break;          break;
809       case(Points):       case(Points):
810          throw FinleyAdapterException("Error - Integral of data on points is not supported.");          throw FinleyAdapterException("Error - Integral of data on points is not supported.");
811          break;          break;
812       case(ContactElementsZero):       case(ContactElementsZero):
813          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
814            break;
815         case(ReducedContactElementsZero):
816            Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
817          break;          break;
818       case(ContactElementsOne):       case(ContactElementsOne):
819          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&(arg.getDataC()),&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
820            break;
821         case(ReducedContactElementsOne):
822            Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);
823          break;          break;
824       case(DegreesOfFreedom):       case(DegreesOfFreedom):
825          throw FinleyAdapterException("Error - Integral of data on degrees of freedom is not supported.");          temp=escript::Data( arg, function(asAbstractContinuousDomain()) );
826            _temp=temp.getDataC();
827            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_temp,&integrals[0]);
828          break;          break;
829       case(ReducedDegreesOfFreedom):       case(ReducedDegreesOfFreedom):
830          throw FinleyAdapterException("Error - Integral of data on reduced degrees of freedom is not supported.");          temp=escript::Data( arg, function(asAbstractContinuousDomain()) );
831            _temp=temp.getDataC();
832            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_temp,&integrals[0]);
833          break;          break;
834       default:       default:
835          stringstream temp;          stringstream temp;
# Line 582  void MeshAdapter::setToIntegrals(std::ve Line 838  void MeshAdapter::setToIntegrals(std::ve
838          break;          break;
839    }    }
840    checkFinleyError();    checkFinleyError();
841      blocktimer_increment("integrate()", blocktimer_start);
842  }  }
843    
844  //  //
# Line 597  void MeshAdapter::setToGradient(escript: Line 854  void MeshAdapter::setToGradient(escript:
854       throw FinleyAdapterException("Error - Illegal domain of gradient");       throw FinleyAdapterException("Error - Illegal domain of gradient");
855    
856    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
857      escriptDataC _grad=grad.getDataC();
858    escriptDataC nodeDataC;    escriptDataC nodeDataC;
859  #ifdef PASO_MPI    escript::Data temp;
860    escript::Data nodeTemp( arg, continuousFunction(asAbstractContinuousDomain()) );    if (getMPISize()>1) {
861    if( arg.getFunctionSpace().getTypeCode() != Nodes )        if( arg.getFunctionSpace().getTypeCode() == DegreesOfFreedom ) {
862    {          temp=escript::Data( arg,  continuousFunction(asAbstractContinuousDomain()) );
863      Finley_Assemble_CopyNodalData(mesh->Nodes,&(nodeTemp.getDataC()),&(arg.getDataC()));          nodeDataC = temp.getDataC();
864      nodeDataC = nodeTemp.getDataC();        } else if( arg.getFunctionSpace().getTypeCode() == ReducedDegreesOfFreedom ) {
865            temp=escript::Data( arg,  reducedContinuousFunction(asAbstractContinuousDomain()) );
866            nodeDataC = temp.getDataC();
867          } else {
868            nodeDataC = arg.getDataC();
869          }
870      } else {
871         nodeDataC = arg.getDataC();
872    }    }
   else  
     nodeDataC = arg.getDataC();  
 #else  
   nodeDataC = arg.getDataC();  
 #endif  
873    switch(grad.getFunctionSpace().getTypeCode()) {    switch(grad.getFunctionSpace().getTypeCode()) {
874         case(Nodes):         case(Nodes):
875            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");            throw FinleyAdapterException("Error - Gradient at nodes is not supported.");
876            break;            break;
877           case(ReducedNodes):
878              throw FinleyAdapterException("Error - Gradient at reduced nodes is not supported.");
879              break;
880         case(Elements):         case(Elements):
881            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&_grad,&nodeDataC);
882              break;
883           case(ReducedElements):
884              Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&_grad,&nodeDataC);
885            break;            break;
886         case(FaceElements):         case(FaceElements):
887            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&_grad,&nodeDataC);
888              break;
889           case(ReducedFaceElements):
890              Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&_grad,&nodeDataC);
891            break;            break;
892         case(Points):         case(Points):
893            throw FinleyAdapterException("Error - Gradient at points is not supported.");            throw FinleyAdapterException("Error - Gradient at points is not supported.");
894            break;            break;
895         case(ContactElementsZero):         case(ContactElementsZero):
896            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
897              break;
898           case(ReducedContactElementsZero):
899              Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
900            break;            break;
901         case(ContactElementsOne):         case(ContactElementsOne):
902            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&(grad.getDataC()),&nodeDataC);            Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
903              break;
904           case(ReducedContactElementsOne):
905              Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);
906            break;            break;
907         case(DegreesOfFreedom):         case(DegreesOfFreedom):
908            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 930  void MeshAdapter::setToSize(escript::Dat
930         case(Nodes):         case(Nodes):
931            throw FinleyAdapterException("Error - Size of nodes is not supported.");            throw FinleyAdapterException("Error - Size of nodes is not supported.");
932            break;            break;
933           case(ReducedNodes):
934              throw FinleyAdapterException("Error - Size of reduced nodes is not supported.");
935              break;
936         case(Elements):         case(Elements):
937            Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);
938            break;            break;
939           case(ReducedElements):
940              Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);
941              break;
942         case(FaceElements):         case(FaceElements):
943            Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);
944            break;            break;
945           case(ReducedFaceElements):
946              Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);
947              break;
948         case(Points):         case(Points):
949            throw FinleyAdapterException("Error - Size of point elements is not supported.");            throw FinleyAdapterException("Error - Size of point elements is not supported.");
950            break;            break;
# Line 668  void MeshAdapter::setToSize(escript::Dat Line 952  void MeshAdapter::setToSize(escript::Dat
952         case(ContactElementsOne):         case(ContactElementsOne):
953            Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);            Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);
954            break;            break;
955           case(ReducedContactElementsZero):
956           case(ReducedContactElementsOne):
957              Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);
958              break;
959         case(DegreesOfFreedom):         case(DegreesOfFreedom):
960            throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");            throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");
961            break;            break;
# Line 712  void MeshAdapter::saveDX(const std::stri Line 1000  void MeshAdapter::saveDX(const std::stri
1000    escriptDataC *data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC) : (escriptDataC*)NULL;    escriptDataC *data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC) : (escriptDataC*)NULL;
1001    escriptDataC* *ptr_data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC*) : (escriptDataC**)NULL;    escriptDataC* *ptr_data = (num_data>0) ? TMPMEMALLOC(num_data,escriptDataC*) : (escriptDataC**)NULL;
1002    
1003      boost::python::list keys=arg.keys();    boost::python::list keys=arg.keys();
1004      for (int i=0;i<num_data;++i) {    for (int i=0;i<num_data;++i) {
1005             std::string n=boost::python::extract<std::string>(keys[i]);
1006           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);
1007           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)
1008               throw FinleyAdapterException("Error  in saveVTK: Data must be defined on same Domain");               throw FinleyAdapterException("Error  in saveVTK: Data must be defined on same Domain");
1009           data[i]=d.getDataC();           data[i]=d.getDataC();
1010           ptr_data[i]=&(data[i]);           ptr_data[i]=&(data[i]);
          std::string n=boost::python::extract<std::string>(keys[i]);  
1011           c_names[i]=&(names[i][0]);           c_names[i]=&(names[i][0]);
1012           if (n.length()>MAX_namelength-1) {           if (n.length()>MAX_namelength-1) {
1013              strncpy(c_names[i],n.c_str(),MAX_namelength-1);              strncpy(c_names[i],n.c_str(),MAX_namelength-1);
# Line 762  void MeshAdapter::saveVTK(const std::str Line 1050  void MeshAdapter::saveVTK(const std::str
1050    
1051      boost::python::list keys=arg.keys();      boost::python::list keys=arg.keys();
1052      for (int i=0;i<num_data;++i) {      for (int i=0;i<num_data;++i) {
1053             std::string n=boost::python::extract<std::string>(keys[i]);
1054           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);           escript::Data& d=boost::python::extract<escript::Data&>(arg[keys[i]]);
1055           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)           if (dynamic_cast<const MeshAdapter&>(d.getFunctionSpace().getDomain()) !=*this)
1056               throw FinleyAdapterException("Error  in saveVTK: Data must be defined on same Domain");               throw FinleyAdapterException("Error  in saveVTK: Data must be defined on same Domain");
1057           data[i]=d.getDataC();           data[i]=d.getDataC();
1058           ptr_data[i]=&(data[i]);           ptr_data[i]=&(data[i]);
          std::string n=boost::python::extract<std::string>(keys[i]);  
1059           c_names[i]=&(names[i][0]);           c_names[i]=&(names[i][0]);
1060           if (n.length()>MAX_namelength-1) {           if (n.length()>MAX_namelength-1) {
1061              strncpy(c_names[i],n.c_str(),MAX_namelength-1);              strncpy(c_names[i],n.c_str(),MAX_namelength-1);
# Line 777  void MeshAdapter::saveVTK(const std::str Line 1065  void MeshAdapter::saveVTK(const std::str
1065           }           }
1066      }      }
1067      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);
1068      checkFinleyError();  
1069      checkFinleyError();
1070    /* win32 refactor */    /* win32 refactor */
1071    TMPMEMFREE(c_names);    TMPMEMFREE(c_names);
1072    TMPMEMFREE(data);    TMPMEMFREE(data);
# Line 828  SystemMatrixAdapter MeshAdapter::newSyst Line 1117  SystemMatrixAdapter MeshAdapter::newSyst
1117            
1118      Paso_SystemMatrixPattern* fsystemMatrixPattern=Finley_getPattern(getFinley_Mesh(),reduceRowOrder,reduceColOrder);      Paso_SystemMatrixPattern* fsystemMatrixPattern=Finley_getPattern(getFinley_Mesh(),reduceRowOrder,reduceColOrder);
1119      checkFinleyError();      checkFinleyError();
1120      Paso_SystemMatrix* fsystemMatrix=Paso_SystemMatrix_alloc(type,fsystemMatrixPattern,row_blocksize,column_blocksize);      Paso_SystemMatrix* fsystemMatrix;
1121        int trilinos = 0;
1122        if (trilinos) {
1123    #ifdef TRILINOS
1124          /* Allocation Epetra_VrbMatrix here */
1125    #endif
1126        }
1127        else {
1128          fsystemMatrix=Paso_SystemMatrix_alloc(type,fsystemMatrixPattern,row_blocksize,column_blocksize);
1129        }
1130      checkPasoError();      checkPasoError();
1131      Paso_SystemMatrixPattern_dealloc(fsystemMatrixPattern);      Paso_SystemMatrixPattern_free(fsystemMatrixPattern);
1132      return SystemMatrixAdapter(fsystemMatrix,row_blocksize,row_functionspace,column_blocksize,column_functionspace);      return SystemMatrixAdapter(fsystemMatrix,row_blocksize,row_functionspace,column_blocksize,column_functionspace);
1133  }  }
1134    
# Line 854  bool MeshAdapter::isCellOriented(int fun Line 1152  bool MeshAdapter::isCellOriented(int fun
1152         case(Points):         case(Points):
1153         case(ContactElementsZero):         case(ContactElementsZero):
1154         case(ContactElementsOne):         case(ContactElementsOne):
1155           case(ReducedElements):
1156           case(ReducedFaceElements):
1157           case(ReducedContactElementsZero):
1158           case(ReducedContactElementsOne):
1159            return true;            return true;
1160            break;            break;
1161         default:         default:
# Line 872  bool MeshAdapter::probeInterpolationOnDo Line 1174  bool MeshAdapter::probeInterpolationOnDo
1174       case(Nodes):       case(Nodes):
1175          switch(functionSpaceType_target) {          switch(functionSpaceType_target) {
1176             case(Nodes):             case(Nodes):
1177               case(ReducedNodes):
1178             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
1179             case(DegreesOfFreedom):             case(DegreesOfFreedom):
1180             case(Elements):             case(Elements):
1181               case(ReducedElements):
1182             case(FaceElements):             case(FaceElements):
1183               case(ReducedFaceElements):
1184             case(Points):             case(Points):
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 886  bool MeshAdapter::probeInterpolationOnDo Line 1193  bool MeshAdapter::probeInterpolationOnDo
1193                 throw FinleyAdapterException(temp.str());                 throw FinleyAdapterException(temp.str());
1194          }          }
1195          break;          break;
1196         case(ReducedNodes):
1197            switch(functionSpaceType_target) {
1198               case(ReducedNodes):
1199               case(ReducedDegreesOfFreedom):
1200               case(Elements):
1201               case(ReducedElements):
1202               case(FaceElements):
1203               case(ReducedFaceElements):
1204               case(Points):
1205               case(ContactElementsZero):
1206               case(ReducedContactElementsZero):
1207               case(ContactElementsOne):
1208               case(ReducedContactElementsOne):
1209                   return true;
1210              case(Nodes):
1211              case(DegreesOfFreedom):
1212                 return false;
1213               default:
1214                   stringstream temp;
1215                   temp << "Error - Interpolation On Domain: Finley does not know anything about function space type " << functionSpaceType_target;
1216                   throw FinleyAdapterException(temp.str());
1217            }
1218            break;
1219       case(Elements):       case(Elements):
1220          if (functionSpaceType_target==Elements) {          if (functionSpaceType_target==Elements) {
1221             return true;             return true;
1222            } else if (functionSpaceType_target==ReducedElements) {
1223               return true;
1224            } else {
1225               return false;
1226            }
1227         case(ReducedElements):
1228            if (functionSpaceType_target==ReducedElements) {
1229               return true;
1230          } else {          } else {
1231             return false;             return false;
1232          }          }
1233       case(FaceElements):       case(FaceElements):
1234          if (functionSpaceType_target==FaceElements) {          if (functionSpaceType_target==FaceElements) {
1235             return true;             return true;
1236            } else if (functionSpaceType_target==ReducedFaceElements) {
1237               return true;
1238            } else {
1239               return false;
1240            }
1241         case(ReducedFaceElements):
1242            if (functionSpaceType_target==ReducedFaceElements) {
1243               return true;
1244          } else {          } else {
1245             return false;             return false;
1246          }          }
# Line 908  bool MeshAdapter::probeInterpolationOnDo Line 1254  bool MeshAdapter::probeInterpolationOnDo
1254       case(ContactElementsOne):       case(ContactElementsOne):
1255          if (functionSpaceType_target==ContactElementsZero || functionSpaceType_target==ContactElementsOne) {          if (functionSpaceType_target==ContactElementsZero || functionSpaceType_target==ContactElementsOne) {
1256             return true;             return true;
1257            } else if (functionSpaceType_target==ReducedContactElementsZero || functionSpaceType_target==ReducedContactElementsOne) {
1258               return true;
1259            } else {
1260               return false;
1261            }
1262         case(ReducedContactElementsZero):
1263         case(ReducedContactElementsOne):
1264            if (functionSpaceType_target==ReducedContactElementsZero || functionSpaceType_target==ReducedContactElementsOne) {
1265               return true;
1266          } else {          } else {
1267             return false;             return false;
1268          }          }
# Line 916  bool MeshAdapter::probeInterpolationOnDo Line 1271  bool MeshAdapter::probeInterpolationOnDo
1271             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
1272             case(DegreesOfFreedom):             case(DegreesOfFreedom):
1273             case(Nodes):             case(Nodes):
1274               case(ReducedNodes):
1275             case(Elements):             case(Elements):
1276             case(FaceElements):             case(ReducedElements):
1277             case(Points):             case(Points):
1278               case(FaceElements):
1279               case(ReducedFaceElements):
1280             case(ContactElementsZero):             case(ContactElementsZero):
1281               case(ReducedContactElementsZero):
1282             case(ContactElementsOne):             case(ContactElementsOne):
1283               case(ReducedContactElementsOne):
1284                return true;                return true;
1285             default:             default:
1286               stringstream temp;               stringstream temp;
# Line 931  bool MeshAdapter::probeInterpolationOnDo Line 1291  bool MeshAdapter::probeInterpolationOnDo
1291       case(ReducedDegreesOfFreedom):       case(ReducedDegreesOfFreedom):
1292         switch(functionSpaceType_target) {         switch(functionSpaceType_target) {
1293            case(ReducedDegreesOfFreedom):            case(ReducedDegreesOfFreedom):
1294              case(ReducedNodes):
1295            case(Elements):            case(Elements):
1296              case(ReducedElements):
1297            case(FaceElements):            case(FaceElements):
1298              case(ReducedFaceElements):
1299            case(Points):            case(Points):
1300            case(ContactElementsZero):            case(ContactElementsZero):
1301              case(ReducedContactElementsZero):
1302            case(ContactElementsOne):            case(ContactElementsOne):
1303              case(ReducedContactElementsOne):
1304                return true;                return true;
1305            case(Nodes):            case(Nodes):
1306            case(DegreesOfFreedom):            case(DegreesOfFreedom):
# Line 998  escript::Data MeshAdapter::getSize() con Line 1363  escript::Data MeshAdapter::getSize() con
1363    return function(asAbstractContinuousDomain()).getSize();    return function(asAbstractContinuousDomain()).getSize();
1364  }  }
1365    
1366    int* MeshAdapter::borrowSampleReferenceIDs(int functionSpaceType) const
1367    {
1368      int *out=0,i;
1369      Finley_Mesh* mesh=m_finleyMesh.get();
1370      switch (functionSpaceType) {
1371        case(Nodes):
1372          out=mesh->Nodes->Id;
1373          break;
1374        case(ReducedNodes):
1375          out=mesh->Nodes->reducedNodesId;
1376          break;
1377        case(Elements):
1378          out=mesh->Elements->Id;
1379          break;
1380        case(ReducedElements):
1381          out=mesh->Elements->Id;
1382          break;
1383        case(FaceElements):
1384          out=mesh->FaceElements->Id;
1385          break;
1386        case(ReducedFaceElements):
1387          out=mesh->FaceElements->Id;
1388          break;
1389        case(Points):
1390          out=mesh->Points->Id;
1391          break;
1392        case(ContactElementsZero):
1393          out=mesh->ContactElements->Id;
1394          break;
1395        case(ReducedContactElementsZero):
1396          out=mesh->ContactElements->Id;
1397          break;
1398        case(ContactElementsOne):
1399          out=mesh->ContactElements->Id;
1400          break;
1401        case(ReducedContactElementsOne):
1402          out=mesh->ContactElements->Id;
1403          break;
1404        case(DegreesOfFreedom):
1405          out=mesh->Nodes->degreesOfFreedomId;
1406          break;
1407        case(ReducedDegreesOfFreedom):
1408          out=mesh->Nodes->reducedDegreesOfFreedomId;
1409          break;
1410        default:
1411          stringstream temp;
1412          temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();
1413          throw FinleyAdapterException(temp.str());
1414          break;
1415      }
1416      return out;
1417    }
1418  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const  int MeshAdapter::getTagFromSampleNo(int functionSpaceType, int sampleNo) const
1419  {  {
1420    int out=0;    int out=0;
# Line 1006  int MeshAdapter::getTagFromSampleNo(int Line 1423  int MeshAdapter::getTagFromSampleNo(int
1423    case(Nodes):    case(Nodes):
1424      out=mesh->Nodes->Tag[sampleNo];      out=mesh->Nodes->Tag[sampleNo];
1425      break;      break;
1426      case(ReducedNodes):
1427        throw FinleyAdapterException(" Error - ReducedNodes does not support tags.");
1428        break;
1429    case(Elements):    case(Elements):
1430      out=mesh->Elements->Tag[sampleNo];      out=mesh->Elements->Tag[sampleNo];
1431      break;      break;
1432      case(ReducedElements):
1433        out=mesh->Elements->Tag[sampleNo];
1434        break;
1435    case(FaceElements):    case(FaceElements):
1436      out=mesh->FaceElements->Tag[sampleNo];      out=mesh->FaceElements->Tag[sampleNo];
1437      break;      break;
1438      case(ReducedFaceElements):
1439        out=mesh->FaceElements->Tag[sampleNo];
1440        break;
1441    case(Points):    case(Points):
1442      out=mesh->Points->Tag[sampleNo];      out=mesh->Points->Tag[sampleNo];
1443      break;      break;
1444    case(ContactElementsZero):    case(ContactElementsZero):
1445      out=mesh->ContactElements->Tag[sampleNo];      out=mesh->ContactElements->Tag[sampleNo];
1446      break;      break;
1447      case(ReducedContactElementsZero):
1448        out=mesh->ContactElements->Tag[sampleNo];
1449        break;
1450    case(ContactElementsOne):    case(ContactElementsOne):
1451      out=mesh->ContactElements->Tag[sampleNo];      out=mesh->ContactElements->Tag[sampleNo];
1452      break;      break;
1453      case(ReducedContactElementsOne):
1454        out=mesh->ContactElements->Tag[sampleNo];
1455        break;
1456    case(DegreesOfFreedom):    case(DegreesOfFreedom):
1457        throw FinleyAdapterException(" Error - DegreesOfFreedom does not support tags.");
1458      break;      break;
1459    case(ReducedDegreesOfFreedom):    case(ReducedDegreesOfFreedom):
1460        throw FinleyAdapterException(" Error - ReducedDegreesOfFreedom does not support tags.");
1461      break;      break;
1462    default:    default:
1463      stringstream temp;      stringstream temp;
# Line 1033  int MeshAdapter::getTagFromSampleNo(int Line 1467  int MeshAdapter::getTagFromSampleNo(int
1467    }    }
1468    return out;    return out;
1469  }  }
1470  int MeshAdapter::getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const  
1471    
1472    void MeshAdapter::setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const
1473  {  {
   int out=0,i;  
1474    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
1475    switch (functionSpaceType) {    escriptDataC tmp=mask.getDataC();
1476    case(Nodes):    switch(functionSpaceType) {
1477      if (mesh->Nodes!=NULL) {         case(Nodes):
1478        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];  
1479            break;            break;
1480         }         case(ReducedNodes):
1481      }            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];  
1482            break;            break;
1483         }         case(DegreesOfFreedom):
1484      }            throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");
1485      break;            break;
1486    default:         case(ReducedDegreesOfFreedom):
1487      stringstream temp;            throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");
1488      temp << "Error - Invalid function space type: " << functionSpaceType << " for domain: " << getDescription();            break;
1489      throw FinleyAdapterException(temp.str());         case(Elements):
1490      break;            Finley_ElementFile_setTags(mesh->Elements,newTag,&tmp);
1491              break;
1492           case(ReducedElements):
1493              Finley_ElementFile_setTags(mesh->Elements,newTag,&tmp);
1494              break;
1495           case(FaceElements):
1496              Finley_ElementFile_setTags(mesh->FaceElements,newTag,&tmp);
1497              break;
1498           case(ReducedFaceElements):
1499              Finley_ElementFile_setTags(mesh->FaceElements,newTag,&tmp);
1500              break;
1501           case(Points):
1502              Finley_ElementFile_setTags(mesh->Points,newTag,&tmp);
1503              break;
1504           case(ContactElementsZero):
1505              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1506              break;
1507           case(ReducedContactElementsZero):
1508              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1509              break;
1510           case(ContactElementsOne):
1511              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1512              break;
1513           case(ReducedContactElementsOne):
1514              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);
1515              break;
1516           default:
1517              stringstream temp;
1518              temp << "Error - Finley does not know anything about function space type " << functionSpaceType;
1519              throw FinleyAdapterException(temp.str());
1520    }    }
1521    return out;    checkFinleyError();
1522      return;
1523    }
1524    
1525    void MeshAdapter::setTagMap(const std::string& name,  int tag)
1526    {
1527      Finley_Mesh* mesh=m_finleyMesh.get();
1528      Finley_Mesh_addTagMap(mesh, name.c_str(),tag);
1529      checkPasoError();
1530      // throwStandardException("MeshAdapter::set TagMap is not implemented.");
1531    }
1532    
1533    int MeshAdapter::getTag(const std::string& name) const
1534    {
1535      Finley_Mesh* mesh=m_finleyMesh.get();
1536      int tag=0;
1537      tag=Finley_Mesh_getTag(mesh, name.c_str());
1538      checkPasoError();
1539      // throwStandardException("MeshAdapter::getTag is not implemented.");
1540      return tag;
1541    }
1542    
1543    bool MeshAdapter::isValidTagName(const std::string& name) const
1544    {
1545      Finley_Mesh* mesh=m_finleyMesh.get();
1546      return Finley_Mesh_isValidTagName(mesh,name.c_str());
1547    }
1548    
1549    std::string MeshAdapter::showTagNames() const
1550    {
1551      stringstream temp;
1552      Finley_Mesh* mesh=m_finleyMesh.get();
1553      Finley_TagMap* tag_map=mesh->TagMap;
1554      while (tag_map) {
1555         temp << tag_map->name;
1556         tag_map=tag_map->next;
1557         if (tag_map) temp << ", ";
1558      }
1559      return temp.str();
1560  }  }
1561    
1562  }  // end of namespace  }  // end of namespace

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

  ViewVC Help
Powered by ViewVC 1.1.26