GRSISort "v4.1.1.0"
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 <sstream>
4#include <iostream>
5#include <iomanip>
6
7#include "TInterpreter.h"
8#include "TMnemonic.h"
9#include "TDetectorHit.h"
10#include "TGRSIOptions.h"
11#include "TSortingDiagnostics.h"
12
13////////////////////////////////////////////////////////////
14//
15// TTigress
16//
17// The TTigress class defines the observables and algorithms used
18// when analyzing TIGRESS data. It includes detector positions,
19// add-back methods, etc.
20//
21////////////////////////////////////////////////////////////
22
23bool DefaultTigressAddback(const TDetectorHit* one, const TDetectorHit* two)
24{
25 return ((one->GetDetector() == two->GetDetector()) &&
26 (std::fabs(one->GetTime() - two->GetTime()) < TGRSIOptions::AnalysisOptions()->AddbackWindow()));
27}
28
29std::function<bool(const TDetectorHit*, const TDetectorHit*)> TTigress::fAddbackCriterion = DefaultTigressAddback;
30
31bool DefaultTigressSuppression(const TDetectorHit* hit, const TDetectorHit* bgoHit)
32{
33 //return ((hit.GetDetector() == bgoHit.GetDetector() && hit.GetCrystal() == bgoHit.GetCrystal()) &&
34 return ((hit->GetDetector() == bgoHit->GetDetector()) &&
35 (std::fabs(hit->GetTime() - bgoHit->GetTime()) < TGRSIOptions::AnalysisOptions()->SuppressionWindow()) &&
36 (bgoHit->GetEnergy() > TGRSIOptions::AnalysisOptions()->SuppressionEnergy()));
37}
38
39std::function<bool(const TDetectorHit*, const TDetectorHit*)> TTigress::fSuppressionCriterion = DefaultTigressSuppression;
40
41double TTigress::fTargetOffset = 0.;
42double TTigress::fRadialOffset = 0.;
43
44TTransientBits<uint8_t> TTigress::fGlobalTigressBits = TTransientBits<uint8_t>(static_cast<std::underlying_type_t<TTigress::ETigressGlobalBits>>(TTigress::ETigressGlobalBits::kSetCoreWave));
45
46TTigress::TTigress()
47{
48 /// Default ctor. Ignores TObjectStreamer in ROOT < 6
49 Clear();
50}
51
52TTigress::TTigress(const TTigress& rhs) : TSuppressed(rhs)
53{
54 /// Copy ctor. Ignores TObjectStreamer in ROOT < 6
55 rhs.Copy(*this);
56}
57
58void TTigress::Copy(TObject& rhs) const
59{
60 // Copy function.
61 TSuppressed::Copy(rhs);
62
63 // no need to copy hits, this is already taken care of by TDetector::Copy (called by TSuppressed::Copy)
64 // not copying addback or suppressed vectors
65 for(auto& hit : static_cast<TTigress&>(rhs).fAddbackHits) {
66 delete hit;
67 }
68 for(auto& hit : static_cast<TTigress&>(rhs).fSuppressedHits) {
69 delete hit;
70 }
71 for(auto& hit : static_cast<TTigress&>(rhs).fSuppressedAddbackHits) {
72 delete hit;
73 }
74 static_cast<TTigress&>(rhs).fTigressBits = 0;
75 static_cast<TTigress&>(rhs).fAddbackHits.clear();
76 static_cast<TTigress&>(rhs).fAddbackFrags.clear();
77 static_cast<TTigress&>(rhs).fSuppressedHits.clear();
78 static_cast<TTigress&>(rhs).fSuppressedAddbackHits.clear();
79 static_cast<TTigress&>(rhs).fSuppressedAddbackFrags.clear();
80}
81
82TTigress::~TTigress()
83{
84 // Default Destructor
85 // no need to delete hits, this is taken care of by the destructor of TDetector
86 for(auto& hit : fAddbackHits) {
87 delete hit;
88 }
89 for(auto& hit : fSuppressedHits) {
90 delete hit;
91 }
92 for(auto& hit : fSuppressedAddbackHits) {
93 delete hit;
94 }
95}
96
97void TTigress::Clear(Option_t* opt)
98{
99 // Clears the mother, and all of the hits
100 ClearStatus();
101 TSuppressed::Clear(opt);
102 // hits cleared by TDetector::Clear
103 for(auto& hit : fAddbackHits) {
104 delete hit;
105 }
106 for(auto& hit : fSuppressedHits) {
107 delete hit;
108 }
109 for(auto& hit : fSuppressedAddbackHits) {
110 delete hit;
111 }
112 fAddbackHits.clear();
113 fAddbackFrags.clear();
114 fSuppressedHits.clear();
115 fSuppressedAddbackHits.clear();
116 fSuppressedAddbackFrags.clear();
117}
118
119void TTigress::Print(Option_t*) const
120{
121 Print(std::cout);
122}
123
124void TTigress::Print(std::ostream& out) const
125{
126 std::ostringstream str;
127 str << "Tigress contains " << std::setw(6) << GetMultiplicity() << " hits:" << std::endl;
128 for(const auto& hit : Hits()) {
129 static_cast<TTigressHit*>(hit)->Print(str);
130 }
131
132 if(IsAddbackSet()) {
133 str << std::setw(6) << fAddbackHits.size() << " addback hits" << std::endl;
134 } else {
135 str << std::setw(6) << " "
136 << " Addback not set" << std::endl;
137 }
138
139 str << std::setw(6) << " "
140 << " Cross-talk Set? " << IsCrossTalkSet() << std::endl;
141 out << str.str();
142}
143
144TTigress& TTigress::operator=(const TTigress& rhs)
145{
146 rhs.Copy(*this);
147 return *this;
148}
149
154
159
160void TTigress::SetAddback(const bool flag) const
161{
162 SetBitNumber(ETigressBits::kIsAddbackSet, flag);
163}
164
165void TTigress::SetCrossTalk(const bool flag) const
166{
167 SetBitNumber(ETigressBits::kIsCrossTalkSet, flag);
168}
169
170TTigressHit* TTigress::GetTigressHit(const int& i)
171{
172 /// Get Tigress hit indicated by index i.
173 /// Throws an out of range exception if the index is out of the range of the hit vector.
174 /// Applies cross-talk corrections if they haven't already been applied and are enabled.
175 /// Note: This is different from using TDetector::GetHit and casting the result to a `TTigressHit*`
176 /// as in that case no cross-talk corrections are applied.
177 try {
178 if(!IsCrossTalkSet()) {
179 FixCrossTalk();
180 }
181 return static_cast<TTigressHit*>(Hits().at(i));
182 } catch(const std::out_of_range& oor) {
183 std::cerr << ClassName() << " Hits are out of range: " << oor.what() << std::endl;
184 if(!gInterpreter) {
185 throw grsi::exit_exception(1);
186 }
187 }
188 return nullptr;
189}
190
191Short_t TTigress::GetAddbackMultiplicity()
192{
193 // Automatically builds the addback hits using the fAddbackCriterion (if the size of the fAddbackHits vector is zero)
194 // and return the number of addback hits.
195 if(!IsCrossTalkSet()) {
196 // Calculate Cross Talk on each hit
197 FixCrossTalk();
198 }
199 auto& hitVector = Hits();
200 if(hitVector.empty()) {
201 return 0;
202 }
203 // if the addback has been reset, clear the addback hits
204 if(!IsAddbackSet()) {
205 ResetAddback();
206 }
207 if(fAddbackHits.empty()) {
208 CreateAddback(hitVector, fAddbackHits, fAddbackFrags);
209 SetAddback(true);
210 }
211
212 return fAddbackHits.size();
213}
214
215TTigressHit* TTigress::GetAddbackHit(const int& i)
216{
217 if(i < GetAddbackMultiplicity()) {
218 return static_cast<TTigressHit*>(fAddbackHits[i]);
219 }
220 std::cerr << "Addback hits are out of range" << std::endl;
221 throw grsi::exit_exception(1);
222 return nullptr;
223}
224
225void TTigress::BuildHits()
226{
227 // remove all hits of segments only
228 // remove_if moves all elements to be removed to the end and returns an iterator to the first one to be removed
229 auto remove = std::remove_if(Hits().begin(), Hits().end(), [](TDetectorHit* h) -> bool { return !(static_cast<TTigressHit*>(h)->CoreSet()); });
230 // using remove_if the elements to be removed are left in an undefined state so we can only log how many we are removing!
231 TSortingDiagnostics::Get()->RemovedHits(IsA(), std::distance(remove, Hits().end()), Hits().size());
232 Hits().erase(remove, Hits().end());
233 for(auto& hit : Hits()) {
234 auto* tigressHit = static_cast<TTigressHit*>(hit);
235 if(tigressHit->GetNSegments() > 1) {
236 tigressHit->SortSegments();
237 }
238
239 if(tigressHit->HasWave() && TGRSIOptions::AnalysisOptions()->IsWaveformFitting()) {
240 tigressHit->SetWavefit();
241 }
242 }
243 std::sort(Hits().begin(), Hits().end()); // sorting an empty vector is fine, no need to check for that
244}
245
246void TTigress::AddFragment(const std::shared_ptr<const TFragment>& frag, TChannel* chan)
247{
248 /// Builds the TIGRESS Hits directly from the TFragment. Basically, loops through the hits for an event and sets
249 /// observables.
250 if(frag == nullptr || chan == nullptr) {
251 return;
252 }
253 const TMnemonic* mnemonic = chan->GetMnemonic();
254 if(mnemonic == nullptr) {
255 std::cerr << "Trying to add fragment to TTigress w/o mnemonic in TChannel!" << std::endl;
256 return;
257 }
258
259 if(mnemonic->SubSystem() != TMnemonic::EMnemonic::kG) {
260 std::cerr << __PRETTY_FUNCTION__ << ": not a TIGRESS detector: '" << static_cast<std::underlying_type_t<TMnemonic::EMnemonic>>(mnemonic->SubSystem()) << "' from " << mnemonic << " = " << mnemonic->GetName() << std::endl; // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
261 return;
262 }
263
264 // check whether we have a core (0 or 9) or a segment (any other number)
265 if(chan->GetSegmentNumber() == 0 || chan->GetSegmentNumber() == 9) {
266 // loop over existing hits to see if this core was already created by a previously found segment
267 // of course this means if we have a core in "coincidence" with itself we will overwrite the first hit
268 for(Short_t i = 0; i < GetMultiplicity(); ++i) {
269 TTigressHit* hit = GetTigressHit(i);
270 if((hit->GetDetector() == chan->GetDetectorNumber()) &&
271 (hit->GetCrystal() == chan->GetCrystalNumber())) { // we have a match;
272
273 // B cores will not replace A cores, but they will replace no-core hits created if segments are processed first.
274 if(chan->GetMnemonic()->OutputSensor() == TMnemonic::EMnemonic::kB) {
275 TChannel* channel = hit->GetChannel();
276 if(channel != nullptr && channel->GetMnemonic()->OutputSensor() == TMnemonic::EMnemonic::kA) {
277 return;
278 }
279 }
280
281 hit->CopyFragment(*frag);
282 hit->CoreSet(true);
283 if(TestGlobalBit(ETigressGlobalBits::kSetCoreWave)) {
284 frag->CopyWave(*hit);
285 }
286 return;
287 }
288 }
289 // we haven't found this crystal in the existing hits, so we create a new one
290 auto* hit = new TTigressHit(*frag);
291 hit->CoreSet(true);
292 if(TestGlobalBit(ETigressGlobalBits::kSetCoreWave)) {
293 frag->CopyWave(*hit);
294 }
295 AddHit(hit);
296 return;
297 } else {
298 // create a temporary segment hit (with waveform if requested)
299 TDetectorHit temp(*frag);
300 if(TestGlobalBit(ETigressGlobalBits::kSetSegWave)) {
301 frag->CopyWave(temp);
302 }
303 // check if the crystal this segment belongs to already exists
304 for(Short_t i = 0; i < GetMultiplicity(); ++i) {
305 TTigressHit* hit = GetTigressHit(i);
306 if((hit->GetDetector() == chan->GetDetectorNumber()) &&
307 (hit->GetCrystal() == chan->GetCrystalNumber())) { // we have a match;
308 hit->AddSegment(temp);
309 return;
310 }
311 }
312 // haven't found matching crystal, so we create a new core hit with a fake address
313 auto* corehit = new TTigressHit;
314 corehit->SetAddress(frag->GetAddress()); // fake it till you make it
315 corehit->AddSegment(temp);
316 AddHit(corehit);
317 return;
318 }
319
320 std::cout << ALERTTEXT << "failed to build!" << RESET_COLOR << std::endl;
321 frag->Print();
322}
323
324void TTigress::ResetFlags() const
325{
326 fTigressBits = 0;
327}
328
329void TTigress::ResetAddback()
330{
331 SetAddback(false);
332 SetCrossTalk(false);
333 for(auto& hit : fAddbackHits) {
334 delete hit;
335 }
336 fAddbackHits.clear();
337 fAddbackFrags.clear();
338}
339
340UShort_t TTigress::GetNAddbackFrags(const size_t& idx)
341{
342 // Get the number of addback "fragments" contributing to the total addback hit
343 // with index idx.
344 if(idx < fAddbackFrags.size()) {
345 return fAddbackFrags[idx];
346 }
347 return 0;
348}
349
350void TTigress::SetBitNumber(enum ETigressBits bit, Bool_t set) const
351{
352 // Used to set the flags that are stored in TTigress.
353 fTigressBits.SetBit(bit, set);
354}
355
356Double_t TTigress::CTCorrectedEnergy(const TTigressHit* const hit_to_correct, const TTigressHit* const other_hit,
357 Bool_t time_constraint)
358{
359 if((hit_to_correct == nullptr) || (other_hit == nullptr)) {
360 std::cerr << "One of the hits is invalid in TTigress::CTCorrectedEnergy" << std::endl;
361 return 0;
362 }
363
364 if(time_constraint) {
365 // Figure out if this passes the selected window
366 if(TMath::Abs(other_hit->GetTime() - hit_to_correct->GetTime()) >
367 TGRSIOptions::AnalysisOptions()->AddbackWindow()) { // placeholder
368 return hit_to_correct->GetEnergy();
369 }
370 }
371
372 if(hit_to_correct->GetDetector() != other_hit->GetDetector()) {
373 return hit_to_correct->GetEnergy();
374 }
375 static std::array<bool, 256> been_warned = {false};
376 double fixed_energy = hit_to_correct->GetEnergy();
377 try {
378 if(hit_to_correct->GetChannel() != nullptr) {
379 fixed_energy -= hit_to_correct->GetChannel()->GetCTCoeff().at(other_hit->GetCrystal()) * other_hit->GetNoCTEnergy();
380 }
381 } catch(const std::out_of_range& oor) {
382 int id = 16 * hit_to_correct->GetDetector() + 4 * hit_to_correct->GetCrystal() + other_hit->GetCrystal();
383 if(!been_warned[id]) {
384 been_warned[id] = true;
385 std::cerr << DRED << "Missing CT correction for Det: " << hit_to_correct->GetDetector()
386 << " Crystals: " << hit_to_correct->GetCrystal() << " " << other_hit->GetCrystal() << " (id " << id << ")" << RESET_COLOR << std::endl;
387 }
388 return hit_to_correct->GetEnergy();
389 }
390
391 return fixed_energy;
392}
393
394void TTigress::FixCrossTalk()
395{
396 if(!TGRSIOptions::AnalysisOptions()->IsCorrectingCrossTalk()) { return; }
397
398 auto& hitVector = Hits();
399 if(hitVector.size() < 2) {
400 SetCrossTalk(true);
401 return;
402 }
403 for(auto& hit : hitVector) {
404 static_cast<TTigressHit*>(hit)->ClearEnergy();
405 }
406
407 for(auto& one : hitVector) {
408 for(auto& two : hitVector) {
409 one->SetEnergy(CTCorrectedEnergy(static_cast<TTigressHit*>(one), static_cast<TTigressHit*>(two)));
410 }
411 }
412 SetCrossTalk(true);
413}
414
415const char* TTigress::GetColorFromNumber(int number)
416{
417 switch(number) {
418 case(0): return "B";
419 case(1): return "G";
420 case(2): return "R";
421 case(3): return "W";
422 };
423 return "X";
424}
425
430
435
436TTigressHit* TTigress::GetSuppressedHit(const int& i)
437{
438 try {
439 if(!IsCrossTalkSet()) {
440 FixCrossTalk();
441 }
442 return static_cast<TTigressHit*>(fSuppressedHits.at(i));
443 } catch(const std::out_of_range& oor) {
444 std::cerr << ClassName() << " Suppressed hits are out of range: " << oor.what() << std::endl;
445 if(!gInterpreter) {
446 throw grsi::exit_exception(1);
447 }
448 }
449 return nullptr;
450}
451
452Short_t TTigress::GetSuppressedMultiplicity(const TBgo* bgo)
453{
454 /// Automatically builds the suppressed hits using the fSuppressionCriterion and returns the number of suppressed hits
455 if(!IsCrossTalkSet()) {
456 // Calculate Cross Talk on each hit
457 FixCrossTalk();
458 }
459 auto& hitVector = Hits();
460 if(hitVector.empty()) {
461 return 0;
462 }
463 // if the suppressed has been reset, clear the suppressed hits
464 if(!IsSuppressed()) {
465 ResetSuppressed();
466 }
467 if(fSuppressedHits.empty()) {
468 CreateSuppressed(bgo, hitVector, fSuppressedHits);
469 SetSuppressed(true);
470 }
471
472 return fSuppressedHits.size();
473}
474
475void TTigress::SetSuppressed(const bool flag) const
476{
477 SetBitNumber(ETigressBits::kIsSuppressed, flag);
478}
479
480void TTigress::ResetSuppressed()
481{
482 SetSuppressed(false);
483 for(auto& hit : fSuppressedHits) {
484 delete hit;
485 }
486 fSuppressedHits.clear();
487}
488
489TTigressHit* TTigress::GetSuppressedAddbackHit(const int& i)
490{
491 try {
492 if(!IsCrossTalkSet()) {
493 FixCrossTalk();
494 }
495 return static_cast<TTigressHit*>(fSuppressedAddbackHits.at(i));
496 } catch(const std::out_of_range& oor) {
497 std::cerr << ClassName() << " Suppressed addback hits are out of range: " << oor.what() << std::endl;
498 if(!gInterpreter) {
499 throw grsi::exit_exception(1);
500 }
501 }
502 return nullptr;
503}
504
505Short_t TTigress::GetSuppressedAddbackMultiplicity(const TBgo* bgo)
506{
507 /// Automatically builds the suppressed addback hits using the fAddbackCriterion (if the size of the fAddbackHits vector is zero)
508 /// and return the number of suppressed addback hits.
509 if(!IsCrossTalkSet()) {
510 // Calculate Cross Talk on each hit
511 FixCrossTalk();
512 }
513 auto& hitVector = Hits();
514 if(hitVector.empty()) {
515 return 0;
516 }
517 // if the addback has been reset, clear the addback hits
518 if(!IsSuppressedAddbackSet()) {
519 ResetSuppressedAddback();
520 }
521 if(fSuppressedAddbackHits.empty()) {
522 CreateSuppressedAddback(bgo, hitVector, fSuppressedAddbackHits, fSuppressedAddbackFrags);
523 SetSuppressedAddback(true);
524 }
525
526 return fSuppressedAddbackHits.size();
527}
528
533
534void TTigress::ResetSuppressedAddback()
535{
536 SetSuppressedAddback(false);
537 for(auto& hit : fSuppressedAddbackHits) {
538 delete hit;
539 }
540 fSuppressedAddbackHits.clear();
541 fSuppressedAddbackFrags.clear();
542}
543
544UShort_t TTigress::GetNSuppressedAddbackFrags(const size_t& idx)
545{
546 try {
547 return fSuppressedAddbackFrags.at(idx);
548 } catch(const std::out_of_range& oor) {
549 std::cerr << ClassName() << " Suppressed addback frags are out of range: " << oor.what() << std::endl;
550 if(!gInterpreter) {
551 throw grsi::exit_exception(1);
552 }
553 }
554 return 0;
555}
556
557TVector3 TTigress::GetPosition(const TTigressHit* hit, double dist, bool smear)
558{
559 return GetPosition(hit->GetDetector(), hit->GetCrystal(), hit->GetFirstSegment(), dist, smear);
560}
561
562TVector3 TTigress::GetPosition(int DetNbr, int CryNbr, int SegNbr, double dist, bool smear)
563{
564 if(!TestGlobalBit(ETigressGlobalBits::kVectorsBuilt)) { BuildVectors(); }
565
566 // 0 - forward position, 1 - backward position
567 int position = 0;
568 if(dist > 0) {
569 if(dist > 140.) { position = 1; }
570 } else if(TestGlobalBit(ETigressGlobalBits::kArrayBackPos)) {
571 position = 1;
572 }
573
574 if(smear && SegNbr == 0) {
575 double x = 0.;
576 double y = 0.;
577 double r = sqrt(gRandom->Uniform(0, 400));
578 gRandom->Circle(x, y, r);
579 return fPositionVectors[position][DetNbr][CryNbr][SegNbr] + fCloverCross[DetNbr][0] * x + fCloverCross[DetNbr][1] * y;
580 }
581
582 return fPositionVectors[position][DetNbr][CryNbr][SegNbr];
583}
584
585void TTigress::BuildVectors()
586{
587 for(int position = 0; position < 2; position++) {
588 for(int DetNbr = 0; DetNbr < 17; DetNbr++) {
589 for(int CryNbr = 0; CryNbr < 4; CryNbr++) {
590 for(int SegNbr = 0; SegNbr < 9; SegNbr++) {
591 TVector3 detectorPosition;
592 double xx = 0.;
593 double yy = 0.;
594 double zz = 0.;
595
596 if(position == 1) { // distance=145.0
597 switch(CryNbr) {
598 case 0:
599 xx = fGeBluePositionBack[DetNbr][SegNbr][0];
600 yy = fGeBluePositionBack[DetNbr][SegNbr][1];
601 zz = fGeBluePositionBack[DetNbr][SegNbr][2];
602 break;
603 case 1:
604 xx = fGeGreenPositionBack[DetNbr][SegNbr][0];
605 yy = fGeGreenPositionBack[DetNbr][SegNbr][1];
606 zz = fGeGreenPositionBack[DetNbr][SegNbr][2];
607 break;
608 case 2:
609 xx = fGeRedPositionBack[DetNbr][SegNbr][0];
610 yy = fGeRedPositionBack[DetNbr][SegNbr][1];
611 zz = fGeRedPositionBack[DetNbr][SegNbr][2];
612 break;
613 case 3:
614 xx = fGeWhitePositionBack[DetNbr][SegNbr][0];
615 yy = fGeWhitePositionBack[DetNbr][SegNbr][1];
616 zz = fGeWhitePositionBack[DetNbr][SegNbr][2];
617 break;
618 };
619 } else {
620 switch(CryNbr) {
621 case 0:
622 xx = fGeBluePosition[DetNbr][SegNbr][0];
623 yy = fGeBluePosition[DetNbr][SegNbr][1];
624 zz = fGeBluePosition[DetNbr][SegNbr][2];
625 break;
626 case 1:
627 xx = fGeGreenPosition[DetNbr][SegNbr][0];
628 yy = fGeGreenPosition[DetNbr][SegNbr][1];
629 zz = fGeGreenPosition[DetNbr][SegNbr][2];
630 break;
631 case 2:
632 xx = fGeRedPosition[DetNbr][SegNbr][0];
633 yy = fGeRedPosition[DetNbr][SegNbr][1];
634 zz = fGeRedPosition[DetNbr][SegNbr][2];
635 break;
636 case 3:
637 xx = fGeWhitePosition[DetNbr][SegNbr][0];
638 yy = fGeWhitePosition[DetNbr][SegNbr][1];
639 zz = fGeWhitePosition[DetNbr][SegNbr][2];
640 break;
641 };
642 }
643
644 detectorPosition.SetXYZ(xx, yy, zz - fTargetOffset);
645
646 if(fRadialOffset != 0.) {
647 detectorPosition += fCloverRadial[DetNbr].Unit() * fRadialOffset;
648 }
649
650 fPositionVectors[position][DetNbr][CryNbr][SegNbr] = detectorPosition;
651 }
652 }
653 }
654 }
655
656 for(int DetNbr = 0; DetNbr < 17; DetNbr++) {
657 TVector3 a(-fCloverRadial[DetNbr].Y(), fCloverRadial[DetNbr].X(), 0);
658 TVector3 b = fCloverRadial[DetNbr].Cross(a);
659 fCloverCross[DetNbr][0] = a.Unit();
660 fCloverCross[DetNbr][1] = b.Unit();
661 }
662
663 SetGlobalBit(ETigressGlobalBits::kVectorsBuilt, true);
664}
665
666std::array<std::array<std::array<std::array<TVector3, 9>, 4>, 17>, 2> TTigress::fPositionVectors;
667std::array<std::array<TVector3, 2>, 17> TTigress::fCloverCross;
668
669std::array<TVector3, 17> TTigress::fCloverRadial = {TVector3(0., 0., 0.),
670 TVector3(0.9239, 0.3827, 1.),
671 TVector3(-0.3827, 0.9239, 1.),
672 TVector3(-0.9239, -0.3827, 1.),
673 TVector3(0.3827, -0.9239, 1.),
674 TVector3(0.9239, 0.3827, 0.),
675 TVector3(0.3827, 0.9239, 0.),
676 TVector3(-0.3827, 0.9239, 0.),
677 TVector3(-0.9239, 0.3827, 0.),
678 TVector3(-0.9239, -0.3827, 0.),
679 TVector3(-0.3827, -0.9239, 0.),
680 TVector3(0.3827, -0.9239, 0.),
681 TVector3(0.9239, -0.3827, 0.),
682 TVector3(0.9239, 0.3827, -1.),
683 TVector3(-0.3827, 0.9239, -1.),
684 TVector3(-0.9239, -0.3827, -1.),
685 TVector3(0.3827, -0.9239, -1.)};
686
687std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeBluePosition = {{{{{0., 0., 0.},
688 {0., 0., 0.},
689 {0., 0., 0.},
690 {0., 0., 0.},
691 {0., 0., 0.},
692 {0., 0., 0.},
693 {0., 0., 0.},
694 {0., 0., 0.},
695 {0., 0., 0.}}},
696 {{{78.05, 61.70, 134.09},
697 {47.83, 59.64, 119.06},
698 {63.65, 65.78, 102.12},
699 {72.14, 44.72, 103.15},
700 {57.26, 37.61, 118.80},
701 {72.73, 73.96, 152.77},
702 {89.31, 81.09, 134.70},
703 {99.39, 57.11, 134.51},
704 {82.33, 50.30, 152.93}}},
705 {{{-61.70, 78.05, 134.09},
706 {-59.64, 47.83, 119.06},
707 {-65.78, 63.65, 102.12},
708 {-44.72, 72.14, 103.15},
709 {-37.61, 57.26, 118.80},
710 {-73.96, 72.73, 152.77},
711 {-81.09, 89.31, 134.70},
712 {-57.11, 99.39, 134.51},
713 {-50.30, 82.33, 152.93}}},
714 {{{-78.05, -61.70, 134.09},
715 {-47.83, -59.64, 119.06},
716 {-63.65, -65.78, 102.12},
717 {-72.14, -44.72, 103.15},
718 {-57.26, -37.61, 118.80},
719 {-72.73, -73.96, 152.77},
720 {-89.31, -81.09, 134.70},
721 {-99.39, -57.11, 134.51},
722 {-82.33, -50.30, 152.93}}},
723 {{{61.70, -78.05, 134.09},
724 {59.64, -47.83, 119.06},
725 {65.78, -63.65, 102.12},
726 {44.72, -72.14, 103.15},
727 {37.61, -57.26, 118.80},
728 {73.96, -72.73, 152.77},
729 {81.09, -89.31, 134.70},
730 {57.11, -99.39, 134.51},
731 {50.30, -82.33, 152.93}}},
732 {{{139.75, 87.25, 27.13},
733 {107.47, 84.35, 36.80},
734 {107.64, 84.01, 12.83},
735 {116.86, 63.25, 13.71},
736 {116.66, 62.21, 36.42},
737 {146.69, 104.60, 40.50},
738 {146.58, 104.81, 14.96},
739 {156.50, 80.77, 14.73},
740 {156.44, 80.99, 40.74}}},
741 {{{37.12, 160.51, 27.13},
742 {16.35, 135.64, 36.80},
743 {16.71, 135.51, 12.83},
744 {37.91, 127.36, 13.71},
745 {38.50, 126.48, 36.42},
746 {29.76, 177.69, 40.50},
747 {29.53, 177.76, 14.96},
748 {53.55, 167.78, 14.73},
749 {53.35, 167.89, 40.74}}},
750 {{{-87.25, 139.75, 27.13},
751 {-84.35, 107.47, 36.80},
752 {-84.01, 107.64, 12.83},
753 {-63.25, 116.86, 13.71},
754 {-62.21, 116.66, 36.42},
755 {-104.60, 146.69, 40.50},
756 {-104.81, 146.58, 14.96},
757 {-80.77, 156.50, 14.73},
758 {-80.99, 156.44, 40.74}}},
759 {{{-160.51, 37.12, 27.13},
760 {-135.64, 16.35, 36.80},
761 {-135.51, 16.71, 12.83},
762 {-127.36, 37.91, 13.71},
763 {-126.48, 38.50, 36.42},
764 {-177.69, 29.76, 40.50},
765 {-177.76, 29.53, 14.96},
766 {-167.78, 53.55, 14.73},
767 {-167.89, 53.35, 40.74}}},
768 {{{-139.75, -87.25, 27.13},
769 {-107.47, -84.35, 36.80},
770 {-107.64, -84.01, 12.83},
771 {-116.86, -63.25, 13.71},
772 {-116.66, -62.21, 36.42},
773 {-146.69, -104.60, 40.50},
774 {-146.58, -104.81, 14.96},
775 {-156.50, -80.77, 14.73},
776 {-156.44, -80.99, 40.74}}},
777 {{{-37.12, -160.51, 27.13},
778 {-16.35, -135.64, 36.80},
779 {-16.71, -135.51, 12.83},
780 {-37.91, -127.36, 13.71},
781 {-38.50, -126.48, 36.42},
782 {-29.76, -177.69, 40.50},
783 {-29.53, -177.76, 14.96},
784 {-53.55, -167.78, 14.73},
785 {-53.35, -167.89, 40.74}}},
786 {{{87.25, -139.75, 27.13},
787 {84.35, -107.47, 36.80},
788 {84.01, -107.64, 12.83},
789 {63.25, -116.86, 13.71},
790 {62.21, -116.66, 36.42},
791 {104.60, -146.69, 40.50},
792 {104.81, -146.58, 14.96},
793 {80.77, -156.50, 14.73},
794 {80.99, -156.44, 40.74}}},
795 {{{160.51, -37.12, 27.13},
796 {135.64, -16.35, 36.80},
797 {135.51, -16.71, 12.83},
798 {127.36, -37.91, 13.71},
799 {126.48, -38.50, 36.42},
800 {177.69, -29.76, 40.50},
801 {177.76, -29.53, 14.96},
802 {167.78, -53.55, 14.73},
803 {167.89, -53.35, 40.74}}},
804 {{{113.50, 76.38, -95.72},
805 {95.91, 79.56, -67.01},
806 {80.41, 72.73, -83.98},
807 {90.05, 52.14, -83.76},
808 {104.85, 57.32, -67.30},
809 {125.64, 95.88, -95.49},
810 {108.85, 89.19, -113.54},
811 {118.64, 65.08, -113.68},
812 {135.56, 72.34, -95.31}}},
813 {{{-76.38, 113.50, -95.72},
814 {-79.56, 95.91, -67.01},
815 {-72.73, 80.41, -83.98},
816 {-52.14, 90.05, -83.76},
817 {-57.32, 104.85, -67.30},
818 {-95.88, 125.64, -95.49},
819 {-89.19, 108.85, -113.54},
820 {-65.08, 118.64, -113.68},
821 {-72.34, 135.56, -95.31}}},
822 {{{-113.50, -76.38, -95.72},
823 {-95.91, -79.56, -67.01},
824 {-80.41, -72.73, -83.98},
825 {-90.05, -52.14, -83.76},
826 {-104.85, -57.32, -67.30},
827 {-125.64, -95.88, -95.49},
828 {-108.85, -89.19, -113.54},
829 {-118.64, -65.08, -113.68},
830 {-135.56, -72.34, -95.31}}},
831 {{{76.38, -113.50, -95.72},
832 {79.56, -95.91, -67.01},
833 {72.73, -80.41, -83.98},
834 {52.14, -90.05, -83.76},
835 {57.32, -104.85, -67.30},
836 {95.88, -125.64, -95.49},
837 {89.19, -108.85, -113.54},
838 {65.08, -118.64, -113.68},
839 {72.34, -135.56, -95.31}}}}};
840
841// Assuming this is the 1
842std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeGreenPosition = {{{{{0., 0., 0.},
843 {0., 0., 0.},
844 {0., 0., 0.},
845 {0., 0., 0.},
846 {0., 0., 0.},
847 {0., 0., 0.},
848 {0., 0., 0.},
849 {0., 0., 0.},
850 {0., 0., 0.}}},
851 {{{113.50, 76.38, 95.72},
852 {95.91, 79.56, 67.01},
853 {104.85, 57.32, 67.30},
854 {90.05, 52.14, 83.76},
855 {80.41, 72.73, 83.98},
856 {125.64, 95.88, 95.49},
857 {135.56, 72.34, 95.31},
858 {118.64, 65.08, 113.68},
859 {108.85, 89.19, 113.54}}},
860 {{{-76.38, 113.50, 95.72},
861 {-79.56, 95.91, 67.01},
862 {-57.32, 104.85, 67.30},
863 {-52.14, 90.05, 83.76},
864 {-72.73, 80.41, 83.98},
865 {-95.88, 125.64, 95.49},
866 {-72.34, 135.56, 95.31},
867 {-65.08, 118.64, 113.68},
868 {-89.19, 108.85, 113.54}}},
869 {{{-113.50, -76.38, 95.72},
870 {-95.91, -79.56, 67.01},
871 {-104.85, -57.32, 67.30},
872 {-90.05, -52.14, 83.76},
873 {-80.41, -72.73, 83.98},
874 {-125.64, -95.88, 95.49},
875 {-135.56, -72.34, 95.31},
876 {-118.64, -65.08, 113.68},
877 {-108.85, -89.19, 113.54}}},
878 {{{76.38, -113.50, 95.72},
879 {79.56, -95.91, 67.01},
880 {57.32, -104.85, 67.30},
881 {52.14, -90.05, 83.76},
882 {72.73, -80.41, 83.98},
883 {95.88, -125.64, 95.49},
884 {72.34, -135.56, 95.31},
885 {65.08, -118.64, 113.68},
886 {89.19, -108.85, 113.54}}},
887 {{{139.75, 87.25, -27.13},
888 {107.47, 84.35, -36.80},
889 {116.66, 62.21, -36.42},
890 {116.86, 63.25, -13.71},
891 {107.64, 84.01, -12.83},
892 {146.69, 104.60, -40.50},
893 {156.44, 80.99, -40.74},
894 {156.50, 80.77, -14.73},
895 {146.58, 104.81, -14.96}}},
896 {{{37.12, 160.51, -27.13},
897 {16.35, 135.64, -36.80},
898 {38.50, 126.48, -36.42},
899 {37.91, 127.36, -13.71},
900 {16.71, 135.51, -12.83},
901 {29.76, 177.69, -40.50},
902 {53.35, 167.89, -40.74},
903 {53.55, 167.78, -14.73},
904 {29.53, 177.76, -14.96}}},
905 {{{-87.25, 139.75, -27.13},
906 {-84.35, 107.47, -36.80},
907 {-62.21, 116.66, -36.42},
908 {-63.25, 116.86, -13.71},
909 {-84.01, 107.64, -12.83},
910 {-104.60, 146.69, -40.50},
911 {-80.99, 156.44, -40.74},
912 {-80.77, 156.50, -14.73},
913 {-104.81, 146.58, -14.96}}},
914 {{{-160.51, 37.12, -27.13},
915 {-135.64, 16.35, -36.80},
916 {-126.48, 38.50, -36.42},
917 {-127.36, 37.91, -13.71},
918 {-135.51, 16.71, -12.83},
919 {-177.69, 29.76, -40.50},
920 {-167.89, 53.35, -40.74},
921 {-167.78, 53.55, -14.73},
922 {-177.76, 29.53, -14.96}}},
923 {{{-139.75, -87.25, -27.13},
924 {-107.47, -84.35, -36.80},
925 {-116.66, -62.21, -36.42},
926 {-116.86, -63.25, -13.71},
927 {-107.64, -84.01, -12.83},
928 {-146.69, -104.60, -40.50},
929 {-156.44, -80.99, -40.74},
930 {-156.50, -80.77, -14.73},
931 {-146.58, -104.81, -14.96}}},
932 {{{-37.12, -160.51, -27.13},
933 {-16.35, -135.64, -36.80},
934 {-38.50, -126.48, -36.42},
935 {-37.91, -127.36, -13.71},
936 {-16.71, -135.51, -12.83},
937 {-29.76, -177.69, -40.50},
938 {-53.35, -167.89, -40.74},
939 {-53.55, -167.78, -14.73},
940 {-29.53, -177.76, -14.96}}},
941 {{{87.25, -139.75, -27.13},
942 {84.35, -107.47, -36.80},
943 {62.21, -116.66, -36.42},
944 {63.25, -116.86, -13.71},
945 {84.01, -107.64, -12.83},
946 {104.60, -146.69, -40.50},
947 {80.99, -156.44, -40.74},
948 {80.77, -156.50, -14.73},
949 {104.81, -146.58, -14.96}}},
950 {{{160.51, -37.12, -27.13},
951 {135.64, -16.35, -36.80},
952 {126.48, -38.50, -36.42},
953 {127.36, -37.91, -13.71},
954 {135.51, -16.71, -12.83},
955 {177.69, -29.76, -40.50},
956 {167.89, -53.35, -40.74},
957 {167.78, -53.55, -14.73},
958 {177.76, -29.53, -14.96}}},
959 {{{78.05, 61.70, -134.09},
960 {47.83, 59.64, -119.06},
961 {57.26, 37.61, -118.80},
962 {72.14, 44.72, -103.15},
963 {63.65, 65.78, -102.12},
964 {72.73, 73.96, -152.77},
965 {82.33, 50.30, -152.93},
966 {99.39, 57.11, -134.51},
967 {89.31, 81.09, -134.70}}},
968 {{{-61.70, 78.05, -134.09},
969 {-59.64, 47.83, -119.06},
970 {-37.61, 57.26, -118.80},
971 {-44.72, 72.14, -103.15},
972 {-65.78, 63.65, -102.12},
973 {-73.96, 72.73, -152.77},
974 {-50.30, 82.33, -152.93},
975 {-57.11, 99.39, -134.51},
976 {-81.09, 89.31, -134.70}}},
977 {{{-78.05, -61.70, -134.09},
978 {-47.83, -59.64, -119.06},
979 {-57.26, -37.61, -118.80},
980 {-72.14, -44.72, -103.15},
981 {-63.65, -65.78, -102.12},
982 {-72.73, -73.96, -152.77},
983 {-82.33, -50.30, -152.93},
984 {-99.39, -57.11, -134.51},
985 {-89.31, -81.09, -134.70}}},
986 {{{61.70, -78.05, -134.09},
987 {59.64, -47.83, -119.06},
988 {37.61, -57.26, -118.80},
989 {44.72, -72.14, -103.15},
990 {65.78, -63.65, -102.12},
991 {73.96, -72.73, -152.77},
992 {50.30, -82.33, -152.93},
993 {57.11, -99.39, -134.51},
994 {81.09, -89.31, -134.70}}}}};
995
996// Assuming this is the 2
997std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeRedPosition = {{{{{0., 0., 0.},
998 {0., 0., 0.},
999 {0., 0., 0.},
1000 {0., 0., 0.},
1001 {0., 0., 0.},
1002 {0., 0., 0.},
1003 {0., 0., 0.},
1004 {0., 0., 0.},
1005 {0., 0., 0.}}},
1006 {{{134.26, 26.25, 95.72},
1007 {124.08, 11.56, 67.01},
1008 {108.28, 5.43, 83.98},
1009 {100.55, 26.81, 83.76},
1010 {114.67, 33.61, 67.30},
1011 {156.64, 21.05, 95.49},
1012 {140.03, 13.91, 113.54},
1013 {129.91, 37.87, 113.68},
1014 {147.01, 44.70, 95.31}}},
1015 {{{-26.25, 134.26, 95.72},
1016 {-11.56, 124.08, 67.01},
1017 {-5.43, 108.28, 83.98},
1018 {-26.81, 100.55, 83.76},
1019 {-33.61, 114.67, 67.30},
1020 {-21.05, 156.64, 95.49},
1021 {-13.91, 140.03, 113.54},
1022 {-37.87, 129.91, 113.68},
1023 {-44.70, 147.01, 95.31}}},
1024 {{{-134.26, -26.25, 95.72},
1025 {-124.08, -11.56, 67.01},
1026 {-108.28, -5.43, 83.98},
1027 {-100.55, -26.81, 83.76},
1028 {-114.67, -33.61, 67.30},
1029 {-156.64, -21.05, 95.49},
1030 {-140.03, -13.91, 113.54},
1031 {-129.91, -37.87, 113.68},
1032 {-147.01, -44.70, 95.31}}},
1033 {{{26.25, -134.26, 95.72},
1034 {11.56, -124.08, 67.01},
1035 {5.43, -108.28, 83.98},
1036 {26.81, -100.55, 83.76},
1037 {33.61, -114.67, 67.30},
1038 {21.05, -156.64, 95.49},
1039 {13.91, -140.03, 113.54},
1040 {37.87, -129.91, 113.68},
1041 {44.70, -147.01, 95.31}}},
1042 {{{160.51, 37.12, -27.13},
1043 {135.64, 16.35, -36.80},
1044 {135.51, 16.71, -12.83},
1045 {127.36, 37.91, -13.71},
1046 {126.48, 38.50, -36.42},
1047 {177.69, 29.76, -40.50},
1048 {177.76, 29.53, -14.96},
1049 {167.78, 53.55, -14.73},
1050 {167.89, 53.35, -40.74}}},
1051 {{{87.25, 139.75, -27.13},
1052 {84.35, 107.47, -36.80},
1053 {84.01, 107.64, -12.83},
1054 {63.25, 116.86, -13.71},
1055 {62.21, 116.66, -36.42},
1056 {104.60, 146.69, -40.50},
1057 {104.81, 146.58, -14.96},
1058 {80.77, 156.50, -14.73},
1059 {80.99, 156.44, -40.74}}},
1060 {{{-37.12, 160.51, -27.13},
1061 {-16.35, 135.64, -36.80},
1062 {-16.71, 135.51, -12.83},
1063 {-37.91, 127.36, -13.71},
1064 {-38.50, 126.48, -36.42},
1065 {-29.76, 177.69, -40.50},
1066 {-29.53, 177.76, -14.96},
1067 {-53.55, 167.78, -14.73},
1068 {-53.35, 167.89, -40.74}}},
1069 {{{-139.75, 87.25, -27.13},
1070 {-107.47, 84.35, -36.80},
1071 {-107.64, 84.01, -12.83},
1072 {-116.86, 63.25, -13.71},
1073 {-116.66, 62.21, -36.42},
1074 {-146.69, 104.60, -40.50},
1075 {-146.58, 104.81, -14.96},
1076 {-156.50, 80.77, -14.73},
1077 {-156.44, 80.99, -40.74}}},
1078 {{{-160.51, -37.12, -27.13},
1079 {-135.64, -16.35, -36.80},
1080 {-135.51, -16.71, -12.83},
1081 {-127.36, -37.91, -13.71},
1082 {-126.48, -38.50, -36.42},
1083 {-177.69, -29.76, -40.50},
1084 {-177.76, -29.53, -14.96},
1085 {-167.78, -53.55, -14.73},
1086 {-167.89, -53.35, -40.74}}},
1087 {{{-87.25, -139.75, -27.13},
1088 {-84.35, -107.47, -36.80},
1089 {-84.01, -107.64, -12.83},
1090 {-63.25, -116.86, -13.71},
1091 {-62.21, -116.66, -36.42},
1092 {-104.60, -146.69, -40.50},
1093 {-104.81, -146.58, -14.96},
1094 {-80.77, -156.50, -14.73},
1095 {-80.99, -156.44, -40.74}}},
1096 {{{37.12, -160.51, -27.13},
1097 {16.35, -135.64, -36.80},
1098 {16.71, -135.51, -12.83},
1099 {37.91, -127.36, -13.71},
1100 {38.50, -126.48, -36.42},
1101 {29.76, -177.69, -40.50},
1102 {29.53, -177.76, -14.96},
1103 {53.55, -167.78, -14.73},
1104 {53.35, -167.89, -40.74}}},
1105 {{{139.75, -87.25, -27.13},
1106 {107.47, -84.35, -36.80},
1107 {107.64, -84.01, -12.83},
1108 {116.86, -63.25, -13.71},
1109 {116.66, -62.21, -36.42},
1110 {146.69, -104.60, -40.50},
1111 {146.58, -104.81, -14.96},
1112 {156.50, -80.77, -14.73},
1113 {156.44, -80.99, -40.74}}},
1114 {{{98.82, 11.57, -134.09},
1115 {75.99, -8.35, -119.06},
1116 {91.52, -1.51, -102.12},
1117 {82.63, 19.39, -103.15},
1118 {67.08, 13.90, -118.80},
1119 {103.72, -0.87, -152.77},
1120 {120.49, 5.81, -134.70},
1121 {110.66, 29.90, -134.51},
1122 {93.78, 22.65, -152.93}}},
1123 {{{-11.57, 98.82, -134.09},
1124 {8.35, 75.99, -119.06},
1125 {1.51, 91.52, -102.12},
1126 {-19.39, 82.63, -103.15},
1127 {-13.90, 67.08, -118.80},
1128 {0.87, 103.72, -152.77},
1129 {-5.81, 120.49, -134.70},
1130 {-29.90, 110.66, -134.51},
1131 {-22.65, 93.78, -152.93}}},
1132 {{{-98.82, -11.57, -134.09},
1133 {-75.99, 8.35, -119.06},
1134 {-91.52, 1.51, -102.12},
1135 {-82.63, -19.39, -103.15},
1136 {-67.08, -13.90, -118.80},
1137 {-103.72, 0.87, -152.77},
1138 {-120.49, -5.81, -134.70},
1139 {-110.66, -29.90, -134.51},
1140 {-93.78, -22.65, -152.93}}},
1141 {{{11.57, -98.82, -134.09},
1142 {-8.35, -75.99, -119.06},
1143 {-1.51, -91.52, -102.12},
1144 {19.39, -82.63, -103.15},
1145 {13.90, -67.08, -118.80},
1146 {-0.87, -103.72, -152.77},
1147 {5.81, -120.49, -134.70},
1148 {29.90, -110.66, -134.51},
1149 {22.65, -93.78, -152.93}}}}};
1150
1151// Assuming this is the 3
1152std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeWhitePosition = {{{{{0., 0., 0.},
1153 {0., 0., 0.},
1154 {0., 0., 0.},
1155 {0., 0., 0.},
1156 {0., 0., 0.},
1157 {0., 0., 0.},
1158 {0., 0., 0.},
1159 {0., 0., 0.},
1160 {0., 0., 0.}}},
1161 {{{98.82, 11.57, 134.09},
1162 {75.99, -8.35, 119.06},
1163 {67.08, 13.90, 118.80},
1164 {82.63, 19.39, 103.15},
1165 {91.52, -1.51, 102.12},
1166 {103.72, -0.87, 152.77},
1167 {93.78, 22.65, 152.93},
1168 {110.66, 29.90, 134.51},
1169 {120.49, 5.81, 134.70}}},
1170 {{{-11.57, 98.82, 134.09},
1171 {8.35, 75.99, 119.06},
1172 {-13.90, 67.08, 118.80},
1173 {-19.39, 82.63, 103.15},
1174 {1.51, 91.52, 102.12},
1175 {0.87, 103.72, 152.77},
1176 {-22.65, 93.78, 152.93},
1177 {-29.90, 110.66, 134.51},
1178 {-5.81, 120.49, 134.70}}},
1179 {{{-98.82, -11.57, 134.09},
1180 {-75.99, 8.35, 119.06},
1181 {-67.08, -13.90, 118.80},
1182 {-82.63, -19.39, 103.15},
1183 {-91.52, 1.51, 102.12},
1184 {-103.72, 0.87, 152.77},
1185 {-93.78, -22.65, 152.93},
1186 {-110.66, -29.90, 134.51},
1187 {-120.49, -5.81, 134.70}}},
1188 {{{11.57, -98.82, 134.09},
1189 {-8.35, -75.99, 119.06},
1190 {13.90, -67.08, 118.80},
1191 {19.39, -82.63, 103.15},
1192 {-1.51, -91.52, 102.12},
1193 {-0.87, -103.72, 152.77},
1194 {22.65, -93.78, 152.93},
1195 {29.90, -110.66, 134.51},
1196 {5.81, -120.49, 134.70}}},
1197 {{{160.51, 37.12, 27.13},
1198 {135.64, 16.35, 36.80},
1199 {126.48, 38.50, 36.42},
1200 {127.36, 37.91, 13.71},
1201 {135.51, 16.71, 12.83},
1202 {177.69, 29.76, 40.50},
1203 {167.89, 53.35, 40.74},
1204 {167.78, 53.55, 14.73},
1205 {177.76, 29.53, 14.96}}},
1206 {{{87.25, 139.75, 27.13},
1207 {84.35, 107.47, 36.80},
1208 {62.21, 116.66, 36.42},
1209 {63.25, 116.86, 13.71},
1210 {84.01, 107.64, 12.83},
1211 {104.60, 146.69, 40.50},
1212 {80.99, 156.44, 40.74},
1213 {80.77, 156.50, 14.73},
1214 {104.81, 146.58, 14.96}}},
1215 {{{-37.12, 160.51, 27.13},
1216 {-16.35, 135.64, 36.80},
1217 {-38.50, 126.48, 36.42},
1218 {-37.91, 127.36, 13.71},
1219 {-16.71, 135.51, 12.83},
1220 {-29.76, 177.69, 40.50},
1221 {-53.35, 167.89, 40.74},
1222 {-53.55, 167.78, 14.73},
1223 {-29.53, 177.76, 14.96}}},
1224 {{{-139.75, 87.25, 27.13},
1225 {-107.47, 84.35, 36.80},
1226 {-116.66, 62.21, 36.42},
1227 {-116.86, 63.25, 13.71},
1228 {-107.64, 84.01, 12.83},
1229 {-146.69, 104.60, 40.50},
1230 {-156.44, 80.99, 40.74},
1231 {-156.50, 80.77, 14.73},
1232 {-146.58, 104.81, 14.96}}},
1233 {{{-160.51, -37.12, 27.13},
1234 {-135.64, -16.35, 36.80},
1235 {-126.48, -38.50, 36.42},
1236 {-127.36, -37.91, 13.71},
1237 {-135.51, -16.71, 12.83},
1238 {-177.69, -29.76, 40.50},
1239 {-167.89, -53.35, 40.74},
1240 {-167.78, -53.55, 14.73},
1241 {-177.76, -29.53, 14.96}}},
1242 {{{-87.25, -139.75, 27.13},
1243 {-84.35, -107.47, 36.80},
1244 {-62.21, -116.66, 36.42},
1245 {-63.25, -116.86, 13.71},
1246 {-84.01, -107.64, 12.83},
1247 {-104.60, -146.69, 40.50},
1248 {-80.99, -156.44, 40.74},
1249 {-80.77, -156.50, 14.73},
1250 {-104.81, -146.58, 14.96}}},
1251 {{{37.12, -160.51, 27.13},
1252 {16.35, -135.64, 36.80},
1253 {38.50, -126.48, 36.42},
1254 {37.91, -127.36, 13.71},
1255 {16.71, -135.51, 12.83},
1256 {29.76, -177.69, 40.50},
1257 {53.35, -167.89, 40.74},
1258 {53.55, -167.78, 14.73},
1259 {29.53, -177.76, 14.96}}},
1260 {{{139.75, -87.25, 27.13},
1261 {107.47, -84.35, 36.80},
1262 {116.66, -62.21, 36.42},
1263 {116.86, -63.25, 13.71},
1264 {107.64, -84.01, 12.83},
1265 {146.69, -104.60, 40.50},
1266 {156.44, -80.99, 40.74},
1267 {156.50, -80.77, 14.73},
1268 {146.58, -104.81, 14.96}}},
1269 {{{134.26, 26.25, -95.72},
1270 {124.08, 11.56, -67.01},
1271 {114.67, 33.61, -67.30},
1272 {100.55, 26.81, -83.76},
1273 {108.28, 5.43, -83.98},
1274 {156.64, 21.05, -95.49},
1275 {147.01, 44.70, -95.31},
1276 {129.91, 37.87, -113.68},
1277 {140.03, 13.91, -113.54}}},
1278 {{{-26.25, 134.26, -95.72},
1279 {-11.56, 124.08, -67.01},
1280 {-33.61, 114.67, -67.30},
1281 {-26.81, 100.55, -83.76},
1282 {-5.43, 108.28, -83.98},
1283 {-21.05, 156.64, -95.49},
1284 {-44.70, 147.01, -95.31},
1285 {-37.87, 129.91, -113.68},
1286 {-13.91, 140.03, -113.54}}},
1287 {{{-134.26, -26.25, -95.72},
1288 {-124.08, -11.56, -67.01},
1289 {-114.67, -33.61, -67.30},
1290 {-100.55, -26.81, -83.76},
1291 {-108.28, -5.43, -83.98},
1292 {-156.64, -21.05, -95.49},
1293 {-147.01, -44.70, -95.31},
1294 {-129.91, -37.87, -113.68},
1295 {-140.03, -13.91, -113.54}}},
1296 {{{26.25, -134.26, -95.72},
1297 {11.56, -124.08, -67.01},
1298 {33.61, -114.67, -67.30},
1299 {26.81, -100.55, -83.76},
1300 {5.43, -108.28, -83.98},
1301 {21.05, -156.64, -95.49},
1302 {44.70, -147.01, -95.31},
1303 {37.87, -129.91, -113.68},
1304 {13.91, -140.03, -113.54}}}}};
1305
1306std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeBluePositionBack = {{{{{0., 0., 0.},
1307 {0., 0., 0.},
1308 {0., 0., 0.},
1309 {0., 0., 0.},
1310 {0., 0., 0.},
1311 {0., 0., 0.},
1312 {0., 0., 0.},
1313 {0., 0., 0.},
1314 {0., 0., 0.}}},
1315 {{{100.92, 71.17, 158.84},
1316 {70.69, 69.11, 143.80},
1317 {86.51, 75.25, 126.87},
1318 {95.01, 54.19, 127.90},
1319 {80.13, 47.08, 143.55},
1320 {95.59, 83.43, 177.52},
1321 {112.17, 90.56, 159.45},
1322 {122.26, 66.58, 159.26},
1323 {105.20, 59.77, 177.67}}},
1324 {{{-71.17, 100.92, 158.84},
1325 {-69.11, 70.69, 143.80},
1326 {-75.25, 86.51, 126.87},
1327 {-54.19, 95.01, 127.90},
1328 {-47.08, 80.13, 143.55},
1329 {-83.43, 95.59, 177.52},
1330 {-90.56, 112.17, 159.45},
1331 {-66.58, 122.26, 159.26},
1332 {-59.77, 105.20, 177.67}}},
1333 {{{-100.92, -71.17, 158.84},
1334 {-70.69, -69.11, 143.80},
1335 {-86.51, -75.25, 126.87},
1336 {-95.01, -54.19, 127.90},
1337 {-80.13, -47.08, 143.55},
1338 {-95.59, -83.43, 177.52},
1339 {-112.17, -90.56, 159.45},
1340 {-122.26, -66.58, 159.26},
1341 {-105.20, -59.77, 177.67}}},
1342 {{{71.17, -100.92, 158.84},
1343 {69.11, -70.69, 143.80},
1344 {75.25, -86.51, 126.87},
1345 {54.19, -95.01, 127.90},
1346 {47.08, -80.13, 143.55},
1347 {83.43, -95.59, 177.52},
1348 {90.56, -112.17, 159.45},
1349 {66.58, -122.26, 159.26},
1350 {59.77, -105.20, 177.67}}},
1351 {{{172.08, 100.64, 27.13},
1352 {139.81, 97.74, 36.80},
1353 {139.97, 97.40, 12.83},
1354 {149.20, 76.64, 13.71},
1355 {149.00, 75.60, 36.42},
1356 {179.02, 117.99, 40.50},
1357 {178.91, 118.21, 14.96},
1358 {188.84, 94.16, 14.73},
1359 {188.78, 94.39, 40.74}}},
1360 {{{50.52, 192.85, 27.13},
1361 {29.74, 167.97, 36.80},
1362 {30.10, 167.85, 12.83},
1363 {51.31, 159.69, 13.71},
1364 {51.90, 158.82, 36.42},
1365 {43.16, 210.02, 40.50},
1366 {42.93, 210.09, 14.96},
1367 {66.95, 200.11, 14.73},
1368 {66.75, 200.23, 40.74}}},
1369 {{{-100.64, 172.08, 27.13},
1370 {-97.74, 139.81, 36.80},
1371 {-97.40, 139.97, 12.83},
1372 {-76.64, 149.20, 13.71},
1373 {-75.60, 149.00, 36.42},
1374 {-117.99, 179.02, 40.50},
1375 {-118.21, 178.91, 14.96},
1376 {-94.16, 188.84, 14.73},
1377 {-94.39, 188.78, 40.74}}},
1378 {{{-192.85, 50.52, 27.13},
1379 {-167.97, 29.74, 36.80},
1380 {-167.85, 30.10, 12.83},
1381 {-159.69, 51.31, 13.71},
1382 {-158.82, 51.90, 36.42},
1383 {-210.02, 43.16, 40.50},
1384 {-210.09, 42.93, 14.96},
1385 {-200.11, 66.95, 14.73},
1386 {-200.23, 66.75, 40.74}}},
1387 {{{-172.08, -100.64, 27.13},
1388 {-139.81, -97.74, 36.80},
1389 {-139.97, -97.40, 12.83},
1390 {-149.20, -76.64, 13.71},
1391 {-149.00, -75.60, 36.42},
1392 {-179.02, -117.99, 40.50},
1393 {-178.91, -118.21, 14.96},
1394 {-188.84, -94.16, 14.73},
1395 {-188.78, -94.39, 40.74}}},
1396 {{{-50.52, -192.85, 27.13},
1397 {-29.74, -167.97, 36.80},
1398 {-30.10, -167.85, 12.83},
1399 {-51.31, -159.69, 13.71},
1400 {-51.90, -158.82, 36.42},
1401 {-43.16, -210.02, 40.50},
1402 {-42.93, -210.09, 14.96},
1403 {-66.95, -200.11, 14.73},
1404 {-66.75, -200.23, 40.74}}},
1405 {{{100.64, -172.08, 27.13},
1406 {97.74, -139.81, 36.80},
1407 {97.40, -139.97, 12.83},
1408 {76.64, -149.20, 13.71},
1409 {75.60, -149.00, 36.42},
1410 {117.99, -179.02, 40.50},
1411 {118.21, -178.91, 14.96},
1412 {94.16, -188.84, 14.73},
1413 {94.39, -188.78, 40.74}}},
1414 {{{192.85, -50.52, 27.13},
1415 {167.97, -29.74, 36.80},
1416 {167.85, -30.10, 12.83},
1417 {159.69, -51.31, 13.71},
1418 {158.82, -51.90, 36.42},
1419 {210.02, -43.16, 40.50},
1420 {210.09, -42.93, 14.96},
1421 {200.11, -66.95, 14.73},
1422 {200.23, -66.75, 40.74}}},
1423 {{{136.36, 85.85, -120.47},
1424 {118.78, 89.03, -91.76},
1425 {103.27, 82.20, -108.72},
1426 {112.92, 61.61, -108.51},
1427 {127.71, 66.79, -92.04},
1428 {148.51, 105.35, -120.24},
1429 {131.72, 98.66, -138.29},
1430 {141.50, 74.56, -138.43},
1431 {158.43, 81.81, -120.06}}},
1432 {{{-85.85, 136.36, -120.47},
1433 {-89.03, 118.78, -91.76},
1434 {-82.20, 103.27, -108.72},
1435 {-61.61, 112.92, -108.51},
1436 {-66.79, 127.71, -92.04},
1437 {-105.35, 148.51, -120.24},
1438 {-98.66, 131.72, -138.29},
1439 {-74.56, 141.50, -138.43},
1440 {-81.81, 158.43, -120.06}}},
1441 {{{-136.36, -85.85, -120.47},
1442 {-118.78, -89.03, -91.76},
1443 {-103.27, -82.20, -108.72},
1444 {-112.92, -61.61, -108.51},
1445 {-127.71, -66.79, -92.04},
1446 {-148.51, -105.35, -120.24},
1447 {-131.72, -98.66, -138.29},
1448 {-141.50, -74.56, -138.43},
1449 {-158.43, -81.81, -120.06}}},
1450 {{{85.85, -136.36, -120.47},
1451 {89.03, -118.78, -91.76},
1452 {82.20, -103.27, -108.72},
1453 {61.61, -112.92, -108.51},
1454 {66.79, -127.71, -92.04},
1455 {105.35, -148.51, -120.24},
1456 {98.66, -131.72, -138.29},
1457 {74.56, -141.50, -138.43},
1458 {81.81, -158.43, -120.06}}}}};
1459
1460// Assuming this is the 1
1461std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeGreenPositionBack = {{{{{0., 0., 0.},
1462 {0., 0., 0.},
1463 {0., 0., 0.},
1464 {0., 0., 0.},
1465 {0., 0., 0.},
1466 {0., 0., 0.},
1467 {0., 0., 0.},
1468 {0., 0., 0.},
1469 {0., 0., 0.}}},
1470 {{{136.36, 85.85, 120.47},
1471 {118.78, 89.03, 91.76},
1472 {127.71, 66.79, 92.04},
1473 {112.92, 61.61, 108.51},
1474 {103.27, 82.20, 108.72},
1475 {148.51, 105.35, 120.24},
1476 {158.43, 81.81, 120.06},
1477 {141.50, 74.56, 138.43},
1478 {131.72, 98.66, 138.29}}},
1479 {{{-85.85, 136.36, 120.47},
1480 {-89.03, 118.78, 91.76},
1481 {-66.79, 127.71, 92.04},
1482 {-61.61, 112.92, 108.51},
1483 {-82.20, 103.27, 108.72},
1484 {-105.35, 148.51, 120.24},
1485 {-81.81, 158.43, 120.06},
1486 {-74.56, 141.50, 138.43},
1487 {-98.66, 131.72, 138.29}}},
1488 {{{-136.36, -85.85, 120.47},
1489 {-118.78, -89.03, 91.76},
1490 {-127.71, -66.79, 92.04},
1491 {-112.92, -61.61, 108.51},
1492 {-103.27, -82.20, 108.72},
1493 {-148.51, -105.35, 120.24},
1494 {-158.43, -81.81, 120.06},
1495 {-141.50, -74.56, 138.43},
1496 {-131.72, -98.66, 138.29}}},
1497 {{{85.85, -136.36, 120.47},
1498 {89.03, -118.78, 91.76},
1499 {66.79, -127.71, 92.04},
1500 {61.61, -112.92, 108.51},
1501 {82.20, -103.27, 108.72},
1502 {105.35, -148.51, 120.24},
1503 {81.81, -158.43, 120.06},
1504 {74.56, -141.50, 138.43},
1505 {98.66, -131.72, 138.29}}},
1506 {{{172.08, 100.64, -27.13},
1507 {139.81, 97.74, -36.80},
1508 {149.00, 75.60, -36.42},
1509 {149.20, 76.64, -13.71},
1510 {139.97, 97.40, -12.83},
1511 {179.02, 117.99, -40.50},
1512 {188.78, 94.39, -40.74},
1513 {188.84, 94.16, -14.73},
1514 {178.91, 118.21, -14.96}}},
1515 {{{50.52, 192.85, -27.13},
1516 {29.74, 167.97, -36.80},
1517 {51.90, 158.82, -36.42},
1518 {51.31, 159.69, -13.71},
1519 {30.10, 167.85, -12.83},
1520 {43.16, 210.02, -40.50},
1521 {66.75, 200.23, -40.74},
1522 {66.95, 200.11, -14.73},
1523 {42.93, 210.09, -14.96}}},
1524 {{{-100.64, 172.08, -27.13},
1525 {-97.74, 139.81, -36.80},
1526 {-75.60, 149.00, -36.42},
1527 {-76.64, 149.20, -13.71},
1528 {-97.40, 139.97, -12.83},
1529 {-117.99, 179.02, -40.50},
1530 {-94.39, 188.78, -40.74},
1531 {-94.16, 188.84, -14.73},
1532 {-118.21, 178.91, -14.96}}},
1533 {{{-192.85, 50.52, -27.13},
1534 {-167.97, 29.74, -36.80},
1535 {-158.82, 51.90, -36.42},
1536 {-159.69, 51.31, -13.71},
1537 {-167.85, 30.10, -12.83},
1538 {-210.02, 43.16, -40.50},
1539 {-200.23, 66.75, -40.74},
1540 {-200.11, 66.95, -14.73},
1541 {-210.09, 42.93, -14.96}}},
1542 {{{-172.08, -100.64, -27.13},
1543 {-139.81, -97.74, -36.80},
1544 {-149.00, -75.60, -36.42},
1545 {-149.20, -76.64, -13.71},
1546 {-139.97, -97.40, -12.83},
1547 {-179.02, -117.99, -40.50},
1548 {-188.78, -94.39, -40.74},
1549 {-188.84, -94.16, -14.73},
1550 {-178.91, -118.21, -14.96}}},
1551 {{{-50.52, -192.85, -27.13},
1552 {-29.74, -167.97, -36.80},
1553 {-51.90, -158.82, -36.42},
1554 {-51.31, -159.69, -13.71},
1555 {-30.10, -167.85, -12.83},
1556 {-43.16, -210.02, -40.50},
1557 {-66.75, -200.23, -40.74},
1558 {-66.95, -200.11, -14.73},
1559 {-42.93, -210.09, -14.96}}},
1560 {{{100.64, -172.08, -27.13},
1561 {97.74, -139.81, -36.80},
1562 {75.60, -149.00, -36.42},
1563 {76.64, -149.20, -13.71},
1564 {97.40, -139.97, -12.83},
1565 {117.99, -179.02, -40.50},
1566 {94.39, -188.78, -40.74},
1567 {94.16, -188.84, -14.73},
1568 {118.21, -178.91, -14.96}}},
1569 {{{192.85, -50.52, -27.13},
1570 {167.97, -29.74, -36.80},
1571 {158.82, -51.90, -36.42},
1572 {159.69, -51.31, -13.71},
1573 {167.85, -30.10, -12.83},
1574 {210.02, -43.16, -40.50},
1575 {200.23, -66.75, -40.74},
1576 {200.11, -66.95, -14.73},
1577 {210.09, -42.93, -14.96}}},
1578 {{{100.92, 71.17, -158.84},
1579 {70.69, 69.11, -143.80},
1580 {80.13, 47.08, -143.55},
1581 {95.01, 54.19, -127.90},
1582 {86.51, 75.25, -126.87},
1583 {95.59, 83.43, -177.52},
1584 {105.20, 59.77, -177.67},
1585 {122.26, 66.58, -159.26},
1586 {112.17, 90.56, -159.45}}},
1587 {{{-71.17, 100.92, -158.84},
1588 {-69.11, 70.69, -143.80},
1589 {-47.08, 80.13, -143.55},
1590 {-54.19, 95.01, -127.90},
1591 {-75.25, 86.51, -126.87},
1592 {-83.43, 95.59, -177.52},
1593 {-59.77, 105.20, -177.67},
1594 {-66.58, 122.26, -159.26},
1595 {-90.56, 112.17, -159.45}}},
1596 {{{-100.92, -71.17, -158.84},
1597 {-70.69, -69.11, -143.80},
1598 {-80.13, -47.08, -143.55},
1599 {-95.01, -54.19, -127.90},
1600 {-86.51, -75.25, -126.87},
1601 {-95.59, -83.43, -177.52},
1602 {-105.20, -59.77, -177.67},
1603 {-122.26, -66.58, -159.26},
1604 {-112.17, -90.56, -159.45}}},
1605 {{{71.17, -100.92, -158.84},
1606 {69.11, -70.69, -143.80},
1607 {47.08, -80.13, -143.55},
1608 {54.19, -95.01, -127.90},
1609 {75.25, -86.51, -126.87},
1610 {83.43, -95.59, -177.52},
1611 {59.77, -105.20, -177.67},
1612 {66.58, -122.26, -159.26},
1613 {90.56, -112.17, -159.45}}}}};
1614
1615// Assuming this is the 2
1616std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeRedPositionBack = {{{{{0., 0., 0.},
1617 {0., 0., 0.},
1618 {0., 0., 0.},
1619 {0., 0., 0.},
1620 {0., 0., 0.},
1621 {0., 0., 0.},
1622 {0., 0., 0.},
1623 {0., 0., 0.},
1624 {0., 0., 0.}}},
1625 {{{157.13, 35.72, 120.47},
1626 {146.94, 21.03, 91.76},
1627 {131.15, 14.90, 108.72},
1628 {123.41, 36.28, 108.51},
1629 {137.53, 43.08, 92.04},
1630 {179.50, 30.52, 120.24},
1631 {162.90, 23.38, 138.29},
1632 {152.78, 47.34, 138.43},
1633 {169.87, 54.17, 120.06}}},
1634 {{{-35.72, 157.13, 120.47},
1635 {-21.03, 146.94, 91.76},
1636 {-14.90, 131.15, 108.72},
1637 {-36.28, 123.41, 108.51},
1638 {-43.08, 137.53, 92.04},
1639 {-30.52, 179.50, 120.24},
1640 {-23.38, 162.90, 138.29},
1641 {-47.34, 152.78, 138.43},
1642 {-54.17, 169.87, 120.06}}},
1643 {{{-157.13, -35.72, 120.47},
1644 {-146.94, -21.03, 91.76},
1645 {-131.15, -14.90, 108.72},
1646 {-123.41, -36.28, 108.51},
1647 {-137.53, -43.08, 92.04},
1648 {-179.50, -30.52, 120.24},
1649 {-162.90, -23.38, 138.29},
1650 {-152.78, -47.34, 138.43},
1651 {-169.87, -54.17, 120.06}}},
1652 {{{35.72, -157.13, 120.47},
1653 {21.03, -146.94, 91.76},
1654 {14.90, -131.15, 108.72},
1655 {36.28, -123.41, 108.51},
1656 {43.08, -137.53, 92.04},
1657 {30.52, -179.50, 120.24},
1658 {23.38, -162.90, 138.29},
1659 {47.34, -152.78, 138.43},
1660 {54.17, -169.87, 120.06}}},
1661 {{{192.85, 50.52, -27.13},
1662 {167.97, 29.74, -36.80},
1663 {167.85, 30.10, -12.83},
1664 {159.69, 51.31, -13.71},
1665 {158.82, 51.90, -36.42},
1666 {210.02, 43.16, -40.50},
1667 {210.09, 42.93, -14.96},
1668 {200.11, 66.95, -14.73},
1669 {200.23, 66.75, -40.74}}},
1670 {{{100.64, 172.08, -27.13},
1671 {97.74, 139.81, -36.80},
1672 {97.40, 139.97, -12.83},
1673 {76.64, 149.20, -13.71},
1674 {75.60, 149.00, -36.42},
1675 {117.99, 179.02, -40.50},
1676 {118.21, 178.91, -14.96},
1677 {94.16, 188.84, -14.73},
1678 {94.39, 188.78, -40.74}}},
1679 {{{-50.52, 192.85, -27.13},
1680 {-29.74, 167.97, -36.80},
1681 {-30.10, 167.85, -12.83},
1682 {-51.31, 159.69, -13.71},
1683 {-51.90, 158.82, -36.42},
1684 {-43.16, 210.02, -40.50},
1685 {-42.93, 210.09, -14.96},
1686 {-66.95, 200.11, -14.73},
1687 {-66.75, 200.23, -40.74}}},
1688 {{{-172.08, 100.64, -27.13},
1689 {-139.81, 97.74, -36.80},
1690 {-139.97, 97.40, -12.83},
1691 {-149.20, 76.64, -13.71},
1692 {-149.00, 75.60, -36.42},
1693 {-179.02, 117.99, -40.50},
1694 {-178.91, 118.21, -14.96},
1695 {-188.84, 94.16, -14.73},
1696 {-188.78, 94.39, -40.74}}},
1697 {{{-192.85, -50.52, -27.13},
1698 {-167.97, -29.74, -36.80},
1699 {-167.85, -30.10, -12.83},
1700 {-159.69, -51.31, -13.71},
1701 {-158.82, -51.90, -36.42},
1702 {-210.02, -43.16, -40.50},
1703 {-210.09, -42.93, -14.96},
1704 {-200.11, -66.95, -14.73},
1705 {-200.23, -66.75, -40.74}}},
1706 {{{-100.64, -172.08, -27.13},
1707 {-97.74, -139.81, -36.80},
1708 {-97.40, -139.97, -12.83},
1709 {-76.64, -149.20, -13.71},
1710 {-75.60, -149.00, -36.42},
1711 {-117.99, -179.02, -40.50},
1712 {-118.21, -178.91, -14.96},
1713 {-94.16, -188.84, -14.73},
1714 {-94.39, -188.78, -40.74}}},
1715 {{{50.52, -192.85, -27.13},
1716 {29.74, -167.97, -36.80},
1717 {30.10, -167.85, -12.83},
1718 {51.31, -159.69, -13.71},
1719 {51.90, -158.82, -36.42},
1720 {43.16, -210.02, -40.50},
1721 {42.93, -210.09, -14.96},
1722 {66.95, -200.11, -14.73},
1723 {66.75, -200.23, -40.74}}},
1724 {{{172.08, -100.64, -27.13},
1725 {139.81, -97.74, -36.80},
1726 {139.97, -97.40, -12.83},
1727 {149.20, -76.64, -13.71},
1728 {149.00, -75.60, -36.42},
1729 {179.02, -117.99, -40.50},
1730 {178.91, -118.21, -14.96},
1731 {188.84, -94.16, -14.73},
1732 {188.78, -94.39, -40.74}}},
1733 {{{121.68, 21.04, -158.84},
1734 {98.86, 1.12, -143.80},
1735 {114.39, 7.96, -126.87},
1736 {105.50, 28.86, -127.90},
1737 {89.95, 23.37, -143.55},
1738 {126.59, 8.60, -177.52},
1739 {143.35, 15.28, -159.45},
1740 {133.53, 39.37, -159.26},
1741 {116.65, 32.12, -177.67}}},
1742 {{{-21.04, 121.68, -158.84},
1743 {-1.12, 98.86, -143.80},
1744 {-7.96, 114.39, -126.87},
1745 {-28.86, 105.50, -127.90},
1746 {-23.37, 89.95, -143.55},
1747 {-8.60, 126.59, -177.52},
1748 {-15.28, 143.35, -159.45},
1749 {-39.37, 133.53, -159.26},
1750 {-32.12, 116.65, -177.67}}},
1751 {{{-121.68, -21.04, -158.84},
1752 {-98.86, -1.12, -143.80},
1753 {-114.39, -7.96, -126.87},
1754 {-105.50, -28.86, -127.90},
1755 {-89.95, -23.37, -143.55},
1756 {-126.59, -8.60, -177.52},
1757 {-143.35, -15.28, -159.45},
1758 {-133.53, -39.37, -159.26},
1759 {-116.65, -32.12, -177.67}}},
1760 {{{21.04, -121.68, -158.84},
1761 {1.12, -98.86, -143.80},
1762 {7.96, -114.39, -126.87},
1763 {28.86, -105.50, -127.90},
1764 {23.37, -89.95, -143.55},
1765 {8.60, -126.59, -177.52},
1766 {15.28, -143.35, -159.45},
1767 {39.37, -133.53, -159.26},
1768 {32.12, -116.65, -177.67}}}}};
1769
1770// Assuming this is the 3
1771std::array<std::array<std::array<double, 3>, 9>, 17> TTigress::fGeWhitePositionBack = {{{{{0., 0., 0.},
1772 {0., 0., 0.},
1773 {0., 0., 0.},
1774 {0., 0., 0.},
1775 {0., 0., 0.},
1776 {0., 0., 0.},
1777 {0., 0., 0.},
1778 {0., 0., 0.},
1779 {0., 0., 0.}}},
1780 {{{121.68, 21.04, 158.84},
1781 {98.86, 1.12, 143.80},
1782 {89.95, 23.37, 143.55},
1783 {105.50, 28.86, 127.90},
1784 {114.39, 7.96, 126.87},
1785 {126.59, 8.60, 177.52},
1786 {116.65, 32.12, 177.67},
1787 {133.53, 39.37, 159.26},
1788 {143.35, 15.28, 159.45}}},
1789 {{{-21.04, 121.68, 158.84},
1790 {-1.12, 98.86, 143.80},
1791 {-23.37, 89.95, 143.55},
1792 {-28.86, 105.50, 127.90},
1793 {-7.96, 114.39, 126.87},
1794 {-8.60, 126.59, 177.52},
1795 {-32.12, 116.65, 177.67},
1796 {-39.37, 133.53, 159.26},
1797 {-15.28, 143.35, 159.45}}},
1798 {{{-121.68, -21.04, 158.84},
1799 {-98.86, -1.12, 143.80},
1800 {-89.95, -23.37, 143.55},
1801 {-105.50, -28.86, 127.90},
1802 {-114.39, -7.96, 126.87},
1803 {-126.59, -8.60, 177.52},
1804 {-116.65, -32.12, 177.67},
1805 {-133.53, -39.37, 159.26},
1806 {-143.35, -15.28, 159.45}}},
1807 {{{21.04, -121.68, 158.84},
1808 {1.12, -98.86, 143.80},
1809 {23.37, -89.95, 143.55},
1810 {28.86, -105.50, 127.90},
1811 {7.96, -114.39, 126.87},
1812 {8.60, -126.59, 177.52},
1813 {32.12, -116.65, 177.67},
1814 {39.37, -133.53, 159.26},
1815 {15.28, -143.35, 159.45}}},
1816 {{{192.85, 50.52, 27.13},
1817 {167.97, 29.74, 36.80},
1818 {158.82, 51.90, 36.42},
1819 {159.69, 51.31, 13.71},
1820 {167.85, 30.10, 12.83},
1821 {210.02, 43.16, 40.50},
1822 {200.23, 66.75, 40.74},
1823 {200.11, 66.95, 14.73},
1824 {210.09, 42.93, 14.96}}},
1825 {{{100.64, 172.08, 27.13},
1826 {97.74, 139.81, 36.80},
1827 {75.60, 149.00, 36.42},
1828 {76.64, 149.20, 13.71},
1829 {97.40, 139.97, 12.83},
1830 {117.99, 179.02, 40.50},
1831 {94.39, 188.78, 40.74},
1832 {94.16, 188.84, 14.73},
1833 {118.21, 178.91, 14.96}}},
1834 {{{-50.52, 192.85, 27.13},
1835 {-29.74, 167.97, 36.80},
1836 {-51.90, 158.82, 36.42},
1837 {-51.31, 159.69, 13.71},
1838 {-30.10, 167.85, 12.83},
1839 {-43.16, 210.02, 40.50},
1840 {-66.75, 200.23, 40.74},
1841 {-66.95, 200.11, 14.73},
1842 {-42.93, 210.09, 14.96}}},
1843 {{{-172.08, 100.64, 27.13},
1844 {-139.81, 97.74, 36.80},
1845 {-149.00, 75.60, 36.42},
1846 {-149.20, 76.64, 13.71},
1847 {-139.97, 97.40, 12.83},
1848 {-179.02, 117.99, 40.50},
1849 {-188.78, 94.39, 40.74},
1850 {-188.84, 94.16, 14.73},
1851 {-178.91, 118.21, 14.96}}},
1852 {{{-192.85, -50.52, 27.13},
1853 {-167.97, -29.74, 36.80},
1854 {-158.82, -51.90, 36.42},
1855 {-159.69, -51.31, 13.71},
1856 {-167.85, -30.10, 12.83},
1857 {-210.02, -43.16, 40.50},
1858 {-200.23, -66.75, 40.74},
1859 {-200.11, -66.95, 14.73},
1860 {-210.09, -42.93, 14.96}}},
1861 {{{-100.64, -172.08, 27.13},
1862 {-97.74, -139.81, 36.80},
1863 {-75.60, -149.00, 36.42},
1864 {-76.64, -149.20, 13.71},
1865 {-97.40, -139.97, 12.83},
1866 {-117.99, -179.02, 40.50},
1867 {-94.39, -188.78, 40.74},
1868 {-94.16, -188.84, 14.73},
1869 {-118.21, -178.91, 14.96}}},
1870 {{{50.52, -192.85, 27.13},
1871 {29.74, -167.97, 36.80},
1872 {51.90, -158.82, 36.42},
1873 {51.31, -159.69, 13.71},
1874 {30.10, -167.85, 12.83},
1875 {43.16, -210.02, 40.50},
1876 {66.75, -200.23, 40.74},
1877 {66.95, -200.11, 14.73},
1878 {42.93, -210.09, 14.96}}},
1879 {{{172.08, -100.64, 27.13},
1880 {139.81, -97.74, 36.80},
1881 {149.00, -75.60, 36.42},
1882 {149.20, -76.64, 13.71},
1883 {139.97, -97.40, 12.83},
1884 {179.02, -117.99, 40.50},
1885 {188.78, -94.39, 40.74},
1886 {188.84, -94.16, 14.73},
1887 {178.91, -118.21, 14.96}}},
1888 {{{157.13, 35.72, -120.47},
1889 {146.94, 21.03, -91.76},
1890 {137.53, 43.08, -92.04},
1891 {123.41, 36.28, -108.51},
1892 {131.15, 14.90, -108.72},
1893 {179.50, 30.52, -120.24},
1894 {169.87, 54.17, -120.06},
1895 {152.78, 47.34, -138.43},
1896 {162.90, 23.38, -138.29}}},
1897 {{{-35.72, 157.13, -120.47},
1898 {-21.03, 146.94, -91.76},
1899 {-43.08, 137.53, -92.04},
1900 {-36.28, 123.41, -108.51},
1901 {-14.90, 131.15, -108.72},
1902 {-30.52, 179.50, -120.24},
1903 {-54.17, 169.87, -120.06},
1904 {-47.34, 152.78, -138.43},
1905 {-23.38, 162.90, -138.29}}},
1906 {{{-157.13, -35.72, -120.47},
1907 {-146.94, -21.03, -91.76},
1908 {-137.53, -43.08, -92.04},
1909 {-123.41, -36.28, -108.51},
1910 {-131.15, -14.90, -108.72},
1911 {-179.50, -30.52, -120.24},
1912 {-169.87, -54.17, -120.06},
1913 {-152.78, -47.34, -138.43},
1914 {-162.90, -23.38, -138.29}}},
1915 {{{35.72, -157.13, -120.47},
1916 {21.03, -146.94, -91.76},
1917 {43.08, -137.53, -92.04},
1918 {36.28, -123.41, -108.51},
1919 {14.90, -131.15, -108.72},
1920 {30.52, -179.50, -120.24},
1921 {54.17, -169.87, -120.06},
1922 {47.34, -152.78, -138.43},
1923 {23.38, -162.90, -138.29}}}}};
DRED
#define DRED
Definition Globals.h:18
RESET_COLOR
#define RESET_COLOR
Definition Globals.h:5
ALERTTEXT
#define ALERTTEXT
Definition Globals.h:35
DefaultTigressSuppression
bool DefaultTigressSuppression(const TDetectorHit *hit, const TDetectorHit *bgoHit)
Definition TTigress.cxx:31
DefaultTigressAddback
bool DefaultTigressAddback(const TDetectorHit *one, const TDetectorHit *two)
Definition TTigress.cxx:23
TAnalysisOptions::SuppressionWindow
double SuppressionWindow() const
Definition TAnalysisOptions.h:58
TAnalysisOptions::AddbackWindow
double AddbackWindow() const
Definition TAnalysisOptions.h:50
TAnalysisOptions::SuppressionEnergy
double SuppressionEnergy() const
Definition TAnalysisOptions.h:59
TAnalysisOptions::IsWaveformFitting
bool IsWaveformFitting() const
Definition TAnalysisOptions.h:43
TBgo
Definition TBgo.h:16
TChannel::GetDetectorNumber
int GetDetectorNumber() const
Definition TChannel.cxx:1566
TChannel::GetCrystalNumber
int GetCrystalNumber() const
Definition TChannel.cxx:1600
TChannel::GetCTCoeff
std::vector< double > GetCTCoeff() const
Definition TChannel.h:194
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::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
TDetector::GetMultiplicity
virtual Short_t GetMultiplicity() const
Definition TDetector.h:70
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::GetName
const char * GetName() const override
Definition TMnemonic.h:104
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
TSuppressed::Clear
void Clear(Option_t *opt="all") override
!
Definition TSuppressed.cxx:9
TSuppressed::Copy
void Copy(TObject &) const override
!
Definition TSuppressed.cxx:3
TSuppressed::CreateAddback
void CreateAddback(const std::vector< T * > &hits, std::vector< T * > &addbacks, std::vector< UShort_t > &nofFragments)
Definition TSuppressed.h:38
TSuppressed::CreateSuppressed
void CreateSuppressed(const TBgo *bgo, const std::vector< T * > &hits, std::vector< T * > &suppressedHits)
Definition TSuppressed.h:69
TSuppressed::CreateSuppressedAddback
void CreateSuppressedAddback(const TBgo *bgo, const std::vector< T * > &hits, std::vector< T * > &addbacks, std::vector< UShort_t > &nofFragments)
Definition TSuppressed.h:94
TTigressHit::GetNoCTEnergy
Double_t GetNoCTEnergy(Option_t *opt="") const
Definition TTigressHit.cxx:212
TTigressHit::GetFirstSegment
int GetFirstSegment() const
Definition TTigressHit.h:89
TTigressHit::CopyFragment
void CopyFragment(const TFragment &)
Definition TTigressHit.cxx:28
TTigressHit::CoreSet
bool CoreSet() const
Definition TTigressHit.h:77
TTigressHit::AddSegment
void AddSegment(const TDetectorHit &seg)
!
Definition TTigressHit.h:60
TTigress::SetAddback
void SetAddback(bool flag=true) const
Definition TTigress.cxx:160
TTigress::GetPosition
static TVector3 GetPosition(int DetNbr, int CryNbr, int SegNbr, double dist=110.0, bool smear=false)
!
Definition TTigress.cxx:562
TTigress::ResetFlags
void ResetFlags() const
Definition TTigress.cxx:324
TTigress::GetSuppressedHit
TTigressHit * GetSuppressedHit(const int &i)
!
Definition TTigress.cxx:436
TTigress::IsSuppressedAddbackSet
bool IsSuppressedAddbackSet() const
Definition TTigress.cxx:431
TTigress::Copy
void Copy(TObject &) const override
!
Definition TTigress.cxx:58
TTigress::fAddbackHits
std::vector< TDetectorHit * > fAddbackHits
! Used to create addback hits on the fly
Definition TTigress.h:155
TTigress::ResetAddback
void ResetAddback()
!
Definition TTigress.cxx:329
TTigress::fSuppressedAddbackFrags
std::vector< UShort_t > fSuppressedAddbackFrags
! Number of crystals involved in creating in the suppressed addback hit
Definition TTigress.h:161
TTigress::fGeBluePositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeBluePositionBack
! detector segment XYZ
Definition TTigress.h:1306
TTigress::GetTigressHit
TTigressHit * GetTigressHit(const int &i)
!
Definition TTigress.cxx:170
TTigress::fGlobalTigressBits
static TTransientBits< uint8_t > fGlobalTigressBits
!
Definition TTigress.h:152
TTigress::GetAddbackMultiplicity
Short_t GetAddbackMultiplicity()
Definition TTigress.cxx:191
TTigress::GetSuppressedAddbackMultiplicity
Short_t GetSuppressedAddbackMultiplicity(const TBgo *bgo)
Definition TTigress.cxx:505
TTigress::IsSuppressed
bool IsSuppressed() const
Definition TTigress.cxx:426
TTigress::fCloverRadial
static std::array< TVector3, 17 > fCloverRadial
! direction vector of each HPGe Clover
Definition TTigress.h:669
TTigress::fSuppressedAddbackHits
std::vector< TDetectorHit * > fSuppressedAddbackHits
! Used to create suppressed addback hits on the fly
Definition TTigress.h:160
TTigress::fCloverCross
static std::array< std::array< TVector3, 2 >, 17 > fCloverCross
! clover perpendicular vectors, for smearing
Definition TTigress.h:140
TTigress::fGeBluePosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeBluePosition
! detector segment XYZ
Definition TTigress.h:687
TTigress::GetNSuppressedAddbackFrags
UShort_t GetNSuppressedAddbackFrags(const size_t &idx)
Definition TTigress.cxx:544
TTigress::SetSuppressedAddback
void SetSuppressedAddback(bool flag=true) const
Definition TTigress.cxx:529
TTigress::fGeWhitePositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeWhitePositionBack
!
Definition TTigress.h:1771
TTigress::ClearStatus
void ClearStatus() const
!
Definition TTigress.h:164
TTigress::fTargetOffset
static double fTargetOffset
!
Definition TTigress.h:133
TTigress::IsAddbackSet
bool IsAddbackSet() const
Definition TTigress.cxx:150
TTigress::SetGlobalBit
static void SetGlobalBit(ETigressGlobalBits bit, Bool_t set=true)
Definition TTigress.h:167
TTigress::AddFragment
void AddFragment(const std::shared_ptr< const TFragment > &, TChannel *) override
!
Definition TTigress.cxx:246
TTigress::GetSuppressedMultiplicity
Short_t GetSuppressedMultiplicity(const TBgo *bgo)
Definition TTigress.cxx:452
TTigress::ResetSuppressed
void ResetSuppressed()
Definition TTigress.cxx:480
TTigress::BuildHits
void BuildHits() override
!
Definition TTigress.cxx:225
TTigress::fGeGreenPosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeGreenPosition
!
Definition TTigress.h:842
TTigress::fTigressBits
TTransientBits< uint8_t > fTigressBits
Definition TTigress.h:153
TTigress::GetSuppressedAddbackHit
TTigressHit * GetSuppressedAddbackHit(const int &i)
Definition TTigress.cxx:489
TTigress::fGeRedPositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeRedPositionBack
!
Definition TTigress.h:1616
TTigress::fGeRedPosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeRedPosition
!
Definition TTigress.h:997
TTigress::fSuppressedHits
std::vector< TDetectorHit * > fSuppressedHits
! The set of suppressed crystal hits
Definition TTigress.h:158
TTigress::CTCorrectedEnergy
static Double_t CTCorrectedEnergy(const TTigressHit *hit_to_correct, const TTigressHit *other_hit, bool time_constraint=true)
Definition TTigress.cxx:356
TTigress::~TTigress
~TTigress() override
Definition TTigress.cxx:82
TTigress::BuildVectors
static void BuildVectors()
Definition TTigress.cxx:585
TTigress::GetColorFromNumber
static const char * GetColorFromNumber(int number)
Definition TTigress.cxx:415
TTigress::fAddbackCriterion
static std::function< bool(const TDetectorHit *, const TDetectorHit *)> fAddbackCriterion
Definition TTigress.h:129
TTigress::Clear
void Clear(Option_t *opt="all") override
!
Definition TTigress.cxx:97
TTigress::TestGlobalBit
static Bool_t TestGlobalBit(ETigressGlobalBits bit)
Definition TTigress.h:168
TTigress::operator=
TTigress & operator=(const TTigress &)
!
Definition TTigress.cxx:144
TTigress::fGeGreenPositionBack
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeGreenPositionBack
!
Definition TTigress.h:1461
TTigress::ResetSuppressedAddback
void ResetSuppressedAddback()
Definition TTigress.cxx:534
TTigress::SetBitNumber
void SetBitNumber(ETigressBits bit, Bool_t set) const
Definition TTigress.cxx:350
TTigress::TestBitNumber
Bool_t TestBitNumber(ETigressBits bit) const
Definition TTigress.h:166
TTigress::SetCrossTalk
void SetCrossTalk(bool flag=true) const
Definition TTigress.cxx:165
TTigress::FixCrossTalk
void FixCrossTalk()
Definition TTigress.cxx:394
TTigress::GetAddbackHit
TTigressHit * GetAddbackHit(const int &i)
Definition TTigress.cxx:215
TTigress::IsCrossTalkSet
Bool_t IsCrossTalkSet() const
Definition TTigress.cxx:155
TTigress::SetSuppressed
void SetSuppressed(bool flag=true) const
Definition TTigress.cxx:475
TTigress::Print
void Print(Option_t *opt="") const override
!
Definition TTigress.cxx:119
TTigress::fSuppressionCriterion
static std::function< bool(const TDetectorHit *, const TDetectorHit *)> fSuppressionCriterion
Definition TTigress.h:130
TTigress::GetNAddbackFrags
UShort_t GetNAddbackFrags(const size_t &idx)
Definition TTigress.cxx:340
TTigress::fGeWhitePosition
static std::array< std::array< std::array< double, 3 >, 9 >, 17 > fGeWhitePosition
!
Definition TTigress.h:1152
TTigress::fPositionVectors
static std::array< std::array< std::array< std::array< TVector3, 9 >, 4 >, 17 >, 2 > fPositionVectors
!
Definition TTigress.h:137
TTigress::fRadialOffset
static double fRadialOffset
!
Definition TTigress.h:134
TTigress::fAddbackFrags
std::vector< UShort_t > fAddbackFrags
! Number of crystals involved in creating in the addback hit
Definition TTigress.h:156
TTransientBits::SetBit
void SetBit(T bit, Bool_t flag)
Definition TTransientBits.h:33
grsi::exit_exception
Definition Globals.h:74