gambit is hosted by Hepforge, IPPP Durham
GAMBIT  v1.5.0-2191-ga4742ac
a Global And Modular Bsm Inference Tool

#include <mt2w_bisect.h>

Public Member Functions

 mt2w (double upper_bound=500.0, double error_value=499.0, double scan_step=0.5)
 
void set_momenta (double *pl0, double *pb10, double *pb20, double *pmiss0)
 
void set_momenta (double El, double plx, double ply, double plz, double Eb1, double pb1x, double pb1y, double pb1z, double Eb2, double pb2x, double pb2y, double pb2z, double pmissx, double pmissy)
 
double get_mt2w ()
 
void print ()
 

Protected Member Functions

void mt2w_bisect ()
 

Private Member Functions

int teco (double mtop)
 
int signchange_n (long double t1, long double t2, long double t3, long double t4, long double t5)
 
int signchange_p (long double t1, long double t2, long double t3, long double t4, long double t5)
 

Private Attributes

bool solved
 
bool momenta_set
 
double upper_bound
 
double error_value
 
double scan_step
 
double mt2w_b
 
double plx
 
double ply
 
double plz
 
double ml
 
double El
 
double pb1x
 
double pb1y
 
double pb1z
 
double mb1
 
double Eb1
 
double pb2x
 
double pb2y
 
double pb2z
 
double mb2
 
double Eb2
 
double pmissx
 
double pmissy
 
double mv
 
double mw
 
double mlsq
 
double Elsq
 
double mb1sq
 
double Eb1sq
 
double mb2sq
 
double Eb2sq
 
double a1
 
double b1
 
double c1
 
double a2
 
double b2
 
double c2
 
double d1
 
double e1
 
double f1
 
double d2
 
double e2
 
double f2
 
double d2o
 
double e2o
 
double f2o
 
double precision
 

Detailed Description

Definition at line 28 of file mt2w_bisect.h.

Constructor & Destructor Documentation

◆ mt2w()

mt2w_bisect::mt2w::mt2w ( double  upper_bound = 500.0,
double  error_value = 499.0,
double  scan_step = 0.5 
)

Definition at line 44 of file mt2w_bisect.cpp.

45 {
46  solved = false;
47  momenta_set = false;
48  mt2w_b = 0.; // The result field. Start it off at zero.
49  this->upper_bound = upper_bound; // the upper bound of search for MT2W, default value is 500 GeV
50  this->error_value = error_value; // if we couldn't find any compatible region below the upper_bound, output mt2w = error_value;
51  this->scan_step = scan_step; // if we need to scan to find the compatible region, this is the step of the scan
52 }

Member Function Documentation

◆ get_mt2w()

double mt2w_bisect::mt2w::get_mt2w ( )

Definition at line 54 of file mt2w_bisect.cpp.

Referenced by mt2wWrapperHepUtils().

55 {
56  if (!momenta_set)
57  {
58  cout <<" Please set momenta first!" << endl;
59  return error_value;
60  }
61 
62  if (!solved) mt2w_bisect();
63  return mt2w_b;
64 }
Here is the caller graph for this function:

◆ mt2w_bisect()

void mt2w_bisect::mt2w::mt2w_bisect ( )
protected

Definition at line 151 of file mt2w_bisect.cpp.

References mw.

152 {
153 
154 
155  solved = true;
156  cout.precision(11);
157 
158  // In normal running, mtop_high WILL be compatible, and mtop_low will NOT.
159  double mtop_high = upper_bound; //set the upper bound of the search region
160  double mtop_low; //the lower bound of the search region is best chosen as m_W + m_b
161 
162  if (mb1 >= mb2) {mtop_low = mw + mb1;}
163  else {mtop_low = mw + mb2;}
164 
165  // The following if and while deal with the case where there might be a compatable region
166  // between mtop_low and 500 GeV, but it doesn't extend all the way up to 500.
167  //
168 
169  // If our starting high guess is not compatible, start the high guess from the low guess...
170  if (teco(mtop_high)==0) {mtop_high = mtop_low;}
171 
172  // .. and scan up until a compatible high bound is found.
173  //We can also raise the lower bound since we scaned over a region that is not compatible
174  while (teco(mtop_high)==0 && mtop_high < upper_bound + 2.*scan_step) {
175 
176  mtop_low=mtop_high;
177  mtop_high = mtop_high + scan_step;
178  }
179 
180  // if we can not find a compatible region under the upper bound, output the error value
181  if (mtop_high > upper_bound) {
183  return;
184  }
185 
186  // Once we have an compatible mtop_high, we can find mt2w using bisection method
187  while(mtop_high - mtop_low > precision)
188  {
189  double mtop_mid,teco_mid;
190  //bisect
191  mtop_mid = (mtop_high+mtop_low)/2.;
192  teco_mid = teco(mtop_mid);
193 
194  if(teco_mid == 0) {mtop_low = mtop_mid;}
195  else {mtop_high = mtop_mid;}
196 
197  }
198  mt2w_b = mtop_high; //output the value of mt2w
199  return;
200 }
int teco(double mtop)

