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

Diff of /branches/diaplayground/finley/src/CPPAdapter/MeshAdapter.cpp

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

revision 4408 by caltinay, Tue May 14 06:58:43 2013 UTC revision 4441 by caltinay, Fri Jun 7 02:23:49 2013 UTC
# Line 129  void MeshAdapter::dump(const string& fil Line 129  void MeshAdapter::dump(const string& fil
129      NcVar *ids;      NcVar *ids;
130      int *int_ptr;      int *int_ptr;
131      Finley_Mesh *mesh = m_finleyMesh.get();      Finley_Mesh *mesh = m_finleyMesh.get();
     Finley_TagMap* tag_map;  
132      int num_Tags = 0;      int num_Tags = 0;
133      int mpi_size                         = mesh->MPIInfo->size;      int mpi_size                         = mesh->MPIInfo->size;
134      int mpi_rank                         = mesh->MPIInfo->rank;      int mpi_rank                         = mesh->MPIInfo->rank;
# Line 157  void MeshAdapter::dump(const string& fil Line 156  void MeshAdapter::dump(const string& fil
156                                                       mpi_size, mpi_rank);                                                       mpi_size, mpi_rank);
157    
158      // Figure out how much storage is required for tags      // Figure out how much storage is required for tags
159      tag_map = mesh->TagMap;      num_Tags = mesh->tagMap.size();
     num_Tags = 0;  
     while (tag_map) {  
         num_Tags++;  
         tag_map=tag_map->next;  
     }  
160    
161      // NetCDF error handler      // NetCDF error handler
162      NcError err(NcError::verbose_nonfatal);      NcError err(NcError::verbose_nonfatal);
# Line 470  void MeshAdapter::dump(const string& fil Line 464  void MeshAdapter::dump(const string& fil
464          vector<int> Tags_keys;          vector<int> Tags_keys;
465    
466          // Copy tag data into temp arrays          // Copy tag data into temp arrays
467          tag_map = mesh->TagMap;          TagMap::const_iterator it;
468          while (tag_map) {          for (it=mesh->tagMap.begin(); it!=mesh->tagMap.end(); it++) {
469              Tags_keys.push_back(tag_map->tag_key);              Tags_keys.push_back(it->second);
             tag_map=tag_map->next;  
470          }          }
471    
472          // Tags_keys          // Tags_keys
# Line 487  void MeshAdapter::dump(const string& fil Line 480  void MeshAdapter::dump(const string& fil
480          // This is an array of strings, it should be stored as an array but          // This is an array of strings, it should be stored as an array but
481          // instead I have hacked in one attribute per string because the NetCDF          // instead I have hacked in one attribute per string because the NetCDF
482          // manual doesn't tell how to do an array of strings          // manual doesn't tell how to do an array of strings
         tag_map = mesh->TagMap;  
