[1985] | 1 | /*! |
---|
| 2 | \file axis_algorithm_inverse.hpp |
---|
| 3 | \author Ha NGUYEN |
---|
| 4 | \since 14 May 2015 |
---|
| 5 | \date 29 June 2015 |
---|
| 6 | |
---|
| 7 | \brief Algorithm for inversing an axis.. |
---|
| 8 | */ |
---|
| 9 | #include "axis_algorithm_inverse.hpp" |
---|
| 10 | #include "context.hpp" |
---|
| 11 | #include "context_client.hpp" |
---|
| 12 | #include "axis.hpp" |
---|
| 13 | #include "grid.hpp" |
---|
| 14 | #include "grid_transformation_factory_impl.hpp" |
---|
| 15 | #include "inverse_axis.hpp" |
---|
| 16 | #include "client_client_dht_template.hpp" |
---|
| 17 | |
---|
| 18 | namespace xios { |
---|
| 19 | |
---|
[2270] | 20 | shared_ptr<CGenericAlgorithmTransformation> CAxisAlgorithmInverse::create(bool isSource, CGrid* gridDst, CGrid* gridSrc, |
---|
[1985] | 21 | CTransformation<CAxis>* transformation, |
---|
| 22 | int elementPositionInGrid, |
---|
| 23 | std::map<int, int>& elementPositionInGridSrc2ScalarPosition, |
---|
| 24 | std::map<int, int>& elementPositionInGridSrc2AxisPosition, |
---|
| 25 | std::map<int, int>& elementPositionInGridSrc2DomainPosition, |
---|
| 26 | std::map<int, int>& elementPositionInGridDst2ScalarPosition, |
---|
| 27 | std::map<int, int>& elementPositionInGridDst2AxisPosition, |
---|
| 28 | std::map<int, int>& elementPositionInGridDst2DomainPosition) |
---|
| 29 | TRY |
---|
| 30 | { |
---|
| 31 | std::vector<CAxis*> axisListDestP = gridDst->getAxis(); |
---|
| 32 | std::vector<CAxis*> axisListSrcP = gridSrc->getAxis(); |
---|
| 33 | |
---|
| 34 | CInverseAxis* inverseAxis = dynamic_cast<CInverseAxis*> (transformation); |
---|
| 35 | int axisDstIndex = elementPositionInGridDst2AxisPosition[elementPositionInGrid]; |
---|
| 36 | int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; |
---|
| 37 | |
---|
[2270] | 38 | return make_shared<CAxisAlgorithmInverse>(isSource, axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], inverseAxis); |
---|
[1985] | 39 | } |
---|
| 40 | CATCH |
---|
| 41 | |
---|
| 42 | bool CAxisAlgorithmInverse::dummyRegistered_ = CAxisAlgorithmInverse::registerTrans(); |
---|
| 43 | bool CAxisAlgorithmInverse::registerTrans() |
---|
| 44 | TRY |
---|
| 45 | { |
---|
| 46 | return CGridTransformationFactory<CAxis>::registerTransformation(TRANS_INVERSE_AXIS, create); |
---|
| 47 | } |
---|
| 48 | CATCH |
---|
| 49 | |
---|
[1988] | 50 | CAxisAlgorithmInverse::CAxisAlgorithmInverse(bool isSource, CAxis* axisDestination, CAxis* axisSource, CInverseAxis* inverseAxis) |
---|
[2256] | 51 | : CAlgorithmTransformationNoDataModification(isSource), axisDest_(axisDestination), axisSrc_(axisSource) |
---|
[1985] | 52 | TRY |
---|
| 53 | { |
---|
[2256] | 54 | |
---|
| 55 | axisDestination->axis_type.reset(); |
---|
| 56 | axisDestination->n_glo.reset(); |
---|
| 57 | axisDestination->index.reset(); |
---|
| 58 | axisDestination->n.reset(); |
---|
| 59 | axisDestination->begin.reset(); |
---|
| 60 | |
---|
| 61 | axisDestination->mask.reset(); |
---|
| 62 | axisDestination->data_index.reset(); |
---|
| 63 | axisDestination->data_n.reset(); |
---|
| 64 | axisDestination->data_begin.reset(); |
---|
| 65 | |
---|
| 66 | axisDestination->value.reset(); |
---|
| 67 | axisDestination->bounds.reset(); |
---|
| 68 | |
---|
| 69 | axisDestination->n_glo.setValue( axisSource->n_glo.getValue() ); |
---|
| 70 | |
---|
[1985] | 71 | if (axisDestination->n_glo.getValue() != axisSource->n_glo.getValue()) |
---|
| 72 | { |
---|
| 73 | ERROR("CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource)", |
---|
| 74 | << "Two axis have different global size" |
---|
| 75 | << "Size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue() << std::endl |
---|
| 76 | << "Size of axis destination " <<axisDestination->getId() << " is " << axisDestination->n_glo.getValue()); |
---|
| 77 | } |
---|
| 78 | |
---|
[2256] | 79 | int n_glo =axisDestination->n_glo.getValue() ; |
---|
| 80 | |
---|
| 81 | CArray<size_t,1> sourceGlobalIdx = axisSource->getLocalElement()->getGlobalIndex(); |
---|
| 82 | int indexSize = sourceGlobalIdx.numElements(); |
---|
| 83 | |
---|
| 84 | axisDestination->index.resize( indexSize ); |
---|
| 85 | axisDestination->data_index.resize( indexSize ); |
---|
| 86 | axisDestination->data_index = -1; |
---|
| 87 | for (size_t i = 0; i < indexSize ; ++i) |
---|
[1985] | 88 | { |
---|
[2256] | 89 | axisDestination->index(i) = (n_glo-1)-sourceGlobalIdx(i); |
---|
[1985] | 90 | } |
---|
| 91 | |
---|
[2256] | 92 | int idxMin = INT_MAX; |
---|
| 93 | for (int countSrc = 0; countSrc < indexSize ; ++countSrc) |
---|
[1985] | 94 | { |
---|
[2256] | 95 | if ( sourceGlobalIdx(countSrc) < idxMin ) |
---|
| 96 | idxMin = sourceGlobalIdx(countSrc); |
---|
[1985] | 97 | } |
---|
[1999] | 98 | |
---|
[2256] | 99 | CArray<int,1> sourceWorkflowIdx = axisSource->getLocalView(CElementView::WORKFLOW)->getIndex(); |
---|
| 100 | int srcWorkflowSize = sourceWorkflowIdx.numElements(); |
---|
| 101 | for (size_t i = 0; i < indexSize ; ++i) |
---|
[1985] | 102 | { |
---|
[2256] | 103 | // ------------------ define transformation only if in the WF ------------------ |
---|
| 104 | int iIdxSrc2 = (i+idxMin)%axisSource->n_glo; |
---|
| 105 | int convert_locally_global_idx = (iIdxSrc2-idxMin) ; |
---|
| 106 | bool concerned_by_WF(false); |
---|
| 107 | int i2; |
---|
| 108 | for ( i2 = 0 ; i2<sourceWorkflowIdx.numElements() ; ++i2 ) |
---|
[1985] | 109 | { |
---|
[2256] | 110 | if (sourceWorkflowIdx(i2)==convert_locally_global_idx) |
---|
| 111 | { |
---|
| 112 | concerned_by_WF = true; |
---|
| 113 | break; |
---|
| 114 | } |
---|
[1985] | 115 | } |
---|
| 116 | |
---|
[2256] | 117 | if (concerned_by_WF) |
---|
[1985] | 118 | { |
---|
[2256] | 119 | axisDestination->data_index(sourceWorkflowIdx(i2)) = sourceWorkflowIdx(i2); |
---|
[1985] | 120 | } |
---|
[2256] | 121 | // ----------------------------------------------------------------------------- |
---|
[1985] | 122 | |
---|
| 123 | } |
---|
| 124 | |
---|
[2256] | 125 | if (axisSrc_->hasValue) |
---|
[1985] | 126 | { |
---|
[2256] | 127 | axisDestination->value.resize(indexSize); |
---|
| 128 | for (size_t i = 0; i < indexSize ; ++i) |
---|
[1985] | 129 | { |
---|
[2256] | 130 | axisDestination->value(i) = axisSource->value(i); |
---|
[1985] | 131 | } |
---|
| 132 | } |
---|
| 133 | |
---|
[2256] | 134 | if (axisSrc_->hasBounds) |
---|
[1985] | 135 | { |
---|
[2257] | 136 | axisDestination->bounds.resize(2,indexSize); |
---|
| 137 | for (int i = 0; i < indexSize ; ++i) |
---|
[1985] | 138 | { |
---|
[2257] | 139 | axisDestination->bounds(0,i) = axisSource->bounds(0,i); |
---|
| 140 | axisDestination->bounds(1,i) = axisSource->bounds(1,i); |
---|
[1985] | 141 | } |
---|
| 142 | } |
---|
| 143 | |
---|
[2256] | 144 | axisDestination->checkAttributes() ; |
---|
[1985] | 145 | |
---|
| 146 | } |
---|
| 147 | CATCH |
---|
| 148 | |
---|
| 149 | } |
---|