GRSISort "v4.0.0.5"
An extension of the ROOT analysis Framework
Loading...
Searching...
No Matches
TTigress.cxx
Go to the documentation of this file.
1#include "TTigress.h"
2
3#include <iostream>
4
5#include "TRandom.h"
6#include "TClass.h"
7#include "TInterpreter.h"
8
9#include "TGRSIOptions.h"
10#include "TSortingDiagnostics.h"
11#include "TMnemonic.h"
12
13double TTigress::fTargetOffset = 0.;
14double TTigress::fRadialOffset = 0.;
15
16TTransientBits<UShort_t> TTigress::fGlobalTigressBits(ETigressGlobalBits::kSetCoreWave | ETigressGlobalBits::kSetBGOHits);
17
18// Why arent these TTigress class functions?
19bool DefaultAddback(TDetectorHit* one, TDetectorHit* two)
20{
21 // fHits vector is sorted by descending energy during detector construction
22 // Assumption for crystals and segments: higher energy = first interaction
23 // Checking for Scattering FROM "one" TO "two"
24
25 if(std::abs(one->GetTime() - two->GetTime()) < TGRSIOptions::AnalysisOptions()->AddbackWindow()) {
26 // segments of crystals have been sorted by descending energy during detector construction
27 // LastPosition is the position of lowest energy segment and GetPosition the highest energy segment (assumed
28 // first)
29 // Both return core position if no segments
30 double res = (static_cast<TTigressHit*>(one)->GetLastPosition() - static_cast<TTigressHit*>(two)->GetPosition()).Mag();
31
32 // In clover core separation 54.2564, 76.7367
33 // Between clovers core separation 74.2400 91.9550 (high-eff mode)
34 double seperation_limit = 93;
35
36 // Important to avoid GetSegmentVec segfaults for no segment or when we have cores only efficiency calibration
37 if(static_cast<TTigressHit*>(one)->GetSegmentMultiplicity() > 0 && static_cast<TTigressHit*>(two)->GetSegmentMultiplicity() > 0 && !TTigress::GetForceCrystal()) {
38 int one_seg = static_cast<TTigressHit*>(one)->GetSegmentVec().back().GetSegment();
39 int two_seg = static_cast<TTigressHit*>(two)->GetSegmentVec().front().GetSegment();
40
41 // front segment to front segment OR back segment to back segment
42 if((one_seg < 5 && two_seg < 5) || (one_seg > 4 && two_seg > 4)) {
43 seperation_limit = 54;
44 // front to back
45 } else if((one_seg < 5 && two_seg > 4) || (one_seg > 4 && two_seg < 5)) {
46 seperation_limit = 105;
47 }
48 }
49
50 if(res < seperation_limit) {
51 return true;
52 }
53 }
54
55 return false;
56}
57
58std::function<bool(TDetectorHit*, TDetectorHit*)> TTigress::fAddbackCriterion = DefaultAddback;
59
60bool DefaultSuppression(TDetectorHit* tig, TBgoHit& bgo)
61{
62 Float_t dCfd = static_cast<TTigressHit*>(tig)->GetCfd() - bgo.GetCfd();
63 return ((dCfd > -300. && dCfd < 200.) && (tig->GetDetector() == bgo.GetDetector()) && (bgo.GetEnergy() > 0));
64 // The old Suppression doesn't really work, the time gate is bad in GRIF-16s and the suppression scheme gives a bad Peak:Total - S. Gillespie
65
66 // return ((dCfd > -400 && dCfd < -80) && (tig->GetDetector() == bgo.GetDetector()) && (bgo.GetCharge() > 100.) &&
67 // TTigress::BGOSuppression[tig->GetCrystal()][bgo.GetCrystal()][bgo.GetSegment() - 1]);
68}
69
70std::function<bool(TDetectorHit*, TBgoHit&)> TTigress::fSuppressionCriterion = DefaultSuppression;
71
72std::underlying_type_t<TTigress::ETigressGlobalBits> operator|(TTigress::ETigressGlobalBits lhs, TTigress::ETigressGlobalBits rhs)
73{
74 return static_cast<std::underlying_type_t<TTigress::ETigressGlobalBits>>(lhs) |
75 static_cast<std::underlying_type_t<TTigress::ETigressGlobalBits>>(rhs);
76}
77
78TTigress::TTigress()
79{
80 Clear();
81}
82
83TTigress::TTigress(const TTigress& rhs) : TDetector(rhs)
84{
85 rhs.Copy(*this);
86}
87
88void TTigress::Copy(TObject& rhs) const
89{
90 TDetector::Copy(rhs);
91 // to copy the hits without creating a memory leak we need to check
92 // if the right-hand side has more hits than this
93 // if so, we need to delete the hits pointed to by the right-hand side
94 auto& addbackHits = static_cast<TTigress&>(rhs).fAddbackHits;
95 if(addbackHits.size() > fAddbackHits.size()) {
96 for(size_t i = fAddbackHits.size(); i < addbackHits.size(); ++i) {
97 delete addbackHits[i];
98 }
99 addbackHits.resize(fAddbackHits.size());
100 } else if(addbackHits.size() < fAddbackHits.size()) {
101 // right-hand side has less hits, that means there is at least one we can use to determine the type
102 // we need to use IsA()->New() to make a new hit of whatever derived type this actually is
103 addbackHits.resize(fAddbackHits.size(), static_cast<TDetectorHit*>(fAddbackHits[0]->IsA()->New()));
104 }
105 // we have now ensured that the size of the two vectors is the same, so we can copy the contents of the hits
106 for(size_t i = 0; i < fAddbackHits.size(); ++i) {
107 fAddbackHits[i]->Copy(*(addbackHits[i]), true);
108 }
109 static_cast<TTigress&>(rhs).fAddbackFrags = fAddbackFrags;
110 static_cast<TTigress&>(rhs).fBgos = fBgos;
111 static_cast<TTigress&>(rhs).fTigressBits = 0;
112}
113
114void TTigress::Clear(Option_t* opt)
115{
116 // Clears the mother, and all of the hits
117 TDetector::Clear(opt);
118 // deleting the hits causes sef-faults for some reason
119 fAddbackHits.clear();
120 fAddbackFrags.clear();
121 fBgos.clear();
122 fTigressBits = 0;
123}
124
125void TTigress::Print(Option_t*) const
126{
127 Print(std::cout);
128}
129
130void TTigress::Print(std::ostream& out) const
131{
132 std::ostringstream str;
133 str << GetMultiplicity() << " tigress hits" << std::endl;
134 for(Short_t i = 0; i < GetMultiplicity(); i++) {
135 GetHit(i)->Print(str);
136 }
137 out << str.str();
138}
139
140TTigress& TTigress::operator=(const TTigress& rhs)
141{
142 rhs.Copy(*this);
143 return *this;
144}
145
146Int_t TTigress::GetAddbackMultiplicity()
147{
148 // Automatically builds the addback hits using the addback_criterion
149 // (if the size of the addback_hits vector is zero) and return the number of addback hits.
150 if(NoHits()) {
151 return 0;
152 }
153 // if the addback has been reset, clear the addback hits
154 if(!fTigressBits.TestBit(ETigressBits::kAddbackSet)) {
155 // deleting the hits causes sef-faults for some reason
156 fAddbackHits.clear();
157 } else {
158 return fAddbackHits.size();
159 }
160
161 // use the first (highest E) tigress hit as starting point for the addback hits
162 fAddbackHits.push_back(GetHit(0));
163 fAddbackFrags.push_back(1);
164
165 // loop over remaining tigress hits
166 for(Short_t i = 1; i < GetMultiplicity(); i++) {
167 // check for each existing addback hit if this tigress hit should be added
168 size_t j = 0;
169 for(j = 0; j < fAddbackHits.size(); j++) {
170 if(fAddbackCriterion(fAddbackHits[j], GetHit(i))) {
171 // SumHit preserves time and position from first (highest E) hit, but adds segments so this hit becomes
172 // LastPosition()
173 static_cast<TTigressHit*>(fAddbackHits[j])->SumHit(static_cast<TTigressHit*>(GetHit(i))); // Adds
174 fAddbackFrags[j]++;
175 break;
176 }
177 }
178 // if hit[i] was not added to a higher energy hit, create its own addback hit
179 if(j == fAddbackHits.size()) {
180 fAddbackHits.push_back(GetHit(i));
181 static_cast<TTigressHit*>(fAddbackHits.back())->SumHit(static_cast<TTigressHit*>(fAddbackHits.back())); // Does nothing // then why are we doing this?
182 fAddbackFrags.push_back(1);
183 }
184 }
185 fTigressBits.SetBit(ETigressBits::kAddbackSet, true);
186
187 return fAddbackHits.size();
188}
189
190TTigressHit* TTigress::GetAddbackHit(const int& i)
191{
192 /// Get the ith addback hit. This function calls GetAddbackMultiplicity to check the range of the index.
193 /// This automatically calculates all addback hits if they haven't been calculated before.
194 if(i < GetAddbackMultiplicity()) {
195 return static_cast<TTigressHit*>(fAddbackHits.at(i));
196 }
197 std::cerr << "Addback hits are out of range" << std::endl;
198 throw grsi::exit_exception(1);
199 return nullptr;
200}
201
202void TTigress::BuildHits()
203{
204 // remove all hits of segments only
205 // remove_if moves all elements to be removed to the end and returns an iterator to the first one to be removed
206 auto remove = std::remove_if(Hits().begin(), Hits().end(), [](TDetectorHit* h) -> bool { return !(static_cast<TTigressHit*>(h)->CoreSet()); });
207 // using remove_if the elements to be removed are left in an undefined state so we can only log how many we are removing!
208 TSortingDiagnostics::Get()->RemovedHits(IsA(), std::distance(remove, Hits().end()), Hits().size());
209 Hits().erase(remove, Hits().end());
210 for(auto& hit : Hits()) {
211 auto* tigressHit = static_cast<TTigressHit*>(hit);
212 if(tigressHit->GetNSegments() > 1) {
213 tigressHit->SortSegments();
214 }
215
216 if(tigressHit->HasWave() && TGRSIOptions::AnalysisOptions()->IsWaveformFitting()) {
217 tigressHit->SetWavefit();
218 }
219 }
220 if(!NoHits()) {
221 std::sort(Hits().begin(), Hits().end());
222 }
223
224 // Label all hits as being suppressed or not
225 for(auto& fTigressHit : Hits()) {
226 bool suppressed = false;
227 for(auto& fBgo : fBgos) {
228 if(fSuppressionCriterion(fTigressHit, fBgo)) {
229 suppressed = true;
230 break;
231 }
232 }
233 static_cast<TTigressHit*>(fTigressHit)->SetBGOFired(suppressed);
234 }
235}
236
237void TTigress::AddFragment(const std::shared_ptr<const TFragment>& frag, TChannel* chan)
238{
239 if(frag == nullptr || chan == nullptr) {
240 return;
241 }
242
243 if((chan->GetMnemonic()->SubSystem() == TMnemonic::EMnemonic::kG) &&
244 (chan->GetSegmentNumber() == 0 || chan->GetSegmentNumber() == 9)) { // it is a core
245
246 auto* corehit = new TTigressHit;
247 // loop over existing hits to see if this core was already created by a previously found segment
248 // of course this means if we have a core in "coincidence" with itself we will overwrite the first hit
249 for(Short_t i = 0; i < GetMultiplicity(); ++i) {
250 TTigressHit* hit = GetTigressHit(i);
251 if((hit->GetDetector() == chan->GetDetectorNumber()) &&
252 (hit->GetCrystal() == chan->GetCrystalNumber())) { // we have a match;
253
254 // B cores will not replace A cores,
255 // but they will replace no-core hits created if segments are processed first.
256 if(chan->GetMnemonic()->OutputSensor() == TMnemonic::EMnemonic::kB) {
257 TChannel* hitchan = hit->GetChannel();
258 if(hitchan != nullptr) {
259 if(hitchan->GetMnemonic()->OutputSensor() == TMnemonic::EMnemonic::kA) {
260 return;
261 }
262 }
263 }
264
265 hit->CopyFragment(*frag);
266 hit->CoreSet(true);
267 if(TestGlobalBit(ETigressGlobalBits::kSetCoreWave)) {
268 frag->CopyWave(*hit);
269 }
270 return;
271 }
272 }
273 corehit->CopyFragment(*frag);
274 corehit->CoreSet(true);
275 if(TestGlobalBit(ETigressGlobalBits::kSetCoreWave)) {
276 frag->CopyWave(*corehit);
277 }
278 AddHit(corehit);
279 return;
280 }
281 if(chan->GetMnemonic()->SubSystem() == TMnemonic::EMnemonic::kG) { // its ge but its not a core...
282 TDetectorHit temp(*frag);
283 for(Short_t i = 0; i < GetMultiplicity(); ++i) {
284 TTigressHit* hit = GetTigressHit(i);
285 if((hit->GetDetector() == chan->GetDetectorNumber()) &&
286 (hit->GetCrystal() == chan->GetCrystalNumber())) { // we have a match;
287 if(TestGlobalBit(ETigressGlobalBits::kSetSegWave)) {
288 frag->CopyWave(temp);
289 }
290 hit->AddSegment(temp);
291 return;
292 }
293 }
294 auto* corehit = new TTigressHit;
295 corehit->SetAddress((frag->GetAddress())); // fake it till you make it
296 if(TestGlobalBit(ETigressGlobalBits::kSetSegWave)) {
297 frag->CopyWave(temp);
298 }
299 corehit->AddSegment(temp);
300 AddHit(corehit);
301 return;
302 }
303 if(chan->GetMnemonic()->SubSystem() == TMnemonic::EMnemonic::kS) {
304 TBgoHit temp(*frag);
305 fBgos.push_back(temp);
306 return;
307 }
308 // if not suprress errors;
309 std::cout << ALERTTEXT << "failed to build!" << RESET_COLOR << std::endl;
310 frag->Print();
311}
312
313void TTigress::ResetAddback()
314{
315 /// Used to clear the addback hits. When playing back a tree, this must
316 /// be called before building the new addback hits, otherwise, a copy of
317 /// the old addback hits will be stored instead.
318 /// This should have changed now, we're using the stored tigress bits to reset the addback
319 fTigressBits.SetBit(ETigressBits::kAddbackSet, false);
320 // deleting the hits causes sef-faults for some reason
321 fAddbackHits.clear();
322 fAddbackFrags.clear();
323}
324
325UShort_t TTigress::GetNAddbackFrags(size_t idx) const
326{
327 // Get the number of addback "fragments" contributing to the total addback hit
328 // with index idx.
329 if(idx < fAddbackFrags.size()) {
330 return fAddbackFrags.at(idx);
331 }
332 return 0;
333}
334
335TVector3 TTigress::GetPosition(const TTigressHit& hit, double dist, bool smear)
336{
337 return TTigress::GetPosition(hit.GetDetector(), hit.GetCrystal(), hit.GetFirstSeg(), dist, smear);
338}
339
340TVector3 TTigress::GetPosition(int DetNbr, int CryNbr, int SegNbr, double dist, bool smear)
341{
342 if(!GetVectorsBuilt()) {
343 BuildVectors();
344 }
345
346 int BackPos = 0;
347
348 // Would be good to get rid of "dist" and just use SetArrayBackPos, but leaving in for old codes.
349 if(dist > 0) {
350 if(dist > 140.) { BackPos = 1; }
351 } else if(GetArrayBackPos()) {
352 BackPos = 1;
353 }
354
355 if(smear && SegNbr == 0) {
356 double x = 0.;
357 double y = 0.;
358 double r = sqrt(gRandom->Uniform(0, 400));
359 gRandom->Circle(x, y, r);
360 return fPositionVectors[BackPos][DetNbr][CryNbr][SegNbr] + fCloverCross[DetNbr][0] * x + fCloverCross[DetNbr][1] * y;
361 }
362
363 return fPositionVectors[BackPos][DetNbr][CryNbr][SegNbr];
364}
365
366void TTigress::BuildVectors()
367{
368 for(int Back = 0; Back < 2; Back++) {
369 for(int DetNbr = 0; DetNbr < 17; DetNbr++) {
370 for(int CryNbr = 0; CryNbr < 4; CryNbr++) {
371 for(int SegNbr = 0; SegNbr < 9; SegNbr++) {
372 TVector3 det_pos;
373 double xx = 0;
374 double yy = 0;
375 double zz = 0;
376
377 if(Back == 1) { // distance=145.0
378 switch(CryNbr) {
379 case -1: break;
380 case 0:
381 xx = fGeBluePositionBack[DetNbr][SegNbr][0];
382 yy = fGeBluePositionBack[DetNbr][SegNbr][1];
383 zz = fGeBluePositionBack[DetNbr][SegNbr][2];
384 break;
385 case 1:
386 xx = fGeGreenPositionBack[DetNbr][SegNbr][0];
387 yy = fGeGreenPositionBack[DetNbr][SegNbr][1];
388 zz = fGeGreenPositionBack[DetNbr][SegNbr][2];
389 break;
390 case 2:
391 xx = fGeRedPositionBack[DetNbr][SegNbr][0];
392 yy = fGeRedPositionBack[DetNbr][SegNbr][1];
393 zz = fGeRedPositionBack[DetNbr][SegNbr][2];
394 break;
395 case 3:
396 xx = fGeWhitePositionBack[DetNbr][SegNbr][0];
397 yy = fGeWhitePositionBack[DetNbr][SegNbr][1];
398 zz = fGeWhitePositionBack[DetNbr][SegNbr][2];
399 break;
400 };
401 } else {
402 switch(CryNbr) {
403 case -1: break;
404 case 0:
405 xx = fGeBluePosition[DetNbr][SegNbr][0];
406 yy = fGeBluePosition[DetNbr][SegNbr][1];
407 zz = fGeBluePosition[DetNbr][SegNbr][2];
408 break;
409 case 1:
410 xx = fGeGreenPosition[DetNbr][SegNbr][0];
411 yy = fGeGreenPosition[DetNbr][SegNbr][1];
412 zz = fGeGreenPosition[DetNbr][SegNbr][2];
413 break;
414 case 2:
415 xx = fGeRedPosition[DetNbr][SegNbr][0];
416 yy = fGeRedPosition[DetNbr][SegNbr][1];
417 zz = fGeRedPosition[DetNbr][SegNbr][2];
418 break;
419 case 3:
420 xx = fGeWhitePosition[DetNbr][SegNbr][0];
421 yy = fGeWhitePosition[DetNbr][SegNbr][1];
422 zz = fGeWhitePosition[DetNbr][SegNbr][2];
423 break;
424 };
425 }
426
427 det_pos.SetXYZ(xx, yy, zz - fTargetOffset);
428
429 if(fRadialOffset != 0.) {
430 det_pos += fCloverRadial[DetNbr].Unit() * fRadialOffset;
431 }
432
433 fPositionVectors[Back][DetNbr][CryNbr][SegNbr] = det_pos;
434 }
435 }
436 }
437 }
438
439 for(int DetNbr = 0; DetNbr < 17; DetNbr++) {
440 TVector3 a(-fCloverRadial[DetNbr].Y(), fCloverRadial[DetNbr].X(), 0);
441 TVector3 b = fCloverRadial[DetNbr].Cross(a);
442 fCloverCross[DetNbr][0] = a.Unit();
443 fCloverCross[DetNbr][1] = b.Unit();
444 }
445
446 SetGlobalBit(ETigressGlobalBits::kVectorsBuilt, true);
447}
448
449std::array<std::array<std::array<std::array<TVector3, 9>, 4>, 17>, 2> TTigress::fPositionVectors;
450std::array<std::array<TVector3, 2>, 17> TTigress::fCloverCross;
451
452std::array<TVector3, 17> TTigress::fCloverRadial = {TVector3(0., 0., 0.),
453 TVector3(0.9239, 0.3827, 1.),
454 TVector3(-0.3827, 0.9239, 1.),
455 TVector3(-0.9239, -0.3827, 1.),
456 TVector3(0.3827, -0.9239, 1.),
457 TVector3(0.9239, 0.3827, 0.),
458 TVector3(0.3827, 0.9239, 0.),
459 TVector3(-0.3827, 0.9239, 0.),
460 TVector3(-0.9239, 0.3827, 0.),
461 TVector3(-0.9239, -0.3827, 0.),
462 TVector3(-0.3827, -0.9239, 0.),
463 TVector3(0.3827, -0.9239, 0.),
464 TVector3(0.9239, -0.3827, 0.),
465 TVector3(0.9239, 0.3827, -1.),
466 TVector3(-0.3827, 0.9239, -1.),
467 TVector3(-0.9239, -0.3827, -1.),
468 TVector3(0.3827, -0.9239, -1.)};
469
470std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeBluePosition = {{{{{0., 0., 0.},
471 {0., 0., 0.},
472 {0., 0., 0.},
473 {0., 0., 0.},
474 {0., 0., 0.},
475 {0., 0., 0.},
476 {0., 0., 0.},
477 {0., 0., 0.},
478 {0., 0., 0.}}},
479 {{{78.05, 61.70, 134.09},
480 {47.83, 59.64, 119.06},
481 {63.65, 65.78, 102.12},
482 {72.14, 44.72, 103.15},
483 {57.26, 37.61, 118.80},
484 {72.73, 73.96, 152.77},
485 {89.31, 81.09, 134.70},
486 {99.39, 57.11, 134.51},
487 {82.33, 50.30, 152.93}}},
488 {{{-61.70, 78.05, 134.09},
489 {-59.64, 47.83, 119.06},
490 {-65.78, 63.65, 102.12},
491 {-44.72, 72.14, 103.15},
492 {-37.61, 57.26, 118.80},
493 {-73.96, 72.73, 152.77},
494 {-81.09, 89.31, 134.70},
495 {-57.11, 99.39, 134.51},
496 {-50.30, 82.33, 152.93}}},
497 {{{-78.05, -61.70, 134.09},
498 {-47.83, -59.64, 119.06},
499 {-63.65, -65.78, 102.12},
500 {-72.14, -44.72, 103.15},
501 {-57.26, -37.61, 118.80},
502 {-72.73, -73.96, 152.77},
503 {-89.31, -81.09, 134.70},
504 {-99.39, -57.11, 134.51},
505 {-82.33, -50.30, 152.93}}},
506 {{{61.70, -78.05, 134.09},
507 {59.64, -47.83, 119.06},
508 {65.78, -63.65, 102.12},
509 {44.72, -72.14, 103.15},
510 {37.61, -57.26, 118.80},
511 {73.96, -72.73, 152.77},
512 {81.09, -89.31, 134.70},
513 {57.11, -99.39, 134.51},
514 {50.30, -82.33, 152.93}}},
515 {{{139.75, 87.25, 27.13},
516 {107.47, 84.35, 36.80},
517 {107.64, 84.01, 12.83},
518 {116.86, 63.25, 13.71},
519 {116.66, 62.21, 36.42},
520 {146.69, 104.60, 40.50},
521 {146.58, 104.81, 14.96},
522 {156.50, 80.77, 14.73},
523 {156.44, 80.99, 40.74}}},
524 {{{37.12, 160.51, 27.13},
525 {16.35, 135.64, 36.80},
526 {16.71, 135.51, 12.83},
527 {37.91, 127.36, 13.71},
528 {38.50, 126.48, 36.42},
529 {29.76, 177.69, 40.50},
530 {29.53, 177.76, 14.96},
531 {53.55, 167.78, 14.73},
532 {53.35, 167.89, 40.74}}},
533 {{{-87.25, 139.75, 27.13},
534 {-84.35, 107.47, 36.80},
535 {-84.01, 107.64, 12.83},
536 {-63.25, 116.86, 13.71},
537 {-62.21, 116.66, 36.42},
538 {-104.60, 146.69, 40.50},
539 {-104.81, 146.58, 14.96},
540 {-80.77, 156.50, 14.73},
541 {-80.99, 156.44, 40.74}}},
542 {{{-160.51, 37.12, 27.13},
543 {-135.64, 16.35, 36.80},
544 {-135.51, 16.71, 12.83},
545 {-127.36, 37.91, 13.71},
546 {-126.48, 38.50, 36.42},
547 {-177.69, 29.76, 40.50},
548 {-177.76, 29.53, 14.96},
549 {-167.78, 53.55, 14.73},
550 {-167.89, 53.35, 40.74}}},
551 {{{-139.75, -87.25, 27.13},
552 {-107.47, -84.35, 36.80},
553 {-107.64, -84.01, 12.83},
554 {-116.86, -63.25, 13.71},
555 {-116.66, -62.21, 36.42},
556 {-146.69, -104.60, 40.50},
557 {-146.58, -104.81, 14.96},
558 {-156.50, -80.77, 14.73},
559 {-156.44, -80.99, 40.74}}},
560 {{{-37.12, -160.51, 27.13},
561 {-16.35, -135.64, 36.80},
562 {-16.71, -135.51, 12.83},
563 {-37.91, -127.36, 13.71},
564 {-38.50, -126.48, 36.42},
565 {-29.76, -177.69, 40.50},
566 {-29.53, -177.76, 14.96},
567 {-53.55, -167.78, 14.73},
568 {-53.35, -167.89, 40.74}}},
569 {{{87.25, -139.75, 27.13},
570 {84.35, -107.47, 36.80},
571 {84.01, -107.64, 12.83},
572 {63.25, -116.86, 13.71},
573 {62.21, -116.66, 36.42},
574 {104.60, -146.69, 40.50},
575 {104.81, -146.58, 14.96},
576 {80.77, -156.50, 14.73},
577 {80.99, -156.44, 40.74}}},
578 {{{160.51, -37.12, 27.13},
579 {135.64, -16.35, 36.80},
580 {135.51, -16.71, 12.83},
581 {127.36, -37.91, 13.71},
582 {126.48, -38.50, 36.42},
583 {177.69, -29.76, 40.50},
584 {177.76, -29.53, 14.96},
585 {167.78, -53.55, 14.73},
586 {167.89, -53.35, 40.74}}},
587 {{{113.50, 76.38, -95.72},
588 {95.91, 79.56, -67.01},
589 {80.41, 72.73, -83.98},
590 {90.05, 52.14, -83.76},
591 {104.85, 57.32, -67.30},
592 {125.64, 95.88, -95.49},
593 {108.85, 89.19, -113.54},
594 {118.64, 65.08, -113.68},
595 {135.56, 72.34, -95.31}}},
596 {{{-76.38, 113.50, -95.72},
597 {-79.56, 95.91, -67.01},
598 {-72.73, 80.41, -83.98},
599 {-52.14, 90.05, -83.76},
600 {-57.32, 104.85, -67.30},
601 {-95.88, 125.64, -95.49},
602 {-89.19, 108.85, -113.54},
603 {-65.08, 118.64, -113.68},
604 {-72.34, 135.56, -95.31}}},
605 {{{-113.50, -76.38, -95.72},
606 {-95.91, -79.56, -67.01},
607 {-80.41, -72.73, -83.98},
608 {-90.05, -52.14, -83.76},
609 {-104.85, -57.32, -67.30},
610 {-125.64, -95.88, -95.49},
611 {-108.85, -89.19, -113.54},
612 {-118.64, -65.08, -113.68},
613 {-135.56, -72.34, -95.31}}},
614 {{{76.38, -113.50, -95.72},
615 {79.56, -95.91, -67.01},
616 {72.73, -80.41, -83.98},
617 {52.14, -90.05, -83.76},
618 {57.32, -104.85, -67.30},
619 {95.88, -125.64, -95.49},
620 {89.19, -108.85, -113.54},
621 {65.08, -118.64, -113.68},
622 {72.34, -135.56, -95.31}}}}};
623
624// Assuming this is the 1
625std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeGreenPosition = {{{{{0., 0., 0.},
626 {0., 0., 0.},
627 {0., 0., 0.},
628 {0., 0., 0.},
629 {0., 0., 0.},
630 {0., 0., 0.},
631 {0., 0., 0.},
632 {0., 0., 0.},
633 {0., 0., 0.}}},
634 {{{113.50, 76.38, 95.72},
635 {95.91, 79.56, 67.01},
636 {104.85, 57.32, 67.30},
637 {90.05, 52.14, 83.76},
638 {80.41, 72.73, 83.98},
639 {125.64, 95.88, 95.49},
640 {135.56, 72.34, 95.31},
641 {118.64, 65.08, 113.68},
642 {108.85, 89.19, 113.54}}},
643 {{{-76.38, 113.50, 95.72},
644 {-79.56, 95.91, 67.01},
645 {-57.32, 104.85, 67.30},
646 {-52.14, 90.05, 83.76},
647 {-72.73, 80.41, 83.98},
648 {-95.88, 125.64, 95.49},
649 {-72.34, 135.56, 95.31},
650 {-65.08, 118.64, 113.68},
651 {-89.19, 108.85, 113.54}}},
652 {{{-113.50, -76.38, 95.72},
653 {-95.91, -79.56, 67.01},
654 {-104.85, -57.32, 67.30},
655 {-90.05, -52.14, 83.76},
656 {-80.41, -72.73, 83.98},
657 {-125.64, -95.88, 95.49},
658 {-135.56, -72.34, 95.31},
659 {-118.64, -65.08, 113.68},
660 {-108.85, -89.19, 113.54}}},
661 {{{76.38, -113.50, 95.72},
662 {79.56, -95.91, 67.01},
663 {57.32, -104.85, 67.30},
664 {52.14, -90.05, 83.76},
665 {72.73, -80.41, 83.98},
666 {95.88, -125.64, 95.49},
667 {72.34, -135.56, 95.31},
668 {65.08, -118.64, 113.68},
669 {89.19, -108.85, 113.54}}},
670 {{{139.75, 87.25, -27.13},
671 {107.47, 84.35, -36.80},
672 {116.66, 62.21, -36.42},
673 {116.86, 63.25, -13.71},
674 {107.64, 84.01, -12.83},
675 {146.69, 104.60, -40.50},
676 {156.44, 80.99, -40.74},
677 {156.50, 80.77, -14.73},
678 {146.58, 104.81, -14.96}}},
679 {{{37.12, 160.51, -27.13},
680 {16.35, 135.64, -36.80},
681 {38.50, 126.48, -36.42},
682 {37.91, 127.36, -13.71},
683 {16.71, 135.51, -12.83},
684 {29.76, 177.69, -40.50},
685 {53.35, 167.89, -40.74},
686 {53.55, 167.78, -14.73},
687 {29.53, 177.76, -14.96}}},
688 {{{-87.25, 139.75, -27.13},
689 {-84.35, 107.47, -36.80},
690 {-62.21, 116.66, -36.42},
691 {-63.25, 116.86, -13.71},
692 {-84.01, 107.64, -12.83},
693 {-104.60, 146.69, -40.50},
694 {-80.99, 156.44, -40.74},
695 {-80.77, 156.50, -14.73},
696 {-104.81, 146.58, -14.96}}},
697 {{{-160.51, 37.12, -27.13},
698 {-135.64, 16.35, -36.80},
699 {-126.48, 38.50, -36.42},
700 {-127.36, 37.91, -13.71},
701 {-135.51, 16.71, -12.83},
702 {-177.69, 29.76, -40.50},
703 {-167.89, 53.35, -40.74},
704 {-167.78, 53.55, -14.73},
705 {-177.76, 29.53, -14.96}}},
706 {{{-139.75, -87.25, -27.13},
707 {-107.47, -84.35, -36.80},
708 {-116.66, -62.21, -36.42},
709 {-116.86, -63.25, -13.71},
710 {-107.64, -84.01, -12.83},
711 {-146.69, -104.60, -40.50},
712 {-156.44, -80.99, -40.74},
713 {-156.50, -80.77, -14.73},
714 {-146.58, -104.81, -14.96}}},
715 {{{-37.12, -160.51, -27.13},
716 {-16.35, -135.64, -36.80},
717 {-38.50, -126.48, -36.42},
718 {-37.91, -127.36, -13.71},
719 {-16.71, -135.51, -12.83},
720 {-29.76, -177.69, -40.50},
721 {-53.35, -167.89, -40.74},
722 {-53.55, -167.78, -14.73},
723 {-29.53, -177.76, -14.96}}},
724 {{{87.25, -139.75, -27.13},
725 {84.35, -107.47, -36.80},
726 {62.21, -116.66, -36.42},
727 {63.25, -116.86, -13.71},
728 {84.01, -107.64, -12.83},
729 {104.60, -146.69, -40.50},
730 {80.99, -156.44, -40.74},
731 {80.77, -156.50, -14.73},
732 {104.81, -146.58, -14.96}}},
733 {{{160.51, -37.12, -27.13},
734 {135.64, -16.35, -36.80},
735 {126.48, -38.50, -36.42},
736 {127.36, -37.91, -13.71},
737 {135.51, -16.71, -12.83},
738 {177.69, -29.76, -40.50},
739 {167.89, -53.35, -40.74},
740 {167.78, -53.55, -14.73},
741 {177.76, -29.53, -14.96}}},
742 {{{78.05, 61.70, -134.09},
743 {47.83, 59.64, -119.06},
744 {57.26, 37.61, -118.80},
745 {72.14, 44.72, -103.15},
746 {63.65, 65.78, -102.12},
747 {72.73, 73.96, -152.77},
748 {82.33, 50.30, -152.93},
749 {99.39, 57.11, -134.51},
750 {89.31, 81.09, -134.70}}},
751 {{{-61.70, 78.05, -134.09},
752 {-59.64, 47.83, -119.06},
753 {-37.61, 57.26, -118.80},
754 {-44.72, 72.14, -103.15},
755 {-65.78, 63.65, -102.12},
756 {-73.96, 72.73, -152.77},
757 {-50.30, 82.33, -152.93},
758 {-57.11, 99.39, -134.51},
759 {-81.09, 89.31, -134.70}}},
760 {{{-78.05, -61.70, -134.09},
761 {-47.83, -59.64, -119.06},
762 {-57.26, -37.61, -118.80},
763 {-72.14, -44.72, -103.15},
764 {-63.65, -65.78, -102.12},
765 {-72.73, -73.96, -152.77},
766 {-82.33, -50.30, -152.93},
767 {-99.39, -57.11, -134.51},
768 {-89.31, -81.09, -134.70}}},
769 {{{61.70, -78.05, -134.09},
770 {59.64, -47.83, -119.06},
771 {37.61, -57.26, -118.80},
772 {44.72, -72.14, -103.15},
773 {65.78, -63.65, -102.12},
774 {73.96, -72.73, -152.77},
775 {50.30, -82.33, -152.93},
776 {57.11, -99.39, -134.51},
777 {81.09, -89.31, -134.70}}}}};
778
779// Assuming this is the 2
780std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeRedPosition = {{{{{0., 0., 0.},
781 {0., 0., 0.},
782 {0., 0., 0.},
783 {0., 0., 0.},
784 {0., 0., 0.},
785 {0., 0., 0.},
786 {0., 0., 0.},
787 {0., 0., 0.},
788 {0., 0., 0.}}},
789 {{{134.26, 26.25, 95.72},
790 {124.08, 11.56, 67.01},
791 {108.28, 5.43, 83.98},
792 {100.55, 26.81, 83.76},
793 {114.67, 33.61, 67.30},
794 {156.64, 21.05, 95.49},
795 {140.03, 13.91, 113.54},
796 {129.91, 37.87, 113.68},
797 {147.01, 44.70, 95.31}}},
798 {{{-26.25, 134.26, 95.72},
799 {-11.56, 124.08, 67.01},
800 {-5.43, 108.28, 83.98},
801 {-26.81, 100.55, 83.76},
802 {-33.61, 114.67, 67.30},
803 {-21.05, 156.64, 95.49},
804 {-13.91, 140.03, 113.54},
805 {-37.87, 129.91, 113.68},
806 {-44.70, 147.01, 95.31}}},
807 {{{-134.26, -26.25, 95.72},
808 {-124.08, -11.56, 67.01},
809 {-108.28, -5.43, 83.98},
810 {-100.55, -26.81, 83.76},
811 {-114.67, -33.61, 67.30},
812 {-156.64, -21.05, 95.49},
813 {-140.03, -13.91, 113.54},
814 {-129.91, -37.87, 113.68},
815 {-147.01, -44.70, 95.31}}},
816 {{{26.25, -134.26, 95.72},
817 {11.56, -124.08, 67.01},
818 {5.43, -108.28, 83.98},
819 {26.81, -100.55, 83.76},
820 {33.61, -114.67, 67.30},
821 {21.05, -156.64, 95.49},
822 {13.91, -140.03, 113.54},
823 {37.87, -129.91, 113.68},
824 {44.70, -147.01, 95.31}}},
825 {{{160.51, 37.12, -27.13},
826 {135.64, 16.35, -36.80},
827 {135.51, 16.71, -12.83},
828 {127.36, 37.91, -13.71},
829 {126.48, 38.50, -36.42},
830 {177.69, 29.76, -40.50},
831 {177.76, 29.53, -14.96},
832 {167.78, 53.55, -14.73},
833 {167.89, 53.35, -40.74}}},
834 {{{87.25, 139.75, -27.13},
835 {84.35, 107.47, -36.80},
836 {84.01, 107.64, -12.83},
837 {63.25, 116.86, -13.71},
838 {62.21, 116.66, -36.42},
839 {104.60, 146.69, -40.50},
840 {104.81, 146.58, -14.96},
841 {80.77, 156.50, -14.73},
842 {80.99, 156.44, -40.74}}},
843 {{{-37.12, 160.51, -27.13},
844 {-16.35, 135.64, -36.80},
845 {-16.71, 135.51, -12.83},
846 {-37.91, 127.36, -13.71},
847 {-38.50, 126.48, -36.42},
848 {-29.76, 177.69, -40.50},
849 {-29.53, 177.76, -14.96},
850 {-53.55, 167.78, -14.73},
851 {-53.35, 167.89, -40.74}}},
852 {{{-139.75, 87.25, -27.13},
853 {-107.47, 84.35, -36.80},
854 {-107.64, 84.01, -12.83},
855 {-116.86, 63.25, -13.71},
856 {-116.66, 62.21, -36.42},
857 {-146.69, 104.60, -40.50},
858 {-146.58, 104.81, -14.96},
859 {-156.50, 80.77, -14.73},
860 {-156.44, 80.99, -40.74}}},
861 {{{-160.51, -37.12, -27.13},
862 {-135.64, -16.35, -36.80},
863 {-135.51, -16.71, -12.83},
864 {-127.36, -37.91, -13.71},
865 {-126.48, -38.50, -36.42},
866 {-177.69, -29.76, -40.50},
867 {-177.76, -29.53, -14.96},
868 {-167.78, -53.55, -14.73},
869 {-167.89, -53.35, -40.74}}},
870 {{{-87.25, -139.75, -27.13},
871 {-84.35, -107.47, -36.80},
872 {-84.01, -107.64, -12.83},
873 {-63.25, -116.86, -13.71},
874 {-62.21, -116.66, -36.42},
875 {-104.60, -146.69, -40.50},
876 {-104.81, -146.58, -14.96},
877 {-80.77, -156.50, -14.73},
878 {-80.99, -156.44, -40.74}}},
879 {{{37.12, -160.51, -27.13},
880 {16.35, -135.64, -36.80},
881 {16.71, -135.51, -12.83},
882 {37.91, -127.36, -13.71},
883 {38.50, -126.48, -36.42},
884 {29.76, -177.69, -40.50},
885 {29.53, -177.76, -14.96},
886 {53.55, -167.78, -14.73},
887 {53.35, -167.89, -40.74}}},
888 {{{139.75, -87.25, -27.13},
889 {107.47, -84.35, -36.80},
890 {107.64, -84.01, -12.83},
891 {116.86, -63.25, -13.71},
892 {116.66, -62.21, -36.42},
893 {146.69, -104.60, -40.50},
894 {146.58, -104.81, -14.96},
895 {156.50, -80.77, -14.73},
896 {156.44, -80.99, -40.74}}},
897 {{{98.82, 11.57, -134.09},
898 {75.99, -8.35, -119.06},
899 {91.52, -1.51, -102.12},
900 {82.63, 19.39, -103.15},
901 {67.08, 13.90, -118.80},
902 {103.72, -0.87, -152.77},
903 {120.49, 5.81, -134.70},
904 {110.66, 29.90, -134.51},
905 {93.78, 22.65, -152.93}}},
906 {{{-11.57, 98.82, -134.09},
907 {8.35, 75.99, -119.06},
908 {1.51, 91.52, -102.12},
909 {-19.39, 82.63, -103.15},
910 {-13.90, 67.08, -118.80},
911 {0.87, 103.72, -152.77},
912 {-5.81, 120.49, -134.70},
913 {-29.90, 110.66, -134.51},
914 {-22.65, 93.78, -152.93}}},
915 {{{-98.82, -11.57, -134.09},
916 {-75.99, 8.35, -119.06},
917 {-91.52, 1.51, -102.12},
918 {-82.63, -19.39, -103.15},
919 {-67.08, -13.90, -118.80},
920 {-103.72, 0.87, -152.77},
921 {-120.49, -5.81, -134.70},
922 {-110.66, -29.90, -134.51},
923 {-93.78, -22.65, -152.93}}},
924 {{{11.57, -98.82, -134.09},
925 {-8.35, -75.99, -119.06},
926 {-1.51, -91.52, -102.12},
927 {19.39, -82.63, -103.15},
928 {13.90, -67.08, -118.80},
929 {-0.87, -103.72, -152.77},
930 {5.81, -120.49, -134.70},
931 {29.90, -110.66, -134.51},
932 {22.65, -93.78, -152.93}}}}};
933
934// Assuming this is the 3
935std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeWhitePosition = {{{{{0., 0., 0.},
936 {0., 0., 0.},
937 {0., 0., 0.},
938 {0., 0., 0.},
939 {0., 0., 0.},
940 {0., 0., 0.},
941 {0., 0., 0.},
942 {0., 0., 0.},
943 {0., 0., 0.}}},
944 {{{98.82, 11.57, 134.09},
945 {75.99, -8.35, 119.06},
946 {67.08, 13.90, 118.80},
947 {82.63, 19.39, 103.15},
948 {91.52, -1.51, 102.12},
949 {103.72, -0.87, 152.77},
950 {93.78, 22.65, 152.93},
951 {110.66, 29.90, 134.51},
952 {120.49, 5.81, 134.70}}},
953 {{{-11.57, 98.82, 134.09},
954 {8.35, 75.99, 119.06},
955 {-13.90, 67.08, 118.80},
956 {-19.39, 82.63, 103.15},
957 {1.51, 91.52, 102.12},
958 {0.87, 103.72, 152.77},
959 {-22.65, 93.78, 152.93},
960 {-29.90, 110.66, 134.51},
961 {-5.81, 120.49, 134.70}}},
962 {{{-98.82, -11.57, 134.09},
963 {-75.99, 8.35, 119.06},
964 {-67.08, -13.90, 118.80},
965 {-82.63, -19.39, 103.15},
966 {-91.52, 1.51, 102.12},
967 {-103.72, 0.87, 152.77},
968 {-93.78, -22.65, 152.93},
969 {-110.66, -29.90, 134.51},
970 {-120.49, -5.81, 134.70}}},
971 {{{11.57, -98.82, 134.09},
972 {-8.35, -75.99, 119.06},
973 {13.90, -67.08, 118.80},
974 {19.39, -82.63, 103.15},
975 {-1.51, -91.52, 102.12},
976 {-0.87, -103.72, 152.77},
977 {22.65, -93.78, 152.93},
978 {29.90, -110.66, 134.51},
979 {5.81, -120.49, 134.70}}},
980 {{{160.51, 37.12, 27.13},
981 {135.64, 16.35, 36.80},
982 {126.48, 38.50, 36.42},
983 {127.36, 37.91, 13.71},
984 {135.51, 16.71, 12.83},
985 {177.69, 29.76, 40.50},
986 {167.89, 53.35, 40.74},
987 {167.78, 53.55, 14.73},
988 {177.76, 29.53, 14.96}}},
989 {{{87.25, 139.75, 27.13},
990 {84.35, 107.47, 36.80},
991 {62.21, 116.66, 36.42},
992 {63.25, 116.86, 13.71},
993 {84.01, 107.64, 12.83},
994 {104.60, 146.69, 40.50},
995 {80.99, 156.44, 40.74},
996 {80.77, 156.50, 14.73},
997 {104.81, 146.58, 14.96}}},
998 {{{-37.12, 160.51, 27.13},
999 {-16.35, 135.64, 36.80},
1000 {-38.50, 126.48, 36.42},
1001 {-37.91, 127.36, 13.71},
1002 {-16.71, 135.51, 12.83},
1003 {-29.76, 177.69, 40.50},
1004 {-53.35, 167.89, 40.74},
1005 {-53.55, 167.78, 14.73},
1006 {-29.53, 177.76, 14.96}}},
1007 {{{-139.75, 87.25, 27.13},
1008 {-107.47, 84.35, 36.80},
1009 {-116.66, 62.21, 36.42},
1010 {-116.86, 63.25, 13.71},
1011 {-107.64, 84.01, 12.83},
1012 {-146.69, 104.60, 40.50},
1013 {-156.44, 80.99, 40.74},
1014 {-156.50, 80.77, 14.73},
1015 {-146.58, 104.81, 14.96}}},
1016 {{{-160.51, -37.12, 27.13},
1017 {-135.64, -16.35, 36.80},
1018 {-126.48, -38.50, 36.42},
1019 {-127.36, -37.91, 13.71},
1020 {-135.51, -16.71, 12.83},
1021 {-177.69, -29.76, 40.50},
1022 {-167.89, -53.35, 40.74},
1023 {-167.78, -53.55, 14.73},
1024 {-177.76, -29.53, 14.96}}},
1025 {{{-87.25, -139.75, 27.13},
1026 {-84.35, -107.47, 36.80},
1027 {-62.21, -116.66, 36.42},
1028 {-63.25, -116.86, 13.71},
1029 {-84.01, -107.64, 12.83},
1030 {-104.60, -146.69, 40.50},
1031 {-80.99, -156.44, 40.74},
1032 {-80.77, -156.50, 14.73},
1033 {-104.81, -146.58, 14.96}}},
1034 {{{37.12, -160.51, 27.13},
1035 {16.35, -135.64, 36.80},
1036 {38.50, -126.48, 36.42},
1037 {37.91, -127.36, 13.71},
1038 {16.71, -135.51, 12.83},
1039 {29.76, -177.69, 40.50},
1040 {53.35, -167.89, 40.74},
1041 {53.55, -167.78, 14.73},
1042 {29.53, -177.76, 14.96}}},
1043 {{{139.75, -87.25, 27.13},
1044 {107.47, -84.35, 36.80},
1045 {116.66, -62.21, 36.42},
1046 {116.86, -63.25, 13.71},
1047 {107.64, -84.01, 12.83},
1048 {146.69, -104.60, 40.50},
1049 {156.44, -80.99, 40.74},
1050 {156.50, -80.77, 14.73},
1051 {146.58, -104.81, 14.96}}},
1052 {{{134.26, 26.25, -95.72},
1053 {124.08, 11.56, -67.01},
1054 {114.67, 33.61, -67.30},
1055 {100.55, 26.81, -83.76},
1056 {108.28, 5.43, -83.98},
1057 {156.64, 21.05, -95.49},
1058 {147.01, 44.70, -95.31},
1059 {129.91, 37.87, -113.68},
1060 {140.03, 13.91, -113.54}}},
1061 {{{-26.25, 134.26, -95.72},
1062 {-11.56, 124.08, -67.01},
1063 {-33.61, 114.67, -67.30},
1064 {-26.81, 100.55, -83.76},
1065 {-5.43, 108.28, -83.98},
1066 {-21.05, 156.64, -95.49},
1067 {-44.70, 147.01, -95.31},
1068 {-37.87, 129.91, -113.68},
1069 {-13.91, 140.03, -113.54}}},
1070 {{{-134.26, -26.25, -95.72},
1071 {-124.08, -11.56, -67.01},
1072 {-114.67, -33.61, -67.30},
1073 {-100.55, -26.81, -83.76},
1074 {-108.28, -5.43, -83.98},
1075 {-156.64, -21.05, -95.49},
1076 {-147.01, -44.70, -95.31},
1077 {-129.91, -37.87, -113.68},
1078 {-140.03, -13.91, -113.54}}},
1079 {{{26.25, -134.26, -95.72},
1080 {11.56, -124.08, -67.01},
1081 {33.61, -114.67, -67.30},
1082 {26.81, -100.55, -83.76},
1083 {5.43, -108.28, -83.98},
1084 {21.05, -156.64, -95.49},
1085 {44.70, -147.01, -95.31},
1086 {37.87, -129.91, -113.68},
1087 {13.91, -140.03, -113.54}}}}};
1088
1089std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeBluePositionBack = {{{{{0., 0., 0.},
1090 {0., 0., 0.},
1091 {0., 0., 0.},
1092 {0., 0., 0.},
1093 {0., 0., 0.},
1094 {0., 0., 0.},
1095 {0., 0., 0.},
1096 {0., 0., 0.},
1097 {0., 0., 0.}}},
1098 {{{100.92, 71.17, 158.84},
1099 {70.69, 69.11, 143.80},
1100 {86.51, 75.25, 126.87},
1101 {95.01, 54.19, 127.90},
1102 {80.13, 47.08, 143.55},
1103 {95.59, 83.43, 177.52},
1104 {112.17, 90.56, 159.45},
1105 {122.26, 66.58, 159.26},
1106 {105.20, 59.77, 177.67}}},
1107 {{{-71.17, 100.92, 158.84},
1108 {-69.11, 70.69, 143.80},
1109 {-75.25, 86.51, 126.87},
1110 {-54.19, 95.01, 127.90},
1111 {-47.08, 80.13, 143.55},
1112 {-83.43, 95.59, 177.52},
1113 {-90.56, 112.17, 159.45},
1114 {-66.58, 122.26, 159.26},
1115 {-59.77, 105.20, 177.67}}},
1116 {{{-100.92, -71.17, 158.84},
1117 {-70.69, -69.11, 143.80},
1118 {-86.51, -75.25, 126.87},
1119 {-95.01, -54.19, 127.90},
1120 {-80.13, -47.08, 143.55},
1121 {-95.59, -83.43, 177.52},
1122 {-112.17, -90.56, 159.45},
1123 {-122.26, -66.58, 159.26},
1124 {-105.20, -59.77, 177.67}}},
1125 {{{71.17, -100.92, 158.84},
1126 {69.11, -70.69, 143.80},
1127 {75.25, -86.51, 126.87},
1128 {54.19, -95.01, 127.90},
1129 {47.08, -80.13, 143.55},
1130 {83.43, -95.59, 177.52},
1131 {90.56, -112.17, 159.45},
1132 {66.58, -122.26, 159.26},
1133 {59.77, -105.20, 177.67}}},
1134 {{{172.08, 100.64, 27.13},
1135 {139.81, 97.74, 36.80},
1136 {139.97, 97.40, 12.83},
1137 {149.20, 76.64, 13.71},
1138 {149.00, 75.60, 36.42},
1139 {179.02, 117.99, 40.50},
1140 {178.91, 118.21, 14.96},
1141 {188.84, 94.16, 14.73},
1142 {188.78, 94.39, 40.74}}},
1143 {{{50.52, 192.85, 27.13},
1144 {29.74, 167.97, 36.80},
1145 {30.10, 167.85, 12.83},
1146 {51.31, 159.69, 13.71},
1147 {51.90, 158.82, 36.42},
1148 {43.16, 210.02, 40.50},
1149 {42.93, 210.09, 14.96},
1150 {66.95, 200.11, 14.73},
1151 {66.75, 200.23, 40.74}}},
1152 {{{-100.64, 172.08, 27.13},
1153 {-97.74, 139.81, 36.80},
1154 {-97.40, 139.97, 12.83},
1155 {-76.64, 149.20, 13.71},
1156 {-75.60, 149.00, 36.42},
1157 {-117.99, 179.02, 40.50},
1158 {-118.21, 178.91, 14.96},
1159 {-94.16, 188.84, 14.73},
1160 {-94.39, 188.78, 40.74}}},
1161 {{{-192.85, 50.52, 27.13},
1162 {-167.97, 29.74, 36.80},
1163 {-167.85, 30.10, 12.83},
1164 {-159.69, 51.31, 13.71},
1165 {-158.82, 51.90, 36.42},
1166 {-210.02, 43.16, 40.50},
1167 {-210.09, 42.93, 14.96},
1168 {-200.11, 66.95, 14.73},
1169 {-200.23, 66.75, 40.74}}},
1170 {{{-172.08, -100.64, 27.13},
1171 {-139.81, -97.74, 36.80},
1172 {-139.97, -97.40, 12.83},
1173 {-149.20, -76.64, 13.71},
1174 {-149.00, -75.60, 36.42},
1175 {-179.02, -117.99, 40.50},
1176 {-178.91, -118.21, 14.96},
1177 {-188.84, -94.16, 14.73},
1178 {-188.78, -94.39, 40.74}}},
1179 {{{-50.52, -192.85, 27.13},
1180 {-29.74, -167.97, 36.80},
1181 {-30.10, -167.85, 12.83},
1182 {-51.31, -159.69, 13.71},
1183 {-51.90, -158.82, 36.42},
1184 {-43.16, -210.02, 40.50},
1185 {-42.93, -210.09, 14.96},
1186 {-66.95, -200.11, 14.73},
1187 {-66.75, -200.23, 40.74}}},
1188 {{{100.64, -172.08, 27.13},
1189 {97.74, -139.81, 36.80},
1190 {97.40, -139.97, 12.83},
1191 {76.64, -149.20, 13.71},
1192 {75.60, -149.00, 36.42},
1193 {117.99, -179.02, 40.50},
1194 {118.21, -178.91, 14.96},
1195 {94.16, -188.84, 14.73},
1196 {94.39, -188.78, 40.74}}},
1197 {{{192.85, -50.52, 27.13},
1198 {167.97, -29.74, 36.80},
1199 {167.85, -30.10, 12.83},
1200 {159.69, -51.31, 13.71},
1201 {158.82, -51.90, 36.42},
1202 {210.02, -43.16, 40.50},
1203 {210.09, -42.93, 14.96},
1204 {200.11, -66.95, 14.73},
1205 {200.23, -66.75, 40.74}}},
1206 {{{136.36, 85.85, -120.47},
1207 {118.78, 89.03, -91.76},
1208 {103.27, 82.20, -108.72},
1209 {112.92, 61.61, -108.51},
1210 {127.71, 66.79, -92.04},
1211 {148.51, 105.35, -120.24},
1212 {131.72, 98.66, -138.29},
1213 {141.50, 74.56, -138.43},
1214 {158.43, 81.81, -120.06}}},
1215 {{{-85.85, 136.36, -120.47},
1216 {-89.03, 118.78, -91.76},
1217 {-82.20, 103.27, -108.72},
1218 {-61.61, 112.92, -108.51},
1219 {-66.79, 127.71, -92.04},
1220 {-105.35, 148.51, -120.24},
1221 {-98.66, 131.72, -138.29},
1222 {-74.56, 141.50, -138.43},
1223 {-81.81, 158.43, -120.06}}},
1224 {{{-136.36, -85.85, -120.47},
1225 {-118.78, -89.03, -91.76},
1226 {-103.27, -82.20, -108.72},
1227 {-112.92, -61.61, -108.51},
1228 {-127.71, -66.79, -92.04},
1229 {-148.51, -105.35, -120.24},
1230 {-131.72, -98.66, -138.29},
1231 {-141.50, -74.56, -138.43},
1232 {-158.43, -81.81, -120.06}}},
1233 {{{85.85, -136.36, -120.47},
1234 {89.03, -118.78, -91.76},
1235 {82.20, -103.27, -108.72},
1236 {61.61, -112.92, -108.51},
1237 {66.79, -127.71, -92.04},
1238 {105.35, -148.51, -120.24},
1239 {98.66, -131.72, -138.29},
1240 {74.56, -141.50, -138.43},
1241 {81.81, -158.43, -120.06}}}}};
1242
1243// Assuming this is the 1
1244std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeGreenPositionBack = {{{{{0., 0., 0.},
1245 {0., 0., 0.},
1246 {0., 0., 0.},
1247 {0., 0., 0.},
1248 {0., 0., 0.},
1249 {0., 0., 0.},
1250 {0., 0., 0.},
1251 {0., 0., 0.},
1252 {0., 0., 0.}}},
1253 {{{136.36, 85.85, 120.47},
1254 {118.78, 89.03, 91.76},
1255 {127.71, 66.79, 92.04},
1256 {112.92, 61.61, 108.51},
1257 {103.27, 82.20, 108.72},
1258 {148.51, 105.35, 120.24},
1259 {158.43, 81.81, 120.06},
1260 {141.50, 74.56, 138.43},
1261 {131.72, 98.66, 138.29}}},
1262 {{{-85.85, 136.36, 120.47},
1263 {-89.03, 118.78, 91.76},
1264 {-66.79, 127.71, 92.04},
1265 {-61.61, 112.92, 108.51},
1266 {-82.20, 103.27, 108.72},
1267 {-105.35, 148.51, 120.24},
1268 {-81.81, 158.43, 120.06},
1269 {-74.56, 141.50, 138.43},
1270 {-98.66, 131.72, 138.29}}},
1271 {{{-136.36, -85.85, 120.47},
1272 {-118.78, -89.03, 91.76},
1273 {-127.71, -66.79, 92.04},
1274 {-112.92, -61.61, 108.51},
1275 {-103.27, -82.20, 108.72},
1276 {-148.51, -105.35, 120.24},
1277 {-158.43, -81.81, 120.06},
1278 {-141.50, -74.56, 138.43},
1279 {-131.72, -98.66, 138.29}}},
1280 {{{85.85, -136.36, 120.47},
1281 {89.03, -118.78, 91.76},
1282 {66.79, -127.71, 92.04},
1283 {61.61, -112.92, 108.51},
1284 {82.20, -103.27, 108.72},
1285 {105.35, -148.51, 120.24},
1286 {81.81, -158.43, 120.06},
1287 {74.56, -141.50, 138.43},
1288 {98.66, -131.72, 138.29}}},
1289 {{{172.08, 100.64, -27.13},
1290 {139.81, 97.74, -36.80},
1291 {149.00, 75.60, -36.42},
1292 {149.20, 76.64, -13.71},
1293 {139.97, 97.40, -12.83},
1294 {179.02, 117.99, -40.50},
1295 {188.78, 94.39, -40.74},
1296 {188.84, 94.16, -14.73},
1297 {178.91, 118.21, -14.96}}},
1298 {{{50.52, 192.85, -27.13},
1299 {29.74, 167.97, -36.80},
1300 {51.90, 158.82, -36.42},
1301 {51.31, 159.69, -13.71},
1302 {30.10, 167.85, -12.83},
1303 {43.16, 210.02, -40.50},
1304 {66.75, 200.23, -40.74},
1305 {66.95, 200.11, -14.73},
1306 {42.93, 210.09, -14.96}}},
1307 {{{-100.64, 172.08, -27.13},
1308 {-97.74, 139.81, -36.80},
1309 {-75.60, 149.00, -36.42},
1310 {-76.64, 149.20, -13.71},
1311 {-97.40, 139.97, -12.83},
1312 {-117.99, 179.02, -40.50},
1313 {-94.39, 188.78, -40.74},
1314 {-94.16, 188.84, -14.73},
1315 {-118.21, 178.91, -14.96}}},
1316 {{{-192.85, 50.52, -27.13},
1317 {-167.97, 29.74, -36.80},
1318 {-158.82, 51.90, -36.42},
1319 {-159.69, 51.31, -13.71},
1320 {-167.85, 30.10, -12.83},
1321 {-210.02, 43.16, -40.50},
1322 {-200.23, 66.75, -40.74},
1323 {-200.11, 66.95, -14.73},
1324 {-210.09, 42.93, -14.96}}},
1325 {{{-172.08, -100.64, -27.13},
1326 {-139.81, -97.74, -36.80},
1327 {-149.00, -75.60, -36.42},
1328 {-149.20, -76.64, -13.71},
1329 {-139.97, -97.40, -12.83},
1330 {-179.02, -117.99, -40.50},
1331 {-188.78, -94.39, -40.74},
1332 {-188.84, -94.16, -14.73},
1333 {-178.91, -118.21, -14.96}}},
1334 {{{-50.52, -192.85, -27.13},
1335 {-29.74, -167.97, -36.80},
1336 {-51.90, -158.82, -36.42},
1337 {-51.31, -159.69, -13.71},
1338 {-30.10, -167.85, -12.83},
1339 {-43.16, -210.02, -40.50},
1340 {-66.75, -200.23, -40.74},
1341 {-66.95, -200.11, -14.73},
1342 {-42.93, -210.09, -14.96}}},
1343 {{{100.64, -172.08, -27.13},
1344 {97.74, -139.81, -36.80},
1345 {75.60, -149.00, -36.42},
1346 {76.64, -149.20, -13.71},
1347 {97.40, -139.97, -12.83},
1348 {117.99, -179.02, -40.50},
1349 {94.39, -188.78, -40.74},
1350 {94.16, -188.84, -14.73},
1351 {118.21, -178.91, -14.96}}},
1352 {{{192.85, -50.52, -27.13},
1353 {167.97, -29.74, -36.80},
1354 {158.82, -51.90, -36.42},
1355 {159.69, -51.31, -13.71},
1356 {167.85, -30.10, -12.83},
1357 {210.02, -43.16, -40.50},
1358 {200.23, -66.75, -40.74},
1359 {200.11, -66.95, -14.73},
1360 {210.09, -42.93, -14.96}}},
1361 {{{100.92, 71.17, -158.84},
1362 {70.69, 69.11, -143.80},
1363 {80.13, 47.08, -143.55},
1364 {95.01, 54.19, -127.90},
1365 {86.51, 75.25, -126.87},
1366 {95.59, 83.43, -177.52},
1367 {105.20, 59.77, -177.67},
1368 {122.26, 66.58, -159.26},
1369 {112.17, 90.56, -159.45}}},
1370 {{{-71.17, 100.92, -158.84},
1371 {-69.11, 70.69, -143.80},
1372 {-47.08, 80.13, -143.55},
1373 {-54.19, 95.01, -127.90},
1374 {-75.25, 86.51, -126.87},
1375 {-83.43, 95.59, -177.52},
1376 {-59.77, 105.20, -177.67},
1377 {-66.58, 122.26, -159.26},
1378 {-90.56, 112.17, -159.45}}},
1379 {{{-100.92, -71.17, -158.84},
1380 {-70.69, -69.11, -143.80},
1381 {-80.13, -47.08, -143.55},
1382 {-95.01, -54.19, -127.90},
1383 {-86.51, -75.25, -126.87},
1384 {-95.59, -83.43, -177.52},
1385 {-105.20, -59.77, -177.67},
1386 {-122.26, -66.58, -159.26},
1387 {-112.17, -90.56, -159.45}}},
1388 {{{71.17, -100.92, -158.84},
1389 {69.11, -70.69, -143.80},
1390 {47.08, -80.13, -143.55},
1391 {54.19, -95.01, -127.90},
1392 {75.25, -86.51, -126.87},
1393 {83.43, -95.59, -177.52},
1394 {59.77, -105.20, -177.67},
1395 {66.58, -122.26, -159.26},
1396 {90.56, -112.17, -159.45}}}}};
1397
1398// Assuming this is the 2
1399std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeRedPositionBack = {{{{{0., 0., 0.},
1400 {0., 0., 0.},
1401 {0., 0., 0.},
1402 {0., 0., 0.},
1403 {0., 0., 0.},
1404 {0., 0., 0.},
1405 {0., 0., 0.},
1406 {0., 0., 0.},
1407 {0., 0., 0.}}},
1408 {{{157.13, 35.72, 120.47},
1409 {146.94, 21.03, 91.76},
1410 {131.15, 14.90, 108.72},
1411 {123.41, 36.28, 108.51},
1412 {137.53, 43.08, 92.04},
1413 {179.50, 30.52, 120.24},
1414 {162.90, 23.38, 138.29},
1415 {152.78, 47.34, 138.43},
1416 {169.87, 54.17, 120.06}}},
1417 {{{-35.72, 157.13, 120.47},
1418 {-21.03, 146.94, 91.76},
1419 {-14.90, 131.15, 108.72},
1420 {-36.28, 123.41, 108.51},
1421 {-43.08, 137.53, 92.04},
1422 {-30.52, 179.50, 120.24},
1423 {-23.38, 162.90, 138.29},
1424 {-47.34, 152.78, 138.43},
1425 {-54.17, 169.87, 120.06}}},
1426 {{{-157.13, -35.72, 120.47},
1427 {-146.94, -21.03, 91.76},
1428 {-131.15, -14.90, 108.72},
1429 {-123.41, -36.28, 108.51},
1430 {-137.53, -43.08, 92.04},
1431 {-179.50, -30.52, 120.24},
1432 {-162.90, -23.38, 138.29},
1433 {-152.78, -47.34, 138.43},
1434 {-169.87, -54.17, 120.06}}},
1435 {{{35.72, -157.13, 120.47},
1436 {21.03, -146.94, 91.76},
1437 {14.90, -131.15, 108.72},
1438 {36.28, -123.41, 108.51},
1439 {43.08, -137.53, 92.04},
1440 {30.52, -179.50, 120.24},
1441 {23.38, -162.90, 138.29},
1442 {47.34, -152.78, 138.43},
1443 {54.17, -169.87, 120.06}}},
1444 {{{192.85, 50.52, -27.13},
1445 {167.97, 29.74, -36.80},
1446 {167.85, 30.10, -12.83},
1447 {159.69, 51.31, -13.71},
1448 {158.82, 51.90, -36.42},
1449 {210.02, 43.16, -40.50},
1450 {210.09, 42.93, -14.96},
1451 {200.11, 66.95, -14.73},
1452 {200.23, 66.75, -40.74}}},
1453 {{{100.64, 172.08, -27.13},
1454 {97.74, 139.81, -36.80},
1455 {97.40, 139.97, -12.83},
1456 {76.64, 149.20, -13.71},
1457 {75.60, 149.00, -36.42},
1458 {117.99, 179.02, -40.50},
1459 {118.21, 178.91, -14.96},
1460 {94.16, 188.84, -14.73},
1461 {94.39, 188.78, -40.74}}},
1462 {{{-50.52, 192.85, -27.13},
1463 {-29.74, 167.97, -36.80},
1464 {-30.10, 167.85, -12.83},
1465 {-51.31, 159.69, -13.71},
1466 {-51.90, 158.82, -36.42},
1467 {-43.16, 210.02, -40.50},
1468 {-42.93, 210.09, -14.96},
1469 {-66.95, 200.11, -14.73},
1470 {-66.75, 200.23, -40.74}}},
1471 {{{-172.08, 100.64, -27.13},
1472 {-139.81, 97.74, -36.80},
1473 {-139.97, 97.40, -12.83},
1474 {-149.20, 76.64, -13.71},
1475 {-149.00, 75.60, -36.42},
1476 {-179.02, 117.99, -40.50},
1477 {-178.91, 118.21, -14.96},
1478 {-188.84, 94.16, -14.73},
1479 {-188.78, 94.39, -40.74}}},
1480 {{{-192.85, -50.52, -27.13},
1481 {-167.97, -29.74, -36.80},
1482 {-167.85, -30.10, -12.83},
1483 {-159.69, -51.31, -13.71},
1484 {-158.82, -51.90, -36.42},
1485 {-210.02, -43.16, -40.50},
1486 {-210.09, -42.93, -14.96},
1487 {-200.11, -66.95, -14.73},
1488 {-200.23, -66.75, -40.74}}},
1489 {{{-100.64, -172.08, -27.13},
1490 {-97.74, -139.81, -36.80},
1491 {-97.40, -139.97, -12.83},
1492 {-76.64, -149.20, -13.71},
1493 {-75.60, -149.00, -36.42},
1494 {-117.99, -179.02, -40.50},
1495 {-118.21, -178.91, -14.96},
1496 {-94.16, -188.84, -14.73},
1497 {-94.39, -188.78, -40.74}}},
1498 {{{50.52, -192.85, -27.13},
1499 {29.74, -167.97, -36.80},
1500 {30.10, -167.85, -12.83},
1501 {51.31, -159.69, -13.71},
1502 {51.90, -158.82, -36.42},
1503 {43.16, -210.02, -40.50},
1504 {42.93, -210.09, -14.96},
1505 {66.95, -200.11, -14.73},
1506 {66.75, -200.23, -40.74}}},
1507 {{{172.08, -100.64, -27.13},
1508 {139.81, -97.74, -36.80},
1509 {139.97, -97.40, -12.83},
1510 {149.20, -76.64, -13.71},
1511 {149.00, -75.60, -36.42},
1512 {179.02, -117.99, -40.50},
1513 {178.91, -118.21, -14.96},
1514 {188.84, -94.16, -14.73},
1515 {188.78, -94.39, -40.74}}},
1516 {{{121.68, 21.04, -158.84},
1517 {98.86, 1.12, -143.80},
1518 {114.39, 7.96, -126.87},
1519 {105.50, 28.86, -127.90},
1520 {89.95, 23.37, -143.55},
1521 {126.59, 8.60, -177.52},
1522 {143.35, 15.28, -159.45},
1523 {133.53, 39.37, -159.26},
1524 {116.65, 32.12, -177.67}}},
1525 {{{-21.04, 121.68, -158.84},
1526 {-1.12, 98.86, -143.80},
1527 {-7.96, 114.39, -126.87},
1528 {-28.86, 105.50, -127.90},
1529 {-23.37, 89.95, -143.55},
1530 {-8.60, 126.59, -177.52},
1531 {-15.28, 143.35, -159.45},
1532 {-39.37, 133.53, -159.26},
1533 {-32.12, 116.65, -177.67}}},
1534 {{{-121.68, -21.04, -158.84},
1535 {-98.86, -1.12, -143.80},
1536 {-114.39, -7.96, -126.87},
1537 {-105.50, -28.86, -127.90},
1538 {-89.95, -23.37, -143.55},
1539 {-126.59, -8.60, -177.52},
1540 {-143.35, -15.28, -159.45},
1541 {-133.53, -39.37, -159.26},
1542 {-116.65, -32.12, -177.67}}},
1543 {{{21.04, -121.68, -158.84},
1544 {1.12, -98.86, -143.80},
1545 {7.96, -114.39, -126.87},
1546 {28.86, -105.50, -127.90},
1547 {23.37, -89.95, -143.55},
1548 {8.60, -126.59, -177.52},
1549 {15.28, -143.35, -159.45},
1550 {39.37, -133.53, -159.26},
1551 {32.12, -116.65, -177.67}}}}};
1552
1553// Assuming this is the 3
1554std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeWhitePositionBack = {{{{{0., 0., 0.},
1555 {0., 0., 0.},
1556 {0., 0., 0.},
1557 {0., 0., 0.},
1558 {0., 0., 0.},
1559 {0., 0., 0.},
1560 {0., 0., 0.},
1561 {0., 0., 0.},
1562 {0., 0., 0.}}},
1563 {{{121.68, 21.04, 158.84},
1564 {98.86, 1.12, 143.80},
1565 {89.95, 23.37, 143.55},
1566 {105.50, 28.86, 127.90},
1567 {114.39, 7.96, 126.87},
1568 {126.59, 8.60, 177.52},
1569 {116.65, 32.12, 177.67},
1570 {133.53, 39.37, 159.26},
1571 {143.35, 15.28, 159.45}}},
1572 {{{-21.04, 121.68, 158.84},
1573 {-1.12, 98.86, 143.80},
1574 {-23.37, 89.95, 143.55},
1575 {-28.86, 105.50, 127.90},
1576 {-7.96, 114.39, 126.87},
1577 {-8.60, 126.59, 177.52},
1578 {-32.12, 116.65, 177.67},
1579 {-39.37, 133.53, 159.26},
1580 {-15.28, 143.35, 159.45}}},
1581 {{{-121.68, -21.04, 158.84},
1582 {-98.86, -1.12, 143.80},
1583 {-89.95, -23.37, 143.55},
1584 {-105.50, -28.86, 127.90},
1585 {-114.39, -7.96, 126.87},
1586 {-126.59, -8.60, 177.52},
1587 {-116.65, -32.12, 177.67},
1588 {-133.53, -39.37, 159.26},
1589 {-143.35, -15.28, 159.45}}},
1590 {{{21.04, -121.68, 158.84},
1591 {1.12, -98.86, 143.80},
1592 {23.37, -89.95, 143.55},
1593 {28.86, -105.50, 127.90},
1594 {7.96, -114.39, 126.87},
1595 {8.60, -126.59, 177.52},
1596 {32.12, -116.65, 177.67},
1597 {39.37, -133.53, 159.26},
1598 {15.28, -143.35, 159.45}}},
1599 {{{192.85, 50.52, 27.13},
1600 {167.97, 29.74, 36.80},
1601 {158.82, 51.90, 36.42},
1602 {159.69, 51.31, 13.71},
1603 {167.85, 30.10, 12.83},
1604 {210.02, 43.16, 40.50},
1605 {200.23, 66.75, 40.74},
1606 {200.11, 66.95, 14.73},
1607 {210.09, 42.93, 14.96}}},
1608 {{{100.64, 172.08, 27.13},
1609 {97.74, 139.81, 36.80},
1610 {75.60, 149.00, 36.42},
1611 {76.64, 149.20, 13.71},
1612 {97.40, 139.97, 12.83},
1613 {117.99, 179.02, 40.50},
1614 {94.39, 188.78, 40.74},
1615 {94.16, 188.84, 14.73},
1616 {118.21, 178.91, 14.96}}},
1617 {{{-50.52, 192.85, 27.13},
1618 {-29.74, 167.97, 36.80},
1619 {-51.90, 158.82, 36.42},
1620 {-51.31, 159.69, 13.71},
1621 {-30.10, 167.85, 12.83},
1622 {-43.16, 210.02, 40.50},
1623 {-66.75, 200.23, 40.74},
1624 {-66.95, 200.11, 14.73},
1625 {-42.93, 210.09, 14.96}}},
1626 {{{-172.08, 100.64, 27.13},
1627 {-139.81, 97.74, 36.80},
1628 {-149.00, 75.60, 36.42},
1629 {-149.20, 76.64, 13.71},
1630 {-139.97, 97.40, 12.83},
1631 {-179.02, 117.99, 40.50},
1632 {-188.78, 94.39, 40.74},
1633 {-188.84, 94.16, 14.73},
1634 {-178.91, 118.21, 14.96}}},
1635 {{{-192.85, -50.52, 27.13},
1636 {-167.97, -29.74, 36.80},
1637 {-158.82, -51.90, 36.42},
1638 {-159.69, -51.31, 13.71},
1639 {-167.85, -30.10, 12.83},
1640 {-210.02, -43.16, 40.50},
1641 {-200.23, -66.75, 40.74},
1642 {-200.11, -66.95, 14.73},
1643 {-210.09, -42.93, 14.96}}},
1644 {{{-100.64, -172.08, 27.13},
1645 {-97.74, -139.81, 36.80},
1646 {-75.60, -149.00, 36.42},
1647 {-76.64, -149.20, 13.71},
1648 {-97.40, -139.97, 12.83},
1649 {-117.99, -179.02, 40.50},
1650 {-94.39, -188.78, 40.74},
1651 {-94.16, -188.84, 14.73},
1652 {-118.21, -178.91, 14.96}}},
1653 {{{50.52, -192.85, 27.13},
1654 {29.74, -167.97, 36.80},
1655 {51.90, -158.82, 36.42},
1656 {51.31, -159.69, 13.71},
1657 {30.10, -167.85, 12.83},
1658 {43.16, -210.02, 40.50},
1659 {66.75, -200.23, 40.74},
1660 {66.95, -200.11, 14.73},
1661 {42.93, -210.09, 14.96}}},
1662 {{{172.08, -100.64, 27.13},
1663 {139.81, -97.74, 36.80},
1664 {149.00, -75.60, 36.42},
1665 {149.20, -76.64, 13.71},
1666 {139.97, -97.40, 12.83},
1667 {179.02, -117.99, 40.50},
1668 {188.78, -94.39, 40.74},
1669 {188.84, -94.16, 14.73},
1670 {178.91, -118.21, 14.96}}},
1671 {{{157.13, 35.72, -120.47},
1672 {146.94, 21.03, -91.76},
1673 {137.53, 43.08, -92.04},
1674 {123.41, 36.28, -108.51},
1675 {131.15, 14.90, -108.72},
1676 {179.50, 30.52, -120.24},
1677 {169.87, 54.17, -120.06},
1678 {152.78, 47.34, -138.43},
1679 {162.90, 23.38, -138.29}}},
1680 {{{-35.72, 157.13, -120.47},
1681 {-21.03, 146.94, -91.76},
1682 {-43.08, 137.53, -92.04},
1683 {-36.28, 123.41, -108.51},
1684 {-14.90, 131.15, -108.72},
1685 {-30.52, 179.50, -120.24},
1686 {-54.17, 169.87, -120.06},
1687 {-47.34, 152.78, -138.43},
1688 {-23.38, 162.90, -138.29}}},
1689 {{{-157.13, -35.72, -120.47},
1690 {-146.94, -21.03, -91.76},
1691 {-137.53, -43.08, -92.04},
1692 {-123.41, -36.28, -108.51},
1693 {-131.15, -14.90, -108.72},
1694 {-179.50, -30.52, -120.24},
1695 {-169.87, -54.17, -120.06},
1696 {-152.78, -47.34, -138.43},
1697 {-162.90, -23.38, -138.29}}},
1698 {{{35.72, -157.13, -120.47},
1699 {21.03, -146.94, -91.76},
1700 {43.08, -137.53, -92.04},
1701 {36.28, -123.41, -108.51},
1702 {14.90, -131.15, -108.72},
1703 {30.52, -179.50, -120.24},
1704 {54.17, -169.87, -120.06},
1705 {47.34, -152.78, -138.43},
1706 {23.38, -162.90, -138.29}}}}};
1707
1708std::array<std::array<std::array<bool, 5>, 4>, 4> TTigress::fBGOSuppression = {{{{{true, true, true, true, true},
1709 {true, false, false, false, false},
1710 {false, false, false, false, false},
1711 {false, false, false, false, true}}},
1712 {{{false, false, false, false, true},
1713 {true, true, true, true, true},
1714 {true, false, false, false, false},
1715 {false, false, false, false, false}}},
1716 {{{false, false, false, false, false},
1717 {false, false, false, false, true},
1718 {true, true, true, true, true},
1719 {true, false, false, false, false}}},
1720 {{{true, false, false, false, false},
1721 {false, false, false, false, false},
1722 {false, false, false, false, true},
1723 {true, true, true, true, true}}}}};
RESET_COLOR
#define RESET_COLOR
Definition Globals.h:5
ALERTTEXT
#define ALERTTEXT
Definition Globals.h:35
DefaultSuppression
bool DefaultSuppression(TDetectorHit *tig, TBgoHit &bgo)
Definition TTigress.cxx:60
DefaultAddback
bool DefaultAddback(TDetectorHit *one, TDetectorHit *two)
Definition TTigress.cxx:19
TAnalysisOptions::AddbackWindow
double AddbackWindow() const
Definition TAnalysisOptions.h:50
TAnalysisOptions::IsWaveformFitting
bool IsWaveformFitting() const
Definition TAnalysisOptions.h:43
TChannel::GetDetectorNumber
int GetDetectorNumber() const
Definition TChannel.cxx:1566
TChannel::GetCrystalNumber
int GetCrystalNumber() const
Definition TChannel.cxx:1600
TChannel::GetSegmentNumber
int GetSegmentNumber() const
Definition TChannel.cxx:1576
TChannel::GetMnemonic
const TMnemonic * GetMnemonic() const
Definition TChannel.cxx:1712
TDetectorHit::GetEnergy
virtual double GetEnergy(Option_t *opt="") const
Definition TDetectorHit.cxx:74
TDetectorHit::GetCrystal
virtual Int_t GetCrystal() const
!
Definition TDetectorHit.cxx:214
TDetectorHit::GetChannel
TChannel * GetChannel() const
!
Definition TDetectorHit.h:146
TDetectorHit::GetDetector
virtual Int_t GetDetector() const
!
Definition TDetectorHit.cxx:196
TDetectorHit::GetCfd
virtual Float_t GetCfd() const
!
Definition TDetectorHit.h:140
TDetectorHit::GetSegment
virtual Int_t GetSegment() const
!
Definition TDetectorHit.cxx:205
TDetectorHit::GetTime
virtual Double_t GetTime(const ETimeFlag &correct_flag=ETimeFlag::kAll, Option_t *opt="") const
Returns a time value to the nearest nanosecond!
Definition TDetectorHit.cxx:45
TDetectorHit::SetAddress
void SetAddress(const UInt_t &temp_address)
!
Definition TDetectorHit.h:106
TDetectorHit::Print
void Print(Option_t *opt="") const override
!
Definition TDetectorHit.cxx:151
TDetector::Copy
void Copy(TObject &) const override
!
Definition TDetector.cxx:24
TDetector::NoHits
virtual bool NoHits() const
Definition TDetector.h:72
TDetector::GetMultiplicity
virtual Short_t GetMultiplicity() const
Definition TDetector.h:70
TDetector::GetHit
virtual TDetectorHit * GetHit(const int &index) const
Definition TDetector.cxx:84
TDetector::Clear
void Clear(Option_t *="") override
!
Definition TDetector.cxx:67
TDetector::Hits
std::vector< TDetectorHit * > & Hits()
Definition TDetector.h:74
TDetector::AddHit
virtual void AddHit(TDetectorHit *hit)
Definition TDetector.h:60
TGRSIOptions::AnalysisOptions
static TAnalysisOptions * AnalysisOptions()
Definition TGRSIOptions.h:69
TMnemonic::OutputSensor
virtual EMnemonic OutputSensor() const
Definition TMnemonic.h:66
TMnemonic::SubSystem
virtual EMnemonic SubSystem() const
Definition TMnemonic.h:62
TSingleton< TSortingDiagnostics >::Get
static TSortingDiagnostics * Get(bool verbose=false)
Definition TSingleton.h:33
TSortingDiagnostics::RemovedHits
void RemovedHits(TClass *detClass, int64_t removed, int64_t total)
Definition TSortingDiagnostics.cxx:154
TTigressHit::GetLastPosition
TVector3 GetLastPosition(Double_t dist=0.) const
Definition TTigressHit.cxx:58
TTigressHit::SumHit
void SumHit(TTigressHit *)
!
Definition TTigressHit.cxx:113
TTigressHit::GetFirstSeg
int GetFirstSeg() const
Definition TTigressHit.h:104
TTigressHit::CoreSet
bool CoreSet() const
Definition TTigressHit.h:82
TTigressHit::AddSegment
void AddSegment(const TDetectorHit &seg)
!
Definition TTigressHit.h:56
TTigressHit::CopyFragment
void CopyFragment(const TFragment &frag)
Definition TTigressHit.cxx:20
TTigress::GetAddbackMultiplicity
Int_t GetAddbackMultiplicity()
Definition TTigress.cxx:146
TTigress::fBgos
std::vector< TBgoHit > fBgos
Definition TTigress.h:61
TTigress::Copy
void Copy(TObject &) const override
!
Definition TTigress.cxx:88
TTigress::GetVectorsBuilt
static bool GetVectorsBuilt()
!
Definition TTigress.h:171
TTigress::fAddbackHits
std::vector< TDetectorHit * > fAddbackHits
! Used to create addback hits on the fly
Definition TTigress.h:131
TTigress::fAddbackCriterion
static std::function< bool(TDetectorHit *, TDetectorHit *)> fAddbackCriterion
Definition TTigress.h:101
TTigress::ResetAddback
void ResetAddback()
!
Definition TTigress.cxx:313
TTigress::fGeBluePositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeBluePositionBack
! detector segment XYZ
Definition TTigress.h:1089
TTigress::GetNAddbackFrags
UShort_t GetNAddbackFrags(size_t idx) const
Definition TTigress.cxx:325
TTigress::GetArrayBackPos
static bool GetArrayBackPos()
!
Definition TTigress.h:170
TTigress::GetTigressHit
TTigressHit * GetTigressHit(const int &i) const
Definition TTigress.h:57
TTigress::GetAddbackHit
TTigressHit * GetAddbackHit(const int &)
Definition TTigress.cxx:190
TTigress::fCloverRadial
static std::array< TVector3, 17 > fCloverRadial
! clover direction vectors
Definition TTigress.h:452
TTigress::fCloverCross
static std::array< std::array< TVector3, 2 >, 17 > fCloverCross
! clover perpendicular vectors, for smearing
Definition TTigress.h:114
TTigress::fGeBluePosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeBluePosition
! detector segment XYZ
Definition TTigress.h:470
TTigress::GetForceCrystal
static bool GetForceCrystal()
!
Definition TTigress.h:169
TTigress::fGeWhitePositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeWhitePositionBack
!
Definition TTigress.h:1554
TTigress::fTargetOffset
static double fTargetOffset
!
Definition TTigress.h:107
TTigress::SetGlobalBit
static void SetGlobalBit(ETigressGlobalBits bit, Bool_t set=true)
Definition TTigress.h:128
TTigress::AddFragment
void AddFragment(const std::shared_ptr< const TFragment > &, TChannel *) override
!
Definition TTigress.cxx:237
TTigress::BuildHits
void BuildHits() override
!
Definition TTigress.cxx:202
TTigress::fGeGreenPosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeGreenPosition
!
Definition TTigress.h:625
TTigress::fGeRedPositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeRedPositionBack
!
Definition TTigress.h:1399
TTigress::fGeRedPosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeRedPosition
!
Definition TTigress.h:780
TTigress::GetPosition
static TVector3 GetPosition(int DetNbr, int CryNbr, int SegNbr, double dist=0., bool smear=false)
!
Definition TTigress.cxx:340
TTigress::BuildVectors
static void BuildVectors()
!
Definition TTigress.cxx:366
TTigress::fSuppressionCriterion
static std::function< bool(TDetectorHit *, TBgoHit &)> fSuppressionCriterion
Definition TTigress.h:102
TTigress::TestGlobalBit
static Bool_t TestGlobalBit(ETigressGlobalBits bit)
Definition TTigress.h:129
TTigress::operator=
TTigress & operator=(const TTigress &)
!
Definition TTigress.cxx:140
TTigress::fGeGreenPositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeGreenPositionBack
!
Definition TTigress.h:1244
TTigress::Clear
void Clear(Option_t *opt="") override
!
Definition TTigress.cxx:114
TTigress::fTigressBits
TTransientBits< UShort_t > fTigressBits
Definition TTigress.h:105
TTigress::ETigressGlobalBits
ETigressGlobalBits
Definition TTigress.h:38
TTigress::Print
void Print(Option_t *opt="") const override
!
Definition TTigress.cxx:125
TTigress::fGlobalTigressBits
static TTransientBits< UShort_t > fGlobalTigressBits
!
Definition TTigress.h:104
TTigress::fGeWhitePosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeWhitePosition
!
Definition TTigress.h:935
TTigress::fPositionVectors
static std::array< std::array< std::array< std::array< TVector3, 9 >, 4 >, 17 >, 2 > fPositionVectors
!
Definition TTigress.h:111
TTigress::fRadialOffset
static double fRadialOffset
!
Definition TTigress.h:108
TTigress::fAddbackFrags
std::vector< UShort_t > fAddbackFrags
! Number of crystals involved in creating in the addback hit
Definition TTigress.h:132
TTigress::fBGOSuppression
static std::array< std::array< std::array< bool, 5 >, 4 >, 4 > fBGOSuppression
!
Definition TTigress.h:1708
TTransientBits::SetBit
void SetBit(T bit, Bool_t flag)
Definition TTransientBits.h:33
TTransientBits::TestBit
Bool_t TestBit(T bit) const
Definition TTransientBits.h:36
operator|
std::underlying_type_t< TTigress::ETigressGlobalBits > operator|(TTigress::ETigressGlobalBits lhs, TTigress::ETigressGlobalBits rhs)
Definition TTigress.cxx:72
grsi::exit_exception
Definition Globals.h:74