483          int i = 0;          int i = 0;
484          while (tag_map) {          for (it=mesh->tagMap.begin(); it!=mesh->tagMap.end(); it++, i++) {
485              stringstream tagnamestream;              stringstream tagnamestream;
486              tagnamestream << "Tags_name_" << i;              tagnamestream << "Tags_name_" << i;
487              const string tagname = tagnamestream.str();              const string tagname = tagnamestream.str();
488              if (!dataFile.add_att(tagname.c_str(), tag_map->name) )              if (!dataFile.add_att(tagname.c_str(), it->first.c_str()))
489                  throw FinleyAdapterException(msgPrefix+"add_att(Tags_names_XX)");                  throw FinleyAdapterException(msgPrefix+"add_att(Tags_names_X)");
             tag_map=tag_map->next;  
             i++;  
490          }          }
491      }      }
492    
# Line 649  int MeshAdapter::getDim() const Line 639  int MeshAdapter::getDim() const
639  //  //
640  int MeshAdapter::getNumDataPointsGlobal() const  int MeshAdapter::getNumDataPointsGlobal() const
641  {  {
642      return Finley_NodeFile_getGlobalNumNodes(m_finleyMesh.get()->Nodes);      return m_finleyMesh.get()->Nodes->getGlobalNumNodes();
643  }  }
644    
645  //  //
# Line 664  pair<int,int> MeshAdapter::getDataShape( Line 654  pair<int,int> MeshAdapter::getDataShape(
654      switch (functionSpaceCode) {      switch (functionSpaceCode) {
655          case Nodes:          case Nodes:
656              numDataPointsPerSample=1;              numDataPointsPerSample=1;
657              numSamples=Finley_NodeFile_getNumNodes(mesh->Nodes);              numSamples=mesh->Nodes->getNumNodes();
658              break;              break;
659          case ReducedNodes:          case ReducedNodes:
660              numDataPointsPerSample=1;              numDataPointsPerSample=1;
661              numSamples=Finley_NodeFile_getNumReducedNodes(mesh->Nodes);              numSamples=mesh->Nodes->getNumReducedNodes();
662              break;              break;
663          case Elements:          case Elements:
664              if (mesh->Elements!=NULL) {              if (mesh->Elements!=NULL) {
# Line 727  pair<int,int> MeshAdapter::getDataShape( Line 717  pair<int,int> MeshAdapter::getDataShape(
717          case DegreesOfFreedom:          case DegreesOfFreedom:
718              if (mesh->Nodes!=NULL) {              if (mesh->Nodes!=NULL) {
719                  numDataPointsPerSample=1;                  numDataPointsPerSample=1;
720                  numSamples=Finley_NodeFile_getNumDegreesOfFreedom(mesh->Nodes);                  numSamples=mesh->Nodes->getNumDegreesOfFreedom();
721              }              }
722              break;              break;
723          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
724              if (mesh->Nodes!=NULL) {              if (mesh->Nodes!=NULL) {
725                  numDataPointsPerSample=1;                  numDataPointsPerSample=1;
726                  numSamples=Finley_NodeFile_getNumReducedDegreesOfFreedom(mesh->Nodes);                  numSamples=mesh->Nodes->getNumReducedDegreesOfFreedom();
727              }              }
728              break;              break;
729          default:          default:
# Line 761  void MeshAdapter::addPDEToSystem( Line 751  void MeshAdapter::addPDEToSystem(
751      if (!smat)      if (!smat)
752          throw FinleyAdapterException("finley only supports Paso system matrices.");          throw FinleyAdapterException("finley only supports Paso system matrices.");
753    
     escriptDataC _rhs=rhs.getDataC();  
     escriptDataC _A  =A.getDataC();  
     escriptDataC _B=B.getDataC();  
     escriptDataC _C=C.getDataC();  
     escriptDataC _D=D.getDataC();  
     escriptDataC _X=X.getDataC();  
     escriptDataC _Y=Y.getDataC();  
     escriptDataC _d=d.getDataC();  
     escriptDataC _y=y.getDataC();  
     escriptDataC _d_contact=d_contact.getDataC();  
     escriptDataC _y_contact=y_contact.getDataC();  
     escriptDataC _d_dirac=d_dirac.getDataC();  
     escriptDataC _y_dirac=y_dirac.getDataC();  
   
754      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
755      Paso_SystemMatrix* S = smat->getPaso_SystemMatrix();      Paso_SystemMatrix* S = smat->getPaso_SystemMatrix();
756        Assemble_PDE(mesh->Nodes, mesh->Elements, S, rhs, A, B, C, D, X, Y);
     Finley_Assemble_PDE(mesh->Nodes, mesh->Elements, S, &_rhs, &_A, &_B, &_C,  
                         &_D, &_X, &_Y);  
757      checkFinleyError();      checkFinleyError();
758    
759      Finley_Assemble_PDE(mesh->Nodes, mesh->FaceElements, S, &_rhs, 0, 0, 0,      Assemble_PDE(mesh->Nodes, mesh->FaceElements, S, rhs,
760                          &_d, 0, &_y);              escript::Data(), escript::Data(), escript::Data(), d,
761                escript::Data(), y);
762      checkFinleyError();      checkFinleyError();
763    
764      Finley_Assemble_PDE(mesh->Nodes, mesh->ContactElements, S, &_rhs, 0, 0, 0,      Assemble_PDE(mesh->Nodes, mesh->ContactElements, S, rhs,
765              &_d_contact, 0, &_y_contact);              escript::Data(), escript::Data(), escript::Data(), d_contact,
766                escript::Data(), y_contact);
767      checkFinleyError();      checkFinleyError();
768    
769      Finley_Assemble_PDE(mesh->Nodes, mesh->Points, S, &_rhs, 0, 0, 0,      Assemble_PDE(mesh->Nodes, mesh->Points, S, rhs, escript::Data(),
770                          &_d_dirac, 0, &_y_dirac );              escript::Data(), escript::Data(), d_dirac, escript::Data(), y_dirac);
771      checkFinleyError();      checkFinleyError();
772  }  }
773    
# Line 799  void MeshAdapter::addPDEToLumpedSystem(e Line 775  void MeshAdapter::addPDEToLumpedSystem(e
775          const escript::Data& D, const escript::Data& d,          const escript::Data& D, const escript::Data& d,
776          const escript::Data& d_dirac, const bool useHRZ) const          const escript::Data& d_dirac, const bool useHRZ) const
777  {  {
     escriptDataC _mat=mat.getDataC();  
     escriptDataC _D=D.getDataC();  
     escriptDataC _d=d.getDataC();  
     escriptDataC _d_dirac=d_dirac.getDataC();  
   
778      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
779        Assemble_LumpedSystem(mesh->Nodes, mesh->Elements, mat, D, useHRZ);
     Finley_Assemble_LumpedSystem(mesh->Nodes, mesh->Elements, &_mat, &_D, useHRZ);  
780      checkFinleyError();      checkFinleyError();
781    
782      Finley_Assemble_LumpedSystem(mesh->Nodes, mesh->FaceElements, &_mat, &_d, useHRZ);      Assemble_LumpedSystem(mesh->Nodes, mesh->FaceElements, mat, d, useHRZ);
783      checkFinleyError();      checkFinleyError();
784    
785      Finley_Assemble_LumpedSystem(mesh->Nodes, mesh->Points, &_mat, &_d_dirac, useHRZ);      Assemble_LumpedSystem(mesh->Nodes, mesh->Points, mat, d_dirac, useHRZ);
786      checkFinleyError();      checkFinleyError();
787  }  }
788    
# Line 824  void MeshAdapter::addPDEToRHS(escript::D Line 794  void MeshAdapter::addPDEToRHS(escript::D
794          const escript::Data& y_contact, const escript::Data& y_dirac) const          const escript::Data& y_contact, const escript::Data& y_dirac) const
795  {  {
796      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
797        Assemble_PDE(mesh->Nodes, mesh->Elements, 0, rhs,
798      escriptDataC _rhs=rhs.getDataC();              escript::Data(), escript::Data(), escript::Data(), escript::Data(),
799      escriptDataC _X=X.getDataC();              X, Y);
     escriptDataC _Y=Y.getDataC();  
     escriptDataC _y=y.getDataC();  
     escriptDataC _y_contact=y_contact.getDataC();  
     escriptDataC _y_dirac=y_dirac.getDataC();  
   
     Finley_Assemble_PDE(mesh->Nodes,mesh->Elements, 0, &_rhs, 0, 0, 0, 0, &_X, &_Y);  
800      checkFinleyError();      checkFinleyError();
801    
802      Finley_Assemble_PDE(mesh->Nodes,mesh->FaceElements, 0, &_rhs, 0, 0, 0, 0, 0, &_y);      Assemble_PDE(mesh->Nodes, mesh->FaceElements, 0, rhs,
803                escript::Data(), escript::Data(), escript::Data(), escript::Data(),
804                escript::Data(), y);
805      checkFinleyError();      checkFinleyError();
806    
807      Finley_Assemble_PDE(mesh->Nodes,mesh->ContactElements, 0, &_rhs, 0, 0, 0, 0, 0, &_y_contact);      Assemble_PDE(mesh->Nodes, mesh->ContactElements, 0, rhs,
808                escript::Data(), escript::Data(), escript::Data(),
809                escript::Data(), escript::Data(), y_contact);
810      checkFinleyError();      checkFinleyError();
811    
812      Finley_Assemble_PDE(mesh->Nodes,mesh->Points, 0, &_rhs, 0, 0, 0, 0, 0, &_y_dirac);      Assemble_PDE(mesh->Nodes, mesh->Points, 0, rhs,
813                escript::Data(), escript::Data(), escript::Data(), escript::Data(),
814                escript::Data(), y_dirac);
815      checkFinleyError();      checkFinleyError();
816  }  }
817    
# Line 861  void MeshAdapter::addPDEToTransportProbl Line 831  void MeshAdapter::addPDEToTransportProbl
831          throw FinleyAdapterException("finley only supports Paso transport problems.");          throw FinleyAdapterException("finley only supports Paso transport problems.");
832    
833      source.expand();      source.expand();
     escriptDataC _source=source.getDataC();  
     escriptDataC _M=M.getDataC();  
     escriptDataC _A=A.getDataC();  
     escriptDataC _B=B.getDataC();  
     escriptDataC _C=C.getDataC();  
     escriptDataC _D=D.getDataC();  
     escriptDataC _X=X.getDataC();  
     escriptDataC _Y=Y.getDataC();  
     escriptDataC _d=d.getDataC();  
     escriptDataC _y=y.getDataC();  
     escriptDataC _d_contact=d_contact.getDataC();  
     escriptDataC _y_contact=y_contact.getDataC();  
     escriptDataC _d_dirac=d_dirac.getDataC();  
     escriptDataC _y_dirac=y_dirac.getDataC();  
