rtang/SOLARIS_QT6_DAQ
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
SOLARIS_QT6_DAQ/Hit.h

295 lines
9.8 KiB
C++
Raw Permalink Blame History

#ifndef HIT_H
#define HIT_H
#include <stdio.h>
#include <cstdlib>
#include <stdint.h>
#include <string>
#define MaxTraceLenght 8100
enum DataFormat{
ALL = 0x00,
OneTrace = 0x01,
NoTrace = 0x02,
Minimum = 0x03,
MiniWithFineTime = 0x04,
Raw = 0x0A,
};
namespace DPPType{
const std::string PHA = "DPP_PHA";
const std::string PSD = "DPP_PSD";
};
class Hit {
public:
unsigned short dataType;
std::string DPPType;
///============= for dpp-pha
uint8_t channel; // 6 bit
uint16_t energy; // 16 bit
uint16_t energy_short; // 16 bit, only for PSD
uint64_t timestamp; // 48 bit
uint16_t fine_timestamp; // 10 bit
uint16_t flags_low_priority; // 12 bit
uint16_t flags_high_priority; // 8 bit
size_t traceLenght; // 64 bit
uint8_t downSampling; // 8 bit
bool board_fail;
bool flush;
uint8_t analog_probes_type[2]; // 3 bit for PHA, 4 bit for PSD
uint8_t digital_probes_type[4]; // 4 bit for PHA, 5 bit for PSD
int32_t * analog_probes[2]; // 18 bit
uint8_t * digital_probes[4]; // 1 bit
uint16_t trigger_threashold; // 16 bit
size_t event_size; // 64 bit
uint32_t aggCounter; // 32 bit
///============= for raw
uint8_t * data;
size_t dataSize; /// number of byte of the data, size/8 = word [64 bits]
uint32_t n_events;
bool isTraceAllZero;
Hit(){
Init();
}
~Hit(){
ClearMemory();
}
void Init(){
DPPType = DPPType::PHA;
dataType = DataFormat::ALL;
channel = 0;
energy = 0;
energy_short = 0;
timestamp = 0;
fine_timestamp = 0;
downSampling = 0;
board_fail = false;
flush = false;
flags_low_priority = 0;
flags_high_priority = 0;
trigger_threashold = 0;
event_size = 0;
aggCounter = 0;
analog_probes[0] = NULL;
analog_probes[1] = NULL;
digital_probes[0] = NULL;
digital_probes[1] = NULL;
digital_probes[2] = NULL;
digital_probes[3] = NULL;
analog_probes_type[0] = 0xFF;
analog_probes_type[1] = 0xFF;
digital_probes_type[0] = 0xFF;
digital_probes_type[1] = 0xFF;
digital_probes_type[2] = 0xFF;
digital_probes_type[3] = 0xFF;
data = NULL;
isTraceAllZero = true; // indicate trace are all zero
}
void ClearMemory(){
if( data != NULL ) delete data;
if( analog_probes[0] != NULL) delete analog_probes[0];
if( analog_probes[1] != NULL) delete analog_probes[1];
if( digital_probes[0] != NULL) delete digital_probes[0];
if( digital_probes[1] != NULL) delete digital_probes[1];
if( digital_probes[2] != NULL) delete digital_probes[2];
if( digital_probes[3] != NULL) delete digital_probes[3];
isTraceAllZero = true;
}
void SetDataType(unsigned int type, std::string dppType){
dataType = type;
DPPType = dppType;
ClearMemory();
if( dataType == DataFormat::Raw){
data = new uint8_t[20*1024*1024];
}else{
analog_probes[0] = new int32_t[MaxTraceLenght];
analog_probes[1] = new int32_t[MaxTraceLenght];
digital_probes[0] = new uint8_t[MaxTraceLenght];
digital_probes[1] = new uint8_t[MaxTraceLenght];
digital_probes[2] = new uint8_t[MaxTraceLenght];
digital_probes[3] = new uint8_t[MaxTraceLenght];
isTraceAllZero = true;
}
}
void ClearTrace(){
if( isTraceAllZero ) return; // no need to clear again
for( int i = 0; i < MaxTraceLenght; i++){
analog_probes[0][i] = 0;
analog_probes[1][i] = 0;
digital_probes[0][i] = 0;
digital_probes[1][i] = 0;
digital_probes[2][i] = 0;
digital_probes[3][i] = 0;
}
isTraceAllZero = true;
}
void PrintEnergyTimeStamp(){
printf("ch: %2d, energy: %u, timestamp: %lu ch, traceLenght: %lu\n", channel, energy, timestamp, traceLenght);
}
std::string AnaProbeType(uint8_t probeType){
if( DPPType == DPPType::PHA){
switch(probeType){
case 0: return "ADC";
case 1: return "Time filter";
case 2: return "Energy filter";
default : return "none";
}
}else if (DPPType == DPPType::PSD){
switch(probeType){
case 0: return "ADC";
case 9: return "Baseline";
case 10: return "CFD";
default : return "none";
}
}else{
return "none";
}
}
std::string DigiProbeType(uint8_t probeType){
if( DPPType == DPPType::PHA){
switch(probeType){
case 0: return "Trigger";
case 1: return "Time filter armed";
case 2: return "Re-trigger guard";
case 3: return "Energy filter baseline freeze";
case 4: return "Energy filter peaking";
case 5: return "Energy filter peaking ready";
case 6: return "Energy filter pile-up guard";
case 7: return "Event pile-up";
case 8: return "ADC saturation";
case 9: return "ADC saturation protection";
case 10: return "Post-saturation event";
case 11: return "Energy filter saturation";
case 12: return "Signal inhibit";
default : return "none";
}
}else if (DPPType == DPPType::PSD){
switch(probeType){
case 0: return "Trigger";
case 1: return "CFD Filter Armed";
case 2: return "Re-trigger guard";
case 3: return "ADC Input Baseline freeze";
case 20: return "ADC Input OverThreshold";
case 21: return "Charge Ready";
case 22: return "Long Gate";
case 7: return "Pile-Up Trig.";
case 24: return "Short Gate";
case 25: return "Energy Saturation";
case 26: return "Charge over-range";
case 27: return "ADC Input Neg. OverThreshold";
default : return "none";
}
}else{
return "none";
}
}
std::string HighPriority(uint16_t prio){
std::string output;
bool pileup = prio & 0x1;
//bool pileupGuard = (prio >> 1) & 0x1;
//bool eventSaturated = (prio >> 2) & 0x1;
//bool postSatEvent = (prio >> 3) & 0x1;
//bool trapSatEvent = (prio >> 4) & 0x1;
//bool SCA_Event = (prio >> 5) & 0x1;
output = std::string("Pile-up: ") + (pileup ? "Yes" : "No");
return output;
}
//TODO LowPriority
void PrintAll(){
switch(dataType){
case DataFormat::ALL : printf("============= Type : ALL\n"); break;
case DataFormat::OneTrace : printf("============= Type : OneTrace\n"); break;
case DataFormat::NoTrace : printf("============= Type : NoTrace\n"); break;
case DataFormat::MiniWithFineTime : printf("============= Type : Min with FineTimestamp\n"); break;
case DataFormat::Minimum : printf("============= Type : Minimum\n"); break;
case DataFormat::Raw : printf("============= Type : Raw\n"); return; break;
default : return;
}
printf("ch : %2d (0x%02X), fail: %d, flush: %d\n", channel, channel, board_fail, flush);
if( DPPType == DPPType::PHA ) printf("energy: %u, timestamp: %lu, fine_timestamp: %u \n", energy, timestamp, fine_timestamp);
if( DPPType == DPPType::PSD ) printf("energy: %u, energy_S : %u, timestamp: %lu, fine_timestamp: %u \n", energy, energy_short, timestamp, fine_timestamp);
printf("flag (high): 0x%02X, (low): 0x%03X, traceLength: %lu\n", flags_high_priority, flags_low_priority, traceLenght);
printf("Agg counter : %u, trigger Thr.: %u, downSampling: %u \n", aggCounter, trigger_threashold, downSampling);
printf("AnaProbe Type: %s(%u), %s(%u)\n", AnaProbeType(analog_probes_type[0]).c_str(), analog_probes_type[0],
AnaProbeType(analog_probes_type[1]).c_str(), analog_probes_type[1]);
printf("DigProbe Type: %s(%u), %s(%u), %s(%u), %s(%u)\n", DigiProbeType(digital_probes_type[0]).c_str(), digital_probes_type[0],
DigiProbeType(digital_probes_type[1]).c_str(), digital_probes_type[1],
DigiProbeType(digital_probes_type[2]).c_str(), digital_probes_type[2],
DigiProbeType(digital_probes_type[3]).c_str(), digital_probes_type[3]);
}
void PrintTrace(unsigned short ID){
for(unsigned short i = 0; i < (unsigned short)traceLenght; i++){
if( ID == 0 ) printf("%4d| %6d\n", i, analog_probes[0][i]);
if( ID == 1 ) printf("%4d| %6d\n", i, analog_probes[1][i]);
if( ID == 2 ) printf("%4d| %u\n", i, digital_probes[0][i]);
if( ID == 3 ) printf("%4d| %u\n", i, digital_probes[1][i]);
if( ID == 4 ) printf("%4d| %u\n", i, digital_probes[2][i]);
if( ID == 5 ) printf("%4d| %u\n", i, digital_probes[3][i]);
}
}
void PrintTrace(){
printf("---------- trace length : %zu\n", traceLenght);
if( dataType == DataFormat::OneTrace ){
for(unsigned short i = 0; i < (unsigned short)traceLenght; i++){
printf("%4d| %6d\n", i, analog_probes[0][i]);
}
}
if( dataType == DataFormat::ALL){
for(unsigned short i = 0; i < (unsigned short)traceLenght; i++){
printf("%4d| %6d %6d %1d %1d %1d %1d\n", i, analog_probes[0][i],
analog_probes[1][i],
digital_probes[0][i],
digital_probes[1][i],
digital_probes[2][i],
digital_probes[3][i]);
}
}
}
};
#endif
Reference in New Issue View Git Blame Copy Permalink