LOGO
RestFrames  v1.0.1
RestFrames HEP Event Analysis Software Library
example_DiGluino_to_bbXbbX.C
Go to the documentation of this file.
1 // RestFrames: particle physics event analysis library
3 // --------------------------------------------------------------------
4 // Copyright (c) 2014-2019, Christopher Rogan
13 //
14 // This file is part of RestFrames.
15 //
16 // RestFrames is free software; you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation; either version 2 of the License, or
19 // (at your option) any later version.
20 //
21 // RestFrames is distributed in the hope that it will be useful,
22 // but WITHOUT ANY WARRANTY; without even the implied warranty of
23 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 // GNU General Public License for more details.
25 //
26 // You should have received a copy of the GNU General Public License
27 // along with RestFrames. If not, see <http://www.gnu.org/licenses/>.
29 
30 #if (!defined(__CINT__) && !defined(__CLING__))
31 #define COMPILER
32 #endif
33 #if defined(__MAKECINT__) || defined(__ROOTCLING__) || defined(COMPILER)
34 #include "RestFrames/RestFrames.hh"
35 #else
36 RestFrames::RFKey ensure_autoload(1);
37 #endif
38 
39 using namespace RestFrames;
40 
41 void example_DiGluino_to_bbXbbX(std::string output_name =
42  "output_DiGluino_to_bbXbbX.root"){
43  double mG = 1000.;
44  double mX = 100.;
45 
46  // Number of events to generate
47  int Ngen = 10000;
48 
50  g_Log << LogInfo << "Initializing generator frames and tree..." << LogEnd;
52  ppLabGenFrame LAB_Gen("LAB_Gen","LAB");
53  DecayGenFrame GG_Gen("GG_Gen","#tilde{g}#tilde{g}");
54  DecayGenFrame Ga_Gen("Ga_Gen","#tilde{g}_{a}");
55  DecayGenFrame Gb_Gen("Gb_Gen","#tilde{g}_{b}");
56  VisibleGenFrame V1a_Gen("V1a_Gen","j_{1a}");
57  VisibleGenFrame V2a_Gen("V2a_Gen","j_{2a}");
58  InvisibleGenFrame Xa_Gen("Xa_Gen","#tilde{#chi}_{a}");
59  VisibleGenFrame V1b_Gen("V1b_Gen","j_{1b}");
60  VisibleGenFrame V2b_Gen("V2b_Gen","j_{2b}");
61  InvisibleGenFrame Xb_Gen("Xb_Gen","#tilde{#chi}_{b}");
62 
63  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
64 
65  LAB_Gen.SetChildFrame(GG_Gen);
66  GG_Gen.AddChildFrame(Ga_Gen);
67  GG_Gen.AddChildFrame(Gb_Gen);
68  Ga_Gen.AddChildFrame(V1a_Gen);
69  Ga_Gen.AddChildFrame(V2a_Gen);
70  Ga_Gen.AddChildFrame(Xa_Gen);
71  Gb_Gen.AddChildFrame(V1b_Gen);
72  Gb_Gen.AddChildFrame(V2b_Gen);
73  Gb_Gen.AddChildFrame(Xb_Gen);
74 
75  if(LAB_Gen.InitializeTree())
76  g_Log << LogInfo << "...Successfully initialized generator tree" << LogEnd;
77  else
78  g_Log << LogError << "...Failed initializing generator tree" << LogEnd;
79 
80  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
81 
82  GG_Gen.SetVariableMass();
83  // set gluino masses
84  Ga_Gen.SetMass(mG);
85  Gb_Gen.SetMass(mG);
86  // set X masses
87  Xa_Gen.SetMass(mX);
88  Xb_Gen.SetMass(mX);
89  // set jet pT and eta cuts
90  V1a_Gen.SetPtCut(30.); V1a_Gen.SetEtaCut(2.5);
91  V1b_Gen.SetPtCut(30.); V1b_Gen.SetEtaCut(2.5);
92  V2a_Gen.SetPtCut(30.); V2a_Gen.SetEtaCut(2.5);
93  V2b_Gen.SetPtCut(30.); V2b_Gen.SetEtaCut(2.5);
94 
95  if(LAB_Gen.InitializeAnalysis())
96  g_Log << LogInfo << "...Successfully initialized generator analysis" << std::endl << LogEnd;
97  else
98  g_Log << LogError << "...Failed initializing generator analysis" << LogEnd;
101 
103  g_Log << LogInfo << "Initializing reconstruction frames and trees..." << LogEnd;
105  LabRecoFrame LAB("LAB","LAB");
106  DecayRecoFrame GG("GG","#tilde{g}#tilde{g}");
107  DecayRecoFrame Ga("Ga","#tilde{g}_{a}");
108  DecayRecoFrame Gb("Gb","#tilde{g}_{b}");
109  DecayRecoFrame Ca("Ca","C_{a}");
110  DecayRecoFrame Cb("Cb","C_{b}");
111  VisibleRecoFrame V1a("V1a","j_{1a}");
112  VisibleRecoFrame V2a("V2a","j_{2a}");
113  InvisibleRecoFrame Xa("Xa","#tilde{#chi}_{a}");
114  VisibleRecoFrame V1b("V1b","j_{1b}");
115  VisibleRecoFrame V2b("V2b","j_{2b}");
116  InvisibleRecoFrame Xb("Xb","#tilde{#chi}_{b}");
117 
118  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
119 
120  LAB.SetChildFrame(GG);
121  GG.AddChildFrame(Ga);
122  GG.AddChildFrame(Gb);
123  Ga.AddChildFrame(V1a);
124  Ga.AddChildFrame(Ca);
125  Ca.AddChildFrame(V2a);
126  Ca.AddChildFrame(Xa);
127  Gb.AddChildFrame(V1b);
128  Gb.AddChildFrame(Cb);
129  Cb.AddChildFrame(V2b);
130  Cb.AddChildFrame(Xb);
131 
132  if(LAB.InitializeTree())
133  g_Log << LogInfo << "...Successfully initialized reconstruction trees" << LogEnd;
134  else
135  g_Log << LogError << "...Failed initializing reconstruction trees" << LogEnd;
136 
137  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
138 
139  // Set up 'background-like' analysis tree
140  LabRecoFrame LAB_B("LAB_B","LAB");
141  SelfAssemblingRecoFrame CM_B("CM_B","CM");
142  VisibleRecoFrame V_B("V_B","Vis");
143  InvisibleRecoFrame I_B("I_B","Inv");
144  LAB_B.SetChildFrame(CM_B);
145  CM_B.AddChildFrame(V_B);
146  CM_B.AddChildFrame(I_B);
147 
148  if(LAB.InitializeTree())
149  g_Log << LogInfo << "...Successfully initialized reconstruction trees" << LogEnd;
150  else
151  g_Log << LogError << "...Failed initializing reconstruction trees" << LogEnd;
152 
153  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
154 
155  InvisibleGroup INV("INV","WIMP Jigsaws");
156  INV.AddFrame(Xa);
157  INV.AddFrame(Xb);
158  CombinatoricGroup VIS("VIS","Visible Object Jigsaws");
159 
160  // visible frames in first decay step must always have at least one element
161  VIS.AddFrame(V1a);
162  VIS.AddFrame(V1b);
163  VIS.SetNElementsForFrame(V1a,1,false);
164  VIS.SetNElementsForFrame(V1b,1,false);
165  // visible frames in second decay step can have zero elements
166  VIS.AddFrame(V2a);
167  VIS.AddFrame(V2b);
168  VIS.SetNElementsForFrame(V2a,0,false);
169  VIS.SetNElementsForFrame(V2b,0,false);
170 
171  InvisibleGroup INV_B("INV_B","Invisible State Jigsaws");
172  INV_B.AddFrame(I_B);
173  CombinatoricGroup VIS_B("VIS_B","Visible Object Jigsaws");
174  VIS_B.AddFrame(V_B);
175  VIS_B.SetNElementsForFrame(V_B,1,false);
176 
177  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
178 
179  // signal-like jigsaws
180  SetMassInvJigsaw MinMassJigsaw("MINMASS", "Invisible system mass Jigsaw");
181  INV.AddJigsaw(MinMassJigsaw);
182  SetRapidityInvJigsaw RapidityJigsaw("RAPIDITY", "Invisible system rapidity Jigsaw");
183  INV.AddJigsaw(RapidityJigsaw);
184  RapidityJigsaw.AddVisibleFrames((LAB.GetListVisibleFrames()));
185  ContraBoostInvJigsaw ContraBoostJigsaw("CONTRA","Contraboost invariant Jigsaw");
186  INV.AddJigsaw(ContraBoostJigsaw);
187  ContraBoostJigsaw.AddVisibleFrames((Ga.GetListVisibleFrames()), 0);
188  ContraBoostJigsaw.AddVisibleFrames((Gb.GetListVisibleFrames()), 1);
189  ContraBoostJigsaw.AddInvisibleFrames((Ga.GetListInvisibleFrames()), 0);
190  ContraBoostJigsaw.AddInvisibleFrames((Gb.GetListInvisibleFrames()), 1);
191  MinMassesCombJigsaw HemiJigsaw("HEM_JIGSAW","Minimize m _{V_{a,b}} Jigsaw");
192  VIS.AddJigsaw(HemiJigsaw);
193  HemiJigsaw.AddFrame(V1a,0);
194  HemiJigsaw.AddFrame(V1b,1);
195  HemiJigsaw.AddFrame(V2a,0);
196  HemiJigsaw.AddFrame(V2b,1);
197  MinMassesCombJigsaw CaHemiJigsaw("CaHEM_JIGSAW","Minimize m _{C_{a}} Jigsaw");
198  VIS.AddJigsaw(CaHemiJigsaw);
199  CaHemiJigsaw.AddFrame(V1a,0);
200  CaHemiJigsaw.AddFrame(V2a,1);
201  CaHemiJigsaw.AddFrame(Xa,1);
202  MinMassesCombJigsaw CbHemiJigsaw("CbHEM_JIGSAW","Minimize m _{C_{b}} Jigsaw");
203  VIS.AddJigsaw(CbHemiJigsaw);
204  CbHemiJigsaw.AddFrame(V1b,0);
205  CbHemiJigsaw.AddFrame(V2b,1);
206  CbHemiJigsaw.AddFrame(Xb,1);
207 
208  // background tree jigsaws
209  SetMassInvJigsaw MinMassJigsaw_B("MINMASS_B","Zero Mass for invisible system");
210  INV_B.AddJigsaw(MinMassJigsaw_B);
211  SetRapidityInvJigsaw RapidityJigsaw_B("RAPIDITY_B","Invisible system rapidity Jigsaw");
212  INV_B.AddJigsaw(RapidityJigsaw_B);
213  RapidityJigsaw_B.AddVisibleFrames((LAB_B.GetListVisibleFrames()));
214 
215  // check reconstruction trees
216  if(LAB.InitializeAnalysis() && LAB_B.InitializeAnalysis())
217  g_Log << LogInfo << "...Successfully initialized analyses" << LogEnd;
218  else
219  g_Log << LogError << "...Failed initializing analyses" << LogEnd;
220 
222  // draw some pictures of our trees
224 
225  TreePlot* tree_plot = new TreePlot("TreePlot","TreePlot");
226 
227  // generator tree
228  tree_plot->SetTree(LAB_Gen);
229  tree_plot->Draw("GenTree", "Generator Tree", true);
230 
231  // signal reco tree
232  tree_plot->SetTree(LAB);
233  tree_plot->AddJigsaw(ContraBoostJigsaw);
234  tree_plot->AddJigsaw(HemiJigsaw);
235  tree_plot->AddJigsaw(CaHemiJigsaw);
236  tree_plot->AddJigsaw(CbHemiJigsaw);
237  tree_plot->Draw("SigRecoTree", "Signal Reconstruction Tree");
238 
239  // background reco tree
240  tree_plot->SetTree(LAB_B);
241  tree_plot->Draw("BkgRecoTree", "Background Reconstruction Tree");
242 
243  // Invisible Jigsaws
244  tree_plot->SetTree(INV);
245  tree_plot->Draw("InvTree", "Invisible Objects Jigsaws");
246 
247  // Visible Jigsaws
248  tree_plot->SetTree(VIS);
249  tree_plot->Draw("VisTree", "Visible Objects Jigsaws");
250 
251 
252  for(int igen = 0; igen < Ngen; igen++){
253  if(igen%((std::max(Ngen,10))/10) == 0)
254  g_Log << LogInfo << "Generating event " << igen << " of " << Ngen << LogEnd;
255 
256  // generate event
257  LAB_Gen.ClearEvent(); // clear the gen tree
258 
259  LAB_Gen.SetPToverM(LAB_Gen.GetRandom()); // give the di-gluinos some Pt
260 
261  LAB_Gen.AnalyzeEvent(); // generate a new event
262 
263  // analyze event
264  TVector3 MET = LAB_Gen.GetInvisibleMomentum(); // Get the MET from gen tree
265  MET.SetZ(0.);
266  std::vector<TLorentzVector> JETS; // Get the Jets from gen tree
267  JETS.push_back(V1a_Gen.GetFourVector());
268  JETS.push_back(V2a_Gen.GetFourVector());
269  JETS.push_back(V1b_Gen.GetFourVector());
270  JETS.push_back(V2b_Gen.GetFourVector());
271 
272  // give the signal-like tree the event info and analyze
273  LAB.ClearEvent(); // clear the signal-like tree
274  INV.SetLabFrameThreeVector(MET); // Set the MET in reco tree
275  std::vector<RFKey> jetID; // ID for tracking jets in tree
276  for(int i = 0; i < int(JETS.size()); i++)
277  jetID.push_back(VIS.AddLabFrameFourVector(JETS[i]));
278  LAB.AnalyzeEvent(); // analyze the event
279 
280  // give the background-like tree the event info and analyze
281  LAB_B.ClearEvent(); // clear the bkg-like tree
282  INV_B.SetLabFrameThreeVector(MET); // Set the MET in tree
283  for(int i = 0; i < int(JETS.size()); i++){
284  TLorentzVector jet = JETS[i];
285  jet.SetPtEtaPhiM(jet.Pt(), 0., jet.Phi(), jet.M()); // only pass transverse info to bkg-like tree
286  VIS_B.AddLabFrameFourVector(jet);
287  }
288  LAB_B.AnalyzeEvent(); // analyze the event
289 
290  DecayRecoFrame* G[2];
291  DecayRecoFrame* C[2];
292  VisibleRecoFrame* VS[2];
293  VisibleRecoFrame* VC[2];
294  InvisibleRecoFrame* X[2];
295  // Randomize the two hemispheres
296  int flip = (gRandom->Rndm() > 0.5);
297  G[flip] = &Ga;
298  G[(flip+1)%2] = &Gb;
299  C[flip] = &Ca;
300  C[(flip+1)%2] = &Cb;
301  VS[flip] = &V1a;
302  VS[(flip+1)%2] = &V1b;
303  VC[flip] = &V2a;
304  VC[(flip+1)%2] = &V2b;
305  X[flip] = &Xa;
306  X[(flip+1)%2] = &Xb;
307 
309  // Observable Calculations
311 
312  //
313  // signal tree observables
314  //
315 
316  //*** total CM mass
317  double shat = GG.GetMass();
318  //*** 'mass-less' gluino gamma in CM frame
319  double gaminv = GG.GetVisibleShape();
320 
321  TVector3 vPGG = GG.GetFourVector(LAB).Vect();
322 
323  //*** ratio of CM pT to CM mass
324  double RPT = vPGG.Pt() / (vPGG.Pt() + shat/4.);
325  //*** ratio of CM pz to CM mass
326  double RPZ = vPGG.Pz() / (vPGG.Pz() + shat/4.);
327  //*** cos decay angle of GG system
328  double cosGG = GG.GetCosDecayAngle();
329  //*** delta phi between lab and GG decay planes
330  double dphiLGG = LAB.GetDeltaPhiDecayPlanes(GG);
331 
332  TLorentzVector vV1 = G[0]->GetVisibleFourVector(*G[0]);
333  TLorentzVector vV2 = G[1]->GetVisibleFourVector(*G[1]);
334 
335  //*** gluino mass
336  double MG = (vV1.M2()-vV2.M2())/(2.*(vV1.E()-vV2.E()));
337 
338  double PG = G[0]->GetMomentum(GG);
339  double MGG = 2.*sqrt(PG*PG + MG*MG);
340  double gaminvGG = 2.*MG/MGG;
341  double beta = sqrt(1.- gaminv*gaminv);
342  double betaGG = sqrt(1.- gaminvGG*gaminvGG);
343 
344  //*** velocity difference between 'massive' and 'mass-less'
345  double DeltaBetaGG = -(betaGG-beta)/(1.-betaGG*beta);
346  //*** delta phi between GG visible decay products and GG decay axis
347  double dphiVG = GG.GetDeltaPhiDecayVisible();
348  //*** delta phi between GG visible decay products and GG momentum
349  double dphiVGG = GG.GetDeltaPhiBoostVisible();
350 
351  // 'hemisphere' (one for each 'gluino') observables
352 
353  //*** number of visible objects (jets) in hemisphere
354  double NV[2];
355  //*** cosine gluino decay angle
356  double cosG[2];
357  //*** cosine intermediate child decay angle
358  double cosC[2];
359  //*** delta phi between gluino and child decay planes
360  double dphiGC[2];
361  //*** ratio of child and gluino masses (w/ WIMP masses subtracted)
362  double RCG[2];
363  //*** 1st leading jet pT _associated with this hemisphere_
364  double jet1PT[2];
365  //*** 2nd leading jet pT _associated with this hemisphere_
366  double jet2PT[2];
367  //*** Pinv / HG
368  double Pinv[2];
369 
370  for(int i = 0; i < 2; i++){
371  NV[i] = VIS.GetNElementsInFrame(*VS[i]);
372  NV[i] += VIS.GetNElementsInFrame(*VC[i]);
373 
374  TVector3 vP1 = VS[i]->GetFourVector(*G[i]).Vect();
375  TVector3 vP2 = VC[i]->GetFourVector(*G[i]).Vect();
376  Pinv[i] = 2.*(vP1+vP2).Mag()/(vP1.Mag()+vP2.Mag()+(vP1+vP2).Mag());
377 
378  cosG[i] = G[i]->GetCosDecayAngle();
379 
380  int N = jetID.size();
381  double pTmax[2]; pTmax[0] = -1.; pTmax[1] = -1.;
382  for(int j = 0; j < N; j++){
383  const RestFrame& frame = VIS.GetFrame(jetID[j]);
384  if(VS[i]->IsSame(frame) || VC[i]->IsSame(frame)){
385  double pT = VIS.GetLabFrameFourVector(jetID[j]).Pt();
386  if(pT > pTmax[0]){
387  pTmax[1] = pTmax[0];
388  pTmax[0] = pT;
389  } else {
390  if(pT > pTmax[1]) pTmax[1] = pT;
391  }
392  }
393  }
394 
395  jet1PT[i] = pTmax[0];
396  jet2PT[i] = pTmax[1];
397 
398  if(NV[i] > 1){
399  cosC[i] = C[i]->GetCosDecayAngle();
400  dphiGC[i] = G[i]->GetDeltaPhiDecayPlanes(*C[i]);
401  RCG[i] = (C[i]->GetMass()-X[i]->GetMass())/(G[i]->GetMass()-X[i]->GetMass());
402  } else {
403  cosC[i] = -2.;
404  dphiGC[i] = -1.;
405  RCG[i] = -1.;
406  jet2PT[i] = -1.;
407  }
408  }
409 
410  //
411  // background tree observables
412  //
413  TLorentzVector Psib = I_B.GetSiblingFrame().GetFourVector(LAB_B);
414  TLorentzVector Pmet = I_B.GetFourVector(LAB_B);
415 
416  //***
417  double Rpsib = std::max(0.,Psib.Vect().Dot(Pmet.Vect().Unit()));
418  Rpsib = Rpsib / (Pmet.Pt() + Rpsib);
419 
420  TVector3 boostQCD = (Pmet+Psib).BoostVector();
421  Psib.Boost(-boostQCD);
422  double cosQCD = -1.*Psib.Vect().Unit().Dot(boostQCD.Unit());
423  cosQCD = (1.-cosQCD)/2.;
424 
425  //***
426  double DeltaQCD = (cosQCD-Rpsib)/(cosQCD+Rpsib);
427 
428  }
429 
430  TFile fout(output_name.c_str(),"RECREATE");
431  fout.Close();
432  tree_plot->WriteOutput(output_name);
433 }
434 
435 # ifndef __CINT__ // main function for stand-alone compilation
436 int main(){
437  example_DiGluino_to_bbXbbX();
438  return 0;
439 }
440 #endif
RestFrames::RestFrame::GetMomentum
double GetMomentum(const RestFrame &frame) const
Returns magnitude of momentum.
Definition: RestFrame.cc:552
RestFrames::TreePlot::AddJigsaw
void AddJigsaw(const Jigsaw &jigsaw)
Adds a jigsaw to a frame tree and shows how jigsaw could affect the tree.
Definition: TreePlot.cc:170
RestFrames::RestFrame::GetVisibleFourVector
TLorentzVector GetVisibleFourVector(const RestFrame &frame=RestFrame::Empty()) const
Returns four-vector of visible descendants.
Definition: RestFrame.cc:490
RestFrames::TreePlot::Draw
void Draw(const std::string &name="", const std::string &title="", bool invert_colors=false, bool invert_node_colors=false)
Draws tree.
Definition: TreePlot.cc:127
RestFrames::InvisibleGenFrame
Definition: InvisibleGenFrame.hh:41
RestFrames::RestFrame
abstract base class for all Frame objects
Definition: RestFrame.hh:45
RestFrames::ppLabGenFrame
Definition: ppLabGenFrame.hh:40
RestFrames::DecayGenFrame
Definition: DecayGenFrame.hh:43
RestFrames::RestFrame::GetCosDecayAngle
double GetCosDecayAngle(const RestFrame &frame=RestFrame::Empty()) const
Returns the cosine of this frame's decay angle.
Definition: RestFrame.cc:912
RestFrames::RFPlot::WriteOutput
void WriteOutput(const std::string &filename)
Stores all plots in root file.
Definition: RFPlot.cc:59
RestFrames.hh
RestFrames::ContraBoostInvJigsaw
Definition: ContraBoostInvJigsaw.hh:37
RestFrames::VisibleRecoFrame
Definition: VisibleRecoFrame.hh:41
RestFrames::SetRapidityInvJigsaw
Definition: SetRapidityInvJigsaw.hh:37
RestFrames::LabRecoFrame
Definition: LabRecoFrame.hh:44
RestFrames::MinMassesCombJigsaw
Definition: MinMassesCombJigsaw.hh:40
RestFrames::VisibleGenFrame
Definition: VisibleGenFrame.hh:41
RestFrames::InvisibleRecoFrame
Definition: InvisibleRecoFrame.hh:41
RestFrames::RestFrame::GetMass
virtual double GetMass() const
Returns the mass of this frame.
Definition: RestFrame.cc:443
RestFrames::TreePlot::SetTree
void SetTree(const RestFrame &frame)
Sets a tree that shows how a frame is connected to its children.
Definition: TreePlot.cc:160
RestFrames::TreePlot
Definition: TreePlot.hh:50
RestFrames::SetMassInvJigsaw
Definition: SetMassInvJigsaw.hh:37
RestFrames::CombinatoricGroup
Definition: CombinatoricGroup.hh:39
RestFrames::RFKey
Definition: RFKey.hh:38
RestFrames::SelfAssemblingRecoFrame
Definition: SelfAssemblingRecoFrame.hh:43
RestFrames::RestFrame::GetDeltaPhiDecayPlanes
double GetDeltaPhiDecayPlanes(const RestFrame &frame) const
Returns difference of azimuthal angle between decay planes.
Definition: RestFrame.cc:977
RestFrames::DecayRecoFrame
Definition: DecayRecoFrame.hh:43
RestFrames::InvisibleGroup
Definition: InvisibleGroup.hh:40
Generated on Thu Dec 17 2020 14:04:43 for RestFrames by   doxygen 1.8.17