834    
835      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
836      Paso_TransportProblem* _tp = tpa->getPaso_TransportProblem();      Paso_TransportProblem* _tp = tpa->getPaso_TransportProblem();
837    
838      Finley_Assemble_PDE(mesh->Nodes, mesh->Elements, _tp->mass_matrix,      Assemble_PDE(mesh->Nodes, mesh->Elements, _tp->mass_matrix, source,
839                          &_source, 0, 0, 0, &_M, 0, 0);                          escript::Data(), escript::Data(), escript::Data(),
840                            M, escript::Data(), escript::Data());
841      checkFinleyError();      checkFinleyError();
842    
843      Finley_Assemble_PDE(mesh->Nodes, mesh->Elements, _tp->transport_matrix,      Assemble_PDE(mesh->Nodes, mesh->Elements, _tp->transport_matrix,
844                          &_source, &_A, &_B, &_C, &_D, &_X, &_Y);                          source, A, B, C, D, X, Y);
845      checkFinleyError();      checkFinleyError();
846    
847      Finley_Assemble_PDE(mesh->Nodes, mesh->FaceElements, _tp->transport_matrix,      Assemble_PDE(mesh->Nodes, mesh->FaceElements, _tp->transport_matrix,
848                          &_source, 0, 0, 0, &_d, 0, &_y);                          source, escript::Data(), escript::Data(),
849                            escript::Data(), d, escript::Data(), y);
850      checkFinleyError();      checkFinleyError();
851    
852      Finley_Assemble_PDE(mesh->Nodes, mesh->ContactElements,      Assemble_PDE(mesh->Nodes, mesh->ContactElements,
853                          _tp->transport_matrix, &_source, 0, 0, 0, &_d_contact, 0, &_y_contact);                          _tp->transport_matrix, source, escript::Data(),
854                            escript::Data(), escript::Data(), d_contact,
855                            escript::Data(), y_contact);
856      checkFinleyError();      checkFinleyError();
857    
858      Finley_Assemble_PDE(mesh->Nodes, mesh->Points, _tp->transport_matrix,      Assemble_PDE(mesh->Nodes, mesh->Points, _tp->transport_matrix,
859                          &_source, 0, 0, 0, &_d_dirac, 0, &_y_dirac);                          source, escript::Data(), escript::Data(),
860                            escript::Data(), d_dirac, escript::Data(), y_dirac);
861      checkFinleyError();      checkFinleyError();
862  }  }
863    
# Line 913  void MeshAdapter::interpolateOnDomain(es Line 874  void MeshAdapter::interpolateOnDomain(es
874          throw FinleyAdapterException("Error - Illegal domain of interpolation target.");          throw FinleyAdapterException("Error - Illegal domain of interpolation target.");
875    
876      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     escriptDataC _target=target.getDataC();  
     escriptDataC _in=in.getDataC();  
877      switch(in.getFunctionSpace().getTypeCode()) {      switch(in.getFunctionSpace().getTypeCode()) {
878          case Nodes:          case Nodes:
879              switch(target.getFunctionSpace().getTypeCode()) {              switch(target.getFunctionSpace().getTypeCode()) {
# Line 922  void MeshAdapter::interpolateOnDomain(es Line 881  void MeshAdapter::interpolateOnDomain(es
881                  case ReducedNodes:                  case ReducedNodes:
882                  case DegreesOfFreedom:                  case DegreesOfFreedom:
883                  case ReducedDegreesOfFreedom:                  case ReducedDegreesOfFreedom:
884                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                      Assemble_CopyNodalData(mesh->Nodes, target, in);
885                      break;                      break;
886                  case Elements:                  case Elements:
887                  case ReducedElements:                  case ReducedElements:
888                      Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->Elements, in,target);
889                      break;                      break;
890                  case FaceElements:                  case FaceElements:
891                  case ReducedFaceElements:                  case ReducedFaceElements:
892                      Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->FaceElements, in, target);
893                      break;                      break;
894                  case Points:                  case Points:
895                      Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->Points, in, target);
896                      break;                      break;
897                  case ContactElementsZero:                  case ContactElementsZero:
898                  case ReducedContactElementsZero:                  case ReducedContactElementsZero:
899                  case ContactElementsOne:                  case ContactElementsOne:
900                  case ReducedContactElementsOne:                  case ReducedContactElementsOne:
901                      Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->ContactElements, in, target);
902                      break;                      break;
903                  default:                  default:
904                      stringstream temp;                      stringstream temp;
# Line 954  void MeshAdapter::interpolateOnDomain(es Line 913  void MeshAdapter::interpolateOnDomain(es
913                  case ReducedNodes:                  case ReducedNodes:
914                  case DegreesOfFreedom:                  case DegreesOfFreedom:
915                  case ReducedDegreesOfFreedom:                  case ReducedDegreesOfFreedom:
916                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                      Assemble_CopyNodalData(mesh->Nodes, target, in);
917                      break;                      break;
918                  case Elements:                  case Elements:
919                  case ReducedElements:                  case ReducedElements:
920                      Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->Elements, in, target);
921                      break;                      break;
922                  case FaceElements:                  case FaceElements:
923                  case ReducedFaceElements:                  case ReducedFaceElements:
924                      Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->FaceElements, in, target);
925                      break;                      break;
926                  case Points:                  case Points:
927                      Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->Points, in, target);
928                      break;                      break;
929                  case ContactElementsZero:                  case ContactElementsZero:
930                  case ReducedContactElementsZero:                  case ReducedContactElementsZero:
931                      Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);                  case ContactElementsOne:
932                    case ReducedContactElementsOne:
933                        Assemble_interpolate(mesh->Nodes, mesh->ContactElements, in, target);
934                      break;                      break;
935                  default:                  default:
936                      stringstream temp;                      stringstream temp;
# Line 980  void MeshAdapter::interpolateOnDomain(es Line 941  void MeshAdapter::interpolateOnDomain(es
941              break;              break;
942          case Elements:          case Elements:
943              if (target.getFunctionSpace().getTypeCode()==Elements) {              if (target.getFunctionSpace().getTypeCode()==Elements) {
944                  Finley_Assemble_CopyElementData(mesh->Elements,&_target,&_in);                  Assemble_CopyElementData(mesh->Elements, target, in);
945              } else if (target.getFunctionSpace().getTypeCode()==ReducedElements) {              } else if (target.getFunctionSpace().getTypeCode()==ReducedElements) {
946                  Finley_Assemble_AverageElementData(mesh->Elements,&_target,&_in);                  Assemble_AverageElementData(mesh->Elements, target, in);
947              } else {              } else {
948                  throw FinleyAdapterException("Error - No interpolation with data on elements possible.");                  throw FinleyAdapterException("Error - No interpolation with data on elements possible.");
949              }              }
950              break;              break;
951          case ReducedElements:          case ReducedElements:
952              if (target.getFunctionSpace().getTypeCode()==ReducedElements) {              if (target.getFunctionSpace().getTypeCode()==ReducedElements) {
953                  Finley_Assemble_CopyElementData(mesh->Elements,&_target,&_in);                  Assemble_CopyElementData(mesh->Elements, target, in);
954              } else {              } else {
955                  throw FinleyAdapterException("Error - No interpolation with data on elements with reduced integration order possible.");                  throw FinleyAdapterException("Error - No interpolation with data on elements with reduced integration order possible.");
956              }              }
957              break;              break;
958          case FaceElements:          case FaceElements:
959              if (target.getFunctionSpace().getTypeCode()==FaceElements) {              if (target.getFunctionSpace().getTypeCode()==FaceElements) {
960                  Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);                  Assemble_CopyElementData(mesh->FaceElements, target, in);
961              } else if (target.getFunctionSpace().getTypeCode()==ReducedFaceElements) {              } else if (target.getFunctionSpace().getTypeCode()==ReducedFaceElements) {
962                  Finley_Assemble_AverageElementData(mesh->FaceElements,&_target,&_in);                  Assemble_AverageElementData(mesh->FaceElements, target, in);
963              } else {              } else {
964                  throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");                  throw FinleyAdapterException("Error - No interpolation with data on face elements possible.");
965              }              }
966              break;              break;
967          case ReducedFaceElements:          case ReducedFaceElements:
968              if (target.getFunctionSpace().getTypeCode()==ReducedFaceElements) {              if (target.getFunctionSpace().getTypeCode()==ReducedFaceElements) {
969                  Finley_Assemble_CopyElementData(mesh->FaceElements,&_target,&_in);                  Assemble_CopyElementData(mesh->FaceElements, target, in);
970              } else {              } else {
971                  throw FinleyAdapterException("Error - No interpolation with data on face elements with reduced integration order possible.");                  throw FinleyAdapterException("Error - No interpolation with data on face elements with reduced integration order possible.");
972              }              }
973              break;              break;
974          case Points:          case Points:
975              if (target.getFunctionSpace().getTypeCode()==Points) {              if (target.getFunctionSpace().getTypeCode()==Points) {
976                  Finley_Assemble_CopyElementData(mesh->Points,&_target,&_in);                  Assemble_CopyElementData(mesh->Points, target, in);
977              } else {              } else {
978                  throw FinleyAdapterException("Error - No interpolation with data on points possible.");                  throw FinleyAdapterException("Error - No interpolation with data on points possible.");
979              }              }
# Line 1020  void MeshAdapter::interpolateOnDomain(es Line 981  void MeshAdapter::interpolateOnDomain(es
981          case ContactElementsZero:          case ContactElementsZero:
982          case ContactElementsOne:          case ContactElementsOne:
983              if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {              if (target.getFunctionSpace().getTypeCode()==ContactElementsZero || target.getFunctionSpace().getTypeCode()==ContactElementsOne) {
984                  Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);                  Assemble_CopyElementData(mesh->ContactElements, target, in);
985              } else if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {              } else if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {
986                  Finley_Assemble_AverageElementData(mesh->ContactElements,&_target,&_in);                  Assemble_AverageElementData(mesh->ContactElements, target, in);
987              } else {              } else {
988                  throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");                  throw FinleyAdapterException("Error - No interpolation with data on contact elements possible.");
989              }              }
# Line 1030  void MeshAdapter::interpolateOnDomain(es Line 991  void MeshAdapter::interpolateOnDomain(es
991          case ReducedContactElementsZero:          case ReducedContactElementsZero:
992          case ReducedContactElementsOne:          case ReducedContactElementsOne:
993              if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {              if (target.getFunctionSpace().getTypeCode()==ReducedContactElementsZero || target.getFunctionSpace().getTypeCode()==ReducedContactElementsOne) {
994                  Finley_Assemble_CopyElementData(mesh->ContactElements,&_target,&_in);                  Assemble_CopyElementData(mesh->ContactElements, target, in);
995              } else {              } else {
996                  throw FinleyAdapterException("Error - No interpolation with data on contact elements with reduced integration order possible.");                  throw FinleyAdapterException("Error - No interpolation with data on contact elements with reduced integration order possible.");
997              }              }
# Line 1039  void MeshAdapter::interpolateOnDomain(es Line 1000  void MeshAdapter::interpolateOnDomain(es
1000              switch(target.getFunctionSpace().getTypeCode()) {              switch(target.getFunctionSpace().getTypeCode()) {
1001                  case ReducedDegreesOfFreedom:                  case ReducedDegreesOfFreedom:
1002                  case DegreesOfFreedom:                  case DegreesOfFreedom:
1003                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                      Assemble_CopyNodalData(mesh->Nodes, target, in);
1004                      break;                      break;
1005    
1006                  case Nodes:                  case Nodes:
1007                  case ReducedNodes:                  case ReducedNodes:
1008                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1009                          escript::Data temp=escript::Data(in);                          escript::Data in2=escript::Data(in);
1010                          temp.expand();                          in2.expand();
1011                          escriptDataC _in2 = temp.getDataC();                          Assemble_CopyNodalData(mesh->Nodes, target, in2);
                         Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in2);  
1012                      } else {                      } else {
1013                          Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                          Assemble_CopyNodalData(mesh->Nodes, target, in);
1014                      }                      }
1015                      break;                      break;
1016                  case Elements:                  case Elements:
1017                  case ReducedElements:                  case ReducedElements:
1018                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1019                          escript::Data temp=escript::Data(in, continuousFunction(*this));                          escript::Data in2=escript::Data(in, continuousFunction(*this));
1020                          escriptDataC _in2 = temp.getDataC();                          Assemble_interpolate(mesh->Nodes, mesh->Elements, in2, target);
                         Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in2,&_target);  