◆ print()

void mt2w_bisect::mt2w::print ( )

◆ set_momenta() [1/2]

void mt2w_bisect::mt2w::set_momenta ( double pl0,
double pb10,
double pb20,
double pmiss0 
)

Definition at line 67 of file mt2w_bisect.cpp.

Referenced by mt2wWrapperHepUtils().

68 {
69  // Pass in pointers to 4-vectors {E, px, py, px} of doubles.
70  // and pmiss must have [1] and [2] components for x and y. The [0] component is ignored.
71  set_momenta(pl[0], pl[1], pl[2], pl[3],
72  pb1[0], pb1[1], pb1[2], pb1[3],
73  pb2[0], pb2[1], pb2[2], pb2[3],
74  pmiss[1], pmiss[2]);
75 }
void set_momenta(double *pl0, double *pb10, double *pb20, double *pmiss0)
Definition: mt2w_bisect.cpp:67
Here is the caller graph for this function:

◆ set_momenta() [2/2]

void mt2w_bisect::mt2w::set_momenta ( double  El,
double  plx,
double  ply,
double  plz,
double  Eb1,
double  pb1x,
double  pb1y,
double  pb1z,
double  Eb2,
double  pb2x,
double  pb2y,
double  pb2z,
double  pmissx,
double  pmissy 
)

Definition at line 79 of file mt2w_bisect.cpp.

References ABSOLUTE_PRECISION, mw, and RELATIVE_PRECISION.

83 {
84  solved = false; //reset solved tag when momenta are changed.
85  momenta_set = true;
86 
87  double msqtemp; //used for saving the mass squared temporarily
88 
89 //l is the visible lepton
90 
91  this->El = El;
92  this->plx = plx;
93  this->ply = ply;
94  this->plz = plz;
95 
96  Elsq = El*El;
97 
98  msqtemp = El*El-plx*plx-ply*ply-plz*plz;
99  if (msqtemp > 0.0) {mlsq = msqtemp;}
100  else {mlsq = 0.0;} //mass squared can not be negative
101  ml = sqrt(mlsq); // all the input masses are calculated from sqrt(p^2)
102 
103 //b1 is the bottom on the same side as the visible lepton
104 
105  this->Eb1 = Eb1;
106  this->pb1x = pb1x;
107  this->pb1y = pb1y;
108  this->pb1z = pb1z;
109 
110  Eb1sq = Eb1*Eb1;
111 
112  msqtemp = Eb1*Eb1-pb1x*pb1x-pb1y*pb1y-pb1z*pb1z;
113  if (msqtemp > 0.0) {mb1sq = msqtemp;}
114  else {mb1sq = 0.0;} //mass squared can not be negative
115  mb1 = sqrt(mb1sq); // all the input masses are calculated from sqrt(p^2)
116 
117 //b2 is the other bottom (paired with the invisible W)
118 
119  this->Eb2 = Eb2;
120  this->pb2x = pb2x;
121  this->pb2y = pb2y;
122  this->pb2z = pb2z;
123 
124  Eb2sq = Eb2*Eb2;
125 
126  msqtemp = Eb2*Eb2-pb2x*pb2x-pb2y*pb2y-pb2z*pb2z;
127  if (msqtemp > 0.0) {mb2sq = msqtemp;}
128  else {mb2sq = 0.0;} //mass squared can not be negative
129  mb2 = sqrt(mb2sq); // all the input masses are calculated from sqrt(p^2)
130 
131 
132 //missing pt
133 
134 
135  this->pmissx = pmissx;
136  this->pmissy = pmissy;
137 
138 //set the values of masses
139 
140  mv = 0.0; //mass of neutrino
141  mw = 80.4; //mass of W-boson
142 
143 
144 //precision?
145 
147  else precision = 100.*RELATIVE_PRECISION;
148 }
#define RELATIVE_PRECISION
Definition: mt2_bisect.h:7
#define ABSOLUTE_PRECISION
Definition: mt2_bisect.h:8

