rtang/FSUDAQ
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

many many changes

Browse Source
This commit is contained in:
carina@hades 2022-08-23 13:43:05 -04:00
parent c5fd1b1f65
commit 4ead86783a
17 changed files with 938 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

331
ClassData.h
View File

@ -9,176 +9,197 @@
#include <iostream> ///cout
#include <bitset>
#include "CAENDigitizer.h"
#include "CAENDigitizerType.h"
#include "macro.h"
//#include "CAENDigitizer.h"
//#include "CAENDigitizerType.h"
//#include "macro.h"
class Data{
public:
unsigned int nByte; /// number of byte
unsigned int nByte; /// number of byte
char *buffer; /// readout buffer
uint32_t NumEvents[MaxNChannels];
uint32_t AllocatedSize;
uint32_t BufferSize;
CAEN_DGTZ_DPP_PHA_Event_t *Events[MaxNChannels]; /// events buffer
CAEN_DGTZ_DPP_PHA_Waveforms_t *Waveform[MaxNChannels]; /// waveforms buffer
///uint32_t NumEvents[MaxNChannels];
///CAEN_DGTZ_DPP_PHA_Event_t *Events[MaxNChannels]; /// events buffer
///CAEN_DGTZ_DPP_PHA_Waveforms_t *Waveform[MaxNChannels]; /// waveforms buffer
public:
Data(){
nByte = 0;
buffer = NULL;
AllocatedSize = 0;
BufferSize = 0;
for( int i = 0 ; i < MaxNChannels; i++){
NumEvents[i] = 0;
Events[i] = NULL;
Waveform[i] = NULL;
}
}
~Data(){
delete buffer;
for( int i = 0 ; i < MaxNChannels; i++){
delete Events [i];
delete Waveform [i];
}
}
Data();
~Data();
void AllocateMemory(){
BufferSize = 100000; /// byte
buffer = (char *) malloc( BufferSize);
printf("Allocated %d byte for buffer \n", BufferSize);
for( int i = 0 ; i < MaxNChannels ; i++ ) Events[i] = (CAEN_DGTZ_DPP_PHA_Event_t *) malloc( BufferSize);
printf("Allocated %d byte for Events for each channel \n", BufferSize);
void AllocateMemory();
void FreeMemory();
}
void SaveBuffer(char * fileName);
void FreeMemory(){
printf("======= Free memory, not impletment yet \n");
}
void ReadAllBuffer(int verbose = 0){
/// verbose : 0 = off, 1 = only energy + timestamp, 2 = show header, 3 = wave
if( buffer == NULL ) return;
unsigned int nw = 0;
do{
if( verbose >= 2 ) printf("######################################### Board Agg.\n");
unsigned int word = ReadBuffer(nw, verbose);
if( ( (word >> 28) & 0xF ) == 0xA ) { /// start of Board Agg
unsigned int nWord = word & 0x0FFFFFFF ;
if( verbose >= 2 ) printf(" number of words in this Agg : %d \n", nWord);
nw = nw + 1; word = ReadBuffer(nw, verbose);
unsigned int BoardID = ((word >> 27) & 0x1F);
bool BoardFailFlag = ((word >> 26) & 0x1 );
unsigned int ChannelMask = ( word & 0xFF ) ;
if( verbose >= 2 ) printf("Board ID : %d, FailFlag = %d, ChannelMask = 0x%x\n", BoardID, BoardFailFlag, ChannelMask);
nw = nw + 2;
unsigned int AggCounter = ReadBuffer(nw, verbose);
if( verbose >= 2 ) printf("Agg Counter : %d \n", AggCounter);
for( int chMask = 0; chMask < 8 ; chMask ++ ){
if( ((ChannelMask >> chMask) & 0x1 ) == 0 ) continue;
if( verbose >= 2 ) printf("---------------------- Dual Channel Block : %d\n", chMask *2 );
nw = nw + 1; word = ReadBuffer(nw, verbose);
bool hasFormatInfo = ((word >> 31) & 0x1);
unsigned int aggSize = ( word & 0x3FFFFFF ) ;
if( verbose >= 2 ) printf(" size : %d \n", aggSize);
unsigned int nSample = 0; /// wave form;
unsigned int nEvents = 0;
if( hasFormatInfo ){
nw = nw + 1; word = ReadBuffer(nw, verbose);
nSample = ( word & 0xFFFF ) * 8;
unsigned int digitalProbe = ( (word >> 16 ) & 0xF );
unsigned int analogProbe2 = ( (word >> 20 ) & 0x3 );
unsigned int analogProbe1 = ( (word >> 22 ) & 0x3 );
unsigned int extra2Option = ( (word >> 24 ) & 0x7 );
bool hasWaveForm = ( (word >> 27 ) & 0x1 );
bool hasExtra2 = ( (word >> 28 ) & 0x1 );
bool hasTimeStamp = ( (word >> 29 ) & 0x1 );
bool hasEnergy = ( (word >> 30 ) & 0x1 );
bool hasDualTrace = ( (word >> 31 ) & 0x1 );
if( verbose >= 2 ) printf("dualTrace : %d, Energy : %d, Time: %d, Wave : %d, Extra2: %d, Extra2Option: %d \n",
hasDualTrace, hasEnergy, hasTimeStamp, hasWaveForm, hasExtra2, extra2Option);
if( verbose >= 2 ) printf("Ana Probe 1 & 2: %d %d , Digi Probe: %d, nSample : %d \n",
analogProbe1, analogProbe2, digitalProbe, nSample);
nEvents = aggSize / (nSample/2 + 2 + hasExtra2 );
if( verbose >= 2 ) printf("=========== nEvents : %d \n", nEvents);
}else{
if( verbose >= 2 ) printf("does not has format info. unable to read buffer.\n");
break;
}
for( int ev = 0; ev < nEvents ; ev++){
if( verbose >= 2 ) printf("=================================== event : %d\n", ev);
nw = nw +1 ; word = ReadBuffer(nw, verbose);
bool channelTag = ((word >> 31) & 0x1);
unsigned int timeStamp = (word & 0x7FFFFFFF);
int channel = chMask*2 + channelTag;
if( verbose >= 2 ) printf("ch : %d, timeStamp %u \n", channel, timeStamp);
///===== read waveform
for( int wi = 0; wi < nSample/2; wi++){
nw = nw +1 ; word = ReadBuffer(nw, verbose - 2);
bool isTrigger1 = (( word >> 31 ) & 0x1 );
unsigned int wave1 = (( word >> 16) & 0x3FFF);
bool isTrigger0 = (( word >> 15 ) & 0x1 );
unsigned int wave0 = ( word & 0x3FFF);
if( verbose >= 3 && ev == 0 ){
printf("%4d| %5d, %d \n", 2*wi, wave0, isTrigger0);
printf("%4d| %5d, %d \n", 2*wi+1, wave1, isTrigger1);
}
}
nw = nw +1 ; word = ReadBuffer(nw, verbose);
unsigned int extra2 = word;
nw = nw +1 ; word = ReadBuffer(nw, verbose);
unsigned int extra = (( word >> 16) & 0x3FF);
unsigned int energy = (word & 0x7FFF);
bool pileUp = ((word >> 15) & 0x1);
if( verbose >= 2 ) printf("PileUp : %d , extra : 0x%04x, energy : %d \n", pileUp, extra, energy);
if( verbose >= 1 ) printf("ch : %2d, PileUp : %d , energy : %d, timestamp : %u\n",
channel, pileUp, energy, timeStamp);
}
}
}else{
if( verbose >= 2 ) printf("incorrect buffer header. \n");
break;
}
nw++;
}while(true);
}
unsigned int ReadBuffer(unsigned int nWord, int verbose = 0){
if( buffer == NULL ) return 0;
unsigned int word = 0;
for( int i = 0 ; i < 4 ; i++) word += ((buffer[i + 4 * nWord] & 0xFF) << 8*i);
if( verbose >= 2) printf("%d | 0x%08x\n", nWord, word);
return word;
}
void DecodeBuffer(int verbose = 0);
protected:
unsigned int ReadBuffer(unsigned int nWord, int verbose = 0);
};
//==========================================
inline Data::Data(){
nByte = 0;
buffer = NULL;
AllocatedSize = 0;
BufferSize = 0;
///for( int i = 0 ; i < MaxNChannels; i++){
/// NumEvents[i] = 0;
/// Events[i] = NULL;
/// Waveform[i] = NULL;
///}
}
inline Data::~Data(){
if( buffer != NULL ) delete buffer;
///for( int i = 0 ; i < MaxNChannels; i++){
/// delete Events [i];
/// delete Waveform [i];
///}
}
inline void Data::AllocateMemory(){
BufferSize = 100000; /// byte
buffer = (char *) malloc( BufferSize);
printf("Allocated %d byte for buffer \n", BufferSize);
///for( int i = 0 ; i < MaxNChannels ; i++ ) Events[i] = (CAEN_DGTZ_DPP_PHA_Event_t *) malloc( BufferSize);
///printf("Allocated %d byte for Events for each channel \n", BufferSize);
}
inline void Data::FreeMemory(){
printf("======= Free memory\n");
delete buffer;
}
inline unsigned int Data::ReadBuffer(unsigned int nWord, int verbose){
if( buffer == NULL ) return 0;
unsigned int word = 0;
for( int i = 0 ; i < 4 ; i++) word += ((buffer[i + 4 * nWord] & 0xFF) << 8*i);
if( verbose >= 2) printf("%d | 0x%08x\n", nWord, word);
return word;
}
inline void Data::SaveBuffer(char * fileName){
FILE * haha = fopen(fileName, "a+");
fwrite(buffer, nByte, 1, haha);
fclose(haha);
}
inline void Data::DecodeBuffer(int verbose){
/// verbose : 0 = off, 1 = only energy + timestamp, 2 = show header, 3 = wave
if( buffer == NULL ) {
printf(" buffer is empty \n");
return;
}
unsigned int nw = 0;
do{
if( verbose >= 2 ) printf("######################################### Board Agg.\n");
unsigned int word = ReadBuffer(nw, verbose);
if( ( (word >> 28) & 0xF ) == 0xA ) { /// start of Board Agg
unsigned int nWord = word & 0x0FFFFFFF ;
if( verbose >= 2 ) printf(" number of words in this Agg : %d \n", nWord);
nw = nw + 1; word = ReadBuffer(nw, verbose);
unsigned int BoardID = ((word >> 27) & 0x1F);
bool BoardFailFlag = ((word >> 26) & 0x1 );
unsigned int ChannelMask = ( word & 0xFF ) ;
if( verbose >= 2 ) printf("Board ID : %d, FailFlag = %d, ChannelMask = 0x%x\n", BoardID, BoardFailFlag, ChannelMask);
nw = nw + 2;
unsigned int AggCounter = ReadBuffer(nw, verbose);
if( verbose >= 2 ) printf("Agg Counter : %d \n", AggCounter);
for( int chMask = 0; chMask < 8 ; chMask ++ ){
if( ((ChannelMask >> chMask) & 0x1 ) == 0 ) continue;
if( verbose >= 2 ) printf("---------------------- Dual Channel Block : %d\n", chMask *2 );
nw = nw + 1; word = ReadBuffer(nw, verbose);
bool hasFormatInfo = ((word >> 31) & 0x1);
unsigned int aggSize = ( word & 0x3FFFFFF ) ;
if( verbose >= 2 ) printf(" size : %d \n", aggSize);
unsigned int nSample = 0; /// wave form;
unsigned int nEvents = 0;
if( hasFormatInfo ){
nw = nw + 1; word = ReadBuffer(nw, verbose);
nSample = ( word & 0xFFFF ) * 8;
unsigned int digitalProbe = ( (word >> 16 ) & 0xF );
unsigned int analogProbe2 = ( (word >> 20 ) & 0x3 );
unsigned int analogProbe1 = ( (word >> 22 ) & 0x3 );
unsigned int extra2Option = ( (word >> 24 ) & 0x7 );
bool hasWaveForm = ( (word >> 27 ) & 0x1 );
bool hasExtra2 = ( (word >> 28 ) & 0x1 );
bool hasTimeStamp = ( (word >> 29 ) & 0x1 );
bool hasEnergy = ( (word >> 30 ) & 0x1 );
bool hasDualTrace = ( (word >> 31 ) & 0x1 );
if( verbose >= 2 ) printf("dualTrace : %d, Energy : %d, Time: %d, Wave : %d, Extra2: %d, Extra2Option: %d \n",
hasDualTrace, hasEnergy, hasTimeStamp, hasWaveForm, hasExtra2, extra2Option);
if( verbose >= 2 ) printf("Ana Probe 1 & 2: %d %d , Digi Probe: %d, nSample : %d \n",
analogProbe1, analogProbe2, digitalProbe, nSample);
nEvents = aggSize / (nSample/2 + 2 + hasExtra2 );
if( verbose >= 2 ) printf("=========== nEvents : %d \n", nEvents);
}else{
if( verbose >= 2 ) printf("does not has format info. unable to read buffer.\n");
break;
}
for( int ev = 0; ev < nEvents ; ev++){
if( verbose >= 2 ) printf("=================================== event : %d\n", ev);
nw = nw +1 ; word = ReadBuffer(nw, verbose);
bool channelTag = ((word >> 31) & 0x1);
unsigned int timeStamp = (word & 0x7FFFFFFF);
int channel = chMask*2 + channelTag;
if( verbose >= 2 ) printf("ch : %d, timeStamp %u \n", channel, timeStamp);
///===== read waveform
for( int wi = 0; wi < nSample/2; wi++){
nw = nw +1 ; word = ReadBuffer(nw, verbose - 2);
bool isTrigger1 = (( word >> 31 ) & 0x1 );
unsigned int wave1 = (( word >> 16) & 0x3FFF);
bool isTrigger0 = (( word >> 15 ) & 0x1 );
unsigned int wave0 = ( word & 0x3FFF);
if( verbose >= 3 && ev == 0 ){
printf("%4d| %5d, %d \n", 2*wi, wave0, isTrigger0);
printf("%4d| %5d, %d \n", 2*wi+1, wave1, isTrigger1);
}
}
nw = nw +1 ; word = ReadBuffer(nw, verbose);
unsigned int extra2 = word;
nw = nw +1 ; word = ReadBuffer(nw, verbose);
unsigned int extra = (( word >> 16) & 0x3FF);
unsigned int energy = (word & 0x7FFF);
bool pileUp = ((word >> 15) & 0x1);
if( verbose >= 2 ) printf("PileUp : %d , extra : 0x%04x, energy : %d \n", pileUp, extra, energy);
if( verbose >= 1 ) printf("ch : %2d, PileUp : %d , energy : %d, timestamp : %u\n",
channel, pileUp, energy, timeStamp);
}
}
}else{
if( verbose >= 2 ) printf("incorrect buffer header. \n");
break;
}
nw++;
}while(true);
}
#endif