1021                      } else {                      } else {
1022                          Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->Elements, in, target);
1023                      }                      }
1024                      break;                      break;
1025                  case FaceElements:                  case FaceElements:
1026                  case ReducedFaceElements:                  case ReducedFaceElements:
1027                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1028                          escript::Data temp=escript::Data(in, continuousFunction(*this));                          escript::Data in2=escript::Data(in, continuousFunction(*this));
1029                          escriptDataC _in2 = temp.getDataC();                          Assemble_interpolate(mesh->Nodes, mesh->FaceElements, in2, target);
                         Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in2,&_target);  
1030                      } else {                      } else {
1031                          Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->FaceElements, in, target);
1032                      }                      }
1033                      break;                      break;
1034                  case Points:                  case Points:
1035                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1036                          //escript::Data temp=escript::Data(in, continuousFunction(*this) );                          //escript::Data in2=escript::Data(in, continuousFunction(*this) );
                         //escriptDataC _in2 = temp.getDataC();  
1037                      } else {                      } else {
1038                          Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->Points, in, target);
1039                      }                      }
1040                      break;                      break;
1041                  case ContactElementsZero:                  case ContactElementsZero:
# Line 1086  void MeshAdapter::interpolateOnDomain(es Line 1043  void MeshAdapter::interpolateOnDomain(es
1043                  case ReducedContactElementsZero:                  case ReducedContactElementsZero:
1044                  case ReducedContactElementsOne:                  case ReducedContactElementsOne:
1045                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1046                          escript::Data temp=escript::Data(in, continuousFunction(*this));                          escript::Data in2=escript::Data(in, continuousFunction(*this));
1047                          escriptDataC _in2 = temp.getDataC();                          Assemble_interpolate(mesh->Nodes, mesh->ContactElements, in2, target);
                         Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in2,&_target);  
1048                      } else {                      } else {
1049                          Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->ContactElements, in, target);
1050                      }                      }
1051                      break;                      break;
1052                  default:                  default:
1053                      stringstream temp;                      stringstream temp;
1054                      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();
1055                      throw FinleyAdapterException(temp.str());                      throw FinleyAdapterException(temp.str());
                     break;  
