MaCh3 2.2.1
Reference Guide
Loading...
Searching...
No Matches
Public Member Functions | Protected Attributes | List of all members
TSpline3_red Class Reference

CW: Reduced TSpline3 class. More...

#include <Splines/SplineStructs.h>

Inheritance diagram for TSpline3_red:
[legend]
Collaboration diagram for TSpline3_red:
[legend]

Public Member Functions

 TSpline3_red ()
 Empty constructor.
 
 TSpline3_red (TSpline3 *&spline, SplineInterpolation InterPolation=kTSpline3)
 The constructor that takes a TSpline3 pointer and copies in to memory.
 
 TSpline3_red (M3::float_t *X, M3::float_t *Y, M3::int_t N, M3::float_t **P)
 constructor taking parameters
 
void SetFunc (TSpline3 *&spline, SplineInterpolation InterPolation=kTSpline3)
 Set the function.
 
virtual ~TSpline3_red ()
 Empty destructor.
 
int FindX (double x)
 Find the segment relevant to this variation in x See root/hist/hist/src/TSpline3FindX(double) or samplePDFND....::FindSplineSegment.
 
double Eval (double var) override
 CW: Evaluate the weight from a variation.
 
M3::int_t GetNp () override
 CW: Get the number of points.
 
void GetKnot (int i, M3::float_t &xtmp, M3::float_t &ytmp)
 
void GetCoeff (int segment, M3::float_t &x, M3::float_t &y, M3::float_t &b, M3::float_t &c, M3::float_t &d)
 CW: Get the coefficient of a given segment.
 
TSpline3 * ConstructTSpline3 ()
 CW: Make a TSpline3 from the reduced splines.
 
void Print () override
 Print detailed info.
 
- Public Member Functions inherited from TResponseFunction_red
 TResponseFunction_red ()
 Empty constructor.
 
virtual ~TResponseFunction_red ()
 Empty destructor.
 
virtual double Eval (const double var)=0
 Evaluate a variation.
 
virtual void Print ()=0
 KS: Printer.
 
virtual M3::int_t GetNp ()=0
 DL: Get number of points.
 

Protected Attributes

M3::int_t nPoints
 Number of points/knot in TSpline3.
 
M3::float_t ** Par
 Always uses a third order polynomial, so hard-code the number of coefficients in implementation.
 
M3::float_tXPos
 Positions of each x for each knot.
 
M3::float_tYResp
 y-value for each knot
 

Detailed Description

CW: Reduced TSpline3 class.

Definition at line 267 of file SplineStructs.h.

Constructor & Destructor Documentation

◆ TSpline3_red() [1/3]

TSpline3_red::TSpline3_red ( )
inline

Empty constructor.

Definition at line 271 of file SplineStructs.h.

272 nPoints = 0;
273 Par = NULL;
274 XPos = NULL;
275 YResp = NULL;
276 }
TResponseFunction_red()
Empty constructor.
M3::float_t ** Par
Always uses a third order polynomial, so hard-code the number of coefficients in implementation.
M3::int_t nPoints
Number of points/knot in TSpline3.
M3::float_t * XPos
Positions of each x for each knot.
M3::float_t * YResp
y-value for each knot

◆ TSpline3_red() [2/3]

TSpline3_red::TSpline3_red ( TSpline3 *&  spline,
SplineInterpolation  InterPolation = kTSpline3 
)
inline

The constructor that takes a TSpline3 pointer and copies in to memory.

Definition at line 279 of file SplineStructs.h.

280 Par = NULL;
281 XPos = NULL;
282 YResp = NULL;
283 SetFunc(spline, InterPolation);
284 }
void SetFunc(TSpline3 *&spline, SplineInterpolation InterPolation=kTSpline3)
Set the function.

◆ TSpline3_red() [3/3]

TSpline3_red::TSpline3_red ( M3::float_t X,
M3::float_t Y,
M3::int_t  N,
M3::float_t **  P 
)
inline

constructor taking parameters

Definition at line 287 of file SplineStructs.h.