101
ClassDigitizer.cpp
View File

@ -233,7 +233,7 @@ void Digitizer::ErrorMsg(string header){
}
int Digitizer::ProgramBoard(){
printf("----- program Board\n");
ret = CAEN_DGTZ_Reset(handle);
if (ret) {
@ -273,10 +273,9 @@ int Digitizer::ProgramBoard(){
CAEN_DGTZ_TRGMODE_ACQ_ONLY = generate acquisition trigger
CAEN_DGTZ_TRGMODE_ACQ_AND_EXTOUT = generate both Trigger Output and acquisition trigger
see CAENDigitizer user manual, chapter "Trigger configuration" for details */
//TODO set bit
ret |= CAEN_DGTZ_SetExtTriggerInputMode(handle, CAEN_DGTZ_TRGMODE_ACQ_ONLY);
/** Set the mode used to syncronize the acquisition between different boards.
In this example the sync is disabled */
ret |= CAEN_DGTZ_SetRunSynchronizationMode(handle, CAEN_DGTZ_RUN_SYNC_Disabled);
ErrorMsg("End of ProgramBoard");
@ -285,46 +284,6 @@ int Digitizer::ProgramBoard(){
}
//========================================================= ACQ control
int Digitizer::SetAcqMode(string list_mixed){
if( list_mixed == "list"){
AcqMode = CAEN_DGTZ_DPP_ACQ_MODE_List; /// enables the acquisition of time stamps and energy value
}else if ( list_mixed == "mixed"){
AcqMode = CAEN_DGTZ_DPP_ACQ_MODE_Mixed; /// enables the acquisition of both waveforms, energies, and timestamps.
}else{
printf("############ AcqMode must be either list or mixed\n");
return -1;
}
int ret = 0;
if( isConnected ){
/********************* Set the DPP acquisition mode
This setting affects the modes Mixed and List (see CAEN_DGTZ_DPP_AcqMode_t definition for details)
CAEN_DGTZ_DPP_SAVE_PARAM_EnergyOnly Only energy (DPP-PHA) or charge (DPP-PSD/DPP-CI v2) is returned
CAEN_DGTZ_DPP_SAVE_PARAM_TimeOnly Only time is returned
CAEN_DGTZ_DPP_SAVE_PARAM_EnergyAndTime Both energy/charge and time are returned
CAEN_DGTZ_DPP_SAVE_PARAM_None No histogram data is returned */
if( AcqMode == CAEN_DGTZ_DPP_ACQ_MODE_List){
ret = CAEN_DGTZ_SetDPPAcquisitionMode(handle, AcqMode, CAEN_DGTZ_DPP_SAVE_PARAM_EnergyAndTime);
}
if( AcqMode == CAEN_DGTZ_DPP_ACQ_MODE_Mixed ){
///ret = CAEN_DGTZ_SetDPPAcquisitionMode(handle, AcqMode, CAEN_DGTZ_DPP_SAVE_PARAM_TimeOnly);
ret = CAEN_DGTZ_SetDPPAcquisitionMode(handle, AcqMode, CAEN_DGTZ_DPP_SAVE_PARAM_EnergyAndTime);
}
SetExtra2WordOutput(true);
if( ret == 0 ) {
printf("Setting digitizer to \e[33m%s\e[0m mode.\n", list_mixed.c_str());
}else{
ErrorMsg("Set AcqMode");
}
}
return ret;
}
void Digitizer::StartACQ(){
if ( AcqRun ) return;
ret = CAEN_DGTZ_SWStartAcquisition(handle);
@ -347,7 +306,8 @@ void Digitizer::StopACQ(){
unsigned int Digitizer::CalByteForBuffer(){
unsigned int numAggBLT = ReadRegister(Register::DPP::MaxNumberOfAggregatePerBlackTransfer);
//TODO
unsigned int numAggBLT = ReadRegister(Register::DPP::MaxNumberOfAggregatePerBlockTransfer);
/// Channel Mask
/// is takeing waveForm
@ -358,7 +318,7 @@ unsigned int Digitizer::CalByteForBuffer(){
}
void Digitizer::ReadData(){
if( !isConnected ) return;
if( data->buffer == NULL ) {
printf("need allocate memory for readout buffer\n");
return;
@ -371,34 +331,11 @@ void Digitizer::ReadData(){
return;
}
ret = (CAEN_DGTZ_ErrorCode) CAEN_DGTZ_GetDPPEvents(handle, data->buffer, data->BufferSize, reinterpret_cast<void**>(&(data->Events)), data->NumEvents);
for( int i = 0 ; i < MaxNChannels; i++){
printf(" extracted %d events in ch-%02d\n", data->NumEvents[i], i);
}
ErrorMsg("GetDPPEvents");
printf("================================================\n");
///========== print events
for( int ch = 0; ch < NChannel; ch++){
printf("--------- ch - %d, %d\n", ch, data->NumEvents[ch]);
for( int ev = 0; ev < data->NumEvents[ch]; ev++){
printf("%4d, %lu, %d, %d, %d \n", ev, (data->Events[ch][ev]).TimeTag,
(data->Events[ch][ev]).Energy,
(data->Events[ch][ev]).Extras,
(data->Events[ch][ev]).Extras2);
}
}
FILE * haha = fopen("output.bin", "w+");
fwrite(data->buffer, data->nByte, 1, haha);
fclose(haha);
}
//===========================================================
void Digitizer::WriteRegister(uint32_t address, uint32_t value, int ch ){
if( !isConnected ) return;
if( address < 0x8000){
///printf("0x%x, 0x%x=%u, ch:%d\n", address, value, value, ch);
if( ch < 0 ) {
@ -415,6 +352,7 @@ void Digitizer::WriteRegister(uint32_t address, uint32_t value, int ch ){
}
uint32_t Digitizer::ReadRegister(uint32_t address, int ch, string str ){
if( !isConnected ) return 0;
uint32_t * Data = new uint32_t[NChannel];
if( address < 0x8000) {
if( ch < 0 ) {
@ -431,6 +369,7 @@ uint32_t Digitizer::ReadRegister(uint32_t address, int ch, string str ){
}
void Digitizer::SetChannelMask(uint32_t mask){
if( !isConnected ) return;
channelMask = mask;
ret |= CAEN_DGTZ_SetChannelEnableMask(handle, channelMask);
EditByteByRegister(Register::DPP::ChannelEnableMask);
@ -449,9 +388,9 @@ void Digitizer::SetEventAggregation(unsigned int numEvent, int ch){
ErrorMsg("SetEventAggregation");
}
void Digitizer::SetMaxNumberOfAggregatePerBlackTransfer(unsigned int numEvent){
WriteRegister( Register::DPP::MaxNumberOfAggregatePerBlackTransfer,numEvent);
ErrorMsg("SetMaxNumberOfAggregatePerBlackTransfer");
void Digitizer::SetMaxNumberOfAggregatePerBlockTransfer(unsigned int numEvent){
WriteRegister( Register::DPP::MaxNumberOfAggregatePerBlockTransfer,numEvent);
ErrorMsg("SetMaxNumberOfAggregatePerBlockTransfer");
}
void Digitizer::SetInputDynamicRange(unsigned int TwoVol_0_or_halfVol_1, int ch){ WriteRegister( Register::DPP::InputDynamicRange, TwoVol_0_or_halfVol_1, ch); ErrorMsg("SetInputDynamicRange");}
@ -461,6 +400,7 @@ void Digitizer::SetDCOffset(float offsetPrecentage, int ch)
void Digitizer::SetVetoWidth(uint32_t bit, int ch) { WriteRegister( Register::DPP::VetoWidth, bit, ch); ErrorMsg("SetVetoWidth");}
void Digitizer::SetTriggerPolarity(bool RiseingIsZero, int ch ){
if( !isConnected ) return;
if ( DPPType >= 128 ) return; /// do thing for DPP firmware
if( ch < 0 ) {
ret = 0;
@ -519,6 +459,17 @@ void Digitizer::SetDPPAlgorithmControl(uint32_t bit, int ch){
if( ret != 0 ) ErrorMsg("SetDPPAlgorithmControl");
}
unsigned int Digitizer::ReadBits(uint32_t address, unsigned int bitLength, unsigned int bitSmallestPos, int ch ){
uint32_t bit ;
uint32_t bitmask = (uint(pow(2, bitLength)-1) << bitSmallestPos);
int tempCh = ch;
if (ch < 0 && address < 0x8000 ) tempCh = 0; /// take ch-0
bit = ReadRegister(address, tempCh);
///printf("bit : 0x%x, bitmask : 0x%x \n", bit, bitmask);
bit = (bit & ~bitmask);
return bit;
}
void Digitizer::SetBits(uint32_t address, unsigned int bitValue, unsigned int bitLength, unsigned int bitSmallestPos, int ch){
///printf("address : 0x%x, value : 0x%x, len : %d, pos : %d, ch : %d \n", address, bitValue, bitLength, bitSmallestPos, ch);
uint32_t bit ;
@ -533,10 +484,8 @@ void Digitizer::SetBits(uint32_t address, unsigned int bitValue, unsigned int bi
if( ret != 0 ) ErrorMsg("SetBits");
}
void Digitizer::SetExtra2WordOutput(bool OnOff) { SetBits(Register::BoardConfiguration, OnOff, 1, 17); ErrorMsg("PHA-SetExtra2WordOutput");}
int Digitizer::GetChTemperature(int ch){
if( !isConnected ) return -404;
if( BoardInfo.Model != CAEN_DGTZ_V1730 &&
BoardInfo.Model != CAEN_DGTZ_V1725 &&
BoardInfo.Model != CAEN_DGTZ_V1751 ) return -404;
@ -548,7 +497,7 @@ int Digitizer::GetChTemperature(int ch){
}
void Digitizer::PrintACQStatue(){
if( !isConnected ) return;
unsigned int status = ReadRegister(Register::DPP::AcquisitionStatus);
printf("=================== Print ACQ status \n");

45
ClassDigitizer.h
View File

@ -26,8 +26,7 @@ class Digitizer{
Digitizer(int boardID, int portID = 0);
~Digitizer();
Data * data;
void Reset();
int OpenDigitizer(int boardID, int portID = 0, bool verbose = false);/// portID is for optical link for using PCIe card, from 0, 1, 2, 3
int CloseDigitizer();
@ -48,33 +47,44 @@ class Digitizer{
void SetEventAggregation(unsigned int numEvent, int ch = -1);
void SetAggregateOrganization(unsigned int bit);
void SetMaxNumberOfAggregatePerBlackTransfer(unsigned int numEvent);
void SetMaxNumberOfAggregatePerBlockTransfer(unsigned int numEvent);
void SetBits(uint32_t address, unsigned int bitValue, unsigned int bitLength, unsigned int bitSmallestPos, int ch = -1);
void SetDPPAlgorithmControl(uint32_t bit, int ch = -1);
void SetExtra2WordOutput(bool OnOff);
int SetAcqMode(string list_mixed);
///================ Get Settings
int GetSerialNumber() {return BoardInfo.SerialNumber;}
int GetChannelMask() {return channelMask;}
float GetCh2ns() {return ch2ns;}
int GetNChannel() {return NChannel;}
int GetHandle() {return handle;}
int GetSerialNumber() {return BoardInfo.SerialNumber;}
int GetChannelMask() {return channelMask;}
bool GetChannelOnOff(unsigned ch) {return (channelMask & ( 1 << ch) );}
float GetCh2ns() {return ch2ns;}
int GetNChannel() {return NChannel;}
int GetHandle() {return handle;}
bool GetConnectionStatus() {return isConnected;}
int GetDPPType() {return DPPType;}
int GetChTemperature(int ch) ;
int GetChTemperature(int ch) ;
bool GetConnectionStatus() {return isConnected;}
int GetDPPType() {return DPPType;}
unsigned int GetRecordLengthSample(int ch) {return ReadRegister(Register::DPP::RecordLength_G, ch) * 8;}
unsigned int GetInputDynamicRange(int ch) {return ReadRegister(Register::DPP::InputDynamicRange, ch);}
unsigned int GetPreTriggerSample(int ch) {return ReadRegister(Register::DPP::PreTrigger, ch) * 4;}
float GetDCOffset(int ch) {return 100.0 - ReadRegister(Register::DPP::ChannelDCOffset, ch) * 100. / 0xFFFFF; }
unsigned int GetVetoWidth(int ch) {return ReadRegister(Register::DPP::VetoWidth, ch);}
void PrintBoardConfiguration();
void PrintACQStatue();
unsigned int GetEventAggregation(int ch = -1) {return ReadRegister(Register::DPP::NumberEventsPerAggregate_G, ch);}
unsigned int GetAggregateOrganization() {return ReadRegister(Register::DPP::AggregateOrganization);}
unsigned int GetMaxNumberOfAggregatePerBlockTransfer() {return ReadRegister(Register::DPP::MaxNumberOfAggregatePerBlockTransfer);}
unsigned int ReadBits(uint32_t address, unsigned int bitLength, unsigned int bitSmallestPos, int ch = -1 );
unsigned int GetDPPAlgorithmControl(int ch = -1) {return ReadRegister(Register::DPP::DPPAlgorithmControl, ch);}
void PrintACQStatue();
///================ ACQ control
void StopACQ();
void StartACQ();
void ReadData();
Data * GetData(){ return data;}
unsigned int CalByteForBuffer();
@ -86,8 +96,11 @@ class Digitizer{
void EditByteByRegister(uint32_t registerAddress, int ch = -1);
unsigned long ReadSettingBinary(uint32_t filePos, int ch = -1); /// read from setting binary
protected:
Data * data;
///---- fixed parameter
int portID; /// port ID for optical link for using PCIe card, from 0, 1, 2, 3
int boardID; /// board identity

50
DigitizerPHA.cpp
View File

@ -1,7 +1,7 @@
#include "DigitizerPHA.h"
DigitizerPHA::DigitizerPHA(){
DPPType = V1730_DPP_PHA_CODE;
}
DigitizerPHA::DigitizerPHA(int boardID, int portID){
@ -18,22 +18,16 @@ int DigitizerPHA::ProgramBoard(){
printf("======== program board\n");
ret = CAEN_DGTZ_WriteRegister(handle, Register::DPP::RecordLength_G + 0x7000, 625);
if( ret != 0 ) { printf("==== set Record Length.\n"); return 0;}
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::BoardConfiguration, 0x4E8115);
ret = CAEN_DGTZ_WriteRegister(handle, Register::DPP::BoardConfiguration, 0x4E8115);
//TODO change to write register
ret = CAEN_DGTZ_SetAcquisitionMode(handle, CAEN_DGTZ_SW_CONTROLLED); /// software command
ret |= CAEN_DGTZ_SetIOLevel(handle, CAEN_DGTZ_IOLevel_NIM);
ret |= CAEN_DGTZ_SetExtTriggerInputMode(handle, CAEN_DGTZ_TRGMODE_ACQ_ONLY);
if( ret != 0 ) { printf("==== CAEN_DGTZ_SetExtTriggerInputMode.\n"); return 0;}
ret = CAEN_DGTZ_SetChannelEnableMask(handle, 0xFFFF);
if( ret != 0 ) { printf("==== CAEN_DGTZ_SetChannelEnableMask.\n"); return 0;}
ret = CAEN_DGTZ_SetNumEventsPerAggregate(handle, 0);
if( ret != 0 ) { printf("==== CAEN_DGTZ_SetNumEventsPerAggregate. %d\n", ret); return 0;}
//ret = CAEN_DGTZ_SetNumEventsPerAggregate(handle, 0);
ret = CAEN_DGTZ_SetRunSynchronizationMode(handle, CAEN_DGTZ_RUN_SYNC_Disabled);
if( ret != 0 ) { printf("==== set board error.\n"); return 0;}
@ -58,7 +52,7 @@ int DigitizerPHA::ProgramBoard(){
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::NumberEventsPerAggregate_G + 0x7000, 5);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::AggregateOrganization, 0);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlackTransfer, 40);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlockTransfer, 40);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::DPPAlgorithmControl + 0x7000, 0xe30200f);
if( ret != 0 ) { printf("==== set channels error.\n"); return 0;}
@ -68,36 +62,6 @@ int DigitizerPHA::ProgramBoard(){
return ret;
}
void DigitizerPHA::SetAnalogProbe1(unsigned int bit) { SetBits(Register::DPP::BoardConfiguration, bit, 2, 12); ErrorMsg("PHA-SetAnalogProbe1"); }
void DigitizerPHA::SetAnalogProbe2(unsigned int bit) { SetBits(Register::DPP::BoardConfiguration, bit, 2, 14); ErrorMsg("PHA-SetAnalogProbe1"); }
void DigitizerPHA::SetWaveFormRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 16); ErrorMsg("PHA-SetWaveFormRecording"); }
void DigitizerPHA::SetTimeStampRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 18); ErrorMsg("PHA-SetTimeStampRecording"); }
void DigitizerPHA::SetEnergyRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 19); ErrorMsg("PHA-SetEnergyRecording");}
void DigitizerPHA::SetVirtualProbe1(unsigned int bit){ SetBits(Register::DPP::BoardConfiguration, bit, 4, 20); ErrorMsg("PHA-SetVirtualProbe1"); }
void DigitizerPHA::SetTrapezoidRescaling(unsigned int rightShiftBits, int ch){ SetBits(Register::DPP::DPPAlgorithmControl, rightShiftBits, 5, 0, ch); ErrorMsg("SetTrapezoidRescaling"); }
void DigitizerPHA::SetPeakSampling(unsigned int bit, int ch) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 2, 12, ch); ErrorMsg("SetPeakSampling");}
void DigitizerPHA::SetPulsePolarity(bool PositiveIsZero, int ch) { SetBits(Register::DPP::DPPAlgorithmControl, PositiveIsZero, 1, 16, ch); ErrorMsg("SetPulsePolarity");}
void DigitizerPHA::SetBaselineSampling(unsigned int bit, int ch) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 3, 20, ch); ErrorMsg("SetBaselineSampling"); }
void DigitizerPHA::SetRollOverFlag(bool isRollOver, int ch) { SetBits(Register::DPP::DPPAlgorithmControl, isRollOver, 1, 26, ch); ErrorMsg("SetRollOverFlag");}
void DigitizerPHA::SetPileUpFlag(bool isPileUpFlag, int ch) { SetBits(Register::DPP::DPPAlgorithmControl, isPileUpFlag, 1, 27, ch); ErrorMsg("SetPileUpFlag");}
void DigitizerPHA::SetExtra2WordOption(unsigned int bit, int ch) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 3, 8, ch); ErrorMsg("PHA-SetExtra2WordOption");}
void DigitizerPHA::SetDPPAlgorithmControl2(unsigned int bit, int ch) { WriteRegister(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, ch); ErrorMsg("PHA-SetDPPAlgorithmControl2");}
void DigitizerPHA::SetTriggerThreshold(unsigned int threshold, int ch ) { WriteRegister(Register::DPP::PHA::TriggerThreshold, threshold & 0x03FF, ch); ErrorMsg("PHA-SetTriggerThreshold");}
void DigitizerPHA::SetTriggerHoldOff(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::TriggerHoldOffWidth, nSample & 0x03FF, ch); ErrorMsg("PHA-SetTriggerHoldOff"); }
void DigitizerPHA::SetTriggerSmoothingFactor(unsigned int bit, int ch ) { WriteRegister(Register::DPP::PHA::RCCR2SmoothingFactor, bit & 0x001F, ch); ErrorMsg("PHA-SetTriggerSmoothingFactor");}
void DigitizerPHA::SetTriggerOutputWidth(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::ShapedTriggerWidth, nSample & 0x03FF, ch); ErrorMsg("PHA-SetTriggerOutputWidth");}
void DigitizerPHA::SetInputRiseTime(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::InputRiseTime, nSample & 0x00FF, ch); ErrorMsg("PHA-SetInputRiseTime");}
void DigitizerPHA::SetTrapezoidRiseTime(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::TrapezoidRiseTime, nSample & 0x0FFF, ch); ErrorMsg("PHA-SetTrapezoidRiseTime");}
void DigitizerPHA::SetTrapezoidFlatTop(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::TrapezoidFlatTop, nSample & 0x0FFF, ch); ErrorMsg("PHA-SetTrapezoidFlatTop");}
void DigitizerPHA::SetDecayTime(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::DecayTime, nSample & 0xFFFF, ch); ErrorMsg("PHA-SetDecayTime");}
void DigitizerPHA::SetPeakingTime(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::PeakingTime, nSample & 0x0FFF, ch); ErrorMsg("PHA-SetPeakingTime");}
void DigitizerPHA::SetPeakingHoldOff(unsigned int nSample, int ch ) { WriteRegister(Register::DPP::PHA::PeakHoldOff, nSample & 0x03FF, ch); ErrorMsg("PHA-SetPeakingHoldOff");}
void DigitizerPHA::SetEnergyFineGain(unsigned int gain, int ch ) { WriteRegister(Register::DPP::PHA::FineGain, gain & 0xFFFF, ch); ErrorMsg("PHA-SetEnergyFineGain");}
void DigitizerPHA::SetRiseTimeValidWindow(unsigned int nSample, int ch ){ WriteRegister(Register::DPP::PHA::RiseTimeValidationWindow,nSample & 0x03FF, ch); ErrorMsg("PHA-SetRiseTimeValidWindow");}
void DigitizerPHA::AutoSetTrapezoidRescalingAndFindGate(double gain, int ch){
@ -263,7 +227,7 @@ void DigitizerPHA::PrintChannelSettingFromDigitizer(int ch){
printf("========= events storage and transfer\n");
CAEN_DGTZ_ReadRegister(handle, Register::DPP::NumberEventsPerAggregate_G + (ch << 8), value); printf("%24s %d \n", "Event Aggregate", value[0] & 0x3FF);
CAEN_DGTZ_ReadRegister(handle, Register::DPP::AggregateOrganization, value); printf("%24s %d \n", "Buffer Division", ((value[0] & 0x007) < 2 ? 0 : (int)pow(2, value[0] & 7)));
CAEN_DGTZ_ReadRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlackTransfer , value); printf("%24s %d \n", "Num of Agg. / ReadData", value[0] & 0x1FF);
CAEN_DGTZ_ReadRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlockTransfer , value); printf("%24s %d \n", "Num of Agg. / ReadData", value[0] & 0x1FF);
printf("========================================= end of ch-%d\n", ch);

81
DigitizerPHA.h
View File

@ -12,39 +12,68 @@ class DigitizerPHA : public Digitizer {
int ProgramBoard();
void SetAnalogProbe1(unsigned int bit);
void SetAnalogProbe2(unsigned int bit);
void SetWaveFormRecording(bool OnOff);
void SetTimeStampRecording(bool OnOff);
void SetEnergyRecording(bool OnOff);
void SetVirtualProbe1(unsigned int bit);
void SetAutoDataFlush(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 0); ErrorMsg("PHA-SetAutoDataFlush"); }
void SetDualTrace(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 11); ErrorMsg("PHA-SetDualTrace"); }
void SetAnalogProbe1(unsigned int bit) { SetBits(Register::DPP::BoardConfiguration, bit, 2, 12); ErrorMsg("PHA-SetAnalogProbe1"); }
void SetAnalogProbe2(unsigned int bit) { SetBits(Register::DPP::BoardConfiguration, bit, 2, 14); ErrorMsg("PHA-SetAnalogProbe1"); }
void SetWaveFormRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 16); ErrorMsg("PHA-SetWaveFormRecording"); }
void SetEnableExtra2Word(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 17); ErrorMsg("PHA-SetEnableExtra2Word"); }
void SetTimeStampRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 18); ErrorMsg("PHA-SetTimeStampRecording"); }
void SetEnergyRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 19); ErrorMsg("PHA-SetEnergyRecording");}
void SetVirtualProbe1(unsigned int bit){ SetBits(Register::DPP::BoardConfiguration, bit, 4, 20); ErrorMsg("PHA-SetVirtualProbe1"); }
void AutoSetTrapezoidRescalingAndFindGate(double gain = 1, int ch = -1);
void SetTrapezoidRescaling(unsigned int rightShiftBits, int ch = -1){ SetBits(Register::DPP::DPPAlgorithmControl, rightShiftBits, 5, 0, ch); ErrorMsg("PHA-SetTrapezoidRescaling"); }
void SetDecimation(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 2, 8, ch); ErrorMsg("PHA-SetDecimation");}
void SetDecimationGain(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 2, 10, ch); ErrorMsg("PHA-SetDecimationGain");}
void SetPeakSampling(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 2, 12, ch); ErrorMsg("PHA-SetPeakSampling");}
void SetPulsePolarity(bool PositiveIsZero, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, PositiveIsZero, 1, 16, ch); ErrorMsg("PHA-SetPulsePolarity");}
void SetTriggerMode(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 2, 18, ch); ErrorMsg("PHA-SetTriggerMode");}
void SetBaselineSampling(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 3, 20, ch); ErrorMsg("PHA-SetBaselineSampling"); }
void SetDisableSelfTrigger(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 24, ch); ErrorMsg("PHA-SetDisableSelfTrigger");}
void SetRollOverFlag(bool isRollOver, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, isRollOver, 1, 26, ch); ErrorMsg("PHA-SetRollOverFlag");}
void SetPileUpFlag(bool isPileUpFlag, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, isPileUpFlag, 1, 27, ch); ErrorMsg("PHA-SetPileUpFlag");}
void SetDPPAlgorithmControl2(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, ch); ErrorMsg("PHA-SetDPPAlgorithmControl2");}
void SetLocalShapedTriggerMode(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 2, 0, ch); ErrorMsg("PHA-SetLocalShapedTriggerMode");}
void SetEnableLocalShapedTrigger(bool OnOff, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, OnOff, 1, 2, ch); ErrorMsg("PHA-SetEnableLocalShapedTrigger");}
void SetLocalTriggerValidationMode(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 2, 4, ch); ErrorMsg("PHA-SetLocalTriggerValidationMode");}
void SetEnableLocalTriggerValidation(bool OnOff, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, OnOff, 1, 6, ch); ErrorMsg("PHA-SetEnableLocalTriggerValidation");}
void SetExtra2WordOption(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 3, 8, ch); ErrorMsg("PHA-SetExtra2WordOption");}
void SetVetoSource(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 2, 14, ch); ErrorMsg("PHA-SetVetoSource");}
void SetTriggerCounterRateStep(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 2, 16, ch); ErrorMsg("PHA-SetTriggerCounterRateStep");}
void SetBaselineCalWhenACQOFF(bool OnOff, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, OnOff, 1, 18, ch); ErrorMsg("PHA-SetBaselineCalWhenACQOFF");}
void SetTagCorrelatedEvents(bool OnOff, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, OnOff, 1, 19, ch); ErrorMsg("PHA-SetTagCorrelatedEvents");}
void SetBaselineRestoreOptimization(bool OnOff, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, OnOff, 1, 29, ch); ErrorMsg("PHA-SetBaselineRestoreOptimization");}
void SetTrapezoidRescaling(unsigned int rightShiftBits, int ch = -1); /// DPPAlgoritmControl bit-0:5
void SetPeakSampling(unsigned int bit, int ch = -1); /// DPPAlgoritmControl bit-10:11
void SetPulsePolarity(bool PositiveIsZero, int ch = -1); /// DPPAlgoritmControl bit-16
void SetBaselineSampling(unsigned int bit, int ch = -1); /// DPPAlgoritmControl bit-20:22
void SetRollOverFlag(bool isRollOver, int ch = -1); /// DPPAlgoritmControl bit-26
void SetPileUpFlag(bool isPileUpFlag, int ch = -1); /// DPPAlgoritmControl bit-27
void SetExtra2WordOption(unsigned int bit, int ch = -1);
void SetDPPAlgorithmControl2(unsigned int bit, int ch = -1);
void SetTriggerThreshold(unsigned int threshold, int ch = -1) { WriteRegister(Register::DPP::PHA::TriggerThreshold, threshold & 0x03FF, ch); ErrorMsg("PHA-SetTriggerThreshold");}
void SetTriggerHoldOff(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::TriggerHoldOffWidth, nSample & 0x03FF, ch); ErrorMsg("PHA-SetTriggerHoldOff"); }
void SetTriggerSmoothingFactor(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PHA::RCCR2SmoothingFactor, bit & 0x001F, ch); ErrorMsg("PHA-SetTriggerSmoothingFactor");}
void SetTriggerOutputWidth(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::ShapedTriggerWidth, nSample & 0x03FF, ch); ErrorMsg("PHA-SetTriggerOutputWidth");}
void SetInputRiseTime(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::InputRiseTime, nSample & 0x00FF, ch); ErrorMsg("PHA-SetInputRiseTime");}
void SetTriggerThreshold(unsigned int threshold, int ch = -1 );
void SetTriggerHoldOff(unsigned int nSample, int ch = -1 );
void SetTriggerSmoothingFactor(unsigned int bit, int ch = -1 );
void SetInputRiseTime(unsigned int nSample, int ch = -1);
void SetTriggerOutputWidth(unsigned int nSample, int ch = -1);
void SetTrapezoidRiseTime(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::TrapezoidRiseTime, nSample & 0x0FFF, ch); ErrorMsg("PHA-SetTrapezoidRiseTime");}
void SetTrapezoidFlatTop(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::TrapezoidFlatTop, nSample & 0x0FFF, ch); ErrorMsg("PHA-SetTrapezoidFlatTop");}
void SetDecayTime(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::DecayTime, nSample & 0xFFFF, ch); ErrorMsg("PHA-SetDecayTime");}
void SetPeakingTime(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::PeakingTime, nSample & 0x0FFF, ch); ErrorMsg("PHA-SetPeakingTime");}
void SetPeakingHoldOff(unsigned int nSample, int ch = -1) { WriteRegister(Register::DPP::PHA::PeakHoldOff, nSample & 0x03FF, ch); ErrorMsg("PHA-SetPeakingHoldOff");}
void SetTrapezoidRiseTime(unsigned int nSample, int ch = -1 );
void SetTrapezoidFlatTop(unsigned int nSample, int ch = -1 );
void SetDecayTime(unsigned int nSample, int ch = -1 );
void SetPeakingTime(unsigned int nSample, int ch = -1 );
void SetPeakingHoldOff(unsigned int nSample, int ch = -1 );
void SetEnergyFineGain(unsigned int gain, int ch = -1) { WriteRegister(Register::DPP::PHA::FineGain, gain & 0xFFFF, ch); ErrorMsg("PHA-SetEnergyFineGain");}
void SetRiseTimeValidWindow(unsigned int nSample, int ch = -1){ WriteRegister(Register::DPP::PHA::RiseTimeValidationWindow,nSample & 0x03FF, ch); ErrorMsg("PHA-SetRiseTimeValidWindow");}
///=================== Get settings
unsigned int GetAnalogProbe1() {return ReadBits(Register::DPP::BoardConfiguration, 2, 12);}
unsigned int GetAnalogProbe2() {return ReadBits(Register::DPP::BoardConfiguration, 2, 14);}
bool GetWaveFormRecarding() {return ReadBits(Register::DPP::BoardConfiguration, 1, 16);}
bool GetTimeStampRecording() {return ReadBits(Register::DPP::BoardConfiguration, 1, 18);}
bool GetEnergyRecording() {return ReadBits(Register::DPP::BoardConfiguration, 1, 19);}
unsigned int GetVirtualProbe1() {return ReadBits(Register::DPP::BoardConfiguration, 4, 20);}
void SetEnergyFineGain(unsigned int gain, int ch = -1 );
void SetRiseTimeValidWindow(unsigned int nSample, int ch = -1 );
unsigned int GetTriggerThreshold(unsigned int ch) {return ReadRegister(Register::DPP::PHA::TriggerThreshold, ch);}
void PrintBoardConfiguration();
void PrintChannelSettingFromDigitizer(int ch);

