CDPP / AMDA_Kernel

Commit a84c613d35e07afdb61e583d0fa209aa57179f7b

Authored by Benjamin Renard
2 parents f5ef5545 60c2100e
Exists in master and in 89 other branches 10038, 10098, 5390, 5770, 6728, 7616, 7811, 7875, 8034_7628, 8038, 8041, 8045_8044, 8295, 8459, 8528, 8928, 9016, 9016Bis, 9017, 9017-new, 9049, 9084, 9259, 9326, 9347, 9383, 9719, 9719.new, AllLegends, CDF_ISTP, CDF_ISTP_HOPEFULLY_ALL_WORKING, FER_10400, FER_10412, FER_10663, FER_10765, FER_11000, FER_11100, FER_11242, FER_11277, FER_11500, FER_11537, FER_11588, FER_11651, FER_19836, FER_5344, FER_6031, FER_6598, FER_6966, FER_7318, FER_7618, FER_7857, FER_8455, FER_9629, FER_CR41, FER_CR42, FER_CR43, FER_TFCat, Histo1D2D, JUNO_JEDI, MAZ_10936, MAZ_6018, MAZ_9016_New, MAZ_FIX_9016, SpeasyGet, amdadev, amdadev_test, cu2022, das2, density_maps, develop, evol_9042, expression-parser-bre, feature/9259, frames-transformation, pickle, rm_5776, rm_6015, rm_6599, rm_6616, rm_6616_bis, rm_6912, rm_7926, rm_8050, rm_8932, shue, shue97, test-merge, tickplot, ubuntu

Merge branch 'master' into expression-parser-bre

Showing 7 changed files with 651 additions and 0 deletions   Show diff stats
Inline Side-by-side
CMakeLists.txt
  Diff comments   View file @a84c613
... ... @@ -155,6 +155,7 @@ add_subdirectory(src/ExternLib/PlotCurves)
155 155 add_subdirectory(src/ExternLib/StatisticProcesses)
156 156 add_subdirectory(src/ExternLib/FramesTransformation)
157 157 add_subdirectory(src/ExternLib/sum_into_table_range)
  158 +add_subdirectory(src/ExternLib/sum_into_table_indexes)
158 159 add_subdirectory(src/ExternLib/EISCATDataFilter)
159 160 add_subdirectory(src/ExternLib/Tsyganenko96)
160 161 add_subdirectory(src/ExternLib/StatisticFunctions)
... ...
src/ExternLib/sum_into_table_indexes/AMDAPlugin.cc 0 → 100644
  Diff comments   View file @a84c613
... ... @@ -0,0 +1,81 @@
  1 +/* -*- Base: 10 ; Mode: C++ -*- */
  2 +/*------------------------------------------------------------------------
  3 + **
  4 + FOST project
  5 + **
  6 +--------------------------------------------------------------------------
  7 +--------------------------------------------------------------------------
  8 + FILE LOG
  9 + $Revision: 1.3 $ $Date: 2012-06-15 13:04:42 $
  10 +--------------------------------------------------------------------------
  11 +CREATION
  12 + V.SAC
  13 +
  14 +SUMMARY
  15 +
  16 +DESCRIPTION
  17 +
  18 + The main function performs the following actions :
  19 + <ul>
  20 + <li>
  21 + </ul>
  22 +
  23 +------------------------------------------------------------------------*/
  24 +
  25 +//=============================================================================
  26 +//
  27 +// History of code
  28 +//
  29 +// creation
  30 +//
  31 +// modification
  32 +//=============================================================================
  33 +
  34 +/**
  35 +
  36 +*/
  37 +//=============================================================================
  38 +// Include section
  39 +//=============================================================================
  40 +
  41 +// Standard libraries include files
  42 +//-----------------------------------------------------------------------------
  43 +#include <iostream>
  44 +
  45 +// Include oriented definitions
  46 +//-----------------------------------------------------------------------------
  47 +
  48 +// Module Kernel include files
  49 +//-----------------------------------------------------------------------------
  50 +
  51 +#include "ProcessSumIntoTableIndexes.hh"
  52 +#include "ServicesServer.hh"
  53 +#include "PluginManager.hh"
  54 +
  55 +using namespace AMDA::Parameters;
  56 +
  57 +// Other modules include files
  58 +//-----------------------------------------------------------------------------
  59 +
  60 +//=============================================================================
  61 +// Methods of Class AMDAPlugin
  62 +//=============================================================================
  63 +
  64 +
  65 +
  66 +/**
  67 + Retrieve the Plugin version we're going to expect
  68 +*/
  69 +extern "C" const char* getPluginVersion()
  70 +{
  71 + return "(Version)";
  72 +}
  73 +
  74 +/**
  75 + Tells us to register our functionality to an engine kernel
  76 +*/
  77 +extern "C" void registerPlugin(AMDA::Plugins::PluginManager & /*pm*/)
  78 +{
  79 + ProcessFactory factProcessSumIntoTableIndexes = boost::factory<ProcessSumIntoTableIndexes*>();
  80 + ServicesServer::getInstance()->addProcessFactory("sum_into_table_indexes", factProcessSumIntoTableIndexes);
  81 +}