288 nPoints = N;
289 // Save the parameters for each knot
290 Par = new M3::float_t*[nPoints];
291 // Save the positions of the knots
292 XPos = new M3::float_t[nPoints];
293 // Save the y response at each knot
295 for(int j = 0; j < N; ++j){
296 Par[j] = new M3::float_t[3];
297 Par[j][0] = P[j][0];
298 Par[j][1] = P[j][1];
299 Par[j][2] = P[j][2];
300 XPos[j] = X[j];
301 YResp[j] = Y[j];
302
303 if((Par[j][0] == -999) | (Par[j][1] ==-999) | (Par[j][2] ==-999) | (XPos[j] ==-999) | (YResp[j] ==-999)){
304 MACH3LOG_ERROR("******************* Bad parameter values when constructing TSpline3_red *********************");
305 MACH3LOG_ERROR("Passed values (i, x, y, b, c, d): {}, {}, {}, {}, {}, {}", j, X[j], Y[j], P[j][0], P[j][1], P[j][2]);
306 MACH3LOG_ERROR("Set values (i, x, y, b, c, d): {}, {}, {}, {}, {}, {}", j, XPos[j], YResp[j], Par[j][0], Par[j][1], Par[j][2]);
307 MACH3LOG_ERROR("*********************************************************************************************");
308 }
309 }
310 }
#define MACH3LOG_ERROR
Definition: MaCh3Logger.h:25
double float_t
Definition: Core.h:28

◆ ~TSpline3_red()

virtual TSpline3_red::~TSpline3_red ( )
inlinevirtual

Empty destructor.

Definition at line 580 of file SplineStructs.h.

580 {
581 if(Par != NULL) {
582 for (int i = 0; i < nPoints; ++i) {
583 if (Par[i] != NULL) {
584 delete[] Par[i];
585 }
586 }
587 delete[] Par;
588 }
589 if(XPos != NULL) delete[] XPos;
590 if(YResp != NULL) delete[] YResp;
591 Par = NULL;
592 XPos = YResp = NULL;
593 }

Member Function Documentation

◆ ConstructTSpline3()

TSpline3 * TSpline3_red::ConstructTSpline3 ( )
inline

CW: Make a TSpline3 from the reduced splines.

Definition at line 661 of file SplineStructs.h.

661 {
662 // KS: Sadly ROOT only accepts double...
663 #ifdef _LOW_MEMORY_STRUCTS_
664 std::vector<Double_t> xPosDoubles(nPoints);
665 std::vector<Double_t> yPosDoubles(nPoints);
666 for (Int_t i = 0; i < nPoints; ++i) {
667 xPosDoubles[i] = static_cast<Double_t>(XPos[i]); // Convert float to double
668 yPosDoubles[i] = static_cast<Double_t>(YResp[i]); // Convert float to double
669 }
670 TSpline3 *spline = new TSpline3("Spline", xPosDoubles.data(), yPosDoubles.data(), static_cast<int>(nPoints));
671 #else
672 TSpline3 *spline = new TSpline3("Spline", XPos, YResp, nPoints);
673 #endif
674 return spline;
675 }

◆ Eval()

double TSpline3_red::Eval ( double  var)
inlineoverridevirtual

CW: Evaluate the weight from a variation.

Implements TResponseFunction_red.

Definition at line 631 of file SplineStructs.h.

631 {
632 // Get the segment for this variation
633 int segment = FindX(var);
634 // The get the coefficients for this variation
635 M3::float_t x = M3::float_t(-999.99), y = M3::float_t(-999.99), b = M3::float_t(-999.99), c = M3::float_t(-999.99), d = M3::float_t(-999.99);
636 GetCoeff(segment, x, y, b, c, d);
637 double dx = var - x;
638 // Evaluate the third order polynomial
639 double weight = y+dx*(b+dx*(c+d*dx));
640 return weight;
641 }
int FindX(double x)
Find the segment relevant to this variation in x See root/hist/hist/src/TSpline3FindX(double) or samp...
void GetCoeff(int segment, M3::float_t &x, M3::float_t &y, M3::float_t &b, M3::float_t &c, M3::float_t &d)
CW: Get the coefficient of a given segment.

◆ FindX()

int TSpline3_red::FindX ( double  x)
inline

Find the segment relevant to this variation in x See root/hist/hist/src/TSpline3FindX(double) or samplePDFND....::FindSplineSegment.

Definition at line 597 of file SplineStructs.h.