◆ signchange_n()

int mt2w_bisect::mt2w::signchange_n ( long double  t1,
long double  t2,
long double  t3,
long double  t4,
long double  t5 
)
inlineprivate

Definition at line 354 of file mt2w_bisect.cpp.

355 {
356  int nsc;
357  nsc=0;
358  if(t1*t2>0) nsc++;
359  if(t2*t3>0) nsc++;
360  if(t3*t4>0) nsc++;
361  if(t4*t5>0) nsc++;
362  return nsc;
363 }

◆ signchange_p()

int mt2w_bisect::mt2w::signchange_p ( long double  t1,
long double  t2,
long double  t3,
long double  t4,
long double  t5 
)
inlineprivate

Definition at line 364 of file mt2w_bisect.cpp.

365 {
366  int nsc;
367  nsc=0;
368  if(t1*t2<0) nsc++;
369  if(t2*t3<0) nsc++;
370  if(t3*t4<0) nsc++;
371  if(t4*t5<0) nsc++;
372  return nsc;
373 }

◆ teco()

int mt2w_bisect::mt2w::teco ( double  mtop)
private

Definition at line 205 of file mt2w_bisect.cpp.

References Gambit::FlavBit::LoopFunctions::B0(), Gambit::FlavBit::LoopFunctions::B1(), Gambit::FlavBit::LoopFunctions::C0(), Gambit::FlavBit::LoopFunctions::D0(), daFunk::delta(), and mw.