... ...
src/ExternLib/sum_into_table_indexes/CMakeLists.txt 0 → 100644
  Diff comments   View file @a84c613
... ... @@ -0,0 +1,36 @@
  1 +
  2 +PROJECT(sum_into_table_indexes)
  3 +
  4 +set(LIBRARY_OUTPUT_PATH ${PLUGIN_OUTPUT_PATH})
  5 +
  6 +include_directories(
  7 + ${CMAKE_HOME_DIRECTORY}/src/InternLib/
  8 + ${CMAKE_HOME_DIRECTORY}/src/Common/
  9 + ${CMAKE_HOME_DIRECTORY}/src/Parameters/
  10 + ${CMAKE_HOME_DIRECTORY}/src/Plugins/
  11 + ${CMAKE_HOME_DIRECTORY}/src/helpers/
  12 + ${CMAKE_HOME_DIRECTORY}/src/TimeTableCatalog/
  13 + ${CMAKE_HOME_DIRECTORY}/src/Info/
  14 + ${LOG4CXX_INCLUDE_DIR}
  15 + ${Boost_INCLUDE_DIR}
  16 +)
  17 +
  18 +#Library configuration
  19 +file(
  20 + GLOB_RECURSE
  21 + source_files
  22 + ./*
  23 +)
  24 +
  25 +ADD_LIBRARY( sum_into_table_indexes SHARED ${source_files} )
  26 +
  27 +
  28 +target_link_libraries(
  29 + sum_into_table_indexes
  30 + ${LOG4CXX_LIBRARIES}
  31 + Parameters
  32 + InternLib
  33 + TimeTableCatalog
  34 + TimeUtil
  35 + Info
  36 +)
... ...
src/ExternLib/sum_into_table_indexes/ProcessSumIntoTableIndexes.cc 0 → 100644
  Diff comments   View file @a84c613
... ... @@ -0,0 +1,66 @@
  1 +/*
  2 + * ProcessSumIntoTableIndexes.cc
  3 + *
  4 + * Created on: Mar 26, 2019
  5 + * Author: AKKA IS
  6 + */
  7 +#include <stdlib.h>
  8 +#include <string>
  9 +
  10 +#include <boost/lexical_cast.hpp>
  11 +
  12 +#include "DicError.hh"
  13 +#include "AMDA_exception.hh"
  14 +
  15 +#include "Operation.hh"
  16 +#include "ParameterManager.hh"
  17 +#include "ProcessSumIntoTableIndexes.hh"
  18 +#include "SumIntoTableIndexesCreator.hh"
  19 +#include "ParamMgr.hh"
  20 +#include "ParameterCreatorFromExpression.hh"
  21 +
  22 +using namespace std;
  23 +using namespace boost;
  24 +using namespace log4cxx;
  25 +
  26 +namespace AMDA {
  27 +namespace Parameters {
  28 +
  29 + ProcessSumIntoTableIndexes::ProcessSumIntoTableIndexes(Parameter &parameter) : SingleParamProcess_CRTP(parameter) {
  30 + }
  31 +
  32 + ProcessSumIntoTableIndexes::ProcessSumIntoTableIndexes(const ProcessSumIntoTableIndexes& pProcess, Parameter &parameter)
  33 + : SingleParamProcess_CRTP(pProcess,parameter) {
  34 + }
  35 +
  36 + ProcessSumIntoTableIndexes::~ProcessSumIntoTableIndexes() {
  37 + }
  38 +
  39 + TimeStamp ProcessSumIntoTableIndexes::init() {
  40 + if (_attributList.size() < 3) {
  41 + BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_PROCESS_ERR) << AMDA::ex_msg(std::string("ProcessSumIntoTableIndexes::init required at least 3 attributes'")));
  42 + }
  43 +
  44 + int relatedDim = atoi(_attributList[0].c_str());
  45 + int minIndex1 = atoi(_attributList[1].c_str());
  46 + int maxIndex1 = atoi(_attributList[2].c_str());
  47 +
  48 + int minIndex2 = -1;
  49 + int maxIndex2 = -1;
  50 + if (_attributList.size() == 5) {
  51 + minIndex2 = atoi(_attributList[3].c_str());
  52 + maxIndex2 = atoi(_attributList[4].c_str());
  53 + }
  54 +
  55 + TimeStamp timeStamp = _parameterInput->init( this, _timeIntervalList);
  56 + _paramInput = _parameterInput->getParamData(this).get();
  57 + SumIntoTableIndexesCreator lSumIntoTableIndexesCreator(*this, *_paramInput, minIndex1, maxIndex1, relatedDim, minIndex2, maxIndex2);
  58 + _operation = lSumIntoTableIndexesCreator.getOperation();
  59 + _paramData = ParamDataSPtr(_operation->getParamOutput());
  60 + _paramData->setMinSampling(_paramInput->getMinSampling());
  61 +
  62 + return timeStamp;
  63 +}
  64 +
  65 +} /* namespace Parameters */
  66 +} /* namespace AMDA */
