]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/ParaMEDMEM_Swig/ParaMEDMEMCommon.i
Salome HOME
Merge branch 'V9_11_BR'
[tools/medcoupling.git] / src / ParaMEDMEM_Swig / ParaMEDMEMCommon.i
1 // Copyright (C) 2017-2023  CEA, EDF
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 %include std_set.i
21
22 %template() std::set<int>;
23
24 %{
25 #include "CommInterface.hxx"
26 #include "ProcessorGroup.hxx"
27 #include "Topology.hxx"
28 #include "MPIProcessorGroup.hxx"
29 #include "DEC.hxx"
30 #include "InterpKernelDEC.hxx"
31 #include "NonCoincidentDEC.hxx"
32 #include "StructuredCoincidentDEC.hxx"
33 #include "OverlapDEC.hxx"
34 #include "ParaMESH.hxx"
35 #include "ParaFIELD.hxx"
36 #include "ICoCoMEDDoubleField.hxx"
37 #include "ICoCoMEDIntField.hxx"
38 #include "ComponentTopology.hxx"
39 #include "ParaUMesh.hxx"
40 #include "ParaSkyLineArray.hxx"
41 #include "ParaDataArray.hxx"
42
43 using namespace INTERP_KERNEL;
44 using namespace MEDCoupling;
45 using namespace ICoCo;
46 %}
47
48 %include "InterpolationOptions.hxx"
49 %include "ProcessorGroup.hxx"
50 %include "DECOptions.hxx"
51 %include "ParaMESH.hxx"
52 %include "ParaFIELD.hxx"
53 %include "MPIProcessorGroup.hxx"
54 %include "ComponentTopology.hxx"
55 %include "DEC.hxx"
56 %include "DisjointDEC.hxx"
57 %include "StructuredCoincidentDEC.hxx"
58
59 %newobject MEDCoupling::ParaUMesh::New;
60 %newobject MEDCoupling::ParaUMesh::getMesh;
61 %newobject MEDCoupling::ParaUMesh::getGlobalCellIds;
62 %newobject MEDCoupling::ParaUMesh::getGlobalNodeIds;
63 %newobject MEDCoupling::ParaUMesh::getCellIdsLyingOnNodes;
64 %newobject MEDCoupling::ParaUMesh::redistributeCells;
65 %newobject MEDCoupling::ParaUMesh::redistributeCellField;
66 %newobject MEDCoupling::ParaUMesh::redistributeNodeField;
67 %newobject MEDCoupling::ParaDataArrayInt32::New;
68 %newobject MEDCoupling::ParaDataArrayInt32::buildComplement;
69 %newobject MEDCoupling::ParaDataArrayInt64::New;
70 %newobject MEDCoupling::ParaDataArrayInt64::buildComplement;
71 %newobject MEDCoupling::ParaSkyLineArray::New;
72 %newobject MEDCoupling::ParaSkyLineArray::equiRedistribute;
73 %newobject MEDCoupling::ParaSkyLineArray::getSkyLineArray;
74 %newobject MEDCoupling::ParaSkyLineArray::getGlobalIdsArray;
75
76 %newobject MEDCoupling::InterpKernelDEC::_NewWithPG_internal;
77 %newobject MEDCoupling::InterpKernelDEC::_NewWithComm_internal;
78 %newobject MEDCoupling::OverlapDEC::_NewWithComm_internal;
79
80 %feature("unref") ParaSkyLineArray "$this->decrRef();"
81 %feature("unref") ParaUMesh "$this->decrRef();"
82 %feature("unref") ParaDataArrayInt32 "$this->decrRef();"
83 %feature("unref") ParaDataArrayInt64 "$this->decrRef();"
84
85 %nodefaultctor;
86
87 namespace MEDCoupling
88 {
89   class CommInterface
90   {
91   public:
92     CommInterface();
93     virtual ~CommInterface();
94     int worldSize() const;
95     int commSize(MPI_Comm comm, int* size) const;
96     int commRank(MPI_Comm comm, int* rank) const;
97     int commGroup(MPI_Comm comm, MPI_Group* group) const;
98     int groupIncl(MPI_Group group, int size, int* ranks, MPI_Group* group_output) const;
99     int commCreate(MPI_Comm comm, MPI_Group group, MPI_Comm* comm_output) const;
100     int groupFree(MPI_Group* group) const;
101     int commFree(MPI_Comm* comm) const;
102
103     int send(void* buffer, int count, MPI_Datatype datatype, int target, int tag, MPI_Comm comm) const;
104     int recv(void* buffer, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status* status) const;
105     int sendRecv(void* sendbuf, int sendcount, MPI_Datatype sendtype, 
106                  int dest, int sendtag, void* recvbuf, int recvcount, 
107                  MPI_Datatype recvtype, int source, int recvtag, MPI_Comm comm,
108                  MPI_Status* status);
109
110     int Isend(void* buffer, int count, MPI_Datatype datatype, int target,
111               int tag, MPI_Comm comm, MPI_Request *request) const;
112     int Irecv(void* buffer, int count, MPI_Datatype datatype, int source,
113               int tag, MPI_Comm comm, MPI_Request* request) const;
114
115     int wait(MPI_Request *request, MPI_Status *status) const;
116     int test(MPI_Request *request, int *flag, MPI_Status *status) const;
117     int requestFree(MPI_Request *request) const;
118     int waitany(int count, MPI_Request *array_of_requests, int *index, MPI_Status *status) const;
119     int testany(int count, MPI_Request *array_of_requests, int *index, int *flag, MPI_Status *status) const;
120     int waitall(int count, MPI_Request *array_of_requests, MPI_Status *array_of_status) const { return MPI_Waitall(count, array_of_requests, array_of_status); }
121     int testall(int count, MPI_Request *array_of_requests, int *flag, MPI_Status *array_of_status) const;
122     int waitsome(int incount, MPI_Request *array_of_requests,int *outcount, int *array_of_indices, MPI_Status *array_of_status) const;
123     int testsome(int incount, MPI_Request *array_of_requests, int *outcount,
124                  int *array_of_indices, MPI_Status *array_of_status) const;
125     int probe(int source, int tag, MPI_Comm comm, MPI_Status *status) const;
126     int Iprobe(int source, int tag, MPI_Comm comm, int *flag, MPI_Status *status) const;
127     int cancel(MPI_Request *request) const;
128     int testCancelled(MPI_Status *status, int *flag) const;
129     int barrier(MPI_Comm comm) const;
130     int errorString(int errorcode, char *string, int *resultlen) const;
131     int getCount(MPI_Status *status, MPI_Datatype datatype, int *count) const;
132
133     int broadcast(void* buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm) const;
134     int allGather(void* sendbuf, int sendcount, MPI_Datatype sendtype,
135                   void* recvbuf, int recvcount, MPI_Datatype recvtype,
136                   MPI_Comm comm) const;
137     int allToAll(void* sendbuf, int sendcount, MPI_Datatype sendtype,
138                  void* recvbuf, int recvcount, MPI_Datatype recvtype,
139                  MPI_Comm comm) const;
140     int allToAllV(void* sendbuf, int* sendcounts, int* senddispls,
141                   MPI_Datatype sendtype, void* recvbuf, int* recvcounts,
142                   int* recvdispls, MPI_Datatype recvtype, 
143                   MPI_Comm comm) const;
144
145     int reduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm) const;
146     int allReduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm) const;
147     %extend
148     {
149       PyObject *allGatherArrays(const DataArrayIdType *array) const
150       {
151         std::vector< MCAuto<DataArrayIdType> > ret;
152         self->allGatherArrays(MPI_COMM_WORLD,array,ret);
153         return convertFromVectorAutoObjToPyObj<DataArrayIdType>(ret,SWIGTITraits<mcIdType>::TI);
154       }
155
156       PyObject *allToAllArrays(PyObject *arrays) const
157       {
158         std::vector< DataArrayIdType * > arraysIn;
159         std::vector< MCAuto<DataArrayIdType> > arrayOut;
160         convertFromPyObjVectorOfObj<MEDCoupling::DataArrayIdType*>(arrays,SWIGTITraits<mcIdType>::TI,"DataArrayIdType",arraysIn);
161         std::vector< MCAuto<DataArrayIdType> > arraysIn2(FromVecToVecAuto<DataArrayIdType>(arraysIn));
162         self->allToAllArrays(MPI_COMM_WORLD,arraysIn2,arrayOut);
163         return convertFromVectorAutoObjToPyObj<DataArrayIdType>(arrayOut,SWIGTITraits<mcIdType>::TI);
164       }
165     }
166   };
167
168   class ParaUMesh : public RefCountObject
169   {
170   public:
171     static ParaUMesh *New(MEDCouplingUMesh *mesh, DataArrayIdType *globalCellIds, DataArrayIdType *globalNodeIds);
172     ParaUMesh *redistributeCells(const DataArrayIdType *globalCellIds) const;
173     DataArrayIdType *redistributeCellField(const DataArrayIdType *globalCellIds, const DataArrayIdType *fieldValueToRed) const;
174     DataArrayDouble *redistributeCellField(const DataArrayIdType *globalCellIds, const DataArrayDouble *fieldValueToRed) const;
175     DataArrayIdType *redistributeNodeField(const DataArrayIdType *globalCellIds, const DataArrayIdType *fieldValueToRed) const;
176     DataArrayDouble *redistributeNodeField(const DataArrayIdType *globalCellIds, const DataArrayDouble *fieldValueToRed) const;
177     %extend
178     {
179       ParaUMesh(MEDCouplingUMesh *mesh, DataArrayIdType *globalCellIds, DataArrayIdType *globalNodeIds)
180       {
181         return ParaUMesh::New(mesh,globalCellIds,globalNodeIds);
182       }
183
184       MEDCouplingUMesh *getMesh()
185       {
186         MEDCouplingUMesh *ret(self->getMesh());
187         if(ret) ret->incrRef();
188         return ret;
189       }
190
191       DataArrayIdType *getGlobalCellIds()
192       {
193         DataArrayIdType *ret(self->getGlobalCellIds());
194         if(ret) ret->incrRef();
195         return ret;
196       }
197
198       DataArrayIdType *getGlobalNodeIds()
199       {
200         DataArrayIdType *ret(self->getGlobalNodeIds());
201         if(ret) ret->incrRef();
202         return ret;
203       }
204
205       DataArrayIdType *getCellIdsLyingOnNodes(const DataArrayIdType *globalNodeIds, bool fullyIn) const
206       { 
207         MCAuto<DataArrayIdType> ret(self->getCellIdsLyingOnNodes(globalNodeIds,fullyIn));
208         return ret.retn();
209       }
210     }
211   };
212
213   class ParaDataArray : public RefCountObject
214   {
215   };
216
217   class ParaDataArrayInt32 : public ParaDataArray
218   {
219   public:
220     static ParaDataArrayInt32 *New(DataArrayInt32 *seqDa);
221     DataArrayIdType *buildComplement(int nbOfElems) const;
222     %extend
223     {
224       ParaDataArrayInt32(DataArrayInt32 *seqDa)
225       {
226         return ParaDataArrayInt32::New(seqDa);
227       }
228     }
229   };
230
231   class ParaDataArrayInt64 : public ParaDataArray
232   {
233   public:
234     static ParaDataArrayInt64 *New(DataArrayInt64 *seqDa);
235     DataArrayIdType *buildComplement(long nbOfElems) const;
236     %extend
237     {
238       ParaDataArrayInt64(DataArrayInt64 *seqDa)
239       {
240         return ParaDataArrayInt64::New(seqDa);
241       }
242     }
243   };
244
245   class ParaSkyLineArray : public RefCountObject
246   {
247   public:
248     static ParaSkyLineArray *New(MEDCouplingSkyLineArray *ska, DataArrayIdType *globalIds);
249     %extend
250     {
251       ParaSkyLineArray(MEDCouplingSkyLineArray *ska, DataArrayIdType *globalIds)
252       {
253         return ParaSkyLineArray::New(ska,globalIds);
254       }
255
256       ParaSkyLineArray *equiRedistribute(mcIdType nbOfEntities) const
257       {
258         MCAuto<ParaSkyLineArray> ret(self->equiRedistribute(nbOfEntities));
259         return ret.retn();
260       }
261
262       MEDCouplingSkyLineArray *getSkyLineArray() const
263       {
264         MEDCouplingSkyLineArray *ret(self->getSkyLineArray());
265         if(ret)
266           ret->incrRef();
267         return ret;
268       }
269       
270       DataArrayIdType *getGlobalIdsArray() const
271       {
272         DataArrayIdType *ret(self->getGlobalIdsArray());
273         if(ret)
274           ret->incrRef();
275         return ret;
276       }
277     }
278   };
279
280   /* This object can be used only if MED_ENABLE_FVM is defined*/
281   #ifdef MED_ENABLE_FVM
282   class NonCoincidentDEC : public DEC
283   {
284   public:
285     NonCoincidentDEC(ProcessorGroup& source, ProcessorGroup& target);
286   };
287   #endif
288
289   class InterpKernelDEC : public DisjointDEC, public INTERP_KERNEL::InterpolationOptions
290   {
291     public:
292       InterpKernelDEC();
293       InterpKernelDEC(ProcessorGroup& source_group, ProcessorGroup& target_group);
294       InterpKernelDEC(const std::set<int>& src_ids, const std::set<int>& trg_ids); // hide last optional parameter!
295       virtual ~InterpKernelDEC();
296       void release();
297
298       void synchronize();
299       void recvData();
300       void recvData(double time);
301       void sendData();
302       void sendData(double time , double deltatime);
303       void prepareSourceDE();
304       void prepareTargetDE();
305
306       %extend {
307         // Provides a direct ctor for which the communicator can be passed with "MPI._addressof(the_com)":
308         InterpKernelDEC(const std::set<int>& src_ids, const std::set<int>& trg_ids, long long comm_ptr)
309         {
310             return new InterpKernelDEC(src_ids, trg_ids, *((MPI_Comm*)comm_ptr));
311         }
312
313         // This one should really not be called directly by the user since it still has an interface with a pointer to MPI_Comm 
314         // which Swig doesn't handle nicely.
315         // It is just here to provide a constructor taking a **pointer** to a comm - See pythoncode below.
316         static InterpKernelDEC* _NewWithPG_internal(ProcessorGroup& source_group, ProcessorGroup& target_group)
317         {
318           return new InterpKernelDEC(source_group,target_group);
319         }
320
321         static InterpKernelDEC* _NewWithComm_internal(const std::set<int>& src_ids, const std::set<int>& trg_ids, long long another_comm)
322         {
323           return new InterpKernelDEC(src_ids,trg_ids, *(MPI_Comm*)another_comm); // I know, ugly cast ...
324         }
325       }
326   };
327
328   class OverlapDEC : public DEC, public INTERP_KERNEL::InterpolationOptions
329   {
330       public:
331         OverlapDEC(const std::set<int>& procIds);  // hide optional param comm
332         virtual ~OverlapDEC();
333         void release();
334
335         void sendRecvData(bool way=true);
336         void sendData();
337         void recvData();
338         void synchronize();
339         void attachSourceLocalField(ParaFIELD *field, bool ownPt=false);
340         void attachTargetLocalField(ParaFIELD *field, bool ownPt=false);
341         void attachSourceLocalField(MEDCouplingFieldDouble *field);
342         void attachTargetLocalField(MEDCouplingFieldDouble *field);
343         void attachSourceLocalField(ICoCo::MEDDoubleField *field);
344         void attachTargetLocalField(ICoCo::MEDDoubleField *field);
345         ProcessorGroup *getGroup();
346         bool isInGroup() const;
347
348         void setDefaultValue(double val);
349         void setWorkSharingAlgo(int method);
350
351         void debugPrintWorkSharing(std::ostream & ostr) const;
352
353         %extend {
354           OverlapDEC(const std::set<int>& ids, long long comm_ptr)
355           {
356              return new OverlapDEC(ids, *((MPI_Comm*)comm_ptr));
357           }
358
359           // This one should really not be called directly by the user since it still has an interface with a pointer to MPI_Comm 
360           // which Swig doesn't handle nicely.
361           // It is just here to provide a constructor taking a **pointer** to a comm - See pythoncode below.
362           static OverlapDEC* _NewWithComm_internal(const std::set<int>& ids, long long another_comm)
363           {
364             return new OverlapDEC(ids, *(MPI_Comm*)another_comm); // I know, ugly cast ...
365           }
366         }
367    };
368
369 } // end namespace MEDCoupling
370
371 %extend MEDCoupling::ParaMESH
372 {
373   PyObject *getGlobalNumberingCell2() const
374   {
375     const mcIdType *tmp=self->getGlobalNumberingCell();
376     mcIdType size=self->getCellMesh()->getNumberOfCells();
377     PyObject *ret=PyList_New(size);
378     for(mcIdType i=0;i<size;i++)
379       PyList_SetItem(ret,i,PyInt_FromLong(tmp[i])); 
380     return ret;
381   }
382
383   PyObject *getGlobalNumberingFace2() const
384   {
385     const mcIdType *tmp=self->getGlobalNumberingFace();
386     mcIdType size=self->getFaceMesh()->getNumberOfCells();
387     PyObject *ret=PyList_New(size);
388     for(mcIdType i=0;i<size;i++)
389       PyList_SetItem(ret,i,PyInt_FromLong(tmp[i])); 
390     return ret;
391   }
392
393   PyObject *getGlobalNumberingNode2() const
394   {
395     const mcIdType *tmp=self->getGlobalNumberingNode();
396     mcIdType size=self->getCellMesh()->getNumberOfNodes();
397     PyObject *ret=PyList_New(size);
398     for(mcIdType i=0;i<size;i++)
399       PyList_SetItem(ret,i,PyInt_FromLong(tmp[i])); 
400     return ret;
401   }
402 }
403
404 %pythoncode %{
405 if MEDCouplingUse64BitIDs():
406   ParaDataArrayInt = ParaDataArrayInt64
407 else:
408   ParaDataArrayInt = ParaDataArrayInt32
409 %}
410
411 %pythoncode %{
412
413 # And here we use mpi4py ability to provide its internal (C++) pointer to the communicator:
414 # NB: doing a proper typemap from MPI_Comm from Python to C++ requires the inclusion of mpi4py headers and .i file ... an extra dependency ...
415 def _IKDEC_WithComm_internal(src_procs, tgt_procs, mpicomm=None):
416     from mpi4py import MPI
417     # Check iterable:
418     try:
419         s, t = [el for el in src_procs], [el for el in tgt_procs]
420     except:
421         s, t = None, None
422     msg =  "InterpKernelDEC: invalid type in ctor arguments! Possible signatures are:\n"
423     msg += "   - InterpKernelDEC(ProcessorGroup, ProcessorGroup)\n"
424     msg += "   - InterpKernelDEC(<iterable>, <iterable>)\n"
425     msg += "   - InterpKernelDEC(<iterable>, <iterable>, MPI_Comm*) : WARNING here the address of the communicator should be passed with MPI._addressof(the_com)\n"
426     msg += "   - InterpKernelDEC.New(ProcessorGroup, ProcessorGroup)\n"
427     msg += "   - InterpKernelDEC.New(<iterable>, <iterable>)\n"
428     msg += "   - InterpKernelDEC.New(<iterable>, <iterable>, MPI_Comm)\n"
429     if mpicomm is None:
430         if isinstance(src_procs, ProcessorGroup) and isinstance(tgt_procs, ProcessorGroup):
431             return InterpKernelDEC._NewWithPG_internal(src_procs, tgt_procs)
432         elif not s is None:  # iterable
433             return InterpKernelDEC._NewWithComm_internal(s, t, MPI._addressof(MPI.COMM_WORLD))
434         else:
435             raise InterpKernelException(msg)
436     else:
437         if s is None: raise InterpKernelException(msg)  # must be iterable
438         return InterpKernelDEC._NewWithComm_internal(s, t, MPI._addressof(mpicomm))
439
440 def _ODEC_WithComm_internal(procs, mpicomm=None):
441     from mpi4py import MPI
442     # Check iterable:
443     try:
444         g = [el for el in procs]
445     except:
446         msg =  "OverlapDEC: invalid type in ctor arguments! Possible signatures are:\n"
447         msg += "   - OverlapDEC.New(<iterable>)\n"
448         msg += "   - OverlapDEC.New(<iterable>, MPI_Comm)\n"
449         msg += "   - OverlapDEC(<iterable>)\n"
450         msg += "   - OverlapDEC(<iterable>, MPI_Comm*) : WARNING here the address of the communicator should be passed with MPI._addressof(the_com)\n"
451         raise InterpKernelException(msg)
452     if mpicomm is None:
453         return OverlapDEC(g)
454     else:
455         return OverlapDEC._NewWithComm_internal(g, MPI._addressof(mpicomm))
456
457 InterpKernelDEC.New = _IKDEC_WithComm_internal
458 OverlapDEC.New = _ODEC_WithComm_internal
459
460 %}