9
DigitizerPSD.cpp
View File

@ -2,7 +2,7 @@
#include "DigitizerPSD.h"
DigitizerPSD::DigitizerPSD(){
DPPType = V1730_DPP_PSD_CODE;
}
DigitizerPSD::DigitizerPSD(int boardID, int portID){
@ -12,3 +12,10 @@ DigitizerPSD::DigitizerPSD(int boardID, int portID){
DigitizerPSD::~DigitizerPSD(){
}
int DigitizerPSD::ProgramBoard(){
return ret;
}

76
DigitizerPSD.h
View File

@ -9,10 +9,80 @@ class DigitizerPSD : public Digitizer {
DigitizerPSD(int boardID, int portID = 0);
~DigitizerPSD();
//int ProgramBoard();
//
//void GetChannelSetting(int ch);
int ProgramBoard();
void SetAutoDataFlush(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 0); ErrorMsg("PSD-SetAutoDataFlush"); }
void SetDualTrace(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 11); ErrorMsg("PSD-SetDualTrace"); }
void SetAnalogProbe(unsigned int bit) { SetBits(Register::DPP::BoardConfiguration, bit, 2, 12); ErrorMsg("PSD-SetAnalogProbe1"); }
void SetWaveFormRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 16); ErrorMsg("PSD-SetWaveFormRecording"); }
void SetEnableExtraWord(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 17); ErrorMsg("PSD-SetEnableExtraWord"); }
void SetTimeStampRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 18); ErrorMsg("PSD-SetTimeStampRecording"); }
void SetChargeRecording(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 19); ErrorMsg("PSD-SetChargeRecording");}
void SetVirtualProbe1(unsigned int bit){ SetBits(Register::DPP::BoardConfiguration, bit, 3, 23); ErrorMsg("PSD-SetVirtualProbe1"); }
void SetVirtualProbe2(unsigned int bit){ SetBits(Register::DPP::BoardConfiguration, bit, 3, 26); ErrorMsg("PSD-SetVirtualProbe2"); }
void SetEnableDigitalTrace(bool OnOff) { SetBits(Register::DPP::BoardConfiguration, OnOff, 1, 31); ErrorMsg("PSD-SetEnableDigitalTrace");}
void SetChargeSensitivity(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 3, 0, ch); ErrorMsg("PSD-SetChargeSensitivity");}
void SetChargePedestal(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 4, ch); ErrorMsg("PSD-SetChargePedestal");}
void SetTriggerCounting(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 5, ch); ErrorMsg("PSD-SetTriggerCounting");}
void SetDiscriminationMode(bool LEDzero_CFDone, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, LEDzero_CFDone, 1, 6, ch); ErrorMsg("PSD-SetDiscriminationMode");}
void SetPileUpToTRIGOUT(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 7, ch); ErrorMsg("PSD-SetPileUpToTRIGOUT");}
void SetInternalTestPulse(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 8, ch); ErrorMsg("PSD-SetInternalTestPulse");}
void SetTestPulseRate(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 2, 9, ch); ErrorMsg("PSD-SetTestPulseRate");}
void SetBaelineRecalculateAfterLongGate(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 15, ch); ErrorMsg("PSD-SetBaelineRecalculateAfterLongGate");}
void SetPulsePolarity(bool PositiveIsZero, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, PositiveIsZero, 1, 16, ch); ErrorMsg("PSD-SetPulsePolarity");}
void SetTriggerMode(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 2, 18, ch); ErrorMsg("PSD-SetTriggerMode");}
void SetBaselineSampling(unsigned int bit, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, bit, 3, 20, ch); ErrorMsg("PSD-SetBaselineSampling");}
void SetDisableSelfTrigger(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 24, ch); ErrorMsg("PSD-SetDisableSelfTrigger");}
void SetDiscardQlongSmallerQThreshold(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 25, ch); ErrorMsg("PSD-SetDiscardQlongSmallerQThreshold");}
void SetPileUpRejection(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 26, ch); ErrorMsg("PSD-SetPileUpRejection");}
void SetEnablePSDcutBelowThreshold(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 27, ch); ErrorMsg("PSD-SetEnablePSDcutBelowThreshold");}
void SetEnablePSDcutAboveThreshold(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 28, ch); ErrorMsg("PSD-SetEnablePSDcutAboveThreshold");}
void SetOverRangeRejection(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 29, ch); ErrorMsg("PSD-SetOverRangeRejection");}
void SetDisableTriggerHysteresis(bool OnOff, int ch = -1) { SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 30, ch); ErrorMsg("PSD-SetDisableTriggerHysteresis");}
void SetDisableOppositeParityInhibitation(bool OnOff, int ch = -1){ SetBits(Register::DPP::DPPAlgorithmControl, OnOff, 1, 31, ch); ErrorMsg("PSD-SetDisableOppositeParityInhibitation");}
void SetDPPAlgorithmControl2(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::DPPAlgorithmControl2_G, bit, ch); ErrorMsg("PSD-SetDPPAlgorithmControl2");}
void SetLocalShapedTriggerMode(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, bit, 2, 0, ch); ErrorMsg("PSD-SetLocalShapedTriggerMode");}
void SetEnableLocalShapedTrigger(bool OnOff, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, OnOff, 1, 2, ch); ErrorMsg("PSD-SetEnableLocalShapedTrigger");}
void SetLocalTriggerValidationMode(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, bit, 2, 4, ch); ErrorMsg("PSD-SetLocalTriggerValidationMode");}
void SetEnableLocalTriggerValidation(bool OnOff, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, OnOff, 1, 6, ch); ErrorMsg("PSD-SetEnableLocalTriggerValidation");}
void SetExtraWordOption(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 3, 8, ch); ErrorMsg("PSD-SetExtraWordOption");}
void SetUseSmoothedSignal(bool OnOff, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, OnOff, 1, 11, ch); ErrorMsg("PSD-SetUseSmoothedSignal");}
void SetInputSmoothingFactor(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 4, 12, ch); ErrorMsg("PSD-SetInputSmoothingFactor");}
void SetTriggerCounterRateStep(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 2, 16, ch); ErrorMsg("PSD-SetTriggerCounterRateStep");}
void SetVetoSource(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PHA::DPPAlgorithmControl2_G, bit, 2, 18, ch); ErrorMsg("PSD-SetVetoSource");}
void SetMarkSaturatedPulse(bool OnOff, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, OnOff, 1, 24, ch); ErrorMsg("PSD-SetMarkSaturatedPulse");}
void SetAdditionalLocalTriggerValidation(unsigned int bit, int ch = -1 ) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, bit, 2, 25, ch); ErrorMsg("PSD-SetAdditionalLocalTriggerValidation");}
void SetVetoMode(bool OnOff, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, OnOff, 1, 27, ch); ErrorMsg("PSD-SetVetoMode");}
void SetTimestampResetWhenExtVetoActive(bool OnOff, int ch = -1) { SetBits(Register::DPP::PSD::DPPAlgorithmControl2_G, OnOff, 1, 28, ch); ErrorMsg("PSD-SetTimestampResetWhenExtVetoActive");}
void SetCFDSetting(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::CFDSetting, bit & 0x0FFF, ch); ErrorMsg("PSD-SetCFDSetting");}
void SetCFDDelayUnit(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PSD::CFDSetting, bit, 8, 0, ch); ErrorMsg("PSD-SetCFDDelayUnit");}
void SetCFDFraction(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PSD::CFDSetting, bit, 2, 8, ch); ErrorMsg("PSD-SetCFDFraction");}
void SetCFDInterpolationPoint(unsigned int bit, int ch = -1) { SetBits(Register::DPP::PSD::CFDSetting, bit, 2, 10, ch); ErrorMsg("PSD-SetCFDInterpolationPoint");}
void SetForceDataFlush(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::ForcedDataFlush, bit, ch); ErrorMsg("PSD-SetForceDataFlush");}
void SetChargeZeroSuppressionThreshold(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::ChargeZeroSuppressionThreshold, bit & 0xFFFF, ch); ErrorMsg("PSD-SetChargeZeroSuppressionThreshold");}
void SetShortGateWidthSample(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::ShortGateWidth, bit & 0x0FFF, ch); ErrorMsg("PSD-SetShortGateWidthSample");}
void SetLongGateWidthSample(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::LongGateWidth, bit & 0xFFFF, ch); ErrorMsg("PSD-SetLongGateWidthSample");}
void SetGateOffsetSample(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::GateOffset, bit & 0x00FF, ch); ErrorMsg("PSD-SetGateOffsetSample");}
void SetTriggerThreshold(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::TriggerThreshold, bit & 0x3FFF, ch); ErrorMsg("PSD-SetTriggerThreshold");}
void SetTriggerLatency(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::TriggerLatency, bit & 0x03FF, ch); ErrorMsg("PSD-SetTriggerLatency");}
void SetTriggerHoldOff(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::TriggerHoldOffWidth, bit & 0xFFFF, ch); ErrorMsg("PSD-SetTriggerHoldOff");}
void SetThresholdforPSDcut(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::ThresholdForPSDCut, bit & 0x03FF, ch); ErrorMsg("PSD-SetThresholdforPSDcut");}
void SetPurGapThreshold(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::PurGapThreshold, bit & 0x0FFF, ch); ErrorMsg("PSD-SetPurGapThreshold");}
void SetShapedTriggerWidth(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::ShapedTriggerWidth, bit & 0x03FF, ch); ErrorMsg("PSD-SetShapedTriggerWidth");}
void SetEarlyBaselineFreeze(unsigned int bit, int ch = -1) { WriteRegister(Register::DPP::PSD::EarlyBaselineFreeze, bit & 0x03FF, ch); ErrorMsg("PSD-SetEarlyBaselineFreeze");}
void SetFixedBaseline(unsigned int bit, int ch = -1) {
if ( bit == 0 ) SetBaselineSampling(3);
if ( bit > 0 ) {
SetBaselineSampling(0);
WriteRegister(Register::DPP::PSD::FixedBaseline, bit & 0x3FFF, ch);
ErrorMsg("PSD-SetTriggerThreshold");
}
}
};
#endif

