ARA ROOT v3.11 Software

AraEvent/AtriEventHkData.cxx

00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 #include "AtriEventHkData.h"
00010 #include "TMath.h"
00011 #include <iostream>
00012 #include <fstream>
00013 #include <cstring>
00014 ClassImp(AtriEventHkData);
00015 
00016 AtriEventHkData::AtriEventHkData() 
00017 {
00018   //Default Constructor
00019 }
00020 
00021 AtriEventHkData::~AtriEventHkData() {
00022   //Default Destructor
00023 }
00024  
00025 
00026 AtriEventHkData::AtriEventHkData(AraEventHk_t *theHk)
00027   :RawAraGenericHeader(&(theHk->gHdr))
00028 {
00029   unixTime=theHk->unixTime; 
00030   unixTimeUs=theHk->unixTimeUs; 
00031   firmwareVersion=theHk->firmwareVersion; 
00032   firmwareVersionMaj = (firmwareVersion & 0xf000) >> 12;
00033   firmwareVersionMid = (firmwareVersion & 0xf00) >> 8;
00034   firmwareVersionMin = (firmwareVersion & 0xff);
00035 
00036   memcpy(wilkinsonCounter,theHk->wilkinsonCounter,DDA_PER_ATRI*sizeof(UShort_t)); 
00037   memcpy(wilkinsonDelay,theHk->wilkinsonDelay,DDA_PER_ATRI*sizeof(UShort_t)); 
00038   ppsCounter=theHk->ppsCounter; 
00039   clockCounter=theHk->clockCounter; 
00040 
00041   memcpy(l1ScalerSurface,theHk->l1ScalerSurface,ANTS_PER_TDA*sizeof(uint16_t)); 
00042   memcpy(l1Scaler,theHk->l1Scaler,NUM_L1_SCALERS*sizeof(uint16_t)); 
00043   memcpy(l2Scaler,theHk->l2Scaler,NUM_L2_SCALERS*sizeof(uint16_t)); 
00044   memcpy(l3Scaler,theHk->l3Scaler,NUM_L3_SCALERS*sizeof(uint16_t)); 
00045   memcpy(l4Scaler,theHk->l4Scaler,NUM_L4_SCALERS*sizeof(uint16_t)); 
00046   memcpy(t1Scaler,theHk->t1Scaler,NUM_T1_SCALERS*sizeof(uint16_t)); 
00047   memcpy(thresholdDac,theHk->thresholdDac,NUM_L1_SCALERS*sizeof(uint16_t));
00048   memcpy(surfaceThresholdDac,theHk->surfaceThresholdDac,ANTS_PER_TDA*sizeof(uint16_t)); 
00049   memcpy(vdlyDac,theHk->vdlyDac,DDA_PER_ATRI*sizeof(UShort_t));
00050   memcpy(vadjDac,theHk->vadjDac,DDA_PER_ATRI*sizeof(UShort_t));
00051 
00052   if(firmwareVersionMaj > 0 || firmwareVersionMid >= 10){
00053     evReadoutError = theHk->evReadoutError;
00054     evReadoutCountAvg = theHk->evReadoutCountAvg;
00055     evReadoutCountMin = theHk->evReadoutCountMin;
00056     blockBuffCountAvg = theHk->blockBuffCountAvg;
00057     blockBuffCountMax = theHk->blockBuffCountMax;
00058     digDeadTime = theHk->digDeadTime;
00059     buffDeadTime = theHk->buffDeadTime;
00060     totalDeadTime = theHk->totalDeadTime;
00061   }
00062   else{
00063     evReadoutError=0;
00064     evReadoutCountAvg=0;
00065     evReadoutCountMin=0;
00066     blockBuffCountAvg=0;
00067     blockBuffCountMax=0;
00068     digDeadTime=0;
00069     buffDeadTime=0;
00070     totalDeadTime=0;
00071   }
00072 
00073 
00074 }
00075 
00076 AtriEventHkData::AtriEventHkData(AraEventHk2_7_t *theHk)
00077   :RawAraGenericHeader(&(theHk->gHdr))
00078 {
00079   unixTime=theHk->unixTime; 
00080   unixTimeUs=theHk->unixTimeUs; 
00081   firmwareVersion=theHk->firmwareVersion; 
00082   firmwareVersion=theHk->firmwareVersion; 
00083   firmwareVersionMaj = (firmwareVersion & 0xf000) >> 12;
00084   firmwareVersionMid = (firmwareVersion & 0xf00) >> 8;
00085   firmwareVersionMin = (firmwareVersion & 0xff);
00086 
00087   memcpy(wilkinsonCounter,theHk->wilkinsonCounter,DDA_PER_ATRI*sizeof(UShort_t)); 
00088   memcpy(wilkinsonDelay,theHk->wilkinsonDelay,DDA_PER_ATRI*sizeof(UShort_t)); 
00089   ppsCounter=theHk->ppsCounter; 
00090   clockCounter=theHk->clockCounter; 
00091 
00092   memcpy(vdlyDac,theHk->vdlyDac,DDA_PER_ATRI*sizeof(UShort_t));
00093   memcpy(vadjDac,theHk->vadjDac,DDA_PER_ATRI*sizeof(UShort_t));
00094  
00095   evReadoutError=0;
00096   evReadoutCountAvg=0;
00097   evReadoutCountMin=0;
00098   blockBuffCountAvg=0;
00099   blockBuffCountMax=0;
00100   digDeadTime=0;
00101   buffDeadTime=0;
00102   totalDeadTime=0;
00103 
00104 }
00105 
00106 Double_t AtriEventHkData::wilkinsonCounterNs(Int_t dda){
00107   if(dda >= DDA_PER_ATRI || dda < 0) return -1;
00108   Double_t wilkNs = wilkinsonCounter[dda]*(20.83/64.);
00109   return wilkNs;
00110 
00111 }
00112 
00113 
00114 Double_t AtriEventHkData::getSingleChannelRateHz(Int_t tda, Int_t channel){
00115   if(tda >= TDA_PER_ATRI || tda < 0) return -1;
00116   if(channel>= ANTS_PER_TDA || tda <0) return -1;
00117   uint8_t preScale=32;
00118 
00119   return l1Scaler[tda*ANTS_PER_TDA+channel] * preScale;
00120   
00121 }
00122 Double_t AtriEventHkData::getOneOfFourRateHz(Int_t tda){
00123   if(tda >= TDA_PER_ATRI || tda < 0) return -1;
00124   uint8_t preScale=1;
00125   if(firmwareVersionMaj > 0 || firmwareVersionMid > 9 || firmwareVersionMin >= 40) preScale=64; 
00126 
00127   return l2Scaler[tda*4]*preScale;
00128 
00129 
00130 }
00131 Double_t AtriEventHkData::getTwoOfFourRateHz(Int_t tda){
00132   if(tda >= TDA_PER_ATRI || tda < 0) return -1;
00133   return l2Scaler[tda*4+1];
00134 
00135 
00136 }
00137 Double_t AtriEventHkData::getThreeOfFourRateHz(Int_t tda){
00138   if(tda >= TDA_PER_ATRI || tda < 0) return -1;
00139   return l2Scaler[tda*4+2];
00140 
00141 
00142 }
00143 Double_t AtriEventHkData::getThreeOfEightRateHz(Int_t tda_pair){
00144   if(tda_pair > 1 || tda_pair <0) return -1;
00145   return l3Scaler[tda_pair];
00146 
00147 }
00148   
00149 UInt_t AtriEventHkData::getSingleChannelThreshold(Int_t tda, Int_t channel)
00150 {
00152  
00153   if(tda >= TDA_PER_ATRI || tda < 0) return -1;
00154   if(channel>= ANTS_PER_TDA || tda <0) return -1;
00155   return thresholdDac[channel+(tda*ANTS_PER_TDA)];
00156        
00157 }

Generated on Fri Jul 26 15:27:35 2013 for ARA ROOT v3.11 Software by doxygen 1.4.7