... ...
src/ExternLib/sum_into_table_indexes/ProcessSumIntoTableIndexes.hh 0 → 100644
  Diff comments   View file @a84c613
... ... @@ -0,0 +1,44 @@
  1 +/*
  2 + * ProcessSumIntoTableIndexes.hh
  3 + *
  4 + * Created on: Mar 26, 2019
  5 + * Author: AKKA IS
  6 + */
  7 +
  8 +#ifndef PROCESSSUMINTOTABLEINDEXES_HH_
  9 +#define PROCESSSUMINTOTABLEINDEXES_HH_
  10 +
  11 +#include "SingleParamProcess.hh"
  12 +
  13 +namespace AMDA {
  14 +namespace Parameters {
  15 +
  16 +/**
  17 + * @class ProcessSumIntoTableIndexes
  18 + * @brief Process to compute the sum of parameter data into table indexes.
  19 + */
  20 +class ProcessSumIntoTableIndexes : public AMDA::Parameters::SingleParamProcess_CRTP<ProcessSumIntoTableIndexes> {
  21 +
  22 +public:
  23 + /**
  24 + * @brief Constructor.
  25 + */
  26 + ProcessSumIntoTableIndexes(Parameter &parameter);
  27 + /**
  28 + * @brief Copy Constructor.
  29 + */
  30 + ProcessSumIntoTableIndexes(const ProcessSumIntoTableIndexes& pProcess, Parameter &pParameter) ;
  31 + /**
  32 + * @brief Destructor.
  33 + */
  34 + ~ProcessSumIntoTableIndexes();
  35 +
  36 + /**
  37 + * @overload Process::init()
  38 + */
  39 + TimeStamp init();
  40 +};
  41 +
  42 +} /* namespace Parameters */
  43 +} /* namespace AMDA */
  44 +#endif /* PROCESSSUMINTOTABLEINDEXES_HH_ */
