← Back to branch summary

~ajdobbs/maus/event-selection

« back to all changes in this revision

Viewing changes to src/common_cpp/DataStructure/DAQData.cc

  • Committer: Yordan Karadzhov
  • Date: 2016-07-01 11:05:05 UTC
  • Revision ID: yordan.karadzhov@cern.ch-20160701110505-6c8a0osghvnwffjy
EpicsInterface and TriggerEngine are added to the Data structure.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common_cpp/DataStructure/DAQData.cc
20
20
namespace MAUS {
21
21
 
22
22
DAQData::DAQData()
23
 
    : _event_size(0), _V830(), _trigger_request(), _tof1(), _ckov(), _tof2(), _unknown(),
24
 
      _kl(), _tag(), _tof0(), _trigger(), _emr(), _tracker0(), _tracker1() {
 
23
  : _event_size(0), _tr_engine(), _ei(), _V830(), _trigger_request(), _tof1(), _ckov(), _tof2(),
 
24
    _unknown(), _kl(), _tag(), _tof0(), _trigger(), _emr(), _tracker0(), _tracker1() {
25
25
}
26
26
 
27
27
DAQData::DAQData(const DAQData& daqdata)
28
 
    : _event_size(0), _V830(), _trigger_request(), _tof1(), _ckov(), _tof2(), _unknown(),
29
 
      _kl(), _tag(), _tof0(), _trigger(), _emr(), _tracker0(), _tracker1() {
30
 
    *this = daqdata;
 
28
  : _event_size(0), _tr_engine(), _ei(), _V830(), _trigger_request(), _tof1(), _ckov(), _tof2(),
 
29
    _unknown(), _kl(), _tag(), _tof0(), _trigger(), _emr(), _tracker0(), _tracker1() {
 
30
  *this = daqdata;
31
31
}
32
32
 
33
33
DAQData& DAQData::operator=(const DAQData& daqdata) {
34
 
    using DAQDataHelper::VectorDeepcopy;
35
 
    if (this == &daqdata) {
36
 
        return *this;
37
 
    }
38
 
    _event_size = daqdata._event_size;
39
 
    SetV830(daqdata._V830);
40
 
    SetTriggerRequestArray(VectorDeepcopy<>(daqdata._trigger_request));
41
 
    SetTOF1DaqArray(VectorDeepcopy<>(daqdata._tof1));
42
 
    SetCkovArray(VectorDeepcopy<>(daqdata._ckov));
43
 
    SetTOF2DaqArray(VectorDeepcopy<>(daqdata._tof2));
44
 
    SetUnknownArray(VectorDeepcopy<>(daqdata._unknown));
45
 
    SetKLArray(VectorDeepcopy<>(daqdata._kl));
46
 
    SetTagArray(VectorDeepcopy<>(daqdata._tag));
47
 
    SetTOF0DaqArray(VectorDeepcopy<>(daqdata._tof0));
48
 
    SetTriggerArray(VectorDeepcopy<>(daqdata._trigger));
49
 
    SetEMRDaq(daqdata._emr);
50
 
    SetTracker0DaqArray(VectorDeepcopy<>(daqdata._tracker0));
51
 
    SetTracker1DaqArray(VectorDeepcopy<>(daqdata._tracker1));
 
34
  using DAQDataHelper::VectorDeepcopy;
 
35
  if (this == &daqdata) {
 
36
      return *this;
 
37
  }
 
38
  _event_size = daqdata._event_size;
 
39
  SetV830(daqdata._V830);
 
40
  SetTriggerEngine(daqdata._tr_engine);
 
41
  SetEpicsInterface(daqdata._ei);
 
42
  SetTriggerRequestArray(VectorDeepcopy<>(daqdata._trigger_request));
 
43
  SetTOF1DaqArray(VectorDeepcopy<>(daqdata._tof1));
 
44
  SetCkovArray(VectorDeepcopy<>(daqdata._ckov));
 
45
  SetTOF2DaqArray(VectorDeepcopy<>(daqdata._tof2));
 
46
  SetUnknownArray(VectorDeepcopy<>(daqdata._unknown));
 
47
  SetKLArray(VectorDeepcopy<>(daqdata._kl));
 
48
  SetTagArray(VectorDeepcopy<>(daqdata._tag));
 
49
  SetTOF0DaqArray(VectorDeepcopy<>(daqdata._tof0));
 
50
  SetTriggerArray(VectorDeepcopy<>(daqdata._trigger));
 
51
  SetEMRDaq(daqdata._emr);
 
52
  SetTracker0DaqArray(VectorDeepcopy<>(daqdata._tracker0));
 
53
  SetTracker1DaqArray(VectorDeepcopy<>(daqdata._tracker1));
52
54
 
53
 
    return *this;
 
55
  return *this;
54
56
}
55
57
 
56
58
DAQData::~DAQData() {
57
 
    SetTriggerRequestArray(TriggerRequestArray());
58
 
    SetTOF1DaqArray(TOF1DaqArray());
59
 
    SetCkovArray(CkovArray());
60
 
    SetTOF2DaqArray(TOF2DaqArray());
61
 
    SetUnknownArray(UnknownArray());
62
 
    SetKLArray(KLArray());
63
 
    SetTagArray(TagArray());
64
 
    SetTOF0DaqArray(TOF0DaqArray());
65
 
    SetTriggerArray(TriggerArray());
66
 
    SetTracker0DaqArray(Tracker0DaqArray());
67
 
    SetTracker1DaqArray(Tracker1DaqArray());
 
59
  SetTriggerRequestArray(TriggerRequestArray());
 
60
  SetTOF1DaqArray(TOF1DaqArray());
 
61
  SetCkovArray(CkovArray());
 
62
  SetTOF2DaqArray(TOF2DaqArray());
 
63
  SetUnknownArray(UnknownArray());
 
64
  SetKLArray(KLArray());
 
65
  SetTagArray(TagArray());
 
66
  SetTOF0DaqArray(TOF0DaqArray());
 
67
  SetTriggerArray(TriggerArray());
 
68
  SetTracker0DaqArray(Tracker0DaqArray());
 
69
  SetTracker1DaqArray(Tracker1DaqArray());
68
70
}
69
71
 
70
72
unsigned int DAQData::GetEventSize() const {
71
 
    return _event_size;
 
73
  return _event_size;
72
74
}
73
75
 
74
76
void DAQData::SetEventSize(unsigned int size) {
75
 
    _event_size = size;
 
77
  _event_size = size;
76
78
}
77
79
 
78
80
V830 DAQData::GetV830() const {
79
 
    return _V830;
 
81
  return _V830;
80
82
}
81
83
 
82
84
void DAQData::SetV830(V830 V830) {
83
 
    _V830 = V830;
 
85
  _V830 = V830;
 
86
}
 
87
 
 
88
TriggerEngine DAQData::GetTriggerEngine() const {
 
89
  return _tr_engine;
 
90
}
 
91
 
 
92
TriggerEngine* DAQData::GetTriggerEnginePtr() {
 
93
  return &_tr_engine;
 
94
}
 
95
 
 
96
void DAQData::SetTriggerEngine(TriggerEngine tr) {
 
97
  _tr_engine = tr;
84
98
}
85
99
 
86
100
TriggerRequestArray DAQData::GetTriggerRequestArray() const {
87
 
    return _trigger_request;
 
101
  return _trigger_request;
88
102
}
89
103
 
90
104
TriggerRequestArray* DAQData::GetTriggerRequestArrayPtr() {
91
 
    return &_trigger_request;
 
105
  return &_trigger_request;
92
106
}
93
107
 
94
108
TriggerRequest* DAQData::GetTriggerRequestArrayElement(size_t index) const {
95
 
    return _trigger_request[index];
 
109
  return _trigger_request[index];
96
110
}
97
111
 
98
112
size_t DAQData::GetTriggerRequestArraySize() const {
99
 
    return _trigger_request.size();
 
113
  return _trigger_request.size();
100
114
}
101
115
 
102
116
void DAQData::SetTriggerRequestArray(TriggerRequestArray trigger_request) {
103
 
    for (size_t i = 0; i < _trigger_request.size(); ++i) {
104
 
        if (_trigger_request[i] != NULL) {
105
 
            delete _trigger_request[i];
106
 
        }
 
117
  for (size_t i = 0; i < _trigger_request.size(); ++i) {
 
118
    if (_trigger_request[i] != NULL) {
 
119
      delete _trigger_request[i];
107
120
    }
108
 
    _trigger_request = trigger_request;
 
121
  }
 
122
  _trigger_request = trigger_request;
109
123
}
110
124
 
111
125
TOF1DaqArray DAQData::GetTOF1DaqArray() const {
112
 
    return _tof1;
 
126
  return _tof1;
113
127
}
114
128
 
115
129
TOF1DaqArray* DAQData::GetTOF1DaqArrayPtr() {
116
 
    return &_tof1;
 
130
  return &_tof1;
117
131
}
118
132
 
119
133
TOFDaq* DAQData::GetTOF1DaqArrayElement(size_t index) const {
120
 
    return _tof1[index];
 
134
  return _tof1[index];
121
135
}
122
136
 
123
137
size_t DAQData::GetTOF1DaqArraySize() const {
124
 
    return _tof1.size();
 
138
  return _tof1.size();
125
139
}
126
140
 
127
141
void DAQData::SetTOF1DaqArray(TOF1DaqArray tof1) {
128
 
    for (size_t i = 0; i < _tof1.size(); ++i) {
129
 
        if (_tof1[i] != NULL) {
130
 
            delete _tof1[i];
131
 
        }
 
142
  for (size_t i = 0; i < _tof1.size(); ++i) {
 
143
    if (_tof1[i] != NULL) {
 
144
      delete _tof1[i];
132
145
    }
133
 
    _tof1 = tof1;
 
146
  }
 
147
  _tof1 = tof1;
134
148
}
135
149
 
136
150
CkovArray DAQData::GetCkovArray() const {
137
 
    return _ckov;
 
151
  return _ckov;
138
152
}
139
153
 
140
154
CkovArray* DAQData::GetCkovArrayPtr() {
141
 
    return &_ckov;
 
155
  return &_ckov;
142
156
}
143
157
 
144
158
CkovDaq* DAQData::GetCkovArrayElement(size_t index) const {
145
 
    return _ckov[index];
 
159
  return _ckov[index];
146
160
}
147
161
 
148
162
size_t DAQData::GetCkovArraySize() const {
149
 
    return _ckov.size();
 
163
  return _ckov.size();
150
164
}
151
165
 
152
166
void DAQData::SetCkovArray(CkovArray ckov) {
295
309
}
296
310
 
297
311
size_t DAQData::GetTagArraySize() const {
298
 
    return _tag.size();
 
312
  return _tag.size();
299
313
}
300
314
 
301
315
void DAQData::SetTagArray(TagArray tag) {
302
 
    for (size_t i = 0; i < _tag.size(); ++i) {
303
 
        if (_tag[i] != NULL) {
304
 
            delete _tag[i];
305
 
        }
 
316
  for (size_t i = 0; i < _tag.size(); ++i) {
 
317
    if (_tag[i] != NULL) {
 
318
       delete _tag[i];
306
319
    }
307
 
    _tag = tag;
 
320
  }
 
321
  _tag = tag;
308
322
}
309
323
 
310
324
TOF0DaqArray DAQData::GetTOF0DaqArray() const {
311
 
    return _tof0;
 
325
  return _tof0;
312
326
}
313
327
 
314
328
TOF0DaqArray* DAQData::GetTOF0DaqArrayPtr() {
315
 
    return &_tof0;
 
329
  return &_tof0;
316
330
}
317
331
 
318
332
TOFDaq* DAQData::GetTOF0DaqArrayElement(size_t index) const {
319
 
    return _tof0[index];
 
333
  return _tof0[index];
320
334
}
321
335
 
322
336
size_t DAQData::GetTOF0DaqArraySize() const {
323
 
    return _tof0.size();
 
337
  return _tof0.size();
324
338
}
325
339
 
326
340
void DAQData::SetTOF0DaqArray(TOF0DaqArray tof0) {
327
 
    for (size_t i = 0; i < _tof0.size(); ++i) {
328
 
        if (_tof0[i] != NULL) {
329
 
            delete _tof0[i];
330
 
        }
 
341
  for (size_t i = 0; i < _tof0.size(); ++i) {
 
342
    if (_tof0[i] != NULL) {
 
343
      delete _tof0[i];
331
344
    }
332
 
    _tof0 = tof0;
 
345
  }
 
346
  _tof0 = tof0;
333
347
}
334
348
 
335
349
TriggerArray DAQData::GetTriggerArray() const {
336
 
    return _trigger;
 
350
  return _trigger;
337
351
}
338
352
 
339
353
TriggerArray* DAQData::GetTriggerArrayPtr() {
340
 
    return &_trigger;
 
354
  return &_trigger;
341
355
}
342
356
 
343
357
Trigger* DAQData::GetTriggerArrayElement(size_t index) const {
344
 
    return _trigger[index];
 
358
  return _trigger[index];
345
359
}
346
360
 
347
361
size_t DAQData::GetTriggerArraySize() const {
348
 
    return _trigger.size();
 
362
  return _trigger.size();
349
363
}
350
364
 
351
365
void DAQData::SetTriggerArray(TriggerArray trigger) {
352
 
    for (size_t i = 0; i < _trigger.size(); ++i) {
353
 
        if (_trigger[i] != NULL) {
354
 
            delete _trigger[i];
355
 
        }
 
366
  for (size_t i = 0; i < _trigger.size(); ++i) {
 
367
    if (_trigger[i] != NULL) {
 
368
      delete _trigger[i];
356
369
    }
357
 
    _trigger = trigger;
 
370
  }
 
371
  _trigger = trigger;
358
372
}
359
373
 
360
374
EMRDaq DAQData::GetEMRDaq() const {
361
 
    return _emr;
 
375
  return _emr;
362
376
}
363
377
 
364
378
EMRDaq* DAQData::GetEMRDaqPtr() {
366
380
}
367
381
 
368
382
void DAQData::SetEMRDaq(EMRDaq emr) {
369
 
    _emr = emr;
 
383
  _emr = emr;
 
384
}
 
385
 
 
386
EpicsInterface DAQData::GetEpicsInterface() const {
 
387
  return _ei;
 
388
}
 
389
 
 
390
EpicsInterface* DAQData::GetEpicsInterfacePtr() {
 
391
  return &_ei;
 
392
}
 
393
 
 
394
void DAQData::SetEpicsInterface(EpicsInterface ei) {
 
395
  _ei = ei;
370
396
}
371
397
}
372
398