X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FParaMEDMEM%2FOverlapMapping.hxx;h=03d0d7f8a3c37862eab375557994cfa52044f4f0;hb=a5a009e0d290b13f262ba4f251dd20d1c7acb20d;hp=cfb06b1bbb62e8cd4784a5968445876633d5ba30;hpb=766edba73b97ff6903eb9835fa94b4fe515acb39;p=tools%2Fmedcoupling.git diff --git a/src/ParaMEDMEM/OverlapMapping.hxx b/src/ParaMEDMEM/OverlapMapping.hxx index cfb06b1bb..03d0d7f8a 100644 --- a/src/ParaMEDMEM/OverlapMapping.hxx +++ b/src/ParaMEDMEM/OverlapMapping.hxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2015 CEA/DEN, EDF R&D +// Copyright (C) 2007-2016 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -21,36 +21,43 @@ #ifndef __OVERLAPMAPPING_HXX__ #define __OVERLAPMAPPING_HXX__ -#include "MEDCouplingAutoRefCountObjectPtr.hxx" +#include "MCAuto.hxx" +#include "OverlapElementLocator.hxx" #include #include +//#define DEC_DEBUG -namespace ParaMEDMEM +namespace MEDCoupling { class ProcessorGroup; class DataArrayInt; class MEDCouplingFieldDouble; - /* + using namespace std; + typedef map SparseDoubleVec; + + /*! * Internal class, not part of the public API. * * Used by the impl of OverlapInterpolationMatrix, plays an equivalent role than what the NxM_Mapping * does for the InterpolationMatrix. - * */ class OverlapMapping { public: - OverlapMapping(const ProcessorGroup& group); + + OverlapMapping(const ProcessorGroup& group, const OverlapElementLocator& locator); void keepTracksOfSourceIds(int procId, DataArrayInt *ids); void keepTracksOfTargetIds(int procId, DataArrayInt *ids); - void addContributionST(const std::vector< std::map >& matrixST, const DataArrayInt *srcIds, int srcProcId, const DataArrayInt *trgIds, int trgProcId); - void prepare(const std::vector< std::vector >& procsInInteraction, int nbOfTrgElems); + void addContributionST(const vector< SparseDoubleVec >& matrixST, const DataArrayInt *srcIds, int srcProcId, const DataArrayInt *trgIds, int trgProcId); + void prepare(const vector< int >& procsToSendField, int nbOfTrgElems); void computeDenoConservativeVolumic(int nbOfTuplesTrg); - void computeDenoGlobConstraint(); +// void computeDenoIntegralGlobConstraint(); +// void computeDenoIntegral(); + void computeDenoRevIntegral(const DataArrayDouble & targetAreas); // - void multiply(const MEDCouplingFieldDouble *fieldInput, MEDCouplingFieldDouble *fieldOutput) const; + void multiply(const MEDCouplingFieldDouble *fieldInput, MEDCouplingFieldDouble *fieldOutput, double default_val) const; void transposeMultiply(const MEDCouplingFieldDouble *fieldInput, MEDCouplingFieldDouble *fieldOutput); private: void serializeMatrixStep0ST(const int *nbOfElemsSrc, int *&bigArr, int *count, int *offsets, @@ -61,36 +68,62 @@ namespace ParaMEDMEM void unserializationST(int nbOfTrgElems, const int *nbOfElemsSrcPerProc, const int *bigArrRecv, const int *bigArrRecvCounts, const int *bigArrRecvOffs, const int *bigArrRecv2, const double *bigArrDRecv2, const int *bigArrRecv2Count, const int *bigArrRecv2Offs); void finishToFillFinalMatrixST(); - void prepareIdsToSendST(); - void updateZipSourceIdsForFuture(); - //void printTheMatrix() const; + void fillSourceIdsZipReceivedForMultiply(); + +#ifdef DEC_DEBUG + void printMatrixesST() const; + void printTheMatrix() const; + void printDenoMatrix() const; +#endif private: const ProcessorGroup &_group; - //! vector of ids - std::vector< MEDCouplingAutoRefCountObjectPtr > _src_ids_st2;//item #1 - std::vector< int > _src_proc_st2;//item #1 - std::vector< MEDCouplingAutoRefCountObjectPtr > _trg_ids_st2;//item #0 - std::vector< int > _trg_proc_st2;//item #0 - std::vector< int > _nb_of_src_ids_proc_st2;//item #1 - std::vector< int > _src_ids_proc_st2;//item #1 - std::vector< std::vector > _src_ids_zip_st2;//same size as _src_ids_zip_proc_st2. Sorted. specifies for each id the corresponding ids to send. This is for item0 of Step2 of main algorithm - std::vector< int > _src_ids_zip_proc_st2; - //! vector of matrixes the first entry correspond to source proc id in _source_ids_st - std::vector< std::vector< std::map > > _matrixes_st; - std::vector< std::vector > _source_ids_st; - std::vector< int > _source_proc_id_st; - std::vector< std::vector > _target_ids_st; - std::vector< int > _target_proc_id_st; - //! the matrix for matrix-vector product. The first dimension the set of target procs that interacts with local source mesh. The second dimension correspond to nb of local source ids. - std::vector< std::vector< std::map > > _the_matrix_st; - std::vector< int > _the_matrix_st_source_proc_id; - std::vector< std::vector > _the_matrix_st_source_ids; - std::vector< std::vector< std::map > > _the_deno_st; - //! this attribute stores the proc ids that wait for data from this proc ids for matrix-vector computation - std::vector< int > _proc_ids_to_send_vector_st; - std::vector< int > _proc_ids_to_recv_vector_st; - //! this attribute is of size _group.size(); for each procId in _group _source_ids_to_send_st[procId] contains tupleId to send abroad - std::vector< std::vector > _source_ids_to_send_st; + const OverlapElementLocator& _locator; + + /**! Map of DAInt of cell identifiers. For a proc ID i, + * gives an old2new map for the local part of the source mesh that has been sent to proc#i, just based on the + * bounding box computation (this is potentially a larger set than what is finally in the interp matrix). + * Second member gives proc ID. */ + map < int, MCAuto > _sent_src_ids; + + //! See _sent_src_ids. Same for target mesh. + map < int, MCAuto > _sent_trg_ids; + + /**! Vector of matrixes (partial interpolation ratios), result of the LOCAL interpolator run. + * Indexing shared with _source_proc_id_st, and _target_proc_id_st. */ + vector< vector< SparseDoubleVec > > _matrixes_st; + //! See _matrixes_st - vec of source proc IDs + vector< int > _source_proc_id_st; + //! See _matrixes_st - vec of target proc IDs + vector< int > _target_proc_id_st; + + /**! Number of received source mesh IDs at mesh data exchange. + Counting the number of IDs suffices, as we just need this to prepare the receive side, when doing the final vector matrix multiplication. + First dimension is the remote proc ID from which we received. */ + map _nb_of_rcv_src_ids; + + /**! Specifies for each (target) remote proc ID (first dim of the map) the corresponding + * source cell IDs to use. + * This information is stored from the *locally* COMPuted matrices, and corresponds hence to field value that will need to + * sent later on, if this matrix bit itself is sent aways. */ + map > _src_ids_zip_comp; + + /**! Same idea as _src_ids_zip_comp above, but for RECEIVED matrix. */ + map > _src_ids_zip_recv; + + /**! THE matrix for matrix-vector product. The first dimension is indexed in the set of target procs + * that interacts with local source mesh. The second dim is the target cell ID. + * Same indexing as _the_matrix_st_source_proc_id and _the_deno_st. + * We don't use a map here to be more efficient in the final matrix-vector computation which requires the joint + * taversal of _the_matrix_st and _the_deno_st. + * This matrix is filled after receival from other procs, contrary to _matrixes_st which contains local computations.*/ + vector< vector< SparseDoubleVec > > _the_matrix_st; + //! See _the_matrix_st above. List of source proc IDs contributing to _the_matrix_st + vector< int > _the_matrix_st_source_proc_id; + // Denominators (computed from the numerator matrix). As for _the_matrix_st it is paired with _the_matrix_st_source_proc_id + vector< vector< SparseDoubleVec > > _the_deno_st; + + //! Proc IDs to which data will be sent (originating this current proc) for matrix-vector computation + vector< int > _proc_ids_to_send_vector_st; }; }