206 {
207 
208 //first test if mtop is larger than mb+mw
209 
210  if (mtop < mb1+mw || mtop < mb2+mw) {return 0;}
211 
212 //define delta for convenience, note the definition is different from the one in mathematica code by 2*E^2_{b2}
213 
214  double ETb2sq = Eb2sq - pb2z*pb2z; //transverse energy of b2
215  double delta = (mtop*mtop-mw*mw-mb2sq)/(2.*ETb2sq);
216 
217 
218 //del1 and del2 are \Delta'_1 and \Delta'_2 in the notes eq. 10,11
219 
220  double del1 = mw*mw - mv*mv - mlsq;
221  double del2 = mtop*mtop - mw*mw - mb1sq - 2*(El*Eb1-plx*pb1x-ply*pb1y-plz*pb1z);
222 
223 // aa bb cc are A B C in the notes eq.15
224 
225  double aa = (El*pb1x-Eb1*plx)/(Eb1*plz-El*pb1z);
226  double bb = (El*pb1y-Eb1*ply)/(Eb1*plz-El*pb1z);
227  double cc = (El*del2-Eb1*del1)/(2.*Eb1*plz-2.*El*pb1z);
228 
229 
230 //calculate coefficients for the two quadratic equations (ellipses), which are
231 //
232 // a1 x^2 + 2 b1 x y + c1 y^2 + 2 d1 x + 2 e1 y + f1 = 0 , from the 2 steps decay chain (with visible lepton)
233 //
234 // a2 x^2 + 2 b2 x y + c2 y^2 + 2 d2 x + 2 e2 y + f2 <= 0 , from the 1 stop decay chain (with W missing)
235 //
236 // where x and y are px and py of the neutrino on the visible lepton chain
237 
238  a1 = Eb1sq*(1.+aa*aa)-(pb1x+pb1z*aa)*(pb1x+pb1z*aa);
239  b1 = Eb1sq*aa*bb - (pb1x+pb1z*aa)*(pb1y+pb1z*bb);
240  c1 = Eb1sq*(1.+bb*bb)-(pb1y+pb1z*bb)*(pb1y+pb1z*bb);
241  d1 = Eb1sq*aa*cc - (pb1x+pb1z*aa)*(pb1z*cc+del2/2.0);
242  e1 = Eb1sq*bb*cc - (pb1y+pb1z*bb)*(pb1z*cc+del2/2.0);
243  f1 = Eb1sq*(mv*mv+cc*cc) - (pb1z*cc+del2/2.0)*(pb1z*cc+del2/2.0);
244 
245 // First check if ellipse 1 is real (don't need to do this for ellipse 2, ellipse 2 is always real for mtop > mw+mb)
246 
247  double det1 = (a1*(c1*f1 - e1*e1) - b1*(b1*f1 - d1*e1) + d1*(b1*e1-c1*d1))/(a1+c1);
248 
249  if (det1 > 0.0) {return 0;}
250 
251 //coefficients of the ellptical region
252 
253  a2 = 1-pb2x*pb2x/(ETb2sq);
254  b2 = -pb2x*pb2y/(ETb2sq);
255  c2 = 1-pb2y*pb2y/(ETb2sq);
256 
257  // d2o e2o f2o are coefficients in the p2x p2y plane (p2 is the momentum of the missing W-boson)
258  // it is convenient to calculate them first and transfer the ellipse to the p1x p1y plane
259  d2o = -delta*pb2x;
260  e2o = -delta*pb2y;
261  f2o = mw*mw - delta*delta*ETb2sq;
262 
263  d2 = -d2o -a2*pmissx -b2*pmissy;
264  e2 = -e2o -c2*pmissy -b2*pmissx;
265  f2 = a2*pmissx*pmissx + 2*b2*pmissx*pmissy + c2*pmissy*pmissy + 2*d2o*pmissx + 2*e2o*pmissy + f2o;
266 
267 //find a point in ellipse 1 and see if it's within the ellipse 2, define h0 for convenience
268  double x0, h0, y0, r0;
269  x0 = (c1*d1-b1*e1)/(b1*b1-a1*c1);
270  h0 = (b1*x0 + e1)*(b1*x0 + e1) - c1*(a1*x0*x0 + 2*d1*x0 + f1);
271  if (h0 < 0.0) {return 0;} // if h0 < 0, y0 is not real and ellipse 1 is not real, this is a redundant check.
272  y0 = (-b1*x0 -e1 + sqrt(h0))/c1;
273  r0 = a2*x0*x0 + 2*b2*x0*y0 + c2*y0*y0 + 2*d2*x0 + 2*e2*y0 + f2;
274  if (r0 < 0.0) {return 1;} // if the point is within the 2nd ellipse, mtop is compatible
275 
276 
277 //obtain the coefficients for the 4th order equation
278 //devided by Eb1^n to make the variable dimensionless
279  long double A4, A3, A2, A1, A0;
280 
281  A4 =
282  -4*a2*b1*b2*c1 + 4*a1*b2*b2*c1 +a2*a2*c1*c1 +
283  4*a2*b1*b1*c2 - 4*a1*b1*b2*c2 - 2*a1*a2*c1*c2 +
284  a1*a1*c2*c2;
285 
286  A3 =
287  (-4*a2*b2*c1*d1 + 8*a2*b1*c2*d1 - 4*a1*b2*c2*d1 - 4*a2*b1*c1*d2 +
288  8*a1*b2*c1*d2 - 4*a1*b1*c2*d2 - 8*a2*b1*b2*e1 + 8*a1*b2*b2*e1 +
289  4*a2*a2*c1*e1 - 4*a1*a2*c2*e1 + 8*a2*b1*b1*e2 - 8*a1*b1*b2*e2 -
290  4*a1*a2*c1*e2 + 4*a1*a1*c2*e2)/Eb1;
291 
292 
293  A2 =
294  (4*a2*c2*d1*d1 - 4*a2*c1*d1*d2 - 4*a1*c2*d1*d2 + 4*a1*c1*d2*d2 -
295  8*a2*b2*d1*e1 - 8*a2*b1*d2*e1 + 16*a1*b2*d2*e1 +
296  4*a2*a2*e1*e1 + 16*a2*b1*d1*e2 - 8*a1*b2*d1*e2 -
297  8*a1*b1*d2*e2 - 8*a1*a2*e1*e2 + 4*a1*a1*e2*e2 - 4*a2*b1*b2*f1 +
298  4*a1*b2*b2*f1 + 2*a2*a2*c1*f1 - 2*a1*a2*c2*f1 +
299  4*a2*b1*b1*f2 - 4*a1*b1*b2*f2 - 2*a1*a2*c1*f2 + 2*a1*a1*c2*f2)/Eb1sq;
300 
301  A1 =
302  (-8*a2*d1*d2*e1 + 8*a1*d2*d2*e1 + 8*a2*d1*d1*e2 - 8*a1*d1*d2*e2 -
303  4*a2*b2*d1*f1 - 4*a2*b1*d2*f1 + 8*a1*b2*d2*f1 + 4*a2*a2*e1*f1 -
304  4*a1*a2*e2*f1 + 8*a2*b1*d1*f2 - 4*a1*b2*d1*f2 - 4*a1*b1*d2*f2 -
305  4*a1*a2*e1*f2 + 4*a1*a1*e2*f2)/(Eb1sq*Eb1);
306 
307  A0 =
308  (-4*a2*d1*d2*f1 + 4*a1*d2*d2*f1 + a2*a2*f1*f1 +
309  4*a2*d1*d1*f2 - 4*a1*d1*d2*f2 - 2*a1*a2*f1*f2 +
310  a1*a1*f2*f2)/(Eb1sq*Eb1sq);
311 
312  long double B3, B2, B1, B0;
313  B3 = 4*A4;
314  B2 = 3*A3;
315  B1 = 2*A2;
316  B0 = A1;
317 
318  long double C2, C1, C0;
319  C2 = -(A2/2 - 3*A3*A3/(16*A4));
320  C1 = -(3*A1/4. -A2*A3/(8*A4));
321  C0 = -A0 + A1*A3/(16*A4);
322 
323  long double D1, D0;
324  D1 = -B1 - (B3*C1*C1/C2 - B3*C0 -B2*C1)/C2;
325  D0 = -B0 - B3 *C0 *C1/(C2*C2)+ B2*C0/C2;
326 
327  long double E0;
328  E0 = -C0 - C2*D0*D0/(D1*D1) + C1*D0/D1;
329 
330  long double t1,t2,t3,t4,t5;
331 //find the coefficients for the leading term in the Sturm sequence
332  t1 = A4;
333  t2 = A4;
334  t3 = C2;
335  t4 = D1;
336  t5 = E0;
337 
338 
339 //The number of solutions depends on diffence of number of sign changes for x->Inf and x->-Inf
340  int nsol;
341  nsol = signchange_n(t1,t2,t3,t4,t5) - signchange_p(t1,t2,t3,t4,t5);
342 
343 //Cannot have negative number of solutions, must be roundoff effect
344  if (nsol < 0) nsol = 0;
345 
346  int out;
347  if (nsol == 0) {out = 0;} //output 0 if there is no solution, 1 if there is solution
348  else {out = 1;}
349 
350  return out;
351 
352 }
int signchange_n(long double t1, long double t2, long double t3, long double t4, long double t5)
Funk delta(std::string arg, double pos, double width)
Definition: daFunk.hpp:902
double D0(const double a, const double b, const double c, const double d)
double C0(const double a, const double b, const double c)
int signchange_p(long double t1, long double t2, long double t3, long double t4, long double t5)
double B0(const double a, const double b, const double Q)
double B1(const double a, const double b, const double Q)
Here is the call graph for this function:

