346 const char charal[29] =
" .ABCDEFGHIJKLMNOPQRSTUVWXYZ";
435 fGraphicsMode =
kTRUE;
453 fGraphicsMode =
kTRUE;
461 gROOT->GetListOfSpecials()->Add(
this);
488 gROOT->GetListOfSpecials()->Add(
this);
498 Error(
"TMinuit",
"can not copy construct TMinuit");
511 if (
gROOT != 0 &&
gROOT->GetListOfSpecials() != 0)
gROOT->GetListOfSpecials()->Remove(
this);
513 if (gMinuit ==
this) gMinuit =
nullptr;
593 for (
int i = 0; i <
fMaxpar; i++) {
670 mncont(pa1,pa2,npoints,xcoor,ycoor,npfound);
673 Warning(
"Contour",
"Cannot find more than 4 points, no TGraph returned");
674 fStatus= (npfound==0 ? 1 : npfound);
679 if (npfound!=npoints) {
681 Warning(
"Contour",
"Returning a TGraph with %d points only",npfound);
686 xcoor[npoints] = xcoor[0];
687 ycoor[npoints] = ycoor[0];
690 if ((h =
gROOT->GetPluginManager()->FindHandler(
"TMinuitGraph"))) {
707 mnparm( parNo, sname, initVal, initErr, lowerLimit, upperLimit, err);
827 if (
fFCN) (*fFCN)(npar,grad,fval,
par,flag);
840 mnexcm(
"FIX", tmp, 1, err );
854 mnpout( parNo, name, currentValue, currentError, bnd1, bnd2, err );
893 mnexcm(
"MIGRAD", tmp, 0, err );
907 mnexcm(
"RELEASE", tmp, 1, err );
919 mnexcm(
"SET ERRDEF", &up, 1, err );
960 Error(
"SetFCN",
"Not used anymore.");
980 mnexcm(
"SET PRINT", tmp, 1, err );
982 if (printLevel <=-1)
mnexcm(
"SET NOWarnings",tmp,0,err);
1002 Printf(
" FIRST CALL TO USER FUNCTION AT NEW START POINT, WITH IFLAG=4.");
1022 Double_t awid,ah, al, sigfig, sigrnd, alb;
1023 Int_t kwid, lwid, na=0, log_;
1027 if (al == ah) ah = al + 1;
1030 if (naa == -1)
goto L150;
1039 if (awid <= 1) --log_;
1042 if (sigfig > 2)
goto L40;
1046 if (sigfig > 2.5)
goto L50;
1050 if (sigfig > 5)
goto L60;
1061 if (bwid <= 0)
goto L10;
1065 if (alb < 0) --lwid;
1067 alb = ah / bwid + 1;
1069 if (alb < 0) --kwid;
1072 if (naa > 5)
goto L240;
1073 if (naa == -1)
return;
1075 if (naa > 1 || nb == 1)
return;
1080 if (nb << 1 != naa)
return;
1095 Int_t ndex, i, j,
m,
n, nparx;
1101 for (i = 1; i <=
fNpar; ++i) {
1103 for (j = 1; j <=
fNpar; ++j) {
1106 ndex = m*(m-1) / 2 + n;
1111 for (i = 1; i <=
fNpar; ++i) {denom +=
fGrd[i-1]*(
fXt[i-1] - pvec[i-1]); }
1117 ycalf = (f -
fApsi) / denom;
1135 for (i = 1; i <=
fMaxext; ++i) {
1156 static TString clabel =
"0123456789ABCDEFGHIJ";
1160 Double_t fcna[115], fcnb[115], contur[20];
1161 Double_t ylabel, fmn, fmx, xlo, ylo, xup, yup;
1162 Double_t devs, xsav, ysav, bwidx, bwidy, unext, ff, xb4;
1163 Int_t i, ngrid, ixmid, nparx, ix,
nx,
ny, ki1, ki2, ixzero, iy, ics;
1168 if (ke1 <= 0 || ke2 <= 0)
goto L1350;
1169 if (ke1 >
fNu || ke2 >
fNu)
goto L1350;
1172 if (ki1 <= 0 || ki2 <= 0)
goto L1350;
1173 if (ki1 == ki2)
goto L1350;
1183 if (devs <= 0) devs = 2;
1184 xlo =
fU[ke1-1] - devs*
fWerr[ki1-1];
1185 xup =
fU[ke1-1] + devs*fWerr[ki1-1];
1186 ylo =
fU[ke2-1] - devs*fWerr[ki2-1];
1187 yup =
fU[ke2-1] + devs*fWerr[ki2-1];
1199 if (nx < 11) nx = 11;
1200 if (ny < 11) ny = 11;
1201 if (nx >= 115) nx = 114;
1212 bwidx = (xup - xlo) /
Double_t(nx);
1213 bwidy = (yup - ylo) /
Double_t(ny);
1214 ixmid =
Int_t(((xsav - xlo)*
Double_t(nx) / (xup - xlo)) + 1);
1215 if (ixmid < 1) ixmid = 1;
1218 for (i = 1; i <= 20; ++i) { contur[i-1] =
fAmin +
fUp*(i-1)*(i-1); }
1219 contur[0] +=
fUp*.01;
1228 for (ix = 1; ix <= nx + 1; ++ix) {
1232 if (xb4 < 0 &&
fU[ke1-1] > 0) ixzero = ix - 1;
1237 Printf(
" Y-AXIS: PARAMETER %3d: %s",ke2,(
const char*)
fCpnam[ke2-1]);
1239 chzero[ixzero-1] =
'+';
1244 for (iy = 1; iy <=
ny; ++iy) {
1245 unext =
fU[ke2-1] - bwidy;
1250 chln[ixmid-1] =
'*';
1251 if (ixzero != 0) chln[ixzero-1] =
':';
1252 if (
fU[ke2-1] > ysav && unext < ysav) chln = chmid;
1253 if (
fU[ke2-1] > 0 && unext < 0) chln = chzero;
1255 ylabel =
fU[ke2-1] + bwidy*.5;
1257 for (ix = 1; ix <= nx + 1; ++ix) {
1258 fcna[ix-1] = fcnb[ix-1];
1264 for (ix = 1; ix <=
nx; ++ix) {
1271 for (ics = 1; ics <= 20; ++ics) {
1272 if (contur[ics-1] > fmn)
goto L240;
1276 if (contur[ics-1] < fmx) chln[ix-1] = clabel[ics-1];
1279 Printf(
" %12.4g %s",ylabel,(
const char*)chln);
1284 chln(ixmid-1,1) =
'I';
1286 Printf(
" %s",(
const char*)chln);
1291 Printf(
" %12.4g%s%12.4g",xlo,(
const char*)chln,xup);
1292 Printf(
" %s%12.4g",(
const char*)chln,xsav);
1294 Printf(
" %12.4g%s%12.4g%s%12.4g",xlo,(
const char*)chln,xsav,(
const char*)chln,xup);
1296 Printf(
" X-AXIS: PARAMETER %3d %s ONE COLUMN=%12.4g" 1297 ,ke1,(
const char*)
fCpnam[ke1-1],bwidx);
1305 Printf(
" INVALID PARAMETER NUMBER(S) REQUESTED. IGNORED.");
1335 Int_t ierr, ipos, i, llist, lenbuf, lnc;
1337 TString comand, crdbuf, ctemp;
1341 lenbuf = crdbuf.
Length();
1346 for (i = 1; i <=
TMath::Min(20,lenbuf); ++i) {
1347 if (crdbuf[i-1] ==
'\'')
break;
1348 if (crdbuf[i-1] ==
' ') {
1356 if (ipos > lenbuf) {
1357 Printf(
" BLANK COMMAND IGNORED.");
1363 if (crdbuf(ipos-1,3) ==
"PAR") {
1369 if (crdbuf(ipos-1,3) ==
"SET INP") {
1375 if (crdbuf(ipos-1,7) ==
"SET TIT") {
1381 if (crdbuf(ipos-1,7) ==
"SET COV") {
1387 ctemp = crdbuf(ipos-1,lenbuf-ipos+1);
1390 Printf(
" COMMAND CANNOT BE INTERPRETED");
1426 Double_t a1, a2, val2mi, val2pl, dc, sclfac, bigdis, sigsav;
1427 Int_t nall, iold,
line, mpar, ierr, inew, move, next, i, j, nfcol, iercr;
1428 Int_t idist=0, npcol, kints, i2, i1, lr, nfcnco=0, ki1, ki2, ki3, ke3;
1429 Int_t nowpts, istrav, nfmxin, isw2, isw4;
1435 ldebug =
fIdbg[6] >= 1;
1436 if (ke1 <= 0 || ke2 <= 0)
goto L1350;
1437 if (ke1 >
fNu || ke2 >
fNu)
goto L1350;
1440 if (ki1 <= 0 || ki2 <= 0)
goto L1350;
1441 if (ki1 == ki2)
goto L1350;
1442 if (nptu < 4)
goto L1400;
1454 Printf(
" START MNCONTOUR CALCULATION OF %4d POINTS ON CONTOUR.",nptu);
1457 ki3 = 6 - ki1 - ki2;
1459 Printf(
" EACH POINT IS A MINIMUM WITH RESPECT TO PARAMETER %3d %s",ke3,(
const char*)
fCpnam[ke3-1]);
1461 Printf(
" EACH POINT IS A MINIMUM WITH RESPECT TO THE OTHER %3d VARIABLE PARAMETERS.",
fNpar - 2);
1468 mnmnot(ke1, ke2, val2pl, val2mi);
1470 xptu[0] =
fAlim[ke1-1];
1471 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1473 if (
fErn[ki1-1] >= 0)
goto L1500;
1474 xptu[0] = u1min +
fErn[ki1-1];
1479 xptu[2] =
fBlim[ke1-1];
1480 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1482 if (
fErp[ki1-1] <= 0)
goto L1500;
1483 xptu[2] = u1min +
fErp[ki1-1];
1486 scalx = 1 / (xptu[2] - xptu[0]);
1488 mnmnot(ke2, ke1, val2pl, val2mi);
1490 yptu[1] =
fAlim[ke2-1];
1491 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1493 if (
fErn[ki2-1] >= 0)
goto L1500;
1494 yptu[1] = u2min +
fErn[ki2-1];
1498 yptu[3] =
fBlim[ke2-1];
1499 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1501 if (
fErp[ki2-1] <= 0)
goto L1500;
1502 yptu[3] = u2min +
fErp[ki2-1];
1505 scaly = 1 / (yptu[3] - yptu[1]);
1509 Printf(
" Plot of four points found by MINOS");
1515 for (i = 2; i <= nall; ++i) {
1516 fXpt[i-1] = xptu[i-2];
1517 fYpt[i-1] = yptu[i-2];
1519 sprintf(
fChpt,
"%s",
" ABCD");
1533 for (i = 1; i <= mpar; ++i) {
fXt[i-1] =
fX[i-1]; }
1534 i__1 = mpar*(mpar + 1) / 2;
1536 for (i = 1; i <= mpar; ++i) {
1546 for (inew = next; inew <= nptu; ++inew) {
1549 for (iold = 1; iold <= inew - 1; ++iold) {
1551 if (i2 == inew) i2 = 1;
1552 d__1 = scalx*(xptu[iold-1] - xptu[i2-1]);
1553 d__2 = scaly*(yptu[iold-1] - yptu[i2-1]);
1554 dist = d__1*d__1 + d__2*d__2;
1555 if (dist > bigdis) {
1562 if (i2 == inew) i2 = 1;
1567 fXmidcr = a1*xptu[i1-1] + a2*xptu[i2-1];
1568 fYmidcr = a1*yptu[i1-1] + a2*yptu[i2-1];
1569 xdir = yptu[i2-1] - yptu[i1-1];
1570 ydir = xptu[i1-1] - xptu[i2-1];
1583 Printf(
" MNCONT CANNOT FIND NEXT POINT ON CONTOUR. ONLY %3d POINTS FOUND.",nowpts);
1587 mnwarn(
"W",
"MNContour ",
"Cannot find midpoint, try closer.");
1593 for (move = nowpts; move >= i1 + 1; --move) {
1594 xptu[move] = xptu[move-1];
1595 yptu[move] = yptu[move-1];
1605 if (nowpts < nptu)
fCstatu =
"INCOMPLETE";
1613 for (i = 2; i <= nall; ++i) {
1614 fXpt[i-1] = xptu[i-2];
1615 fYpt[i-1] = yptu[i-2];
1619 Printf(
" Y-AXIS: PARAMETER %3d %s",ke2,(
const char*)
fCpnam[ke2-1]);
1623 Printf(
" X-AXIS: PARAMETER %3d %s",ke1,(
const char*)
fCpnam[ke1-1]);
1627 npcol = (nowpts + 1) / 2;
1629 Printf(
"%5d POINTS ON CONTOUR. FMIN=%13.5e ERRDEF=%11.3g",nowpts,abest,
fUp);
1631 (
const char*)
fCpnam[ke2-1],
1632 (
const char*)
fCpnam[ke1-1],
1633 (
const char*)
fCpnam[ke2-1]);
1634 for (line = 1; line <= nfcol; ++
line) {
1636 Printf(
" %5d%13.5e%13.5e %5d%13.5e%13.5e",line,xptu[line-1],yptu[line-1],lr,xptu[lr-1],yptu[lr-1]);
1638 if (nfcol < npcol) {
1639 Printf(
" %5d%13.5e%13.5e",npcol,xptu[npcol-1],yptu[npcol-1]);
1646 i__1 = mpar*(mpar + 1) / 2;
1648 for (i = 1; i <= mpar; ++i) {
1667 Printf(
" INVALID PARAMETER NUMBERS.");
1670 Printf(
" LESS THAN FOUR POINTS REQUESTED.");
1676 Printf(
" MNCONT UNABLE TO FIND FOUR POINTS.");
1705 const char *cnumer =
"123456789-.0+";
1708 Int_t ifld, iend, lend, left, nreq, ipos, kcmnd, nextb, ic, ibegin, ltoadd;
1709 Int_t ielmnt, lelmnt[25], nelmnt;
1715 char *crdbuf = (
char*)cardbuf.
Data();
1722 for (ipos = nextb; ipos <= lend; ++ipos) {
1724 if (crdbuf[ipos-1] ==
' ')
continue;
1725 if (crdbuf[ipos-1] ==
',')
goto L250;
1731 for (ipos = ibegin + 1; ipos <= lend; ++ipos) {
1732 if (crdbuf[ipos-1] ==
' ')
goto L250;
1733 if (crdbuf[ipos-1] ==
',')
goto L250;
1739 if (iend >= ibegin) celmnt[ielmnt-1] = &crdbuf[ibegin-1];
1740 else celmnt[ielmnt-1] = cnull;
1741 lelmnt[ielmnt-1] = iend - ibegin + 1;
1742 if (lelmnt[ielmnt-1] > 19) {
1743 Printf(
" MINUIT WARNING: INPUT DATA WORD TOO LONG.");
1744 ctemp = cardbuf(ibegin-1,iend-ibegin+1);
1746 Printf(
" TRUNCATED TO:%s",celmnt[ielmnt-1]);
1747 lelmnt[ielmnt-1] = 19;
1749 if (ipos >= lend)
goto L300;
1750 if (ielmnt >= 25)
goto L300;
1752 for (ipos = iend + 1; ipos <= lend; ++ipos) {
1753 if (crdbuf[ipos-1] ==
' ')
continue;
1755 if (crdbuf[ipos-1] ==
',') nextb = ipos + 1;
1762 command[0] =
' '; command[1] = 0;
1766 if (ielmnt == 0)
goto L900;
1768 for (ielmnt = 1; ielmnt <= nelmnt; ++ielmnt) {
1769 if ( celmnt[ielmnt-1] == cnull)
goto L450;
1770 for (ic = 1; ic <= 13; ++ic) {
1771 if (*celmnt[ielmnt-1] == cnumer[ic-1])
goto L450;
1773 if (kcmnd >= maxcwd)
continue;
1774 left = maxcwd - kcmnd;
1775 ltoadd = lelmnt[ielmnt-1];
1776 if (ltoadd > left) ltoadd = left;
1777 strncpy(&command[kcmnd],celmnt[ielmnt-1],ltoadd);
1779 if (kcmnd == maxcwd)
continue;
1780 command[kcmnd] =
' ';
1790 for (ifld = ielmnt; ifld <= nelmnt; ++ifld) {
1793 nreq = nelmnt - ielmnt + 1;
1794 Printf(
" MINUIT WARNING IN MNCRCK: ");
1795 Printf(
" COMMAND HAS INPUT %5d NUMERIC FIELDS, BUT MINUIT CAN ACCEPT ONLY%3d",nreq,mxp);
1798 if (celmnt[ifld-1] == cnull) plist[llist-1] = 0;
1800 sscanf(celmnt[ifld-1],
"%lf",&plist[llist-1]);
1805 if (lnc <= 0) lnc = 1;
1823 Double_t alsb[3], flsb[3], bmin, bmax, zmid, sdev, zdir, zlim;
1824 Double_t coeff[3], aleft, aulim, fdist, adist, aminsv;
1825 Double_t anext, fnext, slope, s1, s2,
x1,
x2, ecarmn, ecarmx;
1826 Double_t determ, rt, smalla, aright, aim, tla, tlf, dfda,ecart;
1827 Int_t iout=0, i, ileft, ierev, maxlk, ibest, ik, it;
1828 Int_t noless, iworst=0, iright, itoohi, kex, ipt;
1833 ldebug =
fIdbg[6] >= 1;
1852 for (ik = 1; ik <= 2; ++ik) {
1858 if (
fKe2cr == 0)
continue;
1863 if (
fNvarl[kex-1] <= 1)
continue;
1864 if (zdir == 0)
continue;
1865 zlim =
fAlim[kex-1];
1866 if (zdir > 0) zlim =
fBlim[kex-1];
1867 aulim =
TMath::Min(aulim,(zlim - zmid) / zdir);
1875 mneval(anext, fnext, ierev);
1878 Printf(
" MNCROS: calls=%8d AIM=%10.5f F,A=%10.5f%10.5f",
fNfcn,aim,fnext,aopt);
1880 if (ierev > 0)
goto L900;
1881 if (
fLimset && fnext <= aim)
goto L930;
1883 fXpt[ipt-1] = anext;
1884 fYpt[ipt-1] = fnext;
1890 if (
TMath::Abs(fnext - aim) < tlf)
goto L800;
1892 if (aopt < -.5)aopt = -.5;
1893 if (aopt > 1) aopt = 1;
1899 mneval(aopt, fnext, ierev);
1902 Printf(
" MNCROS: calls=%8d AIM=%10.5f F,A=%10.5f%10.5f",
fNfcn,aim,fnext,aopt);
1904 if (ierev > 0)
goto L900;
1905 if (
fLimset && fnext <= aim)
goto L930;
1908 fXpt[ipt-1] = alsb[1];
1909 fYpt[ipt-1] = fnext;
1912 dfda = (flsb[1] - flsb[0]) / (alsb[1] - alsb[0]);
1914 if (dfda > 0)
goto L460;
1916 mnwarn(
"D",
"MNCROS ",
"Looking for slope of the right sign");
1918 for (it = 1; it <= maxlk; ++it) {
1927 mneval(aopt, fnext, ierev);
1930 Printf(
" MNCROS: calls=%8d AIM=%10.5f F,A=%10.5f%10.5f",
fNfcn,aim,fnext,aopt);
1932 if (ierev > 0)
goto L900;
1933 if (
fLimset && fnext <= aim)
goto L930;
1936 fXpt[ipt-1] = alsb[1];
1937 fYpt[ipt-1] = fnext;
1940 dfda = (flsb[1] - flsb[0]) / (alsb[1] - alsb[0]);
1941 if (dfda > 0)
goto L450;
1943 mnwarn(
"W",
"MNCROS ",
"Cannot find slope of the right sign");
1948 aopt = alsb[1] + (aim - flsb[1]) / dfda;
1953 if (adist < tla && fdist < tlf)
goto L800;
1954 if (ipt >= 15)
goto L950;
1956 if (aopt < bmin) aopt = bmin;
1958 if (aopt > bmax) aopt = bmax;
1965 mneval(aopt, fnext, ierev);
1968 Printf(
" MNCROS: calls=%8d AIM=%10.5f F,A=%10.5f%10.5f",
fNfcn,aim,fnext,aopt);
1970 if (ierev > 0)
goto L900;
1971 if (
fLimset && fnext <= aim)
goto L930;
1974 fXpt[ipt-1] = alsb[2];
1975 fYpt[ipt-1] = fnext;
1983 for (i = 1; i <= 3; ++i) {
1985 if (ecart > ecarmx) { ecarmx = ecart; iworst = i; }
1986 if (ecart < ecarmn) { ecarmn = ecart; ibest = i; }
1987 if (flsb[i-1] < aim) ++noless;
1990 if (noless == 1 || noless == 2)
goto L500;
1992 if (noless == 0 && ibest != 3)
goto L950;
1995 if (noless == 3 && ibest != 3) {
2001 alsb[iworst-1] = alsb[2];
2002 flsb[iworst-1] = flsb[2];
2003 dfda = (flsb[1] - flsb[0]) / (alsb[1] - alsb[0]);
2007 mnpfit(alsb, flsb, 3, coeff, sdev);
2008 if (coeff[2] <= 0) {
2009 mnwarn(
"D",
"MNCROS ",
"Curvature is negative near contour line.");
2011 determ = coeff[1]*coeff[1] - coeff[2]*4*(coeff[0] - aim);
2013 mnwarn(
"D",
"MNCROS ",
"Problem 2, impossible determinant");
2018 x1 = (-coeff[1] + rt) / (coeff[2]*2);
2019 x2 = (-coeff[1] - rt) / (coeff[2]*2);
2020 s1 = coeff[1] + x1*2*coeff[2];
2021 s2 = coeff[1] + x2*2*coeff[2];
2023 Printf(
" MNCONTour problem 1");
2037 if (ipt >= 15)
goto L950;
2046 for (i = 1; i <= 3; ++i) {
2048 if (ecart < ecarmn) { ecarmn = ecart; ibest = i; }
2049 if (ecart > ecarmx) { ecarmx = ecart; }
2050 if (flsb[i-1] > aim) {
2051 if (iright == 0) iright = i;
2052 else if (flsb[i-1] > flsb[iright-1]) iout = i;
2053 else { iout = iright; iright = i; }
2055 else if (ileft == 0) ileft = i;
2056 else if (flsb[i-1] < flsb[ileft-1]) iout = i;
2057 else { iout = ileft; ileft = i; }
2060 if (ecarmx >
TMath::Abs(flsb[iout-1] - aim)*10) {
2061 aopt = aopt*.5 + (alsb[iright-1] + alsb[ileft-1])*.25;
2065 if (slope*smalla > tlf) smalla = tlf / slope;
2066 aleft = alsb[ileft-1] + smalla;
2067 aright = alsb[iright-1] - smalla;
2069 if (aopt < aleft) aopt = aleft;
2070 if (aopt > aright) aopt = aright;
2071 if (aleft > aright) aopt = (aleft + aright)*.5;
2080 mneval(aopt, fnext, ierev);
2083 Printf(
" MNCROS: calls=%8d AIM=%10.5f F,A=%10.5f%10.5f",
fNfcn,aim,fnext,aopt);
2085 if (ierev > 0)
goto L900;
2086 if (
fLimset && fnext <= aim)
goto L930;
2089 fYpt[ipt-1] = fnext;
2092 alsb[iout-1] = aopt;
2093 flsb[iout-1] = fnext;
2105 if (ierev == 1)
goto L940;
2122 for (i = 1; i <= ipt; ++i) {
2123 if (
fYpt[i-1] > aim + fUp) {
2131 if (
fXdircr < 0) chsign =
"NEGA";
2133 Printf(
" %sTIVE MINOS ERROR, PARAMETER %3d",chsign,
fKe1cr);
2136 Printf(
"POINTS LABELLED '+' WERE TOO HIGH TO PLOT.");
2139 Printf(
"RIGHTMOST POINT IS UP AGAINST LIMIT.");
2156 Int_t ndex, iext, i, j;
2159 Printf(
" FUNCTION MUST BE MINIMIZED BEFORE CALLING %s",(
const char*)
fCfrom);
2166 mnwarn(
"W",
fCfrom,
"NO ERROR MATRIX. WILL IMPROVISE.");
2167 for (i = 1; i <=
fNpar; ++i) {
2169 for (j = 1; j <= i-1; ++j) {
2174 if (
fG2[i-1] <= 0) {
2177 if (
fNvarl[iext-1] > 1) {
2182 fG2[i-1] =
fUp / (wint*wint);
2203 Double_t step, dfmin, stepb4, dd, df, fs1;
2204 Double_t tlrstp, tlrgrd, epspri, optstp, stpmax, stpmin, fs2, grbfor=0, d1d2, xtf;
2205 Int_t icyc, ncyc, iint, iext, i, nparx;
2209 ldebug =
fIdbg[2] >= 1;
2211 if (
fISW[2] == 1)
goto L100;
2223 Printf(
" FIRST DERIVATIVE DEBUG PRINTOUT. MNDERI");
2224 Printf(
" PAR DERIV STEP MINSTEP OPTSTEP D1-D2 2ND DRV");
2241 for (i = 1; i <=
fNpar; ++i) {
2248 for (icyc = 1; icyc <= ncyc; ++icyc) {
2254 if (
fGstep[i-1] < 0 && step > .5) step = .5;
2257 if (step > stpmax) step = stpmax;
2260 if (step < stpmin) step = stpmin;
2262 if (TMath::Abs((step - stepb4) / step) < tlrstp)
goto L50;
2268 fX[i-1] = xtf + step;
2272 fX[i-1] = xtf - step;
2276 fGrd[i-1] = (fs1 - fs2) / (step*2);
2277 fG2[i-1] = (fs1 + fs2 -
fAmin*2) / (step*step);
2280 d1d2 = (fs1 + fs2 -
fAmin*2) / step;
2281 Printf(
"%4d%11.3g%11.3g%10.2g%10.2g%10.2g%10.2g",i,
fGrd[i-1],step,stpmin,optstp,d1d2,
fG2[i-1]);
2284 if (TMath::Abs(grbfor -
fGrd[i-1]) / (TMath::Abs(
fGrd[i-1]) + dfmin/step) < tlrgrd)
2288 if (ncyc == 1)
goto L50;
2297 for (iint = 1; iint <=
fNpar; ++iint) {
2299 if (
fNvarl[iext-1] <= 1) {
2335 Int_t i, j, k,
l,
m=0, i0, i1, j1, m1, n1;
2339 a_offset = ndima + 1;
2347 for (i1 = 2; i1 <=
n; ++i1) {
2349 f = a[i + (i-1)*ndima];
2352 if (l < 1)
goto L25;
2354 for (k = 1; k <=
l; ++k) {
2355 d__1 = a[i + k*ndima];
2361 if (gl > 1
e-35)
goto L30;
2369 if (f >= 0) gl = -gl;
2372 a[i + (i-1)*ndima] = f - gl;
2374 for (j = 1; j <=
l; ++j) {
2375 a[j + i*ndima] = a[i + j*ndima] /
h;
2377 for (k = 1; k <= j; ++k) { gl += a[j + k*ndima]*a[i + k*ndima]; }
2378 if (j >= l)
goto L47;
2380 for (k = j1; k <=
l; ++k) { gl += a[k + j*ndima]*a[i + k*ndima]; }
2382 work[n + j] = gl /
h;
2383 f += gl*a[j + i*ndima];
2386 for (j = 1; j <=
l; ++j) {
2388 gl = work[n + j] - hh*
f;
2390 for (k = 1; k <= j; ++k) {
2391 a[j + k*ndima] = a[j + k*ndima] - f*work[n + k] - gl*a[i + k*ndima];
2400 for (i = 1; i <=
n; ++i) {
2402 if (work[i] == 0 || l == 0)
goto L100;
2404 for (j = 1; j <=
l; ++j) {
2406 for (k = 1; k <=
l; ++k) { gl += a[i + k*ndima]*a[k + j*ndima]; }
2407 for (k = 1; k <=
l; ++k) { a[k + j*ndima] -= gl*a[k + i*ndima]; }
2410 work[i] = a[i + i*ndima];
2412 if (l == 0)
continue;
2414 for (j = 1; j <=
l; ++j) {
2421 for (i = 2; i <=
n; ++i) {
2423 work[i0] = work[i0 + 1];
2428 for (l = 1; l <=
n; ++
l) {
2432 for (m1 = l; m1 <=
n; ++m1) {
2438 if (m == l)
goto L205;
2441 if (j == mits)
return;
2443 pt = (work[l + 1] - work[
l]) / (work[n + l]*2);
2446 if (pt < 0) pr = pt -
r;
2448 h = work[
l] - work[n +
l] / pr;
2449 for (i = l; i <=
n; ++i) { work[i] -=
h; }
2456 for (i1 = l; i1 <= m1; ++i1) {
2463 c = pt / work[n + i];
2465 work[n + j] = s*work[n + i]*
r;
2470 c = work[n + i] /
pt;
2472 work[n + j] = s*pt*
r;
2476 pt = c*work[i] - s*gl;
2477 work[j] = h + s*(c*gl + s*work[i]);
2478 for (k = 1; k <=
n; ++k) {
2480 a[k + j*ndima] = s*a[k + i*ndima] + c*
h;
2481 a[k + i*ndima] = c*a[k + i*ndima] - s*
h;
2492 for (i = 1; i <= n1; ++i) {
2496 for (j = i1; j <=
n; ++j) {
2497 if (work[j] >= pt)
continue;
2502 if (k == i)
continue;
2506 for (j = 1; j <=
n; ++j) {
2507 pt = a[j + i*ndima];
2508 a[j + i*ndima] = a[j + k*ndima];
2509 a[j + k*ndima] =
pt;
2526 Int_t emat_dim1, emat_offset;
2530 Int_t i, j, k, npard, k2, kk, iz, nperln, kga, kgb;
2535 emat_offset = emat_dim1 + 1;
2536 emat -= emat_offset;
2539 if (
fISW[1] < 1)
return;
2541 Printf(
" EXTERNAL ERROR MATRIX. NDIM=%4d NPAR=%3d ERR DEF=%g",ndim,
fNpar,
fUp);
2548 Printf(
" USER-DIMENSIONED ARRAY EMAT NOT BIG ENOUGH. REDUCED MATRIX CALCULATED.");
2555 if (
fISW[4] >= 1 && npard > nperln) {
2556 Printf(
" ELEMENTS ABOVE DIAGONAL ARE NOT PRINTED.");
2559 for (i = 1; i <= npard; ++i) {
2562 for (j = 1; j <= i; ++j) {
2565 emat[i + j*emat_dim1] = dxdi*
fVhmat[kgb-1]*dxdj*
fUp;
2566 emat[j + i*emat_dim1] = emat[i + j*emat_dim1];
2571 for (i = 1; i <= npard; ++i) {
2573 if (npard >= nperln) iz = i;
2575 for (k = 1; nperln < 0 ? k >= iz : k <= iz; k += nperln) {
2576 k2 = k + nperln - 1;
2577 if (k2 > iz) k2 = iz;
2578 for (kk = k; kk <= k2; ++kk) {
2581 Printf(
"%s",(
const char*)ctemp);
2603 Int_t ndiag, iin, iex;
2607 if (iex >
fNu || iex <= 0)
goto L900;
2609 if (iin <= 0)
goto L900;
2612 eplus =
fErp[iin-1];
2613 if (eplus ==
fUndefi) eplus = 0;
2614 eminus =
fErn[iin-1];
2615 if (eminus ==
fUndefi) eminus = 0;
2617 ndiag = iin*(iin + 1) / 2;
2621 if (
fISW[1] < 2)
return;
2659 if (
fISW[0] >= 1) ierev = 1;
2660 if (
fISW[3] < 1) ierev = 2;
2691 static const char *cname[40] = {
2736 Double_t step, xptu[101], yptu[101],
f, rno;
2737 Int_t icol, kcol, ierr, iint, iext, lnow, nptu, i, iflag, ierrf;
2738 Int_t ilist, nparx, izero, nf, lk, it, iw, inonde, nsuper;
2739 Int_t it2, ke1, ke2, nowprt, kll, krl;
2740 TString chwhy, c26, cvblnk, cneway, comd;
2742 Bool_t lfreed, ltofix, lfixed;
2749 if (lk > 20) lk = 20;
2754 for (iw = 1; iw <=
fMaxpar; ++iw) {
2756 if (iw <= llist)
fWord7[iw-1] = plist[iw-1];
2763 if (lnow > 4) lnow = 4;
2766 for (i = 1; i <= lnow; ++i) {
2769 Printf(
"%s",(
const char*)ctemp);
2778 for (i = lnow + 1; i <= kll; ++i) {
2779 Printf(
"%12.4g",plist[i-1]);
2784 Printf(
" ERROR: ABOVE CALL TO MNEXCM TRIED TO PASS MORE THAN %d PARAMETERS.",
fMaxpar);
2802 for (i = 1; i <= nntot; ++i) {
2803 if (strncmp(ctemp.
Data(),cname[i-1],3) == 0)
goto L90;
2805 Printf(
"UNKNOWN COMMAND IGNORED:%s", comand.
Data());
2810 if (
fCword(0,4) ==
"MINO") i = 5;
2811 if (i != 6 && i != 7 && i != 8 && i != 23) {
2826 case 10:
goto L1000;
2827 case 11:
goto L1100;
2828 case 12:
goto L1200;
2829 case 13:
goto L1300;
2830 case 14:
goto L1400;
2831 case 15:
goto L1500;
2832 case 16:
goto L1600;
2833 case 17:
goto L1700;
2834 case 18:
goto L1800;
2835 case 19:
goto L1900;
2836 case 20:
goto L1900;
2837 case 21:
goto L1900;
2838 case 22:
goto L2200;
2839 case 23:
goto L2300;
2840 case 24:
goto L2400;
2841 case 25:
goto L1900;
2842 case 26:
goto L2600;
2843 case 27:
goto L3300;
2844 case 28:
goto L3300;
2845 case 29:
goto L3300;
2846 case 30:
goto L3300;
2847 case 31:
goto L3300;
2848 case 32:
goto L3300;
2849 case 33:
goto L3300;
2850 case 34:
goto L3400;
2851 case 35:
goto L3500;
2852 case 36:
goto L3600;
2853 case 37:
goto L3700;
2854 case 38:
goto L3800;
2855 case 39:
goto L3900;
2856 case 40:
goto L4000;
2865 if (
fISW[3] < 1) ierflg = 4;
2873 if (
fISW[3] >= 1)
return;
2875 if (
fISW[0] == 1)
return;
2876 if (
fCword(0,3) ==
"MIG")
return;
2881 if (
fISW[0] == 1)
return;
2884 if (
fISW[3] >= 1) ierflg = 0;
2900 if (fNfcn < nsuper)
goto L510;
2901 Printf(
" TOO MANY FUNCTION CALLS. MINOS GIVES UP");
2921 Printf(
"%s: NO PARAMETERS REQUESTED ",(
const char*)
fCword);
2924 for (ilist = 1; ilist <= llist; ++ilist) {
2925 iext =
Int_t(plist[ilist-1]);
2926 chwhy =
" IS UNDEFINED.";
2927 if (iext <= 0)
goto L930;
2928 if (iext >
fNu)
goto L930;
2929 if (
fNvarl[iext-1] < 0)
goto L930;
2930 chwhy =
" IS CONSTANT. ";
2931 if (
fNvarl[iext-1] == 0)
goto L930;
2934 chwhy =
" ALREADY FIXED.";
2935 if (iint == 0)
goto L930;
2937 if (ierr == 0) lfixed =
kTRUE;
2940 chwhy =
" ALREADY VARIABLE.";
2941 if (iint > 0)
goto L930;
2948 if (
fISW[4] >= 0)
Printf(
" PARAMETER %4d %s IGNORED.",iext,(
const char*)chwhy);
2950 if (lfreed || lfixed)
mnrset(0);
2963 if (it > 1 || it < 0)
goto L1005;
2974 Printf(
" IGNORED. UNKNOWN ARGUMENT:%4d",it);
2984 if (iext <= 0)
goto L1210;
2987 if (it2 <= 0)
goto L1250;
2993 Printf(
" PARAMETER %4d NOT VARIABLE.",iext);
3005 Printf(
"%s: NO PARAMETERS REQUESTED ",(
const char*)
fCword);
3011 mncntr(ke1-1, ke2-1, ierrf);
3012 if (ierrf > 0) ierflg = 3;
3043 }
else if (f <
fAmin) {
3047 if (
fISW[4] >= 0 && iflag <= 5 && nowprt == 1) {
3052 if (iflag > 5)
mnrset(1);
3063 if (
fISW[4] >= 0)
Printf(
" CALL TO USER FUNCTION WITH IFLAG = 3");
3068 if (
fCword(0,3) ==
"END") ierflg = 10;
3069 if (
fCword(0,3) ==
"RET") ierflg = 12;
3075 Printf(
" MINUIT MEMORY CLEARED. NO PARAMETERS NOW DEFINED.");
3081 for (icol = 5; icol <= lk; ++icol) {
3082 if (
fCword[icol-1] ==
' ')
continue;
3087 if (kcol == 0) comd =
"* ";
3088 else comd =
fCword(kcol-1,lk-kcol+1);
3096 if (ke1 == 0 &&
fNpar == 2) {
3101 if (nptu <= 0) nptu = 20;
3102 if (nptu > 101) nptu = 101;
3104 mncont(ke1-1, ke2-1, nptu, xptu, yptu, ierrf);
3105 if (ierrf < nptu) ierflg = 4;
3106 if (ierrf == -1) ierflg = 3;
3111 if (step <= 0) step = 2;
3114 for (i = 1; i <=
fNpar; ++i) {
3117 fX[i-1] += rno*step*
fWerr[i-1];
3125 Printf(
" BLANK COMMAND IGNORED.");
3131 Printf(
" THE *COVARIANCE* COMMAND IS OSBSOLETE. THE COVARIANCE MATRIX IS NOW SAVED IN A DIFFERENT FORMAT WITH THE *SAVE* COMMAND AND READ IN WITH:*SET COVARIANCE*");
3136 cneway =
"SET PRInt ";
3140 cneway =
"SET GRAd ";
3144 cneway =
"SHOW COVar";
3148 cneway =
"SET ERRdef";
3152 cneway =
"SET LIMits";
3159 Printf(
" OBSOLETE COMMAND:%s PLEASE USE:%s",(
const char*)
fCword 3160 ,(
const char*)cneway);
3162 if (
fCword ==
"SAVE ")
goto L1500;
3179 for (iint = 1; iint <=
fNpar; ++iint) {
3182 pint[iint-1] = pinti;
3195 Int_t kold, nold, ndex, knew, iext, i, j,
m,
n, lc, ik;
3199 Int_t iint = iint1+1;
3200 if (iint >
fNpar || iint <= 0) {
3202 Printf(
" MINUIT ERROR. ARGUMENT TO MNFIXP=%4d",iint);
3208 Printf(
" MINUIT CANNOT FIX PARAMETER %4d MAXIMUM NUMBER THAT CAN BE FIXED IS %d",iext,
fMaxpar);
3228 for (ik = iext + 1; ik <=
fNu; ++ik) {
3242 if (
fISW[1] <= 0)
return;
3244 if (
fNpar <= 0)
return;
3245 for (i = 1; i <= nold; ++i) {
3248 ndex = m*(m-1) / 2 + n;
3254 for (i = 1; i <= nold; ++i) {
3255 for (j = 1; j <= i; ++j) {
3257 if (j == iint || i == iint)
continue;
3281 Double_t grdv, xv, dirinv, g2v, gstepv, xtv;
3282 Int_t i, ipsav, ka, lc, ik,
iq, ir, is;
3285 Printf(
" CALL TO MNFREE IGNORED. ARGUMENT GREATER THAN ONE");
3288 Printf(
" CALL TO MNFREE IGNORED. THERE ARE NO FIXED PARAMETERS");
3290 if (k == 1 || k == 0)
goto L40;
3294 if (
fNiofex[ka-1] == 0)
goto L15;
3295 Printf(
" IGNORED. PARAMETER SPECIFIED IS ALREADY VARIABLE.");
3298 if (
fNpfix < 1)
goto L21;
3299 for (ik = 1; ik <=
fNpfix; ++ik) {
if (
fIpfix[ik-1] == ka)
goto L24; }
3301 Printf(
" PARAMETER %4d NOT FIXED. CANNOT BE RELEASED.",ka);
3304 if (ik ==
fNpfix)
goto L40;
3314 for (i = ik + 1; i <=
fNpfix; ++i) {
3332 if (
fNpfix < 1)
goto L300;
3335 for (ik =
fNu; ik >= ir; --ik) {
3341 fX[lc-1] =
fX[lc-2];
3351 if (is == 0) is =
fNpar;
3355 fX[is-1] =
fXs[iq-1];
3366 Printf(
" PARAMETER %4d %s RESTORED TO VARIABLE.",ir,
3367 (
const char*)
fCpnam[ir-1]);
3369 if (k == 0)
goto L40;
3388 Int_t i, nparx, lc, istsav;
3394 if (
fWord7[0] > 0)
goto L2000;
3408 Printf(
" CHECK OF GRADIENT CALCULATION IN FCN");
3409 Printf(
" PARAMETER G(IN FCN) G(MINUIT) DG(MINUIT) AGREEMENT");
3412 for (lc = 1; lc <=
fNpar; ++lc) {
3422 if (cwd !=
"GOOD")
fISW[2] = 0;
3423 Printf(
" %5d %10s%12.4e%12.4e%12.4e %s",i
3424 ,(
const char*)
fCpnam[i-1]
3428 Printf(
" AGREEMENT=NONE MEANS FCN DID NOT CALCULATE THE DERIVATIVE");
3431 Printf(
" MINUIT DOES NOT ACCEPT DERIVATIVE CALCULATIONS BY FCN");
3432 Printf(
" TO FORCE ACCEPTANCE, ENTER *SET GRAD 1*");
3466 if( comd.
Length() == 0 || comd[0] ==
'*' || comd[0] ==
'?' || comd[0] == 0 || comd==
"HELP" ) {
3467 Printf(
" ==>List of MINUIT Interactive commands:");
3468 Printf(
" CLEar Reset all parameter names and values undefined");
3469 Printf(
" CONtour Make contour map of the user function");
3470 Printf(
" EXIT Exit from Interactive Minuit");
3471 Printf(
" FIX Cause parameter(s) to remain constant");
3472 Printf(
" HESse Calculate the Hessian or error matrix.");
3473 Printf(
" IMPROVE Search for a new minimum around current minimum");
3474 Printf(
" MIGrad Minimize by the method of Migrad");
3475 Printf(
" MINImize MIGRAD + SIMPLEX method if Migrad fails");
3476 Printf(
" MINOs Exact (non-linear) parameter error analysis");
3477 Printf(
" MNContour Calculate one MINOS function contour");
3478 Printf(
" PARameter Define or redefine new parameters and values");
3479 Printf(
" RELease Make previously FIXed parameters variable again");
3480 Printf(
" REStore Release last parameter fixed");
3481 Printf(
" SAVe Save current parameter values on a file");
3482 Printf(
" SCAn Scan the user function by varying parameters");
3483 Printf(
" SEEk Minimize by the method of Monte Carlo");
3484 Printf(
" SET Set various MINUIT constants or conditions");
3485 Printf(
" SHOw Show values of current constants or conditions");
3486 Printf(
" SIMplex Minimize by the method of Simplex");
3494 if( !strncmp(comd.
Data(),
"CLE",3) ) {
3496 Printf(
" Resets all parameter names and values to undefined.");
3497 Printf(
" Must normally be followed by a PARameters command or ");
3498 Printf(
" equivalent, in order to define parameter values.");
3505 if( !strncmp(comd.
Data(),
"CON",3) ) {
3506 Printf(
" ***>CONTOUR <par1> <par2> [devs] [ngrid]");
3507 Printf(
" Instructs Minuit to trace contour lines of the user function");
3508 Printf(
" with respect to the two parameters whose external numbers");
3509 Printf(
" are <par1> and <par2>.");
3510 Printf(
" Other variable parameters of the function, if any, will have");
3511 Printf(
" their values fixed at the current values during the contour");
3512 Printf(
" tracing. The optional parameter [devs] (default value 2.)");
3513 Printf(
" gives the number of standard deviations in each parameter");
3514 Printf(
" which should lie entirely within the plotting area.");
3515 Printf(
" Optional parameter [ngrid] (default value 25 unless page");
3516 Printf(
" size is too small) determines the resolution of the plot,");
3517 Printf(
" i.e. the number of rows and columns of the grid at which the");
3518 Printf(
" function will be evaluated. [See also MNContour.]");
3525 if( !strncmp(comd.
Data(),
"END",3) ) {
3527 Printf(
" Signals the end of a data block (i.e., the end of a fit),");
3528 Printf(
" and implies that execution should continue, because another");
3529 Printf(
" Data Block follows. A Data Block is a set of Minuit data");
3530 Printf(
" consisting of");
3532 Printf(
" (2) One or more Parameter Definitions,");
3533 Printf(
" (3) A blank line, and");
3534 Printf(
" (4) A set of Minuit Commands.");
3535 Printf(
" The END command is used when more than one Data Block is to");
3536 Printf(
" be used with the same FCN function. It first causes Minuit");
3537 Printf(
" to issue a CALL FCN with IFLAG=3, in order to allow FCN to");
3538 Printf(
" perform any calculations associated with the final fitted");
3539 Printf(
" parameter values, unless a CALL FCN 3 command has already");
3540 Printf(
" been executed at the current FCN value.");
3547 if( !strncmp(comd.
Data(),
"EXI",3) ) {
3549 Printf(
" Signals the end of execution.");
3550 Printf(
" The EXIT command first causes Minuit to issue a CALL FCN");
3551 Printf(
" with IFLAG=3, to allow FCN to perform any calculations");
3552 Printf(
" associated with the final fitted parameter values, unless a");
3553 Printf(
" CALL FCN 3 command has already been executed.");
3560 if( !strncmp(comd.
Data(),
"FIX",3) ) {
3561 Printf(
" ***>FIX} <parno> [parno] ... [parno]");
3562 Printf(
" Causes parameter(s) <parno> to be removed from the list of");
3563 Printf(
" variable parameters, and their value(s) will remain constant");
3564 Printf(
" during subsequent minimizations, etc., until another command");
3565 Printf(
" changes their value(s) or status.");
3572 if( !strncmp(comd.
Data(),
"HES",3) ) {
3573 Printf(
" ***>HESse [maxcalls]");
3574 Printf(
" Calculate, by finite differences, the Hessian or error matrix.");
3575 Printf(
" That is, it calculates the full matrix of second derivatives");
3576 Printf(
" of the function with respect to the currently variable");
3577 Printf(
" parameters, and inverts it, printing out the resulting error");
3578 Printf(
" matrix. The optional argument [maxcalls] specifies the");
3579 Printf(
" (approximate) maximum number of function calls after which");
3580 Printf(
" the calculation will be stopped.");
3587 if( !strncmp(comd.
Data(),
"IMP",3) ) {
3588 Printf(
" ***>IMPROVE [maxcalls]");
3589 Printf(
" If a previous minimization has converged, and the current");
3590 Printf(
" values of the parameters therefore correspond to a local");
3591 Printf(
" minimum of the function, this command requests a search for");
3592 Printf(
" additional distinct local minima.");
3593 Printf(
" The optional argument [maxcalls] specifies the (approximate");
3594 Printf(
" maximum number of function calls after which the calculation");
3595 Printf(
" will be stopped.");
3602 if( !strncmp(comd.
Data(),
"MIG",3) ) {
3603 Printf(
" ***>MIGrad [maxcalls] [tolerance]");
3604 Printf(
" Causes minimization of the function by the method of Migrad,");
3605 Printf(
" the most efficient and complete single method, recommended");
3606 Printf(
" for general functions (see also MINImize).");
3607 Printf(
" The minimization produces as a by-product the error matrix");
3608 Printf(
" of the parameters, which is usually reliable unless warning");
3609 Printf(
" messages are produced.");
3610 Printf(
" The optional argument [maxcalls] specifies the (approximate)");
3611 Printf(
" maximum number of function calls after which the calculation");
3612 Printf(
" will be stopped even if it has not yet converged.");
3613 Printf(
" The optional argument [tolerance] specifies required tolerance");
3614 Printf(
" on the function value at the minimum.");
3615 Printf(
" The default tolerance is 0.1, and the minimization will stop");
3616 Printf(
" when the estimated vertical distance to the minimum (EDM) is");
3617 Printf(
" less than 0.001*[tolerance]*UP (see [SET ERRordef]).");
3624 if( !strncmp(comd.
Data(),
"MINI",4) ) {
3625 Printf(
" ***>MINImize [maxcalls] [tolerance]");
3626 Printf(
" Causes minimization of the function by the method of Migrad,");
3627 Printf(
" as does the MIGrad command, but switches to the SIMplex method");
3628 Printf(
" if Migrad fails to converge. Arguments are as for MIGrad.");
3629 Printf(
" Note that command requires four characters to be unambiguous.");
3636 if( !strncmp(comd.
Data(),
"MIN0",4) ) {
3637 Printf(
" ***>MINOs [maxcalls] [parno] [parno] ...");
3638 Printf(
" Causes a Minos error analysis to be performed on the parameters");
3639 Printf(
" whose numbers [parno] are specified. If none are specified,");
3640 Printf(
" Minos errors are calculated for all variable parameters.");
3641 Printf(
" Minos errors may be expensive to calculate, but are very");
3642 Printf(
" reliable since they take account of non-linearities in the");
3643 Printf(
" problem as well as parameter correlations, and are in general");
3645 Printf(
" The optional argument [maxcalls] specifies the (approximate)");
3646 Printf(
" maximum number of function calls per parameter requested,");
3647 Printf(
" after which the calculation will stop for that parameter.");
3654 if( !strncmp(comd.
Data(),
"MNC",3) ) {
3655 Printf(
" ***>MNContour <par1> <par2> [npts]");
3656 Printf(
" Calculates one function contour of FCN with respect to");
3657 Printf(
" parameters par1 and par2, with FCN minimized always with");
3658 Printf(
" respect to all other NPAR-2 variable parameters (if any).");
3659 Printf(
" Minuit will try to find npts points on the contour (default 20)");
3660 Printf(
" If only two parameters are variable at the time, it is not");
3661 Printf(
" necessary to specify their numbers. To calculate more than");
3662 Printf(
" one contour, it is necessary to SET ERRordef to the appropriate");
3663 Printf(
" value and issue the MNContour command for each contour.");
3670 if( !strncmp(comd.
Data(),
"PAR",3) ) {
3671 Printf(
" ***>PARameters");
3672 Printf(
" followed by one or more parameter definitions.");
3673 Printf(
" Parameter definitions are of the form:");
3674 Printf(
" <number> ''name'' <value> <step> [lolim] [uplim] ");
3676 Printf(
" 3 ''K width'' 1.2 0.1");
3677 Printf(
" the last definition is followed by a blank line or a zero.");
3684 if( !strncmp(comd.
Data(),
"REL",3) ) {
3685 Printf(
" ***>RELease <parno> [parno] ... [parno]");
3686 Printf(
" If <parno> is the number of a previously variable parameter");
3687 Printf(
" which has been fixed by a command: FIX <parno>, then that");
3688 Printf(
" parameter will return to variable status. Otherwise a warning");
3689 Printf(
" message is printed and the command is ignored.");
3690 Printf(
" Note that this command operates only on parameters which were");
3691 Printf(
" at one time variable and have been FIXed. It cannot make");
3692 Printf(
" constant parameters variable; that must be done by redefining");
3693 Printf(
" the parameter with a PARameters command.");
3700 if( !strncmp(comd.
Data(),
"RES",3) ) {
3701 Printf(
" ***>REStore [code]");
3702 Printf(
" If no [code] is specified, this command restores all previously");
3703 Printf(
" FIXed parameters to variable status. If [code]=1, then only");
3704 Printf(
" the last parameter FIXed is restored to variable status.");
3705 Printf(
" If code is neither zero nor one, the command is ignored.");
3712 if( !strncmp(comd.
Data(),
"RET",3) ) {
3714 Printf(
" Signals the end of a data block, and instructs Minuit to return");
3715 Printf(
" to the program which called it. The RETurn command first");
3716 Printf(
" causes Minuit to CALL FCN with IFLAG=3, in order to allow FCN");
3717 Printf(
" to perform any calculations associated with the final fitted");
3718 Printf(
" parameter values, unless a CALL FCN 3 command has already been");
3719 Printf(
" executed at the current FCN value.");
3726 if( !strncmp(comd.
Data(),
"SAV",3) ) {
3728 Printf(
" Causes the current parameter values to be saved on a file in");
3729 Printf(
" such a format that they can be read in again as Minuit");
3730 Printf(
" parameter definitions. If the covariance matrix exists, it is");
3731 Printf(
" also output in such a format. The unit number is by default 7,");
3732 Printf(
" or that specified by the user in their call to MINTIO or");
3733 Printf(
" MNINIT. The user is responsible for opening the file previous");
3734 Printf(
" to issuing the [SAVe] command (except where this can be done");
3735 Printf(
" interactively).");
3742 if( !strncmp(comd.
Data(),
"SCA",3) ) {
3743 Printf(
" ***>SCAn [parno] [numpts] [from] [to]");
3744 Printf(
" Scans the value of the user function by varying parameter");
3745 Printf(
" number [parno], leaving all other parameters fixed at the");
3746 Printf(
" current value. If [parno] is not specified, all variable");
3747 Printf(
" parameters are scanned in sequence.");
3748 Printf(
" The number of points [numpts] in the scan is 40 by default,");
3749 Printf(
" and cannot exceed 100. The range of the scan is by default");
3750 Printf(
" 2 standard deviations on each side of the current best value,");
3751 Printf(
" but can be specified as from [from] to [to].");
3752 Printf(
" After each scan, if a new minimum is found, the best parameter");
3753 Printf(
" values are retained as start values for future scans or");
3754 Printf(
" minimizations. The curve resulting from each scan is plotted");
3755 Printf(
" on the output unit in order to show the approximate behaviour");
3756 Printf(
" of the function.");
3757 Printf(
" This command is not intended for minimization, but is sometimes");
3758 Printf(
" useful for debugging the user function or finding a");
3759 Printf(
" reasonable starting point.");
3766 if( !strncmp(comd.
Data(),
"SEE",3) ) {
3767 Printf(
" ***>SEEk [maxcalls] [devs]");
3768 Printf(
" Causes a Monte Carlo minimization of the function, by choosing");
3769 Printf(
" random values of the variable parameters, chosen uniformly");
3770 Printf(
" over a hypercube centered at the current best value.");
3771 Printf(
" The region size is by default 3 standard deviations on each");
3772 Printf(
" side, but can be changed by specifying the value of [devs].");
3779 if( !strncmp(comd.
Data(),
"SET",3) ) {
3780 Printf(
" ***>SET <option_name>");
3782 Printf(
" Informs Minuit that it is running in batch mode.");
3785 Printf(
" SET EPSmachine <accuracy>");
3786 Printf(
" Informs Minuit that the relative floating point arithmetic");
3787 Printf(
" precision is <accuracy>. Minuit determines the nominal");
3788 Printf(
" precision itself, but the SET EPSmachine command can be");
3789 Printf(
" used to override Minuit own determination, when the user");
3790 Printf(
" knows that the FCN function value is not calculated to");
3791 Printf(
" the nominal machine accuracy. Typical values of <accuracy>");
3792 Printf(
" are between 10**-5 and 10**-14.");
3795 Printf(
" SET ERRordef <up>");
3796 Printf(
" Sets the value of UP (default value= 1.), defining parameter");
3797 Printf(
" errors. Minuit defines parameter errors as the change");
3798 Printf(
" in parameter value required to change the function value");
3799 Printf(
" by UP. Normally, for chisquared fits UP=1, and for negative");
3800 Printf(
" log likelihood, UP=0.5.");
3803 Printf(
" SET GRAdient [force]");
3804 Printf(
" Informs Minuit that the user function is prepared to");
3805 Printf(
" calculate its own first derivatives and return their values");
3806 Printf(
" in the array GRAD when IFLAG=2 (see specs of FCN).");
3807 Printf(
" If [force] is not specified, Minuit will calculate");
3808 Printf(
" the FCN derivatives by finite differences at the current");
3809 Printf(
" point and compare with the user calculation at that point,");
3810 Printf(
" accepting the user values only if they agree.");
3811 Printf(
" If [force]=1, Minuit does not do its own derivative");
3812 Printf(
" calculation, and uses the derivatives calculated in FCN.");
3815 Printf(
" SET INPut [unitno] [filename]");
3816 Printf(
" Causes Minuit, in data-driven mode only, to read subsequent");
3817 Printf(
" commands (or parameter definitions) from a different input");
3818 Printf(
" file. If no [unitno] is specified, reading reverts to the");
3819 Printf(
" previous input file, assuming that there was one.");
3820 Printf(
" If [unitno] is specified, and that unit has not been opened,");
3821 Printf(
" then Minuit attempts to open the file [filename]} if a");
3822 Printf(
" name is specified. If running in interactive mode and");
3823 Printf(
" [filename] is not specified and [unitno] is not opened,");
3824 Printf(
" Minuit prompts the user to enter a file name.");
3825 Printf(
" If the word REWIND is added to the command (note:no blanks");
3826 Printf(
" between INPUT and REWIND), the file is rewound before");
3827 Printf(
" reading. Note that this command is implemented in standard");
3828 Printf(
" Fortran 77 and the results may depend on the system;");
3829 Printf(
" for example, if a filename is given under VM/CMS, it must");
3830 Printf(
" be preceded by a slash.");
3833 Printf(
" SET INTeractive");
3834 Printf(
" Informs Minuit that it is running interactively.");
3837 Printf(
" SET LIMits [parno] [lolim] [uplim]");
3838 Printf(
" Allows the user to change the limits on one or all");
3839 Printf(
" parameters. If no arguments are specified, all limits are");
3840 Printf(
" removed from all parameters. If [parno] alone is specified,");
3841 Printf(
" limits are removed from parameter [parno].");
3842 Printf(
" If all arguments are specified, then parameter [parno] will");
3843 Printf(
" be bounded between [lolim] and [uplim].");
3844 Printf(
" Limits can be specified in either order, Minuit will take");
3845 Printf(
" the smaller as [lolim] and the larger as [uplim].");
3846 Printf(
" However, if [lolim] is equal to [uplim], an error condition");
3850 Printf(
" SET LINesperpage");
3851 Printf(
" Sets the number of lines for one page of output.");
3852 Printf(
" Default value is 24 for interactive mode");
3855 Printf(
" SET NOGradient");
3856 Printf(
" The inverse of SET GRAdient, instructs Minuit not to");
3857 Printf(
" use the first derivatives calculated by the user in FCN.");
3860 Printf(
" SET NOWarnings");
3861 Printf(
" Supresses Minuit warning messages.");
3864 Printf(
" SET OUTputfile <unitno>");
3865 Printf(
" Instructs Minuit to write further output to unit <unitno>.");
3868 Printf(
" SET PAGethrow <integer>");
3869 Printf(
" Sets the carriage control character for ``new page'' to");
3870 Printf(
" <integer>. Thus the value 1 produces a new page, and 0");
3871 Printf(
" produces a blank line, on some devices (see TOPofpage)");
3875 Printf(
" SET PARameter <parno> <value>");
3876 Printf(
" Sets the value of parameter <parno> to <value>.");
3877 Printf(
" The parameter in question may be variable, fixed, or");
3878 Printf(
" constant, but must be defined.");
3881 Printf(
" SET PRIntout <level>");
3882 Printf(
" Sets the print level, determining how much output will be");
3883 Printf(
" produced. Allowed values and their meanings are displayed");
3884 Printf(
" after a SHOw PRInt command, and are currently <level>=:");
3885 Printf(
" [-1] no output except from SHOW commands");
3886 Printf(
" [0] minimum output");
3887 Printf(
" [1] default value, normal output");
3888 Printf(
" [2] additional output giving intermediate results.");
3889 Printf(
" [3] maximum output, showing progress of minimizations.");
3890 Printf(
" Note: See also the SET WARnings command.");
3893 Printf(
" SET RANdomgenerator <seed>");
3894 Printf(
" Sets the seed of the random number generator used in SEEk.");
3895 Printf(
" This can be any integer between 10000 and 900000000, for");
3896 Printf(
" example one which was output from a SHOw RANdom command of");
3897 Printf(
" a previous run.");
3900 Printf(
" SET STRategy <level>");
3901 Printf(
" Sets the strategy to be used in calculating first and second");
3902 Printf(
" derivatives and in certain minimization methods.");
3903 Printf(
" In general, low values of <level> mean fewer function calls");
3904 Printf(
" and high values mean more reliable minimization.");
3905 Printf(
" Currently allowed values are 0, 1 (default), and 2.");
3909 Printf(
" Informs Minuit that the next input line is to be considered");
3910 Printf(
" the (new) title for this task or sub-task. This is for");
3911 Printf(
" the convenience of the user in reading their output.");
3915 Printf(
" Instructs Minuit to output warning messages when suspicious");
3916 Printf(
" conditions arise which may indicate unreliable results.");
3917 Printf(
" This is the default.");
3920 Printf(
" SET WIDthpage");
3921 Printf(
" Informs Minuit of the output page width.");
3922 Printf(
" Default values are 80 for interactive jobs");
3929 if( !strncmp(comd.
Data(),
"SHO",3) ) {
3930 Printf(
" ***>SHOw <option_name>");
3931 Printf(
" All SET XXXX commands have a corresponding SHOw XXXX command.");
3932 Printf(
" In addition, the SHOw commands listed starting here have no");
3933 Printf(
" corresponding SET command for obvious reasons.");
3936 Printf(
" SHOw CORrelations");
3937 Printf(
" Calculates and prints the parameter correlations from the");
3938 Printf(
" error matrix.");
3941 Printf(
" SHOw COVariance");
3942 Printf(
" Prints the (external) covariance (error) matrix.");
3945 Printf(
" SHOw EIGenvalues");
3946 Printf(
" Calculates and prints the eigenvalues of the covariance");
3950 Printf(
" SHOw FCNvalue");
3951 Printf(
" Prints the current value of FCN.");
3958 if( !strncmp(comd.
Data(),
"SIM",3) ) {
3959 Printf(
" ***>SIMplex [maxcalls] [tolerance]");
3960 Printf(
" Performs a function minimization using the simplex method of");
3961 Printf(
" Nelder and Mead. Minimization terminates either when the");
3962 Printf(
" function has been called (approximately) [maxcalls] times,");
3963 Printf(
" or when the estimated vertical distance to minimum (EDM) is");
3964 Printf(
" less than [tolerance].");
3965 Printf(
" The default value of [tolerance] is 0.1*UP(see SET ERRordef).");
3972 if( !strncmp(comd.
Data(),
"STA",3) ) {
3980 if( !strncmp(comd.
Data(),
"STO",3) ) {
3982 Printf(
" Same as EXIT.");
3989 if( !strncmp(comd.
Data(),
"TOP",3) ) {
3990 Printf(
" ***>TOPofpage");
3991 Printf(
" Causes Minuit to write the character specified in a");
3992 Printf(
" SET PAGethrow command (default = 1) to column 1 of the output");
3993 Printf(
" file, which may or may not position your output medium to");
3994 Printf(
" the top of a page depending on the device and system.");
3998 Printf(
" Unknown MINUIT command. Type HELP for list of commands.");
4016 Double_t dmin_, dxdi, elem, wint, tlrg2, d, dlast, ztemp, g2bfor;
4017 Double_t df, aimsag, fs1, tlrstp, fs2, stpinm, g2i, sag=0, xtf, xti, xtj;
4018 Int_t icyc, ncyc, ndex, idrv, iext, npar2, i, j, ifail, npard, nparx,
id, multpy;
4021 ldebug =
fIdbg[3] >= 1;
4038 if (
fISW[4] >= 2 || ldebug) {
4039 Printf(
" START COVARIANCE MATRIX CALCULATION.");
4055 Printf(
" PAR D GSTEP D G2 GRD SAG ");
4065 for (i = 1; i <= npar2; ++i) {
fVhmat[i-1] = 0; }
4069 for (
id = 1;
id <= npard; ++
id) {
4070 i =
id +
fNpar - npard;
4072 if (
fG2[i-1] == 0) {
4073 mnwarn(
"W",
"HESSE",
Form(
"Second derivative enters zero, param %d",iext));
4075 if (
fNvarl[iext-1] > 1) {
4080 fG2[i-1] =
fUp / (wint*wint);
4088 for (icyc = 1; icyc <= ncyc; ++icyc) {
4090 for (multpy = 1; multpy <= 5; ++multpy) {
4100 sag = (fs1 + fs2 -
fAmin*2)*.5;
4101 if (sag != 0)
goto L30;
4103 if (d >= .5)
goto L26;
4105 if (d > .5) d = .51;
4116 fG2[i-1] = sag*2 / (d*d);
4117 fGrd[i-1] = (fs1 - fs2) / (d*2);
4119 Printf(
"%4d%2d%12.5g%12.5g%12.5g%12.5g%12.5g",i,idrv,
fGstep[i-1],d,
fG2[i-1],
fGrd[i-1],sag);
4130 if (d < dmin_) d = dmin_;
4132 if (TMath::Abs((d - dlast) / d) < tlrstp ||
4133 TMath::Abs((
fG2[i-1] - g2bfor) /
fG2[i-1]) < tlrg2) {
4144 ndex = i*(i + 1) / 2;
4155 if (
fNpar == 1)
goto L214;
4156 for (i = 1; i <=
fNpar; ++i) {
4157 for (j = 1; j <= i-1; ++j) {
4161 fX[j-1] = xtj + fDirin[j-1];
4167 fDirin[i-1]*fDirin[j-1]);
4168 ndex = i*(i-1) / 2 + j;
4176 for (i = 1; i <=
fNpar; ++i) {
4177 for (j = 1; j <= i; ++j) {
4178 ndex = i*(i-1) / 2 + j;
4185 mnwarn(
"W",
"HESSE",
"Matrix inversion fails.");
4191 for (i = 1; i <=
fNpar; ++i) {
4194 for (j = 1; j <= i-1; ++j) {
4206 Printf(
" COVARIANCE MATRIX CALCULATED SUCCESSFULLY");
4215 Printf(
" MNHESS FAILS AND WILL RETURN DIAGONAL MATRIX. ");
4217 for (i = 1; i <=
fNpar; ++i) {
4219 for (j = 1; j <= i-1; ++j) {
4225 if (g2i <= 0) g2i = 1;
4226 fVhmat[ndex-1] = 2 / g2i;
4241 Double_t dmin_, d, dfmin, dgmin=0, change, chgold, grdold=0, epspri;
4242 Double_t fs1, optstp, fs2, grdnew=0, sag, xtf;
4243 Int_t icyc, ncyc=0, idrv, i, nparx;
4246 ldebug =
fIdbg[5] >= 1;
4254 for (i = 1; i <=
fNpar; ++i) {
4260 if (d > optstp) d = optstp;
4261 if (d < dmin_) d = dmin_;
4264 for (icyc = 1; icyc <= ncyc; ++icyc) {
4273 sag = (fs1 + fs2 -
fAmin*2)*.5;
4275 grdnew = (fs1 - fs2) / (d*2);
4278 Printf(
"%4d%2d%12.5g%12.5g%12.5g%12.5g%12.5g",i,idrv,
fGstep[i-1],d,
fG2[i-1],grdnew,sag);
4280 if (grdnew == 0)
goto L60;
4281 change =
TMath::Abs((grdold - grdnew) / grdnew);
4282 if (change > chgold && icyc > 1)
goto L60;
4288 if (change < .05)
goto L60;
4289 if (TMath::Abs(grdold - grdnew) < dgmin)
goto L60;
4291 mnwarn(
"D",
"MNHES1",
"Step size too small for 1st drv.");
4322 Double_t amax, ycalf, ystar, ystst;
4323 Double_t pb, ep, wg, xi, sigsav, reg, sig2;
4324 Int_t npfn, ndex, loop=0, i, j, ifail, iseed=0;
4325 Int_t jhold, nloop, nparx, nparp1, jh, jl, iswtr;
4327 if (
fNpar <= 0)
return;
4334 if (nloop <= 0) nloop =
fNpar + 4;
4341 for (i = 1; i <=
fNpar; ++i) {
4344 for (j = 1; j <= i; ++j) {
4345 ndex = i*(i-1) / 2 + j;
4351 if (ifail >= 1)
goto L280;
4353 for (i = 1; i <=
fNpar; ++i) {
4355 for (j = 1; j <= i; ++j) {
4363 for (i = 1; i <=
fNpar; ++i) {
4371 Printf(
"START ATTEMPT NO.%2d TO FIND NEW MINIMUM",loop);
4381 for (i = 1; i <=
fNpar; ++i) {
4384 fX[i-1] = xi -
fDirin[i-1]*(rnum - .5);
4390 }
else if (
fIMPRy[i-1] > amax) {
4403 if (
fAmin < 0)
goto L95;
4404 if (
fISW[1] <= 2)
goto L280;
4406 if (sig2 < ep &&
fEDM < ep)
goto L100;
4410 for (i = 1; i <=
fNpar; ++i) {
4418 if (ystar >=
fAmin)
goto L70;
4420 for (i = 1; i <=
fNpar; ++i) {
4425 if (ystst <
fIMPRy[jl-1])
goto L67;
4433 if (ystar >=
fIMPRy[jh-1])
goto L73;
4436 if (jhold != jh)
goto L50;
4439 for (i = 1; i <=
fNpar; ++i) {
4444 if (ystst >
fIMPRy[jh-1])
goto L30;
4446 if (ystst <
fAmin)
goto L67;
4452 Printf(
" AN IMPROVEMENT ON THE PREVIOUS MINIMUM HAS BEEN FOUND");
4459 for (i = 1; i <=
fNpar; ++i) {
4469 for (i = 1; i <=
fNpar; ++i) {
4487 Printf(
" IMPROVE HAS FOUND A TRULY NEW MINIMUM");
4488 Printf(
" *************************************");
4494 Printf(
" COVARIANCE MATRIX WAS NOT POSITIVE-DEFINITE");
4500 for (i = 1; i <=
fNpar; ++i) {
4509 Printf(
" IMPROVE HAS RETURNED TO REGION OF ORIGINAL MINIMUM");
4513 if (
fISW[1] < 2)
goto L380;
4514 if (loop < nloop &&
fISW[0] < 1)
goto L20;
4530 for (j = 0; j <
fNpar; ++j) {
4550 Double_t piby2, epstry, epsbak, distnn;
4568 fCovmes[0] =
"NO ERROR MATRIX ";
4569 fCovmes[1] =
"ERR MATRIX APPROXIMATE";
4570 fCovmes[2] =
"ERR MATRIX NOT POS-DEF";
4571 fCovmes[3] =
"ERROR MATRIX ACCURATE ";
4589 for (idb = 0; idb <= 10; ++
idb) {
fIdbg[
idb] = 0; }
4609 for (i = 1; i <= 100; ++i) {
4613 if (epsbak < epstry)
goto L35;
4617 Printf(
" MNINIT UNABLE TO DETERMINE ARITHMETIC PRECISION. WILL ASSUME:%g",
fEpsmac);
4640 Int_t kint, i2, newcod, ifx=0, inu;
4646 if (i2 >
fMaxext || i2 < 0)
goto L900;
4647 if (i2 > 0)
goto L30;
4651 for (inu = 1; inu <=
fNu; ++inu) {
4652 if (
fNvarl[inu-1] <= 0)
continue;
4653 if (
fNvarl[inu-1] == 1 && newcod == 1)
continue;
4658 Printf(
" LIMITS NOT CHANGED FOR FIXED PARAMETER:%4d",inu);
4665 Printf(
" LIMITS REMOVED FROM PARAMETER :%3d",inu);
4669 snew =
fGstep[kint-1]*dxdi;
4677 Printf(
" PARAMETER %3d LIMITS SET TO %15.5g%15.5g",inu,
fAlim[inu-1],
fBlim[inu-1]);
4688 Printf(
" PARAMETER %3d IS NOT VARIABLE.", i2);
4694 Printf(
" REQUEST TO CHANGE LIMITS ON FIXED PARAMETER:%3d",i2);
4695 for (ifx = 1; ifx <=
fNpfix; ++ifx) {
4696 if (i2 ==
fIpfix[ifx-1])
goto L92;
4698 Printf(
" MINUIT BUG IN MNLIMS. SEE F. JAMES");
4706 Printf(
" LIMITS REMOVED FROM PARAMETER %2d",i2);
4715 fGrd[kint-1] *= dxdi;
4719 Printf(
" NO LIMITS SPECIFIED. PARAMETER %3d IS ALREADY UNLIMITED. NO CHANGE.",i2);
4728 Printf(
" PARAMETER %3d LIMITS SET TO %15.5g%15.5g",i2,
fAlim[i2-1],
fBlim[i2-1]);
4731 if (kint <= 0)
fGsteps[ifx-1] = -.1;
4732 else fGstep[kint-1] = -.1;
4735 if (
fCstatu !=
"NO CHANGE ") {
4759 Double_t xpq[12], ypq[12], slam, sdev, coeff[3], denom, flast;
4760 Double_t fvals[3], xvals[3],
f1, fvmin, xvmin, ratio,
f2, f3 = 0., fvmax;
4761 Double_t toler8, toler9, overal, undral, slamin, slamax, slopem;
4762 Int_t i, nparx=0, nvmax=0, nxypt, kk, ipt;
4769 l65 = 0; l70 = 0; l80 = 0;
4770 ldebug =
fIdbg[1] >= 1;
4779 Printf(
" MNLINE start point not consistent, F values, parameters=");
4780 for (kk = 1; kk <=
fNpar; ++kk) {
4794 for (i = 1; i <=
fNpar; ++i) {
4795 if (step[i-1] != 0) {
4797 if (slamin == 0) slamin = ratio;
4798 if (ratio < slamin) slamin = ratio;
4800 fX[i-1] = start[i-1] + step[i-1];
4802 if (slamin == 0) slamin =
fEpsmac;
4809 chpq[nxypt-1] =
charal[nxypt-1];
4824 denom = (flast - fstart - slope*slam)*2 / (slam*slam);
4826 if (denom != 0) slam = -slope / denom;
4827 if (slam < 0) slam = slamax;
4828 if (slam > slamax) slam = slamax;
4829 if (slam < toler8) slam = toler8;
4830 if (slam < slamin) {
4834 if (
TMath::Abs(slam - 1) < toler8 && f1 < fstart) {
4838 if (
TMath::Abs(slam - 1) < toler8) slam = toler8 + 1;
4843 for (i = 1; i <=
fNpar; ++i) {
fX[i-1] = start[i-1] + slam*step[i-1]; }
4848 chpq[nxypt-1] =
charal[nxypt-1];
4849 xpq[nxypt-1] = slam;
4855 if (fstart == fvmin) {
4857 toler8 = toler*slam;
4858 overal = slam - toler8;
4861 }
while (fstart == fvmin);
4863 if (!l65 && !l70 && !l80) {
4867 xvals[1] = xpq[nxypt-2];
4868 fvals[1] = ypq[nxypt-2];
4869 xvals[2] = xpq[nxypt-1];
4870 fvals[2] = ypq[nxypt-1];
4874 mnpfit(xvals, fvals, 3, coeff, sdev);
4875 if (coeff[2] <= 0) {
4876 slopem = coeff[2]*2*xvmin + coeff[1];
4877 if (slopem <= 0) slam = xvmin + slamax;
4878 else slam = xvmin - slamax;
4880 slam = -coeff[1] / (coeff[2]*2);
4881 if (slam > xvmin + slamax) slam = xvmin + slamax;
4882 if (slam < xvmin - slamax) slam = xvmin - slamax;
4887 else if (slam < undral)
4894 for (ipt = 1; ipt <= 3; ++ipt) {
4895 if (
TMath::Abs(slam - xvals[ipt-1]) < toler9) {
4906 for (i = 1; i <=
fNpar; ++i) {
fX[i-1] = start[i-1] + slam*step[i-1]; }
4910 chpq[nxypt-1] =
charal[nxypt-1];
4911 xpq[nxypt-1] = slam;
4916 if (fvals[1] > fvmax) {
4920 if (fvals[2] > fvmax) {
4930 if (slam > xvmin) overal =
TMath::Min(overal,slam - toler8);
4931 if (slam < xvmin) undral =
TMath::Max(undral,slam + toler8);
4932 slam = (slam + xvmin)*.5;
4934 }
while (f3 >= fvmax);
4937 if (l65 || l70)
break;
4939 xvals[nvmax-1] = slam;
4940 fvals[nvmax-1] = f3;
4945 if (slam > xvmin) overal =
TMath::Min(overal,slam - toler8);
4946 if (slam < xvmin) undral =
TMath::Max(undral,slam + toler8);
4948 }
while (nxypt < 12);
4954 cmess =
" LINE SEARCH HAS EXHAUSTED THE LIMIT OF FUNCTION CALLS ";
4956 Printf(
" MNLINE DEBUG: steps=");
4957 for (kk = 1; kk <=
fNpar; ++kk) {
4958 Printf(
" %12.4g",step[kk-1]);
4963 if (l70) cmess =
" LINE SEARCH HAS ATTAINED TOLERANCE ";
4964 if (l80) cmess =
" STEP SIZE AT ARITHMETICALLY ALLOWED MINIMUM";
4967 for (i = 1; i <=
fNpar; ++i) {
4968 fDirin[i-1] = step[i-1]*xvmin;
4969 fX[i-1] = start[i-1] +
fDirin[i-1];
4973 mnwarn(
"D",
"MNLINE",
" LINE MINIMUM IN BACKWARDS DIRECTION");
4975 if (fvmin == fstart) {
4976 mnwarn(
"D",
"MNLINE",
" LINE SEARCH FINDS NO IMPROVEMENT ");
4979 Printf(
" AFTER %3d POINTS,%s",nxypt,(
const char*)cmess);
4993 Int_t ndex, i, j,
m,
n, ncoef, nparm,
id, it, ix;
4994 Int_t nsofar, ndi, ndj, iso, isw2, isw5;
5003 Printf(
" MNMATU: NPAR=0");
5017 if (
fNpar <= 1)
return;
5023 Printf(
" PARAMETER CORRELATION COEFFICIENTS ");
5024 ctemp =
" NO. GLOBAL";
5025 for (
id = 1;
id <= nparm; ++
id) {
5028 Printf(
"%s",(
const char*)ctemp);
5029 for (i = 1; i <=
fNpar; ++i) {
5031 ndi = i*(i + 1) / 2;
5032 for (j = 1; j <=
fNpar; ++j) {
5035 ndex = m*(m-1) / 2 + n;
5036 ndj = j*(j + 1) / 2;
5041 for (it = 1; it <= nparm; ++it) {
5044 Printf(
"%s",(
const char*)ctemp);
5045 if (i <= nparm)
continue;
5047 for (iso = 1; iso <= 10; ++iso) {
5050 for (it = nsofar + 1; it <= nparm; ++it) {
5053 Printf(
"%s",(
const char*)ctemp);
5054 if (i <= nparm)
break;
5073 Double_t gdel, gami, vlen, dsum, gssq, vsum, d;
5074 Double_t fzero, fs, ri, delgam, rhotol;
5076 Int_t npfn, ndex, iext, i, j,
m,
n, npsdf, nparx;
5077 Int_t iswtr, lined2, kk, nfcnmg, nrstrt,iter;
5081 if (
fNpar <= 0)
return;
5096 rhotol =
fApsi*.001;
5098 Printf(
" START MIGRAD MINIMIZATION. STRATEGY %2d. CONVERGENCE WHEN EDM .LT.%9.2e",
fIstrat,rhotol);
5113 if (
fISW[1] >= 1)
goto L10;
5121 if (
fISW[1] >= 1)
goto L10;
5123 for (i = 1; i <=
fNpar; ++i) {
5130 for (i = 1; i <=
fNpar; ++i) {
5131 if (
fG2[i-1] > 0)
continue;
5137 mnwarn(
"D",
"MNMIGR",
"Negative G2 line search");
5140 Printf(
" Negative G2 line search, param %3d %13.3g%13.3g",iext,fs,
fAmin);
5146 for (i = 1; i <=
fNpar; ++i) {
5148 for (j = 1; j <= i-1; ++j) {
5153 if (
fG2[i-1] <= 0)
fG2[i-1] = 1;
5158 Printf(
" DEBUG MNMIGR, STARTING MATRIX DIAGONAL, VHMAT=");
5159 for (kk = 1; kk <=
Int_t(vlen); ++kk) {
5173 for (i = 1; i <=
fNpar; ++i) {
5177 for (j = 1; j <= i-1; ++j) {
5186 mnwarn(
"W",
"MIGRAD",
"STARTING MATRIX NOT POS-DEFINITE.");
5196 if (iswtr >= 2)
mnmatu(0);
5202 for (i = 1; i <=
fNpar; ++i) {
5205 for (j = 1; j <=
fNpar; ++j) {
5208 ndex = m*(m-1) / 2 + n;
5209 ri +=
fVhmat[ndex-1]*fMIGRgs[j-1];
5215 mnwarn(
"D",
"MIGRAD",
" FIRST DERIVATIVES OF FCN ARE ALL ZERO");
5220 mnwarn(
"D",
"MIGRAD",
" NEWTON STEP NOT DESCENT.");
5221 if (npsdf == 1)
goto L1;
5228 if (
fAmin == fs)
goto L200;
5245 for (i = 1; i <=
fNpar; ++i) {
5248 for (j = 1; j <=
fNpar; ++j) {
5251 ndex = m*(m-1) / 2 + n;
5257 gdgssq += gami*gami;
5259 delgam +=
fDirin[i-1]*gami;
5264 if (
fEDM < 0 || gvg <= 0) {
5265 mnwarn(
"D",
"MIGRAD",
"NOT POS-DEF. EDM OR GVG NEGATIVE.");
5267 if (npsdf == 1)
goto L230;
5274 if (iswtr >= 3 || (iswtr == 2 && iter % 10 == 1)) {
5279 mnwarn(
"D",
"MIGRAD",
"NO CHANGE IN FIRST DERIVATIVES OVER LAST STEP");
5282 mnwarn(
"D",
"MIGRAD",
"FIRST DERIVATIVES INCREASING ALONG SEARCH LINE");
5288 for (kk = 1; kk <= 10; ++kk) {
5294 for (i = 1; i <=
fNpar; ++i) {
5295 for (j = 1; j <= i; ++j) {
5296 if(delgam == 0 || gvg == 0) d = 0;
5299 ndex = i*(i-1) / 2 + j;
5306 if (iswtr >= 3 || ldebug) {
5307 Printf(
" RELATIVE CHANGE IN COV. MATRIX=%5.1f per cent",
fDcovar*100);
5311 for (kk = 1; kk <= 10; ++kk) {
5315 if (delgam <= gvg)
goto L135;
5316 for (i = 1; i <=
fNpar; ++i) {
5319 for (i = 1; i <=
fNpar; ++i) {
5320 for (j = 1; j <= i; ++j) {
5321 ndex = i*(i-1) / 2 + j;
5327 if (
fEDM < rhotol*.1)
goto L300;
5329 for (i = 1; i <=
fNpar; ++i) {
5343 Printf(
" CALL LIMIT EXCEEDED IN MIGRAD.");
5350 Printf(
" MIGRAD FAILS TO FIND IMPROVEMENT");
5353 if (
fEDM < rhotol)
goto L300;
5356 Printf(
" MACHINE ACCURACY LIMITS FURTHER IMPROVEMENT.");
5362 Printf(
" MIGRAD FAILS WITH STRATEGY=0. WILL TRY WITH STRATEGY=1.");
5370 Printf(
" MIGRAD TERMINATED WITHOUT CONVERGENCE.");
5378 Printf(
" MIGRAD MINIMIZATION HAS CONVERGED.");
5383 Printf(
" MIGRAD WILL VERIFY CONVERGENCE AND ERROR MATRIX.");
5388 if (
fEDM > rhotol)
goto L10;
5399 if (iswtr >= 0)
mnprin(3, fAmin);
5400 if (iswtr >= 1)
mnmatu(1);
5414 Int_t nbad, ilax, ilax2, ngood, nfcnmi, iin, knt;
5416 if (
fNpar <= 0)
goto L700;
5421 for (knt = 1; knt <=
fNpar; ++knt) {
5425 if (knt >= 7)
break;
5427 if (ilax == 0)
break;
5428 if (ilax > 0 && ilax <=
fNu) {
5429 if (
fNiofex[ilax-1] > 0)
goto L565;
5431 Printf(
" PARAMETER NUMBER %3d NOT A VARIABLE. IGNORED.",ilax);
5437 mnmnot(ilax, ilax2, val2pl, val2mi);
5441 if (
fErp[iin-1] > 0) ++ngood;
5443 if (
fErn[iin-1] < 0) ++ngood;
5451 if (ngood == 0 && nbad == 0)
goto L700;
5452 if (ngood > 0 && nbad == 0)
fCstatu =
"SUCCESSFUL";
5453 if (ngood == 0 && nbad > 0)
fCstatu =
"FAILURE ";
5454 if (ngood > 0 && nbad > 0)
fCstatu =
"PROBLEMS ";
5464 Printf(
" NEW MINIMUM FOUND. GO BACK TO MINIMIZATION STEP.");
5465 Printf(
" =================================================");
5475 Printf(
" THERE ARE NO MINOS ERRORS TO CALCULATE.");
5492 Double_t abest, xunit, dc, ut, sigsav, du1;
5494 Int_t marc, isig, mpar, ndex, imax, indx, ierr, i, j;
5495 Int_t iercr, it, istrav, nfmxin, nlimit, isw2, isw4;
5509 for (i = 1; i <= mpar; ++i) {
fXt[i-1] =
fX[i-1]; }
5510 i__1 = mpar*(mpar + 1) / 2;
5512 for (i = 1; i <= mpar; ++i) {
5521 if (
fNvarl[ilax-1] == 1) {
5523 fBlim[ilax-1] = ut + fMNOTw[it-1]*100;
5525 ndex = it*(it + 1) / 2;
5528 for (i = 1; i <= mpar; ++i) {
5529 if (i == it)
continue;
5538 Printf(
" MINUIT ERROR. CANNOT FIX PARAMETER %4d INTERNAL %3d",ilax,it);
5544 for (isig = 1; isig <= 2; ++isig) {
5554 Printf(
" DETERMINATION OF %sTIVE MINOS ERROR FOR PARAMETER %d %s" 5555 ,(
const char*)csig,ilax
5556 ,(
const char*)
fCpnam[ilax-1]);
5559 mnwarn(
"D",
"MINOS",
"NO COVARIANCE MATRIX.");
5561 nlimit =
fNfcn + nfmxin;
5564 fU[ilax-1] = ut + sig*du1;
5567 delu =
fU[ilax-1] - ut;
5570 fac = delu /
fMNOTw[it-1];
5571 for (i = 1; i <=
fNpar; ++i) {
5575 Printf(
" PARAMETER %4d SET TO%11.3e + %10.3e = %12.3e",ilax,ut,delu,
fU[ilax-1]);
5586 if (abest -
fAmin >
fUp*.01)
goto L650;
5587 if (iercr == 1)
goto L440;
5588 if (iercr == 2)
goto L450;
5589 if (iercr == 3)
goto L460;
5593 Printf(
" THE %4sTIVE MINOS ERROR OF PARAMETER %3d %10s, IS %12.4e" 5594 ,(
const char*)csig,ilax
5595 ,(
const char*)
fCpnam[ilax-1],eros);
5601 Printf(
" THE %4sTIVE MINOS ERROR OF PARAMETER %3d, %s EXCEEDS ITS LIMIT." 5602 ,(
const char*)csig,ilax
5603 ,(
const char*)
fCpnam[ilax-1]);
5609 Printf(
" THE %4sTIVE MINOS ERROR %4d REQUIRES MORE THAN %5d FUNCTION CALLS." 5610 ,(
const char*)csig,ilax,nfmxin);
5616 Printf(
" %4sTIVE MINOS ERROR NOT CALCULATED FOR PARAMETER %d" 5617 ,(
const char*)csig,ilax);
5623 Printf(
" **************************************************************************");
5627 if (ilax2 > 0 && ilax2 <=
fNu) val2mi =
fU[ilax2-1];
5630 if (ilax2 > 0 && ilax2 <=
fNu) val2pl =
fU[ilax2-1];
5637 i__1 = mpar*(mpar + 1) / 2;
5639 for (i = 1; i <= mpar; ++i) {
5688 Double_t vplu, a_small, gsmin, pinti, vminu, danger, sav, sav2;
5689 Int_t ierr, kint, in, ix, ktofix, lastin, kinfix, nvl;
5697 Printf(
" MINUIT USER ERROR. PARAMETER NUMBER IS %3d ALLOWED RANGE IS ONE TO %4d",k,fMaxext);
5702 if (
fNvarl[k-1] < 0)
goto L50;
5705 for (ix = 1; ix <=
fNpfix; ++ix) {
5706 if (
fIpfix[ix-1] == k) ktofix = k;
5709 mnwarn(
"W",
"PARAM DEF",
"REDEFINING A FIXED PARAMETER.");
5711 Printf(
" CANNOT RELEASE. MAX NPAR EXCEEDED.");
5722 Printf(
" PARAMETER DEFINITIONS:");
5723 Printf(
" NO. NAME VALUE STEP SIZE LIMITS");
5726 if (wk > 0)
goto L122;
5729 Printf(
" %5d %-10s %13.5e constant",k,(
const char*)cnamk,uk);
5734 if (a == 0 && b == 0) {
5738 Printf(
" %5d %-10s %13.5e%13.5e no limits",k,(
const char*)cnamk,uk,wk);
5745 Printf(
" %5d %-10s %13.5e%13.5e %13.5e%13.5e",k,(
const char*)cnamk,uk,wk,a,b);
5751 Printf(
" MINUIT USER ERROR. TOO MANY VARIABLE PARAMETERS.");
5754 if (nvl == 1)
goto L200;
5756 Printf(
" USER ERROR IN MINUIT PARAMETER");
5758 Printf(
" UPPER AND LOWER LIMITS EQUAL.");
5765 mnwarn(
"W",
"PARAM DEF",
"PARAMETER LIMITS WERE REVERSED.");
5772 danger = (b - uk)*(uk - a);
5774 mnwarn(
"W",
"PARAM DEF",
"STARTING VALUE OUTSIDE LIMITS.");
5777 mnwarn(
"W",
"PARAM DEF",
"STARTING VALUE IS AT LIMIT.");
5795 for (ix = 1; ix <= k-1; ++ix) {
if (
fNiofex[ix-1] > 0) ++lastin; }
5797 if (kint ==
fNpar)
goto L280;
5800 for (in =
fNpar; in >= lastin + 1; --in) {
5814 for (in = lastin + 1; in <= kint; ++in) {
5837 mnpint(sav, ix-1, pinti);
5839 fXt[in-1] =
fX[in-1];
5842 mnpint(sav2, ix-1, pinti);
5843 vplu = pinti -
fX[in-1];
5845 mnpint(sav2, ix-1, pinti);
5846 vminu = pinti - fX[in-1];
5865 if (kinfix > 0)
mnfixp(kinfix-1, ierr);
5866 if (ierr > 0)
goto L800;
5891 Int_t ierr, kapo1, kapo2;
5892 Int_t k, llist, ibegin, lenbuf, istart, lnc, icy;
5893 TString cnamk, comand, celmnt, ctemp;
5896 lenbuf = strlen((
const char*)crdbuf);
5898 kapo1 = strspn((
const char*)crdbuf,
"'");
5899 if (kapo1 == 0)
goto L150;
5900 kapo2 = strspn((
const char*)crdbuf + kapo1,
"'");
5901 if (kapo2 == 0)
goto L150;
5905 for (istart = 1; istart <= kapo1-1; ++istart) {
5906 if (crdbuf(istart-1,1) !=
' ')
goto L120;
5911 celmnt = crdbuf(istart-1, kapo1-istart);
5912 if (scanf((
const char*)celmnt,&fk)) {;}
5914 if (k <= 0)
goto L210;
5915 cnamk =
"PARAM " + celmnt;
5916 if (kapo2 - kapo1 > 1) {
5917 cnamk = crdbuf(kapo1, kapo2-1-kapo1);
5920 for (icy = kapo2 + 1; icy <= lenbuf; ++icy) {
5921 if (crdbuf(icy-1,1) ==
',')
goto L139;
5922 if (crdbuf(icy-1,1) !=
' ')
goto L140;
5933 ctemp = crdbuf(ibegin-1,lenbuf-ibegin);
5935 if (ierr > 0)
goto L180;
5946 if (scanf((
const char*)crdbuf,&xk,stmp,&uk,&wk,&a,&
b)) {;}
5949 if (k == 0)
goto L210;
5952 mnparm(k-1, cnamk, uk, wk, a,
b, ierr);
5979 Double_t a,
f, s, t,
y, s2,
x2,
x3,
x4, y2, cz[3], xm,
xy, x2y;
5989 for (i = 1; i <= 3; ++i) { cz[i-1] = 0; }
5991 if (npar2p < 3)
goto L10;
5995 for (i = 1; i <= npar2p; ++i) { xm += parx2p[i]; }
6004 for (i = 1; i <= npar2p; ++i) {
6016 a = (f*x4 - x2*
x2)*x2 - f*(x3*x3);
6017 if (a == 0)
goto L10;
6018 cz[2] = (x2*(f*x2y - x2*
y) - f*x3*xy) /
a;
6019 cz[1] = (xy - x3*cz[2]) / x2;
6020 cz[0] = (y - x2*cz[2]) / f;
6021 if (npar2p == 3)
goto L6;
6022 sdev2p = y2 - (cz[0]*y + cz[1]*xy + cz[2]*x2y);
6023 if (sdev2p < 0) sdev2p = 0;
6026 cz[0] += xm*(xm*cz[2] - cz[1]);
6027 cz[1] -= xm*2*cz[2];
6029 for (i = 1; i <= 3; ++i) { coef2p[i] = cz[i-1]; }
6051 yy = (pexti - alimi)*2 / (blimi - alimi) - 1;
6056 chbuf2 =
" IS AT ITS LOWER ALLOWED LIMIT.";
6059 chbuf2 =
" IS AT ITS UPPER ALLOWED LIMIT.";
6062 pexti = alimi + (blimi - alimi)*.5*(
TMath::Sin(a) + 1);
6064 if (yy2 > 1) chbuf2 =
" BROUGHT BACK INSIDE LIMITS.";
6093 if ((h =
gROOT->GetPluginManager()->FindHandler(
"TMinuitGraph"))) {
6106 Double_t bwidx, bwidy, xbest, ybest, ax, ay, bx, by;
6107 Double_t xvalus[12], any, dxx, dyy;
6108 Int_t iten, i, j, k, maxnx, maxny, iquit, ni, linodd;
6109 Int_t nxbest, nybest, km1, ibk, isp1,
nx,
ny, ks, ix;
6118 if (maxnx < 10) maxnx = 10;
6120 if (maxny < 10) maxny = 10;
6121 if (nxypt <= 1)
return;
6127 for (i = 1; i <= km1; ++i) {
6130 for (j = 1; j <= ni; ++j) {
6131 if (ypt[j-1] > ypt[j])
continue;
6143 if (iquit == 0)
break;
6148 for (i = 1; i <= nxypt; ++i) {
6149 if (xpt[i-1] > xmax) xmax = xpt[i-1];
6150 if (xpt[i-1] < xmin) xmin = xpt[i-1];
6152 dxx = (xmax -
xmin)*.001;
6155 mnbins(xmin, xmax, maxnx, xmin, xmax, nx, bwidx);
6157 ymin = ypt[nxypt-1];
6158 if (ymax == ymin) ymax = ymin + 1;
6159 dyy = (ymax -
ymin)*.001;
6162 mnbins(ymin, ymax, maxny, ymin, ymax, ny, bwidy);
6165 if (chbest ==
' ')
goto L50;
6166 xbest = (xmax +
xmin)*.5;
6167 ybest = (ymax +
ymin)*.5;
6175 for (i = 1; i <= nxypt; ++i) {
6176 xpt[i-1] = ax*xpt[i-1] + bx;
6177 ypt[i-1] = any - ay*ypt[i-1] - by;
6179 nxbest =
Int_t((ax*xbest + bx));
6180 nybest =
Int_t((any - ay*ybest - by));
6187 for (i = 1; i <=
ny; ++i) {
6188 for (ibk = 1; ibk <=
nx; ++ibk) { cline[ibk-1] =
' '; }
6193 if (nx>0) cline[nx-1] =
'.';
6194 cline[nxbest-1] =
'.';
6195 if (i != 1 && i != nybest && i != ny)
goto L320;
6196 for (j = 1; j <=
nx; ++j) { cline[j-1] =
'.'; }
6199 if (isp1 > nxypt)
goto L350;
6201 for (k = isp1; k <= nxypt; ++k) {
6202 ks =
Int_t(ypt[k-1]);
6203 if (ks > i)
goto L345;
6204 ix =
Int_t(xpt[k-1]);
6205 if (cline[ix-1] ==
'.')
goto L340;
6206 if (cline[ix-1] ==
' ')
goto L340;
6207 if (cline[ix-1] == chpt[k-1])
continue;
6214 cline[ix-1] = chpt[k-1];
6221 if (linodd == 1 || i == ny)
goto L380;
6224 Printf(
" %s",(
const char*)ctemp);
6228 Printf(
" %14.7g ..%s",yprt,(
const char*)ctemp);
6234 for (ibk = 1; ibk <=
nx; ++ibk) {
6236 if (ibk % 10 == 1) cline[ibk-1] =
'/';
6240 for (ibk = 1; ibk <= 12; ++ibk) {
6241 xvalus[ibk-1] = xmin +
Double_t(ibk-1)*10*bwidx;
6243 iten = (nx + 9) / 10;
6244 for (ibk = 1; ibk <= iten && ibk <= 12; ++ibk) {
6245 snprintf(cline + (ibk-1)*10, 11-(ibk == 12),
"%#9.3g ", xvalus[ibk-1]);
6249 if (overpr) chmess =
" Overprint character is &";
6250 Printf(
" ONE COLUMN=%13.7g%s",bwidx,(
const char*)chmess);
6273 Int_t iint, iext, nvl;
6275 Int_t iuext = iuext1 + 1;
6279 if (iuext == 0)
goto L100;
6283 if (iint >
fNpar)
goto L100;
6289 if (iext >
fNu)
goto L100;
6295 if (nvl < 0)
goto L100;
6298 if (iint > 0) err =
fWerr[iint-1];
6300 xlolim =
fAlim[iext-1];
6301 xuplim =
fBlim[iext-1];
6307 chnam =
"undefined";
6337 Int_t nadd, i, k,
l,
m, ikode, ic, nc, ntrail, lbl;
6339 TString colhdl[6], colhdu[6], cx2, cx3, cheval;
6342 Printf(
" THERE ARE CURRENTLY NO PARAMETERS DEFINED");
6348 ikode =
fISW[1] + 1;
6349 if (ikode > 3) ikode = 3;
6352 for (k = 1; k <= 6; ++k) {
6353 colhdu[k-1] =
"UNDEFINED";
6354 colhdl[k-1] =
"COLUMN HEAD";
6361 if (fval ==
fUndefi) cheval =
" unknown ";
6362 else cheval.
Form(
"%g",fval);
6368 Printf(
" FCN=%s FROM %8s STATUS=%10s %6d CALLS %9d TOTAL" 6369 ,(
const char*)cheval
6373 if (m == 0 || m == 2 ||
fDcovar == 0) {
6374 Printf(
" EDM=%s STRATEGY=%2d %s" 6380 Printf(
" EDM=%s STRATEGY=%2d ERROR MATRIX UNCERTAINTY %5.1f per cent" 6381 ,(
const char*)chedm,
fIstrat,dc);
6384 if (ikode == 0)
return;
6387 for (i = 1; i <=
fNu; ++i) {
6388 if (
fNvarl[i-1] < 0)
continue;
6389 for (ic = 10; ic >= 1; --ic) {
6390 if (
fCpnam[i-1](ic-1,1) !=
" ")
goto L16;
6395 if (lbl < ntrail) ntrail = lbl;
6397 nadd = ntrail / 2 + 1;
6400 colhdl[0] =
" ERROR ";
6401 colhdu[1] =
" PHYSICAL";
6402 colhdu[2] =
" LIMITS ";
6403 colhdl[1] =
" NEGATIVE ";
6404 colhdl[2] =
" POSITIVE ";
6408 colhdl[0] =
" ERROR ";
6409 colhdu[1] =
" INTERNAL ";
6410 colhdl[1] =
" STEP SIZE ";
6411 colhdu[2] =
" INTERNAL ";
6412 colhdl[2] =
" VALUE ";
6416 colhdl[0] =
" ERROR ";
6417 colhdu[1] =
" STEP ";
6418 colhdl[1] =
" SIZE ";
6419 colhdu[2] =
" FIRST ";
6420 colhdl[2] =
" DERIVATIVE ";
6423 colhdu[0] =
" PARABOLIC ";
6424 colhdl[0] =
" ERROR ";
6425 colhdu[1] =
" MINOS ";
6426 colhdu[2] =
"ERRORS ";
6427 colhdl[1] =
" NEGATIVE ";
6428 colhdl[2] =
" POSITIVE ";
6432 if (
fISW[1] < 3) colhdu[0] =
" APPROXIMATE ";
6433 if (
fISW[1] < 1) colhdu[0] =
" CURRENT GUESS";
6435 Printf(
" EXT PARAMETER %-14s%-14s%-14s",(
const char*)colhdu[0]
6436 ,(
const char*)colhdu[1]
6437 ,(
const char*)colhdu[2]);
6438 Printf(
" NO. NAME VALUE %-14s%-14s%-14s",(
const char*)colhdl[0]
6439 ,(
const char*)colhdl[1]
6440 ,(
const char*)colhdl[2]);
6442 for (i = 1; i <=
fNu; ++i) {
6443 if (
fNvarl[i-1] < 0)
continue;
6445 cnambf = cblank(0,nadd) +
fCpnam[i-1];
6446 if (l == 0)
goto L55;
6449 cx2 =
"PLEASE GET X..";
6450 cx3 =
"PLEASE GET X..";
6453 Printf(
"%4d %-11s%14.5e%14.5e",i,(
const char*)cnambf,
fU[i-1],x1);
6468 cx3 =
"** at limit **";
6473 if (x2 == 0) cx2 =
" ";
6474 if (x2 ==
fUndefi) cx2 =
" at limit ";
6476 if (x3 == 0) cx3 =
" ";
6477 if (x3 ==
fUndefi) cx3 =
" at limit ";
6479 if (cx2 ==
"PLEASE GET X..") cx2.
Form(
"%14.5e",x2);
6480 if (cx3 ==
"PLEASE GET X..") cx3.
Form(
"%14.5e",x3);
6481 Printf(
"%4d %-11s%14.5e%14.5e%-14s%-14s",i
6482 ,(
const char*)cnambf,
fU[i-1],x1
6483 ,(
const char*)cx2,(
const char*)cx3);
6486 if (
fNvarl[i-1] <= 1 || ikode == 3)
continue;
6488 Printf(
" WARNING - - ABOVE PARAMETER IS AT LIMIT.");
6494 colhdu[0] =
" constant ";
6495 if (
fNvarl[i-1] > 0) colhdu[0] =
" fixed ";
6496 if (
fNvarl[i-1] == 4 && ikode == 1) {
6497 Printf(
"%4d %-11s%14.5e%-14s%14.5e%14.5e",i
6498 ,(
const char*)cnambf,
fU[i-1]
6499 ,(
const char*)colhdu[0],
fAlim[i-1],
fBlim[i-1]);
6501 Printf(
"%4d %-11s%14.5e%s",i
6502 ,(
const char*)cnambf,
fU[i-1],(
const char*)colhdu[0]);
6520 Double_t dgmin, padd, pmin, pmax, dg, epspdf, epsmin;
6521 Int_t ndex, i, j, ndexd, ip, ifault;
6528 for (i = 1; i <=
fNpar; ++i) {
6529 ndex = i*(i + 1) / 2;
6530 if (
fVhmat[ndex-1] <= 0) {
6536 dg = epspdf + 1 - dgmin;
6542 for (i = 1; i <=
fNpar; ++i) {
6546 if (
fVhmat[ndexd-1]==0) {
6551 for (j = 1; j <= i; ++j) {
6560 for (ip = 2; ip <=
fNpar; ++ip) {
6566 Printf(
" EIGENVALUES OF SECOND-DERIVATIVE MATRIX:");
6568 for (ip = 1; ip <=
fNpar; ++ip) {
6573 if (pmin > epspdf*pmax)
return;
6575 padd = pmax*.001 - pmin;
6576 for (ip = 1; ip <=
fNpar; ++ip) {
6577 ndex = ip*(ip + 1) / 2;
6578 fVhmat[ndex-1] *= padd + 1;
6581 mnwarn(
"W",
fCfrom,
Form(
"MATRIX FORCED POS-DEF BY ADDING %f TO DIAGONAL.",padd));
6601 for (i = 1; i <=
fNpar; ++i) {
fX[i-1] = pnew[i-1]; }
6609 for (j = 2; j <= nparp1; ++j) {
if (y[j-1] > y[jh-1]) jh = j; }
6610 fEDM = y[jh-1] - y[jl-1];
6611 if (
fEDM <= 0)
goto L45;
6612 for (i = 1; i <=
fNpar; ++i) {
6615 for (j = 2; j <= nparp1; ++j) {
6619 fDirin[i-1] = pbig - plit;
6624 Printf(
" FUNCTION VALUE DOES NOT SEEM TO DEPEND ON ANY OF THE %d VARIABLE PARAMETERS.",
fNpar);
6625 Printf(
" VERIFY THAT STEP SIZES ARE BIG ENOUGH AND CHECK FCN LOGIC.");
6626 Printf(
" *******************************************************************************");
6627 Printf(
" *******************************************************************************");
6644 static Int_t iseed = 12345;
6648 if (val == 3)
goto L100;
6651 iseed = (iseed - k*53668)*40014 - k*12211;
6652 if (iseed < 0) iseed += 2147483563;
6683 for (i = 1; i <=
fNpar; ++i) {
6704 Printf(
"mnsave is dummy in TMinuit");
6718 Double_t step, uhigh, xhreq, xlreq, ubest, fnext, unext, xh, xl;
6720 Int_t nxypt, nccall, iparwd;
6725 if (ncall <= 1) ncall = 41;
6726 if (ncall > 98) ncall = 98;
6732 if (iparwd > 0)
goto L200;
6737 if (ipar >
fNu)
goto L900;
6739 if (iint <= 0)
goto L100;
6751 if (
fNvarl[ipar-1] > 1)
goto L300;
6754 if (xlreq == xhreq)
goto L250;
6756 step = (xhreq - xlreq) /
Double_t(ncall-1);
6759 xl = ubest -
fWerr[iint-1];
6760 xh = ubest + fWerr[iint-1];
6761 mnbins(xl, xh, ncall, unext, uhigh, nbins, step);
6766 if (xlreq == xhreq)
goto L350;
6771 if (xl >= xh)
goto L700;
6773 step = (xh - xl) /
Double_t(ncall-1);
6776 unext =
fAlim[ipar-1];
6780 for (icall = 1; icall <= nccall; ++icall) {
6785 fXpt[nxypt-1] = unext;
6786 fYpt[nxypt-1] = fnext;
6787 fChpt[nxypt-1] =
'*';
6788 if (fnext <
fAmin) {
6801 Printf(
"%dSCAN OF PARAMETER NO. %d, %s" 6806 Printf(
" REQUESTED RANGE OUTSIDE LIMITS FOR PARAMETER %d",ipar);
6808 if (iparwd <= 0)
goto L100;
6828 Double_t dxdi, rnum, ftry, rnum1, rnum2, alpha;
6830 Int_t ipar, iext, j, ifail, iseed=0, nparx, istep, ib, mxfail, mxstep;
6833 if (mxfail <= 0) mxfail =
fNpar*20 + 100;
6837 if (alpha <= 0) alpha = 3;
6839 Printf(
" MNSEEK: MONTE CARLO MINIMIZATION USING METROPOLIS ALGORITHM");
6840 Printf(
" TO STOP AFTER %6d SUCCESSIVE FAILURES, OR %7d STEPS",mxfail,mxstep);
6841 Printf(
" MAXIMUM STEP SIZE IS %9.3f ERROR BARS.",alpha);
6853 for (ipar = 1; ipar <=
fNpar; ++ipar) {
6856 if (
fNvarl[iext-1] > 1) {
6859 if (dxdi == 0) dxdi = 1;
6860 fDirin[ipar-1] = alpha*2*fWerr[ipar-1] / dxdi;
6862 fDirin[ipar-1] = 6.2831859999999997;
6869 for (istep = 1; istep <= mxstep; ++istep) {
6870 if (ifail >= mxfail)
break;
6871 for (ipar = 1; ipar <=
fNpar; ++ipar) {
6901 Printf(
" MNSEEK: %5d SUCCESSIVE UNSUCCESSFUL TRIALS.",ifail);
6924 static const char *cname[30] = {
6956 static Int_t nname = 25;
6957 static Int_t nntot = 30;
6959 "-1: NO OUTPUT EXCEPT FROM SHOW ",
6960 " 0: REDUCED OUTPUT ",
6961 " 1: NORMAL OUTPUT ",
6962 " 2: EXTRA OUTPUT FOR PROBLEM CASES",
6963 " 3: MAXIMUM OUTPUT "};
6966 " 0: MINIMIZE THE NUMBER OF CALLS TO FUNCTION",
6967 " 1: TRY TO BALANCE SPEED AGAINST RELIABILITY",
6968 " 2: MAKE SURE MINIMUM TRUE, ERRORS CORRECT "};
6971 "REPORT ALL EXCEPTIONAL CONDITIONS ",
6972 "MNLINE: LINE SEARCH MINIMIZATION ",
6973 "MNDERI: FIRST DERIVATIVE CALCULATIONS ",
6974 "MNHESS: SECOND DERIVATIVE CALCULATIONS ",
6975 "MNMIGR: COVARIANCE MATRIX UPDATES ",
6976 "MNHES1: FIRST DERIVATIVE UNCERTAINTIES ",
6977 "MNCONT: MNCONTOUR PLOT (MNCROS SEARCH) "};
6984 Int_t iset, iprm, i, jseed, kname, iseed, iunit,
id, ii, kk;
6985 Int_t ikseed, idbopt, igrain=0, iswsav, isw2;
6986 TString cfname, cmode, ckind, cwarn, copt, ctemp, ctemp2;
6989 for (i = 1; i <= nntot; ++i) {
6993 if (strstr(ctemp2.
Data(),ckind.
Data()))
goto L5;
7001 if ( ctemp2.
Contains(
"HEL"))
goto L2000;
7002 if ( ctemp2.
Contains(
"SHO"))
goto L1000;
7003 if (!ctemp2.
Contains(
"SET"))
goto L1900;
7007 if (kname <= 0)
goto L1900;
7009 switch ((
int)kname) {
7027 case 18:
goto L3000;
7029 case 20:
goto L3000;
7034 case 25:
goto L3000;
7035 case 26:
goto L1900;
7045 if (iprm >
fNu)
goto L25;
7046 if (iprm <= 0)
goto L25;
7047 if (
fNvarl[iprm-1] < 0)
goto L25;
7059 Printf(
" UNDEFINED PARAMETER NUMBER. IGNORED.");
7090 for (i = 1; i <=
fNpar; ++i) {
7118 mnwarn(
"W",
"SHO",
"SHO");
7126 Printf(
" MINUIT RANDOM NUMBER SEED SET TO %d",jseed);
7138 if (
fISW[4] > 0)
goto L1172;
7156 if (
fISW[4] >= 0)
goto L1220;
7161 if (
fISW[4] >= 0)
goto L1100;
7166 if (
fISW[4] >= 0)
goto L1100;
7177 if (idbopt > 6)
goto L288;
7179 fIdbg[idbopt] = iset;
7180 if (iset == 1)
fIdbg[0] = 1;
7183 for (
id = 0;
id <= 6; ++
id) {
fIdbg[
id] = iset; }
7186 mnwarn(
"D",
"SHO",
"SHO");
7189 Printf(
" UNKNOWN DEBUG OPTION %d REQUESTED. IGNORED",idbopt);
7200 if (kname <= 0)
goto L1900;
7202 switch ((
int)kname) {
7212 case 10:
goto L1100;
7213 case 11:
goto L1110;
7214 case 12:
goto L1120;
7215 case 13:
goto L1130;
7216 case 14:
goto L1130;
7217 case 15:
goto L1150;
7218 case 16:
goto L1160;
7219 case 17:
goto L1170;
7220 case 18:
goto L1180;
7221 case 19:
goto L1190;
7222 case 20:
goto L1200;
7223 case 21:
goto L1210;
7224 case 22:
goto L1220;
7225 case 23:
goto L1100;
7226 case 24:
goto L1100;
7227 case 25:
goto L1250;
7228 case 26:
goto L1900;
7229 case 27:
goto L1270;
7230 case 28:
goto L1270;
7231 case 29:
goto L1290;
7232 case 30:
goto L1300;
7262 Printf(
" ALLOWED PRINT LEVELS ARE:");
7268 Printf(
" CURRENT PRINTOUT LEVEL IS %s",cprlev[
fISW[4]+1].
Data());
7273 Printf(
" NOGRAD IS SET. DERIVATIVES NOT COMPUTED IN FCN.");
7275 Printf(
" GRAD IS SET. USER COMPUTES DERIVATIVES IN FCN.");
7280 Printf(
" ERRORS CORRESPOND TO FUNCTION CHANGE OF %g",
fUp);
7304 cmode =
"BATCH MODE ";
7305 if (
fISW[5] == 1) cmode =
"INTERACTIVE MODE";
7306 if (! lname) cfname =
"unknown";
7307 Printf(
" INPUT NOW BEING READ IN %s FROM UNIT NO. %d FILENAME: %s" 7308 ,(
const char*)cmode,
fIsysrd,(
const char*)cfname);
7320 cwarn =
"SUPPRESSED";
7321 if (
fLwarn) cwarn =
"REPORTED ";
7322 Printf(
"%s",(
const char*)cwarn);
7330 Printf(
" MINUIT RNDM SEED IS CURRENTLY=%d",ikseed);
7337 Printf(
" TITLE OF CURRENT TASK IS:%s",(
const char*)
fCtitl);
7341 Printf(
" ALLOWED STRATEGIES ARE:");
7346 Printf(
" NOW USING STRATEGY %s",(
const char*)cstrat[
fIstrat]);
7363 Printf(
" NO PAGE THROWS IN MINUIT OUTPUT");
7368 for (ii = 1; ii <=
fNpar; ++ii) {
7369 if (
fErp[ii-1] > 0 ||
fErn[ii-1] < 0)
goto L1204;
7371 Printf(
" THERE ARE NO MINOS ERRORS CURRENTLY VALID.");
7378 Printf(
" FLOATING-POINT NUMBERS ASSUMED ACCURATE TO %g",
fEpsmac);
7386 Printf(
" THIS IS MINUIT VERSION:%s",(
const char*)
fCvrsn);
7390 for (
id = 0;
id <= 6; ++
id) {
7392 if (
fIdbg[
id] >= 1) copt =
"ON ";
7393 Printf(
" DEBUG OPTION %3d IS %3s :%s" 7394 ,
id,(
const char*)copt,(
const char*)cdbopt[
id]);
7409 Printf(
" THE COMMAND:%10s IS UNKNOWN.",(
const char*)
fCword);
7416 if (strcmp(ctemp2.
Data(),
"SHO")) ckind =
"SHOW";
7418 Printf(
" THE FORMAT OF THE %4s COMMAND IS:",(
const char*)ckind);
7419 Printf(
" %s xxx [numerical arguments if any]",(
const char*)ckind);
7420 Printf(
" WHERE xxx MAY BE ONE OF THE FOLLOWING:");
7421 for (kk = 1; kk <= nname; ++kk) {
7422 Printf(
" %s",cname[kk-1]);
7428 Printf(
" ABOVE COMMAND IS ILLEGAL. IGNORED");
7449 Double_t dmin_, dxdi, yrho,
f, ynpp1, aming, ypbar;
7450 Double_t bestx, ystar, y1, y2, ystst, pb, wg;
7451 Double_t absmin, rho, sig2, rho1, rho2;
7452 Int_t npfn, i, j, k, jhold, ncycl, nparx;
7453 Int_t nparp1, kg, jh, nf, jl, ns;
7455 if (
fNpar <= 0)
return;
7464 rho2 = rho1 + alpha*
gamma;
7467 Printf(
" START SIMPLEX MINIMIZATION. CONVERGENCE WHEN EDM .LT. %g",
fEpsi);
7469 for (i = 1; i <=
fNpar; ++i) {
7482 for (i = 1; i <=
fNpar; ++i) {
7493 if (f <= aming)
goto L6;
7495 if (kg == 1)
goto L8;
7499 if (nf < 3)
goto L4;
7509 if (ns < 6)
goto L4;
7513 if (aming < absmin) jl = i;
7514 if (aming < absmin) absmin = aming;
7534 for (i = 1; i <=
fNpar; ++i) {
7542 if (ystar >=
fAmin)
goto L70;
7544 for (i = 1; i <=
fNpar; ++i) {
7550 y1 = (ystar -
fSIMPy[jh-1])*rho2;
7551 y2 = (ystst -
fSIMPy[jh-1])*rho1;
7552 rho = (rho2*y1 - rho1*y2)*.5 / (y1 - y2);
7553 if (rho < rhomin)
goto L66;
7554 if (rho > rhomax) rho = rhomax;
7555 for (i = 1; i <=
fNpar; ++i) {
7560 if (yrho <
fSIMPy[jl-1] && yrho < ystst)
goto L65;
7561 if (ystst <
fSIMPy[jl-1])
goto L67;
7562 if (yrho >
fSIMPy[jl-1])
goto L66;
7568 if (ystst <
fSIMPy[jl-1])
goto L67;
7575 if (
fISW[4] < 2)
goto L50;
7576 if (
fISW[4] >= 3 || ncycl % 10 == 0) {
7582 if (ystar >=
fSIMPy[jh-1])
goto L73;
7585 if (jhold != jh)
goto L50;
7588 for (i = 1; i <=
fNpar; ++i) {
7593 if (ystst >
fSIMPy[jh-1])
goto L1;
7595 if (ystst <
fAmin)
goto L67;
7601 Printf(
" SIMPLEX MINIMIZATION HAS CONVERGED.");
7607 Printf(
" SIMPLEX TERMINATES WITHOUT CONVERGENCE.");
7613 for (i = 1; i <=
fNpar; ++i) {
7681 static TString cpt =
" ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890./;:[]$%*_!@#&+()";
7684 l = strlen((
const char*)cfname);
7685 for (i = 1; i <=
l; ++i) {
7686 for (ic = 1; ic <= 80; ++ic) {
7687 if (cfname[i-1] == cpt[ic-1])
goto L100;
7710 Int_t i, j, k, kp1, km1;
7718 if (n < 1)
goto L100;
7721 for (i = 1; i <=
n; ++i) {
7723 if (si <= 0)
goto L100;
7726 for (i = 1; i <=
n; ++i) {
7727 for (j = 1; j <=
n; ++j) {
7732 for (i = 1; i <=
n; ++i) {
7735 if (a[k + k*l] != 0)
fVERTq[k-1] = 1 / a[k + k*
l];
7741 if (km1 < 0)
goto L100;
7742 else if (km1 == 0)
goto L50;
7745 for (j = 1; j <= km1; ++j) {
7751 if (k - n < 0)
goto L51;
7752 else if (k - n == 0)
goto L60;
7755 for (j = kp1; j <=
n; ++j) {
7762 for (j = 1; j <=
n; ++j) {
7767 for (j = 1; j <=
n; ++j) {
7768 for (k = 1; k <= j; ++k) {
7770 a[j + k*
l] = a[k + j*
l];
7797 const Int_t kMAXMES = 10;
7798 Int_t ityp, i, ic, nm;
7801 if (corg(0,3) !=
"SHO" || cmes(0,3) !=
"SHO") {
7807 Printf(
" MINUIT WARNING IN %s",(
const char*)corg);
7808 Printf(
" ============== %s",(
const char*)cmes);
7814 Printf(
" MINUIT DEBUG FOR %s",(
const char*)corg);
7815 Printf(
" =============== %s ",(
const char*)cmes);
7840 englsh =
" WAS SUPPRESSED. ";
7841 if (
fNwrmes[ityp-1] > 1) englsh =
"S WERE SUPPRESSED.";
7843 ,(
const char*)ctyp,(
const char*)englsh);
7847 Printf(
" ONLY THE MOST RECENT 10 WILL BE LISTED BELOW.");
7851 Printf(
" CALLS ORIGIN MESSAGE");
7852 for (i = 1; i <= nm; ++i) {
7854 if (ic > kMAXMES) ic = 1;
7870 Double_t denom, ba, al, dx, du1, du2;
7871 Int_t ndex, ierr, i, j, k,
l, ndiag, k1, iin;
7875 for (l = 1; l <=
fNpar; ++
l) {
7876 ndex = l*(l + 1) / 2;
7881 ba =
fBlim[i-1] - al;
7884 if (dx > 1) du1 = ba;
7892 for (i = 1; i <=
fNpar; ++i) {
7895 for (j = 1; j <= i; ++j) {
7903 for (iin = 1; iin <=
fNpar; ++iin) {
7904 ndiag = iin*(iin + 1) / 2;
7906 if (denom <= 1 && denom >= 0)
fGlobcc[iin-1] = 0;
virtual void mnmnos()
Performs a MINOS error analysis.
virtual void mnsimp()
Minimization using the simplex method of Nelder and Mead.
TMinuit()
Minuit normal constructor.
virtual Int_t GetNumFreePars() const
returns the number of currently free parameters
virtual void mnstat(Double_t &fmin, Double_t &fedm, Double_t &errdef, Int_t &npari, Int_t &nparx, Int_t &istat)
Returns concerning the current status of the minimization.
double dist(Rotation3D const &r1, Rotation3D const &r2)
virtual void mneval(Double_t anext, Double_t &fnext, Int_t &ierev)
Evaluates the function being analysed by MNCROS.
virtual void mnprin(Int_t inkode, Double_t fval)
Prints the values of the parameters at the time of the call.
virtual Int_t SetPrintLevel(Int_t printLevel=0)
set Minuit print level.
virtual void mnexin(Double_t *pint)
Transforms the external parameter values U to internal values.
virtual void mnhes1()
Calculate first derivatives (GRD) and uncertainties (DGRD)
virtual void mnvert(Double_t *a, Int_t l, Int_t m, Int_t n, Int_t &ifail)
Inverts a symmetric matrix.
Implementation in C++ of the Minuit package written by Fred James.
virtual void mnemat(Double_t *emat, Int_t ndim)
Calculates the external error matrix from the internal matrix.
void(* fFCN)(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag)
virtual void mnwarn(const char *copt, const char *corg, const char *cmes)
Prints Warning messages.
virtual void mnline(Double_t *start, Double_t fstart, Double_t *step, Double_t slope, Double_t toler)
Perform a line search from position START.
void ToUpper()
Change string to upper case.
virtual void mnseek()
Performs a rough (but global) minimization by monte carlo search.
Int_t LoadPlugin()
Load the plugin library for this handler.
Short_t Min(Short_t a, Short_t b)
R__EXTERN TVirtualMutex * gROOTMutex
virtual void mnderi()
Calculates the first derivatives of FCN (GRD)
virtual void mncros(Double_t &aopt, Int_t &iercr)
Find point where MNEVAL=AMIN+UP.
virtual void mngrad()
Interprets the SET GRAD command.
virtual void mnbins(Double_t a1, Double_t a2, Int_t naa, Double_t &bl, Double_t &bh, Int_t &nb, Double_t &bwid)
Compute reasonable histogram intervals.
virtual void mnrset(Int_t iopt)
Resets function value and errors to UNDEFINED.
Long_t ExecPlugin(int nargs, const T &...params)
virtual void mntiny(volatile Double_t epsp1, Double_t &epsbak)
To find the machine precision.
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
double beta(double x, double y)
Calculates the beta function.
virtual Int_t GetNumPars() const
returns the total number of parameters that have been defined as fixed or free.
TString fOrigin[kMAXWARN]
virtual Int_t FixParameter(Int_t parNo)
fix a parameter
virtual Int_t Eval(Int_t npar, Double_t *grad, Double_t &fval, Double_t *par, Int_t flag)
Evaluate the minimisation function Input parameters:
virtual void mneig(Double_t *a, Int_t ndima, Int_t n, Int_t mits, Double_t *work, Double_t precis, Int_t &ifault)
Compute matrix eigen values.
void SetParamPtrs(void *paramArr, Int_t nparam=-1)
ParamArr is an array containing the function argument values.
const char * Data() const
virtual void mnmigr()
Performs a local function minimization.
virtual void mnfree(Int_t k)
Restores one or more fixed parameter(s) to variable status.
static const double x2[5]
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString...
The TNamed class is the base class for all named ROOT classes.
virtual void mncrck(TString crdbuf, Int_t maxcwd, TString &comand, Int_t &lnc, Int_t mxp, Double_t *plist, Int_t &llist, Int_t &ierr, Int_t isyswr)
Cracks the free-format input.
virtual void mnrn15(Double_t &val, Int_t &inseed)
This is a super-portable random number generator.
virtual TObject * Contour(Int_t npoints=10, Int_t pa1=0, Int_t pa2=1)
Creates a TGraph object describing the n-sigma contour of a TMinuit fit.
Double_t Log10(Double_t x)
virtual ~TMinuit()
Minuit default destructor.
static const double x4[22]
virtual void DeleteArrays()
Delete internal Minuit arrays.
std::vector< std::vector< double > > Data
virtual void mncuve()
Makes sure that the current point is a local minimum.
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
virtual void BuildArrays(Int_t maxpar=15)
Create internal Minuit arrays for the maxpar parameters.
Method or function calling interface.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
virtual void mnmnot(Int_t ilax, Int_t ilax2, Double_t &val2pl, Double_t &val2mi)
Performs a MINOS error analysis on one parameter.
virtual Int_t DefineParameter(Int_t parNo, const char *name, Double_t initVal, Double_t initErr, Double_t lowerLimit, Double_t upperLimit)
Define a parameter.
virtual void mncont(Int_t ke1, Int_t ke2, Int_t nptu, Double_t *xptu, Double_t *yptu, Int_t &ierrf)
Find points along a contour where FCN is minimum.
TString * fCpnam
Character to be plotted at the X,Y contour positions.
virtual void mncler()
Resets the parameter list to UNDEFINED.
virtual void mnparm(Int_t k, TString cnamj, Double_t uk, Double_t wk, Double_t a, Double_t b, Int_t &ierflg)
Implements one parameter definition.
virtual Int_t GetParameter(Int_t parNo, Double_t ¤tValue, Double_t ¤tError) const
return parameter value and error
virtual void mnfixp(Int_t iint, Int_t &ierr)
Removes parameter IINT from the internal parameter list.
virtual void mncalf(Double_t *pvec, Double_t &ycalf)
Transform FCN to find further minima.
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
char * Form(const char *fmt,...)
virtual Int_t SetErrorDef(Double_t up)
To get the n-sigma contour the error def parameter "up" has to set to n^2.
TMethodCall * GetMethodCall() const
TMethodCall * fMethodCall
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
virtual void mnerrs(Int_t number, Double_t &eplus, Double_t &eminus, Double_t &eparab, Double_t &gcc)
Utility routine to get MINOS errors.
virtual void mnhess()
Calculates the full second-derivative matrix of FCN.
#define R__LOCKGUARD2(mutex)
virtual Int_t GetNumFixedPars() const
returns the number of currently fixed parameters
virtual void mnpsdf()
Calculates the eigenvalues of v to see if positive-def.
virtual void mndxdi(Double_t pint, Int_t ipar, Double_t &dxdi)
Calculates the transformation factor between ext/internal values.
virtual void mnamin()
Initialize AMIN.
static const double x1[5]
virtual void mnscan()
Scans the values of FCN as a function of one parameter.
TString fWarmes[kMAXWARN]
virtual void mnhelp(TString comd)
HELP routine for MINUIT interactive commands.
void InteractiveFCNm(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag)
Static function called when SetFCN is called in interactive mode.
virtual Int_t Release(Int_t parNo)
release a parameter
virtual void mnpfit(Double_t *parx2p, Double_t *pary2p, Int_t npar2p, Double_t *coef2p, Double_t &sdev2p)
To fit a parabola to npar2p points.
virtual void SetFCN(void *fcn) R__DEPRECATED(6
To set the address of the minimization function.
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
virtual void mnlims()
Interprets the SET LIM command, to reset the parameter limits.
virtual void mnexcm(const char *comand, Double_t *plist, Int_t llist, Int_t &ierflg)
Interprets a command and takes appropriate action.
virtual void mncntr(Int_t ke1, Int_t ke2, Int_t &ierrf)
Print function contours in two variables, on line printer.
virtual void SetMaxIterations(Int_t maxiter=500)
virtual void mncomd(const char *crdbin, Int_t &icondn)
Reads a command string and executes.
virtual Int_t Command(const char *command)
Execute a Minuit command.
virtual void mninit(Int_t i1, Int_t i2, Int_t i3)
Main initialization member function for MINUIT.
Mother of all ROOT objects.
virtual Int_t Migrad()
invokes the MIGRAD minimizer
virtual void mnpars(TString &crdbuf, Int_t &icondn)
Implements one parameter definition.
virtual void mnplot(Double_t *xpt, Double_t *ypt, char *chpt, Int_t nxypt, Int_t npagwd, Int_t npagln)
Plots points in array xypt onto one page with labelled axes.
virtual void mnpint(Double_t &pexti, Int_t i, Double_t &pinti)
Calculates the internal parameter value PINTI.
virtual void mnsave()
Writes current parameter values and step sizes onto file ISYSSA.
virtual void mninex(Double_t *pint)
Transforms from internal coordinates (PINT) to external (U)
double f2(const double *x)
void Execute(const char *, const char *, int *=0)
Execute method on this object with the given parameter string, e.g.
Short_t Max(Short_t a, Short_t b)
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
virtual void mnmatu(Int_t kode)
Prints the covariance matrix v when KODE=1.
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
virtual void mnset()
Interprets the commands that start with SET and SHOW.
Bool_t mnunpt(TString &cfname)
Returns .TRUE.
virtual void mnrazz(Double_t ynew, Double_t *pnew, Double_t *y, Int_t &jh, Int_t &jl)
Called only by MNSIMP (and MNIMPR) to add a new point.
Double_t Sqrt(Double_t x)
virtual void mnpout(Int_t iuext, TString &chnam, Double_t &val, Double_t &err, Double_t &xlolim, Double_t &xuplim, Int_t &iuint) const
Provides the user with information concerning the current status.
virtual void mnimpr()
Attempts to improve on a good local minimum.
void Resize(Ssiz_t n)
Resize the string. Truncate or add blanks as necessary.
static const double x3[11]
virtual void mnwerr()
Calculates the WERR, external parameter errors.
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.