92
FSUDAQ.cpp
View File

@ -16,29 +16,29 @@
#include "DigitizerPHA.h"
#include "DigitizerPSD.h"
#include "FSUDAQ.h"
enum MenuIdentifiers{
M_DIGITIZER_SCAN,
M_FILE_OPEN,
M_EXIT,
M_CH_SETTINGS_SUMMARY,
M_CH_SETTING,
M_MODULE_SETTINGS,
M_BOARD_SETTINGS,
M_PROGRAM_SETTINGS,
M_FINDPEAKS,
M_SHOW_CHANNELS_RATE
};
///make static members
DigitizerPHA * MainWindow::digi = NULL;
Digitizer ** MainWindow::digi = NULL;
TGTextEdit * MainWindow::teLog = NULL;
TRootEmbeddedCanvas * MainWindow::fEcanvas = NULL;
MainWindow::MainWindow(const TGWindow *p,UInt_t w,UInt_t h) {
DetectDigitizer();
digi = new DigitizerPHA(0,0);
nDigi = 0;
/// Create a main frame
fMain = new TGMainFrame(p,w,h);
@ -48,6 +48,7 @@ MainWindow::MainWindow(const TGWindow *p,UInt_t w,UInt_t h) {
fMenuBar = new TGMenuBar(fMain, 1, 1, kHorizontalFrame);
fMain->AddFrame(fMenuBar, new TGLayoutHints(kLHintsTop | kLHintsExpandX));
fMenuFile = new TGPopupMenu(gClient->GetRoot());
fMenuFile->AddEntry("&Scan Digitizers", M_DIGITIZER_SCAN);
fMenuFile->AddEntry("&Open File", M_FILE_OPEN);
fMenuFile->AddSeparator();
fMenuFile->AddEntry("E&xit", M_EXIT);
@ -58,7 +59,7 @@ MainWindow::MainWindow(const TGWindow *p,UInt_t w,UInt_t h) {
fMenuSettings->AddEntry("&Settings Summary", M_CH_SETTINGS_SUMMARY);
fMenuSettings->AddEntry("&Channel Setting", M_CH_SETTING);
fMenuSettings->AddSeparator();
fMenuSettings->AddEntry("&Digitizer Settings", M_MODULE_SETTINGS);
fMenuSettings->AddEntry("&Digitizer Settings", M_BOARD_SETTINGS);
fMenuSettings->AddSeparator();
fMenuSettings->AddEntry("Program Settings", M_PROGRAM_SETTINGS);
fMenuSettings->Connect("Activated(Int_t)", "MainWindow", this, "HandleMenu(Int_t)");
@ -75,6 +76,11 @@ MainWindow::MainWindow(const TGWindow *p,UInt_t w,UInt_t h) {
TGHorizontalFrame *hframe = new TGHorizontalFrame(fMain,200,40);
fMain->AddFrame(hframe, new TGLayoutHints(kLHintsCenterX,2,2,2,2));
///================= Open digitizers
TGTextButton *bOpenDigitizers = new TGTextButton(hframe,"Open Digitizers");
bOpenDigitizers->Connect("Clicked()","MainWindow",this,"DetectDigitizer()");
hframe->AddFrame(bOpenDigitizers, uniLayoutHints);
///================= signal Channel group
TGGroupFrame * group1 = new TGGroupFrame(hframe, "Single Channel", kHorizontalFrame);
hframe->AddFrame(group1 );
@ -107,13 +113,13 @@ MainWindow::MainWindow(const TGWindow *p,UInt_t w,UInt_t h) {
//fillHistThread = new TThread("kakaka", FillHistogram, (void *) 1);
///settingsSummary = NULL;
//boardSetting = NULL;
///channelSetting = NULL;
boardSetting = NULL;
channelSetting = NULL;
///scalarPanel = NULL;
LogMsg("Ready to run.");
///HandleMenu(M_CH_SETTINGS_SUMMARY);
HandleMenu(M_BOARD_SETTINGS);
}
MainWindow::~MainWindow() {
@ -122,16 +128,17 @@ MainWindow::~MainWindow() {
delete fMenuSettings;
delete fMenuUtility;
//delete modIDEntry;
//delete boardIDEntry;
//delete chEntry;
//delete tePath;
delete teLog;
delete digi;
if( digi != NULL ) delete [] digi;
delete boardSetting;
delete channelSetting;
//delete settingsSummary;
//delete boardSetting;
//delete channelSetting;
//delete scalarPanel;
//
//delete saveDataThread;
@ -146,6 +153,26 @@ MainWindow::~MainWindow() {
void MainWindow::HandleMenu(Int_t id){
switch(id){
///========================= Scan digitizers
case M_DIGITIZER_SCAN:{
printf("============= detect digitizers \n");
//DetectDigitizer();
printf("============= Connect %d digitizers...\n", nDigi);
if( nDigi > 0 ) {
digi = new Digitizer *[nDigi];
for( int i = 0; i < nDigi; i++){
if( DPPType[i] == V1730_DPP_PSD_CODE ) {
digi[i] = new DigitizerPSD(boardID[i], portID[i]);
}else if( DPPType[i] == V1730_DPP_PHA_CODE ){
digi[i] = new DigitizerPHA(boardID[i], portID[i]);
}else{
digi[i] = new Digitizer(boardID[i], portID[i]);
}
}
}
}break;
///========================= File Open
case M_FILE_OPEN:{
@ -161,11 +188,24 @@ void MainWindow::HandleMenu(Int_t id){
}break;
case M_CH_SETTING:{
if( channelSetting == NULL ) {
channelSetting = new ChannelSetting(gClient->GetRoot(), 600, 600, digi, nDigi);
}else{
//if( !channelSetting->isOpened ) {
channelSetting = new ChannelSetting(gClient->GetRoot(), 600, 600, digi, nDigi);
//}
}
}break;
///========================= Module setting
case M_MODULE_SETTINGS:{
///========================= Board setting
case M_BOARD_SETTINGS:{
if( boardSetting == NULL ) {
boardSetting = new BoardSetting(gClient->GetRoot(), 600, 600, digi, nDigi);
}else{
//if( !boardSetting->isOpened ) {
boardSetting = new BoardSetting(gClient->GetRoot(), 600, 600, digi, nDigi);
//}
}
}break;
///========================= Program setting
@ -191,13 +231,13 @@ void MainWindow::HandleMenu(Int_t id){
}
void MainWindow::DetectDigitizer(){
Digitizer * dig = new Digitizer();
vector<int> DPPType;
vector<int> portID;
vector<int> boardID;
int nDigi = 0;
DPPType.clear();
portID.clear();
boardID.clear();
nDigi = 0;
Digitizer * dig = new Digitizer();
for( int port = 0; port < 4 ; port ++){
for( int board = 0; board < 3 ; board ++){
@ -207,6 +247,7 @@ void MainWindow::DetectDigitizer(){
DPPType.push_back(dig->GetDPPType());
portID.push_back(port);
boardID.push_back(board);
serialNum.push_back(dig->GetSerialNumber());
dig->CloseDigitizer();
}
}
@ -238,8 +279,9 @@ Double_t standardPulse(Double_t *x, Double_t * par){
void MainWindow::GoodBye(){
digi->CloseDigitizer();
if( nDigi > 0 && digi != NULL) {
for(int i = 0; i < nDigi ; i++) digi[0]->CloseDigitizer();
}
printf("----- bye bye ---- \n");
gApplication->Terminate(0);

24
FSUDAQ.h
View File

@ -11,13 +11,16 @@
#include <TBenchmark.h>
#include <TGTextEditor.h>
#include "CAENDigitizer.h"
#include "macro.h"
#include "DigitizerPHA.h"
#include "DigitizerPSD.h"
///#include "global_macro.h"
#include "boardSetting.h"
#include "channelSetting.h"
///#include "settingsSummary.h"
///#include "scalarPanel.h"
//#include "boardSetting.h"
//#include "channelSetting.h"
class TGWindow;
class TGMainFrame;
class TRootEmbeddedCanvas;
@ -31,7 +34,7 @@ private:
TGMenuBar *fMenuBar;
TGPopupMenu *fMenuFile, *fMenuSettings, *fMenuUtility;
//static TGNumberEntry * modIDEntry, *chEntry;
//static TGNumberEntry * boardIDEntry, *chEntry;
//TGNumberEntry * runIDEntry;
//TGTextEntry * tePath;
//
@ -41,12 +44,17 @@ private:
//TGTextButton *bStopRun;
//TGTextButton *bFitTrace;
static DigitizerPHA * digi;
int nDigi;
vector<int> DPPType;
vector<int> portID;
vector<int> boardID;
vector<int> serialNum;
static Digitizer ** digi;
BoardSetting * boardSetting;
ChannelSetting * channelSetting;
//SettingsSummary * settingsSummary;
///ModuleSetting * moduleSetting;
//ChannelSetting * channelSetting;
//ScalarPanel * scalarPanel;
//
//TThread * saveDataThread;

20
Makefile
View File

@ -11,7 +11,7 @@ CAENLIBS = -lCAENDigitizer
ROOTLIBS = `root-config --cflags --glibs`
OBJS = ClassDigitizer.o DigitizerPHA.o DigitizerPSD.o FSUDAQ.o
OBJS = channelSetting.o boardSetting.o ClassDigitizer.o DigitizerPHA.o DigitizerPSD.o FSUDAQ.o
#########################################################################
@ -21,9 +21,6 @@ clean :
/bin/rm -f $(OBJS) test FSUDAQ FSUDAQDict.cxx *.pcm
#ClassData.o : ClassData.h macro.h
# $(CC) $(COPTS) -c ClassData.h -o ClassData.o
ClassDigitizer.o : ClassDigitizer.cpp ClassDigitizer.h RegisterAddress.h macro.h ClassData.h
$(CC) $(COPTS) -c ClassDigitizer.cpp
@ -38,8 +35,12 @@ test : test.cpp ClassDigitizer.o DigitizerPHA.o DigitizerPSD.o
$(CC) $(COPTS) -o test test.cpp ClassDigitizer.o DigitizerPHA.o DigitizerPSD.o $(CAENLIBS)
test_indep : test_indep.cpp RegisterAddress.h macro.h
@echo "--------- making test_indep"
$(CC) $(COPTS) -o test_indep test_indep.cpp $(CAENLIBS)
FSUDAQ : FSUDAQDict.cxx $(OBJS)
@echo "----------- creating FSUDAQ"
$(CC) $(COPTS) FSUDAQDict.cxx $(OBJS) -o FSUDAQ $(CAENLIBS) $(ROOTLIBS)
FSUDAQDict.cxx : FSUDAQ.h FSUDAQLinkDef.h
@echo "----------- creating pcm and cxx for root"
@ -50,10 +51,15 @@ FSUDAQ.o : FSUDAQ.h FSUDAQ.cpp FSUDAQDict.cxx
@echo "----------- creating FSUDAQ.o"
$(CC) $(COPTS) -c FSUDAQ.cpp ClassDigitizer.cpp DigitizerPHA.cpp DigitizerPSD.cpp $(ROOTLIBS)
FSUDAQ : FSUDAQDict.cxx $(OBJS)
@echo "----------- creating FSUDAQ"
$(CC) $(COPTS) FSUDAQDict.cxx $(OBJS) -o FSUDAQ $(CAENLIBS) $(ROOTLIBS)
boardSetting.o : boardSetting.h boardSetting.cpp
@echo "----------- creating boardSetting.o"
$(CC) $(COPTS) -c boardSetting.cpp $(ROOTLIBS)
channelSetting.o : channelSetting.h channelSetting.cpp
@echo "----------- creating channelSetting.o"
$(CC) $(COPTS) -c channelSetting.cpp $(ROOTLIBS)
#CutsCreator: $(OBJS3) src/CutsCreator.c
# g++ -std=c++17 -pthread src/CutsCreator.c -o CutsCreator $(ROOTLIBS)

6
RegisterAddress.h
View File

@ -59,7 +59,7 @@ namespace Register {
const uint32_t RelocationAddress = 0xEF10; /// R/W
const uint32_t InterruptStatusID = 0xEF14; /// R/W
const uint32_t InterruptEventNumber = 0xEF18; /// R/W
const uint32_t MaxNumberOfAggregatePerBlackTransfer = 0xEF1C; /// R/W
const uint32_t MaxNumberOfAggregatePerBlockTransfer = 0xEF1C; /// R/W
const uint32_t Scratch = 0xEF20; /// R/W
const uint32_t SoftwareReset = 0xEF24; /// W
const uint32_t SoftwareClear = 0xEF28; /// W
@ -117,7 +117,7 @@ namespace Register {
const uint32_t RelocationAddress = 0xEF10; /// R/W
const uint32_t InterruptStatusID = 0xEF14; /// R/W
const uint32_t InterruptEventNumber = 0xEF18; /// R/W
const uint32_t MaxNumberOfAggregatePerBlackTransfer = 0xEF1C; /// R/W
const uint32_t MaxNumberOfAggregatePerBlockTransfer = 0xEF1C; /// R/W
const uint32_t Scratch = 0xEF20; /// R/W
const uint32_t SoftwareReset = 0xEF24; /// W
const uint32_t SoftwareClear = 0xEF28; /// W
@ -178,7 +178,7 @@ namespace Register {
const uint32_t ShapedTriggerWidth = 0x1070; /// R/W
const uint32_t TriggerHoldOffWidth = 0x1074; /// R/W
const uint32_t ThresholdForPSDCut = 0x1078; /// R/W
const uint32_t PureGapThreshold = 0x107C; /// R/W
const uint32_t PurGapThreshold = 0x107C; /// R/W
const uint32_t DPPAlgorithmControl2_G = 0x1084; /// R/W
const uint32_t EarlyBaselineFreeze = 0x10D8; /// R/W
}

117
boardSetting.cpp Normal file
View File

@ -0,0 +1,117 @@
#include <TApplication.h>
#include <TGClient.h>
#include <TCanvas.h>
#include <TF1.h>
#include <TRandom.h>
#include <TGButton.h>
#include <TRootEmbeddedCanvas.h>
#include <TGTableContainer.h>
#include <TGFileDialog.h>
#include "boardSetting.h"
TString boardSettingName[NUM_BOARD_SETTING] = {
"Model",
"Board Info",
"Link Type",
"Serial Number",
"Number of channels",
"Sampling rate",
"ADC bit",
"ROC version",
"AMC version",
"Channel Enable Mask",
"Board Config",
"Aggregate Organization",
"Max Num. Of Aggregate Per Block Transfer",
"Acquisition Control",
"Acquisition Status",
"Global Trigger Mask",
"Disable External Trigger",
"Trigger Validation Mask",
"Extended Veto Delay",
"Front Panel TRG-OUT Enable Mask",
"Front Panel IO Control",
"Front Panel LVDS IO New Features",
"LVDS IO Data",
"AnalogMonitor Mode",
"FanSpeed Control",
"Readout Control",
"Readout Status"
};
BoardSetting::BoardSetting(const TGWindow *p, UInt_t w, UInt_t h, Digitizer ** digi, int nBoard){
this->digi = digi;
fMain = new TGMainFrame(p,w,h);
fMain->SetWindowName("Board Settings ");
fMain->Connect("CloseWindow()", "BoardSetting", this, "CloseWindow()");
TGVerticalFrame * vframe = new TGVerticalFrame(fMain);
fMain->AddFrame(vframe, new TGLayoutHints(kLHintsCenterX, 2,2,2,2));
///==========Module choose
TGHorizontalFrame *hframe0 = new TGHorizontalFrame(vframe, w, 50 );
vframe->AddFrame(hframe0, new TGLayoutHints(kLHintsCenterX, 2,2,2,2));
TGLabel * lb0 = new TGLabel(hframe0, "Board ID :");
hframe0->AddFrame(lb0, new TGLayoutHints(kLHintsCenterX | kLHintsCenterY, 5, 5, 3, 4));
boardIDEntry = new TGNumberEntry(hframe0, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
boardIDEntry->SetWidth(50);
boardIDEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, nBoard);
boardIDEntry->Connect("Modified()", "BoardSetting", this, "ChangeBoard()");
if( nBoard <= 1 ) boardIDEntry->SetState(false);
hframe0->AddFrame(boardIDEntry, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
int modID = boardIDEntry->GetNumber();
int comboBoxWidth = 135;
int comboBoxHeigth = 30;
TGHorizontalFrame *hframe[NUM_BOARD_SETTING];
TGLabel * lb[NUM_BOARD_SETTING];
for( int i = 0 ; i < NUM_BOARD_SETTING; i++){
hframe[i] = new TGHorizontalFrame(vframe, 50, 50 );
vframe->AddFrame(hframe[i], new TGLayoutHints(kLHintsRight, 2,2,2,2));
//int temp = digi[0]->GetSerialNumber();
int temp = 0;
lb[i] = new TGLabel(hframe[i], boardSettingName[i]);
hframe[i]->AddFrame(lb[i], new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5, 5, 3, 4));
entry[i] = new TGTextEntry(hframe[i], new TGTextBuffer(1));
entry[i]->SetEnabled(false);
entry[i]->SetText( Form("0x%x", temp) );
hframe[i]->AddFrame(entry[i], new TGLayoutHints(kLHintsRight, 5,5,3,4));
}
fMain->MapSubwindows();
fMain->Resize(fMain->GetDefaultSize());
fMain->MapWindow();
isOpened = true;
}
BoardSetting::~BoardSetting(){
isOpened = false;
delete boardIDEntry;
//delete entry;
/// fMain must be delete last;
fMain->Cleanup();
delete fMain;
}
void BoardSetting::ChangeBoard(){
int boardID = boardIDEntry->GetNumber();
return;
}

36
boardSetting.h Normal file
View File

@ -0,0 +1,36 @@
#ifndef BOARD_SETTING_H
#define BOARD_SETTING_H
#include <TQObject.h>
#include <TGNumberEntry.h>
#include <TGComboBox.h>
#include <TGLabel.h>
#include "DigitizerPHA.h"
#include "DigitizerPSD.h"
#include "macro.h"
#define NUM_BOARD_SETTING 27
class TGWindow;
class TGMainFrame;
class BoardSetting{
private:
TGMainFrame * fMain;
TGNumberEntry * boardIDEntry;
TGTextEntry * entry[NUM_BOARD_SETTING];
Digitizer ** digi;
public:
BoardSetting(const TGWindow *p, UInt_t w, UInt_t h, Digitizer ** digi, int nBoard);
virtual ~BoardSetting();
void CloseWindow() { printf("close BoardSetting window\n"); delete this; }
void ChangeBoard();
bool isOpened;
};
#endif

222
channelSetting.cpp Normal file
View File

@ -0,0 +1,222 @@
#include <TApplication.h>
#include <TGClient.h>
#include <TCanvas.h>
#include <TF1.h>
#include <TRandom.h>
#include <TGButton.h>
#include <TRootEmbeddedCanvas.h>
#include <TGTableContainer.h>
#include <TGFileDialog.h>
#include "channelSetting.h"
//TODO set MAX
///---------------------------------------------- NAME, DIGI, unit ... MAX
TString settingName[NUM_CHANNEL_SETTING][3] = {{"TRIGGER_RISETIME", "2", "us"},
{"TRIGGER_FLATTOP", "2", "us"},
{"TRIGGER_THRESHOLD", "0", "ADC"},
{"ENERGY_RISETIME", "1", "us"},
{"ENERGY_FLATTOP", "1", "us"},
{"TAU", "2", "us"},
{"TRACE_LENGTH", "2", "us"},
{"TRACE_DELAY", "2", "us"},
{"VOFFSET", "2", "V"},
{"XDT", "2", "us"},
{"BASELINE_PERCENT", "0", "%"},
{"BASELINE_AVERAGE", "0", ""},
{"BLCUT", "0", ""},
{"EMIN", "0", ""},
{"MultiplicityMaskL", "0", ""},
{"MultiplicityMaskH", "0", ""},
{"CHANNEL_CSRA", "0", ""}};
ChannelSetting::ChannelSetting(const TGWindow *p, UInt_t w, UInt_t h, Digitizer ** digi, int nDigi){
this->digi = digi;
fMain = new TGMainFrame(p,w,h);
fMain->SetWindowName("Channel Settings ");
fMain->Connect("CloseWindow()", "ChannelSetting", this, "CloseWindow()");
TGVerticalFrame * vframe = new TGVerticalFrame(fMain);
fMain->AddFrame(vframe, new TGLayoutHints(kLHintsCenterX, 2,2,2,2));
///==========Board choose
TGHorizontalFrame *hframe0 = new TGHorizontalFrame(vframe, w, 50 );
vframe->AddFrame(hframe0, new TGLayoutHints(kLHintsCenterX, 2,2,2,2));
TGLabel * lb0 = new TGLabel(hframe0, "Module ID :");
hframe0->AddFrame(lb0, new TGLayoutHints(kLHintsCenterX | kLHintsCenterY, 5, 5, 3, 4));
boardIDEntry = new TGNumberEntry(hframe0, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
boardIDEntry->SetWidth(50);
boardIDEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, nDigi);
boardIDEntry->Connect("Modified()", "ChannelSetting", this, "ChangeBoard()");
if( nDigi <= 1 ) boardIDEntry->SetState(false);
NChannel = 16 ;// digi[0]->GetNChannel();
hframe0->AddFrame(boardIDEntry, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
TGLabel * lb1 = new TGLabel(hframe0, "Channel :");
hframe0->AddFrame(lb1, new TGLayoutHints(kLHintsCenterX | kLHintsCenterY, 5, 5, 3, 4));
chIDEntry = new TGNumberEntry(hframe0, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
chIDEntry->SetWidth(50);
chIDEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, NChannel-1);
chIDEntry->Connect("Modified()", "ChannelSetting", this, "ChangeCh()");
hframe0->AddFrame(chIDEntry, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
int boardID = boardIDEntry->GetNumber();
int ch = chIDEntry->GetNumber();
int width = 80;
///----------- on/off
TGHorizontalFrame *hframeOnOff = new TGHorizontalFrame(vframe, 50, 50 );
vframe->AddFrame(hframeOnOff, new TGLayoutHints(kLHintsRight, 2,2,2,2));
cbOnOff = new TGComboBox(hframeOnOff);
cbOnOff->AddEntry("ON", 1);
cbOnOff->AddEntry("off", 0);
cbOnOff->Resize(width, 20);
//pixie->GetChannelOnOff(boardID, ch) ? cbOnOff->Select(1) : cbOnOff->Select(0);
cbOnOff->Connect("Selected(Int_t, Int_t)", "ChannelSetting", this, "ChangeOnOff()");
hframeOnOff->AddFrame(cbOnOff, new TGLayoutHints(kLHintsRight, 5,5,3,4));
TGLabel * lbOnOff = new TGLabel(hframeOnOff, "On/Off");
hframeOnOff->AddFrame(lbOnOff, new TGLayoutHints(kLHintsRight | kLHintsCenterY, 5, 5, 3, 4));
///----------- Polarity
TGHorizontalFrame *hframePol = new TGHorizontalFrame(vframe, 50, 50 );
vframe->AddFrame(hframePol, new TGLayoutHints(kLHintsRight, 2,2,2,2));
cbPolarity = new TGComboBox(hframePol);
cbPolarity->AddEntry("Positive +", 1);
cbPolarity->AddEntry("Negative -", 0);
cbPolarity->Resize(width, 20);
//pixie->GetChannelPolarity(boardID, ch) ? cbPolarity->Select(1) : cbPolarity->Select(0);
cbPolarity->Connect("Selected(Int_t, Int_t)", "ChannelSetting", this, "ChangeOnOff()");
hframePol->AddFrame(cbPolarity, new TGLayoutHints(kLHintsRight, 5,5,3,4));
TGLabel * lbPol = new TGLabel(hframePol, "Polarity");
hframePol->AddFrame(lbPol, new TGLayoutHints(kLHintsRight | kLHintsCenterY, 5, 5, 3, 4));
///----- all other
TGHorizontalFrame *hframe[NUM_CHANNEL_SETTING];
TGLabel * lb[NUM_CHANNEL_SETTING];
for( int i = 0 ; i < NUM_CHANNEL_SETTING; i++){
hframe[i] = new TGHorizontalFrame(vframe, 50, 50 );
vframe->AddFrame(hframe[i], new TGLayoutHints(kLHintsRight, 2,2,2,2));
///----------- Trace on/off
if(settingName[i][0] == "TAU"){
TGHorizontalFrame *hframeTraceOnOff = new TGHorizontalFrame(vframe, 50, 50 );
vframe->AddFrame(hframeTraceOnOff, new TGLayoutHints(kLHintsRight, 2,2,2,2));
cbTraceOnOff = new TGComboBox(hframeTraceOnOff);
cbTraceOnOff->AddEntry("On", 1);
cbTraceOnOff->AddEntry("Off", 0);
cbTraceOnOff->Resize(width, 20);
//pixie->GetChannelTraceOnOff(boardID, ch) ? cbTraceOnOff->Select(1) : cbTraceOnOff->Select(0);
cbTraceOnOff->Connect("Selected(Int_t, Int_t)", "ChannelSetting", this, "ChangeOnOff()");
hframeTraceOnOff->AddFrame(cbTraceOnOff, new TGLayoutHints(kLHintsRight, 5,5,3,4));
TGLabel * lbTraceOnOff = new TGLabel(hframeTraceOnOff, "Trace On/Off");
hframeTraceOnOff->AddFrame(lbTraceOnOff, new TGLayoutHints(kLHintsRight | kLHintsCenterY, 5, 5, 3, 4));
}
double temp = 0; // pixie->GetChannelSetting(settingName[i][0].Data(), boardID, ch, false);
TGNumberFormat::EStyle digi = TGNumberFormat::kNESInteger;
if( settingName[i][1] == "0" ) digi = TGNumberFormat::kNESInteger;
if( settingName[i][1] == "1" ) digi = TGNumberFormat::kNESRealOne;
if( settingName[i][1] == "2" ) digi = TGNumberFormat::kNESRealTwo;
if( settingName[i][1] == "3" ) digi = TGNumberFormat::kNESRealThree;
entry[i] = new TGNumberEntry(hframe[i], temp, 0, 0, digi, TGNumberFormat::kNEANonNegative);
entry[i]->Resize(width, 20);
if( i >= NUM_CHANNEL_SETTING - 3 ) {
entry[i]->SetState(false);
}else{
entry[i]->Connect("Modified()", "ChannelSetting", this, Form("ChangeID(=%d)", i));
}
hframe[i]->AddFrame(entry[i], new TGLayoutHints(kLHintsRight, 5,5,3,4));
lb[i] = new TGLabel(hframe[i], settingName[i][0] + (settingName[i][2] != "" ? " [" + settingName[i][2] + "]" : ""));
hframe[i]->AddFrame(lb[i], new TGLayoutHints(kLHintsRight | kLHintsCenterY, 5, 5, 3, 4));
}
fMain->MapSubwindows();
fMain->Resize(fMain->GetDefaultSize());
fMain->MapWindow();
isOpened = true;
}
ChannelSetting::~ChannelSetting(){
isOpened = false;
delete boardIDEntry;
delete cbOnOff;
delete cbTraceOnOff;
delete cbPolarity;
for ( int i = 0; i < NUM_CHANNEL_SETTING; i++){
delete entry[i];
}
/// fMain must be delete last;
fMain->Cleanup();
delete fMain;
}
void ChannelSetting::ChangeBoard(){
ChangeCh();
}
void ChannelSetting::ChangeCh(){
int boardID = boardIDEntry->GetNumber();
int ch = chIDEntry->GetNumber();
//pixie->GetChannelOnOff(boardID, ch) ? cbOnOff->Select(1) : cbOnOff->Select(0);
//pixie->GetChannelPolarity(boardID, ch) ? cbPolarity->Select(1) : cbPolarity->Select(0);
//pixie->GetChannelTraceOnOff(boardID, ch) ? cbTraceOnOff->Select(1) : cbTraceOnOff->Select(0);
for( int i = 0 ; i < NUM_CHANNEL_SETTING; i++){
double temp = 0 ;//pixie->GetChannelSetting(settingName[i][0].Data(), boardID, ch, false);
entry[i]->SetNumber(temp );
}
}
void ChannelSetting::ChangeOnOff(){
short boardID = boardIDEntry->GetNumber();
short ch = chIDEntry->GetNumber();
int val = cbOnOff->GetSelected();
//pixie->SetChannelOnOff(val, boardID, ch);
//pixie->SaveSettings(pixie->GetSettingFile(boardIDEntry->GetNumber()));
}
void ChannelSetting::ChangePolarity(){
short boardID = boardIDEntry->GetNumber();
short ch = chIDEntry->GetNumber();
int val = cbPolarity->GetSelected();
//pixie->SetChannelPositivePolarity(val, boardID, ch);
//pixie->SaveSettings(pixie->GetSettingFile(boardIDEntry->GetNumber()));
}
void ChannelSetting::ChangeTraceOnOff(){
short boardID = boardIDEntry->GetNumber();
short ch = chIDEntry->GetNumber();
int val = cbTraceOnOff->GetSelected();
//pixie->SetChannelTraceOnOff(val, boardID, ch);
//pixie->SaveSettings(pixie->GetSettingFile(boardIDEntry->GetNumber()));
}
void ChannelSetting::ChangeID(int id){
short boardID = boardIDEntry->GetNumber();
short ch = chIDEntry->GetNumber();
double val = entry[id]->GetNumber();
//pixie->SetChannelSetting(settingName[id][0].Data(), val, boardID, ch, 1);
//pixie->SaveSettings(pixie->GetSettingFile(boardIDEntry->GetNumber()));
}

44
channelSetting.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef CHANNEL_SETTING_H
#define CHANNEL_SETTING_H
#include <TQObject.h>
#include <TGNumberEntry.h>
#include <TGComboBox.h>
#include <TGLabel.h>
#include "ClassDigitizer.h"
#include "macro.h"
#define NUM_CHANNEL_SETTING 17
class TGWindow;
class TGMainFrame;
class ChannelSetting{
private:
TGMainFrame * fMain;
TGNumberEntry * boardIDEntry, * chIDEntry;
TGComboBox * cbOnOff;
TGComboBox * cbPolarity;
TGComboBox * cbTraceOnOff;
TGNumberEntry * entry[NUM_CHANNEL_SETTING];
Digitizer ** digi;
int NChannel;
public:
ChannelSetting(const TGWindow *p, UInt_t w, UInt_t h, Digitizer ** digi, int nDigi);
virtual ~ChannelSetting();
void CloseWindow() { printf("close ChannelSetting window\n"); delete this; }
void ChangeBoard();
void ChangeCh();
void ChangeOnOff();
void ChangePolarity();
void ChangeTraceOnOff();
void ChangeID(int id);
bool isOpened;
};
#endif

78
test.cpp
View File

@ -1,8 +1,11 @@
#include "DigitizerPHA.h"
//#include "DigitizerPSD.h"
#include "DigitizerPSD.h"
#include "ClassData.h"
int main(int argc, char* argv[]){
/**************
const int nBoard = 1;
DigitizerPHA *dig = new DigitizerPHA[nBoard];
//DigitizerPSD * psd = new DigitizerPSD();
@ -13,40 +16,11 @@ int main(int argc, char* argv[]){
dig[i].OpenDigitizer(board, port, true);
dig[i].CreateAndSaveSettingBinary("setting_" + to_string(dig[i].GetSerialNumber()) + ".bin");
//dig[i].OpenSettingBinary("setting_" + to_string(dig[i].GetSerialNumber()) + ".bin");
//dig[i].SetAcqMode("list");
//dig[i].PrintACQStatue();
}
//dig[0].WriteRegister(Register::DPP::FrontPanelTRGOUTEnableMask, 0xFF, -1);
//dig[0].WriteRegister(Register::DPP::FrontPanelIOControl, 0x100, -1);
//dig[0].WriteRegister(Register::DPP::TriggerValidationMask, 0, -1);
//dig[0].SetDPPAlgorithmControl(0x830200E);
//dig[0].SetInputDynamicRange(2);
//dig[0].SetTriggerThreshold(20);
//dig[0].SetChannelMask(0x8000); /// only channel 15
//dig[0].SetChannelMask(0xffff); /// all channels
//dig[0].SetWaveFormRecording(true);
//dig[0].SetPileUpFlag(false);
//dig[0].SetBits(Register::DPP::BoardConfiguration, 0x0101, 4, 20); // TRG validation window
//dig[0].PrintBoardConfiguration(); //[20:23] vitural probe
//dig[0].PrintChannelSettingFromDigitizer(7);
//dig[0].PrintChannelSettingFromDigitizer(8);
//dig[0].PrintChannelSettingFromDigitizer(9);
//dig[0].PrintChannelSettingFromDigitizer(10);
dig[0].PrintBoardConfiguration();
dig[0].PrintChannelSettingFromDigitizer(4);
//dig[0].ReadRegister(Register::DPP::PHA::DPPAlgorithmControl2_G, 13, "DPP Control 2");
//dig[0].ReadRegister(Register::DPP::AcquisitionControl, -1, "Acq control"); // [0:1]
//dig[0].ReadRegister(Register::DPP::GlobalTriggerMask, -1, "GlobalTrigger mask");
//dig[0].ReadRegister(Register::DPP::FrontPanelTRGOUTEnableMask, -1, "Front Planel Trig-OUT mask"); /// should be 0xFF
//dig[0].ReadRegister(Register::DPP::FrontPanelIOControl, -1, "Front Planel I/O control");
//dig[0].ReadRegister(Register::DPP::DisableExternalTrigger, -1, "Disable External Trigger");
//dig[0].ReadRegister(Register::DPP::TriggerValidationMask, -1, "Trigger validation Mask");
//dig[0].PrintChannelSettingFromDigitizer(15);
Data * data = dig[0].data;
data->AllocateMemory();
@ -56,17 +30,55 @@ int main(int argc, char* argv[]){
for( int p = 0; p < 11; p++){
sleep(1);
dig[0].ReadData();
data->DecodeBuffer(1);
}
//printf("|%s|\n", data->buffer);
dig[0].StopACQ();
data->ReadAllBuffer(1);
delete [] dig;
//delete psd;
*********************/
///********************* method for using Data Class for decoding bin file
/**
FILE * haha = fopen("output.bin", "r");
fseek(haha, 0L, SEEK_END);
size_t inFileSize = ftell(haha);
printf("file size : %d Byte\n", (int) inFileSize);
fclose(haha);
haha = fopen("output.bin", "r");
char * buffer = new char[(int)inFileSize];
size_t dump = fread(buffer, inFileSize, 1, haha);
fclose(haha);
Data * data = new Data();
data->buffer = buffer;
data->DecodeBuffer(3);
/*********************/
///****************************** casting digitizer type
Digitizer ** dig = new Digitizer *[2] ;
//dig[0] = new Digitizer();
dig[0] = new DigitizerPHA();
dig[1] = new DigitizerPSD();
printf("%d \n", dig[0]->GetDPPType());
printf("%d \n", dig[1]->GetDPPType());
((DigitizerPHA *)dig[0])->PrintBoardConfiguration();
((DigitizerPHA *)dig[0])->SetDPPAlgorithmControl2(0x10000);
return 0;
}

4
test_indep.cpp
View File

@ -91,7 +91,7 @@ void PrintChannelSettingFromDigitizer(int handle, int ch, float ch2ns){
printf("========= events storage and transfer\n");
CAEN_DGTZ_ReadRegister(handle, Register::DPP::NumberEventsPerAggregate_G + (ch << 8), value); printf("%24s %d \n", "Event Aggregate", value[0] & 0x3FF);
CAEN_DGTZ_ReadRegister(handle, Register::DPP::AggregateOrganization, value); printf("%24s %d \n", "Buffer Division", ((value[0] & 0x007) < 2 ? 0 : (int)pow(2, value[0] & 7)));
CAEN_DGTZ_ReadRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlackTransfer , value); printf("%24s %d \n", "Num of Agg. / ReadData", value[0] & 0x1FF);
CAEN_DGTZ_ReadRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlockTransfer , value); printf("%24s %d \n", "Num of Agg. / ReadData", value[0] & 0x1FF);
printf("========================================= end of ch-%d\n", ch);
@ -281,7 +281,7 @@ int main(int argc, char* argv[]){
//ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::BoardConfiguration , 0x10E0114 );
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::NumberEventsPerAggregate_G + 0x7000, 5);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::AggregateOrganization, 0);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlackTransfer, 40);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::MaxNumberOfAggregatePerBlockTransfer, 40);
ret |= CAEN_DGTZ_WriteRegister(handle, Register::DPP::DPPAlgorithmControl + 0x7000, 0xe30200f);