detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-23 06:50:02 +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
Show Stats 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 "sls_detector_defs.h"
#include "versionAPI.h"
#include "Parallel.h"
#include "MaskGenerator.h"
#include <fstream>
@ -755,15 +757,17 @@ Result<bool> Detector::getUseReceiverFlag(Positions pos) const {
}
Result<std::string> Detector::getRxHostname(const int udpInterface, Positions pos) const {
switch (udpInterface) {
case 1:
return pimpl->Parallel1(&Receiver::getHostname, pos, {});
case 2:
return pimpl->Parallel2(&Receiver::getHostname, pos, {});
default:
throw RuntimeError("Invalid udp interface number " +
std::to_string(udpInterface));
}
// switch (udpInterface) {
// case 1:
// return pimpl->Parallel1(&Receiver::getHostname, pos, {});
// case 2:
// return pimpl->Parallel2(&Receiver::getHostname, pos, {});
// default:
// throw RuntimeError("Invalid udp interface number " +
// 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) {

138
slsDetectorSoftware/src/DetectorImpl.cpp
View File

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

4
slsDetectorSoftware/src/DetectorImpl.h
View File

@ -82,6 +82,8 @@ class DetectorImpl : public virtual slsDetectorDefs {
*/
virtual ~DetectorImpl();
template <class CT> struct NonDeduced { using type = CT; };
template <typename RT, typename... 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,
const std::vector<int> &port);
Result<std::string> getHostname(Positions pos, int udp_interface);
int getNumberofReceiversPerModule() const;
void initReceiver(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 };
OperationMode mode_{OperationMode::ALL};
std::vector<size_t> idx0;
std::vector<int> idx0; // hack
size_t x_{0};
size_t y_{0};
size_t z_{0};
@ -22,15 +22,21 @@ class MaskGenerator {
MaskGenerator(size_t i, size_t j, size_t 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) {}
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) {
return mask(cont.shape());
}
Container3<bool> mask(std::array<size_t, 3> 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_) {
case OperationMode::ALL:
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.
*/
namespace experimental{
namespace experimental {
using sls::Container3;
template <class CT> struct NonDeduced { using type = CT; };
template <typename RT, typename Class, typename... CT>
sls::Result<RT>
Parallel(RT (Class::*func)(CT...) const, const Container3<Class> &objects,
const Container3<bool> &mask, typename NonDeduced<CT>::type... Args) {
sls::Result<RT> Parallel(RT (Class::*func)(CT...) const,
const Container3<std::unique_ptr<Class>> &objects,
const Container3<bool> &mask,
typename NonDeduced<CT>::type... Args) {
std::vector<std::future<RT>> futures;
for (size_t i = 0; i < objects.size(); ++i) {
if (mask[i])
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;
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>
sls::Result<RT>
Parallel(RT (Class::*func)(CT...), const Container3<Class> &objects,
const Container3<bool> &mask, typename NonDeduced<CT>::type... Args) {
sls::Result<RT> Parallel(RT (Class::*func)(CT...),
const Container3<std::unique_ptr<Class>> &objects,
const Container3<bool> &mask,
typename NonDeduced<CT>::type... Args) {
std::vector<std::future<RT>> futures;
for (size_t i = 0; i < objects.size(); ++i) {
if (mask[i])
@ -50,7 +52,8 @@ Parallel(RT (Class::*func)(CT...), const Container3<Class> &objects,
template <typename Class, typename... CT>
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) {
std::vector<std::future<void>> futures;
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>
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,
typename NonDeduced<CT>::type... Args) {
@ -78,4 +82,4 @@ void Parallel(void (Class::*func)(CT...), const Container3<Class> &objects,
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};
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(0, 0, 0) == true);
CHECK(m(3, 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);
positions.erase(std::remove(positions.begin(), positions.end(), 0),
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);
}