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

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

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

revision 1311 by gross, Sat Jun 23 11:43:12 2007 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  #ifdef PASO_MPI  /* $Id$ */
 #include <mpi.h>  
 #endif  
 #include "MeshAdapter.h"  
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 47  MeshAdapter::MeshAdapter(Finley_Mesh* fi Line 47  MeshAdapter::MeshAdapter(Finley_Mesh* fi
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 66  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 85  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 string("FinleyMesh");    return "FinleyMesh";
108  }  }
109    
110  string MeshAdapter::functionSpaceTypeAsString(int functionSpaceType) const  string MeshAdapter::functionSpaceTypeAsString(int functionSpaceType) const
# Line 97  string MeshAdapter::functionSpaceTypeAsS Line 114  string MeshAdapter::functionSpaceTypeAsS
114    if (loc==m_functionSpaceTypeNames.end()) {    if (loc==m_functionSpaceTypeNames.end()) {
115      return "Invalid function space type code.";      return "Invalid function space type code.";
116    } else {    } else {
117      return string(loc->second);      return loc->second;
118    }    }
119  }  }
120    
# Line 220  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;             break;
242        case(ReducedNodes):        case(ReducedNodes):
            /* TODO: add ReducedNodes */  
243             numDataPointsPerSample=1;             numDataPointsPerSample=1;
244             if (mesh->Nodes!=NULL) numSamples=mesh->Nodes->numNodes;             numSamples=Finley_NodeFile_getNumReducedNodes(mesh->Nodes);
            throw FinleyAdapterException("Error - ReducedNodes is not supported yet.");  
245             break;             break;
246        case(Elements):        case(Elements):
247             if (mesh->Elements!=NULL) {             if (mesh->Elements!=NULL) {
# Line 285  pair<int,int> MeshAdapter::getDataShape( Line 300  pair<int,int> MeshAdapter::getDataShape(
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 346  void MeshAdapter::addPDEToSystem( Line 353  void MeshAdapter::addPDEToSystem(
353    
354  void  MeshAdapter::addPDEToLumpedSystem(  void  MeshAdapter::addPDEToLumpedSystem(
355                       escript::Data& mat,                       escript::Data& mat,
356                       const escript::Data& D,                       const escript::Data& D,
357                       const escript::Data& d) const                       const escript::Data& d) const
358  {  {
359     escriptDataC _mat=mat.getDataC();     escriptDataC _mat=mat.getDataC();
# Line 354  void  MeshAdapter::addPDEToLumpedSystem( Line 361  void  MeshAdapter::addPDEToLumpedSystem(
361     escriptDataC _d=d.getDataC();     escriptDataC _d=d.getDataC();
362    
363     Finley_Mesh* mesh=m_finleyMesh.get();     Finley_Mesh* mesh=m_finleyMesh.get();
364      
365     Finley_Assemble_LumpedSystem(mesh->Nodes,mesh->Elements,&_mat, &_D);     Finley_Assemble_LumpedSystem(mesh->Nodes,mesh->Elements,&_mat, &_D);
366     Finley_Assemble_LumpedSystem(mesh->Nodes,mesh->FaceElements,&_mat, &_d);     Finley_Assemble_LumpedSystem(mesh->Nodes,mesh->FaceElements,&_mat, &_d);
367    
# Line 532  void MeshAdapter::interpolateOnDomain(es Line 539  void MeshAdapter::interpolateOnDomain(es
539          switch(target.getFunctionSpace().getTypeCode()) {          switch(target.getFunctionSpace().getTypeCode()) {
540             case(ReducedDegreesOfFreedom):             case(ReducedDegreesOfFreedom):
541             case(DegreesOfFreedom):             case(DegreesOfFreedom):
            case(Nodes):  
            case(ReducedNodes):  
542                Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
543                break;                break;
544  #ifndef PASO_MPI  
545             case(Elements):             case(Nodes):
546             case(ReducedElements):             case(ReducedNodes):
547                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);                if (getMPISize()>1) {
548                break;                    escript::Data temp=escript::Data(in);
549             case(FaceElements):                    temp.expand();
550             case(ReducedFaceElements):                    escriptDataC _in2 = temp.getDataC();
551                Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);                    Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in2);
552                break;                } else {
553             case(Points):                    Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);
554                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);                }
555                break;                break;
            case(ContactElementsZero):  
            case(ContactElementsOne):  
            case(ReducedContactElementsZero):  
            case(ReducedContactElementsOne):  
               Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);  
              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):             case(ReducedElements):
558                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                if (getMPISize()>1) {
559                Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&(nodeTemp.getDataC()),&_target);                   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):             case(ReducedFaceElements):
568                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                if (getMPISize()>1) {
569                Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&(nodeTemp.getDataC()),&_target);                   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                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                if (getMPISize()>1) {
579                Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&(nodeTemp.getDataC()),&_target);                   escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
580                     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):             case(ReducedContactElementsZero):
588             case(ReducedContactElementsOne):             case(ReducedContactElementsOne):
589                escript::Data nodeTemp( in, continuousFunction(asAbstractContinuousDomain()) );                if (getMPISize()>1) {
590                Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&(nodeTemp.getDataC()),&_target);                   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 591  void MeshAdapter::interpolateOnDomain(es Line 607  void MeshAdapter::interpolateOnDomain(es
607               throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to mesh nodes.");               throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to mesh nodes.");
608               break;               break;
609            case(ReducedNodes):            case(ReducedNodes):
610               Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                if (getMPISize()>1) {
611               break;                    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):            case(DegreesOfFreedom):
620               throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to degrees of freedom");               throw FinleyAdapterException("Error - Finley does not support interpolation from reduced degrees of freedom to degrees of freedom");
621               break;               break;
# Line 601  void MeshAdapter::interpolateOnDomain(es Line 624  void MeshAdapter::interpolateOnDomain(es
624               break;               break;
625            case(Elements):            case(Elements):
626            case(ReducedElements):            case(ReducedElements):
627               Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);                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            case(ReducedFaceElements):            case(ReducedFaceElements):
637               Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);                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,&_target);                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            case(ReducedContactElementsZero):            case(ReducedContactElementsZero):
657            case(ReducedContactElementsOne):            case(ReducedContactElementsOne):
658               Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);                if (getMPISize()>1) {
659                     escript::Data temp=escript::Data( in,  continuousFunction(asAbstractContinuousDomain()) );
660                     escriptDataC _in2 = temp.getDataC();
661                     Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in2,&_target);
662                  } else {
663                     Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);
664                 }
665               break;               break;
666            default:            default:
667               stringstream temp;               stringstream temp;
# Line 731  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();    escriptDataC _arg=arg.getDataC();
786    switch(arg.getFunctionSpace().getTypeCode()) {    switch(arg.getFunctionSpace().getTypeCode()) {
787       case(Nodes):       case(Nodes):
788          /* TODO */          temp=escript::Data( arg, function(asAbstractContinuousDomain()) );
789          throw FinleyAdapterException("Error - Integral of data on nodes is not supported.");          _temp=temp.getDataC();
790            Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_temp,&integrals[0]);
791          break;          break;
792       case(ReducedNodes):       case(ReducedNodes):
793          /* TODO */          temp=escript::Data( arg, function(asAbstractContinuousDomain()) );
794          throw FinleyAdapterException("Error - Integral of data on reduced nodes is not supported.");          _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,&integrals[0]);          Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);
# Line 770  void MeshAdapter::setToIntegrals(std::ve Line 822  void MeshAdapter::setToIntegrals(std::ve
822          Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);          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 782  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 799  void MeshAdapter::setToGradient(escript: Line 856  void MeshAdapter::setToGradient(escript:
856    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
857    escriptDataC _grad=grad.getDataC();    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.");
# Line 941  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 saveDX: 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 991  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 1005  void MeshAdapter::saveVTK(const std::str Line 1064  void MeshAdapter::saveVTK(const std::str
1064              strcpy(c_names[i],n.c_str());              strcpy(c_names[i],n.c_str());
1065           }           }
1066      }      }
 #ifndef PASO_MPI      
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);
 #else  
     Finley_Mesh_saveVTK_MPIO(filename.c_str(),m_finleyMesh.get(),num_data,c_names,ptr_data);  
 #endif  
