2024-09-05 16:04:35 -04:00
# ifndef BeamTune_h
# define BeamTune_h
/*********************************************
* This is online analyzer for PID , ANL
*
* Created by Khushi @ 2024 - 09 - 03
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# include "Analyser.h"
# include <cmath>
# include "math.h"
# include <algorithm>
2024-09-14 11:52:18 -04:00
//#include "TLine.h"
2024-09-05 16:04:35 -04:00
//#include <TMarker.h>
# include <vector>
# include <iostream>
class BeamTune : public Analyzer {
public :
BeamTune ( Digitizer * * digi , unsigned int nDigi , QMainWindow * parent = nullptr ) : Analyzer ( digi , nDigi , parent ) {
SetUpdateTimeInSec ( 2.0 ) ;
RedefineEventBuilder ( { 0 } ) ; // only builder for the 0-th digitizer.
tick2ns = digi [ 0 ] - > GetTick2ns ( ) ;
SetBackwardBuild ( false , 100 ) ; // using normal building (acceding in time) or backward building, int the case of backward building, default events to be build is 100.
evtbder = GetEventBuilder ( ) ;
evtbder - > SetTimeWindow ( 500 ) ;
//========== use the influx from the Analyzer
influx = new InfluxDB ( " https://fsunuc.physics.fsu.edu/influx/ " ) ;
dataBaseName = " testing " ;
SetUpCanvas ( ) ; // see below
} ;
void SetUpCanvas ( ) ;
public slots :
void UpdateHistograms ( ) ;
private :
MultiBuilder * evtbder ;
//Histogram2D * hPID;
Histogram2D * hFrame ; // dE versus E : ch1 versus ch4
Histogram2D * hFrame1 ; // dE versus E : ch1 versus ch4
//Histogram2D * hdEtotE; // dE versus totE : ch1 versus (ch1+ch4)
int tick2ns ;
float s0 , s1 , s2 , s3 ;
unsigned long long s_t0 , s_t1 , s_t2 , s_t3 ;
float e0 , e1 , e2 , e3 , dE1 , dE2 ;
unsigned long long t0 , t1 , t2 , t3 , dE1_t , dE2_t ;
float ch1 , ch4 , ch7 ;
//unsigned long long t1, t4, t7;
} ;
inline void BeamTune : : SetUpCanvas ( ) {
setGeometry ( 0 , 0 , 2000 , 1000 ) ;
//============ histograms
//hPID = new Histogram2D("RAISOR", "E", "dE", 100, 0, 5000, 100, 0, 5000, this);
//layout->addWidget(hPID, 2, 0);
hFrame = new Histogram2D ( " X Map " , " X-axis " , " Y-axis " , 100 , - 10 , 110 , 100 , - 0.8 , 0.8 , this ) ;
layout - > addWidget ( hFrame , 0 , 0 , 1 , 2 ) ;
hFrame1 = new Histogram2D ( " X Map " , " X-axis " , " Y-axis " , 100 , - 10 , 110 , 100 , - 0.8 , 0.8 , this ) ;
layout - > addWidget ( hFrame1 , 1 , 1 , 1 , 2 ) ;
/*
hdEdT = new Histogram2D ( " dE vs TOF " , " TOF [ns] " , " dE " , 100 , 0 , 500 , 100 , 0 , 4000 , this ) ;
layout - > addWidget ( hdEdT , 1 , 3 ) ;
hdEtotE = new Histogram2D ( " dE vs TotE " , " TotE[ch] " , " dE[ch] " , 500 , 0 , 10000 , 500 , 0 , 10000 , this ) ;
layout - > addWidget ( hdEtotE , 1 , 0 , 1 , 2 ) ;
*/
}
inline void BeamTune : : UpdateHistograms ( ) {
if ( this - > isVisible ( ) = = false ) return ;
BuildEvents ( false ) ; // call the event builder to build events
//============ Get events, and do analysis
long eventBuilt = evtbder - > eventBuilt ;
if ( eventBuilt = = 0 ) return ;
//============ Get the cut list, if any
/*
QList < QPolygonF > cutList = hPID - > GetCutList ( ) ;
const int nCut = cutList . count ( ) ;
unsigned long long tMin [ nCut ] = { 0xFFFFFFFFFFFFFFFF } , tMax [ nCut ] = { 0 } ;
unsigned int count [ nCut ] = { 0 } ;
QList < QPolygonF > cutList1 = hFrame - > GetCutList ( ) ;
const int nCut1 = cutList1 . count ( ) ;
unsigned long long tMin1 [ nCut1 ] = { 0xFFFFFFFFFFFFFFFF } , tMax1 [ nCut1 ] = { 0 } ;
unsigned int count1 [ nCut1 ] = { 0 } ;
*/
/*
QList < QPolygonF > cutList2 = hdEtotE - > GetCutList ( ) ;
const int nCut2 = cutList2 . count ( ) ;
unsigned long long tMin2 [ nCut2 ] = { 0xFFFFFFFFFFFFFFFF } , tMax2 [ nCut2 ] = { 0 } ;
unsigned int count2 [ nCut2 ] = { 0 } ;
*/
//============ Processing data and fill histograms
long eventIndex = evtbder - > eventIndex ;
long eventStart = eventIndex - eventBuilt + 1 ;
if ( eventStart < 0 ) eventStart + = MaxNEvent ;
for ( long i = eventStart ; i < = eventIndex ; i + + ) {
std : : vector < Hit > event = evtbder - > events [ i ] ;
//printf("-------------- %ld\n", i);
if ( event . size ( ) = = 0 ) return ;
e0 = 0 ;
e1 = 0 ;
e2 = 0 ;
e3 = 0 ;
t0 = 0 ;
t1 = 0 ;
t2 = 0 ;
t3 = 0 ;
s0 = 0 ;
s1 = 0 ;
s2 = 0 ;
s3 = 0 ;
s_t0 = 0 ;
s_t1 = 0 ;
s_t2 = 0 ;
s_t3 = 0 ;
//std::vector<TLine*> lines; // Store lines to draw after the loop
//std::vector<TMarker*> markers; // Store markers to draw after the loop
//int lineCount = 0; // Counter to keep track of the number of lines
for ( int k = 0 ; k < ( int ) event . size ( ) ; k + + ) {
//event[k].Print();
if ( event [ k ] . ch = = 2 ) { s0 = event [ k ] . energy ; s_t0 = event [ k ] . timestamp ; } //
if ( event [ k ] . ch = = 3 ) { s1 = event [ k ] . energy ; s_t1 = event [ k ] . timestamp ; } // The 4 output signals from the
if ( event [ k ] . ch = = 4 ) { s2 = event [ k ] . energy ; s_t2 = event [ k ] . timestamp ; } // MCP detector
if ( event [ k ] . ch = = 5 ) { s3 = event [ k ] . energy ; s_t3 = event [ k ] . timestamp ; } //
if ( event [ k ] . ch = = 10 ) { e0 = event [ k ] . energy ; t0 = event [ k ] . timestamp ; } //
if ( event [ k ] . ch = = 11 ) { e1 = event [ k ] . energy ; t1 = event [ k ] . timestamp ; } // The 4 output signals from the
if ( event [ k ] . ch = = 12 ) { e2 = event [ k ] . energy ; t2 = event [ k ] . timestamp ; } // position sensitive E detector
if ( event [ k ] . ch = = 13 ) { e3 = event [ k ] . energy ; t3 = event [ k ] . timestamp ; } //
}
if ( s0 > 10 & & s1 > 10 & & s2 > 10 & & s3 > 10 & & e0 > 10 & & e1 > 10 & & e2 > 10 & & e3 > 10 ) {
float_t rotation_angle = 31. ;
double_t Xr = ( ( ( s1 + s2 ) / ( s0 + s1 + s2 + s3 ) ) - 0.51 ) * cos ( - rotation_angle * M_PI / 180 ) - ( ( ( s2 + s3 ) / ( s0 + s1 + s2 + s3 ) ) - 0.51 ) * sin ( - rotation_angle * M_PI / 180 ) ;
double_t Yr = ( ( ( s1 + s2 ) / ( s0 + s1 + s2 + s3 ) ) - 0.51 ) * sin ( - rotation_angle * M_PI / 180 ) + ( ( ( s2 + s3 ) / ( s0 + s1 + s2 + s3 ) ) - 0.51 ) * cos ( - rotation_angle * M_PI / 180 ) ;
double_t X2 = ( ( e0 - e1 ) / ( e0 + e1 ) ) ; // PSD X position
double_t Y2 = ( ( e3 - e2 ) / ( e2 + e3 ) ) ; // PSD Y position
// printf("(E, dE) = (%f, %f)\n", E, dE);
// Create the line and store it in the vector
2024-09-14 11:52:18 -04:00
//TLine *line = new TLine(Xr, Yr, X2, Y2);
2024-09-05 16:04:35 -04:00
//line->SetLineColor(kBlack);
// Set line color based on Y2 value
/*
if ( Y2 > 0 ) {
line - > SetLineColor ( kPink ) ; // Pink color if Y2 > 0
} else {
line - > SetLineColor ( kBlack ) ; // Black otherwise
}
*/
//lines.push_back(line);
//lineCount++; // Increment the counter
//Create markers at the start and end of the line
//TMarker *startMarker = new TMarker(Xr, Yr, kFullCircle);
//startMarker->SetMarkerColor(kRed);
//startMarker->SetMarkerSize(0.1);
//markers.push_back(startMarker);
//TMarker *endMarker = new TMarker(X2, Y2, kFullCircle);
//endMarker->SetMarkerColor(kGreen);
//endMarker->SetMarkerSize(0.2);
//markers.push_back(endMarker);
2024-09-14 11:52:18 -04:00
//hFrame->Fill(Xr,Yr, sX2,Y2);
//hFrame1->Fill(X2,Y2);
2024-09-05 16:04:35 -04:00
// Draw all the lines after the loop
//for (auto line : lines) {
// line->Draw();
//}
// Draw all the markers after the lines
//for (auto marker : markers) {
// marker->Draw();
//}
//gStyle->SetOptStat(0000000);
//hdEtotE->Fill(ch1*0.25*0.25 + ch4,ch1);
}
//check events inside any Graphical cut and extract the rate
/*
for ( int p = 0 ; p < cutList . count ( ) ; p + + ) {
if ( cutList [ p ] . isEmpty ( ) ) continue ;
if ( cutList [ p ] . containsPoint ( QPointF ( ch4 , ch1 ) , Qt : : OddEvenFill ) ) {
if ( t1 < tMin [ p ] ) tMin [ p ] = t1 ;
if ( t1 > tMax [ p ] ) tMax [ p ] = t1 ;
count [ p ] + + ;
//printf(".... %d \n", count[p]);
}
}
for ( int p = 0 ; p < cutList1 . count ( ) ; p + + ) {
if ( cutList1 [ p ] . isEmpty ( ) ) continue ;
if ( cutList1 [ p ] . containsPoint ( QPointF ( ch4 , ch1 ) , Qt : : OddEvenFill ) ) {
if ( t1 < tMin1 [ p ] ) tMin1 [ p ] = t1 ;
if ( t1 > tMax1 [ p ] ) tMax1 [ p ] = t1 ;
count1 [ p ] + + ;
//printf("hdEE.... %d \n", count1[p]);
}
}
for ( int p = 0 ; p < cutList2 . count ( ) ; p + + ) {
if ( cutList2 [ p ] . isEmpty ( ) ) continue ;
if ( cutList2 [ p ] . containsPoint ( QPointF ( ch1 + ch4 , ch1 ) , Qt : : OddEvenFill ) ) {
if ( t1 < tMin2 [ p ] ) tMin2 [ p ] = t1 ;
if ( t1 > tMax2 [ p ] ) tMax2 [ p ] = t1 ;
count2 [ p ] + + ;
//printf("hdEtotE.... %d \n", count2[p]);
}
}
*/
}
/*
for ( int p = 0 ; p < cutList2 . count ( ) ; p + + ) {
printf ( " hdEE.... %d %d \n " , p , count1 [ p ] ) ;
}
*/
//hPID->UpdatePlot();
hFrame - > UpdatePlot ( ) ;
hFrame1 - > UpdatePlot ( ) ;
//hdEtotE->UpdatePlot();
/*
//========== output to Influx
QList < QString > cutNameList = hPID - > GetCutNameList ( ) ;
for ( int p = 0 ; p < cutList . count ( ) ; p + + ) {
if ( cutList [ p ] . isEmpty ( ) ) continue ;
double dT = ( tMax [ p ] - tMin [ p ] ) * tick2ns / 1e9 ; // tick to sec
double rate = count [ p ] * 1.0 / ( dT ) ;
//printf("%llu %llu, %f %d\n", tMin[p], tMax[p], dT, count[p]);
//printf("%10s | %d | %f Hz \n", cutNameList[p].toStdString().c_str(), count[p], rate);
influx - > AddDataPoint ( " Cut,name= " + cutNameList [ p ] . toStdString ( ) + " value= " + std : : to_string ( rate ) ) ;
influx - > WriteData ( dataBaseName ) ;
influx - > ClearDataPointsBuffer ( ) ;
}
*/
}
# endif