1056              }              }
1057              break;              break;
1058          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
1059              switch(target.getFunctionSpace().getTypeCode()) {              switch(target.getFunctionSpace().getTypeCode()) {
1060                  case Nodes:                  case Nodes:
1061                      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.");
                     break;  
1062                  case ReducedNodes:                  case ReducedNodes:
1063                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1064                          escript::Data temp=escript::Data(in);                          escript::Data in2=escript::Data(in);
1065                          temp.expand();                          in2.expand();
1066                          escriptDataC _in2 = temp.getDataC();                          Assemble_CopyNodalData(mesh->Nodes, target, in2);
                         Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in2);  
1067                      } else {                      } else {
1068                          Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                          Assemble_CopyNodalData(mesh->Nodes, target, in);
1069                      }                      }
1070                      break;                      break;
1071                  case DegreesOfFreedom:                  case DegreesOfFreedom:
1072                      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");
1073                      break;                      break;
1074                  case ReducedDegreesOfFreedom:                  case ReducedDegreesOfFreedom:
1075                      Finley_Assemble_CopyNodalData(mesh->Nodes,&_target,&_in);                      Assemble_CopyNodalData(mesh->Nodes, target, in);
1076                      break;                      break;
1077                  case Elements:                  case Elements:
1078                  case ReducedElements:                  case ReducedElements:
1079                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1080                          escript::Data temp=escript::Data(in, reducedContinuousFunction(*this) );                          escript::Data in2=escript::Data(in, reducedContinuousFunction(*this) );
1081                          escriptDataC _in2 = temp.getDataC();                          Assemble_interpolate(mesh->Nodes, mesh->Elements, in2, target);
                         Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in2,&_target);  
1082                      } else {                      } else {
1083                          Finley_Assemble_interpolate(mesh->Nodes,mesh->Elements,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->Elements, in, target);
1084                      }                      }
1085                      break;                      break;
1086                  case FaceElements:                  case FaceElements:
1087                  case ReducedFaceElements:                  case ReducedFaceElements:
1088                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1089                          escript::Data temp=escript::Data(in, reducedContinuousFunction(*this) );                          escript::Data in2=escript::Data(in, reducedContinuousFunction(*this) );
1090                          escriptDataC _in2 = temp.getDataC();                          Assemble_interpolate(mesh->Nodes, mesh->FaceElements, in2, target);
                         Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in2,&_target);  
1091                      } else {                      } else {
1092                          Finley_Assemble_interpolate(mesh->Nodes,mesh->FaceElements,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->FaceElements, in, target);
1093                      }                      }
1094                      break;                      break;
1095                  case Points:                  case Points:
1096                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1097                          escript::Data temp=escript::Data(in, reducedContinuousFunction(*this));                          escript::Data in2=escript::Data(in, reducedContinuousFunction(*this));
1098                          escriptDataC _in2 = temp.getDataC();                          Assemble_interpolate(mesh->Nodes, mesh->Points, in2, target);
                         Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in2,&_target);  
1099                      } else {                      } else {
1100                          Finley_Assemble_interpolate(mesh->Nodes,mesh->Points,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->Points, in, target);
1101                      }                      }
1102                      break;                      break;
1103                  case ContactElementsZero:                  case ContactElementsZero:
# Line 1155  void MeshAdapter::interpolateOnDomain(es Line 1105  void MeshAdapter::interpolateOnDomain(es
1105                  case ReducedContactElementsZero:                  case ReducedContactElementsZero:
1106                  case ReducedContactElementsOne:                  case ReducedContactElementsOne:
1107                      if (getMPISize()>1) {                      if (getMPISize()>1) {
1108                          escript::Data temp=escript::Data(in, reducedContinuousFunction(*this));                          escript::Data in2=escript::Data(in, reducedContinuousFunction(*this));
1109                          escriptDataC _in2 = temp.getDataC();                          Assemble_interpolate(mesh->Nodes, mesh->ContactElements, in2, target);
                         Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in2,&_target);  
1110                      } else {                      } else {
1111                          Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);                          Assemble_interpolate(mesh->Nodes, mesh->ContactElements, in, target);
1112                      }                      }
1113                      break;                      break;
1114                  default:                  default:
# Line 1189  void MeshAdapter::setToX(escript::Data& Line 1138  void MeshAdapter::setToX(escript::Data&
1138      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
1139      // in case of appropriate function space we can do the job directly:      // in case of appropriate function space we can do the job directly:
1140      if (arg.getFunctionSpace().getTypeCode()==Nodes) {      if (arg.getFunctionSpace().getTypeCode()==Nodes) {
1141          escriptDataC _arg=arg.getDataC();          Assemble_NodeCoordinates(mesh->Nodes, arg);
         Finley_Assemble_NodeCoordinates(mesh->Nodes, &_arg);  
1142      } else {      } else {
1143          escript::Data tmp_data=Vector(0., continuousFunction(*this), true);          escript::Data tmp_data=Vector(0., continuousFunction(*this), true);
1144          escriptDataC _tmp_data=tmp_data.getDataC();          Assemble_NodeCoordinates(mesh->Nodes, tmp_data);
         Finley_Assemble_NodeCoordinates(mesh->Nodes, &_tmp_data);  
1145          // this is then interpolated onto arg:          // this is then interpolated onto arg:
1146          interpolateOnDomain(arg, tmp_data);          interpolateOnDomain(arg, tmp_data);
1147      }      }
# Line 1210  void MeshAdapter::setToNormal(escript::D Line 1157  void MeshAdapter::setToNormal(escript::D
1157      if (normalDomain!=*this)      if (normalDomain!=*this)
1158          throw FinleyAdapterException("Error - Illegal domain of normal locations");          throw FinleyAdapterException("Error - Illegal domain of normal locations");
1159      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     escriptDataC _normal=normal.getDataC();  
1160      switch(normal.getFunctionSpace().getTypeCode()) {      switch(normal.getFunctionSpace().getTypeCode()) {
1161          case Nodes:          case Nodes:
1162              throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");              throw FinleyAdapterException("Error - Finley does not support surface normal vectors for nodes");
# Line 1226  void MeshAdapter::setToNormal(escript::D Line 1172  void MeshAdapter::setToNormal(escript::D
1172              break;              break;
1173          case FaceElements:          case FaceElements:
1174          case ReducedFaceElements:          case ReducedFaceElements:
1175              Finley_Assemble_setNormal(mesh->Nodes,mesh->FaceElements,&_normal);              Assemble_setNormal(mesh->Nodes, mesh->FaceElements, normal);
1176              break;              break;
1177          case Points:          case Points:
1178              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");
# Line 1235  void MeshAdapter::setToNormal(escript::D Line 1181  void MeshAdapter::setToNormal(escript::D
1181          case ContactElementsZero:          case ContactElementsZero:
1182          case ReducedContactElementsOne:          case ReducedContactElementsOne:
1183          case ReducedContactElementsZero:          case ReducedContactElementsZero:
1184              Finley_Assemble_setNormal(mesh->Nodes,mesh->ContactElements,&_normal);              Assemble_setNormal(mesh->Nodes, mesh->ContactElements, normal);
1185              break;              break;
1186          case DegreesOfFreedom:          case DegreesOfFreedom:
1187              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 1255  void MeshAdapter::setToNormal(escript::D Line 1201  void MeshAdapter::setToNormal(escript::D
1201  //  //
1202  // interpolates data to other domain  // interpolates data to other domain
1203  //  //
1204  void MeshAdapter::interpolateACross(escript::Data& target,const escript::Data& source) const  void MeshAdapter::interpolateACross(escript::Data& target, const escript::Data& source) const
1205  {  {
1206      escript::const_Domain_ptr targetDomain_p=target.getFunctionSpace().getDomain();      throw FinleyAdapterException("Error - Finley does not allow interpolation across domains.");
     const MeshAdapter* targetDomain=dynamic_cast<const MeshAdapter*>(targetDomain_p.get());  
     if (targetDomain!=this)  
         throw FinleyAdapterException("Error - Illegal domain of interpolation target");  
   
     throw FinleyAdapterException("Error - Finley does not allow interpolation across domains yet.");  
1207  }  }
1208    
1209  //  //
# Line 1276  void MeshAdapter::setToIntegrals(vector< Line 1217  void MeshAdapter::setToIntegrals(vector<
1217    
1218      double blocktimer_start = blocktimer_time();      double blocktimer_start = blocktimer_time();
1219      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     escriptDataC _temp;  
     escript::Data temp;  
     escriptDataC _arg=arg.getDataC();  
1220      switch(arg.getFunctionSpace().getTypeCode()) {      switch(arg.getFunctionSpace().getTypeCode()) {
1221          case Nodes:          case Nodes:
1222              temp=escript::Data(arg, escript::function(*this));              {
1223              _temp=temp.getDataC();                  escript::Data temp(arg, escript::function(*this));
1224              Finley_Assemble_integrate(mesh->Nodes, mesh->Elements, &_temp, &integrals[0]);                  Assemble_integrate(mesh->Nodes, mesh->Elements, temp, &integrals[0]);
1225                }
1226              break;              break;
1227          case ReducedNodes:          case ReducedNodes:
1228              temp=escript::Data( arg, escript::function(*this) );              {
1229              _temp=temp.getDataC();                  escript::Data temp(arg, escript::function(*this));
1230              Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_temp,&integrals[0]);                  Assemble_integrate(mesh->Nodes, mesh->Elements, temp, &integrals[0]);
1231                }
1232              break;              break;
1233          case Elements:          case Elements:
1234          case ReducedElements:          case ReducedElements:
1235              Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_arg,&integrals[0]);              Assemble_integrate(mesh->Nodes, mesh->Elements, arg, &integrals[0]);
1236              break;              break;
1237          case FaceElements:          case FaceElements:
1238          case ReducedFaceElements:          case ReducedFaceElements:
1239              Finley_Assemble_integrate(mesh->Nodes,mesh->FaceElements,&_arg,&integrals[0]);              Assemble_integrate(mesh->Nodes, mesh->FaceElements, arg, &integrals[0]);
1240              break;              break;
1241          case Points:          case Points:
1242              throw FinleyAdapterException("Error - Integral of data on points is not supported.");              throw FinleyAdapterException("Error - Integral of data on points is not supported.");
# Line 1305  void MeshAdapter::setToIntegrals(vector< Line 1245  void MeshAdapter::setToIntegrals(vector<
1245          case ReducedContactElementsZero:          case ReducedContactElementsZero:
1246          case ContactElementsOne:          case ContactElementsOne:
1247          case ReducedContactElementsOne:          case ReducedContactElementsOne:
1248              Finley_Assemble_integrate(mesh->Nodes,mesh->ContactElements,&_arg,&integrals[0]);              Assemble_integrate(mesh->Nodes, mesh->ContactElements, arg, &integrals[0]);
1249              break;              break;
1250          case DegreesOfFreedom:          case DegreesOfFreedom:
1251          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
1252              temp=escript::Data(arg, escript::function(*this));              {
1253              _temp=temp.getDataC();                  escript::Data temp(arg, escript::function(*this));
1254              Finley_Assemble_integrate(mesh->Nodes,mesh->Elements,&_temp,&integrals[0]);                  Assemble_integrate(mesh->Nodes, mesh->Elements, temp, &integrals[0]);
1255                }
1256              break;              break;
1257          default:          default:
1258              stringstream temp;              stringstream temp;
# Line 1336  void MeshAdapter::setToGradient(escript: Line 1277  void MeshAdapter::setToGradient(escript:
1277          throw FinleyAdapterException("Error - Illegal domain of gradient");          throw FinleyAdapterException("Error - Illegal domain of gradient");
1278    
1279      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
1280      escriptDataC _grad=grad.getDataC();      escript::Data nodeData;
     escriptDataC nodeDataC;  
     escript::Data temp;  
1281      if (getMPISize()>1) {      if (getMPISize()>1) {
1282          if (arg.getFunctionSpace().getTypeCode() == DegreesOfFreedom) {          if (arg.getFunctionSpace().getTypeCode() == DegreesOfFreedom) {
1283              temp=escript::Data(arg, continuousFunction(*this));              nodeData=escript::Data(arg, continuousFunction(*this));
             nodeDataC = temp.getDataC();  
1284          } else if(arg.getFunctionSpace().getTypeCode() == ReducedDegreesOfFreedom) {          } else if(arg.getFunctionSpace().getTypeCode() == ReducedDegreesOfFreedom) {
1285              temp=escript::Data(arg, reducedContinuousFunction(*this));              nodeData=escript::Data(arg, reducedContinuousFunction(*this));
             nodeDataC = temp.getDataC();  
1286          } else {          } else {
1287              nodeDataC = arg.getDataC();              nodeData = arg;
1288          }          }
1289      } else {      } else {
1290          nodeDataC = arg.getDataC();          nodeData = arg;
1291      }      }
1292      switch(grad.getFunctionSpace().getTypeCode()) {      switch(grad.getFunctionSpace().getTypeCode()) {
1293          case Nodes:          case Nodes:
# Line 1361  void MeshAdapter::setToGradient(escript: Line 1298  void MeshAdapter::setToGradient(escript:
1298              break;              break;
1299          case Elements:          case Elements:
1300          case ReducedElements:          case ReducedElements:
1301              Finley_Assemble_gradient(mesh->Nodes,mesh->Elements,&_grad,&nodeDataC);              Assemble_gradient(mesh->Nodes, mesh->Elements, grad, nodeData);
1302              break;              break;
1303          case FaceElements:          case FaceElements:
1304          case ReducedFaceElements:          case ReducedFaceElements:
1305              Finley_Assemble_gradient(mesh->Nodes,mesh->FaceElements,&_grad,&nodeDataC);              Assemble_gradient(mesh->Nodes, mesh->FaceElements, grad, nodeData);
1306              break;              break;
1307          case Points:          case Points:
1308              throw FinleyAdapterException("Error - Gradient at points is not supported.");              throw FinleyAdapterException("Error - Gradient at points is not supported.");
# Line 1374  void MeshAdapter::setToGradient(escript: Line 1311  void MeshAdapter::setToGradient(escript:
1311          case ReducedContactElementsZero:          case ReducedContactElementsZero:
1312          case ContactElementsOne:          case ContactElementsOne:
1313          case ReducedContactElementsOne:          case ReducedContactElementsOne:
1314              Finley_Assemble_gradient(mesh->Nodes,mesh->ContactElements,&_grad,&nodeDataC);              Assemble_gradient(mesh->Nodes, mesh->ContactElements, grad, nodeData);
1315              break;              break;
1316          case DegreesOfFreedom:          case DegreesOfFreedom:
1317              throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");              throw FinleyAdapterException("Error - Gradient at degrees of freedom is not supported.");
# Line 1397  void MeshAdapter::setToGradient(escript: Line 1334  void MeshAdapter::setToGradient(escript:
1334  void MeshAdapter::setToSize(escript::Data& size) const  void MeshAdapter::setToSize(escript::Data& size) const
1335  {  {
1336      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     escriptDataC tmp=size.getDataC();  
1337      switch(size.getFunctionSpace().getTypeCode()) {      switch(size.getFunctionSpace().getTypeCode()) {
1338          case Nodes:          case Nodes:
1339              throw FinleyAdapterException("Error - Size of nodes is not supported.");              throw FinleyAdapterException("Error - Size of nodes is not supported.");
# Line 1407  void MeshAdapter::setToSize(escript::Dat Line 1343  void MeshAdapter::setToSize(escript::Dat
1343              break;              break;
1344          case Elements:          case Elements:
1345          case ReducedElements:          case ReducedElements:
1346              Finley_Assemble_getSize(mesh->Nodes,mesh->Elements,&tmp);              Assemble_getSize(mesh->Nodes, mesh->Elements, size);
1347              break;              break;
1348          case FaceElements:          case FaceElements:
1349          case ReducedFaceElements:          case ReducedFaceElements:
1350              Finley_Assemble_getSize(mesh->Nodes,mesh->FaceElements,&tmp);              Assemble_getSize(mesh->Nodes, mesh->FaceElements, size);
1351              break;              break;
1352          case Points:          case Points:
1353              throw FinleyAdapterException("Error - Size of point elements is not supported.");              throw FinleyAdapterException("Error - Size of point elements is not supported.");
# Line 1420  void MeshAdapter::setToSize(escript::Dat Line 1356  void MeshAdapter::setToSize(escript::Dat
1356          case ContactElementsOne:          case ContactElementsOne:
1357          case ReducedContactElementsZero:          case ReducedContactElementsZero:
1358          case ReducedContactElementsOne:          case ReducedContactElementsOne:
1359              Finley_Assemble_getSize(mesh->Nodes,mesh->ContactElements,&tmp);              Assemble_getSize(mesh->Nodes,mesh->ContactElements,size);
1360              break;              break;
1361          case DegreesOfFreedom:          case DegreesOfFreedom:
1362              throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");              throw FinleyAdapterException("Error - Size of degrees of freedom is not supported.");
# Line 1443  void MeshAdapter::setToSize(escript::Dat Line 1379  void MeshAdapter::setToSize(escript::Dat
1379  void MeshAdapter::setNewX(const escript::Data& new_x)  void MeshAdapter::setNewX(const escript::Data& new_x)
1380  {  {
1381      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     escriptDataC tmp;  
1382      const MeshAdapter& newDomain=dynamic_cast<const MeshAdapter&>(*(new_x.getFunctionSpace().getDomain()));      const MeshAdapter& newDomain=dynamic_cast<const MeshAdapter&>(*(new_x.getFunctionSpace().getDomain()));
1383      if (newDomain!=*this)      if (newDomain!=*this)
1384          throw FinleyAdapterException("Error - Illegal domain of new point locations");          throw FinleyAdapterException("Error - Illegal domain of new point locations");
1385      if (new_x.getFunctionSpace() == continuousFunction(*this)) {      if (new_x.getFunctionSpace() == continuousFunction(*this)) {
1386          tmp = new_x.getDataC();          Finley_Mesh_setCoordinates(mesh, new_x);
         Finley_Mesh_setCoordinates(mesh,&tmp);  
1387      } else {      } else {
1388          throw FinleyAdapterException("As of escript version 3.3 SetX() only accepts ContinuousFunction arguments. Please interpolate.");          throw FinleyAdapterException("As of escript version 3.3 SetX() only accepts ContinuousFunction arguments. Please interpolate.");
         //escript::Data new_x_inter=escript::Data( new_x,  continuousFunction(*this) );  
         //tmp = new_x_inter.getDataC();  
         //Finley_Mesh_setCoordinates(mesh,&tmp);  
1389      }      }
1390      checkFinleyError();      checkFinleyError();
1391  }  }
# Line 1463  bool MeshAdapter::ownSample(int fs_code, Line 1394  bool MeshAdapter::ownSample(int fs_code,
1394  {  {
1395      if (getMPISize() > 1) {      if (getMPISize() > 1) {
1396  #ifdef ESYS_MPI  #ifdef ESYS_MPI
1397          index_t myFirstNode=0, myLastNode=0, k=0;          int myFirstNode=0, myLastNode=0, k=0;
1398          index_t* globalNodeIndex=0;          int* globalNodeIndex=0;
1399          Finley_Mesh* mesh_p=m_finleyMesh.get();          Finley_Mesh* mesh_p=m_finleyMesh.get();
1400          /*          /*
1401           * this method is only used by saveDataCSV which would use the returned           * this method is only used by saveDataCSV which would use the returned
# Line 1476  bool MeshAdapter::ownSample(int fs_code, Line 1407  bool MeshAdapter::ownSample(int fs_code,
1407          } else          } else
1408          */          */
1409          if (fs_code == FINLEY_NODES) {          if (fs_code == FINLEY_NODES) {
1410              myFirstNode = Finley_NodeFile_getFirstNode(mesh_p->Nodes);              myFirstNode = mesh_p->Nodes->getFirstNode();
1411              myLastNode = Finley_NodeFile_getLastNode(mesh_p->Nodes);              myLastNode = mesh_p->Nodes->getLastNode();
1412              globalNodeIndex = Finley_NodeFile_borrowGlobalNodesIndex(mesh_p->Nodes);              globalNodeIndex = mesh_p->Nodes->borrowGlobalNodesIndex();
1413          } else {          } else {
1414              throw FinleyAdapterException("Unsupported function space type for ownSample()");              throw FinleyAdapterException("Unsupported function space type for ownSample()");
1415          }          }
1416    
1417          k=globalNodeIndex[id];          k=globalNodeIndex[id];
1418          return static_cast<bool>( (myFirstNode <= k) && (k < myLastNode) );          return ((myFirstNode <= k) && (k < myLastNode));
1419  #endif  #endif
1420      }      }
1421      return true;      return true;
# Line 2030  int MeshAdapter::getTagFromSampleNo(int Line 1961  int MeshAdapter::getTagFromSampleNo(int
1961  void MeshAdapter::setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const  void MeshAdapter::setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const
1962  {  {
1963      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     escriptDataC tmp=mask.getDataC();  
1964      switch(functionSpaceType) {      switch(functionSpaceType) {
1965          case Nodes:          case Nodes:
1966              Finley_NodeFile_setTags(mesh->Nodes,newTag,&tmp);              mesh->Nodes->setTags(newTag, mask);
1967              break;              break;
1968          case ReducedNodes:          case ReducedNodes:
1969              throw FinleyAdapterException("Error - ReducedNodes does not support tags");              throw FinleyAdapterException("Error - ReducedNodes does not support tags");
             break;  
1970          case DegreesOfFreedom:          case DegreesOfFreedom:
1971              throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");              throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");
             break;  
1972          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
1973              throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");              throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");
             break;  
1974          case Elements:          case Elements:
1975          case ReducedElements:          case ReducedElements:
1976              Finley_ElementFile_setTags(mesh->Elements,newTag,&tmp);              mesh->Elements->setTags(newTag, mask);
1977              break;              break;
1978          case FaceElements:          case FaceElements:
1979          case ReducedFaceElements:          case ReducedFaceElements:
1980              Finley_ElementFile_setTags(mesh->FaceElements,newTag,&tmp);              mesh->FaceElements->setTags(newTag, mask);
1981              break;              break;
1982          case Points:          case Points:
1983              Finley_ElementFile_setTags(mesh->Points,newTag,&tmp);              mesh->Points->setTags(newTag, mask);
1984              break;              break;
1985          case ContactElementsZero:          case ContactElementsZero:
1986          case ReducedContactElementsZero:          case ReducedContactElementsZero:
1987          case ContactElementsOne:          case ContactElementsOne:
1988          case ReducedContactElementsOne:          case ReducedContactElementsOne:
1989              Finley_ElementFile_setTags(mesh->ContactElements,newTag,&tmp);              mesh->ContactElements->setTags(newTag, mask);
1990              break;              break;
1991          default:          default:
1992              stringstream temp;              stringstream temp;
# Line 2094  string MeshAdapter::showTagNames() const Line 2021  string MeshAdapter::showTagNames() const
2021  {  {
2022      stringstream temp;      stringstream temp;
2023      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
2024      Finley_TagMap* tag_map=mesh->TagMap;      TagMap::const_iterator it = mesh->tagMap.begin();
2025      while (tag_map) {      while (it != mesh->tagMap.end()) {
2026          temp << tag_map->name;          temp << it->first;
2027          tag_map=tag_map->next;          ++it;
2028          if (tag_map) temp << ", ";          if (it != mesh->tagMap.end())
2029                temp << ", ";
2030      }      }
2031      return temp.str();      return temp.str();
2032  }  }
# Line 2106  string MeshAdapter::showTagNames() const Line 2034  string MeshAdapter::showTagNames() const
2034  int MeshAdapter::getNumberOfTagsInUse(int functionSpaceCode) const  int MeshAdapter::getNumberOfTagsInUse(int functionSpaceCode) const
2035  {  {
2036      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     dim_t numTags=0;  
2037      switch(functionSpaceCode) {      switch(functionSpaceCode) {
2038          case Nodes:          case Nodes:
2039              numTags=mesh->Nodes->numTagsInUse;              return mesh->Nodes->tagsInUse.size();
             break;  
2040          case ReducedNodes:          case ReducedNodes:
2041              throw FinleyAdapterException("Error - ReducedNodes does not support tags");              throw FinleyAdapterException("Error - ReducedNodes does not support tags");
             break;  
2042          case DegreesOfFreedom:          case DegreesOfFreedom:
2043              throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");              throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");
             break;  
2044          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
2045              throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");              throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");
             break;  
2046          case Elements:          case Elements:
2047          case ReducedElements:          case ReducedElements:
2048              numTags=mesh->Elements->numTagsInUse;              return mesh->Elements->tagsInUse.size();
             break;  
2049          case FaceElements:          case FaceElements:
2050          case ReducedFaceElements:          case ReducedFaceElements:
2051              numTags=mesh->FaceElements->numTagsInUse;              return mesh->FaceElements->tagsInUse.size();
             break;  
2052          case Points:          case Points:
2053              numTags=mesh->Points->numTagsInUse;              return mesh->Points->tagsInUse.size();
             break;  
2054          case ContactElementsZero:          case ContactElementsZero:
2055          case ReducedContactElementsZero:          case ReducedContactElementsZero:
2056          case ContactElementsOne:          case ContactElementsOne:
2057          case ReducedContactElementsOne:          case ReducedContactElementsOne:
2058              numTags=mesh->ContactElements->numTagsInUse;              return mesh->ContactElements->tagsInUse.size();
             break;  
2059          default:          default:
2060              stringstream temp;              stringstream ss;
2061              temp << "Error - Finley does not know anything about function space type " << functionSpaceCode;              ss << "Finley does not know anything about function space type "
2062              throw FinleyAdapterException(temp.str());                   << functionSpaceCode;
2063                throw FinleyAdapterException(ss.str());
2064      }      }
2065      return numTags;      return 0;
2066  }  }
2067    
2068  const int* MeshAdapter::borrowListOfTagsInUse(int functionSpaceCode) const  const int* MeshAdapter::borrowListOfTagsInUse(int functionSpaceCode) const
2069  {  {
2070      Finley_Mesh* mesh=m_finleyMesh.get();      Finley_Mesh* mesh=m_finleyMesh.get();
     index_t* tags=NULL;  
2071      switch(functionSpaceCode) {      switch(functionSpaceCode) {
2072          case Nodes:          case Nodes:
2073              tags=mesh->Nodes->tagsInUse;              return &mesh->Nodes->tagsInUse[0];
             break;  
2074          case ReducedNodes:          case ReducedNodes:
2075              throw FinleyAdapterException("Error - ReducedNodes does not support tags");              throw FinleyAdapterException("Error - ReducedNodes does not support tags");
             break;  
2076          case DegreesOfFreedom:          case DegreesOfFreedom:
2077              throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");              throw FinleyAdapterException("Error - DegreesOfFreedom does not support tags");
             break;  
2078          case ReducedDegreesOfFreedom:          case ReducedDegreesOfFreedom:
2079              throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");              throw FinleyAdapterException("Error - ReducedDegreesOfFreedom does not support tags");
             break;  
2080          case Elements:          case Elements:
2081          case ReducedElements:          case ReducedElements:
2082              tags=mesh->Elements->tagsInUse;              return &mesh->Elements->tagsInUse[0];
             break;  
2083          case FaceElements:          case FaceElements:
2084          case ReducedFaceElements:          case ReducedFaceElements:
2085              tags=mesh->FaceElements->tagsInUse;              return &mesh->FaceElements->tagsInUse[0];
             break;  
2086          case Points:          case Points:
2087              tags=mesh->Points->tagsInUse;              return &mesh->Points->tagsInUse[0];
             break;  
2088          case ContactElementsZero:          case ContactElementsZero:
2089          case ReducedContactElementsZero:          case ReducedContactElementsZero:
2090          case ContactElementsOne:          case ContactElementsOne:
2091          case ReducedContactElementsOne:          case ReducedContactElementsOne:
2092              tags=mesh->ContactElements->tagsInUse;              return &mesh->ContactElements->tagsInUse[0];
             break;  
2093          default:          default:
2094              stringstream temp;              stringstream temp;
2095              temp << "Error - Finley does not know anything about function space type " << functionSpaceCode;              temp << "Error - Finley does not know anything about function space type " << functionSpaceCode;
2096              throw FinleyAdapterException(temp.str());              throw FinleyAdapterException(temp.str());
2097      }      }
2098      return tags;      return NULL;
2099  }  }
2100    
2101    

Legend:
Removed from v.4408  
changed lines
  Added in v.4441

  ViewVC Help
Powered by ViewVC 1.1.26