SurfHk.cxx
1 
9 #include "SurfHk.h"
10 #include "AnitaPacketUtil.h"
11 #include "AnitaGeomTool.h"
12 #include "AnitaEventCalibrator.h"
13 #include <iostream>
14 #include <fstream>
15 #include <cstring>
16 #include "AnitaVersion.h"
17 
18 ClassImp(SurfHk);
19 
20 SurfHk::SurfHk()
21 {
22  //Default Constructor
23 }
24 
25 SurfHk::~SurfHk() {
26  //Default Destructor
27 }
28 
29 SurfHk::SurfHk(Int_t trun, Int_t trealTime, FullSurfHkStruct_t *surfPtr)
30 {
31  simplePacketCheck(&(surfPtr->gHdr),PACKET_SURF_HK);
32 
33 
34  run=trun;
35  realTime=trealTime;
36  payloadTime=surfPtr->unixTime;
37  payloadTimeUs=surfPtr->unixTimeUs;
38  globalThreshold=surfPtr->globalThreshold;
39  errorFlag=surfPtr->errorFlag;
40  memcpy(scalerGoals,surfPtr->scalerGoals,sizeof(UShort_t)*NUM_ANTENNA_RINGS);
41  memcpy(upperWords,surfPtr->upperWords,sizeof(UShort_t)*ACTIVE_SURFS);
42 
43  //At some point will fix this to do it properly
44  int rawSurfToTrigSurf[ACTIVE_SURFS]={-1,-1,0,1,2,3,4,5,6,7,-1,-1};
45 
46 
47  for(int surf=0;surf<ACTIVE_SURFS;surf++) {
48  if(rawSurfToTrigSurf[surf]>=0) {
49  surfTrigBandMask[surf]=surfPtr->surfTrigBandMask[rawSurfToTrigSurf[surf]];
50  for(int l1=0;l1<L1S_PER_SURF;l1++) {
51  l1Scaler[surf][l1]=surfPtr->l1Scaler[rawSurfToTrigSurf[surf]][l1];
52  }
53  for(int l2=0;l2<L2S_PER_SURF;l2++) {
54  l2Scaler[surf][l2]=surfPtr->l2Scaler[rawSurfToTrigSurf[surf]][l2];
55  }
56  for(int i=0;i<12;i++) {
57  scaler[surf][i]=surfPtr->scaler[rawSurfToTrigSurf[surf]][i];
58  threshold[surf][i]=surfPtr->threshold[rawSurfToTrigSurf[surf]][i];
59  setThreshold[surf][i]=surfPtr->setThreshold[rawSurfToTrigSurf[surf]][i];
60  }
61  }
62  else {
63  surfTrigBandMask[surf]=0;
64  for(int l1=0;l1<L1S_PER_SURF;l1++) {
65  l1Scaler[surf][l1]=0;
66  }
67  for(int l2=0;l2<L2S_PER_SURF;l2++) {
68  l2Scaler[surf][l2]=0;
69  }
70  for(int i=0;i<12;i++) {
71  scaler[surf][i]=0;
72  threshold[surf][i]=0;
73  setThreshold[surf][i]=0;
74  }
75  }
76  }
77  memcpy(rfPower,surfPtr->rfPower,sizeof(UShort_t)*ACTIVE_SURFS*RFCHAN_PER_SURF);
78  intFlag=0;
79 }
80 
81 
82 
83 SurfHk::SurfHk(Int_t trun, Int_t trealTime, FullSurfHkStructVer40_t *surfPtr)
84 {
85  if(surfPtr->gHdr.code!=PACKET_SURF_HK ||
86  surfPtr->gHdr.verId!=VER_SURF_HK ||
87  surfPtr->gHdr.numBytes!=sizeof(FullSurfHkStruct_t)) {
88  std::cerr << "Mismatched packet\t" << packetCodeAsString(PACKET_SURF_HK)
89 
90  << "\ncode:\t" << (int)surfPtr->gHdr.code << "\t" << PACKET_SURF_HK
91  << "\nversion:\t" << (int)surfPtr->gHdr.verId
92  << "\t" << VER_SURF_HK
93  << "\nsize:\t" << surfPtr->gHdr.numBytes << "\t"
94  << sizeof(FullSurfHkStruct_t) << std::endl;
95  }
96 
97 
98  run=trun;
99  realTime=trealTime;
100  payloadTime=surfPtr->unixTime;
101  payloadTimeUs=surfPtr->unixTimeUs;
102  globalThreshold=surfPtr->globalThreshold;
103  errorFlag=surfPtr->errorFlag;
104  memcpy(scalerGoals,surfPtr->scalerGoals,sizeof(UShort_t)*NUM_ANTENNA_RINGS);
105  memcpy(upperWords,surfPtr->upperWords,sizeof(UShort_t)*ACTIVE_SURFS);
106 
107  for(int surf=0;surf<ACTIVE_SURFS;surf++) {
108  for(int l1=0;l1<L1S_PER_SURF;l1++) {
109  l1Scaler[surf][l1]=surfPtr->l1Scaler[surf][l1];
110  }
111  for(int i=0;i<12;i++) {
112  scaler[surf][i]=surfPtr->scaler[surf][i];
113  threshold[surf][i]=surfPtr->threshold[surf][i];
114  setThreshold[surf][i]=surfPtr->setThreshold[surf][i];
115  }
116  }
117  memcpy(rfPower,surfPtr->rfPower,sizeof(UShort_t)*ACTIVE_SURFS*RFCHAN_PER_SURF);
118  memcpy(surfTrigBandMask,surfPtr->surfTrigBandMask,sizeof(UShort_t)*ACTIVE_SURFS);
119  intFlag=0;
120 }
121 
122 
123 
124 SurfHk::SurfHk(Int_t trun, Int_t trealTime, FullSurfHkStructVer30_t *surfPtr)
125 {
126  if(surfPtr->gHdr.code!=PACKET_SURF_HK ||
127  surfPtr->gHdr.verId!=VER_SURF_HK ||
128  surfPtr->gHdr.numBytes!=sizeof(FullSurfHkStruct_t)) {
129  std::cerr << "Mismatched packet\t" << packetCodeAsString(PACKET_SURF_HK)
130 
131  << "\ncode:\t" << (int)surfPtr->gHdr.code << "\t" << PACKET_SURF_HK
132  << "\nversion:\t" << (int)surfPtr->gHdr.verId
133  << "\t" << VER_SURF_HK
134  << "\nsize:\t" << surfPtr->gHdr.numBytes << "\t"
135  << sizeof(FullSurfHkStruct_t) << std::endl;
136  }
137 
138 
139  run=trun;
140  realTime=trealTime;
141  payloadTime=surfPtr->unixTime;
142  payloadTimeUs=surfPtr->unixTimeUs;
143  globalThreshold=surfPtr->globalThreshold;
144  errorFlag=surfPtr->errorFlag;
145  memcpy(scalerGoals,surfPtr->scalerGoals,sizeof(UShort_t)*BANDS_PER_ANT);
146  memcpy(scalerGoalsNadir,surfPtr->scalerGoalsNadir,sizeof(UShort_t)*BANDS_PER_ANT);
147  memcpy(upperWords,surfPtr->upperWords,sizeof(UShort_t)*ACTIVE_SURFS);
148  memcpy(scaler,surfPtr->scaler,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF_V30);
149  memcpy(threshold,surfPtr->threshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF_V30);
150  memcpy(setThreshold,surfPtr->setThreshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF_V30);
151  memcpy(rfPower,surfPtr->rfPower,sizeof(UShort_t)*ACTIVE_SURFS*RFCHAN_PER_SURF);
152  memcpy(surfTrigBandMask,surfPtr->surfTrigBandMask,sizeof(UShort_t)*ACTIVE_SURFS);
153  intFlag=0;
154 }
155 
156 
157 SurfHk::SurfHk(Int_t trun, Int_t trealTime, FullSurfHkStructVer14_t *surfPtr)
158 {
159  if(surfPtr->gHdr.code!=PACKET_SURF_HK ||
160  surfPtr->gHdr.verId!=14 ||
161  surfPtr->gHdr.numBytes!=sizeof(FullSurfHkStructVer14_t)) {
162  std::cerr << "Mismatched packet\t" << packetCodeAsString(PACKET_SURF_HK)
163 
164  << "\ncode:\t" << (int)surfPtr->gHdr.code << "\t" << PACKET_SURF_HK
165  << "\nversion:\t" << (int)surfPtr->gHdr.verId
166  << "\t" << 14
167  << "\nsize:\t" << surfPtr->gHdr.numBytes << "\t"
168  << sizeof(FullSurfHkStructVer14_t) << std::endl;
169  }
170 
171 
172  run=trun;
173  realTime=trealTime;
174  payloadTime=surfPtr->unixTime;
175  payloadTimeUs=surfPtr->unixTimeUs;
176  globalThreshold=surfPtr->globalThreshold;
177  errorFlag=surfPtr->errorFlag;
178  memcpy(scalerGoals,surfPtr->scalerGoals,sizeof(UShort_t)*BANDS_PER_ANT);
179  memcpy(scalerGoalsNadir,surfPtr->scalerGoalsNadir,sizeof(UShort_t)*BANDS_PER_ANT);
180  memcpy(upperWords,surfPtr->upperWords,sizeof(UShort_t)*ACTIVE_SURFS);
181  memcpy(scaler,surfPtr->scaler,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
182  memcpy(threshold,surfPtr->threshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
183  memcpy(setThreshold,surfPtr->setThreshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
184  memcpy(rfPower,surfPtr->rfPower,sizeof(UShort_t)*ACTIVE_SURFS*RFCHAN_PER_SURF);
185  memcpy(surfTrigBandMask,surfPtr->surfTrigBandMask,sizeof(UShort_t)*ACTIVE_SURFS);
186  intFlag=0;
187 }
188 
189 SurfHk::SurfHk(Int_t trun, Int_t trealTime, FullSurfHkStructVer13_t *surfPtr)
190 {
191  if(surfPtr->gHdr.code!=PACKET_SURF_HK ||
192  surfPtr->gHdr.verId!=13 ||
193  surfPtr->gHdr.numBytes!=sizeof(FullSurfHkStructVer13_t)) {
194  std::cerr << "Mismatched packet\t" << packetCodeAsString(PACKET_SURF_HK)
195 
196  << "\ncode:\t" << (int)surfPtr->gHdr.code << "\t" << PACKET_SURF_HK
197  << "\nversion:\t" << (int)surfPtr->gHdr.verId
198  << "\t" << 13
199  << "\nsize:\t" << surfPtr->gHdr.numBytes << "\t"
200  << sizeof(FullSurfHkStructVer13_t) << std::endl;
201  }
202 
203 
204  run=trun;
205  realTime=trealTime;
206  payloadTime=surfPtr->unixTime;
207  payloadTimeUs=surfPtr->unixTimeUs;
208  globalThreshold=surfPtr->globalThreshold;
209  errorFlag=surfPtr->errorFlag;
210  memcpy(scalerGoals,surfPtr->scalerGoals,sizeof(UShort_t)*BANDS_PER_ANT);
211  for(int band=0;band<BANDS_PER_ANT;band++)
212  scalerGoalsNadir[band]=scalerGoals[band];
213  memcpy(upperWords,surfPtr->upperWords,sizeof(UShort_t)*ACTIVE_SURFS);
214  memcpy(scaler,surfPtr->scaler,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
215  memcpy(threshold,surfPtr->threshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
216  memcpy(setThreshold,surfPtr->setThreshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
217  memcpy(rfPower,surfPtr->rfPower,sizeof(UShort_t)*ACTIVE_SURFS*RFCHAN_PER_SURF);
218  memcpy(surfTrigBandMask,surfPtr->surfTrigBandMask,sizeof(UShort_t)*ACTIVE_SURFS);
219  intFlag=0;
220 }
221 
222 SurfHk::SurfHk(Int_t trun, Int_t trealTime, FullSurfHkStructVer12_t *surfPtr)
223 {
224  if(surfPtr->gHdr.code!=PACKET_SURF_HK ||
225  surfPtr->gHdr.verId!=12 ||
226  surfPtr->gHdr.numBytes!=sizeof(FullSurfHkStructVer12_t)) {
227  std::cerr << "Mismatched packet\t" << packetCodeAsString(PACKET_SURF_HK)
228 
229  << "\ncode:\t" << (int)surfPtr->gHdr.code << "\t" << PACKET_SURF_HK
230  << "\nversion:\t" << (int)surfPtr->gHdr.verId
231  << "\t" << 12
232  << "\nsize:\t" << surfPtr->gHdr.numBytes << "\t"
233  << sizeof(FullSurfHkStructVer12_t) << std::endl;
234  }
235 
236 
237  run=trun;
238  realTime=trealTime;
239  payloadTime=surfPtr->unixTime;
240  payloadTimeUs=surfPtr->unixTimeUs;
241  globalThreshold=surfPtr->globalThreshold;
242  errorFlag=surfPtr->errorFlag;
243  for(int band=0;band<BANDS_PER_ANT;band++) {
244  scalerGoalsNadir[band]=surfPtr->scalerGoal;
245  scalerGoals[band]=surfPtr->scalerGoal;
246  }
247  memcpy(upperWords,surfPtr->upperWords,sizeof(UShort_t)*ACTIVE_SURFS);
248  memcpy(scaler,surfPtr->scaler,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
249  memcpy(threshold,surfPtr->threshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
250  memcpy(setThreshold,surfPtr->setThreshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
251  memcpy(rfPower,surfPtr->rfPower,sizeof(UShort_t)*ACTIVE_SURFS*RFCHAN_PER_SURF);
252  memcpy(surfTrigBandMask,surfPtr->surfTrigBandMask,sizeof(UShort_t)*ACTIVE_SURFS);
253  intFlag=0;
254 }
255 
256 SurfHk::SurfHk(Int_t trun,
257  UInt_t trealTime,
258  UInt_t tpayloadTime,
259  UInt_t tpayloadTimeUs,
260  UShort_t tglobalThreshold,
261  UShort_t terrorFlag,
262  UShort_t tscalerGoals[BANDS_PER_ANT],
263  UShort_t tscalerGoalsNadir[BANDS_PER_ANT],
264  UShort_t tupperWords[ACTIVE_SURFS],
265  UShort_t tscaler[ACTIVE_SURFS][SCALERS_PER_SURF],
266  UShort_t tthreshold[ACTIVE_SURFS][SCALERS_PER_SURF],
267  UShort_t tsetThreshold[ACTIVE_SURFS][SCALERS_PER_SURF],
268  UShort_t trfPower[ACTIVE_SURFS][RFCHAN_PER_SURF],
269  UShort_t tsurfTrigBandMask[ACTIVE_SURFS],
270  Int_t tintFlag)
271 {
272 
273  run=trun;
274  realTime=trealTime;
275  payloadTime=tpayloadTime;
276  payloadTimeUs=tpayloadTimeUs;
277  globalThreshold=tglobalThreshold;
278  errorFlag=terrorFlag;
279  memcpy(scalerGoals,tscalerGoals,sizeof(UShort_t)*BANDS_PER_ANT);
280  memcpy(scalerGoalsNadir,tscalerGoalsNadir,sizeof(UShort_t)*BANDS_PER_ANT);
281  memcpy(upperWords,tupperWords,sizeof(UShort_t)*ACTIVE_SURFS);
282  memcpy(scaler,tscaler,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
283  memcpy(threshold,tthreshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
284  memcpy(setThreshold,tsetThreshold,sizeof(UShort_t)*ACTIVE_SURFS*SCALERS_PER_SURF);
285  memcpy(rfPower,trfPower,sizeof(UShort_t)*ACTIVE_SURFS*RFCHAN_PER_SURF);
286  memcpy(surfTrigBandMask,tsurfTrigBandMask,sizeof(UShort_t)*ACTIVE_SURFS);
287  intFlag=tintFlag;
288 
289 }
290 
291 Int_t SurfHk::getL1Scaler(int phi, AnitaPol::AnitaPol_t pol, AnitaRing::AnitaRing_t ring)
292 {
293  Int_t surf, l1Scl;
294 
295  if (AnitaVersion::get() == 4)
296  AnitaGeomTool::getSurfL1TriggerChanFromPhiRing(phi,ring,surf,l1Scl);
297  else
298  AnitaGeomTool::getSurfL1TriggerChanFromPhiPol(phi,pol,surf,l1Scl);
299 
300  if((surf>=0 && surf<ACTIVE_SURFS) && (l1Scl>=0 && l1Scl<L1S_PER_SURF)) {
301  return l1Scaler[surf][l1Scl];
302  }
303  return -1;
304 }
305 
306 
307 Int_t SurfHk::getL2Scaler(int phi)
308 {
309  if (AnitaVersion::get() == 3) return -1;
310 
311  Int_t surf, l2Scl;
312  AnitaGeomTool::getSurfL2TriggerChanFromPhi(phi,surf,l2Scl);
313  if((surf>=0 && surf<ACTIVE_SURFS) && (l2Scl>=0 && l2Scl<L2S_PER_SURF)) {
314  return l2Scaler[surf][l2Scl];
315  }
316  return -1;
317 }
318 
319 
320 
321 Int_t SurfHk::getScaler(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
322 {
323  Int_t surf,scl;
324  AnitaGeomTool::getSurfChanTriggerFromPhiRingPol(phi,ring,pol,surf,scl);
325  if((surf>=0 && surf<ACTIVE_SURFS) && (scl>=0 && scl<SCALERS_PER_SURF))
326  return scaler[surf][scl];
327  return -1;
328 }
329 
330 Int_t SurfHk::getThreshold(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
331 {
332  Int_t surf,scl;
333  AnitaGeomTool::getSurfChanTriggerFromPhiRingPol(phi,ring,pol,surf,scl);
334  if((surf>=0 && surf<ACTIVE_SURFS) && (scl>=0 && scl<SCALERS_PER_SURF))
335  return threshold[surf][scl];
336  return -1;
337 
338 }
339 
340 Int_t SurfHk::getSetThreshold(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
341 {
342  Int_t surf,scl;
343  AnitaGeomTool::getSurfChanTriggerFromPhiRingPol(phi,ring,pol,surf,scl);
344  if((surf>=0 && surf<ACTIVE_SURFS) && (scl>=0 && scl<SCALERS_PER_SURF))
345  return setThreshold[surf][scl];
346  return -1;
347 }
348 
349 
350 Int_t SurfHk::isMasked(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
351 {
352  Int_t surf,scl;
353  AnitaGeomTool::getSurfChanTriggerFromPhiRingPol(phi,ring,pol,surf,scl);
354  if((surf>=0 && surf<ACTIVE_SURFS) && (scl>=0 && scl<SCALERS_PER_SURF))
355  return isBandMasked(surf,scl);
356  return -1;
357 }
358 
359 Int_t SurfHk::getLogicalIndex(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
360 {
361  Int_t surf,scl;
362  AnitaGeomTool::getSurfChanTriggerFromPhiRingPol(phi,ring,pol,surf,scl);
363  return scl +surf*SCALERS_PER_SURF;
364 }
365 
366 Int_t SurfHk::getScalerGoalRing(AnitaRing::AnitaRing_t ring)
367 {
368  return scalerGoals[ring];
369 }
370 
371 Int_t SurfHk::getScalerGoal(int surf, int scl)
372 {
373  Int_t phi=-1;
374  AnitaRing::AnitaRing_t ring=AnitaRing::kTopRing;
375  AnitaTrigPol::AnitaTrigPol_t pol=AnitaTrigPol::kLCP;
376 
377  AnitaGeomTool::getPhiRingPolFromSurfChanTrigger(surf,scl,phi,ring,pol);
378  return getScalerGoalRing(ring);
379 }
380 
381 Double_t SurfHk::getRFPowerInK(int surf, int chan)
382 {
383  if(surf<0 || surf>=ACTIVE_SURFS)
384  return -1;
385  if(chan<0 || chan>=RFCHAN_PER_SURF)
386  return -1;
387  Int_t adc=rfPower[surf][chan]&0x7fff
388 ;
389  if(adc==0) return 290;
390 
391  Double_t kelvin=AnitaEventCalibrator::Instance()->convertRfPowToKelvin(surf,chan,adc);
392  if(TMath::IsNaN(kelvin)) return 290;
393  if(kelvin<0) return 290;
394  if(kelvin>1e6) return 290;
395  return kelvin;
396 }
397 
398 
399 // Double_t SurfHk::getMeasuredRFPowerInK(int surf, int chan)
400 // {
401 // if(surf<0 || surf>=ACTIVE_SURFS)
402 // return -1;
403 // if(chan<0 || chan>=RFCHAN_PER_SURF)
404 // return -1;
405 // Int_t adc=rfPower[surf][chan];
406 // Double_t kelvin=AnitaEventCalibrator::Instance()->convertRfPowToKelvinMeasured(surf,chan,adc);
407 // return kelvin;
408 // }
409 
410 Double_t SurfHk::getRawRFPower(int surf, int chan)
411 {
412  if(surf<0 || surf>=ACTIVE_SURFS)
413  return -1;
414  if(chan<0 || chan>=RFCHAN_PER_SURF)
415  return -1;
416  UShort_t adc=rfPower[surf][chan]&0x7FFF; //mask off top bit
417  return adc;
418 }
419 
420 UInt_t SurfHk::getRFPowerTimeOffset(int surf, int chan)
421 {
422 
423  if(surf<0 || surf>=ACTIVE_SURFS)
424  return -1;
425  if(chan<0 || chan>=RFCHAN_PER_SURF)
426  return -1;
427 
428  int zeroPhaseChan = 0;
429  UInt_t startPhase = rfPower[surf][0]&0x8000;
430  for (int chani =0; chani<=RFCHAN_PER_SURF; chani++) {
431  if ((rfPower[surf][chani]&0x8000) != startPhase) {
432  zeroPhaseChan = chani;
433  break;
434  }
435  }
436  UInt_t PhaseOffset = 0;
437  if (chan < zeroPhaseChan) {
438  PhaseOffset = zeroPhaseChan - chan; }
439  if (chan >= zeroPhaseChan) {
440  PhaseOffset = (zeroPhaseChan+8) - chan; }
441 
442  return PhaseOffset;
443 
444 }
445 
446 UInt_t SurfHk::getRFPowerPayloadTime(UInt_t surf, UInt_t chan)
447 {
448  if( surf>=ACTIVE_SURFS)
449  return -1;
450  if( chan>=RFCHAN_PER_SURF)
451  return -1;
452 
453  UInt_t zeroPhaseChan = 0;
454  UInt_t startPhase = rfPower[surf][0]&0x8000;
455  for (UInt_t chani =0; chani<=RFCHAN_PER_SURF; chani++) {
456  if ((rfPower[surf][chani]&0x8000) != startPhase) {
457  zeroPhaseChan = chani;
458  break;
459  }
460  }
461  UInt_t PhaseOffset = 0;
462  if (chan < zeroPhaseChan) {
463  PhaseOffset = zeroPhaseChan - chan; }
464  if (chan >= zeroPhaseChan) {
465  PhaseOffset = (zeroPhaseChan+8) - chan;}
466 
467  if (payloadTimeUs < 12500*PhaseOffset) {
468  return payloadTime - 1;}
469  else {
470  return payloadTime;}
471 
472 }
473 
474 UInt_t SurfHk::getRFPowerPayloadTimeUs(UInt_t surf, UInt_t chan)
475 {
476  if(surf>=ACTIVE_SURFS)
477  return -1;
478  if(chan>=RFCHAN_PER_SURF)
479  return -1;
480 
481  UInt_t zeroPhaseChan = 0;
482  UInt_t startPhase = rfPower[surf][0]&0x8000;
483  for (UInt_t chani=0; chani<=RFCHAN_PER_SURF; chani++) {
484  if ((rfPower[surf][chani]&0x8000) != startPhase) {
485  zeroPhaseChan = chani;
486  break;
487  }
488  }
489  UInt_t PhaseOffset = 0;
490  if (chan < zeroPhaseChan) {
491  PhaseOffset = zeroPhaseChan - chan; }
492  if (chan >= zeroPhaseChan) {
493  PhaseOffset = (zeroPhaseChan+8) - chan;}
494 
495  if (payloadTimeUs < 12500*PhaseOffset) {
496  return (1e6-12500*PhaseOffset)+payloadTimeUs; }
497  else {
498  return payloadTimeUs+PhaseOffset; }
499 
500  return 0;
501 }
FullSurfHkStructVer13_t
Definition: oldStructs.h:267
SurfHk::scalerGoals
UShort_t scalerGoals[4]
Scaler goal for each ring, only use 3.
Definition: SurfHk.h:59
FullSurfHkStructVer40_t
Definition: oldStructs.h:232
AnitaGeomTool::getSurfL2TriggerChanFromPhi
static Int_t getSurfL2TriggerChanFromPhi(Int_t phi, Int_t &surf, Int_t &l2Chan)
Converts phi-sector to surf and l2 trigger channel.
Definition: AnitaGeomTool.cxx:411
SurfHk::intFlag
Int_t intFlag
Interpolation flag, should be zero for raw data.
Definition: SurfHk.h:69
FullSurfHkStructVer12_t
Definition: oldStructs.h:250
SurfHk::SurfHk
SurfHk()
Default constructor.
Definition: SurfHk.cxx:20
SurfHk::scalerGoalsNadir
UShort_t scalerGoalsNadir[4]
Deprecated.
Definition: SurfHk.h:60
SurfHk::l2Scaler
UShort_t l2Scaler[12][2]
L2 Scaler values.
Definition: SurfHk.h:64
SurfHk::l1Scaler
UShort_t l1Scaler[12][6]
L1 Scaler values.
Definition: SurfHk.h:63
FullSurfHkStructVer30_t::scalerGoalsNadir
unsigned short scalerGoalsNadir[4]
What are we aiming for with the scaler rate.
Definition: oldStructs.h:309
AnitaEventCalibrator::Instance
static AnitaEventCalibrator * Instance(int version=0)
Instance generator.
Definition: AnitaEventCalibrator.cxx:67
SurfHk::surfTrigBandMask
UShort_t surfTrigBandMask[12]
Which bands are masked off?
Definition: SurfHk.h:68
SurfHk::getThreshold
Int_t getThreshold(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns readback threhsold value for given ring-phi-pol.
Definition: SurfHk.cxx:330
AnitaTrigPol::kLCP
Left-circular polarisation (e.g. A4)
Definition: AnitaConventions.h:211
FullSurfHkStructVer14_t::errorFlag
unsigned short errorFlag
Will define at some point.
Definition: oldStructs.h:287
AnitaGeomTool::getPhiRingPolFromSurfChanTrigger
static Int_t getPhiRingPolFromSurfChanTrigger(Int_t surf, Int_t chan, Int_t &phi, AnitaRing::AnitaRing_t &ring, AnitaTrigPol::AnitaTrigPol_t &pol)
Converts the SURF and channel numbers to phi-sector, ring and polarization.
Definition: AnitaGeomTool.cxx:261
PACKET_SURF_HK
FullSurfHkStruct_t –Yes.
Definition: simpleStructs.h:205
SurfHk::realTime
UInt_t realTime
Time in unixTime.
Definition: SurfHk.h:54
SurfHk::getRawRFPower
Double_t getRawRFPower(int surf, int chan)
Returns the measured adc value of the RF power while masking the top bit (the "phase" bit) ...
Definition: SurfHk.cxx:410
SurfHk::getL2Scaler
Int_t getL2Scaler(int phi)
Returns the L2 scaler value for given phi-pol.
Definition: SurfHk.cxx:307
SurfHk::getRFPowerInK
Double_t getRFPowerInK(int surf, int chan)
Returns the pseudo-calibrated RF power in K.
Definition: SurfHk.cxx:381
SurfHk::getSetThreshold
Int_t getSetThreshold(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns set threshold value for given ring-phi-pol.
Definition: SurfHk.cxx:340
FullSurfHkStructVer30_t::errorFlag
unsigned short errorFlag
Will define at some point.
Definition: oldStructs.h:307
SurfHk::upperWords
UShort_t upperWords[12]
Upper words of each SURF... for debugging.
Definition: SurfHk.h:61
SurfHk
SurfHk – The raw SURF scaler+threshold data.
Definition: SurfHk.h:24
SurfHk::payloadTimeUs
UInt_t payloadTimeUs
Subsecond time of readout in us.
Definition: SurfHk.h:56
FullSurfHkStructVer30_t
SURF Hk – Telemetered.
Definition: oldStructs.h:302
FullSurfHkStruct_t::scalerGoals
unsigned short scalerGoals[3]
What are we aiming for with the scaler rate.
Definition: simpleStructs.h:1191
FullSurfHkStruct_t::errorFlag
unsigned short errorFlag
Will define at some point.
Definition: simpleStructs.h:1190
AnitaRing::AnitaRing_t
enum AnitaRing::EAnitaRing AnitaRing_t
Ring enumeration.
AnitaTrigPol::AnitaTrigPol_t
enum AnitaTrigPol::EAnitaTrigPol AnitaTrigPol_t
Polarisation enumeration.
packetCodeAsString
const char * packetCodeAsString(PacketCode_t code)
packetCodeAsString – utility function
Definition: AnitaPacketUtil.cxx:223
FullSurfHkStructVer14_t::scalerGoals
unsigned short scalerGoals[4]
What are we aiming for with the scaler rate.
Definition: oldStructs.h:288
SurfHk::getL1Scaler
Int_t getL1Scaler(int phi, AnitaPol::AnitaPol_t pol, AnitaRing::AnitaRing_t ring)
Returns the L1 scaler value for given phi-ring-pol.
Definition: SurfHk.cxx:291
SurfHk::globalThreshold
UShort_t globalThreshold
Global threshold if set.
Definition: SurfHk.h:57
FullSurfHkStructVer14_t::globalThreshold
unsigned short globalThreshold
set to zero if there isn&#39;t one
Definition: oldStructs.h:286
FullSurfHkStruct_t::globalThreshold
unsigned short globalThreshold
set to zero if there isn&#39;t one
Definition: simpleStructs.h:1189
AnitaGeomTool::getSurfL1TriggerChanFromPhiRing
static Int_t getSurfL1TriggerChanFromPhiRing(Int_t phi, AnitaRing::AnitaRing_t ring, Int_t &surf, Int_t &l1Chan)
Convert phi-sector and polarization from phi-sector and polarization.
Definition: AnitaGeomTool.cxx:356
SurfHk::setThreshold
UShort_t setThreshold[12][16]
Threshold values intedned, should match threshold array exactly.
Definition: SurfHk.h:66
SurfHk::scaler
UShort_t scaler[12][16]
Scaler values, multiple by 1000 to get Hz.
Definition: SurfHk.h:62
SurfHk::errorFlag
UShort_t errorFlag
Error flag.
Definition: SurfHk.h:58
SurfHk::isMasked
Int_t isMasked(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns 1 if given phi-ring-pol is masked.
Definition: SurfHk.cxx:350
FullSurfHkStructVer14_t
Definition: oldStructs.h:282
AnitaGeomTool::getSurfChanTriggerFromPhiRingPol
static Int_t getSurfChanTriggerFromPhiRingPol(Int_t phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol, Int_t &surf, Int_t &chan)
Converts the SURF and L1 trigger channel to phi-sector and polarization.
Definition: AnitaGeomTool.cxx:329
FullSurfHkStructVer40_t::errorFlag
unsigned short errorFlag
Will define at some point.
Definition: oldStructs.h:237
SurfHk::getLogicalIndex
Int_t getLogicalIndex(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns logical pol index.
Definition: SurfHk.cxx:359
FullSurfHkStructVer14_t::scalerGoalsNadir
unsigned short scalerGoalsNadir[4]
What are we aiming for with the scaler rate.
Definition: oldStructs.h:289
SurfHk::~SurfHk
~SurfHk()
Destructor.
Definition: SurfHk.cxx:25
SurfHk::getScaler
Int_t getScaler(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns scaler value for given ring-phi-pol.
Definition: SurfHk.cxx:321
FullSurfHkStructVer30_t::scalerGoals
unsigned short scalerGoals[4]
What are we aiming for with the scaler rate.
Definition: oldStructs.h:308
FullSurfHkStructVer30_t::globalThreshold
unsigned short globalThreshold
set to zero if there isn&#39;t one
Definition: oldStructs.h:306
FullSurfHkStructVer40_t::globalThreshold
unsigned short globalThreshold
set to zero if there isn&#39;t one
Definition: oldStructs.h:236
FullSurfHkStructVer40_t::scalerGoals
unsigned short scalerGoals[3]
What are we aiming for with the scaler rate.
Definition: oldStructs.h:238
SurfHk::rfPower
UShort_t rfPower[12][8]
RF power per input channel in ADC counts.
Definition: SurfHk.h:67
AnitaPol::AnitaPol_t
enum AnitaPol::EAnitaPol AnitaPol_t
Polarisation enumeration.
SurfHk::getScalerGoal
Int_t getScalerGoal(int surf, int scl)
Returns scaler goal of surf-scaler.
Definition: SurfHk.cxx:371
FullSurfHkStruct_t
SURF Hk – Telemetered.
Definition: simpleStructs.h:1185
SurfHk::isBandMasked
Int_t isBandMasked(int surf, int scl)
Returns 1 if band is masked.
Definition: SurfHk.h:71
SurfHk::run
Int_t run
Run number from offline.
Definition: SurfHk.h:53
SurfHk::threshold
UShort_t threshold[12][16]
Threshold values in DAC counts.
Definition: SurfHk.h:65
SurfHk::payloadTime
UInt_t payloadTime
Time in unixTime.
Definition: SurfHk.h:55
simplePacketCheck
int simplePacketCheck(GenericHeader_t *gHdr, PacketCode_t code)
simplePacketCheck – utility function
Definition: AnitaPacketUtil.cxx:13
Generated on Tue Mar 23 2021 12:52:27 for ANITA Software by   doxygen 1.8.14