597 {
598 // The segment we're interested in (klow in ROOT code)
599 int segment = 0;
600 int kHigh = nPoints-1;
601 // If the variation is below the lowest saved spline point
602 if (x <= XPos[0]){
603 segment = 0;
604 // If the variation is above the highest saved spline point
605 } else if (x >= XPos[nPoints-1]) {
606 // Yes, the -2 is indeed correct, see TSpline.cxx:814 and //see: https://savannah.cern.ch/bugs/?71651
607 segment = kHigh;
608 // If the variation is between the maximum and minimum, perform a binary search
609 } else {
610 // The top point we've got
611 int kHalf = 0;
612 // While there is still a difference in the points (we haven't yet found the segment)
613 // This is a binary search, incrementing segment and decrementing kHalf until we've found the segment
614 while (kHigh - segment > 1) {
615 // Increment the half-step
616 kHalf = (segment + kHigh)/2;
617 // If our variation is above the kHalf, set the segment to kHalf
618 if (x > XPos[kHalf]) {
619 segment = kHalf;
620 // Else move kHigh down
621 } else {
622 kHigh = kHalf;
623 }
624 } // End the while: we've now done our binary search
625 } // End the else: we've now found our point
626 if (segment >= nPoints-1 && nPoints > 1) segment = nPoints-2;
627 return segment;
628 }

◆ GetCoeff()

void TSpline3_red::GetCoeff ( int  segment,
M3::float_t x,
M3::float_t y,
M3::float_t b,
M3::float_t c,
M3::float_t d 
)
inline

CW: Get the coefficient of a given segment.

Definition at line 652 of file SplineStructs.h.

652 {
653 b = Par[segment][0];
654 c = Par[segment][1];
655 d = Par[segment][2];
656 x = XPos[segment];
657 y = YResp[segment];
658 }

◆ GetKnot()

void TSpline3_red::GetKnot ( int  i,
M3::float_t xtmp,
M3::float_t ytmp 
)
inline

Definition at line 646 of file SplineStructs.h.

646 {
647 xtmp = XPos[i];
648 ytmp = YResp[i];
649 }

◆ GetNp()

M3::int_t TSpline3_red::GetNp ( )
inlineoverridevirtual

CW: Get the number of points.

Implements TResponseFunction_red.

Definition at line 644 of file SplineStructs.h.

644{ return nPoints; }

◆ Print()

void TSpline3_red::Print ( )
inlineoverridevirtual

Print detailed info.

Implements TResponseFunction_red.

Definition at line 678 of file SplineStructs.h.

678 {
679 MACH3LOG_INFO("Printing TSpline_red:");
680 MACH3LOG_INFO(" Nknots = {}", nPoints);
681 for (int i = 0; i < nPoints; ++i) {
682 MACH3LOG_INFO(" i = {} x = {} y = {} b = {} c = {} d = {}",
683 i, XPos[i], YResp[i], Par[i][0], Par[i][1], Par[i][2]);
684 }
685 }
#define MACH3LOG_INFO
Definition: MaCh3Logger.h:23

◆ SetFunc()

void TSpline3_red::SetFunc ( TSpline3 *&  spline,
SplineInterpolation  InterPolation = kTSpline3 
)
inline

Set the function.

Definition at line 312 of file SplineStructs.h.

