SplitArray.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "ApplicationModule.h"
#include "ArrayAccessor.h"
 
namespace ChimeraTK {
 
  template<typename TYPE>
  struct WriteSplitArrayModule : public ApplicationModule {
    WriteSplitArrayModule(EntityOwner* owner, const std::string& name, const std::string& description, size_t nGroups,
        size_t nElemsPerGroup = 1);
 
    WriteSplitArrayModule() {}
 
    std::vector<ArrayPushInput<TYPE>> input;
 
    ArrayOutput<TYPE> output;
 
    void mainLoop();
 
   private:
    size_t _nGroups;
    size_t _nElemsPerGroup;
  };
 
  /********************************************************************************************************************/
 
  template<typename TYPE>
  struct ReadSplitArrayModule : public ApplicationModule {
    ReadSplitArrayModule(EntityOwner* owner, const std::string& name, const std::string& description, size_t nGroups,
        size_t nElemsPerGroup = 1);
 
    ReadSplitArrayModule() {}
 
    std::vector<ArrayOutput<TYPE>> output;
 
    ArrayPushInput<TYPE> input;
 
    void mainLoop();
 
   private:
    size_t _nGroups;
    size_t _nElemsPerGroup;
  };
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<typename TYPE>
  WriteSplitArrayModule<TYPE>::WriteSplitArrayModule(EntityOwner* owner, const std::string& name,
      const std::string& description, size_t nGroups, size_t nElemsPerGroup)
  : ApplicationModule(owner, name, description), output(this, "output", "", nGroups * nElemsPerGroup, "Output array"),
    _nGroups(nGroups), _nElemsPerGroup(nElemsPerGroup) {
    for(size_t i = 0; i < _nGroups; ++i) {
      std::string comment;
      if(_nElemsPerGroup == 1) {
        comment = "The element " + std::to_string(i) + " of the output array";
      }
      else {
        comment = "The elements " + std::to_string(i * _nElemsPerGroup) + " to " +
            std::to_string((i + 1) * _nElemsPerGroup - 1) + " of the output array";
      }
      input.push_back(ArrayPushInput<TYPE>(this, "input" + std::to_string(i), "", _nElemsPerGroup, comment));
    }
  }
 
  /********************************************************************************************************************/
 
  template<typename TYPE>
  void WriteSplitArrayModule<TYPE>::mainLoop() {
    auto readGroup = readAnyGroup();
    while(true) {
      // write the array from the individual elements
      for(size_t i = 0; i < _nGroups; ++i) {
        for(size_t k = 0; k < _nElemsPerGroup; ++k) {
          output[i * _nElemsPerGroup + k] = input[i][k];
        }
      }
      output.write();
 
      // wait for new input values (at the end, since we want to process the
      // initial values first)
      readGroup.readAny();
    }
  }
 
  /********************************************************************************************************************/
 
  template<typename TYPE>
  ReadSplitArrayModule<TYPE>::ReadSplitArrayModule(EntityOwner* owner, const std::string& name,
      const std::string& description, size_t nGroups, size_t nElemsPerGroup)
  : ApplicationModule(owner, name, description), input(this, "input", "", nGroups * nElemsPerGroup, "Input array"),
    _nGroups(nGroups), _nElemsPerGroup(nElemsPerGroup) {
    for(size_t i = 0; i < _nGroups; ++i) {
      std::string comment;
      if(_nElemsPerGroup == 1) {
        comment = "The element " + std::to_string(i) + " of the input array";
      }
      else {
        comment = "The elements " + std::to_string(i * _nElemsPerGroup) + " to " +
            std::to_string((i + 1) * _nElemsPerGroup - 1) + " of the input array";
      }
      output.push_back(ArrayOutput<TYPE>(this, "output" + std::to_string(i), "", _nElemsPerGroup, comment));
    }
  }
 
  /********************************************************************************************************************/
 
  template<typename TYPE>
  void ReadSplitArrayModule<TYPE>::mainLoop() {
    while(true) {
      // write the array from the individual elements
      for(size_t i = 0; i < _nGroups; ++i) {
        for(size_t k = 0; k < _nElemsPerGroup; ++k) {
          input[i][k] = output[i * _nElemsPerGroup + k];
        }
      }
      writeAll();
 
      // wait for new input values (at the end, since we want to process the
      // initial values first)
      input.read();
    }
  }
 
} // namespace ChimeraTK