detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-15 06:17:12 +02:00
Code Issues Actions Packages Releases Activity

getHostname

Browse Source
This commit is contained in:
Erik Frojdh
2020-04-27 17:03:52 +02:00
parent d66df844e5
commit b90f9b046f
6 changed files with 134 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
slsDetectorSoftware/src/Detector.cpp
View File

@ -9,6 +9,8 @@
#include "Receiver.h" #include "Receiver.h"
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
#include "versionAPI.h" #include "versionAPI.h"
#include "Parallel.h"
#include "MaskGenerator.h"
#include <fstream> #include <fstream>
@ -755,15 +757,17 @@ Result<bool> Detector::getUseReceiverFlag(Positions pos) const {
} }
Result<std::string> Detector::getRxHostname(const int udpInterface, Positions pos) const { Result<std::string> Detector::getRxHostname(const int udpInterface, Positions pos) const {
switch (udpInterface) { // switch (udpInterface) {
case 1: // case 1:
return pimpl->Parallel1(&Receiver::getHostname, pos, {}); // return pimpl->Parallel1(&Receiver::getHostname, pos, {});
case 2: // case 2:
return pimpl->Parallel2(&Receiver::getHostname, pos, {}); // return pimpl->Parallel2(&Receiver::getHostname, pos, {});
default: // default:
throw RuntimeError("Invalid udp interface number " + // throw RuntimeError("Invalid udp interface number " +
std::to_string(udpInterface)); // std::to_string(udpInterface));
} // }
return pimpl->getHostname(pos, udpInterface);
// return experimental::Parallel(&Receiver::getHostname, receivers, MaskGenerator(){receivers});
} }
void Detector::setRxHostname(const int udpInterface, const std::string &hostname, Positions pos) { void Detector::setRxHostname(const int udpInterface, const std::string &hostname, Positions pos) {

138
slsDetectorSoftware/src/DetectorImpl.cpp
View File

@ -1,5 +1,7 @@
#include "DetectorImpl.h" #include "DetectorImpl.h"
#include "Module.h" #include "Module.h"
#include "Parallel.h"
#include "MaskGenerator.h"
#include "Receiver.h" #include "Receiver.h"
#include "SharedMemory.h" #include "SharedMemory.h"
#include "ZmqSocket.h" #include "ZmqSocket.h"
@ -313,6 +315,11 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
updateDetectorSize(); updateDetectorSize();
} }
Result<std::string> DetectorImpl::getHostname(Positions pos, int udp_interface){
LOG(logWARNING) << ToString(pos) << ": " << udp_interface;
return experimental::Parallel(&Receiver::getHostname, receivers, MaskGenerator(pos, udp_interface).mask(receivers));
}
void DetectorImpl::setHostname(const std::vector<std::string> &name, void DetectorImpl::setHostname(const std::vector<std::string> &name,
const std::vector<int> &port) { const std::vector<int> &port) {
if (name.size() != port.size()) { if (name.size() != port.size()) {
@ -371,46 +378,46 @@ int DetectorImpl::getNumberofReceiversPerModule() const {
} }
void DetectorImpl::initReceiver(const int udpInterface) { void DetectorImpl::initReceiver(const int udpInterface) {
// if (udpInterface == 1) { LOG(logWARNING) << "interface" << udpInterface;
// if (receivers.size() != 0) { if (udpInterface == 1) {
// throw RuntimeError("receiver vector already initialized"); if (receivers.size() != 0) {
// } throw RuntimeError("receiver vector already initialized");
// int tcpPort = DEFAULT_RX_PORTNO; }
// int zmqPort = DEFAULT_ZMQ_CL_PORTNO; int tcpPort = DEFAULT_RX_PORTNO;
// try { int zmqPort = DEFAULT_ZMQ_CL_PORTNO;
// for (int iModule = 0; iModule < size(); ++iModule) { try {
// receivers.resize(detectors.size()); for (int iModule = 0; iModule < size(); ++iModule) {
// receivers[iModule].push_back( receivers.resize(detectors.size(), 1, 1);
// sls::make_unique<Receiver>(detectorId, iModule, 0, receivers(iModule, 0, 0) = sls::make_unique<Receiver>(
// 0, tcpPort++, "", zmqPort++)); detectorId, iModule, 0, 0, tcpPort++, "", zmqPort++);
// detectors[iModule]->setNumberOfReceivers(1); detectors[iModule]->setNumberOfReceivers(1);
// } }
// } catch (...) { } catch (...) {
// receivers.clear(); receivers.clear();
// throw; throw;
// } }
// } else if (udpInterface == 2) { } else if (udpInterface == 2) {
// if (receivers2.size() != 0) { if (receivers.size(1) == 2) {
// throw RuntimeError("receiver2 vector already initialized"); throw RuntimeError("receiver2 vector already initialized");
// } }
// int tcpPort = DEFAULT_RX_PORTNO + size(); int tcpPort = DEFAULT_RX_PORTNO + size();
// int zmqPort = DEFAULT_ZMQ_CL_PORTNO + size(); int zmqPort = DEFAULT_ZMQ_CL_PORTNO + size();
// try { try {
// for (int iModule = 0; iModule < size(); ++iModule) { for (int iModule = 0; iModule < size(); ++iModule) {
// receivers2.resize(detectors.size()); receivers.resize(detectors.size(), 2, 1);
// receivers2[iModule].push_back( receivers(iModule, 1, 0) =
// sls::make_unique<Receiver>(detectorId, iModule, 1, sls::make_unique<Receiver>(detectorId, iModule, 1,
// 0, tcpPort++, "", zmqPort++)); 0, tcpPort++, "", zmqPort++);
// detectors[iModule]->setNumberOfReceivers2(1); detectors[iModule]->setNumberOfReceivers2(1);
// } }
// } catch (...) { } catch (...) {
// receivers2.clear(); receivers.clear();
// throw; throw;
// } }
// } else { } else {
// throw RuntimeError("Invalid udp interface number " + throw RuntimeError("Invalid udp interface number " +
// std::to_string(udpInterface)); std::to_string(udpInterface));
// } }
} }
bool DetectorImpl::isReceiverInitialized(const int udpInterface) { bool DetectorImpl::isReceiverInitialized(const int udpInterface) {
@ -478,45 +485,50 @@ void DetectorImpl::configureReceiver(const int udpInterface, Positions pos,
void DetectorImpl::configureReceiver(const int udpInterface, int module_id, void DetectorImpl::configureReceiver(const int udpInterface, int module_id,
const std::string &hostname, const std::string &hostname,
const int port) { const int port) {
LOG(logWARNING) << "HEY";
if (Parallel(&Module::getRunStatus, {}).squash(defs::ERROR) == if (Parallel(&Module::getRunStatus, {}).squash(defs::ERROR) ==
defs::RUNNING) { defs::RUNNING) {
LOG(logWARNING) << "Acquisition already running, Stopping it."; LOG(logWARNING) << "Acquisition already running, Stopping it.";
Parallel(&Module::stopAcquisition, {}); Parallel(&Module::stopAcquisition, {});
} }
LOG(logWARNING) << "HEY2";
if (!isReceiverInitialized(udpInterface)) { if (!isReceiverInitialized(udpInterface)) {
initReceiver(udpInterface); initReceiver(udpInterface);
} }
LOG(logWARNING) << "ds " << detectors.size() << "\nmodule id: " << module_id;
auto t = detectors[module_id]->getReceiverParameters(); auto t = detectors[module_id]->getReceiverParameters();
LOG(logWARNING) << "Shape: " << ToString(receivers.shape());
receivers(module_id, udpInterface, 0)->setTCPPort(port); //TODO! FIX!!!
receivers(module_id, udpInterface, 0)->setHostname(hostname); receivers(module_id, udpInterface-1, 0)->setTCPPort(port);
auto m = receivers(module_id, udpInterface, 0)->configure(t); receivers(module_id, udpInterface-1, 0)->setHostname(hostname);
LOG(logWARNING) << "HEY3";
auto m = receivers(module_id, udpInterface-1, 0)->configure(t);
LOG(logWARNING) << "HEY4";
if (m != 0) { if (m != 0) {
if (udpInterface == 0) { if (udpInterface == 1) {
detectors[module_id]->setDestinationUDPMAC(m); detectors[module_id]->setDestinationUDPMAC(m);
} else if (udpInterface == 1) { } else if (udpInterface == 2) {
detectors[module_id]->setDestinationUDPMAC2(m); detectors[module_id]->setDestinationUDPMAC2(m);
} else { } else {
throw sls::RuntimeError("Incorrect udp interface id"); throw sls::RuntimeError("Incorrect udp interface id");
} }
} }
// if (udpInterface == 1) { if (udpInterface == 1) {
// receivers[module_id][0]->setTCPPort(port); receivers(module_id, 0, 0)->setTCPPort(port);
// receivers[module_id][0]->setHostname(hostname); receivers(module_id, 0, 0)->setHostname(hostname);
// auto m = receivers[module_id][0]->configure(t); auto m = receivers(module_id,0,0)->configure(t);
// if (m != 0) { if (m != 0) {
// detectors[module_id]->setDestinationUDPMAC(m); detectors[module_id]->setDestinationUDPMAC(m);
// } }
// } else { } else {
// receivers2[module_id][0]->setTCPPort(port); receivers(module_id, 1, 0)->setTCPPort(port);
// receivers2[module_id][0]->setHostname(hostname); receivers(module_id, 1, 0)->setHostname(hostname);
// auto m = receivers2[module_id][0]->configure(t); auto m = receivers(module_id, 1, 0)->configure(t);
// if (m != 0) { if (m != 0) {
// detectors[module_id]->setDestinationUDPMAC2(m); detectors[module_id]->setDestinationUDPMAC2(m);
// } }
// } }
} }
void DetectorImpl::updateDetectorSize() { void DetectorImpl::updateDetectorSize() {

4
slsDetectorSoftware/src/DetectorImpl.h
View File

@ -82,6 +82,8 @@ class DetectorImpl : public virtual slsDetectorDefs {
*/ */
virtual ~DetectorImpl(); virtual ~DetectorImpl();
template <class CT> struct NonDeduced { using type = CT; }; template <class CT> struct NonDeduced { using type = CT; };
template <typename RT, typename... CT> template <typename RT, typename... CT>
sls::Result<RT> Parallel(RT (sls::Module::*somefunc)(CT...), sls::Result<RT> Parallel(RT (sls::Module::*somefunc)(CT...),
@ -302,6 +304,8 @@ class DetectorImpl : public virtual slsDetectorDefs {
void setHostname(const std::vector<std::string> &name, void setHostname(const std::vector<std::string> &name,
const std::vector<int> &port); const std::vector<int> &port);
Result<std::string> getHostname(Positions pos, int udp_interface);
int getNumberofReceiversPerModule() const; int getNumberofReceiversPerModule() const;
void initReceiver(const int udpInterface); void initReceiver(const int udpInterface);
bool isReceiverInitialized(const int udpInterface); bool isReceiverInitialized(const int udpInterface);

12
slsDetectorSoftware/src/MaskGenerator.h
View File

@ -9,7 +9,7 @@ class MaskGenerator {
enum class OperationMode { ALL, ROW, SINGLE }; enum class OperationMode { ALL, ROW, SINGLE };
OperationMode mode_{OperationMode::ALL}; OperationMode mode_{OperationMode::ALL};
std::vector<size_t> idx0; std::vector<int> idx0; // hack
size_t x_{0}; size_t x_{0};
size_t y_{0}; size_t y_{0};
size_t z_{0}; size_t z_{0};
@ -22,15 +22,21 @@ class MaskGenerator {
MaskGenerator(size_t i, size_t j, size_t k) MaskGenerator(size_t i, size_t j, size_t k)
: mode_(OperationMode::SINGLE), x_(i), y_(j), z_(k) {} : mode_(OperationMode::SINGLE), x_(i), y_(j), z_(k) {}
explicit MaskGenerator(const std::vector<size_t> vec) explicit MaskGenerator(const std::vector<int> vec)
: mode_(OperationMode::ROW), idx0(vec) {} : mode_(OperationMode::ROW), idx0(vec) {}
explicit MaskGenerator(const std::vector<int> vec, size_t y)
: mode_(OperationMode::ROW), idx0(vec), y_(y) {}
template <typename T> Container3<bool> mask(const Container3<T>& cont) { template <typename T> Container3<bool> mask(const Container3<T>& cont) {
return mask(cont.shape()); return mask(cont.shape());
} }
Container3<bool> mask(std::array<size_t, 3> shape) { Container3<bool> mask(std::array<size_t, 3> shape) {
Container3<bool> m(shape); Container3<bool> m(shape);
if (idx0.size()== 1 && idx0[0] == -1){
idx0.resize(m.size(0));
std::iota(begin(idx0), end(idx0), 0);
}
switch (mode_) { switch (mode_) {
case OperationMode::ALL: case OperationMode::ALL:
for (auto &item : m) for (auto &item : m)

28
slsDetectorSoftware/src/Parallel.h
View File

@ -10,19 +10,20 @@ end up moving temporary objects into the first called function
leaving the other ones with moved from args. leaving the other ones with moved from args.
*/ */
namespace experimental{ namespace experimental {
using sls::Container3;
template <class CT> struct NonDeduced { using type = CT; }; template <class CT> struct NonDeduced { using type = CT; };
template <typename RT, typename Class, typename... CT> template <typename RT, typename Class, typename... CT>
sls::Result<RT> sls::Result<RT> Parallel(RT (Class::*func)(CT...) const,
Parallel(RT (Class::*func)(CT...) const, const Container3<Class> &objects, const Container3<std::unique_ptr<Class>> &objects,
const Container3<bool> &mask, typename NonDeduced<CT>::type... Args) { const Container3<bool> &mask,
typename NonDeduced<CT>::type... Args) {
std::vector<std::future<RT>> futures; std::vector<std::future<RT>> futures;
for (size_t i = 0; i < objects.size(); ++i) { for (size_t i = 0; i < objects.size(); ++i) {
if (mask[i]) if (mask[i])
futures.push_back( futures.push_back(
std::async(std::launch::async, func, &objects[i], Args...)); std::async(std::launch::async, func, objects[i].get(), Args...));
} }
sls::Result<RT> result; sls::Result<RT> result;
for (auto &f : futures) { for (auto &f : futures) {
@ -32,9 +33,10 @@ Parallel(RT (Class::*func)(CT...) const, const Container3<Class> &objects,
} }
template <typename RT, typename Class, typename... CT> template <typename RT, typename Class, typename... CT>
sls::Result<RT> sls::Result<RT> Parallel(RT (Class::*func)(CT...),
Parallel(RT (Class::*func)(CT...), const Container3<Class> &objects, const Container3<std::unique_ptr<Class>> &objects,
const Container3<bool> &mask, typename NonDeduced<CT>::type... Args) { const Container3<bool> &mask,
typename NonDeduced<CT>::type... Args) {
std::vector<std::future<RT>> futures; std::vector<std::future<RT>> futures;
for (size_t i = 0; i < objects.size(); ++i) { for (size_t i = 0; i < objects.size(); ++i) {
if (mask[i]) if (mask[i])
@ -50,7 +52,8 @@ Parallel(RT (Class::*func)(CT...), const Container3<Class> &objects,
template <typename Class, typename... CT> template <typename Class, typename... CT>
void Parallel(void (Class::*func)(CT...) const, void Parallel(void (Class::*func)(CT...) const,
const Container3<Class> &objects, const Container3<bool> &mask, const Container3<std::unique_ptr<Class>> &objects,
const Container3<bool> &mask,
typename NonDeduced<CT>::type... Args) { typename NonDeduced<CT>::type... Args) {
std::vector<std::future<void>> futures; std::vector<std::future<void>> futures;
for (size_t i = 0; i < objects.size(); ++i) { for (size_t i = 0; i < objects.size(); ++i) {
@ -64,7 +67,8 @@ void Parallel(void (Class::*func)(CT...) const,
} }
template <typename Class, typename... CT> template <typename Class, typename... CT>
void Parallel(void (Class::*func)(CT...), const Container3<Class> &objects, void Parallel(void (Class::*func)(CT...),
const Container3<std::unique_ptr<Class>> &objects,
const Container3<bool> &mask, const Container3<bool> &mask,
typename NonDeduced<CT>::type... Args) { typename NonDeduced<CT>::type... Args) {
@ -78,4 +82,4 @@ void Parallel(void (Class::*func)(CT...), const Container3<Class> &objects,
f.get(); f.get();
} }
} } // namespace experimental

19
slsDetectorSoftware/tests/test-MaskGenerator.cpp
View File

@ -23,14 +23,14 @@ TEST_CASE("With std::vector we give back the first index and 0, 0") {
Container3<int> rec{14, 1, 3}; Container3<int> rec{14, 1, 3};
auto m = MaskGenerator(std::vector<size_t>{0, 3, 5}).mask(rec.shape()); auto m = MaskGenerator(std::vector<int>{0, 3, 5}).mask(rec.shape());
CHECK(m.shape() == std::array<size_t, 3>{14, 1, 3}); CHECK(m.shape() == std::array<size_t, 3>{14, 1, 3});
CHECK(m(0, 0, 0) == true); CHECK(m(0, 0, 0) == true);
CHECK(m(3, 0, 0) == true); CHECK(m(3, 0, 0) == true);
CHECK(m(5, 0, 0) == true); CHECK(m(5, 0, 0) == true);
std::vector<size_t> positions(rec.size(0)); std::vector<int> positions(rec.size(0));
std::iota(begin(positions), end(positions), 0); std::iota(begin(positions), end(positions), 0);
positions.erase(std::remove(positions.begin(), positions.end(), 0), positions.erase(std::remove(positions.begin(), positions.end(), 0),
positions.end()); positions.end());
@ -81,4 +81,19 @@ TEST_CASE("With three numbers we get x,y,z") {
} }
} }
} }
}
TEST_CASE("Passing in -1 as the only element in the vector gives all rows"){
Container3<int> r{3,3,3};
std::vector<int> vec{-1};
auto m = MaskGenerator(vec, 0).mask(r);
REQUIRE(m.shape() == std::array<size_t, 3>{3,3,3});
CHECK(m(0,0,0) == true);
CHECK(m(1,0,0) == true);
CHECK(m(2,0,0) == true);
CHECK(m(0,1,0) == false);
CHECK(m(0,2,0) == false);
CHECK(m(0,0,1) == false);
} }