... ...
src/ExternLib/sum_into_table_indexes/SumIntoTableIndexes.hh 0 → 100644
  Diff comments   View file @a84c613
... ... @@ -0,0 +1,244 @@
  1 +/*
  2 + * SumIntoTableIndexes.hh
  3 + *
  4 + * Created on: Mar 26, 2019
  5 + * Author: AKKA IS
  6 + */
  7 +
  8 +#ifndef SUMINTOTABLEINDEXES_HH_
  9 +#define SUMINTOTABLEINDEXES_HH_
  10 +
  11 +#include "Parameter.hh"
  12 +#include "ParamData.hh"
  13 +#include "DataTypeMath.hh"
  14 +#include "Operation.hh"
  15 +
  16 +namespace AMDA {
  17 +namespace Parameters {
  18 +namespace SumIntoTableIndexes {
  19 +
  20 +/**
  21 + * @class SumIntoTableIndexes1D
  22 + * @brief It is responsible to compute the sum of 1D parameter data into a table of indexes.
  23 + * @details This class implement the interface Operation.
  24 + */
  25 +template<typename DataType>
  26 +class SumIntoTableIndexes1D : public Operation {
  27 +
  28 +public:
  29 + /**
  30 + * @brief Constructor.
  31 + * @details Create the ParamData type of the input ParamData.
  32 + */
  33 + SumIntoTableIndexes1D(Process& pProcess, ParamDataSpec<std::vector<DataType> >& paramInput, int minIndex, int maxIndex)
  34 + : Operation(pProcess),
  35 + _paramInput(paramInput),
  36 + _paramOutput(new ParamDataSpec<DataType>()), _minIndex(minIndex), _maxIndex(maxIndex) {
  37 + _paramDataOutput=_paramOutput;
  38 + }
  39 +
  40 + virtual ~SumIntoTableIndexes1D() {
  41 + }
  42 +
  43 + /**
  44 + * @overload Operation::write(ParamDataIndexInfo &pParamDataIndexInfo)
  45 + */
  46 + void write(ParamDataIndexInfo &pParamDataIndexInfo) {
  47 + for (unsigned int _index = pParamDataIndexInfo._startIndex ;
  48 + _index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
  49 + ++_index)
  50 + {
  51 + double crtTime = _paramInput.getTime(_index);
  52 + std::vector<DataType> inputElt = _paramInput.get(_index);
  53 +
  54 + DataType output = 0;
  55 +
  56 + for (int i = _minIndex; i <= _maxIndex; ++i) {
  57 + if ((i >= inputElt.size()) || isNAN(inputElt[i]))
  58 + continue;
  59 + output += inputElt[i];
  60 + }
  61 +
  62 + _paramOutput->pushTime(crtTime);
  63 + _paramOutput->getDataList().push_back(output);
  64 + }
  65 + }
  66 +
  67 +private:
  68 + /**<
  69 + * @brief It is the channel of data derived
  70 + */
  71 + ParamDataSpec<std::vector<DataType> > &_paramInput;
  72 +
  73 + /**<
  74 + * @brief It is the channel of the data derived
  75 + */
  76 + ParamDataSpec<DataType> *_paramOutput;
  77 +
  78 + int _minIndex;
  79 +
  80 + int _maxIndex;
  81 +};
  82 +
  83 +/**
  84 + * @class SumIntoTableIndexes2DOneRange
  85 + * @brief It is responsible to compute the sum of 2D parameter data into one table indexes.
  86 + * @details This class implement the interface Operation.
  87 + */
  88 +template<typename DataType>
  89 +class SumIntoTableIndexes2DOneRange : public Operation {
  90 +
  91 +public:
  92 +
  93 + /**
  94 + * @brief Constructor.
  95 + * @details Create the ParamData type of the input ParamData when only one range is defined for one dimension (the output data is a vector).
  96 + */
  97 + SumIntoTableIndexes2DOneRange(Process& pProcess, ParamDataSpec<Tab2DData<DataType> >& paramInput, int minIndex, int maxIndex, int tableRelatedDim)
  98 + : Operation(pProcess),
  99 + _paramInput(paramInput),
  100 + _paramOutput(new ParamDataSpec<std::vector<DataType>>()),
  101 + _tableRelatedDim(tableRelatedDim), _minIndex(minIndex), _maxIndex(maxIndex) {
  102 + _paramDataOutput = _paramOutput;
  103 + }
  104 +
  105 +
  106 + virtual ~SumIntoTableIndexes2DOneRange() {
  107 + }
  108 +
  109 + /**
  110 + * @overload Operation::write(ParamDataIndexInfo &pParamDataIndexInfo)
  111 + */
  112 + void write(ParamDataIndexInfo &pParamDataIndexInfo) {
  113 + for (unsigned int _index = pParamDataIndexInfo._startIndex ;
  114 + _index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
  115 + ++_index)
  116 + {
  117 + double crtTime = _paramInput.getTime(_index);
  118 + Tab2DData<DataType> inputElt = _paramInput.get(_index);
  119 +
  120 + std::vector<DataType> outputElt;
  121 + if (_tableRelatedDim == 0) {
  122 + outputElt.resize(inputElt.getDim2Size(), 0);
  123 + for (int i = _minIndex; i <= _maxIndex; ++i) {
  124 + for (int j = 0; j < inputElt.getDim2Size(); ++j) {
  125 + if (isNAN(inputElt[i][j]))
  126 + continue;
  127 + outputElt[j] += inputElt[i][j];
  128 + }
  129 + }
  130 + }
  131 + else {
  132 + outputElt.resize(inputElt.getDim1Size(), 0);
  133 +
  134 + for (int j = _minIndex; j <= _maxIndex; ++j) {
  135 + for (int i = 0; i < inputElt.getDim1Size(); ++i) {
  136 + if (isNAN(inputElt[i][j]))
  137 + continue;
  138 + outputElt[i] += inputElt[i][j];
  139 + }
  140 + }
  141 + }
  142 +
  143 + _paramOutput->pushTime(crtTime);
  144 + _paramOutput->getDataList().push_back(outputElt);
  145 + }
  146 + }
  147 +
  148 +private:
  149 + /**<
  150 + * @brief It is the channel of data derived
  151 + */
  152 + ParamDataSpec<Tab2DData<DataType> > &_paramInput;
  153 +
  154 + ParamDataSpec<std::vector<DataType>> *_paramOutput;
  155 +
  156 + int _tableRelatedDim;
  157 +
  158 + int _minIndex;
  159 +
  160 + int _maxIndex;
  161 +};
  162 +
  163 +/**
  164 + * @class SumIntoIndexesTable2DTwoRanges
  165 + * @brief It is responsible to compute the sum of 2D parameter data into two tables ranges of indexes.
  166 + * @details This class implement the interface Operation.
  167 + */
  168 +template<typename DataType>
  169 +class SumIntoTableIndexes2DTwoRanges : public Operation {
  170 +
  171 +public:
  172 +
  173 + /**
  174 + * @brief Constructor.
  175 + * @details Create the ParamData type of the input ParamData when a range is defined for each dimensions (the output data is a scalar).
  176 + */
  177 + SumIntoTableIndexes2DTwoRanges(Process& pProcess, ParamDataSpec<Tab2DData<DataType> >& paramInput, int minIndex1, int maxIndex1, int table1RelatedDim, int minIndex2, int maxIndex2)
  178 + : Operation(pProcess),
  179 + _paramInput(paramInput),
  180 + _paramOutput(new ParamDataSpec<DataType>()),
  181 + _table1RelatedDim(table1RelatedDim), _minIndex1(minIndex1), _maxIndex1(maxIndex1), _minIndex2(minIndex2), _maxIndex2(maxIndex2) {
  182 + _paramDataOutput = _paramOutput;
  183 + }
  184 +
  185 + virtual ~SumIntoTableIndexes2DTwoRanges() {
  186 + }
  187 +
  188 + /**
  189 + * @overload Operation::write(ParamDataIndexInfo &pParamDataIndexInfo)
  190 + */
  191 + void write(ParamDataIndexInfo &pParamDataIndexInfo) {
  192 + for (unsigned int _index = pParamDataIndexInfo._startIndex ;
  193 + _index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
  194 + ++_index)
  195 + {
  196 + double crtTime = _paramInput.getTime(_index);
  197 + Tab2DData<DataType> inputElt = _paramInput.get(_index);
  198 +
  199 + DataType outputElt = 0;
  200 +
  201 + for (int i = _minIndex1; i <= _maxIndex1; ++i) {
  202 + for (int j = _minIndex2; j <= _maxIndex2; ++j) {
  203 + if (_table1RelatedDim == 0) {
  204 + if (isNAN(inputElt[i][j]))
  205 + continue;
  206 + outputElt += inputElt[i][j];
  207 + }
  208 + else {
  209 + if (isNAN(inputElt[j][i]))
  210 + continue;
  211 + outputElt += inputElt[j][i];
  212 + }
  213 + }
  214 + }
  215 +
  216 + _paramOutput->pushTime(crtTime);
  217 + _paramOutput->getDataList().push_back(outputElt);
  218 + }
  219 + }
  220 +
  221 +private:
  222 + /**<
  223 + * @brief It is the channel of data derived
  224 + */
  225 + ParamDataSpec<Tab2DData<DataType> > &_paramInput;
  226 +
  227 + ParamDataSpec<DataType> *_paramOutput;
  228 +
  229 + int _table1RelatedDim;
  230 +
  231 + int _minIndex1;
  232 +
  233 + int _maxIndex1;
  234 +
  235 + int _minIndex2;
  236 +
  237 + int _maxIndex2;
  238 +};
  239 +
  240 +
  241 +} /* namespace SumIntoTableIndexes */
  242 +} /* namespace Parameters */
  243 +} /* namespace AMDA */
  244 +#endif /* SUMINTOTABLEINDEXES_HH_ */