Member Data Documentation

◆ a1

double mt2w_bisect::mt2w::a1
private

Definition at line 80 of file mt2w_bisect.h.

◆ a2

double mt2w_bisect::mt2w::a2
private

Definition at line 80 of file mt2w_bisect.h.

◆ b1

double mt2w_bisect::mt2w::b1
private

Definition at line 80 of file mt2w_bisect.h.

◆ b2

double mt2w_bisect::mt2w::b2
private

Definition at line 80 of file mt2w_bisect.h.

◆ c1

double mt2w_bisect::mt2w::c1
private

Definition at line 80 of file mt2w_bisect.h.

◆ c2

double mt2w_bisect::mt2w::c2
private

Definition at line 80 of file mt2w_bisect.h.

◆ d1

double mt2w_bisect::mt2w::d1
private

Definition at line 80 of file mt2w_bisect.h.

◆ d2

double mt2w_bisect::mt2w::d2
private

Definition at line 80 of file mt2w_bisect.h.

◆ d2o

double mt2w_bisect::mt2w::d2o
private

Definition at line 81 of file mt2w_bisect.h.

◆ e1

double mt2w_bisect::mt2w::e1
private

Definition at line 80 of file mt2w_bisect.h.

◆ e2

double mt2w_bisect::mt2w::e2
private

Definition at line 80 of file mt2w_bisect.h.

◆ e2o

double mt2w_bisect::mt2w::e2o
private

Definition at line 81 of file mt2w_bisect.h.

◆ Eb1

double mt2w_bisect::mt2w::Eb1
private

Definition at line 69 of file mt2w_bisect.h.

