#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "TMath.h" #include #include #include #include #include #include #include #include #include "TSystem.h" #include #include #include #include #include #include #include "TVirtualFFT.h" #include "TParameter.h" #include "online_lib.C" #define COLOR #ifdef COLOR #define c_RED "\x1b[31m" #define c_GREEN "\x1b[32m" #define c_YELLOW "\x1b[33m" #define c_BLUE "\x1b[34m" #define c_MAGENTA "\x1b[35m" #define c_CYAN "\x1b[36m" #define c_RESET "\x1b[0m" #else #define c_RED "" #define c_GREEN "" #define c_CYAN "" #define c_RESET "" #endif #define TRG 4 // pattern for beam triggers #define CAL 2 // pattern for BPC calibration pulser triggers #ifdef COLOR #endif #define DT_MAX 1. // upper limit on the interval between two adjacent CAL events, // to detect empty spill without beam triggers int iCol=0; int myCol[19]={kBlack, kRed, kGreen, kBlue, kOrange, kMagenta, kViolet, kAzure, kCyan, kGray, kRed-9, kGreen-9, kBlue-9, kOrange-1, kMagenta-9, kViolet-1, kAzure-5, kCyan-9, kRed-6}; int nCol=19; int runBegin=151; int runEnd=322; std::ofstream matchFile; std::ofstream summFile; double TDCtoMM(int iPL, int tdc0, int tdc1) { // TDC order left-right or down-up double result; // x1 y1 x2 y2 x3 y3 // x2 is inverted! double c0[6]={-7137.9, -6913.9, 7019.0, -6995.1, -7381.5, -7018.8}; double c1[6]={ -92.5, 39.0, -5.5, 43.6, -172.9, 88.6}; double c2[6]={ 6853.6, 6967.9, -7022.8, 7084.8, 6970.0, 7164.6}; result = 72./(c2[iPL]-c0[iPL])*(tdc0-tdc1-c1[iPL]); return result; } //============================================================ void BPC_DIG_timing_match_20210915() { TLatex* myLatex; TLine* myLine; TArc* myArc; char fname[100]; char htitl[200]; char hname[200]; char myText[200]; char version[200]; char psFirst[200]; char psBulk[200]; char psLast[200]; sprintf(version, "2021_09_15"); sprintf(psFirst, "plots/matching_%s.ps(", version); sprintf(psBulk, "plots/matching_%s.ps", version); sprintf(psLast, "plots/matching_%s.ps)", version); long double TDIG0[3]; long double TDIG1[3]; long double TDIG2[3]; // Tdig(2-1), Tdig(3-1) statistics std::vector myRuns; std::vector trigBPCtiming; std::vector trigDIGtiming; //===================== canvas and histograms ; TCanvas* canvas0 = new TCanvas("canvas0", "Time deviation", 0, 0, 900, 900); TH1D* diffAh = new TH1D("diffAh", "Mismatch, All Runs", 200, 0., 5.0); TH1D* diffBh = new TH1D("diffBh", "Mismatch, All Runs", 200, 0., 5.0); diffAh->GetXaxis()->SetTitle("Event Spacing Mismatch, msec"); diffBh->GetXaxis()->SetTitle("Event Spacing Mismatch, msec"); diffAh->GetYaxis()->SetTitle("Attempts"); diffBh->GetYaxis()->SetTitle("Events"); diffAh->SetLineWidth(4); diffBh->SetLineWidth(2); diffAh->SetLineColor(kGray); diffBh->SetLineColor(kRed); diffAh->SetStats(0); diffBh->SetStats(0); TCanvas* canvas1 = new TCanvas("canvas1", "Time deviation, Run", 900, 0, 900, 900); TH1D* diffAh1 = new TH1D("diffAh1", "Mismatch", 200, 0., 5.0); TH1D* diffBh1 = new TH1D("diffBh1", "Mismatch", 200, 0., 5.0); diffAh1->GetXaxis()->SetTitle("Event Spacing Mismatch, msec"); diffBh1->GetXaxis()->SetTitle("Event Spacing Mismatch, msec"); diffAh1->GetYaxis()->SetTitle("Attempts"); diffBh1->GetYaxis()->SetTitle("Events"); diffAh1->SetLineWidth(4); diffBh1->SetLineWidth(2); diffAh1->SetLineColor(kGray); diffBh1->SetLineColor(kRed); diffAh1->SetStats(0); diffBh1->SetStats(0); //===================== special variables for time agreement check double st0=0.0; double st1=0.0; double st2=0.0; std::vector runAcc; std::vector splAcc; std::vector dtAcc; std::vector stAcc; std::vector dtTAG; std::vector stTAG; double dtTAGmax=0.0; runAcc.clear(); splAcc.clear(); dtAcc.clear(); stAcc.clear(); dtTAG.clear(); stTAG.clear(); //===================== special variables for BPC position study; hit myHit; std::vector x1hits; std::vector x2hits; std::vector x3hits; std::vector y1hits; std::vector y2hits; std::vector y3hits; double failCut=3.0e-4; // ===================================================== BPC data and branches int ntrg=0; // number of triggers int nevBPC=0; // number of events (entries) in the BPC tree int nevDIG=0; // number of events (entries) in the Digitizer tree int ptrn, // branch var "pattern" (ev type =2 for CAL, =4 for beam triggers) ptrn_prev; // previous ev type double tBPC, // branch var "tBPC" (wall clock timestamp, in s); t_prev=-1; // timestamp of the previous entry double t_pre1=-1; double tDIG=0.0; double tDIG2=0.0; double tDIGprev=-1.0; const Int_t maxHits=100; // declaration of leaf types Int_t x1l_n; // number of hits left Int_t x1l_t[maxHits]; // hits left Int_t x1r_n; // number of hits right Int_t x1r_t[maxHits]; // hits right Int_t y1u_n; // number of hits up Int_t y1u_t[maxHits]; // hits up Int_t y1d_n; // number of hits down Int_t y1d_t[maxHits]; // hits rdown Int_t x2l_n; // number of hits left Int_t x2l_t[maxHits]; // hits left Int_t x2r_n; // number of hits right Int_t x2r_t[maxHits]; // hits right Int_t y2u_n; // number of hits up Int_t y2u_t[maxHits]; // hits up Int_t y2d_n; // number of hits down Int_t y2d_t[maxHits]; // hits rdown Int_t x3l_n; // number of hits left Int_t x3l_t[maxHits]; // hits left Int_t x3r_n; // number of hits right Int_t x3r_t[maxHits]; // hits right Int_t y3u_n; // number of hits up Int_t y3u_t[maxHits]; // hits up Int_t y3d_n; // number of hits down Int_t y3d_t[maxHits]; // hits rdown TBranch *b_x1l_n; //! TBranch *b_x1l_t; //! TBranch *b_x1r_n; //! TBranch *b_x1r_t; //! TBranch *b_y1u_n; //! TBranch *b_y1u_t; //! TBranch *b_y1d_n; //! TBranch *b_y1d_t; //! TBranch *b_x2l_n; //! TBranch *b_x2l_t; //! TBranch *b_x2r_n; //! TBranch *b_x2r_t; //! TBranch *b_y2u_n; //! TBranch *b_y2u_t; //! TBranch *b_y2d_n; //! TBranch *b_y2d_t; //! TBranch *b_x3l_n; //! TBranch *b_x3l_t; //! TBranch *b_x3r_n; //! TBranch *b_x3r_t; //! TBranch *b_y3u_n; //! TBranch *b_y3u_t; //! TBranch *b_y3d_n; //! TBranch *b_y3d_t; //! //=========================================== Digitizer Branches and data from mergedData.h ========== // Declaration of leaf types UInt_t dataFormatVersion; UInt_t channelDataSize; UInt_t RecordLength; UInt_t PostTrigger; UInt_t FPIOtype; UInt_t NumBoards; UInt_t SerialNumber[3]; UInt_t ExtTriggerMode[3]; UInt_t EnableMask[3]; UInt_t DCoffset[3][8]; UInt_t ChannelTriggerMode[3][8]; UInt_t PulsePolarity[3][8]; UInt_t GWn; UInt_t GWaddr[12]; UInt_t GWdata[12]; UInt_t GWmask[12]; UInt_t nCryostats; UShort_t scintUsed; UShort_t sourceInBeam; UInt_t runNumber; UInt_t spillNumber; TDatime *spillStartTime; UInt_t BeamStatus; UInt_t boardFailBits[3]; Float_t SCal_HV_set; Float_t SCal_HV_read; Float_t FCal_inner_HV_set; Float_t FCal_tubeA_HV_read; Float_t FCal_outer_HV_set; Float_t FCal_tubeB_HV_read; Float_t FCal_tubeC_HV_read; Float_t cryoTemp[3]; Float_t cryoPressure[3]; UInt_t NumEventsMax; UInt_t NumEventsInSpill; UInt_t nchannels; UInt_t eventCounter; UInt_t triggerTimeTag[3]; vector *FCal_rod_source_section_a_data; vector *FCal_rod_source_section_b_data; vector *FCal_rod_source_section_c_data; vector *ShCal_front_source_quad_1_data; vector *ShCal_front_source_quad_2_data; vector *ShCal_front_source_quad_3_data; vector *ShCal_front_source_quad_4_data; vector *ShCal_rear_source_quad_1_data; vector *ShCal_rear_source_quad_2_data; vector *ShCal_rear_source_quad_3_data; vector *ShCal_rear_source_quad_4_data; vector *FCal_rod_nosource_section_a_data; vector *FCal_rod_nosource_section_b_data; vector *FCal_rod_nosource_section_c_data; vector *ShCal_front_nosource_quad_1_data; vector *ShCal_front_nosource_quad_2_data; vector *ShCal_front_nosource_quad_3_data; vector *ShCal_front_nosource_quad_4_data; vector *ShCal_rear_nosource_quad_1_data; vector *ShCal_rear_nosource_quad_2_data; vector *ShCal_rear_nosource_quad_3_data; vector *ShCal_rear_nosource_quad_4_data; vector *Trig_scint_data; vector *Trig_leak_halo_data; UShort_t FCal_rod_source_section_a_board; UShort_t FCal_rod_source_section_a_channel; UShort_t FCal_rod_source_section_b_board; UShort_t FCal_rod_source_section_b_channel; UShort_t FCal_rod_source_section_c_board; UShort_t FCal_rod_source_section_c_channel; UShort_t ShCal_front_source_quad_1_board; UShort_t ShCal_front_source_quad_1_channel; UShort_t ShCal_front_source_quad_2_board; UShort_t ShCal_front_source_quad_2_channel; UShort_t ShCal_front_source_quad_3_board; UShort_t ShCal_front_source_quad_3_channel; UShort_t ShCal_front_source_quad_4_board; UShort_t ShCal_front_source_quad_4_channel; UShort_t ShCal_rear_source_quad_1_board; UShort_t ShCal_rear_source_quad_1_channel; UShort_t ShCal_rear_source_quad_2_board; UShort_t ShCal_rear_source_quad_2_channel; UShort_t ShCal_rear_source_quad_3_board; UShort_t ShCal_rear_source_quad_3_channel; UShort_t ShCal_rear_source_quad_4_board; UShort_t ShCal_rear_source_quad_4_channel; UShort_t FCal_rod_nosource_section_a_board; UShort_t FCal_rod_nosource_section_a_channel; UShort_t FCal_rod_nosource_section_b_board; UShort_t FCal_rod_nosource_section_b_channel; UShort_t FCal_rod_nosource_section_c_board; UShort_t FCal_rod_nosource_section_c_channel; UShort_t ShCal_front_nosource_quad_1_board; UShort_t ShCal_front_nosource_quad_1_channel; UShort_t ShCal_front_nosource_quad_2_board; UShort_t ShCal_front_nosource_quad_2_channel; UShort_t ShCal_front_nosource_quad_3_board; UShort_t ShCal_front_nosource_quad_3_channel; UShort_t ShCal_front_nosource_quad_4_board; UShort_t ShCal_front_nosource_quad_4_channel; UShort_t ShCal_rear_nosource_quad_1_board; UShort_t ShCal_rear_nosource_quad_1_channel; UShort_t ShCal_rear_nosource_quad_2_board; UShort_t ShCal_rear_nosource_quad_2_channel; UShort_t ShCal_rear_nosource_quad_3_board; UShort_t ShCal_rear_nosource_quad_3_channel; UShort_t ShCal_rear_nosource_quad_4_board; UShort_t ShCal_rear_nosource_quad_4_channel; UShort_t Trig_scint_board; UShort_t Trig_scint_channel; UShort_t Trig_leak_halo_board; UShort_t Trig_leak_halo_channel; Bool_t good_BPC_data; UShort_t BPC_tag; UShort_t BPC_runNumber; UShort_t BPC_spillNumber; UShort_t BPC_triggerNumber; UInt_t BPC_accum_time; UInt_t BPC_wall_time; Float_t BPC_x1; Float_t BPC_y1; Float_t BPC_x2; Float_t BPC_y2; Float_t BPC_x3; Float_t BPC_y3; // List of branches TBranch *b_dataFormatVersion; //! TBranch *b_channelDataSize; //! TBranch *b_RecordLength; //! TBranch *b_PostTrigger; //! TBranch *b_FPIOtype; //! TBranch *b_NumBoards; //! TBranch *b_SerialNumber; //! TBranch *b_ExtTriggerMode; //! TBranch *b_EnableMask; //! TBranch *b_DCoffset; //! TBranch *b_ChannelTriggerMode; //! TBranch *b_PulsePolarity; //! TBranch *b_GWn; //! TBranch *b_GWaddr; //! TBranch *b_GWdata; //! TBranch *b_GWmask; //! TBranch *b_nCryostats; //! TBranch *b_scintUsed; //! TBranch *b_sourceInBeam; //! TBranch *b_runNumber; //! TBranch *b_spillNumber; //! TBranch *b_spillStartTime; //! TBranch *b_BeamStatus; //! TBranch *b_boardFailBits; //! TBranch *b_SCal_HV_set; //! TBranch *b_SCal_HV_read; //! TBranch *b_FCal_inner_HV_set; //! TBranch *b_FCal_tubeA_HV_read; //! TBranch *b_FCal_outer_HV_set; //! TBranch *b_FCal_tubeB_HV_read; //! TBranch *b_FCal_tubeC_HV_read; //! TBranch *b_cryoTemp; //! TBranch *b_cryoPressure; //! TBranch *b_NumEventsMax; //! TBranch *b_NumEventsInSpill; //! TBranch *b_nchannels; //! TBranch *b_eventCounter; //! TBranch *b_triggerTimeTag; //! TBranch *b_FCal_rod_source_section_a_data; //! TBranch *b_FCal_rod_source_section_b_data; //! TBranch *b_FCal_rod_source_section_c_data; //! TBranch *b_ShCal_front_source_quad_1_data; //! TBranch *b_ShCal_front_source_quad_2_data; //! TBranch *b_ShCal_front_source_quad_3_data; //! TBranch *b_ShCal_front_source_quad_4_data; //! TBranch *b_ShCal_rear_source_quad_1_data; //! TBranch *b_ShCal_rear_source_quad_2_data; //! TBranch *b_ShCal_rear_source_quad_3_data; //! TBranch *b_ShCal_rear_source_quad_4_data; //! TBranch *b_FCal_rod_nosource_section_a_data; //! TBranch *b_FCal_rod_nosource_section_b_data; //! TBranch *b_FCal_rod_nosource_section_c_data; //! TBranch *b_ShCal_front_nosource_quad_1_data; //! TBranch *b_ShCal_front_nosource_quad_2_data; //! TBranch *b_ShCal_front_nosource_quad_3_data; //! TBranch *b_ShCal_front_nosource_quad_4_data; //! TBranch *b_ShCal_rear_nosource_quad_1_data; //! TBranch *b_ShCal_rear_nosource_quad_2_data; //! TBranch *b_ShCal_rear_nosource_quad_3_data; //! TBranch *b_ShCal_rear_nosource_quad_4_data; //! TBranch *b_Trig_scint_data; //! TBranch *b_Trig_leak_halo_data; //! TBranch *b_FCal_rod_source_section_a_board; //! TBranch *b_FCal_rod_source_section_a_channel; //! TBranch *b_FCal_rod_source_section_b_board; //! TBranch *b_FCal_rod_source_section_b_channel; //! TBranch *b_FCal_rod_source_section_c_board; //! TBranch *b_FCal_rod_source_section_c_channel; //! TBranch *b_ShCal_front_source_quad_1_board; //! TBranch *b_ShCal_front_source_quad_1_channel; //! TBranch *b_ShCal_front_source_quad_2_board; //! TBranch *b_ShCal_front_source_quad_2_channel; //! TBranch *b_ShCal_front_source_quad_3_board; //! TBranch *b_ShCal_front_source_quad_3_channel; //! TBranch *b_ShCal_front_source_quad_4_board; //! TBranch *b_ShCal_front_source_quad_4_channel; //! TBranch *b_ShCal_rear_source_quad_1_board; //! TBranch *b_ShCal_rear_source_quad_1_channel; //! TBranch *b_ShCal_rear_source_quad_2_board; //! TBranch *b_ShCal_rear_source_quad_2_channel; //! TBranch *b_ShCal_rear_source_quad_3_board; //! TBranch *b_ShCal_rear_source_quad_3_channel; //! TBranch *b_ShCal_rear_source_quad_4_board; //! TBranch *b_ShCal_rear_source_quad_4_channel; //! TBranch *b_FCal_rod_nosource_section_a_board; //! TBranch *b_FCal_rod_nosource_section_a_channel; //! TBranch *b_FCal_rod_nosource_section_b_board; //! TBranch *b_FCal_rod_nosource_section_b_channel; //! TBranch *b_FCal_rod_nosource_section_c_board; //! TBranch *b_FCal_rod_nosource_section_c_channel; //! TBranch *b_ShCal_front_nosource_quad_1_board; //! TBranch *b_ShCal_front_nosource_quad_1_channel; //! TBranch *b_ShCal_front_nosource_quad_2_board; //! TBranch *b_ShCal_front_nosource_quad_2_channel; //! TBranch *b_ShCal_front_nosource_quad_3_board; //! TBranch *b_ShCal_front_nosource_quad_3_channel; //! TBranch *b_ShCal_front_nosource_quad_4_board; //! TBranch *b_ShCal_front_nosource_quad_4_channel; //! TBranch *b_ShCal_rear_nosource_quad_1_board; //! TBranch *b_ShCal_rear_nosource_quad_1_channel; //! TBranch *b_ShCal_rear_nosource_quad_2_board; //! TBranch *b_ShCal_rear_nosource_quad_2_channel; //! TBranch *b_ShCal_rear_nosource_quad_3_board; //! TBranch *b_ShCal_rear_nosource_quad_3_channel; //! TBranch *b_ShCal_rear_nosource_quad_4_board; //! TBranch *b_ShCal_rear_nosource_quad_4_channel; //! TBranch *b_Trig_scint_board; //! TBranch *b_Trig_scint_channel; //! TBranch *b_Trig_leak_halo_board; //! TBranch *b_Trig_leak_halo_channel; //! TBranch *b_good_BPC_data; //! TBranch *b_BPC_tag; //! TBranch *b_BPC_runNumber; //! TBranch *b_BPC_spillNumber; //! TBranch *b_BPC_triggerNumber; //! TBranch *b_BPC_accum_time; //! TBranch *b_BPC_wall_time; //! TBranch *b_BPC_x1; //! TBranch *b_BPC_y1; //! TBranch *b_BPC_x2; //! TBranch *b_BPC_y2; //! TBranch *b_BPC_x3; //! TBranch *b_BPC_y3; //! //=========================================== end of Digitizer Branches and data from mergedData.h === int oddEventCounter=0; int beamEventCounter=0; int iControl = 100; int iFilter=0; Int_t iDay=0; Int_t iHou=0; Int_t iMin=0; Int_t iSec=0; Int_t iTspill=0; // ---> preapre load run list std::string run_name;// char runName[200]; myRuns.clear(); system("rm list.txt"); system("ls /data1/varnes/FCalPulse/data_remap/all/ > list.txt"); std::ifstream runlist; runlist.open("list.txt", ifstream::in); if (!runlist.is_open()) { printf("failed to open list of runs, bye!\n"); runlist.clear(); exit(-1); } int runOld=-1; do { int iRun; int iSpill; char dummy[200]; runlist >> run_name; if (runlist.eof()) break; strcpy(runName, run_name.c_str()); // printf("file-> %s", runName); sscanf(runName, "%3s%d%5s%d", dummy, &iRun, dummy, &iSpill); // printf(" run=%d spill=%d \n", iRun, iSpill); if (iRun != runOld) { runOld=iRun; Run myRun; myRun.SetNumber(iRun); myRuns.push_back(myRun); } myRuns.at(myRuns.size()-1).AddSpill(iSpill); } while (true); runlist.close(); runlist.clear(); // <--- run list created and loaded // ---> order run list by run and spill int moved=10; while (moved>0) { moved=0; for (int i=0; i<(int)myRuns.size()-1; i++) { if (myRuns.at(i).GetNumber() > myRuns.at(i+1).GetNumber()) { Run myRun; myRun=myRuns.at(i); myRuns.at(i)=myRuns.at(i+1); myRuns.at(i+1)=myRun; moved++; } } // printf("%d runs moved\n", moved); } // <--- runs ordered for (int i=0; i<(int)myRuns.size(); i++) { // printf("run#%d\n", myRuns.at(i).GetNumber()); myRuns.at(i).OrderSpills(); int spill_old=0; int spill_new=0; for (int j=0; j"); cin >> runBegin; if (runBegin<1) exit(-1); printf("Enter last run ->"); cin >> runEnd; if (runEnd<1) exit(-1); sprintf(fname, "summary%d_%d_%s.dat", runBegin, runEnd, version); summFile.open(fname, ofstream::out); summFile << "Run\tBPC spills\tBPC triggs\tDIG spills\tDIG trigs\tfailed BPC->DIG\tfailed DIG->BPC\n"; bool firstRun=true; //printf("Enter filter mode 0 - no filter\n"); //printf(" 1 - single hits in chamber X and Y\n"); //printf(" 2 - single hits in all chambers\n"); //cin >> iFilter; //TFile *fDIG; for (int run=runBegin; run<=runEnd; run++) { int indxRun=-1; //====================== find run in the myRuns vector ===================== for (int ir=0; ir<(int)myRuns.size(); ir++) { if (myRuns.at(ir).GetNumber() == run) { indxRun=ir; break; } } if (indxRun==-1) {// run not found in DIG runs printf("***************** BPC run#%d not found *************\n", run); continue; } if (run>128 && run<172) continue; // bad/empty runs printf("\n\nProcessing run#%d\n", run); diffAh1->Reset(); diffBh1->Reset(); sprintf(myText, "Mismatch, Run#%d", run); diffAh1->SetTitle(myText); diffBh1->SetTitle(myText); summFile << run << " \t"; // Open the file containing the BPC tree. sprintf(fname,"/home/savin/FCalPulse2021/BPC_DATA/bpc_%d.root",run); TFile *fbpc = new TFile(fname, "READ"); if (!fbpc->IsOpen()) { printf("file %s not open\n", fname); summFile << "-1 no BPC file" << endl; continue; } TTree *bpcD = (TTree*)fbpc->Get("DATA"); bpcD->SetBranchAddress("t", &tBPC); bpcD->SetBranchAddress("pattern", &ptrn); bpcD->SetBranchAddress("dwc1left_nt00", &x1l_n, &b_x1l_n); bpcD->SetBranchAddress("dwc1left_tt00", x1l_t, &b_x1l_t); bpcD->SetBranchAddress("dwc1right_nt01", &x1r_n, &b_x1r_n); bpcD->SetBranchAddress("dwc1right_tt01", x1r_t, &b_x1r_t); bpcD->SetBranchAddress("dwc1up_nt02", &y1u_n, &b_y1u_n); bpcD->SetBranchAddress("dwc1up_tt02", y1u_t, &b_y1u_t); bpcD->SetBranchAddress("dwc1down_nt03", &y1d_n, &b_y1d_n); bpcD->SetBranchAddress("dwc1down_tt03", y1d_t, &b_y1d_t); bpcD->SetBranchAddress("dwc2left_nt04", &x2l_n, &b_x2l_n); bpcD->SetBranchAddress("dwc2left_tt04", x2l_t, &b_x2l_t); bpcD->SetBranchAddress("dwc2right_nt05", &x2r_n, &b_x2r_n); bpcD->SetBranchAddress("dwc2right_tt05", x2r_t, &b_x2r_t); bpcD->SetBranchAddress("dwc2up_nt06", &y2u_n, &b_y2u_n); bpcD->SetBranchAddress("dwc2up_tt06", y2u_t, &b_y2u_t); bpcD->SetBranchAddress("dwc2down_nt07", &y2d_n, &b_y2d_n); bpcD->SetBranchAddress("dwc2down_tt07", y2d_t, &b_y2d_t); bpcD->SetBranchAddress("dwc3left_nt08", &x3l_n, &b_x3l_n); bpcD->SetBranchAddress("dwc3left_tt08", x3l_t, &b_x3l_t); bpcD->SetBranchAddress("dwc3right_nt09", &x3r_n, &b_x3r_n); bpcD->SetBranchAddress("dwc3right_tt09", x3r_t, &b_x3r_t); bpcD->SetBranchAddress("dwc3up_nt10", &y3u_n, &b_y3u_n); bpcD->SetBranchAddress("dwc3up_tt10", y3u_t, &b_y3u_t); bpcD->SetBranchAddress("dwc3down_nt11", &y3d_n, &b_y3d_n); bpcD->SetBranchAddress("dwc3down_tt11", y3d_t, &b_y3d_t); nevBPC = bpcD->GetEntries(); if (nevBPC==0) { printf("Run#%d has no BPC events\n", run); summFile << "-1 empty BPC file" << endl; continue; } else { // printf("Run#%d, %d BPC events\n",run, nevBPC); } oddEventCounter=0; beamEventCounter=0; bool inSpill=true; int spillBPC=-1; int spillDIG=0; int spillNumber0=0; ptrn_prev=-1; double T_spill_start_BPC=0.; double T_spill_end=0.; double T_off_spill_start=0.; double T_off_spill_end=0.; double T_first_event_BPC=-1.; double T_first_event_DIG=-1.; int bpcEntry=0; int spillEvt=0; ptrn_prev=-1; t_prev=-1000.; int trigCount=0; int trigSpill=0; int digEntry=0; double tPrevBPC=0.; trigBPCtiming.clear(); // load BPC data, store BPC_timing in a vector for (bpcEntry=0; bpcEntryGetEntry(bpcEntry); // get BPC event if (bpcEntry==0) { T_first_event_BPC=tBPC; } if (ptrn_prev == 2 && ptrn ==2 && tBPC-t_prev>0.2) {// empty spill T_spill_start_BPC=t_prev; spillBPC++; } else if (ptrn_prev == 2 && ptrn == 4) { trigSpill=0; T_spill_start_BPC=tBPC; spillBPC++; } ptrn_prev=ptrn; t_prev=tBPC; if (ptrn == 4) { BPC_timing myBPCtiming; if (trigSpill==0) tPrevBPC=tBPC-T_spill_start_BPC; myBPCtiming.Set(trigCount, spillBPC, trigSpill, tBPC, tBPC-T_spill_start_BPC, tPrevBPC); trigBPCtiming.push_back(myBPCtiming); // if (trigCount<40) { if (iControl==1 && trigCount<40) { printf("BPC=> evt#%5d(%3d) Spill=%3d Tspill=%8.3f Tprev=%8.3f Diff=%5.3f\n", trigCount, trigBPCtiming.at(trigCount).GetTrigSpill(), trigBPCtiming.at(trigCount).GetSpill(), trigBPCtiming.at(trigCount).GetTspl(), tPrevBPC, trigBPCtiming.at(trigCount).GetTdiff() ); // trigBPCtiming.at(trigCount).GetTspl()-tPrevBPC ); } tPrevBPC=trigBPCtiming.at(trigCount).GetTspl(); trigSpill++; trigCount++; } } printf("BPC data: %d spills %d triggers\n", spillBPC, trigCount); if (trigCount==0) { printf("***** no BPC data ******\n"); summFile << "-1 no BPC triggers" << endl; continue; } summFile << spillBPC << "\t\t" << trigCount << "\t\t"; int bpcCount=trigCount; fbpc->Close(); trigCount=0; spillDIG=0; trigDIGtiming.clear(); for (int i=0; i<3; i++) { TDIG0[i]=0.0; TDIG1[i]=0.0; TDIG2[i]=0.0; } //============================================= Digitizer spills loop ================ for (int jsp=0; jspIsOpen()) { printf("file %s not found\n", fname); continue; } if (fDIG->GetSize() < 1000) { printf("file %s too small (%d)\n", fname, (int)fDIG->GetSize()); continue; } // printf("file open %s, size=%d\n", fname, (int)fDIG->GetSize()); TTree *digD = (TTree*)fDIG->Get("merged_digitizer_BPC"); // Set object pointer spillStartTime = 0; FCal_rod_source_section_a_data = 0; FCal_rod_source_section_b_data = 0; FCal_rod_source_section_c_data = 0; ShCal_front_source_quad_1_data = 0; ShCal_front_source_quad_2_data = 0; ShCal_front_source_quad_3_data = 0; ShCal_front_source_quad_4_data = 0; ShCal_rear_source_quad_1_data = 0; ShCal_rear_source_quad_2_data = 0; ShCal_rear_source_quad_3_data = 0; ShCal_rear_source_quad_4_data = 0; FCal_rod_nosource_section_a_data = 0; FCal_rod_nosource_section_b_data = 0; FCal_rod_nosource_section_c_data = 0; ShCal_front_nosource_quad_1_data = 0; ShCal_front_nosource_quad_2_data = 0; ShCal_front_nosource_quad_3_data = 0; ShCal_front_nosource_quad_4_data = 0; ShCal_rear_nosource_quad_1_data = 0; ShCal_rear_nosource_quad_2_data = 0; ShCal_rear_nosource_quad_3_data = 0; ShCal_rear_nosource_quad_4_data = 0; Trig_scint_data = 0; Trig_leak_halo_data = 0; digD->SetBranchAddress("dataFormatVersion", &dataFormatVersion, &b_dataFormatVersion); digD->SetBranchAddress("channelDataSize", &channelDataSize, &b_channelDataSize); digD->SetBranchAddress("RecordLength", &RecordLength, &b_RecordLength); digD->SetBranchAddress("PostTrigger", &PostTrigger, &b_PostTrigger); digD->SetBranchAddress("FPIOtype", &FPIOtype, &b_FPIOtype); digD->SetBranchAddress("NumBoards", &NumBoards, &b_NumBoards); digD->SetBranchAddress("SerialNumber", SerialNumber, &b_SerialNumber); digD->SetBranchAddress("ExtTriggerMode", ExtTriggerMode, &b_ExtTriggerMode); digD->SetBranchAddress("EnableMask", EnableMask, &b_EnableMask); digD->SetBranchAddress("DCoffset", DCoffset, &b_DCoffset); digD->SetBranchAddress("ChannelTriggerMode", ChannelTriggerMode, &b_ChannelTriggerMode); digD->SetBranchAddress("PulsePolarity", PulsePolarity, &b_PulsePolarity); digD->SetBranchAddress("GWn", &GWn, &b_GWn); digD->SetBranchAddress("GWaddr", GWaddr, &b_GWaddr); digD->SetBranchAddress("GWdata", GWdata, &b_GWdata); digD->SetBranchAddress("GWmask", GWmask, &b_GWmask); digD->SetBranchAddress("nCryostats", &nCryostats, &b_nCryostats); digD->SetBranchAddress("scintUsed", &scintUsed, &b_scintUsed); digD->SetBranchAddress("sourceInBeam", &sourceInBeam, &b_sourceInBeam); digD->SetBranchAddress("runNumber", &runNumber, &b_runNumber); digD->SetBranchAddress("spillNumber", &spillNumber, &b_spillNumber); digD->SetBranchAddress("spillStartTime", &spillStartTime, &b_spillStartTime); digD->SetBranchAddress("BeamStatus", &BeamStatus, &b_BeamStatus); digD->SetBranchAddress("boardFailBits", boardFailBits, &b_boardFailBits); digD->SetBranchAddress("SCal_HV_set", &SCal_HV_set, &b_SCal_HV_set); digD->SetBranchAddress("SCal_HV_read", &SCal_HV_read, &b_SCal_HV_read); digD->SetBranchAddress("FCal_inner_HV_set", &FCal_inner_HV_set, &b_FCal_inner_HV_set); digD->SetBranchAddress("FCal_tubeA_HV_read", &FCal_tubeA_HV_read, &b_FCal_tubeA_HV_read); digD->SetBranchAddress("FCal_outer_HV_set", &FCal_outer_HV_set, &b_FCal_outer_HV_set); digD->SetBranchAddress("FCal_tubeB_HV_read", &FCal_tubeB_HV_read, &b_FCal_tubeB_HV_read); digD->SetBranchAddress("FCal_tubeC_HV_read", &FCal_tubeC_HV_read, &b_FCal_tubeC_HV_read); digD->SetBranchAddress("cryoTemp", cryoTemp, &b_cryoTemp); digD->SetBranchAddress("cryoPressure", cryoPressure, &b_cryoPressure); digD->SetBranchAddress("NumEventsMax", &NumEventsMax, &b_NumEventsMax); digD->SetBranchAddress("NumEventsInSpill", &NumEventsInSpill, &b_NumEventsInSpill); digD->SetBranchAddress("nchannels", &nchannels, &b_nchannels); digD->SetBranchAddress("eventCounter", &eventCounter, &b_eventCounter); digD->SetBranchAddress("triggerTimeTag", triggerTimeTag, &b_triggerTimeTag); /* digD->SetBranchAddress("FCal_rod_source_section_a_data", &FCal_rod_source_section_a_data, &b_FCal_rod_source_section_a_data); digD->SetBranchAddress("FCal_rod_source_section_b_data", &FCal_rod_source_section_b_data, &b_FCal_rod_source_section_b_data); digD->SetBranchAddress("FCal_rod_source_section_c_data", &FCal_rod_source_section_c_data, &b_FCal_rod_source_section_c_data); digD->SetBranchAddress("ShCal_front_source_quad_1_data", &ShCal_front_source_quad_1_data, &b_ShCal_front_source_quad_1_data); digD->SetBranchAddress("ShCal_front_source_quad_2_data", &ShCal_front_source_quad_2_data, &b_ShCal_front_source_quad_2_data); digD->SetBranchAddress("ShCal_front_source_quad_3_data", &ShCal_front_source_quad_3_data, &b_ShCal_front_source_quad_3_data); digD->SetBranchAddress("ShCal_front_source_quad_4_data", &ShCal_front_source_quad_4_data, &b_ShCal_front_source_quad_4_data); digD->SetBranchAddress("ShCal_rear_source_quad_1_data", &ShCal_rear_source_quad_1_data, &b_ShCal_rear_source_quad_1_data); digD->SetBranchAddress("ShCal_rear_source_quad_2_data", &ShCal_rear_source_quad_2_data, &b_ShCal_rear_source_quad_2_data); digD->SetBranchAddress("ShCal_rear_source_quad_3_data", &ShCal_rear_source_quad_3_data, &b_ShCal_rear_source_quad_3_data); digD->SetBranchAddress("ShCal_rear_source_quad_4_data", &ShCal_rear_source_quad_4_data, &b_ShCal_rear_source_quad_4_data); digD->SetBranchAddress("FCal_rod_nosource_section_a_data", &FCal_rod_nosource_section_a_data, &b_FCal_rod_nosource_section_a_data); digD->SetBranchAddress("FCal_rod_nosource_section_b_data", &FCal_rod_nosource_section_b_data, &b_FCal_rod_nosource_section_b_data); digD->SetBranchAddress("FCal_rod_nosource_section_c_data", &FCal_rod_nosource_section_c_data, &b_FCal_rod_nosource_section_c_data); digD->SetBranchAddress("ShCal_front_nosource_quad_1_data", &ShCal_front_nosource_quad_1_data, &b_ShCal_front_nosource_quad_1_data); digD->SetBranchAddress("ShCal_front_nosource_quad_2_data", &ShCal_front_nosource_quad_2_data, &b_ShCal_front_nosource_quad_2_data); digD->SetBranchAddress("ShCal_front_nosource_quad_3_data", &ShCal_front_nosource_quad_3_data, &b_ShCal_front_nosource_quad_3_data); digD->SetBranchAddress("ShCal_front_nosource_quad_4_data", &ShCal_front_nosource_quad_4_data, &b_ShCal_front_nosource_quad_4_data); digD->SetBranchAddress("ShCal_rear_nosource_quad_1_data", &ShCal_rear_nosource_quad_1_data, &b_ShCal_rear_nosource_quad_1_data); digD->SetBranchAddress("ShCal_rear_nosource_quad_2_data", &ShCal_rear_nosource_quad_2_data, &b_ShCal_rear_nosource_quad_2_data); digD->SetBranchAddress("ShCal_rear_nosource_quad_3_data", &ShCal_rear_nosource_quad_3_data, &b_ShCal_rear_nosource_quad_3_data); digD->SetBranchAddress("ShCal_rear_nosource_quad_4_data", &ShCal_rear_nosource_quad_4_data, &b_ShCal_rear_nosource_quad_4_data); digD->SetBranchAddress("Trig_scint_data", &Trig_scint_data, &b_Trig_scint_data); digD->SetBranchAddress("Trig_leak_halo_data", &Trig_leak_halo_data, &b_Trig_leak_halo_data); //---> digD->SetBranchAddress("FCal_rod_source_section_a_board", &FCal_rod_source_section_a_board, &b_FCal_rod_source_section_a_board); digD->SetBranchAddress("FCal_rod_source_section_a_channel", &FCal_rod_source_section_a_channel, &b_FCal_rod_source_section_a_channel); digD->SetBranchAddress("FCal_rod_source_section_b_board", &FCal_rod_source_section_b_board, &b_FCal_rod_source_section_b_board); digD->SetBranchAddress("FCal_rod_source_section_b_channel", &FCal_rod_source_section_b_channel, &b_FCal_rod_source_section_b_channel); digD->SetBranchAddress("FCal_rod_source_section_c_board", &FCal_rod_source_section_c_board, &b_FCal_rod_source_section_c_board); digD->SetBranchAddress("FCal_rod_source_section_c_channel", &FCal_rod_source_section_c_channel, &b_FCal_rod_source_section_c_channel); digD->SetBranchAddress("ShCal_front_source_quad_1_board", &ShCal_front_source_quad_1_board, &b_ShCal_front_source_quad_1_board); digD->SetBranchAddress("ShCal_front_source_quad_1_channel", &ShCal_front_source_quad_1_channel, &b_ShCal_front_source_quad_1_channel); digD->SetBranchAddress("ShCal_front_source_quad_2_board", &ShCal_front_source_quad_2_board, &b_ShCal_front_source_quad_2_board); digD->SetBranchAddress("ShCal_front_source_quad_2_channel", &ShCal_front_source_quad_2_channel, &b_ShCal_front_source_quad_2_channel); digD->SetBranchAddress("ShCal_front_source_quad_3_board", &ShCal_front_source_quad_3_board, &b_ShCal_front_source_quad_3_board); digD->SetBranchAddress("ShCal_front_source_quad_3_channel", &ShCal_front_source_quad_3_channel, &b_ShCal_front_source_quad_3_channel); digD->SetBranchAddress("ShCal_front_source_quad_4_board", &ShCal_front_source_quad_4_board, &b_ShCal_front_source_quad_4_board); digD->SetBranchAddress("ShCal_front_source_quad_4_channel", &ShCal_front_source_quad_4_channel, &b_ShCal_front_source_quad_4_channel); digD->SetBranchAddress("ShCal_rear_source_quad_1_board", &ShCal_rear_source_quad_1_board, &b_ShCal_rear_source_quad_1_board); digD->SetBranchAddress("ShCal_rear_source_quad_1_channel", &ShCal_rear_source_quad_1_channel, &b_ShCal_rear_source_quad_1_channel); digD->SetBranchAddress("ShCal_rear_source_quad_2_board", &ShCal_rear_source_quad_2_board, &b_ShCal_rear_source_quad_2_board); digD->SetBranchAddress("ShCal_rear_source_quad_2_channel", &ShCal_rear_source_quad_2_channel, &b_ShCal_rear_source_quad_2_channel); digD->SetBranchAddress("ShCal_rear_source_quad_3_board", &ShCal_rear_source_quad_3_board, &b_ShCal_rear_source_quad_3_board); digD->SetBranchAddress("ShCal_rear_source_quad_3_channel", &ShCal_rear_source_quad_3_channel, &b_ShCal_rear_source_quad_3_channel); digD->SetBranchAddress("ShCal_rear_source_quad_4_board", &ShCal_rear_source_quad_4_board, &b_ShCal_rear_source_quad_4_board); digD->SetBranchAddress("ShCal_rear_source_quad_4_channel", &ShCal_rear_source_quad_4_channel, &b_ShCal_rear_source_quad_4_channel); digD->SetBranchAddress("FCal_rod_nosource_section_a_board", &FCal_rod_nosource_section_a_board, &b_FCal_rod_nosource_section_a_board); digD->SetBranchAddress("FCal_rod_nosource_section_a_channel", &FCal_rod_nosource_section_a_channel, &b_FCal_rod_nosource_section_a_channel); digD->SetBranchAddress("FCal_rod_nosource_section_b_board", &FCal_rod_nosource_section_b_board, &b_FCal_rod_nosource_section_b_board); digD->SetBranchAddress("FCal_rod_nosource_section_b_channel", &FCal_rod_nosource_section_b_channel, &b_FCal_rod_nosource_section_b_channel); digD->SetBranchAddress("FCal_rod_nosource_section_c_board", &FCal_rod_nosource_section_c_board, &b_FCal_rod_nosource_section_c_board); digD->SetBranchAddress("FCal_rod_nosource_section_c_channel", &FCal_rod_nosource_section_c_channel, &b_FCal_rod_nosource_section_c_channel); digD->SetBranchAddress("ShCal_front_nosource_quad_1_board", &ShCal_front_nosource_quad_1_board, &b_ShCal_front_nosource_quad_1_board); digD->SetBranchAddress("ShCal_front_nosource_quad_1_channel", &ShCal_front_nosource_quad_1_channel, &b_ShCal_front_nosource_quad_1_channel); digD->SetBranchAddress("ShCal_front_nosource_quad_2_board", &ShCal_front_nosource_quad_2_board, &b_ShCal_front_nosource_quad_2_board); digD->SetBranchAddress("ShCal_front_nosource_quad_2_channel", &ShCal_front_nosource_quad_2_channel, &b_ShCal_front_nosource_quad_2_channel); digD->SetBranchAddress("ShCal_front_nosource_quad_3_board", &ShCal_front_nosource_quad_3_board, &b_ShCal_front_nosource_quad_3_board); digD->SetBranchAddress("ShCal_front_nosource_quad_3_channel", &ShCal_front_nosource_quad_3_channel, &b_ShCal_front_nosource_quad_3_channel); digD->SetBranchAddress("ShCal_front_nosource_quad_4_board", &ShCal_front_nosource_quad_4_board, &b_ShCal_front_nosource_quad_4_board); digD->SetBranchAddress("ShCal_front_nosource_quad_4_channel", &ShCal_front_nosource_quad_4_channel, &b_ShCal_front_nosource_quad_4_channel); digD->SetBranchAddress("ShCal_rear_nosource_quad_1_board", &ShCal_rear_nosource_quad_1_board, &b_ShCal_rear_nosource_quad_1_board); digD->SetBranchAddress("ShCal_rear_nosource_quad_1_channel", &ShCal_rear_nosource_quad_1_channel, &b_ShCal_rear_nosource_quad_1_channel); digD->SetBranchAddress("ShCal_rear_nosource_quad_2_board", &ShCal_rear_nosource_quad_2_board, &b_ShCal_rear_nosource_quad_2_board); digD->SetBranchAddress("ShCal_rear_nosource_quad_2_channel", &ShCal_rear_nosource_quad_2_channel, &b_ShCal_rear_nosource_quad_2_channel); digD->SetBranchAddress("ShCal_rear_nosource_quad_3_board", &ShCal_rear_nosource_quad_3_board, &b_ShCal_rear_nosource_quad_3_board); digD->SetBranchAddress("ShCal_rear_nosource_quad_3_channel", &ShCal_rear_nosource_quad_3_channel, &b_ShCal_rear_nosource_quad_3_channel); digD->SetBranchAddress("ShCal_rear_nosource_quad_4_board", &ShCal_rear_nosource_quad_4_board, &b_ShCal_rear_nosource_quad_4_board); digD->SetBranchAddress("ShCal_rear_nosource_quad_4_channel", &ShCal_rear_nosource_quad_4_channel, &b_ShCal_rear_nosource_quad_4_channel); digD->SetBranchAddress("Trig_scint_board", &Trig_scint_board, &b_Trig_scint_board); digD->SetBranchAddress("Trig_scint_channel", &Trig_scint_channel, &b_Trig_scint_channel); digD->SetBranchAddress("Trig_leak_halo_board", &Trig_leak_halo_board, &b_Trig_leak_halo_board); digD->SetBranchAddress("Trig_leak_halo_channel", &Trig_leak_halo_channel, &b_Trig_leak_halo_channel); */ digD->SetBranchAddress("good_BPC_data", &good_BPC_data, &b_good_BPC_data); digD->SetBranchAddress("BPC_tag", &BPC_tag, &b_BPC_tag); digD->SetBranchAddress("BPC_runNumber", &BPC_runNumber, &b_BPC_runNumber); digD->SetBranchAddress("BPC_spillNumber", &BPC_spillNumber, &b_BPC_spillNumber); digD->SetBranchAddress("BPC_triggerNumber", &BPC_triggerNumber, &b_BPC_triggerNumber); digD->SetBranchAddress("BPC_accum_time", &BPC_accum_time, &b_BPC_accum_time); digD->SetBranchAddress("BPC_wall_time", &BPC_wall_time, &b_BPC_wall_time); digD->SetBranchAddress("BPC_x1", &BPC_x1, &b_BPC_x1); digD->SetBranchAddress("BPC_y1", &BPC_y1, &b_BPC_y1); digD->SetBranchAddress("BPC_x2", &BPC_x2, &b_BPC_x2); digD->SetBranchAddress("BPC_y2", &BPC_y2, &b_BPC_y2); digD->SetBranchAddress("BPC_x3", &BPC_x3, &b_BPC_x3); digD->SetBranchAddress("BPC_y3", &BPC_y3, &b_BPC_y3); nevDIG = digD->GetEntries(); // printf("Run#%d\t SpillDIG#%d\t SpillBPC#%d\t -> %d DIG events\n",run, spillDIG, spillBPC, nevDIG); if (nevDIG==0) { fDIG->Close(); // close the empty spill DIG file continue; } spillDIG++; st0=0.0; st1=0.0; st2=0.0; double tDIGprev; for (int digEntry=0; digEntryGetEntry(digEntry); iDay=spillStartTime->GetDay(); iHou=spillStartTime->GetHour(); iMin=spillStartTime->GetMinute(); iSec=spillStartTime->GetSecond(); iTspill=iSec+60*(iMin+24*(iHou+24*iDay)); DIG_timing myDIGtiming; myDIGtiming.Set(trigCount, spillDIG, digEntry, iTspill, triggerTimeTag[0], triggerTimeTag[1], triggerTimeTag[2]); double tPrevDig=myDIGtiming.GetTdig(); if (digEntry>0) tPrevDig=trigDIGtiming.at(trigCount-1).GetTdig(); myDIGtiming.Set(trigCount, spillDIG, digEntry, iTspill, triggerTimeTag[0], triggerTimeTag[1], triggerTimeTag[2], tPrevDig); trigDIGtiming.push_back(myDIGtiming); double diff=trigDIGtiming.at(digEntry).GetTag1() - trigDIGtiming.at(digEntry).GetTag0(); if (abs(diff)<0.001) { TDIG0[0]+=1.0; TDIG1[0]+=diff; TDIG2[0]+=diff*diff; } diff=trigDIGtiming.at(digEntry).GetTag2() - trigDIGtiming.at(digEntry).GetTag0(); if (abs(diff)<0.001) { TDIG0[1]+=1.0; TDIG1[1]+=diff; TDIG2[1]+=diff*diff; } diff=trigDIGtiming.at(digEntry).GetTag2() - trigDIGtiming.at(digEntry).GetTag1(); if (abs(diff)<0.001) { TDIG0[2]+=1.0; TDIG1[2]+=diff; TDIG2[2]+=diff*diff; } tDIG=trigDIGtiming.at(trigCount).GetTdig(); double diffDIG=0.; if (digEntry>0) diffDIG=tDIG-trigDIGtiming.at(trigCount-1).GetTdig(); if (trigCount<40 && iControl==1) printf("DIG=> evt#%5d(%3d) Spill=%3d Tdig=%8.3f diff=%.3f\n", trigCount, trigDIGtiming.at(trigCount).GetTrigSpill(), trigDIGtiming.at(trigCount).GetSpill(), tDIG, trigDIGtiming.at(trigCount).GetTdiff()); // diffDIG); trigCount++; if (iControl<2) { printf("Push for next event ->"); cin >> iControl; if (iControl==-1) exit(-1); } if (iControl==0) break; } // end of digEntry events loop fDIG->Close(); if (iControl<3) { printf("Push for next spill ->"); cin >> iControl; if (iControl==-1) exit(-1); } if (iControl==0) break; } // end of DIG spills loop printf("DIG data: %d spills %d triggers\n", spillDIG, trigCount); if (trigCount==0) { printf("***** no digitizer data ******\n"); summFile << "-1 no digitizer triggers" << endl; continue; } summFile << spillDIG << "\t\t" << trigCount << "\t\t"; for (int i=0; i<3; i++) { TDIG1[i]/=TDIG0[i]; TDIG2[i]/=TDIG0[i]; TDIG2[i]-=TDIG1[i]*TDIG1[i]; if (TDIG2[i]>0.0) TDIG2[i]=sqrt(TDIG2[i]); else TDIG2[i]=0.0; } printf("tag1-tag0 = %Lf+/-%Lf\n", TDIG1[0], TDIG2[0]); printf("tag2-tag0 = %Lf+/-%Lf\n", TDIG1[1], TDIG2[1]); printf("tag2-tag1 = %Lf+/-%Lf\n", TDIG1[2], TDIG2[2]); int digCount=trigCount; // exit(-1); // iControl=1; double tRunBPC=0.; double tRunDIG=0.; double tSpillBPC=0.; double tSpillDIG=0.; tPrevBPC=0.; double tPrevDIG=0.; double tDIG=0.; //============= match BPC to DIG events ======= int iMatch=0; int nFail0=0; int nFail1=0; sprintf(fname, "/data1/tb2021/BPCtoDIGmatching/run%d_%s.dat", run, version); matchFile.open(fname, ofstream::out); for (int iBPC=0; iBPC=digCount) continue; double diffBest=1.0e10; double accBest=0.; // for (int iDig=iMatch; iDig=bpcCount) continue; if (jDIG>=digCount) continue; if (trigBPCtiming.at(iBPC).GetSpill() != trigBPCtiming.at(jBPC).GetSpill()) continue; if (trigDIGtiming.at(iDIG).GetSpill() != trigDIGtiming.at(jDIG).GetSpill()) continue; double diffBPC=trigBPCtiming.at(jBPC).GetTdiff(); double diffDIG=trigDIGtiming.at(jDIG).GetTdiff(); // printf("\t\tBPC#%d\t spill#%d\t diff=%.3f\t DIG#%d\t spill#%d\t diff=%.3f\n", // iBPC, trigBPCtiming.at(jBPC).GetSpill(), diffBPC, // iDIG, trigDIGtiming.at(jDIG).GetSpill(), diffDIG); difAcc+=(diffBPC-diffDIG)*(diffBPC-diffDIG); cntAcc+=1.0; } difAcc/=cntAcc; difAcc=sqrt(difAcc); diffAh->Fill(1000.0*difAcc); //sec->msec diffAh1->Fill(1000.0*difAcc); //sec->msec // printf("\tdffAcc=%f cntAcc=%f\n", difAcc, cntAcc); if (diffBest>difAcc) { diffBest=difAcc; accBest=cntAcc; iMatch=iDIG; } } // Digitizer events loop diffBh ->Fill(1000.0*diffBest); diffBh1->Fill(1000.0*diffBest); //sec->msec if (diffBest>failCut || iControl<3) printf("\nBPC=> evt#%5d(%3d) Spill=%3d Diff=%5.3f\n", iBPC, trigBPCtiming.at(iBPC).GetTrigSpill(), trigBPCtiming.at(iBPC).GetSpill(), trigBPCtiming.at(iBPC).GetTdiff() ); tDIG=trigDIGtiming.at(iMatch).GetTdig(); if (diffBest>failCut || iControl<3) printf("DIG=> evt#%5d(%3d) Spill=%3d Match=%.3e n=%.0f failed ***\n", iMatch, trigDIGtiming.at(iMatch).GetTrigSpill(), trigDIGtiming.at(iMatch).GetSpill(), diffBest, accBest ); if (diffBest0) { printf("Event#%d done, push for next event ->", iBPC); cin >> iControl; if (iControl==-1) exit(-1); } if (iControl==0) break; tPrevBPC=trigBPCtiming.at(iBPC).GetTbpc(); } // BPC events loop summFile << nFail0 << "\t\t"; matchFile.close(); matchFile.clear(); //======================================================================= // match DIG to BPC //======================================================================= sprintf(fname, "/data1/tb2021/DIGtoBPCmatching/run%d_%s.dat", run, version); matchFile.open(fname, ofstream::out); for (int iDIG=0; iDIG=digCount) continue; double diffBest=1.0e10; double accBest=0.; for (int iBPC=0; iBPC=bpcCount) continue; if (jDIG>=digCount) continue; if (trigBPCtiming.at(iBPC).GetSpill() != trigBPCtiming.at(jBPC).GetSpill()) continue; if (trigDIGtiming.at(iDIG).GetSpill() != trigDIGtiming.at(jDIG).GetSpill()) continue; double diffBPC=trigBPCtiming.at(jBPC).GetTdiff(); double diffDIG=trigDIGtiming.at(jDIG).GetTdiff(); difAcc+=(diffBPC-diffDIG)*(diffBPC-diffDIG); cntAcc+=1.0; } difAcc/=cntAcc; difAcc=sqrt(difAcc); diffAh ->Fill(1000.0*difAcc); //sec->msec diffAh1->Fill(1000.0*difAcc); //sec->msec if (diffBest>difAcc) { diffBest=difAcc; accBest=cntAcc; iMatch=iBPC; } } // BPC events loop diffBh ->Fill(1000.0*diffBest); //sec->msec diffBh1->Fill(1000.0*diffBest); //sec->msec if (diffBest>failCut || iControl<3) printf("\nDIG=> evt#%5d(%3d) Spill=%3d T(1-0)=%f\t T(2-1)=%f\t T(2-0)=%f\n", iDIG, trigDIGtiming.at(iDIG).GetTrigSpill(), trigDIGtiming.at(iDIG).GetSpill(), trigDIGtiming.at(iDIG).GetTag1() - trigDIGtiming.at(iDIG).GetTag0(), trigDIGtiming.at(iDIG).GetTag2() - trigDIGtiming.at(iDIG).GetTag0(), trigDIGtiming.at(iDIG).GetTag2() - trigDIGtiming.at(iDIG).GetTag1() ); if (diffBest>failCut || iControl<3)printf("BPC=> evt#%5d(%3d) Spill=%3d Match=%.3e n=%.0f failed ********\n", iMatch, trigBPCtiming.at(iMatch).GetTrigSpill(), trigBPCtiming.at(iMatch).GetSpill(), diffBest, accBest ); if (diffBest0) { printf("Event#%d done, push for next DIG event ->", iDIG); cin >> iControl; if (iControl==-1) exit(-1); } if (iControl==0) break; } // DIG events loop matchFile.close(); matchFile.clear(); summFile << nFail1 << endl; diffBh ->SetMinimum(0.5); diffAh ->SetMinimum(0.5); diffBh1->SetMinimum(0.5); diffAh1->SetMinimum(0.5); canvas0->Clear(); canvas0->Divide(1,1); canvas0->cd(0)->SetGrid(1); gPad->SetLogy(1); diffBh->DrawCopy(); diffAh->DrawCopy("same"); diffBh->DrawCopy("same"); canvas0->Update(); canvas1->Clear(); canvas1->Divide(1,1); canvas1->cd(0)->SetGrid(1); gPad->SetLogy(1); diffBh1->DrawCopy(); diffAh1->DrawCopy("same"); diffBh1->DrawCopy("same"); canvas1->Update(); if (firstRun) { firstRun=false; canvas1->Print(psFirst); } else { canvas1->Print(psBulk); } if (iControl<10 && iControl>0) { printf("Run#%d done, push for next run ->", run); cin >> iControl; if (iControl==-1) exit(-1); } if (iControl==0) break; } canvas0->Print(psLast); summFile.close(); summFile.clear(); /* TProfile* dtProf = new TProfile("dtProf", "

