Edtm live time (#268)

* Incorporate event 129 into scaler reads

* Add configuration event handler

* Add pre-scale values and factors, also had HMS hodoscope scaler info

* Fix typo

DEF-files/HMS/SCALERS/hscaler_cuts.def

@@ -18,7 +18,7 @@ Block: Decode
 hms_trigs         HMS_event
 edtm_accepted     T.hms.hHODO_EDTM_tdcTime != 0.0
 physics_accepted  T.hms.hHODO_EDTM_tdcTime == 0.0
-triggers_accepted T.hms.hT1_tdcTime == 0.0
+triggers_accepted T.hms.hT1_tdcTime == 300.0
 
 Decode_master     HMS_event
 

DEF-files/SHMS/SCALERS/pscaler_cuts.def

@@ -18,7 +18,7 @@ Block: Decode
 shms_trigs        SHMS_event
 edtm_accepted     T.shms.pHODO_EDTM_tdcTime != 0.0
 physics_accepted  T.shms.pHODO_EDTM_tdcTime == 0.0
-triggers_accepted T.shms.pT2_tdcTime == 0.0
+triggers_accepted T.shms.pT2_tdcTime == 300.0
 
 Decode_master     SHMS_event
 

SCRIPTS/HMS/SCALERS/replay_hms_scalers.C

@@ -48,18 +48,17 @@ void replay_hms_scalers(Int_t RunNumber=0, Int_t MaxEvent=0) {
   THcTrigDet* hms = new THcTrigDet("hms", "HMS Trigger Information");
   TRG->AddDetector(hms);
 
-  // Add handler for EPICS events
+  // Add event handler for EPICS events
   THaEpicsEvtHandler *hcepics = new THaEpicsEvtHandler("epics", "HC EPICS event type 180");
   gHaEvtHandlers->Add(hcepics);
-  // Add handler for scaler events
-  THcScalerEvtHandler *hscaler = new THcScalerEvtHandler("H","Hall C scaler event type 1");
-  
-  hscaler->SetUseFirstEvent(kTRUE);
+  // Add event handler for scaler events
+  THcScalerEvtHandler *hscaler = new THcScalerEvtHandler("H","Hall C scaler event type 129");
   hscaler->AddEvtType(129);
-  hscaler->SetDelayedType(129);
-  hscaler->SetOnlyBanks(kTRUE);
-
+  hscaler->SetUseFirstEvent(kTRUE);
   gHaEvtHandlers->Add(hscaler);
+  // Add event handler for DAQ configuration event
+  THcConfigEvtHandler *hconfig = new THcConfigEvtHandler("hconfig", "Hall C configuration event handler");
+  gHaEvtHandlers->Add(hconfig);
 
   // Set up the analyzer - we use the standard one,
   // but this could be an experiment-specific one as well.
@@ -68,14 +67,15 @@ void replay_hms_scalers(Int_t RunNumber=0, Int_t MaxEvent=0) {
   // and executes the output routines.
   THcAnalyzer* analyzer = new THcAnalyzer;
 
-  // A simple event class to be output to the resulting tree.
+  // A simple event class to be output to the resulting tree. 
   // Creating your own descendant of THaEvent is one way of
   // defining and controlling the output.
   THaEvent* event = new THaEvent;
 
   // Define the run(s) that we want to analyze.
   // We just set up one, but this could be many.
-  THaRun* run = new THaRun( pathList, Form(RunFileNamePattern, RunNumber) );
+  //THaRun* run = new THaRun( pathList, Form(RunFileNamePattern, RunNumber) );
+  THcRun* run = new THcRun( pathList, Form(RunFileNamePattern, RunNumber) );
 
   // Eventually need to learn to skip over, or properly analyze
   // the pedestal events
@@ -91,7 +91,6 @@ void replay_hms_scalers(Int_t RunNumber=0, Int_t MaxEvent=0) {
                                 // 1 = counter is # of all decode reads
                                 // 2 = counter is event number
   analyzer->SetEvent(event);
- 
   // Set EPICS event type
   analyzer->SetEpicsEvtType(180);
   // Define crate map

SCRIPTS/SHMS/SCALERS/replay_shms_scalers.C

@@ -53,9 +53,12 @@ void replay_shms_scalers (Int_t RunNumber = 0, Int_t MaxEvent = 0) {
   gHaEvtHandlers->Add(hcepics);
   // Add handler for scaler events
   THcScalerEvtHandler *pscaler = new THcScalerEvtHandler("P","Hall C scaler event type 1");
-  pscaler->AddEvtType(1);
+  pscaler->AddEvtType(129);
   pscaler->SetUseFirstEvent(kTRUE);
   gHaEvtHandlers->Add(pscaler);
+  // Add event handler for DAQ configuration event
+  THcConfigEvtHandler *pconfig = new THcConfigEvtHandler("pconfig", "Hall C configuration event handler");
+  gHaEvtHandlers->Add(pconfig);
 
   // Set up the analyzer - we use the standard one,
   // but this could be an experiment-specific one as well.
@@ -71,7 +74,7 @@ void replay_shms_scalers (Int_t RunNumber = 0, Int_t MaxEvent = 0) {
 
   // Define the run(s) that we want to analyze.
   // We just set up one, but this could be many.
-  THaRun* run = new THaRun( pathList, Form(RunFileNamePattern, RunNumber) );
+  THcRun* run = new THcRun( pathList, Form(RunFileNamePattern, RunNumber) );
 
   // Eventually need to learn to skip over, or properly analyze
   // the pedestal events

TEMPLATES/HMS/SCALERS/hscalers.template

@@ -24,6 +24,24 @@ BCM1 Counts: {H.BCM1.scalerCut} 	Total Charge: {H.BCM1.scalerChargeCut:%.3f} uC
 BCM2 Counts: {H.BCM2.scalerCut} 	Total Charge: {H.BCM2.scalerChargeCut:%.3f} uC
 Unser Counts: {H.Unser.scalerCut} 	Total Charge: {H.Unser.scalerChargeCut:%.3f} uC
 
+********************
+* DAQ Configuration
+********************
+
+Ps1_value = {ghconfig_ti_ps[0]}
+Ps2_value = {ghconfig_ti_ps[1]}
+Ps3_value = {ghconfig_ti_ps[2]}
+Ps4_value = {ghconfig_ti_ps[3]}
+Ps5_value = {ghconfig_ti_ps[4]}
+Ps6_value = {ghconfig_ti_ps[5]}
+
+Ps1_factor = {floor(2**(ghconfig_ti_ps[0] - 1) + 1):%d}
+Ps2_factor = {floor(2**(ghconfig_ti_ps[1] - 1) + 1):%d}
+Ps3_factor = {floor(2**(ghconfig_ti_ps[2] - 1) + 1):%d}
+Ps4_factor = {floor(2**(ghconfig_ti_ps[3] - 1) + 1):%d}
+Ps5_factor = {floor(2**(ghconfig_ti_ps[4] - 1) + 1):%d}
+Ps6_factor = {floor(2**(ghconfig_ti_ps[5] - 1) + 1):%d}
+
 ***********
 * Triggers
 ***********
@@ -56,4 +74,130 @@ Total Dead Time (EDTM) : {100.0 - (edtm_accepted.npassed / H.HOD_EDTM.scaler)*10
 Physics Triggers           : {H.Trig.scaler - H.HOD_EDTM.scaler}
 Estimated Physics Triggers : {(H.Trig.scalerRate - H.HOD_EDTM.scalerRate)*(H.1Mhz.scaler/1000000.):%.0f}
 Physics Trigger Rate       : {(H.Trig.scalerRate - H.HOD_EDTM.scalerRate)/1000.:%.3f} kHz
-Accepted Physics Triggers  : {physics_accepted.npassed}
+Accepted Physics Triggers  : {physics_accepted.npassed}
\ No newline at end of file
+
+*******************
+* Hardware Scalers
+*******************
+
+*HODOSCOPES*
+Scint	Counts		Rate
+H1X1+:  {H.hod.1x1.posScaler} [ {H.hod.1x1.posScalerRate/1000.:%.3f} kHz ]
+H1X2+:  {H.hod.1x2.posScaler} [ {H.hod.1x2.posScalerRate/1000.:%.3f} kHz ]
+H1X3+:  {H.hod.1x3.posScaler} [ {H.hod.1x3.posScalerRate/1000.:%.3f} kHz ]
+H1X4+:  {H.hod.1x4.posScaler} [ {H.hod.1x4.posScalerRate/1000.:%.3f} kHz ]
+H1X5+:  {H.hod.1x5.posScaler} [ {H.hod.1x5.posScalerRate/1000.:%.3f} kHz ]
+H1X6+:  {H.hod.1x6.posScaler} [ {H.hod.1x6.posScalerRate/1000.:%.3f} kHz ]
+H1X7+:  {H.hod.1x7.posScaler} [ {H.hod.1x7.posScalerRate/1000.:%.3f} kHz ]
+H1X8+:  {H.hod.1x8.posScaler} [ {H.hod.1x8.posScalerRate/1000.:%.3f} kHz ]
+H1X9+:  {H.hod.1x9.posScaler} [ {H.hod.1x9.posScalerRate/1000.:%.3f} kHz ]
+H1X10+: {H.hod.1x10.posScaler} [ {H.hod.1x10.posScalerRate/1000.:%.3f} kHz ]
+H1X11+: {H.hod.1x11.posScaler} [ {H.hod.1x11.posScalerRate/1000.:%.3f} kHz ] 
+H1X12+: {H.hod.1x12.posScaler} [ {H.hod.1x12.posScalerRate/1000.:%.3f} kHz ]
+H1X13+: {H.hod.1x13.posScaler} [ {H.hod.1x13.posScalerRate/1000.:%.3f} kHz ]
+H1X14+: {H.hod.1x14.posScaler} [ {H.hod.1x14.posScalerRate/1000.:%.3f} kHz ]
+H1X15+: {H.hod.1x15.posScaler} [ {H.hod.1x15.posScalerRate/1000.:%.3f} kHz ]
+H1X16+: {H.hod.1x16.posScaler} [ {H.hod.1x16.posScalerRate/1000.:%.3f} kHz ]
+
+H1X1-:  {H.hod.1x1.negScaler} [ {H.hod.1x1.negScalerRate/1000.:%.3f} kHz ]
+H1X2-:  {H.hod.1x2.negScaler} [ {H.hod.1x2.negScalerRate/1000.:%.3f} kHz ]
+H1X3-:  {H.hod.1x3.negScaler} [ {H.hod.1x3.negScalerRate/1000.:%.3f} kHz ]
+H1X4-:  {H.hod.1x4.negScaler} [ {H.hod.1x4.negScalerRate/1000.:%.3f} kHz ]
+H1X5-:  {H.hod.1x5.negScaler} [ {H.hod.1x5.negScalerRate/1000.:%.3f} kHz ]
+H1X6-:  {H.hod.1x6.negScaler} [ {H.hod.1x6.negScalerRate/1000.:%.3f} kHz ]
+H1X7-:  {H.hod.1x7.negScaler} [ {H.hod.1x7.negScalerRate/1000.:%.3f} kHz ]
+H1X8-:  {H.hod.1x8.negScaler} [ {H.hod.1x8.negScalerRate/1000.:%.3f} kHz ]
+H1X9-:  {H.hod.1x9.negScaler} [ {H.hod.1x9.negScalerRate/1000.:%.3f} kHz ]
+H1X10-: {H.hod.1x10.negScaler} [ {H.hod.1x10.negScalerRate/1000.:%.3f} kHz ]
+H1X11-: {H.hod.1x11.negScaler} [ {H.hod.1x11.negScalerRate/1000.:%.3f} kHz ]
+H1X12-: {H.hod.1x12.negScaler} [ {H.hod.1x12.negScalerRate/1000.:%.3f} kHz ]
+H1X13-: {H.hod.1x13.negScaler} [ {H.hod.1x13.negScalerRate/1000.:%.3f} kHz ]
+H1X14-: {H.hod.1x14.negScaler} [ {H.hod.1x14.negScalerRate/1000.:%.3f} kHz ]
+H1X15-: {H.hod.1x15.negScaler} [ {H.hod.1x15.negScalerRate/1000.:%.3f} kHz ]
+H1X16-: {H.hod.1x16.negScaler} [ {H.hod.1x16.negScalerRate/1000.:%.3f} kHz ]
+ 
+H1Y1+:  {H.hod.1y1.posScaler} [ {H.hod.1y1.posScalerRate/1000.:%.3f} kHz ]
+H1Y2+:  {H.hod.1y2.posScaler} [ {H.hod.1y2.posScalerRate/1000.:%.3f} kHz ]
+H1Y3+:  {H.hod.1y3.posScaler} [ {H.hod.1y3.posScalerRate/1000.:%.3f} kHz ]
+H1Y4+:  {H.hod.1y4.posScaler} [ {H.hod.1y4.posScalerRate/1000.:%.3f} kHz ]
+H1Y5+:  {H.hod.1y5.posScaler} [ {H.hod.1y5.posScalerRate/1000.:%.3f} kHz ]
+H1Y6+:  {H.hod.1y6.posScaler} [ {H.hod.1y6.posScalerRate/1000.:%.3f} kHz ]
+H1Y7+:  {H.hod.1y7.posScaler} [ {H.hod.1y7.posScalerRate/1000.:%.3f} kHz ]
+H1Y8+:  {H.hod.1y8.posScaler} [ {H.hod.1y8.posScalerRate/1000.:%.3f} kHz ]
+H1Y9+:  {H.hod.1y9.posScaler} [ {H.hod.1y9.posScalerRate/1000.:%.3f} kHz ]
+H1Y10+: {H.hod.1y10.posScaler} [ {H.hod.1y10.posScalerRate/1000.:%.3f} kHz ]
+
+H1Y1-:  {H.hod.1y1.negScaler} [ {H.hod.1y1.negScalerRate/1000.:%.3f} kHz ]
+H1Y2-:  {H.hod.1y2.negScaler} [ {H.hod.1y2.negScalerRate/1000.:%.3f} kHz ]
+H1Y3-:  {H.hod.1y3.negScaler} [ {H.hod.1y3.negScalerRate/1000.:%.3f} kHz ]
+H1Y4-:  {H.hod.1y4.negScaler} [ {H.hod.1y4.negScalerRate/1000.:%.3f} kHz ]
+H1Y5-:  {H.hod.1y5.negScaler} [ {H.hod.1y5.negScalerRate/1000.:%.3f} kHz ]
+H1Y6-:  {H.hod.1y6.negScaler} [ {H.hod.1y6.negScalerRate/1000.:%.3f} kHz ]
+H1Y7-:  {H.hod.1y7.negScaler} [ {H.hod.1y7.negScalerRate/1000.:%.3f} kHz ]
+H1Y8-:  {H.hod.1y8.negScaler} [ {H.hod.1y8.negScalerRate/1000.:%.3f} kHz ]
+H1Y9-:  {H.hod.1y9.negScaler} [ {H.hod.1y9.negScalerRate/1000.:%.3f} kHz ]
+H1Y10-: {H.hod.1y10.negScaler} [ {H.hod.1y10.negScalerRate/1000.:%.3f} kHz ]
+
+H2X1+:  {H.hod.2x1.posScaler} [ {H.hod.2x1.posScalerRate/1000.:%.3f} kHz ]
+H2X2+:  {H.hod.2x2.posScaler} [ {H.hod.2x2.posScalerRate/1000.:%.3f} kHz ]
+H2X3+:  {H.hod.2x3.posScaler} [ {H.hod.2x3.posScalerRate/1000.:%.3f} kHz ]
+H2X4+:  {H.hod.2x4.posScaler} [ {H.hod.2x4.posScalerRate/1000.:%.3f} kHz ]
+H2X5+:  {H.hod.2x5.posScaler} [ {H.hod.2x5.posScalerRate/1000.:%.3f} kHz ]
+H2X6+:  {H.hod.2x6.posScaler} [ {H.hod.2x6.posScalerRate/1000.:%.3f} kHz ]
+H2X7+:  {H.hod.2x7.posScaler} [ {H.hod.2x7.posScalerRate/1000.:%.3f} kHz ]
+H2X8+:  {H.hod.2x8.posScaler} [ {H.hod.2x8.posScalerRate/1000.:%.3f} kHz ]
+H2X9+:  {H.hod.2x9.posScaler} [ {H.hod.2x9.posScalerRate/1000.:%.3f} kHz ]
+H2X10+: {H.hod.2x10.posScaler} [ {H.hod.2x10.posScalerRate/1000.:%.3f} kHz ]
+H2X11+: {H.hod.2x11.posScaler} [ {H.hod.2x11.posScalerRate/1000.:%.3f} kHz ]
+H2X12+: {H.hod.2x12.posScaler} [ {H.hod.2x12.posScalerRate/1000.:%.3f} kHz ]
+H2X13+: {H.hod.2x13.posScaler} [ {H.hod.2x13.posScalerRate/1000.:%.3f} kHz ]
+H2X14+: {H.hod.2x14.posScaler} [ {H.hod.2x14.posScalerRate/1000.:%.3f} kHz ]
+H2X15+: {H.hod.2x15.posScaler} [ {H.hod.2x15.posScalerRate/1000.:%.3f} kHz ]
+H2X16+: {H.hod.2x16.posScaler} [ {H.hod.2x16.posScalerRate/1000.:%.3f} kHz ]
+
+H2X1-:  {H.hod.2x1.negScaler} [ {H.hod.2x1.negScalerRate/1000.:%.3f} kHz ]
+H2X2-:  {H.hod.2x2.negScaler} [ {H.hod.2x2.negScalerRate/1000.:%.3f} kHz ]
+H2X3-:  {H.hod.2x3.negScaler} [ {H.hod.2x3.negScalerRate/1000.:%.3f} kHz ]
+H2X4-:  {H.hod.2x4.negScaler} [ {H.hod.2x4.negScalerRate/1000.:%.3f} kHz ]
+H2X5-:  {H.hod.2x5.negScaler} [ {H.hod.2x5.negScalerRate/1000.:%.3f} kHz ]
+H2X6-:  {H.hod.2x6.negScaler} [ {H.hod.2x6.negScalerRate/1000.:%.3f} kHz ]
+H2X7-:  {H.hod.2x7.negScaler} [ {H.hod.2x7.negScalerRate/1000.:%.3f} kHz ]
+H2X8-:  {H.hod.2x8.negScaler} [ {H.hod.2x8.negScalerRate/1000.:%.3f} kHz ]
+H2X9-:  {H.hod.2x9.negScaler} [ {H.hod.2x9.negScalerRate/1000.:%.3f} kHz ]
+H2X10-: {H.hod.2x10.negScaler} [ {H.hod.2x10.negScalerRate/1000.:%.3f} kHz ]
+H2X11-: {H.hod.2x11.negScaler} [ {H.hod.2x11.negScalerRate/1000.:%.3f} kHz ]
+H2X12-: {H.hod.2x12.negScaler} [ {H.hod.2x12.negScalerRate/1000.:%.3f} kHz ]
+H2X13-: {H.hod.2x13.negScaler} [ {H.hod.2x13.negScalerRate/1000.:%.3f} kHz ]
+H2X14-: {H.hod.2x14.negScaler} [ {H.hod.2x14.negScalerRate/1000.:%.3f} kHz ]
+H2X15-: {H.hod.2x15.negScaler} [ {H.hod.2x15.negScalerRate/1000.:%.3f} kHz ]
+H2X16-: {H.hod.2x16.negScaler} [ {H.hod.2x16.negScalerRate/1000.:%.3f} kHz ]
+
+H2Y1+:  {H.hod.2y1.posScaler} [ {H.hod.2y1.posScalerRate/1000.:%.3f} kHz ]
+H2Y2+:  {H.hod.2y2.posScaler} [ {H.hod.2y2.posScalerRate/1000.:%.3f} kHz ]
+H2Y3+:  {H.hod.2y3.posScaler} [ {H.hod.2y3.posScalerRate/1000.:%.3f} kHz ] 
+H2Y4+:  {H.hod.2y4.posScaler} [ {H.hod.2y4.posScalerRate/1000.:%.3f} kHz ]
+H2Y5+:  {H.hod.2y5.posScaler} [ {H.hod.2y5.posScalerRate/1000.:%.3f} kHz ]
+H2Y6+:  {H.hod.2y6.posScaler} [ {H.hod.2y6.posScalerRate/1000.:%.3f} kHz ]
+H2Y7+:  {H.hod.2y7.posScaler} [ {H.hod.2y7.posScalerRate/1000.:%.3f} kHz ]
+H2Y8+:  {H.hod.2y8.posScaler} [ {H.hod.2y8.posScalerRate/1000.:%.3f} kHz ]
+H2Y9+:  {H.hod.2y9.posScaler} [ {H.hod.2y9.posScalerRate/1000.:%.3f} kHz ]
+H2Y10+: {H.hod.2y10.posScaler} [ {H.hod.2y10.posScalerRate/1000.:%.3f} kHz ]
+
+H2Y1-:  {H.hod.2y1.negScaler} [ {H.hod.2y1.negScalerRate/1000.:%.3f} kHz ]
+H2Y2-:  {H.hod.2y2.negScaler} [ {H.hod.2y2.negScalerRate/1000.:%.3f} kHz ]
+H2Y3-:  {H.hod.2y3.negScaler} [ {H.hod.2y3.negScalerRate/1000.:%.3f} kHz ]
+H2Y4-:  {H.hod.2y4.negScaler} [ {H.hod.2y4.negScalerRate/1000.:%.3f} kHz ]
+H2Y5-:  {H.hod.2y5.negScaler} [ {H.hod.2y5.negScalerRate/1000.:%.3f} kHz ]
+H2Y6-:  {H.hod.2y6.negScaler} [ {H.hod.2y6.negScalerRate/1000.:%.3f} kHz ]
+H2Y7-:  {H.hod.2y7.negScaler} [ {H.hod.2y7.negScalerRate/1000.:%.3f} kHz ]
+H2Y8-:  {H.hod.2y8.negScaler} [ {H.hod.2y8.negScalerRate/1000.:%.3f} kHz ]
+H2Y9-:  {H.hod.2y9.negScaler} [ {H.hod.2y9.negScalerRate/1000.:%.3f} kHz ]
+H2Y10-: {H.hod.2y10.negScaler} [ {H.hod.2y10.negScalerRate/1000.:%.3f} kHz ]
+
+H1X: {H.S1X.scaler} [ {H.S1X.scalerRate/1000.:%.3f} kHz ] AND between + and - sides of H1X 
+H1Y: {H.S1Y.scaler} [ {H.S1Y.scalerRate/1000.:%.3f} kHz ] AND between + and - sides of H1Y
+H2X: {H.S2X.scaler} [ {H.S2X.scalerRate/1000.:%.3f} kHz ] AND between + and - sides of H2X
+H2Y: {H.S2Y.scaler} [ {H.S2Y.scalerRate/1000.:%.3f} kHz ] AND between + and - sides of H2Y
+
+H1XH1Y: {H.S1XS1Y.scaler} [{H.S1XS1Y.scalerRate/1000.:%.3f}] AND between H1X and H1Y planes 
+H2XH2Y: {H.S2XS2Y.scaler} [{H.S2XS2Y.scalerRate/1000.:%.3f}] OR between H2X and H2Y planes (just for kpp, will be AND)
\ No newline at end of file