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

veto file in

Browse Source
This commit is contained in:
maliakal_d
2020-07-14 18:51:47 +02:00
parent 35dbc3813d
commit 7752b86d97
12 changed files with 255 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
View File

@ -1803,7 +1803,6 @@ int setVetoPhoton(int chipIndex, int gainIndex, int *values) {
("Setting veto photon [chip:%d, G%d]\n", chipIndex, gainIndex));
// add gain bits
{
int gainValue = 0;
switch (gainIndex) {
case 0:
@ -1824,8 +1823,11 @@ int setVetoPhoton(int chipIndex, int gainIndex, int *values) {
values[i] |= gainValue;
LOG(logDEBUG2, ("Value %d: 0x%x\n", i, values[i]));
}
}
return configureASICVetoReference(chipIndex, values);
}
int configureASICVetoReference(int chipIndex, int *values) {
const int lenDataBitsPerchannel = ASIC_GAIN_MAX_BITS + ADU_MAX_BITS; // 14
const int lenBits = lenDataBitsPerchannel * NCHAN; // 1792
const int padding = 4; // due to address (4) to make it byte aligned
@ -1906,6 +1908,32 @@ int getVetoPhoton(int chipIndex, int *retvals) {
return OK;
}
int setVetoFile(int chipIndex, int *gainIndices, int *values) {
LOG(logINFO, ("Setting veto file [chip:%d]\n", chipIndex));
// correct gain bits and integrate into values
for (int i = 0; i < NCHAN; ++i) {
switch (gainIndices[i]) {
case 0:
gainIndices[i] = ASIC_G0_VAL;
break;
case 1:
gainIndices[i] = ASIC_G1_VAL;
break;
case 2:
gainIndices[i] = ASIC_G2_VAL;
break;
default:
LOG(logERROR,
("Unknown gain index %d for channel %d\n", gainIndices[i], i));
return FAIL;
}
values[i] |= gainIndices[i];
LOG(logDEBUG2, ("Values[%d]: 0x%x\n", i, values[i]));
}
return configureASICVetoReference(chipIndex, values);
}
int configureSingleADCDriver(int chipIndex) {
LOG(logINFO, ("Configuring ADC for %s chips [chipIndex:%d Burst Mode:%d]\n",
chipIndex == -1 ? "All" : "Single", chipIndex, burstMode));

2
slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
View File

@ -504,7 +504,9 @@ int setInjectChannel(int offset, int increment);
void getInjectedChannels(int *offset, int *increment);
int setVetoReference(int gainIndex, int value);
int setVetoPhoton(int chipIndex, int gainIndex, int *values);
int configureASICVetoReference(int chipIndex, int *values);
int getVetoPhoton(int chipIndex, int *retvals);
int setVetoFile(int chipIndex, int *gainIndices, int *values);
int configureSingleADCDriver(int chipIndex);
int configureADC();
int setBurstModeinFPGA(enum burstMode value);

1
slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h
View File

@ -233,3 +233,4 @@ int get_cds_gain(int);
int set_cds_gain(int);
int get_filter(int);
int set_filter(int);
int set_veto_file(int);

76
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -350,6 +350,7 @@ void function_table() {
flist[F_SET_CDS_GAIN] = &set_cds_gain;
flist[F_GET_FILTER] = &get_filter;
flist[F_SET_FILTER] = &set_filter;
flist[F_SET_VETO_FILE] = &set_veto_file;
// check
if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@ -6319,6 +6320,7 @@ int set_veto_photon(int file_des) {
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
int values[args[2]];
memset(values, 0, sizeof(values));
if (receiveData(file_des, values, sizeof(values), INT32) < 0)
return printSocketReadError();
LOG(logINFO, ("Setting Veto Photon: [chipIndex:%d, G%d, nch:%d]\n", args[0],
@ -6356,7 +6358,7 @@ int set_veto_photon(int file_des) {
sprintf(mess,
"Could not set veto photon. Invalid ADU value 0x%x "
"for channel %d, must be 12 bit.\n",
i, values[i]);
values[i], i);
LOG(logERROR, (mess));
break;
}
@ -7746,3 +7748,75 @@ int set_filter(int file_des) {
#endif
return Server_SendResult(file_des, INT32, NULL, 0);
}
int set_veto_file(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1, -1};
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
int chipIndex = args[0];
int nch = args[1];
int gainIndices[nch];
memset(gainIndices, 0, sizeof(gainIndices));
int values[nch];
memset(values, 0, sizeof(values));
if (receiveData(file_des, gainIndices, sizeof(gainIndices), INT32) < 0)
return printSocketReadError();
if (receiveData(file_des, values, sizeof(values), INT32) < 0)
return printSocketReadError();
LOG(logINFO,
("Setting Veto file: [chipIndex:%d, nch:%d]\n", chipIndex, nch));
#ifndef GOTTHARD2D
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
if (chipIndex < -1 || chipIndex >= NCHIP) {
ret = FAIL;
sprintf(mess, "Could not set veto file. Invalid chip index %d\n",
chipIndex);
LOG(logERROR, (mess));
} else if (nch != NCHAN) {
ret = FAIL;
sprintf(mess,
"Could not set veto file. Invalid number of channels %d. "
"Expected %d\n",
nch, NCHAN);
LOG(logERROR, (mess));
} else {
for (int i = 0; i < NCHAN; ++i) {
if (values[i] < 0 || values[i] > ADU_MAX_VAL) {
ret = FAIL;
sprintf(mess,
"Could not set veto file. Invalid ADU value 0x%x "
"for channel %d, must be 12 bit.\n",
values[i], i);
LOG(logERROR, (mess));
break;
}
if (gainIndices[i] < 0 || gainIndices[i] > 2) {
ret = FAIL;
sprintf(mess,
"Could not set veto file. Invalid gain index %d "
"for channel %d\n",
gainIndices[i], i);
LOG(logERROR, (mess));
break;
}
}
if (ret == OK) {
ret = setVetoFile(chipIndex, gainIndices, values);
if (ret == FAIL) {
sprintf(mess, "Could not set veto file for chip index %d\n",
chipIndex);
LOG(logERROR, (mess));
}
}
}
}
#endif
return Server_SendResult(file_des, INT32, NULL, 0);
}

4
slsDetectorSoftware/include/Detector.h
View File

@ -983,6 +983,10 @@ class Detector {
void setVetoReference(const int gainIndex, const int value,
Positions pos = {});
/** [Gotthard2] */
void setVetoFile(const int chipIndex, const std::string &fname,
Positions pos = {});
/** [Gotthard2] */
Result<defs::burstMode> getBurstMode(Positions pos = {});

23
slsDetectorSoftware/src/CmdProxy.cpp
View File

@ -1669,6 +1669,29 @@ std::string CmdProxy::VetoReference(int action) {
return os.str();
}
std::string CmdProxy::VetoFile(int action) {
std::ostringstream os;
os << cmd << ' ';
if (action == defs::HELP_ACTION) {
os << "[chip index 0-10, -1 for all] [file name] \n\t[Gotthard2] Set "
"veto reference for each 128 channels for specific chip. The "
"file should have 128 rows of gain index and 12 bit value in hex"
<< '\n';
} else if (action == defs::GET_ACTION) {
throw sls::RuntimeError(
"cannot get vetofile. Did you mean vetophoton?");
} else if (action == defs::PUT_ACTION) {
if (args.size() != 2) {
WrongNumberOfParameters(2);
}
det->setVetoFile(StringTo<int>(args[0]), args[1], {det_id});
os << sls::ToString(args) << '\n';
} else {
throw sls::RuntimeError("Unknown action");
}
return os.str();
}
std::string CmdProxy::BurstMode(int action) {
std::ostringstream os;
os << cmd << ' ';

2
slsDetectorSoftware/src/CmdProxy.h
View File

@ -834,6 +834,7 @@ class CmdProxy {
{"inj_ch", &CmdProxy::InjectChannel},
{"vetophoton", &CmdProxy::VetoPhoton},
{"vetoref", &CmdProxy::VetoReference},
{"vetofile", &CmdProxy::VetoFile},
{"burstmode", &CmdProxy::BurstMode},
{"cdsgain", &CmdProxy::cdsgain},
{"filter", &CmdProxy::filter},
@ -1015,6 +1016,7 @@ class CmdProxy {
std::string InjectChannel(int action);
std::string VetoPhoton(int action);
std::string VetoReference(int action);
std::string VetoFile(int action);
std::string BurstMode(int action);
/* Mythen3 Specific */
std::string Counters(int action);

5
slsDetectorSoftware/src/Detector.cpp
View File

@ -1297,6 +1297,11 @@ void Detector::setVetoReference(const int gainIndex, const int value,
pimpl->Parallel(&Module::setVetoReference, pos, gainIndex, value);
}
void Detector::setVetoFile(const int chipIndex, const std::string &fname,
Positions pos) {
pimpl->Parallel(&Module::setVetoFile, pos, chipIndex, fname);
}
Result<defs::burstMode> Detector::getBurstMode(Positions pos) {
return pimpl->Parallel(&Module::getBurstMode, pos);
}

76
slsDetectorSoftware/src/Module.cpp
View File

@ -1521,6 +1521,82 @@ void Module::setVetoReference(const int gainIndex, const int value) {
sendToDetector(F_SET_VETO_REFERENCE, args, nullptr);
}
void Module::setVetoFile(const int chipIndex, const std::string &fname) {
if (shm()->myDetectorType != GOTTHARD2) {
throw RuntimeError(
"Set Veto file is not implemented for this detector");
}
if (chipIndex < -1 || chipIndex >= shm()->nChip.x) {
throw RuntimeError("Could not set veto file. Invalid chip index: " +
std::to_string(chipIndex));
}
std::ifstream infile(fname.c_str());
if (!infile.is_open()) {
throw RuntimeError("Could not set veto file for chip " +
std::to_string(chipIndex) +
". Could not open file: " + fname);
}
std::ifstream input_file(fname);
if (!input_file.is_open()) {
throw RuntimeError("Could not open veto file " + fname +
" for reading");
}
int ch = shm()->nChan.x;
int nRead = 0;
int gainIndices[ch];
memset(gainIndices, 0, sizeof(gainIndices));
int values[ch];
memset(values, 0, sizeof(values));
for (std::string line; std::getline(input_file, line);) {
if (line.find('#') != std::string::npos) {
line.erase(line.find('#'));
}
LOG(logDEBUG1) << "line after removing comments:\n\t" << line;
if (line.length() > 1) {
// convert command and string to a vector
std::istringstream iss(line);
std::string val;
if (!(iss >> gainIndices[nRead] >> val)) {
throw RuntimeError("Could not set veto file. Invalid gain "
"or reference value for channel " +
std::to_string(nRead));
}
try {
values[nRead] = StringTo<int>(val);
} catch (...) {
throw RuntimeError("Could not set veto file. Invalid value " +
val + " for channel " +
std::to_string(nRead));
}
++nRead;
if (nRead >= ch) {
break;
}
}
}
int fnum = F_SET_VETO_FILE;
int ret = FAIL;
int args[]{chipIndex, ch};
LOG(logDEBUG) << "Sending veto file value to detector [chip:" << chipIndex
<< "]: " << args;
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(&fnum, sizeof(fnum));
client.Send(args, sizeof(args));
client.Send(gainIndices, sizeof(gainIndices));
client.Send(values, sizeof(values));
client.Receive(&ret, sizeof(ret));
if (ret == FAIL) {
char mess[MAX_STR_LENGTH]{};
client.Receive(mess, MAX_STR_LENGTH);
throw RuntimeError("Detector " + std::to_string(moduleId) +
" returned error: " + std::string(mess));
}
}
slsDetectorDefs::burstMode Module::getBurstMode() {
auto r = sendToDetector<int>(F_GET_BURST_MODE);
return static_cast<slsDetectorDefs::burstMode>(r);

1
slsDetectorSoftware/src/Module.h
View File

@ -373,6 +373,7 @@ class Module : public virtual slsDetectorDefs {
void setVetoPhoton(const int chipIndex, const int numPhotons,
const int energy, const std::string &fname);
void setVetoReference(const int gainIndex, const int value);
void setVetoFile(const int chipIndex, const std::string &fname);
burstMode getBurstMode();
void setBurstMode(burstMode value);
bool getCDSGain();

14
slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
View File

@ -343,6 +343,20 @@ TEST_CASE("vetoref", "[.cmd][.new]") {
}
}
TEST_CASE("vetofile", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
REQUIRE_THROWS(proxy.Call("vetofile", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetofile", {"12", "/tmp/bla.txt"}, -1,
PUT)); // invalid chip index
} else {
REQUIRE_THROWS(proxy.Call("vetofile", {"-1"}, -1, GET));
}
}
TEST_CASE("burstmode", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);

3
slsSupportLib/include/sls_detector_funcs.h
View File

@ -207,6 +207,7 @@ enum detFuncs {
F_SET_CDS_GAIN,
F_GET_FILTER,
F_SET_FILTER,
F_SET_VETO_FILE,
NUM_DET_FUNCTIONS,
RECEIVER_ENUM_START = 256, /**< detector function should not exceed this
@ -512,6 +513,8 @@ const char* getFunctionNameFromEnum(enum detFuncs func) {
case F_SET_CDS_GAIN: return "F_SET_CDS_GAIN";
case F_GET_FILTER: return "F_GET_FILTER";
case F_SET_FILTER: return "F_SET_FILTER";
case F_SET_VETO_FILE: return "F_SET_VETO_FILE";
case NUM_DET_FUNCTIONS: return "NUM_DET_FUNCTIONS";
case RECEIVER_ENUM_START: return "RECEIVER_ENUM_START";