", nSpills, -0.5, nSpills-0.5); TProfile* stProf = new TProfile("stProf", "#sigma(dT)", nSpills, -0.5, nSpills-0.5); TProfile* dtProfTAG = new TProfile("dtProfTAG", "

DIG", nSpills, -0.5, nSpills-0.5); TProfile* stProfTAG = new TProfile("stProfTAG", "#sigma(dT) DIG", nSpills, -0.5, nSpills-0.5); dtProf ->GetXaxis()->SetTitle("Spill index"); stProf ->GetXaxis()->SetTitle("Spill index"); dtProfTAG->GetXaxis()->SetTitle("Spill index"); stProfTAG->GetXaxis()->SetTitle("Spill index"); dtProf ->GetYaxis()->SetTitle("Average T_BPC - T_DIG, sec"); stProf ->GetYaxis()->SetTitle("#sigma(T_BPC - T_DIG), sec"); dtProfTAG->GetYaxis()->SetTitle("Max DIFF (T_DIG), sec"); stProfTAG->GetYaxis()->SetTitle("#sigma (T_DIG), sec"); dtProf ->SetStats(0); stProf ->SetStats(0); dtProfTAG->SetStats(0); stProfTAG->SetStats(0); for (int i=0; iFill((double)i, dtAcc.at(i)); stProf ->Fill((double)i, stAcc.at(i)); dtProfTAG->Fill((double)i, dtTAG.at(i)); stProfTAG->Fill((double)i, stTAG.at(i)); } canvas0->Clear(); canvas0->Divide(1,4); canvas0->cd(1)->SetGrid(1); dtProf->GetYaxis()->SetRangeUser(-2.7e-4, 2.7e-4); dtProf->DrawCopy(); canvas0->cd(2)->SetGrid(1); stProf->GetYaxis()->SetRangeUser(0.0, 2.0e-4); stProf->DrawCopy(); canvas0->cd(3)->SetGrid(1); //dtProfTAG->GetYaxis()->SetRangeUser(-2.7e-4, 2.7e-4); dtProfTAG->DrawCopy(); canvas0->cd(4)->SetGrid(1); //stProfTAG->GetYaxis()->SetRangeUser(0.0, 2.0e-4); stProfTAG->DrawCopy(); canvas0->Update(); */ }