rtang/PixieDAQ
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
PixieDAQ/Pixie16Class.cpp

785 lines
32 KiB
C++
Raw Normal View History

use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
#ifndef PIXIE16_CPP
#define PIXIE16_CPP
cannot figure out why the baseline is high and the trace has threshold...
2022-03-07 12:30:18 -05:00
///legacy pixie libaray
///#include "pixie16app_export.h"
///#include "pixie16sys_export.h"
///#include "def21160.h"
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
#include <bitset>
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
#include <fstream>
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
#include <iostream>
#include <stdexcept>
#include <stdio.h>
#include <string>
#include <algorithm>
#include <array>
#include "Pixie16Class.h"
std::string exec(const char* cmd) {
char buffer[128];
std::string result = "";
FILE* pipe = popen(cmd, "r");
if (!pipe) throw std::runtime_error("popen() failed!");
try {
while (fgets(buffer, sizeof buffer, pipe) != NULL) {
result += buffer;
}
} catch (...) {
pclose(pipe);
throw;
}
pclose(pipe);
return result;
}
Pixie16::Pixie16(){
isRunning = false;
retval = 0;
implement load config file
2022-03-07 18:34:47 -05:00
if( LoadConfigFile() == 0 ) {
retval = -1;
return;
}
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
CheckDriver();
if( retval > 0 ) CheckHardware();
if( retval > 0 ){
LoadConfigFile("");
BootDigitizers();
nFIFOWords = 0;
ExtFIFO_Data = NULL;
Statistics = NULL;
data = new DataBlock();
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
nextWord = 0;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
}
Pixie16::~Pixie16(){
retval = Pixie16ExitSystem(NumModules);
CheckError("Pixie16ExitSystem");
delete PXISlotMap;
added ch2ns, remove Pixie16Msg.log at begin of test.cpp
2022-03-07 16:20:50 -05:00
delete ch2ns;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
delete ComFPGAConfigFile;
delete SPFPGAConfigFile;
delete TrigFPGAConfigFile;
delete DSPCodeFile;
delete DSPParFile;
delete DSPVarFile;
delete ExtFIFO_Data;
delete Statistics;
delete data;
}
implement load config file
2022-03-07 18:34:47 -05:00
bool Pixie16::LoadConfigFile(bool verbose, std::string fileName){
/************************************************************
* this method is copy and modified from J.M. Allmond (ORNL)
* *********************************************************/
printf("\033[32m======= Loading Configuration file : %s\033[m\n",fileName.c_str());
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
implement load config file
2022-03-07 18:34:47 -05:00
NumCrates = 1;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
implement load config file
2022-03-07 18:34:47 -05:00
short LINE_LENGTH = 300;
char line[LINE_LENGTH];
FILE *fprconfig;
char configType=0;
char tempcharbuf[LINE_LENGTH];
int tempint1=0, tempint2=0, tempint3=0;
char tempComFPGAConfigFile[100][LINE_LENGTH];
char tempSPFPGAConfigFile[100][LINE_LENGTH];
char tempDSPCodeFile[100][LINE_LENGTH];
char tempDSPParFile[100][LINE_LENGTH];
char tempDSPVarFile[100][LINE_LENGTH];
unsigned short tempPXISlotMap[100];
unsigned short tempPXIFPGAMap[100];
if ((fprconfig = fopen(fileName.c_str(), "r")) == NULL) {
fprintf(stderr, "Error, cannot open input file %s\n", fileName.c_str());
return false;
}
NumModules = 0;
///========================= Get number of modules and FPGA firmware
while(fgets(line, LINE_LENGTH, fprconfig) != NULL){
for(int i = 0; i < LINE_LENGTH; i++){
if(line[i] == '#'){
if(verbose)printf("%s", line);
break;
}else if(line[i] >= 0 && line[i] != ' ' && line[i] != '\n'){
//Slot and mode and fpga
if (line[0] == 'S') {
sscanf(line,"%c\t%d\t%d\t%d\n", &configType, &tempint1, &tempint2, &tempint3);
if(verbose) printf("%c\t%d\t%d\t%d\n", configType, tempint1, tempint2, tempint3);
if (tempint1 >= 2 && tempint2 >= 0 && tempint3 >= 0) {
tempPXISlotMap[tempint2] = tempint1;
tempPXIFPGAMap[tempint2] = tempint3;
NumModules ++;
}
break;
//FPGA file
}else if (line[0] == 'F') {
sscanf(line,"%c\t%d\t%d\t%s\n", &configType, &tempint1, &tempint2, tempcharbuf);
if(verbose) printf("%c\t%d\t%d\t%s\n", configType, tempint1, tempint2, tempcharbuf);
if (tempint1 >= 0 && tempint1 < 100 && tempint2 >= 0 && tempint2 < 6) {
if (tempint2 == 0) strncpy(tempComFPGAConfigFile[tempint1], tempcharbuf, LINE_LENGTH);
if (tempint2 == 1) strncpy(tempSPFPGAConfigFile[tempint1], tempcharbuf, LINE_LENGTH);
if (tempint2 == 2) strncpy(tempDSPCodeFile[tempint1], tempcharbuf, LINE_LENGTH);
if (tempint2 == 3) strncpy(tempDSPVarFile[tempint1] , tempcharbuf, LINE_LENGTH);
if (tempint2 == 4) strncpy(tempDSPParFile[tempint1], tempcharbuf, LINE_LENGTH);
}
break;
}else {
printf("Error in reading %s : bad id or format\n", fileName.c_str());
return -1;
}
}else if(line[i]=='\n'){
if(verbose) printf("\n");
break;
}else {
continue;
}
}
memset(line, 0, LINE_LENGTH);
}
fclose(fprconfig);
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
implement load config file
2022-03-07 18:34:47 -05:00
PXISlotMap = new unsigned short [NumModules];
added ch2ns, remove Pixie16Msg.log at begin of test.cpp
2022-03-07 16:20:50 -05:00
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
ComFPGAConfigFile = new char* [NumModules];
SPFPGAConfigFile = new char* [NumModules];
TrigFPGAConfigFile = new char* [NumModules];
DSPCodeFile = new char* [NumModules];
DSPParFile = new char* [NumModules];
DSPVarFile = new char* [NumModules];
implement load config file
2022-03-07 18:34:47 -05:00
OfflineMode = 0;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
BootPattern = 0x7F;
implement load config file
2022-03-07 18:34:47 -05:00
for ( int i = 0 ; i < NumModules ; i++){
PXISlotMap[i] = tempPXISlotMap[i];
ComFPGAConfigFile [i] = tempComFPGAConfigFile[tempPXIFPGAMap[i]];
SPFPGAConfigFile [i] = tempSPFPGAConfigFile[tempPXIFPGAMap[i]];
TrigFPGAConfigFile [i] = (char *)"FPGATrig"; ///only Revision A
DSPCodeFile [i] = tempDSPCodeFile[tempPXIFPGAMap[i]];
DSPVarFile [i] = tempDSPVarFile[tempPXIFPGAMap[i]];
DSPParFile [i] = tempDSPParFile[tempPXIFPGAMap[i]];
}
cannot figure out why the baseline is high and the trace has threshold...
2022-03-07 12:30:18 -05:00
printf("########################## \n");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf("Number of Module : %d \n", NumModules);
implement load config file
2022-03-07 18:34:47 -05:00
printf(" Slot Map : "); for( int i = 0; i < NumModules ; i++) printf("%2d\t", PXISlotMap[i]);
printf("\n");
printf("Module ID : "); for( int i = 0; i < NumModules ; i++) printf("%2d\t", i);
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf("\n");
for( int i = 0; i < NumModules; i++){
implement load config file
2022-03-07 18:34:47 -05:00
printf("\033[0;32m--- configuration files for module-%02d (slot-%02d)\033[m\n", i, PXISlotMap[i] );
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf(" ComFPGA : %s \n", ComFPGAConfigFile[i]);
printf(" SPFPGA : %s \n", SPFPGAConfigFile[i]);
printf(" DSP Code : %s \n", DSPCodeFile[i]);
printf(" DSP Var : %s \n", DSPVarFile[i]);
printf(" DSP Par : %s \n", DSPParFile[i]);
}
return true;
}
int Pixie16::CheckError(std::string operation){
if( retval < 0 ){
printf("\033[1;31m*ERROR* \033[1;33m%s\033[m failed, retval = %d\n", operation.c_str(), retval);
return -1;
}
return 1;
}
void Pixie16::CheckDriver(){
printf("\033[32m======= check PLX PCI 9054 ...\033[m\n");
//check driver is loaded
std::string ans = exec("lsmod | grep 9054 | wc -l");
if( ans == "0\n" ){
printf("cannot find PLX PCI 9054 driver.\n");
retval = -1;
return;
}
printf("Found PLX PCI 9054 driver.\n");
retval = 1;
}
void Pixie16::CheckHardware(){
//check pci is there
std::string ans = exec("lspci | grep 9054 | wc -l");
if( ans == "0\n" ){
printf("cannot find PLX PCI 9054.\n");
retval = -2;
return;
}
printf("Found PLX PCI 9054 card.\n");
//check pci is OK
ans = exec("lspci -vv| grep \"Unknown header type\" | wc -l");
if( atoi(ans.c_str()) > 0 ){
printf("found PLX PCI 9054, but not working. Unknown header Type.\n");
retval = -3;
return;
}
printf("PLX PCI 9054 card does not detected problem.\n");
retval = 1;
}
void Pixie16::GetDigitizerInfo(unsigned short modID){
unsigned short ModRev;
unsigned int ModSerNum;
unsigned short ModADCBits;
unsigned short ModADCMSPS;
retval = Pixie16ReadModuleInfo(modID, &ModRev, &ModSerNum, &ModADCBits, &ModADCMSPS);
if( CheckError("Pixie16ReadModuleInfo") < 0 ) return ;
printf("------------ Module-%d \n", modID);
printf(" Revision : %d \n", ModRev);
printf(" Serial Num : %d \n", ModSerNum);
printf(" ADC Bits : %d \n", ModADCBits);
printf("ADC sampling rate : %d \n", ModADCMSPS);
added ch2ns, remove Pixie16Msg.log at begin of test.cpp
2022-03-07 16:20:50 -05:00
ch2ns[modID] = 1000/ModADCMSPS;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
void Pixie16::BootDigitizers(){
// Boot Modules
printf("\033[32m======= Booting Pixie16 System ...\033[0m\n");
retval = Pixie16InitSystem (NumModules, PXISlotMap, OfflineMode);
printf("\033[32mInit Ok\033[0m\n");
// Boot Module
printf("\033[32mBooting module ...\033[0m\n");
for( int i = 0 ; i < NumModules; i++){
GetDigitizerInfo(i);
retval = Pixie16BootModule (
ComFPGAConfigFile[i],
SPFPGAConfigFile[i],
TrigFPGAConfigFile[i],
DSPCodeFile[i],
DSPParFile[i],
DSPVarFile[i],
i,
BootPattern
);
if( CheckError("Pixie16BootModule") < 0 ) return ;
printf("\033[32mBoot Ok\033[0m\n");
}
}
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
void Pixie16::AdjustOffset(){
retval = Pixie16AdjustOffsets(NumModules);
if( CheckError("Pixie16AdjustOffsets") < 0 ) return;
printf(" Adjust Offset for All modules.\n");
}
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
void Pixie16::CaptureBaseLine(unsigned short modID, unsigned short ch){
retval = Pixie16AcquireBaselines(modID);
if( CheckError("Pixie16AcquireBaselines::MOD::"+std::to_string(modID)) < 0 ) return;
retval = Pixie16ReadSglChanBaselines(Baselines, TimeStamps, 3640, modID, ch);
if( CheckError("Pixie16ReadSglChanBaselines::MOD::"+std::to_string(modID) + "CH::"+std::to_string(ch)) < 0 ) return;
}
void Pixie16::CaptureADCTrace(unsigned short modID, unsigned short ch){
retval = Pixie16AcquireADCTrace (modID);
if( CheckError("Pixie16AcquireADCTrace") < 0 ) return;
retval = Pixie16ReadSglChanADCTrace (ADCTrace, 8192, modID, ch);
if( CheckError("Pixie16ReadSglChanADCTrace") < 0 ) return;
}
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
void Pixie16::StartRun(bool listMode){
unsigned short mode = NEW_RUN; //RESUME_RUN
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
//listmode
if( listMode ){
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
//SetDigitizerSynchWait(1, i);
//SetDigitizerInSynch(0, i);
retval = Pixie16StartListModeRun(NumModules, LIST_MODE_RUN, mode);
if( CheckError("Pixie16StartListModeRun") < 0 ) return;
printf("\033[32m LIST_MODE run\033[0m\n");
}else{
//MCA mode
retval = Pixie16StartHistogramRun(NumModules, mode);
if( CheckError("Pixie16StartHistogramRun") < 0 ) return;
printf("\033[32m MCA MODE run\033[0m\n");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
isRunning = true;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
void Pixie16::StopRun(){
retval = Pixie16EndRun( NumModules );
if( CheckError("Pixie16EndRun") < 0 ) return;
printf("\033[32mRun Stopped\033[0m\n");
isRunning = false;
}
void Pixie16::ReadData(unsigned short modID){
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
if( Pixie16CheckRunStatus(modID) == 1){
retval = Pixie16CheckExternalFIFOStatus (&nFIFOWords, modID);
if( CheckError("Pixie16CheckExternalFIFOStatus") < 0 ) return;
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
///if(nFIFOWords *1.0 / EXTERNAL_FIFO_LENGTH > 0.2) {
if(nFIFOWords > 0) {
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
printf("\033[1;31m####### READ DATA \033[m: number of word in module-%d FIFO : %d \n", modID, nFIFOWords);
if( ExtFIFO_Data != NULL ) delete ExtFIFO_Data;
ExtFIFO_Data = new unsigned int [nFIFOWords];
retval = Pixie16ReadDataFromExternalFIFO(ExtFIFO_Data, nFIFOWords, modID);
CheckError("Pixie16ReadDataFromExternalFIFO");
}
}else{
printf("Pixie16 is not running.\n");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
}
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
bool Pixie16::ProcessSingleData(){
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
bool breakProcessLoopFlag = false;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
if( nextWord < nFIFOWords ){
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
data->ch = ExtFIFO_Data[nextWord] & 0xF ;
data->slot = (ExtFIFO_Data[nextWord] >> 4) & 0xF;
data->crate = (ExtFIFO_Data[nextWord] >> 8) & 0xF;
data->headerLength = (ExtFIFO_Data[nextWord] >> 12) & 0x1F;
data->eventLength = (ExtFIFO_Data[nextWord] >> 17) & 0x3FFF;
data->pileup = ExtFIFO_Data[nextWord] >> 31 ;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
data->eventID ++;
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
if( nextWord + data->eventLength <= nFIFOWords ){
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
data->time = ((unsigned long long)(ExtFIFO_Data[nextWord+2] & 0xFFFF) << 32) + ExtFIFO_Data[nextWord+1];
data->cfd = ExtFIFO_Data[nextWord + 2] >> 16 ;
data->energy = (ExtFIFO_Data[nextWord + 3] & 0xFFFF );
data->trace_length = (ExtFIFO_Data[nextWord + 3] >> 16) & 0x7FFF;
data->trace_out_of_range = ExtFIFO_Data[nextWord + 3] >> 31;
if( data->eventLength > data->headerLength ){
for( int i = 0; i < data->trace_length/2 ; i++){
data->trace[2*i+0] = ExtFIFO_Data[nextWord + data->headerLength + i] & 0xFFFF ;
data->trace[2*i+1] = (ExtFIFO_Data[nextWord + data->headerLength + i] >> 16 ) & 0xFFFF ;
}
}
}else{
data->time = 0;
data->cfd = 0;
data->energy = 0;
data->trace_length = 0;
data->trace_out_of_range = 0;
}
nextWord += data->eventLength ;
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
if( nextWord == nFIFOWords ) {nextWord = 0; breakProcessLoopFlag = true;}
if( nextWord > nFIFOWords ) {nextWord = nextWord - nFIFOWords; breakProcessLoopFlag = true;}
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
good state, don't understand why the baseline is so high
2022-03-04 18:52:58 -05:00
return breakProcessLoopFlag ;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
unsigned int Pixie16::GetDigitizerSetting(std::string parName, unsigned short modID, bool verbose){
unsigned int ParData;
retval = Pixie16ReadSglModPar (const_cast<char*> (parName.c_str()), &ParData, modID);
if( CheckError("Pixie16ReadSglModPar::"+parName) < 0 ) return -404;
if( verbose ){
if( parName == "MODULE_CSRA" || parName == "FastTrigBackplaneEna" || parName == "TrigConfig0" || parName == "TrigConfig1" || parName == "TrigConfig2" || parName == "TrigConfig3" ){
printf("READ | Mod : %2d, %20s = %X\n", modID, parName.c_str(), ParData);
}else if(parName == "MODULE_CSRB"){
printf("READ | Mod : %2d, %20s = %X\n", modID, parName.c_str(), ParData);
printf("---------------------------------------------------------------------------\n");
printf( " 32 28 24 20 16 12 8 4 0\n");
printf( " | | | | | | | | |\n");
std::cout <<" Module Configuration : 0xb" << std::bitset<32>(ParData) << std::endl;
printf(" wired-OR trigger lines to backplane to pullup resistor (bit: 0) : %s \n", ParData & MOD_CSRB_BIT::WIRED_OR_TRIGGER_TO_PULLUP_RESIST ? "Yes" : "No");
printf(" Direct module (bit: 4) : %s \n", ParData & MOD_CSRB_BIT::DIRECT_MODULUE ? "Yes" : "No");
printf(" Chassis Master module (bit: 6) : %s \n", ParData & MOD_CSRB_BIT::CHASSIS_MASTER ? "\033[1;33mYes\033[m" : "\033[1;31mNo\033[m");
printf(" Use Global Fast Trigger Source (bit: 7) : %s \n", ParData & MOD_CSRB_BIT::GLOBAL_FAST_TRIGGER ? "Yes" : "No");
printf(" Use external trigger source (bit: 8) : %s \n", ParData & MOD_CSRB_BIT::EXTERNAL_TRIGGER ? "Yes" : "No");
printf(" Control external INHIBIT signal (bit: 10) : %s \n", ParData & MOD_CSRB_BIT::USE_INHIBIT ? "INHIBIT" : "not INHIBIT");
printf(" distribute clock and triggers in multiple crates (bit: 11) : %s \n", ParData & MOD_CSRB_BIT::DISTRIBUTE_CLOCK ? "multiple crates" : "single crate");
printf(" Sort Timestamp (bit: 12) : %s \n", ParData & MOD_CSRB_BIT::SORT_TIMESTAMP ? "\033[1;33mYes\033[m" : "\033[1;31mNo\033[m");
printf(" Enable connection of fast triggers to backplane (bit: 13) : %s \n", ParData & MOD_CSRB_BIT::FAST_TRIGGER_TO_BACKPLANE ? "enable" : "disable");
printf("---------------------------------------------------------------------------\n");
}else if(parName == "SYNCH_WAIT"){
printf("READ | Mod : %2d, %20s = %d (%s)\n", modID, parName.c_str(), ParData, ParData ? "simultaneously" : "not simultaneously");
}else if(parName == "IN_SYNCH"){
printf("READ | Mod : %2d, %20s = %d (%s)\n", modID, parName.c_str(), ParData, ParData ? "not simultaneously" : "simultaneously");
}else if(parName == "HOST_RT_PRESET"){
printf("READ | Mod : %2d, %20s = %f sec\n", modID, parName.c_str(), IEEEFloating2Decimal(ParData));
}else{
printf("READ | Mod : %2d, %20s = %d\n", modID, parName.c_str(), ParData);
}
}
return ParData;
}
void Pixie16::PrintDigitizerSettings(unsigned short modID){
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
printf("############################################### Digitizer setting for module-%d\n", modID);
///GetDigitizerSetting("MODULE_NUMBER", modID, true);
///GetDigitizerSetting("ModID", modID, true);
///GetDigitizerSetting("MODULE_FORMAT", modID, true);
///GetDigitizerSetting("MODULE_CSRA", modID, true);
///GetDigitizerSetting("MAX_EVENTS", modID, true);
GetDigitizerSetting("CrateID", modID, true);
GetDigitizerSetting("SlotID", modID, true);
GetDigitizerSetting("SYNCH_WAIT", modID, true);
GetDigitizerSetting("IN_SYNCH", modID, true);
GetDigitizerSetting("SLOW_FILTER_RANGE", modID, true);
GetDigitizerSetting("FAST_FILTER_RANGE", modID, true);
GetDigitizerSetting("FastTrigBackplaneEna", modID, true);
GetDigitizerSetting("TrigConfig0", modID, true);
GetDigitizerSetting("TrigConfig1", modID, true);
GetDigitizerSetting("TrigConfig2", modID, true);
GetDigitizerSetting("TrigConfig3", modID, true);
GetDigitizerSetting("HOST_RT_PRESET", modID, true);
GetDigitizerSetting("MODULE_CSRB", modID, true);
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
void Pixie16::SetDigitizerSetting(std::string parName, unsigned int val, unsigned short modID, bool verbose){
retval = Pixie16WriteSglModPar( const_cast<char*> (parName.c_str()), val, modID);
if( CheckError("Pixie16WriteSglModPar::"+parName) < 0 ) return;
if( verbose ) GetDigitizerSetting(parName, modID, verbose);
}
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
double Pixie16::GetChannelSetting(std::string parName, unsigned short modID, unsigned short ch, bool verbose){
double ParData;
retval = Pixie16ReadSglChanPar( const_cast<char*> (parName.c_str()), &ParData, modID, ch);
if( CheckError("Pixie16ReadSglChanPar::"+parName) < 0 ) return -404;
if( verbose ) {
if( parName == "TRIGGER_THRESHOLD" ) {
printf("READ | Mod : %2d, CH: %2d, %18s = %5d ADC\n", modID, ch, parName.c_str(), (int) ParData);
}else if( parName == "BASELINE_PERCENT" ) {
printf("READ | Mod : %2d, CH: %2d, %18s = %9.3f %%\n", modID, ch, parName.c_str(), ParData);
}else if( parName == "BLCUT" ) {
printf("READ | Mod : %2d, CH: %2d, %18s = %5d \n", modID, ch, parName.c_str(), (int) ParData);
}else if ( parName == "CHANNEL_CSRA" || parName == "CHANNEL_CSRB" || parName == "MultiplicityMaskL" || parName == "MultiplicityMaskH"){
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
if( parName == "CHANNEL_CSRA" ) printf("---------------------------------------------------------------------------\n");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf("READ | Mod : %2d, CH: %2d, %18s = %X\n", modID, ch, parName.c_str(), (int) ParData);
printf( " 32 28 24 20 16 12 8 4 0\n");
printf( " | | | | | | | | |\n");
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
std::cout <<" Channel Configuration : 0xb" << std::bitset<32>(ParData) << std::endl;
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
if( parName == "CHANNEL_CSRA" ){
int CSRA = (int) ParData;
printf(" fast trigger selection (bit: 0) : %s \n", CSRA & CSRA_BIT::FAST_TRIGGER ? "external" : "internal");
printf(" module validation signal selection (bit: 1) : %s \n", CSRA & CSRA_BIT::M_VALIDATION ? "module gate" : "global gate");
printf(" channel enable (bit: 2) : %s \n", CSRA & CSRA_BIT::ENABLE_CHANNEL ? "\033[1;33mYes\033[m" : "\033[1;31mNo\033[m");
printf(" channal validation signal selection (bit: 3) : %s \n", CSRA & CSRA_BIT::C_VALIFATION ? "module gate" : "global gate");
printf("Block data acquisition if trace or header DPMs are full (bit: 4) : %s \n", CSRA & CSRA_BIT::BLOCK_DAQ_DPM_FULL ? "Yes" : "No");
cannot figure out why the baseline is high and the trace has threshold...
2022-03-07 12:30:18 -05:00
printf(" signal polarity (bit: 5) : %s \n", CSRA & CSRA_BIT::POLARITY ? "\033[1;33mPositive\033[m" : "\033[1;31mNegative\033[m");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf(" veto channel trigger (bit: 6) : %s \n", CSRA & CSRA_BIT::VETO_TRIGGER ? "enable" : "disable");
printf(" Enable trace capture (bit: 8) : %s \n", CSRA & CSRA_BIT::ENABLE_TRACE ? "enable" : "disable");
printf(" Enable QDC sum capture (bit: 9) : %s \n", CSRA & CSRA_BIT::ENABLE_QDC ? "enable" : "disable");
printf(" Enable CFD trigger mode (bit: 10) : %s \n", CSRA & CSRA_BIT::ENABLE_CFD ? "enable" : "disable");
printf(" required module validation trigger (bit: 11) : %s \n", CSRA & CSRA_BIT::REQ_M_VALIDATION ? "required" : "not required");
printf(" Enable capture raw energy sums and baselines (bit: 12) : %s \n", CSRA & CSRA_BIT::CAPTURE_ESUMS_BASELINE ? "enable" : "disable");
printf(" required cahnnel validation trigger (bit: 13) : %s \n", CSRA & CSRA_BIT::REQ_C_VALIDATION ? "required" : "not required");
cannot figure out why the baseline is high and the trace has threshold...
2022-03-07 12:30:18 -05:00
printf(" Enable input relay (Gain) (bit: 14) : %s \n", CSRA & CSRA_BIT::INPUT_RELAY ? "\033[1;33mclose (no att.)\033[m" : "\033[1;31mopen (1/4 att.)\033[m");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf(" Pile-up control (bit: 15-16) : ");
int pileUpVaule = (CSRA & CSRA_BIT::PILEUP);
if( pileUpVaule == 0 ) printf("no energy for pile-up\n");
if( pileUpVaule == 1 ) printf("reject pile-up\n");
if( pileUpVaule == 2 ) printf("no trace for non-pile-up\n");
if( pileUpVaule == 3 ) printf("only pile-up\n");
printf(" Enable no-trace-for-large-pulse (bit: 17) : %s \n", CSRA & CSRA_BIT::NO_TRACE_LARGE_PULSE ? "enable" : "disable");
printf(" Group trigger selection (bit: 18) : %s \n", CSRA & CSRA_BIT::GROUP_TRIGGER ? "group trigger" : "local fast trigger");
printf(" Channel veto selection (bit: 19) : %s \n", CSRA & CSRA_BIT::CH_VETO ? "channel validation trigger" : "front pannel channel veto");
printf(" Module veto selection (bit: 20) : %s \n", CSRA & CSRA_BIT::MO_VETO ? "module validation trigger" : "front pannel module veto");
printf(" external timestamp in event header (bit: 21) : %s \n", CSRA & CSRA_BIT::EXT_TIMESTAMP ? "enable" : "disable");
printf("---------------------------------------------------------------------------\n");
}
}else{
printf("READ | Mod : %2d, CH: %2d, %18s = %9.3f us\n", modID, ch, parName.c_str(), ParData);
}
}
return ParData;
}
unsigned short Pixie16::GetCSRA(int bitwise, unsigned short modID, unsigned short ch, bool verbose){
double ParData;
retval = Pixie16ReadSglChanPar( (char *)"CHANNEL_CSRA", &ParData, modID, ch);
if( CheckError("Pixie16ReadSglChanPar::CHANNEL_CSRA") < 0 ) return false;
if( verbose ) printf("Mod-%d CH-%02d %X: %s\n", modID, ch, bitwise, (((int)ParData) & bitwise ) ? "Positive" : "Negative" );
return (((int)ParData) & bitwise );
}
void Pixie16::PrintChannelAllSettings(unsigned short modID, unsigned short ch){
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
printf("######################################################## Channel setting. Mod-%d CH-%02d\n", modID, ch);
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
GetChannelSetting("TRIGGER_RISETIME", modID, ch, true);
GetChannelSetting("TRIGGER_FLATTOP", modID, ch, true);
GetChannelSetting("TRIGGER_THRESHOLD", modID, ch, true);
GetChannelSetting("ENERGY_RISETIME", modID, ch, true);
GetChannelSetting("ENERGY_FLATTOP", modID, ch, true);
GetChannelSetting("TAU", modID, ch, true);
GetChannelSetting("TRACE_LENGTH", modID, ch, true);
GetChannelSetting("TRACE_DELAY", modID, ch, true);
GetChannelSetting("VOFFSET", modID, ch, true);
GetChannelSetting("XDT", modID, ch, true);
GetChannelSetting("BASELINE_PERCENT", modID, ch, true);
GetChannelSetting("BASELINE_AVERAGE", modID, ch, true);
GetChannelSetting("BLCUT", modID, ch, true);
GetChannelSetting("EMIN", modID, ch, true);
///GetChannelSetting("CHANNEL_CSRB", modID, ch, true); //CSRB is reserved to be zero
GetChannelSetting("QDCLen0", modID, ch, true);
GetChannelSetting("QDCLen1", modID, ch, true);
GetChannelSetting("QDCLen2", modID, ch, true);
GetChannelSetting("QDCLen3", modID, ch, true);
GetChannelSetting("QDCLen4", modID, ch, true);
GetChannelSetting("QDCLen5", modID, ch, true);
GetChannelSetting("QDCLen6", modID, ch, true);
GetChannelSetting("QDCLen7", modID, ch, true);
GetChannelSetting("MultiplicityMaskL", modID, ch, true);
GetChannelSetting("MultiplicityMaskH", modID, ch, true);
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
GetChannelSetting("CHANNEL_CSRA", modID, ch, true);
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf("=====================================\n");
}
void Pixie16::PrintChannelsMainSettings(unsigned short modID){
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
cannot figure out why the baseline is high and the trace has threshold...
2022-03-07 12:30:18 -05:00
printf("====+=====+======+========+========+===========+==========+==========+==========+========+========+=========+======+====== \n");
printf(" ch | En | Gain | Trig_L | Trig_G | Threshold | Polarity | Energy_L | Energy_G | Tau | Trace | Trace_d | Voff | BL \n");
printf("----+-----+------+--------+--------+-----------+----------+----------+----------+--------+--------+---------+------+------ \n");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
for( int ch = 0; ch < 16; ch ++){
printf(" %2d |", ch);
cannot figure out why the baseline is high and the trace has threshold...
2022-03-07 12:30:18 -05:00
printf(" %3s |", GetChannelOnOff(modID, ch) ? "On" : "Off" );
printf(" %3s |", GetChannelGain(modID, ch) ? "x1" : "1/4" );
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf(" %6.2f |", GetChannelTriggerRiseTime(modID, ch));
printf(" %6.2f |", GetChannelTriggerFlatTop(modID, ch));
printf(" %9.2f |", GetChannelTriggerThreshold(modID, ch));
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
printf(" %8s |", GetChannelPolarity(modID, ch) ? "Pos" : "Neg");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
printf(" %8.2f |", GetChannelEnergyRiseTime(modID, ch));
printf(" %8.2f |", GetChannelEnergyFlatTop(modID, ch));
printf(" %5.2f |", GetChannelEnergyTau(modID, ch));
if( GetChannelTraceOnOff(modID, ch) ){
printf(" %7.2f |", GetChannelTraceLength(modID, ch));
printf(" %7.2f |", GetChannelTraceDelay(modID, ch));
}else{
printf(" %7s |", "Off");
printf(" %7s |", "Off");
}
printf(" %4.2f |", GetChannelVOffset(modID, ch));
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
printf(" %4.2f %% \n", GetChannelBaseLinePrecent(modID, ch));
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
}
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
void Pixie16::SetChannelSetting(std::string parName, double val, unsigned short modID, unsigned short ch, bool verbose ){
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
retval = Pixie16WriteSglChanPar( const_cast<char*> (parName.c_str()), val, modID, ch);
if( CheckError("Pixie16WriteSglChanPar::"+parName) < 0 ) return;
if( verbose ) GetChannelSetting(parName, modID, ch, verbose);
}
void Pixie16::SwitchCSRA(int bitwise, unsigned short modID, unsigned short ch){
double ParData;
retval = Pixie16ReadSglChanPar( (char *)"CHANNEL_CSRA", &ParData, modID, ch);
if( CheckError("Pixie16ReadSglChanPar::CHANNEL_CSRA") < 0 ) return;
ParData = ((int)ParData) ^ bitwise;
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
SetChannelSetting("CHANNEL_CSRA", ParData, modID, ch);
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
void Pixie16::SetCSRABit(int bitwise, unsigned short val, unsigned short modID, unsigned short ch){
double ParData;
retval = Pixie16ReadSglChanPar( (char *)"CHANNEL_CSRA", &ParData, modID, ch);
if( CheckError("Pixie16ReadSglChanPar::CHANNEL_CSRA") < 0 ) return;
int temp = ((int)ParData) & ~bitwise ;
int haha = 0;
if( bitwise == CSRA_BIT::FAST_TRIGGER ) haha = val << 0;
if( bitwise == CSRA_BIT::M_VALIDATION ) haha = val << 1;
if( bitwise == CSRA_BIT::ENABLE_CHANNEL ) haha = val << 2;
if( bitwise == CSRA_BIT::C_VALIFATION ) haha = val << 3;
if( bitwise == CSRA_BIT::BLOCK_DAQ_DPM_FULL ) haha = val << 4;
if( bitwise == CSRA_BIT::POLARITY ) haha = val << 5;
if( bitwise == CSRA_BIT::VETO_TRIGGER ) haha = val << 6;
if( bitwise == CSRA_BIT::HIST_ENERGY ) haha = val << 7;
if( bitwise == CSRA_BIT::ENABLE_TRACE ) haha = val << 8;
if( bitwise == CSRA_BIT::ENABLE_QDC ) haha = val << 9;
if( bitwise == CSRA_BIT::ENABLE_CFD ) haha = val << 10;
if( bitwise == CSRA_BIT::REQ_M_VALIDATION ) haha = val << 11;
if( bitwise == CSRA_BIT::CAPTURE_ESUMS_BASELINE ) haha = val << 12;
if( bitwise == CSRA_BIT::REQ_C_VALIDATION ) haha = val << 13;
if( bitwise == CSRA_BIT::INPUT_RELAY ) haha = val << 14;
if( bitwise == CSRA_BIT::PILEUP ) haha = val << 15;
if( bitwise == CSRA_BIT::NO_TRACE_LARGE_PULSE ) haha = val << 17;
if( bitwise == CSRA_BIT::GROUP_TRIGGER ) haha = val << 18;
if( bitwise == CSRA_BIT::CH_VETO ) haha = val << 19;
if( bitwise == CSRA_BIT::MO_VETO ) haha = val << 20;
if( bitwise == CSRA_BIT::EXT_TIMESTAMP ) haha = val << 21;
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
SetChannelSetting("CHANNEL_CSRA", (temp | haha), modID, ch);
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
unsigned int * Pixie16::GetStatitics(unsigned short modID){
int ss = Pixie16GetStatisticsSize();
if( Statistics != NULL ) delete Statistics;
Statistics = new unsigned int [ss];
retval = Pixie16ReadStatisticsFromModule (Statistics, modID);
if( CheckError("Pixie16ReadStatisticsFromModule") < 0 ) return NULL;
return Statistics;
}
void Pixie16::PrintStatistics(unsigned short modID){
GetStatitics(modID);
if( retval >= 0 ){
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
double realTime = Pixie16ComputeRealTime (Statistics, modID);
printf(" Real (or RUN) Time : %9.3f sec \n", realTime);
printf(" ch | live time (sec) | input count rate | output count rate | trigger | events \n");
printf("-----+-----------------+------------------+-------------------+---------+--------\n");
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
for( int ch = 0; ch < 16; ch ++){
printf(" %2d |", ch);
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
double liveTime = Pixie16ComputeLiveTime(Statistics, modID, ch);
double ICR = Pixie16ComputeInputCountRate(Statistics, modID, ch);
double OCR = Pixie16ComputeOutputCountRate(Statistics, modID, ch);
printf(" %15.4f |", liveTime);
printf(" %16.4f |", ICR);
printf(" %17.4f |", OCR);
printf(" %7d |", (int) (ICR * liveTime) );
printf(" %7d \n", (int) (OCR * realTime) );
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
}
}
}
double Pixie16::GetInputCountRate(unsigned short modID, unsigned short ch){
int ss = Pixie16GetStatisticsSize();
unsigned int statistics[ss];
retval = Pixie16ReadStatisticsFromModule (statistics, modID);
if( CheckError("Pixie16ReadStatisticsFromModule") < 0 ) return -404;
return Pixie16ComputeInputCountRate (Statistics, modID, ch);
}
double Pixie16::GetLiveTime(unsigned short modID, unsigned short ch){
int ss = Pixie16GetStatisticsSize();
unsigned int statistics[ss];
retval = Pixie16ReadStatisticsFromModule (statistics, modID);
if( CheckError("Pixie16ReadStatisticsFromModule") < 0 ) return -404;
return Pixie16ComputeLiveTime (statistics, modID, ch);
}
double Pixie16::GetOutputCountRate(unsigned short modID, unsigned short ch){
int ss = Pixie16GetStatisticsSize();
unsigned int statistics[ss];
retval = Pixie16ReadStatisticsFromModule (statistics, modID);
if( CheckError("Pixie16ReadStatisticsFromModule") < 0 ) return -404;
return Pixie16ComputeOutputCountRate (statistics, modID, ch);
}
double Pixie16::GetRealTime(unsigned short modID){
int ss = Pixie16GetStatisticsSize();
unsigned int statistics[ss];
retval = Pixie16ReadStatisticsFromModule (statistics, modID);
if( CheckError("Pixie16ReadStatisticsFromModule") < 0 ) return -404;
return Pixie16ComputeRealTime (statistics, modID);
}
void Pixie16::SaveSettings(std::string fileName){
retval = Pixie16SaveDSPParametersToFile((char *)fileName.c_str());
if( CheckError("Pixie16SaveDSPParametersToFile") < 0 ) {
return;
}else{
printf("saved setting to %s\n", fileName.c_str());
}
}
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
void Pixie16::OpenFile(std::string fileName, bool append){
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
if( !outFile.is_open() ) {
if( append ) {
outFile.open(fileName, std::ios::out | std::ios::binary | std::ios::app);
}else{
outFile.open(fileName, std::ios::out | std::ios::binary);
}
}
}
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
can get data in list mode. need to check the trace data
2022-03-04 13:42:24 -05:00
void Pixie16::SaveData(){
if( outFile.is_open() ) outFile.write(reinterpret_cast<char*>(ExtFIFO_Data), nFIFOWords * sizeof(uint32_t));
}
void Pixie16::CloseFile(){
outFile.close();
}
use libPixie16Api.so, can change setting, try to understand the collected data
2022-03-02 18:28:38 -05:00
#endif
Reference in New Issue Copy Permalink