... ...
src/ExternLib/sum_into_table_indexes/SumIntoTableIndexesCreator.hh 0 → 100644
  Diff comments   View file @a84c613
... ... @@ -0,0 +1,179 @@
  1 +/*
  2 + * SumIntoTableIndexesCreator.hh
  3 + *
  4 + * Created on: Mar 26, 2019
  5 + * Author: AKKA IS
  6 + */
  7 +
  8 +#ifndef FRAMEINTOTABLEINDEXESCREATOR_HH_
  9 +#define FRAMEINTOTABLEINDEXESCREATOR_HH_
  10 +
  11 +#include "ParamData.hh"
  12 +#include "VisitorOfParamData.hh"
  13 +#include "SumIntoTableIndexes.hh"
  14 +#include "AMDA_exception.hh"
  15 +
  16 +namespace AMDA {
  17 +namespace Parameters {
  18 +
  19 +/**
  20 + * @class SumIntoTableIndexesCreator
  21 + * @brief Creator of the Operation SumIntoTableIndexes parameterized with ParamData input type.
  22 + * @details Implement the interface VisitorOfParamData.
  23 + */
  24 +class SumIntoTableIndexesCreator : public VisitorOfParamData {
  25 +public:
  26 + /**
  27 + * @brief Constructor.
  28 + */
  29 + SumIntoTableIndexesCreator(Process& pProcess, ParamData& paramInput, double minIndex1, double maxIndex1, int table1RelatedDim, double minIndex2, double maxIndex2)
  30 + : _process(pProcess), _paramData(paramInput), _operation(NULL), _minIndex1(minIndex1), _maxIndex1(maxIndex1),_table1RelatedDim(table1RelatedDim), _minIndex2(minIndex2), _maxIndex2(maxIndex2) {
  31 + _paramData.accept(*this);
  32 + }
  33 +
  34 + /**
  35 + * @overload VisitorOfParamData::visit(ParamDataScalaireShort *)
  36 + */
  37 + void visit(ParamDataScalaireShort *) { BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported")); }
  38 +
  39 + /**
  40 + * @overload VisitorOfParamData::visit(ParamDataScalaireFloat *)
  41 + */
  42 + void visit(ParamDataScalaireFloat *) { BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported")); }
  43 +
  44 + /**
  45 + * @overload VisitorOfParamData::visit(ParamDataScalaireDouble *)
  46 + */
  47 + void visit(ParamDataScalaireDouble *) { BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported")); }
  48 +
  49 + /**
  50 + * @overload VisitorOfParamData::visit(ParamDataScalaireLongDouble *)
  51 + */
  52 + void visit(ParamDataScalaireLongDouble *) { BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported")); }
  53 +
  54 + /**
  55 + * @overload VisitorOfParamData::visit(ParamDataScalaireInt *)
  56 + */
  57 + void visit(ParamDataScalaireInt *) { BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported")); }
  58 +
  59 + /**
  60 + * @overload VisitorOfParamData::visit(ParamDataLogicalData *)
  61 + */
  62 + void visit(ParamDataLogicalData *) { BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported")); }
  63 +
  64 + /**
  65 + * @overload VisitorOfParamData::visit(ParamDataTab1DShort *)
  66 + */
  67 + void visit(ParamDataTab1DShort *) {_operation = new SumIntoTableIndexes::SumIntoTableIndexes1D<short>( _process, dynamic_cast<ParamDataTab1DShort &>(_paramData), _minIndex1, _maxIndex1);}
  68 +
  69 + /**
  70 + * @overload VisitorOfParamData::visit(ParamDataTab1DFloat *)
  71 + */
  72 + void visit(ParamDataTab1DFloat *) {_operation = new SumIntoTableIndexes::SumIntoTableIndexes1D<float>( _process, dynamic_cast<ParamDataTab1DFloat &>(_paramData), _minIndex1, _maxIndex1);}
  73 +
  74 + /**
  75 + * @overload VisitorOfParamData::visit(ParamDataTab1DDouble *)
  76 + */
  77 + void visit(ParamDataTab1DDouble *) {_operation = new SumIntoTableIndexes::SumIntoTableIndexes1D<double>( _process, dynamic_cast<ParamDataTab1DDouble &>(_paramData), _minIndex1, _maxIndex1);}
  78 +
  79 + /**
  80 + * @overload VisitorOfParamData::visit(ParamDataTab1DLongDouble *)
  81 + */
  82 + void visit(ParamDataTab1DLongDouble *) {_operation = new SumIntoTableIndexes::SumIntoTableIndexes1D<long double>( _process, dynamic_cast<ParamDataTab1DLongDouble &>(_paramData), _minIndex1, _maxIndex1);}
  83 +
  84 + /**
  85 + * @overload VisitorOfParamData::visit(ParamDataTab1DInt *)
  86 + */
  87 + void visit(ParamDataTab1DInt *) {_operation = new SumIntoTableIndexes::SumIntoTableIndexes1D<int>( _process, dynamic_cast<ParamDataTab1DInt &>(_paramData), _minIndex1, _maxIndex1);}
  88 +
  89 + /**
  90 + * @overload VisitorOfParamData::visit(ParamDataTab1DLogicalData *)
  91 + */
  92 + void visit(ParamDataTab1DLogicalData *) { BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported")); }
  93 +
  94 + /**
  95 + * @overload VisitorOfParamData::visit(ParamDataTab2DShort *)
  96 + */
  97 + void visit(ParamDataTab2DShort *) {
  98 + if (_maxIndex2 < 0) {
  99 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DOneRange<short>(_process, dynamic_cast<ParamDataTab2DShort &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim);
  100 + }
  101 + else {
  102 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DTwoRanges<short>(_process, dynamic_cast<ParamDataTab2DShort &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim, _minIndex2, _maxIndex2);
  103 + }
  104 + }
  105 +
  106 + /**
  107 + * @overload VisitorOfParamData::visit(ParamDataTab2DFloat *)
  108 + */
  109 + void visit(ParamDataTab2DFloat *) {
  110 + if (_maxIndex2 < 0) {
  111 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DOneRange<float>(_process, dynamic_cast<ParamDataTab2DFloat &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim);
  112 + }
  113 + else {
  114 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DTwoRanges<float>(_process, dynamic_cast<ParamDataTab2DFloat &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim, _minIndex2, _maxIndex2);
  115 + }
  116 + }
  117 +
  118 + /**
  119 + * @overload VisitorOfParamData::visit(ParamDataTab2DDouble *)
  120 + */
  121 + void visit(ParamDataTab2DDouble *) {
  122 + if (_maxIndex2 < 0) {
  123 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DOneRange<double>(_process, dynamic_cast<ParamDataTab2DDouble &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim);
  124 + }
  125 + else {
  126 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DTwoRanges<double>(_process, dynamic_cast<ParamDataTab2DDouble &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim, _minIndex2, _maxIndex2);
  127 + }
  128 + }
  129 +
  130 + /**
  131 + * @overload VisitorOfParamData::visit(ParamDataTab2DLongDouble *)
  132 + */
  133 + void visit(ParamDataTab2DLongDouble *) {
  134 + if (_maxIndex2 < 0) {
  135 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DOneRange<long double>(_process, dynamic_cast<ParamDataTab2DLongDouble &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim);
  136 + }
  137 + else {
  138 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DTwoRanges<long double>(_process, dynamic_cast<ParamDataTab2DLongDouble &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim, _minIndex2, _maxIndex2);
  139 + }
  140 + }
  141 +
  142 + /**
  143 + * @overload VisitorOfParamData::visit(ParamDataTab2DInt *)
  144 + */
  145 + void visit(ParamDataTab2DInt *) {
  146 + if (_maxIndex2 < 0) {
  147 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DOneRange<int>(_process, dynamic_cast<ParamDataTab2DInt &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim);
  148 + }
  149 + else {
  150 + _operation = new SumIntoTableIndexes::SumIntoTableIndexes2DTwoRanges<int>(_process, dynamic_cast<ParamDataTab2DInt &>(_paramData), _minIndex1, _maxIndex1, _table1RelatedDim, _minIndex2, _maxIndex2);
  151 + }
  152 + }
  153 +
  154 + /**
  155 + * @overload VisitorOfParamData::visit(ParamDataTab2DLogicalData *)
  156 + */
  157 + void visit(ParamDataTab2DLogicalData *) {
  158 + BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("SumIntoTableIndexes operation not supported"));
  159 + }
  160 +
  161 + /**
  162 + * @brief get the Deriv parameterized operation.
  163 + */
  164 + Operation * getOperation() const { return _operation; }
  165 +
  166 +private:
  167 + Process &_process;
  168 + ParamData &_paramData;
  169 + Operation *_operation;
  170 + int _minIndex1;
  171 + int _maxIndex1;
  172 + int _table1RelatedDim;
  173 + int _minIndex2;
  174 + int _maxIndex2;
  175 +};
  176 +
  177 +} /* namespace Parameters */
  178 +} /* namespace AMDA */
  179 +#endif /* FRAMEINTOTABLEINDEXESCREATOR_HH_ */
... ...