312 {
313 nPoints = M3::int_t(spline->GetNp());
314 if (Par != NULL) {
315 for (int i = 0; i < nPoints; ++i) {
316 delete[] Par[i];
317 Par[i] = NULL;
318 }
319 delete[] Par;
320 Par = NULL;
321 }
322 if (XPos != NULL) delete[] XPos;
323 if (YResp != NULL) delete[] YResp;
324 // Save the parameters for each knot
325 Par = new M3::float_t*[nPoints];
326 // Save the positions of the knots
327 XPos = new M3::float_t[nPoints];
328 // Save the y response at each knot
330
331 //KS: Default TSpline3 ROOT implementation
332 if(InterPolation == kTSpline3)
333 {
334 for (int i = 0; i < nPoints; ++i) {
335 // 3 is the size of the TSpline3 coefficients
336 Par[i] = new M3::float_t[3];
337 double x = -999.99, y = -999.99, b = -999.99, c = -999.99, d = -999.99;
338 spline->GetCoeff(i, x, y, b, c, d);
339 XPos[i] = M3::float_t(x);
340 YResp[i] = M3::float_t(y);
341 Par[i][0] = M3::float_t(b);
342 Par[i][1] = M3::float_t(c);
343 Par[i][2] = M3::float_t(d);
344 }
345 }
346 //CW: Reduce to use linear spline interpolation for certain parameters
347 // Not the most elegant way: use TSpline3 object but set coefficients to zero and recalculate spline points; the smart way (but more human intensive) would be to save memory here and simply not store the zeros at all
348 // Get which parameters should be linear from the fit manager
349 // Convert the spline number to global xsec parameter
350 // Loop over the splines points
351 // KS: kLinearFunc should be used with TF1, this is just as safety
352 else if(InterPolation == kLinear || InterPolation == kLinearFunc)
353 {
354 for (int k = 0; k < nPoints; ++k) {
355 // 3 is the size of the TSpline3 coefficients
356 Par[k] = new M3::float_t[3];
357 Double_t x1, y1, b1, c1, d1, x2, y2, b2, c2, d2 = 0;
358 spline->GetCoeff(k, x1, y1, b1, c1, d1);
359 spline->GetCoeff(k+1, x2, y2, b2, c2, d2);
360 double tempb = (y2-y1)/(x2-x1);
361
362 XPos[k] = M3::float_t(x1);
363 YResp[k] = M3::float_t(y1);
364 Par[k][0] = M3::float_t(tempb);
365 Par[k][1] = M3::float_t(0);
366 Par[k][2] = M3::float_t(0);
367 }
368 }
369 //EM: Akima spline is similar to regular cubic spline but is allowed to be discontinuous in 2nd derivative and coefficients in any segment
370 // only depend on th 2 nearest points on either side
371 else if(InterPolation == kAkima)
372 {
373 // get the knot values for the spline
374 for (int i = 0; i < nPoints; ++i) {
375 // 3 is the size of the TSpline3 coefficients
376 Par[i] = new M3::float_t[3];
377
378 double x = -999.99, y = -999.99;
379 spline->GetKnot(i, x, y);
380
381 XPos[i] = M3::float_t(x);
382 YResp[i] = M3::float_t(y);
383 }
384
385 M3::float_t* mvals = new M3::float_t[nPoints + 3];
386 M3::float_t* svals = new M3::float_t[nPoints + 1];
387
388 for (int i = -2; i <= nPoints; ++i) {
389 // if segment is first or last or 2nd to first or last, needs to be dealt with slightly differently;
390 // need to estimate the values for additinal points which would lie outside of the spline
391 if(i ==-2){
392 mvals[i+2] = M3::float_t(3.0 * (YResp[1] - YResp[0]) / (XPos[1] - XPos[0]) - 2.0*(YResp[2] - YResp[1]) / (XPos[2] - XPos[1]));
393 }
394 else if(i==-1){
395 mvals[i+2] = M3::float_t(2.0 * (YResp[1] - YResp[0]) / (XPos[1] - XPos[0]) - (YResp[2] - YResp[1]) / (XPos[2] - XPos[1]));
396 }
397 else if(i==nPoints){
398 mvals[i+2] = M3::float_t(3.0 * (YResp[nPoints-1] - YResp[nPoints-2]) / (XPos[nPoints-1] - XPos[nPoints-2]) - 2.0*(YResp[nPoints-2] - YResp[nPoints-3]) / (XPos[nPoints-2] - XPos[nPoints-3]));
399 }
400 else if(i == nPoints - 1){
401 mvals[i+2] = M3::float_t(2.0 * (YResp[nPoints-1] - YResp[nPoints-2]) / (XPos[nPoints-1] - XPos[nPoints-2]) - (YResp[nPoints-2] - YResp[nPoints-3]) / (XPos[nPoints-2] - XPos[nPoints-3]));
402 }
403 //standard internal segment
404 else{
405 mvals[i+2] = (YResp[i+1] - YResp[i])/ (XPos[i+1] - XPos[i]);
406 }
407 }
408
409 for(int i =2; i<=nPoints+2; i++){
410 if (std::abs(mvals[i+1] - mvals[i]) + std::abs(mvals[i-1] - mvals[i-2]) != 0.0){
411 svals[i-2] = (std::abs(mvals[i+1] - mvals[i]) * mvals[i-1] + std::abs(mvals[i-1] - mvals[i-2]) *mvals[i]) / (std::abs(mvals[i+1] - mvals[i]) + std::abs(mvals[i-1] - mvals[i-2]));
412 }
413 else{svals[i-2] = mvals[i];}
414 }
415
416 // calculate the coefficients for the spline
417 for(int i = 0; i <nPoints; i++){
418 M3::float_t b, c, d = M3::float_t(-999.999);
419
420 b = svals[i];
421 c = M3::float_t(3.0* (YResp[i+1] - YResp[i]) / (XPos[i+1] - XPos[i]) -2.0 *svals[i] - svals[i +1]) /(XPos[i+1] - XPos[i]);
422 d = M3::float_t((svals[i + 1] +svals[i]) - 2.0*(YResp[i+1] - YResp[i]) / (XPos[i+1] - XPos[i])) / ((XPos[i+1] - XPos[i]) * (XPos[i+1] - XPos[i]));
423
424 Par[i][0] = b;
425 Par[i][1] = c;
426 Par[i][2] = d;
427 }
428
429 // check the input spline for linear segments, if there are any then overwrite the calculated coefficients
430 // this will pretty much only ever be the case if they are set to be linear in samplePDFND i.e. the user wants it to be linear
431 for(int i = 0; i <nPoints-1; i++){
432 double x = -999.99, y = -999.99, b = -999.99, c = -999.99, d = -999.99;
433 spline->GetCoeff(i, x, y, b, c, d);
434
435 if((c == 0.0 && d == 0.0)){
436 Par[i][0] = M3::float_t(b);
437 Par[i][1] = M3::float_t(0.0);
438 Par[i][2] = M3::float_t(0.0);
439 }
440 }
441 delete[] mvals;
442 delete[] svals;
443 }
444 //EM: Monotone spline is similar to regular cubic spline but enforce the condition that the interpolated value at any point
445 // must be between its two nearest knots, DOES NOT make the entire spline monotonic, only the segments
446 else if(InterPolation == kMonotonic)
447 {
448 // values of the secants at each point (for calculating monotone spline)
449 M3::float_t * Secants = new M3::float_t[nPoints -1];
450 // values of the tangens at each point (for calculating monotone spline)
451 M3::float_t * Tangents = new M3::float_t[nPoints];
452
453 // get the knot values for the spline
454 for (int i = 0; i < nPoints; ++i) {
455 // 3 is the size of the TSpline3 coefficients
456 Par[i] = new M3::float_t[3];
457
458 double x = -999.99, y = -999.99;
459 spline->GetKnot(i, x, y);
460
461 XPos[i] = M3::float_t(x);
462 YResp[i] = M3::float_t(y);
463
464 Tangents[i] = 0.0;
465 }
466
467 // deal with the case of two points (just do linear interpolation between them)
468 if (nPoints == 2){
469 Par[0][0] = (YResp[1] - YResp[0]) / (XPos[1] - XPos[0]);
470 Par[0][1] = 0.0;
471 Par[0][2] = 0.0;
472 // extra "virtual" segment at end to make Par array shape fit with knot arrays shapes
473 Par[1][1] = 0.0;
474 Par[1][2] = 0.0;
475
476 return;
477 } // if nPoints !=2 do full monotonic spline treatment:
478 else
479 {
480 // first pass over knots to calculate the secants
481 for (int i = 0; i < nPoints-1; ++i) {
482 Secants[i] = (YResp[i+1] - YResp[i]) / (XPos[i+1] - XPos[i]);
483 MACH3LOG_TRACE("Secant {}: {}", i, Secants[i]);
484 }
485
486 Tangents[0] = Secants[0];
487 Tangents[nPoints-1] = Secants[nPoints -2];
488
489 M3::float_t alpha;
490 M3::float_t beta;
491
492 // second pass over knots to calculate tangents
493 for (int i = 1; i < nPoints-1; ++i) {
494 if ((Secants[i-1] >= 0.0 && Secants[i] >= 0.0) | (Secants[i-1] < 0.0 && Secants[i] < 0.0)){ //check for same sign
495 Tangents[i] = M3::float_t((Secants[i-1] + Secants[i]) /2.0);
496 }
497 }
498
499 // third pass over knots to rescale tangents
500 for (int i = 0; i < nPoints-1; ++i) {
501 if (Secants[i] == 0.0){
502 Tangents[i] = 0.0;
503 Tangents[i+1] = 0.0;
504 }
505
506 else{
507 alpha = Tangents[i] / Secants[i];
508 beta = Tangents[i+1] / Secants[i];
509
510 if (alpha <0.0){
511 Tangents[i] = 0.0;
512 }
513 if (beta < 0.0){
514 Tangents[i+1] = 0.0;
515 }
516
517 if (alpha * alpha + beta * beta >9.0){
518 M3::float_t tau = M3::float_t(3.0 / std::sqrt(alpha * alpha + beta * beta));
519 Tangents[i] = tau * alpha * Secants[i];
520 Tangents[i+1] = tau * beta * Secants[i];
521 }
522 }
523 } // finished rescaling tangents
524 // fourth pass over knots to calculate the coefficients for the spline
525 M3::float_t dx;
526 for(int i = 0; i <nPoints-1; i++){
527 M3::float_t b, c, d = M3::float_t(-999.999);
528 dx = XPos[i+1] - XPos[i];
529
530 b = Tangents[i] * dx;
531 c = M3::float_t(3.0* (YResp[i+1] - YResp[i]) -2.0 *dx * Tangents[i] - dx * Tangents[i +1]);
532 d = M3::float_t(2.0* (YResp[i] - YResp[i+1]) + dx * (Tangents[i] + Tangents[i+1]));
533
534 Par[i][0] = b / dx;
535 Par[i][1] = c / (dx * dx);
536 Par[i][2] = d / (dx * dx * dx);
537
538 if((Par[i][0] == -999) | (Par[i][1] == -999) | (Par[i][2] ==-999) | (Par[i][0] == -999.999) | (Par[i][1] == -999.999) | (Par[i][2] ==-999.999)){
539 MACH3LOG_INFO("Bad spline parameters for segment {}: (b, c, d) = {}, {}, {}. This will cause problems with GPU.",
540 i, Par[i][0], Par[i][1], Par[i][2]);
541 }
542 MACH3LOG_TRACE("b: {}", b);
543 MACH3LOG_TRACE("dx: {}, x_0: {}, x_1: {}", dx, XPos[i], XPos[i+1]);
544 MACH3LOG_TRACE(" y_0: {}, y_1: {}", YResp[i], YResp[i+1]);
545 }
546
547 // include params for final "segment" outside of the spline so that par array fits with x and y arrays,
548 // should never actually get used but if not set then the GPU code gets very angry
549 Par[nPoints-1][0] = 0.0;
550 Par[nPoints-1][1] = 0.0;
551 Par[nPoints-1][2] = 0.0;
552
553 // check the input spline for linear segments, if there are any then overwrite the calculated coefficients
554 // this will pretty much only ever be the case if they are set to be linear in samplePDFND i.e. the user wants it to be linear
555 for(int i = 0; i <nPoints-1; i++){
556 double x = -999.99, y = -999.99, b = -999.99, c = -999.99, d = -999.99;
557 spline->GetCoeff(i, x, y, b, c, d);
558
559 if((c == 0.0 && d == 0.0)){
560 Par[i][0] = M3::float_t(b);
561 Par[i][1] = 0.0;
562 Par[i][2] = 0.0;
563 }
564 }
565 delete[] Secants;
566 delete[] Tangents;
567 } // end of if(nPoints !=2)
568 }
569 else
570 {
571 MACH3LOG_ERROR("Unsupported interpolation type {}", static_cast<int>(InterPolation));
572 throw MaCh3Exception(__FILE__ , __LINE__ );
573 }
574
575 delete spline;
576 spline = NULL;
577 }
#define MACH3LOG_TRACE
Definition: MaCh3Logger.h:21
@ kTSpline3
Default TSpline3 interpolation.
@ kMonotonic
EM: DOES NOT make the entire spline monotonic, only the segments.
@ kLinear
Linear interpolation between knots.
@ kLinearFunc
Liner interpolation using TF1 not spline.
@ kAkima
EM: Akima spline iis allowed to be discontinuous in 2nd derivative and coefficients in any segment.
Custom exception class for MaCh3 errors.
int int_t
Definition: Core.h:29

Member Data Documentation

◆ nPoints

M3::int_t TSpline3_red::nPoints
protected

Number of points/knot in TSpline3.

Definition at line 689 of file SplineStructs.h.

◆ Par

M3::float_t** TSpline3_red::Par
protected

Always uses a third order polynomial, so hard-code the number of coefficients in implementation.

Definition at line 691 of file SplineStructs.h.

◆ XPos

M3::float_t* TSpline3_red::XPos
protected

Positions of each x for each knot.

Definition at line 693 of file SplineStructs.h.

◆ YResp

M3::float_t* TSpline3_red::YResp
protected

y-value for each knot

Definition at line 695 of file SplineStructs.h.


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