src/minimizers/SDMinimizer.cpp

#include "minimizers/SDMinimizer.hpp"
#include "utils/Utility.hpp"

namespace oopse {
SDMinimizer::SDMinimizer(SimInfo* info) : OOPSEMinimizer(info) {
    direction.resize(ndim);
    stepSize = paramSet->getStepSize();
}

void SDMinimizer::init() {
    calcG();

    for(int i = 0; i < direction.size(); i++) {
        direction[i] = -curG[i];
    }
}

int SDMinimizer::step() {
  int lsStatus;

    prevF = curF;

    //optimize along the search direction and reset minimum point value
    lsStatus = doLineSearch(direction, stepSize);

    if (lsStatus < 0)
        return -1;
    else
        return 1;
}

void SDMinimizer::prepareStep() {
    for(int i = 0; i < direction.size(); i++) {
        direction[i] = -curG[i];
    }
}

int SDMinimizer::checkConvg() {
  double fTol;
  double relativeFTol; // relative tolerance
  double deltaF;
  double gTol;
  double relativeGTol;
  double gnorm;

    // test function tolerance test
    fTol = paramSet->getFTol();
    relativeFTol = fTol * std::max(1.0, fabs(curF)); // relative tolerance
    deltaF = prevF - curF;

    if (fabs(deltaF) <= relativeFTol) {
        if (bVerbose) {
            std::cout << "function value tolerance test passed" << std::endl;
            std::cout << "ftol = " << fTol << "\tdeltaf = " << deltaF << std::endl;
        }

        return CONVG_FTOL;
    }

    //gradient tolerance test
    gTol = paramSet->getGTol();
    relativeGTol = gTol * std::max(1.0, fabs(curF));

#ifndef IS_MPI

    gnorm = sqrt(dotProduct(curG, curG));

#else

  double localDP;
  double globalDP;

    localDP = dotProduct(curG, curG);
    MPI_Allreduce(&localDP, &globalDP, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
    gnorm = sqrt(globalDP);

#endif

    if (gnorm <= relativeGTol) {
        std::cout << "gradient tolerance test" << std::endl;
        std::cout << "gnorm = " << gnorm << "\trelativeGTol = " << relativeGTol
            << std::endl;
        return CONVG_GTOL;
    }

    //absolute gradient tolerance test

    if (gnorm <= gTol) {
        std::cout << "absolute gradient tolerance test" << std::endl;
        std::cout << "gnorm = " << gnorm << "\tgTol = " << gTol << std::endl;
        return CONVG_ABSGTOL;
    }

    return CONVG_UNCONVG;
}

}
Revision:	1900
Committed:	Tue Jan 4 22:18:06 2005 UTC (20 years, 10 months ago) by tim
File size:	2229 byte(s)
Log Message:	minimizers in progress
#	User	Rev	Content
1	tim	1900	#include "minimizers/SDMinimizer.hpp"
2	tim	1492	#include "utils/Utility.hpp"
3	gezelter	1490
4	tim	1900	namespace oopse {
5			SDMinimizer::SDMinimizer(SimInfo* info) : OOPSEMinimizer(info) {
6	tim	1884	direction.resize(ndim);
7			stepSize = paramSet->getStepSize();
8			}
9	gezelter	1490
10	tim	1884	void SDMinimizer::init() {
11			calcG();
12
13			for(int i = 0; i < direction.size(); i++) {
14			direction[i] = -curG[i];
15			}
16	gezelter	1490	}
17
18	tim	1884	int SDMinimizer::step() {
19			int lsStatus;
20	gezelter	1490
21	tim	1884	prevF = curF;
22	gezelter	1490
23	tim	1884	//optimize along the search direction and reset minimum point value
24	gezelter	1490	lsStatus = doLineSearch(direction, stepSize);
25
26	tim	1884	if (lsStatus < 0)
27			return -1;
28			else
29			return 1;
30	gezelter	1490	}
31
32	tim	1884	void SDMinimizer::prepareStep() {
33			for(int i = 0; i < direction.size(); i++) {
34			direction[i] = -curG[i];
35			}
36			}
37
38			int SDMinimizer::checkConvg() {
39	gezelter	1490	double fTol;
40	tim	1884	double relativeFTol; // relative tolerance
41	gezelter	1490	double deltaF;
42			double gTol;
43			double relativeGTol;
44			double gnorm;
45
46	tim	1884	// test function tolerance test
47			fTol = paramSet->getFTol();
48			relativeFTol = fTol * std::max(1.0, fabs(curF)); // relative tolerance
49			deltaF = prevF - curF;
50	gezelter	1490
51	tim	1884	if (fabs(deltaF) <= relativeFTol) {
52			if (bVerbose) {
53	tim	1900	std::cout << "function value tolerance test passed" << std::endl;
54			std::cout << "ftol = " << fTol << "\tdeltaf = " << deltaF << std::endl;
55	tim	1884	}
56
57			return CONVG_FTOL;
58	gezelter	1490	}
59
60	tim	1884	//gradient tolerance test
61			gTol = paramSet->getGTol();
62			relativeGTol = gTol * std::max(1.0, fabs(curF));
63
64	gezelter	1490	#ifndef IS_MPI
65	tim	1884
66			gnorm = sqrt(dotProduct(curG, curG));
67
68	gezelter	1490	#else
69	tim	1884
70	gezelter	1490	double localDP;
71			double globalDP;
72
73	tim	1884	localDP = dotProduct(curG, curG);
74			MPI_Allreduce(&localDP, &globalDP, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
75			gnorm = sqrt(globalDP);
76
77	gezelter	1490	#endif
78
79	tim	1884	if (gnorm <= relativeGTol) {
80	tim	1900	std::cout << "gradient tolerance test" << std::endl;
81			std::cout << "gnorm = " << gnorm << "\trelativeGTol = " << relativeGTol
82	tim	1884	<< std::endl;
83			return CONVG_GTOL;
84			}
85	gezelter	1490
86	tim	1884	//absolute gradient tolerance test
87	gezelter	1490
88	tim	1884	if (gnorm <= gTol) {
89	tim	1900	std::cout << "absolute gradient tolerance test" << std::endl;
90			std::cout << "gnorm = " << gnorm << "\tgTol = " << gTol << std::endl;
91	tim	1884	return CONVG_ABSGTOL;
92			}
93
94			return CONVG_UNCONVG;
95	gezelter	1490	}
96	tim	1900
97			}