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

3. Dev/voltage to power (#816)

Browse Source 
* getVoltageList, getVoltage /set, getMeasuredVoltage, getVoltageNames /set, getVoltageIndex moved to 'Power' as its misleading

* added cstdint and names slowadc,  added division to mV

* changed uV to mV in command line slow adc help. removed all python slowadcs (as it was already implemented as slowadc

---------

Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com>
This commit is contained in:
maliakal_d
2023-10-02 11:11:28 +02:00
committed by GitHub
parent d003a6d8e0
commit dad3dc3e46
20 changed files with 414 additions and 610 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
slsDetectorSoftware/include/sls/Detector.h
View File

@ -1629,21 +1629,21 @@ class Detector {
/** [CTB] in MHZ */
Result<int> getSYNCClock(Positions pos = {}) const;
/** gets list of voltage enums */
std::vector<defs::dacIndex> getVoltageList() const;
/** gets list of power enums */
std::vector<defs::dacIndex> getPowerList() const;
/** gets list of slow adc enums */
std::vector<defs::dacIndex> getSlowADCList() const;
/** [CTB] */
Result<int> getVoltage(defs::dacIndex index, Positions pos = {}) const;
Result<int> getPower(defs::dacIndex index, Positions pos = {}) const;
/**
* [CTB] mV
* [Ctb] Options: V_LIMIT, V_POWER_A, V_POWER_B, V_POWER_C,
* V_POWER_D, V_POWER_IO, V_POWER_CHIP
*/
void setVoltage(defs::dacIndex index, int value, Positions pos = {});
void setPower(defs::dacIndex index, int value, Positions pos = {});
/**
* [CTB] Options: [0- 4] or [1V, 1.14V, 1.33V, 1.6V, 2V]
@ -1711,8 +1711,8 @@ class Detector {
/**
* [CTB] mV
* Options: V_POWER_A, V_POWER_B, V_POWER_C, V_POWER_D, V_POWER_IO */
Result<int> getMeasuredVoltage(defs::dacIndex index,
Positions pos = {}) const;
Result<int> getMeasuredPower(defs::dacIndex index,
Positions pos = {}) const;
/**
* [CTB] mA
@ -1806,19 +1806,19 @@ class Detector {
std::string getSignalName(const int i) const;
/** [CTB] */
void setVoltageNames(const std::vector<std::string> names);
void setPowerNames(const std::vector<std::string> names);
/** [CTB] */
std::vector<std::string> getVoltageNames() const;
std::vector<std::string> getPowerNames() const;
/** [CTB] */
defs::dacIndex getVoltageIndex(const std::string &name) const;
defs::dacIndex getPowerIndex(const std::string &name) const;
/** [CTB] */
void setVoltageName(const defs::dacIndex i, const std::string &name);
void setPowerName(const defs::dacIndex i, const std::string &name);
/** [CTB] */
std::string getVoltageName(const defs::dacIndex i) const;
std::string getPowerName(const defs::dacIndex i) const;
/** [CTB] */
void setSlowADCNames(const std::vector<std::string> names);

2
slsDetectorSoftware/src/CmdProxy.cpp
View File

@ -2719,7 +2719,7 @@ std::string CmdProxy::SlowADC(int action) {
os << cmd << ' ';
if (action == defs::HELP_ACTION) {
os << "[n_channel (0-7 for channel]\n\t[Ctb] Slow "
"ADC channel in uV"
"ADC channel in mV"
<< '\n';
} else if (action == defs::GET_ACTION) {
if (args.size() != 1) {

67
slsDetectorSoftware/src/CmdProxy.h
View File

@ -1053,10 +1053,10 @@ class CmdProxy {
{"signallist", &CmdProxy::signallist},
{"signalname", &CmdProxy::signalname},
{"signalindex", &CmdProxy::signalindex},
{"voltagelist", &CmdProxy::voltagelist},
{"voltagename", &CmdProxy::voltagename},
{"voltageindex", &CmdProxy::voltageindex},
{"voltagevalues", &CmdProxy::voltagevalues},
{"powerlist", &CmdProxy::powerlist},
{"powername", &CmdProxy::powername},
{"powerindex", &CmdProxy::powerindex},
{"powervalues", &CmdProxy::powervalues},
{"slowadclist", &CmdProxy::slowadclist},
{"slowadcname", &CmdProxy::slowadcname},
{"slowadcindex", &CmdProxy::slowadcindex},
@ -1779,22 +1779,21 @@ class CmdProxy {
"[name] \n\t\t[ChipTestBoard] Get "
"the signal index for the given name.");
CTB_NAMED_LIST(voltagelist, getVoltageNames, setVoltageNames,
"[voltagename1 voltagename2 .. voltagename4] "
CTB_NAMED_LIST(powerlist, getPowerNames, setPowerNames,
"[powername1 powername2 .. powername4] "
"\n\t\t[ChipTestBoard] Set "
"the list of voltage names for this board.");
"the list of power names for this board.");
CTB_SINGLE_DACNAME(voltagename, getVoltageName, setVoltageName,
defs::V_POWER_A,
CTB_SINGLE_DACNAME(powername, getPowerName, setPowerName, defs::V_POWER_A,
"[0-4][name] \n\t\t[ChipTestBoard] Set "
"the voltage at the given position to the given name.");
"the power at the given position to the given name.");
CTB_GET_DACINDEX(voltageindex, getVoltageIndex, defs::V_POWER_A,
CTB_GET_DACINDEX(powerindex, getPowerIndex, defs::V_POWER_A,
"[name] \n\t\t[ChipTestBoard] Get "
"the voltage index for the given name.");
"the power index for the given name.");
CTB_VALUES(voltagevalues, getVoltage, getVoltageList, getVoltageNames,
"[name] \n\t\t[ChipTestBoard] Get values of all voltages.");
CTB_VALUES(powervalues, getPower, getPowerList, getPowerNames,
"[name] \n\t\t[ChipTestBoard] Get values of all powers.");
CTB_VALUES(slowadcvalues, getSlowADC, getSlowADCList, getSlowADCNames,
"[name] \n\t\t[ChipTestBoard] Get values of all slow adcs.");
@ -2426,7 +2425,7 @@ class CmdProxy {
GET_COMMAND(syncclk, getSYNCClock,
"[n_clk in MHz]\n\t[Ctb] Sync clock in MHz.");
INTEGER_IND_COMMAND(v_limit, getVoltage, setVoltage, StringTo<int>,
INTEGER_IND_COMMAND(v_limit, getPower, setPower, StringTo<int>,
defs::V_LIMIT,
"[n_value]\n\t[Ctb] Soft limit for power "
"supplies (ctb only) and DACS in mV.");
@ -2468,47 +2467,43 @@ class CmdProxy {
"[n_clk in MHz]\n\t[Ctb] Clock for latching the "
"digital bits in MHz.");
INTEGER_IND_COMMAND(v_a, getVoltage, setVoltage, StringTo<int>,
defs::V_POWER_A,
"[n_value]\n\t[Ctb] Voltage supply a in mV.");
INTEGER_IND_COMMAND(v_a, getPower, setPower, StringTo<int>, defs::V_POWER_A,
"[n_value]\n\t[Ctb] Power supply a in mV.");
INTEGER_IND_COMMAND(v_b, getVoltage, setVoltage, StringTo<int>,
defs::V_POWER_B,
"[n_value]\n\t[Ctb] Voltage supply b in mV.");
INTEGER_IND_COMMAND(v_b, getPower, setPower, StringTo<int>, defs::V_POWER_B,
"[n_value]\n\t[Ctb] Power supply b in mV.");
INTEGER_IND_COMMAND(v_c, getVoltage, setVoltage, StringTo<int>,
defs::V_POWER_C,
"[n_value]\n\t[Ctb] Voltage supply c in mV.");
INTEGER_IND_COMMAND(v_c, getPower, setPower, StringTo<int>, defs::V_POWER_C,
"[n_value]\n\t[Ctb] Power supply c in mV.");
INTEGER_IND_COMMAND(v_d, getVoltage, setVoltage, StringTo<int>,
defs::V_POWER_D,
"[n_value]\n\t[Ctb] Voltage supply d in mV.");
INTEGER_IND_COMMAND(v_d, getPower, setPower, StringTo<int>, defs::V_POWER_D,
"[n_value]\n\t[Ctb] Power supply d in mV.");
INTEGER_IND_COMMAND(
v_io, getVoltage, setVoltage, StringTo<int>, defs::V_POWER_IO,
"[n_value]\n\t[Ctb] Voltage supply io in mV. Minimum 1200 mV. Must "
v_io, getPower, setPower, StringTo<int>, defs::V_POWER_IO,
"[n_value]\n\t[Ctb] Power supply io in mV. Minimum 1200 mV. Must "
"be the first power regulator to be set after fpga reset (on-board "
"detector server start up).");
INTEGER_IND_COMMAND(
v_chip, getVoltage, setVoltage, StringTo<int>, defs::V_POWER_CHIP,
"[n_value]\n\t[Ctb] Voltage supply chip in mV. Do not use it "
v_chip, getPower, setPower, StringTo<int>, defs::V_POWER_CHIP,
"[n_value]\n\t[Ctb] Power supply chip in mV. Do not use it "
"unless "
"you are completely sure you will not fry the board.");
GET_IND_COMMAND(vm_a, getMeasuredVoltage, defs::V_POWER_A, "",
GET_IND_COMMAND(vm_a, getMeasuredPower, defs::V_POWER_A, "",
"\n\t[Ctb] Measured voltage of power supply a in mV.");
GET_IND_COMMAND(vm_b, getMeasuredVoltage, defs::V_POWER_B, "",
GET_IND_COMMAND(vm_b, getMeasuredPower, defs::V_POWER_B, "",
"\n\t[Ctb] Measured voltage of power supply b in mV.");
GET_IND_COMMAND(vm_c, getMeasuredVoltage, defs::V_POWER_C, "",
GET_IND_COMMAND(vm_c, getMeasuredPower, defs::V_POWER_C, "",
"\n\t[Ctb] Measured voltage of power supply c in mV.");
GET_IND_COMMAND(vm_d, getMeasuredVoltage, defs::V_POWER_D, "",
GET_IND_COMMAND(vm_d, getMeasuredPower, defs::V_POWER_D, "",
"\n\t[Ctb] Measured voltage of power supply d in mV.");
GET_IND_COMMAND(vm_io, getMeasuredVoltage, defs::V_POWER_IO, "",
GET_IND_COMMAND(vm_io, getMeasuredPower, defs::V_POWER_IO, "",
"\n\t[Ctb] Measured voltage of power supply io in mV.");
GET_IND_COMMAND(im_a, getMeasuredCurrent, defs::I_POWER_A, "",

46
slsDetectorSoftware/src/CtbConfig.cpp
View File

@ -20,11 +20,11 @@ CtbConfig::CtbConfig() {
for (size_t i = 0; i != num_signals; ++i) {
setSignalName(i, "BIT" + ToString(i));
}
setVoltageName(0, "VA");
setVoltageName(1, "VB");
setVoltageName(2, "VC");
setVoltageName(3, "VD");
setVoltageName(4, "VIO");
setPowerName(0, "VA");
setPowerName(1, "VB");
setPowerName(2, "VC");
setPowerName(3, "VD");
setPowerName(4, "VIO");
for (size_t i = 0; i != num_slowADCs; ++i) {
setSlowADCName(i, "SLOWADC" + ToString(i));
}
@ -54,10 +54,10 @@ void CtbConfig::check_signal_index(size_t i) const {
}
}
void CtbConfig::check_voltage_index(size_t i) const {
if (i >= num_voltages) {
void CtbConfig::check_power_index(size_t i) const {
if (i >= num_powers) {
std::ostringstream oss;
oss << "Invalid Voltage index. Options: 0 - " << num_voltages
oss << "Invalid Power index. Options: 0 - " << num_powers
<< " or V_POWER_A - V_POWER_IO";
throw RuntimeError(oss.str());
}
@ -176,33 +176,33 @@ std::vector<std::string> CtbConfig::getSignalNames() const {
return names;
}
void CtbConfig::setVoltageName(size_t index, const std::string &name) {
check_voltage_index(index);
void CtbConfig::setPowerName(size_t index, const std::string &name) {
check_power_index(index);
check_size(name);
char *dst = &voltagenames[index * name_length];
char *dst = &powernames[index * name_length];
memset(dst, '\0', name_length);
memcpy(dst, &name[0], name.size());
}
void CtbConfig::setVoltageNames(const std::vector<std::string> &names) {
if (names.size() != num_voltages) {
throw RuntimeError("Voltage names need to be of size " +
std::to_string(num_voltages));
void CtbConfig::setPowerNames(const std::vector<std::string> &names) {
if (names.size() != num_powers) {
throw RuntimeError("Power names need to be of size " +
std::to_string(num_powers));
}
for (size_t i = 0; i != num_voltages; ++i) {
setVoltageName(i, names[i]);
for (size_t i = 0; i != num_powers; ++i) {
setPowerName(i, names[i]);
}
}
std::string CtbConfig::getVoltageName(size_t index) const {
check_voltage_index(index);
return voltagenames + index * name_length;
std::string CtbConfig::getPowerName(size_t index) const {
check_power_index(index);
return powernames + index * name_length;
}
std::vector<std::string> CtbConfig::getVoltageNames() const {
std::vector<std::string> CtbConfig::getPowerNames() const {
std::vector<std::string> names;
for (size_t i = 0; i != num_voltages; ++i)
names.push_back(getVoltageName(i));
for (size_t i = 0; i != num_powers; ++i)
names.push_back(getPowerName(i));
return names;
}

14
slsDetectorSoftware/src/CtbConfig.h
View File

@ -8,19 +8,19 @@ class CtbConfig {
static constexpr size_t num_dacs = 18;
static constexpr size_t num_adcs = 32;
static constexpr size_t num_signals = 64;
static constexpr size_t num_voltages = 5;
static constexpr size_t num_powers = 5;
static constexpr size_t num_slowADCs = 8;
static constexpr const char *shm_tag_ = "ctbdacs";
char dacnames[name_length * num_dacs]{};
char adcnames[name_length * num_adcs]{};
char signalnames[name_length * num_signals]{};
char voltagenames[name_length * num_voltages]{};
char powernames[name_length * num_powers]{};
char slowADCnames[name_length * num_slowADCs]{};
void check_dac_index(size_t i) const;
void check_adc_index(size_t i) const;
void check_signal_index(size_t i) const;
void check_voltage_index(size_t i) const;
void check_power_index(size_t i) const;
void check_slow_adc_index(size_t i) const;
void check_size(const std::string &name) const;
@ -46,10 +46,10 @@ class CtbConfig {
std::string getSignalName(size_t index) const;
std::vector<std::string> getSignalNames() const;
void setVoltageNames(const std::vector<std::string> &names);
void setVoltageName(size_t index, const std::string &name);
std::string getVoltageName(size_t index) const;
std::vector<std::string> getVoltageNames() const;
void setPowerNames(const std::vector<std::string> &names);
void setPowerName(size_t index, const std::string &name);
std::string getPowerName(size_t index) const;
std::vector<std::string> getPowerNames() const;
void setSlowADCNames(const std::vector<std::string> &names);
void setSlowADCName(size_t index, const std::string &name);

42
slsDetectorSoftware/src/Detector.cpp
View File

@ -2069,9 +2069,9 @@ Result<int> Detector::getSYNCClock(Positions pos) const {
return pimpl->Parallel(&Module::getClockFrequency, pos, defs::SYNC_CLOCK);
}
std::vector<defs::dacIndex> Detector::getVoltageList() const {
std::vector<defs::dacIndex> Detector::getPowerList() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD) {
throw RuntimeError("Voltage list not implemented for this detector");
throw RuntimeError("Power list not implemented for this detector");
}
return std::vector<defs::dacIndex>{defs::V_POWER_A, defs::V_POWER_B,
defs::V_POWER_C, defs::V_POWER_D,
@ -2087,7 +2087,7 @@ std::vector<defs::dacIndex> Detector::getSlowADCList() const {
defs::SLOW_ADC4, defs::SLOW_ADC5, defs::SLOW_ADC6, defs::SLOW_ADC7};
}
Result<int> Detector::getVoltage(defs::dacIndex index, Positions pos) const {
Result<int> Detector::getPower(defs::dacIndex index, Positions pos) const {
switch (index) {
case defs::V_LIMIT:
case defs::V_POWER_A:
@ -2098,12 +2098,12 @@ Result<int> Detector::getVoltage(defs::dacIndex index, Positions pos) const {
case defs::V_POWER_CHIP:
break;
default:
throw RuntimeError("Unknown Voltage Index");
throw RuntimeError("Unknown Power Index");
}
return pimpl->Parallel(&Module::getDAC, pos, index, true);
}
void Detector::setVoltage(defs::dacIndex index, int value, Positions pos) {
void Detector::setPower(defs::dacIndex index, int value, Positions pos) {
switch (index) {
case defs::V_LIMIT:
case defs::V_POWER_A:
@ -2114,7 +2114,7 @@ void Detector::setVoltage(defs::dacIndex index, int value, Positions pos) {
case defs::V_POWER_CHIP:
break;
default:
throw RuntimeError("Unknown Voltage Index");
throw RuntimeError("Unknown Power Index");
}
pimpl->Parallel(&Module::setDAC, pos, value, index, true);
}
@ -2185,8 +2185,8 @@ void Detector::setDBITClock(int value_in_MHz, Positions pos) {
value_in_MHz);
}
Result<int> Detector::getMeasuredVoltage(defs::dacIndex index,
Positions pos) const {
Result<int> Detector::getMeasuredPower(defs::dacIndex index,
Positions pos) const {
switch (index) {
case defs::V_POWER_A:
case defs::V_POWER_B:
@ -2196,7 +2196,7 @@ Result<int> Detector::getMeasuredVoltage(defs::dacIndex index,
case defs::V_POWER_CHIP:
break;
default:
throw RuntimeError("Unknown Voltage Index");
throw RuntimeError("Unknown Power Index");
}
return pimpl->Parallel(&Module::getADC, pos, index);
}
@ -2377,39 +2377,39 @@ std::string Detector::getSignalName(const int i) const {
return pimpl->getCtbSignalName(i);
}
void Detector::setVoltageNames(const std::vector<std::string> names) {
void Detector::setPowerNames(const std::vector<std::string> names) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
pimpl->setCtbVoltageNames(names);
pimpl->setCtbPowerNames(names);
}
std::vector<std::string> Detector::getVoltageNames() const {
std::vector<std::string> Detector::getPowerNames() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
return pimpl->getCtbVoltageNames();
return pimpl->getCtbPowerNames();
}
defs::dacIndex Detector::getVoltageIndex(const std::string &name) const {
defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
auto names = getVoltageNames();
auto names = getPowerNames();
auto it = std::find(names.begin(), names.end(), name);
if (it == names.end())
throw RuntimeError("Voltage name not found");
throw RuntimeError("Power name not found");
return static_cast<defs::dacIndex>(it - names.begin() + defs::V_POWER_A);
}
void Detector::setVoltageName(const defs::dacIndex index,
const std::string &name) {
void Detector::setPowerName(const defs::dacIndex index,
const std::string &name) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
pimpl->setCtbVoltageName(index, name);
pimpl->setCtbPowerName(index, name);
}
std::string Detector::getVoltageName(const defs::dacIndex i) const {
std::string Detector::getPowerName(const defs::dacIndex i) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
return pimpl->getCtbVoltageName(i);
return pimpl->getCtbPowerName(i);
}
void Detector::setSlowADCNames(const std::vector<std::string> names) {

18
slsDetectorSoftware/src/DetectorImpl.cpp
View File

@ -2039,21 +2039,21 @@ void DetectorImpl::setCtbSignalName(const int index, const std::string &name) {
ctb_shm()->setSignalName(index, name);
}
std::vector<std::string> DetectorImpl::getCtbVoltageNames() const {
return ctb_shm()->getVoltageNames();
std::vector<std::string> DetectorImpl::getCtbPowerNames() const {
return ctb_shm()->getPowerNames();
}
void DetectorImpl::setCtbVoltageNames(const std::vector<std::string> &names) {
ctb_shm()->setVoltageNames(names);
void DetectorImpl::setCtbPowerNames(const std::vector<std::string> &names) {
ctb_shm()->setPowerNames(names);
}
std::string DetectorImpl::getCtbVoltageName(const defs::dacIndex i) const {
return ctb_shm()->getVoltageName(static_cast<int>(i - defs::V_POWER_A));
std::string DetectorImpl::getCtbPowerName(const defs::dacIndex i) const {
return ctb_shm()->getPowerName(static_cast<int>(i - defs::V_POWER_A));
}
void DetectorImpl::setCtbVoltageName(const defs::dacIndex index,
const std::string &name) {
ctb_shm()->setVoltageName(static_cast<int>(index - defs::V_POWER_A), name);
void DetectorImpl::setCtbPowerName(const defs::dacIndex index,
const std::string &name) {
ctb_shm()->setPowerName(static_cast<int>(index - defs::V_POWER_A), name);
}
std::vector<std::string> DetectorImpl::getCtbSlowADCNames() const {

12
slsDetectorSoftware/src/DetectorImpl.h
View File

@ -84,7 +84,9 @@ class DetectorImpl : public virtual slsDetectorDefs {
*/
virtual ~DetectorImpl();
template <class CT> struct NonDeduced { using type = CT; };
template <class CT> struct NonDeduced {
using type = CT;
};
template <typename RT, typename... CT>
Result<RT> Parallel(RT (Module::*somefunc)(CT...),
std::vector<int> positions,
@ -342,10 +344,10 @@ class DetectorImpl : public virtual slsDetectorDefs {
void setCtbSignalNames(const std::vector<std::string> &names);
void setCtbSignalName(const int index, const std::string &name);
std::vector<std::string> getCtbVoltageNames() const;
std::string getCtbVoltageName(const defs::dacIndex i) const;
void setCtbVoltageNames(const std::vector<std::string> &names);
void setCtbVoltageName(const defs::dacIndex index, const std::string &name);
std::vector<std::string> getCtbPowerNames() const;
std::string getCtbPowerName(const defs::dacIndex i) const;
void setCtbPowerNames(const std::vector<std::string> &names);
void setCtbPowerName(const defs::dacIndex index, const std::string &name);
std::vector<std::string> getCtbSlowADCNames() const;
std::string getCtbSlowADCName(const defs::dacIndex i) const;

86
slsDetectorSoftware/tests/test-CmdProxy-chiptestboard.cpp
View File

@ -261,15 +261,15 @@ TEST_CASE("signalindex", "[.cmd]") {
}
}
TEST_CASE("voltagelist", "[.cmd]") {
TEST_CASE("powerlist", "[.cmd]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
auto prev = det.getVoltageNames();
auto prev = det.getPowerNames();
REQUIRE_THROWS(proxy.Call("voltagelist", {"a", "s", "d"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("powerlist", {"a", "s", "d"}, -1, PUT));
std::vector<std::string> names;
for (int iarg = 0; iarg != 5; ++iarg) {
@ -277,87 +277,87 @@ TEST_CASE("voltagelist", "[.cmd]") {
}
{
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("voltagelist", names, -1, PUT, oss));
REQUIRE_NOTHROW(proxy.Call("powerlist", names, -1, PUT, oss));
}
{
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("voltagelist", {}, -1, GET, oss));
REQUIRE_NOTHROW(proxy.Call("powerlist", {}, -1, GET, oss));
REQUIRE(oss.str() ==
std::string("voltagelist ") + ToString(names) + '\n');
std::string("powerlist ") + ToString(names) + '\n');
}
det.setVoltageNames(prev);
det.setPowerNames(prev);
} else {
REQUIRE_THROWS(proxy.Call("voltagelist", {"a", "b"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("voltagelist", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("powerlist", {"a", "b"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("powerlist", {}, -1, GET));
}
}
TEST_CASE("voltagename", "[.cmd]") {
TEST_CASE("powername", "[.cmd]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
std::string str_voltage_index = "2";
auto prev = det.getVoltageName(ind);
std::string str_power_index = "2";
auto prev = det.getPowerName(ind);
// 1 arg throw
REQUIRE_THROWS(proxy.Call("voltagename", {"2", "3", "bname"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("powername", {"2", "3", "bname"}, -1, PUT));
// invalid index
REQUIRE_THROWS(proxy.Call("voltagename", {"5", "bname"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("powername", {"5", "bname"}, -1, PUT));
{
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call(
"voltagename", {str_voltage_index, "bname"}, -1, PUT, oss));
REQUIRE_NOTHROW(proxy.Call("powername", {str_power_index, "bname"},
-1, PUT, oss));
}
{
std::ostringstream oss;
REQUIRE_NOTHROW(
proxy.Call("voltagename", {str_voltage_index}, -1, GET, oss));
REQUIRE(oss.str() == std::string("voltagename ") +
str_voltage_index + " bname\n");
proxy.Call("powername", {str_power_index}, -1, GET, oss));
REQUIRE(oss.str() ==
std::string("powername ") + str_power_index + " bname\n");
}
det.setVoltageName(ind, prev);
det.setPowerName(ind, prev);
} else {
REQUIRE_THROWS(proxy.Call("voltagename", {"2", "b"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("voltagename", {"2"}, -1, GET));
REQUIRE_THROWS(proxy.Call("powername", {"2", "b"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("powername", {"2"}, -1, GET));
}
}
TEST_CASE("voltageindex", "[.cmd]") {
TEST_CASE("powerindex", "[.cmd]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
std::string str_voltage_index = "2";
std::string str_power_index = "2";
// 1 arg throw
REQUIRE_THROWS(proxy.Call("voltageindex", {"2", "2"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("powerindex", {"2", "2"}, -1, PUT));
// invalid index
REQUIRE_THROWS(proxy.Call("voltageindex", {"5"}, -1, PUT));
auto voltagename = det.getVoltageName(ind);
REQUIRE_THROWS(proxy.Call("powerindex", {"5"}, -1, PUT));
auto powername = det.getPowerName(ind);
{
std::ostringstream oss;
REQUIRE_NOTHROW(
proxy.Call("voltageindex", {voltagename}, -1, GET, oss));
proxy.Call("powerindex", {powername}, -1, GET, oss));
REQUIRE(oss.str() ==
std::string("voltageindex ") + str_voltage_index + '\n');
std::string("powerindex ") + str_power_index + '\n');
}
} else {
REQUIRE_THROWS(proxy.Call("voltageindex", {"2"}, -1, GET));
REQUIRE_THROWS(proxy.Call("powerindex", {"2"}, -1, GET));
}
}
TEST_CASE("voltagevalues", "[.cmd]") {
TEST_CASE("powervalues", "[.cmd]") {
Detector det;
CmdProxy proxy(&det);
REQUIRE_NOTHROW(proxy.Call("voltagevalues", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("voltagevalues", {}, -1, PUT));
REQUIRE_NOTHROW(proxy.Call("powervalues", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("powervalues", {}, -1, PUT));
}
TEST_CASE("slowadcvalues", "[.cmd]") {
@ -733,7 +733,7 @@ TEST_CASE("v_limit", "[.cmd]") {
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
auto prev_val = det.getVoltage(defs::V_LIMIT);
auto prev_val = det.getPower(defs::V_LIMIT);
{
std::ostringstream oss;
proxy.Call("v_limit", {"1500"}, -1, PUT, oss);
@ -758,7 +758,7 @@ TEST_CASE("v_limit", "[.cmd]") {
if (prev_val[i] == -100) {
prev_val[i] = 0;
}
det.setVoltage(defs::V_LIMIT, prev_val[i], {i});
det.setPower(defs::V_LIMIT, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("v_limit", {}, -1, GET));
@ -1006,7 +1006,7 @@ TEST_CASE("v_a", "[.cmd]") {
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
auto prev_val = det.getVoltage(defs::V_POWER_A);
auto prev_val = det.getPower(defs::V_POWER_A);
{
std::ostringstream oss1, oss2;
proxy.Call("v_a", {"700"}, -1, PUT, oss1);
@ -1015,7 +1015,7 @@ TEST_CASE("v_a", "[.cmd]") {
REQUIRE(oss2.str() == "v_a 700\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setVoltage(defs::V_POWER_A, prev_val[i], {i});
det.setPower(defs::V_POWER_A, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("v_a", {}, -1, GET));
@ -1027,7 +1027,7 @@ TEST_CASE("v_b", "[.cmd]") {
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
auto prev_val = det.getVoltage(defs::V_POWER_B);
auto prev_val = det.getPower(defs::V_POWER_B);
{
std::ostringstream oss1, oss2;
proxy.Call("v_b", {"700"}, -1, PUT, oss1);
@ -1036,7 +1036,7 @@ TEST_CASE("v_b", "[.cmd]") {
REQUIRE(oss2.str() == "v_b 700\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setVoltage(defs::V_POWER_B, prev_val[i], {i});
det.setPower(defs::V_POWER_B, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("v_b", {}, -1, GET));
@ -1048,7 +1048,7 @@ TEST_CASE("v_c", "[.cmd]") {
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
auto prev_val = det.getVoltage(defs::V_POWER_C);
auto prev_val = det.getPower(defs::V_POWER_C);
{
std::ostringstream oss1, oss2;
proxy.Call("v_c", {"700"}, -1, PUT, oss1);
@ -1057,7 +1057,7 @@ TEST_CASE("v_c", "[.cmd]") {
REQUIRE(oss2.str() == "v_c 700\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setVoltage(defs::V_POWER_C, prev_val[i], {i});
det.setPower(defs::V_POWER_C, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("v_c", {}, -1, GET));
@ -1069,7 +1069,7 @@ TEST_CASE("v_d", "[.cmd]") {
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
auto prev_val = det.getVoltage(defs::V_POWER_D);
auto prev_val = det.getPower(defs::V_POWER_D);
{
std::ostringstream oss1, oss2;
proxy.Call("v_d", {"700"}, -1, PUT, oss1);
@ -1078,7 +1078,7 @@ TEST_CASE("v_d", "[.cmd]") {
REQUIRE(oss2.str() == "v_d 700\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setVoltage(defs::V_POWER_D, prev_val[i], {i});
det.setPower(defs::V_POWER_D, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("v_d", {}, -1, GET));

2
slsDetectorSoftware/tests/test-CtbConfig.cpp
View File

@ -26,7 +26,7 @@ TEST_CASE("Default construction") {
REQUIRE(adcnames[1] == "ADC1");
REQUIRE(adcnames[2] == "ADC2");
REQUIRE(adcnames[3] == "ADC3");
auto powernames = c.getVoltageNames();
auto powernames = c.getPowerNames();
REQUIRE(powernames.size() == 5);
REQUIRE(powernames[0] == "VA");
REQUIRE(powernames[1] == "VB");