1068    
1069  checkFinleyError();    checkFinleyError();
1070    /* win32 refactor */    /* win32 refactor */
1071    TMPMEMFREE(c_names);    TMPMEMFREE(c_names);
1072    TMPMEMFREE(data);    TMPMEMFREE(data);
# Line 1062  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 1305  int* MeshAdapter::borrowSampleReferenceI Line 1369  int* MeshAdapter::borrowSampleReferenceI
1369    Finley_Mesh* mesh=m_finleyMesh.get();    Finley_Mesh* mesh=m_finleyMesh.get();
1370    switch (functionSpaceType) {    switch (functionSpaceType) {
1371      case(Nodes):      case(Nodes):
1372        if (mesh->Nodes!=NULL) {        out=mesh->Nodes->Id;
1373          out=mesh->Nodes->Id;        break;
         break;  
       }  
1374      case(ReducedNodes):      case(ReducedNodes):
1375        throw FinleyAdapterException("Error -  ReducedNodes not supported yet.");        out=mesh->Nodes->reducedNodesId;
1376        break;        break;
1377      case(Elements):      case(Elements):
1378        out=mesh->Elements->Id;        out=mesh->Elements->Id;
# Line 1340  int* MeshAdapter::borrowSampleReferenceI Line 1402  int* MeshAdapter::borrowSampleReferenceI
1402        out=mesh->ContactElements->Id;        out=mesh->ContactElements->Id;
1403        break;        break;
1404      case(DegreesOfFreedom):      case(DegreesOfFreedom):
1405        out=mesh->Nodes->degreeOfFreedomId;        out=mesh->Nodes->degreesOfFreedomId;
1406        break;        break;
1407      case(ReducedDegreesOfFreedom):      case(ReducedDegreesOfFreedom):
1408        out=mesh->Nodes->reducedDegreeOfFreedomId;        out=mesh->Nodes->reducedDegreesOfFreedomId;
1409        break;        break;
1410      default:      default:
1411        stringstream temp;        stringstream temp;
# Line 1494  std::string MeshAdapter::showTagNames() Line 1556  std::string MeshAdapter::showTagNames()
1556       tag_map=tag_map->next;       tag_map=tag_map->next;
1557       if (tag_map) temp << ", ";       if (tag_map) temp << ", ";
1558    }    }
1559    return string(temp.str());    return temp.str();
1560  }  }
1561    
1562  }  // end of namespace  }  // end of namespace

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

  ViewVC Help
Powered by ViewVC 1.1.26