◆ Eb1sq

double mt2w_bisect::mt2w::Eb1sq
private

Definition at line 76 of file mt2w_bisect.h.

◆ Eb2

double mt2w_bisect::mt2w::Eb2
private

Definition at line 70 of file mt2w_bisect.h.

◆ Eb2sq

double mt2w_bisect::mt2w::Eb2sq
private

Definition at line 77 of file mt2w_bisect.h.

◆ El

double mt2w_bisect::mt2w::El
private

Definition at line 68 of file mt2w_bisect.h.

◆ Elsq

double mt2w_bisect::mt2w::Elsq
private

Definition at line 75 of file mt2w_bisect.h.

◆ error_value

double mt2w_bisect::mt2w::error_value
private

Definition at line 59 of file mt2w_bisect.h.

◆ f1

double mt2w_bisect::mt2w::f1
private

Definition at line 80 of file mt2w_bisect.h.

◆ f2

double mt2w_bisect::mt2w::f2
private

Definition at line 80 of file mt2w_bisect.h.

◆ f2o

double mt2w_bisect::mt2w::f2o
private

Definition at line 81 of file mt2w_bisect.h.

◆ mb1

double mt2w_bisect::mt2w::mb1
private

Definition at line 69 of file mt2w_bisect.h.

◆ mb1sq

double mt2w_bisect::mt2w::mb1sq
private

Definition at line 76 of file mt2w_bisect.h.

◆ mb2

double mt2w_bisect::mt2w::mb2
private

Definition at line 70 of file mt2w_bisect.h.

◆ mb2sq

double mt2w_bisect::mt2w::mb2sq
private

Definition at line 77 of file mt2w_bisect.h.

◆ ml

double mt2w_bisect::mt2w::ml
private

Definition at line 68 of file mt2w_bisect.h.

◆ mlsq

double mt2w_bisect::mt2w::mlsq
private

Definition at line 75 of file mt2w_bisect.h.

◆ momenta_set

bool mt2w_bisect::mt2w::momenta_set
private

Definition at line 57 of file mt2w_bisect.h.

◆ mt2w_b

double mt2w_bisect::mt2w::mt2w_b
private

Definition at line 61 of file mt2w_bisect.h.

◆ mv

double mt2w_bisect::mt2w::mv
private

Definition at line 72 of file mt2w_bisect.h.

◆ mw

double mt2w_bisect::mt2w::mw
private

Definition at line 72 of file mt2w_bisect.h.

◆ pb1x

double mt2w_bisect::mt2w::pb1x
private

Definition at line 69 of file mt2w_bisect.h.

◆ pb1y

double mt2w_bisect::mt2w::pb1y
private

Definition at line 69 of file mt2w_bisect.h.

◆ pb1z

double mt2w_bisect::mt2w::pb1z
private

Definition at line 69 of file mt2w_bisect.h.

◆ pb2x

double mt2w_bisect::mt2w::pb2x
private

Definition at line 70 of file mt2w_bisect.h.

◆ pb2y

double mt2w_bisect::mt2w::pb2y
private

Definition at line 70 of file mt2w_bisect.h.

◆ pb2z

double mt2w_bisect::mt2w::pb2z
private

Definition at line 70 of file mt2w_bisect.h.

◆ plx

double mt2w_bisect::mt2w::plx
private

Definition at line 68 of file mt2w_bisect.h.

◆ ply

double mt2w_bisect::mt2w::ply
private

Definition at line 68 of file mt2w_bisect.h.

◆ plz

double mt2w_bisect::mt2w::plz
private

Definition at line 68 of file mt2w_bisect.h.

◆ pmissx

double mt2w_bisect::mt2w::pmissx
private

Definition at line 71 of file mt2w_bisect.h.

◆ pmissy

double mt2w_bisect::mt2w::pmissy
private

Definition at line 71 of file mt2w_bisect.h.

◆ precision

double mt2w_bisect::mt2w::precision
private

Definition at line 83 of file mt2w_bisect.h.

◆ scan_step

double mt2w_bisect::mt2w::scan_step
private

Definition at line 60 of file mt2w_bisect.h.

◆ solved

bool mt2w_bisect::mt2w::solved
private

Definition at line 56 of file mt2w_bisect.h.

◆ upper_bound

double mt2w_bisect::mt2w::upper_bound
private

Definition at line 58 of file mt2w_bisect.h.


The documentation for this class was generated from the following files: