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

Diff of /trunk/finley/src/CPPAdapter/MeshAdapter.cpp

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

revision 4437 by caltinay, Tue Jun 4 05:37:18 2013 UTC revision 4441 by caltinay, Fri Jun 7 02:23:49 2013 UTC
# Line 751  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 789  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 814  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 851  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 903  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 912  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 944  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                  case ContactElementsOne:                  case ContactElementsOne:
932                  case ReducedContactElementsOne:                  case ReducedContactElementsOne:
933                      Finley_Assemble_interpolate(mesh->Nodes,mesh->ContactElements,&_in,&_target);                      Assemble_interpolate(mesh->Nodes, mesh->ContactElements, in, target);
934                      break;                      break;
935                  default:                  default:
936                      stringstream temp;                      stringstream temp;
# Line 972  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 1012  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 1022  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 1031  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 1078  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 1147  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 1181  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 1202  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 1218  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 1227  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 1247  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 1268  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 1297  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 1328  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 1353  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 1366  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 1389  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 1399  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 1412  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 1442  void MeshAdapter::setNewX(const escript: Line 1386  void MeshAdapter::setNewX(const escript:
1386          Finley_Mesh_setCoordinates(mesh, new_x);          Finley_Mesh_setCoordinates(mesh, new_x);
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));  
         //Finley_Mesh_setCoordinates(mesh, new_x_inter);  
1389      }      }
1390      checkFinleyError();      checkFinleyError();
1391  }  }
# Line 1452  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 1473  bool MeshAdapter::ownSample(int fs_code, Line 1415  bool MeshAdapter::ownSample(int fs_code,
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;

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

  ViewVC Help
Powered by ViewVC 1.1.26