Debian Codegraph @

packages/rol/adapters/teuchos/test/sol/test_06.cpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Rapid Optimization Library (ROL) Package
4 //
5 // Copyright 2014 NTESS and the ROL contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 /*! \file test_01.cpp
11 \brief Test SROMvector interface.
12 */
13
14
15 #include "ROL_SROMVector.hpp"
16 #include "ROL_TeuchosBatchManager.hpp"
17
18 #include "ROL_Stream.hpp"
19 #include "Teuchos_GlobalMPISession.hpp"
20 #include "Teuchos_DefaultComm.hpp"
21
22 typedef double RealT;
23
24 int main(int argc, char *argv[]) {
25
26 Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
27 ROL::Ptr<const Teuchos::Comm<int> > comm
28 = ROL::toPtr(Teuchos::DefaultComm<int>::getComm());
29
30 int iprint = argc - 1;
31 ROL::nullstream bhs; // outputs nothing
32 std::ostream& outStream = (iprint > 0 && !Teuchos::rank<int>(*comm)) ? std::cout : bhs;
33
34 int errorFlag = 0;
35
36 RealT errtol = ROL::ROL_THRESHOLD<RealT>();
37
38 try {
39 // Batch manager
40 ROL::Ptr<ROL::BatchManager<RealT> > bman =
41 ROL::makePtr<ROL::TeuchosBatchManager<RealT,int>>(comm);
42
43 // Dimension of the optimization vector
44 int dimension = 5, numMyAtoms = 10;
45 int size = dimension*numMyAtoms;
46
47 // Create batch std vectors
48 ROL::Ptr<std::vector<RealT> > b1_ptr = ROL::makePtr<std::vector<RealT>>(size);
49 ROL::Ptr<std::vector<RealT> > b2_ptr = ROL::makePtr<std::vector<RealT>>(size);
50 ROL::Ptr<std::vector<RealT> > b3_ptr = ROL::makePtr<std::vector<RealT>>(size);
51 for (int i = 0; i < size; ++i) {
52 (*b1_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
53 (*b2_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
54 (*b3_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
55 }
56 ROL::Ptr<ROL::BatchStdVector<RealT> > b1
57 = ROL::makePtr<ROL::BatchStdVector<RealT>>(b1_ptr,bman);
58 ROL::Ptr<ROL::BatchStdVector<RealT> > b2
59 = ROL::makePtr<ROL::BatchStdVector<RealT>>(b2_ptr,bman);
60 ROL::Ptr<ROL::BatchStdVector<RealT> > b3
61 = ROL::makePtr<ROL::BatchStdVector<RealT>>(b3_ptr,bman);
62
63 // Create atom vectors
64 ROL::Ptr<std::vector<RealT> > a1_ptr = ROL::makePtr<std::vector<RealT>>(size);
65 ROL::Ptr<std::vector<RealT> > a2_ptr = ROL::makePtr<std::vector<RealT>>(size);
66 ROL::Ptr<std::vector<RealT> > a3_ptr = ROL::makePtr<std::vector<RealT>>(size);
67 ROL::Ptr<std::vector<RealT> > aW_ptr = ROL::makePtr<std::vector<RealT>>(size);
68 for (int i = 0; i < size; ++i) {
69 (*a1_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
70 (*a2_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
71 (*a3_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
72 (*aW_ptr)[i] = static_cast<RealT>(2);
73 }
74 ROL::Ptr<ROL::PrimalAtomVector<RealT> > a1
75 = ROL::makePtr<ROL::PrimalAtomVector<RealT>>(a1_ptr,bman,numMyAtoms,dimension,aW_ptr);
76 ROL::Ptr<ROL::PrimalAtomVector<RealT> > a2
77 = ROL::makePtr<ROL::PrimalAtomVector<RealT>>(a2_ptr,bman,numMyAtoms,dimension,aW_ptr);
78 ROL::Ptr<ROL::PrimalAtomVector<RealT> > a3
79 = ROL::makePtr<ROL::PrimalAtomVector<RealT>>(a3_ptr,bman,numMyAtoms,dimension,aW_ptr);
80
81 // Create probability vectors
82 ROL::Ptr<std::vector<RealT> > p1_ptr = ROL::makePtr<std::vector<RealT>>(numMyAtoms);
83 ROL::Ptr<std::vector<RealT> > p2_ptr = ROL::makePtr<std::vector<RealT>>(numMyAtoms);
84 ROL::Ptr<std::vector<RealT> > p3_ptr = ROL::makePtr<std::vector<RealT>>(numMyAtoms);
85 ROL::Ptr<std::vector<RealT> > pW_ptr = ROL::makePtr<std::vector<RealT>>(numMyAtoms);
86 for (int i = 0; i < numMyAtoms; ++i) {
87 (*p1_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
88 (*p2_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
89 (*p3_ptr)[i] = static_cast<RealT>(rand())/static_cast<RealT>(RAND_MAX);
90 (*pW_ptr)[i] = static_cast<RealT>(2);
91 }
92 ROL::Ptr<ROL::PrimalProbabilityVector<RealT> > p1
93 = ROL::makePtr<ROL::PrimalProbabilityVector<RealT>>(p1_ptr,bman,pW_ptr);
94 ROL::Ptr<ROL::PrimalProbabilityVector<RealT> > p2
95 = ROL::makePtr<ROL::PrimalProbabilityVector<RealT>>(p2_ptr,bman,pW_ptr);
96 ROL::Ptr<ROL::PrimalProbabilityVector<RealT> > p3
97 = ROL::makePtr<ROL::PrimalProbabilityVector<RealT>>(p3_ptr,bman,pW_ptr);
98
99 // Create SROM vectors
100 ROL::SROMVector<RealT> x1(p1,a1);
101 ROL::SROMVector<RealT> x2(p2,a2);
102 ROL::SROMVector<RealT> x3(p3,a3);
103
104 // Standard tests.
105 std::vector<RealT> consistencyBMAN = b1->checkVector(*b2, *b3, true, outStream);
106 ROL::StdVector<RealT> checkvecBMAN( ROL::makePtrFromRef(consistencyBMAN) );
107 if (checkvecBMAN.norm() > std::sqrt(errtol)) {
108 errorFlag++;
109 }
110 std::vector<RealT> consistencyAtom = a1->checkVector(*a2, *a3, true, outStream);
111 ROL::StdVector<RealT> checkvecAtom( ROL::makePtrFromRef(consistencyAtom) );
112 if (checkvecAtom.norm() > std::sqrt(errtol)) {
113 errorFlag++;
114 }
115 std::vector<RealT> consistencyProb = p1->checkVector(*p2, *p3, true, outStream);
116 ROL::StdVector<RealT> checkvecProb( ROL::makePtrFromRef(consistencyProb) );
117 if (checkvecProb.norm() > std::sqrt(errtol)) {
118 errorFlag++;
119 }
120 std::vector<RealT> consistencySROM = x1.checkVector(x2, x3, true, outStream);
121 ROL::StdVector<RealT> checkvecSROM( ROL::makePtrFromRef(consistencySROM) );
122 if (checkvecSROM.norm() > std::sqrt(errtol)) {
123 errorFlag++;
124 }
125
126 RealT numProcs = static_cast<RealT>(Teuchos::size<int>(*comm));
127 RealT anorm = std::sqrt(numProcs*size), pnorm = std::sqrt(numProcs*numMyAtoms);
128 RealT norm = std::sqrt(anorm*anorm + pnorm*pnorm);
129 RealT sqrt2 = static_cast<RealT>(std::sqrt(2.));
130
131 // Create batch std vectors
132 ROL::Ptr<std::vector<RealT> > b_ptr = ROL::makePtr<std::vector<RealT>>(size,1);
133 ROL::Ptr<ROL::BatchStdVector<RealT> > b
134 = ROL::makePtr<ROL::BatchStdVector<RealT>>(b_ptr,bman);
135 RealT bnorm = b->norm();
136 outStream << "BatchStdVector Norm Error: "
137 << std::abs(bnorm - anorm) << std::endl;
138 if ( std::abs(bnorm - anorm) > std::sqrt(errtol) ) {
139 errorFlag++;
140 }
141
142 // Create atom vectors
143 ROL::Ptr<std::vector<RealT> > ap_ptr = ROL::makePtr<std::vector<RealT>>(size,1);
144 ROL::Ptr<ROL::PrimalAtomVector<RealT> > ap
145 = ROL::makePtr<ROL::PrimalAtomVector<RealT>>(ap_ptr,bman,numMyAtoms,dimension,aW_ptr);
146 RealT apnorm = ap->norm();
147 outStream << "PrimalAtomVector Norm Error: "
148 << std::abs(apnorm - sqrt2*anorm) << std::endl;
149 if ( std::abs(apnorm - sqrt2*anorm) > std::sqrt(errtol) ) {
150 errorFlag++;
151 }
152 ROL::Ptr<std::vector<RealT> > ad_ptr = ROL::makePtr<std::vector<RealT>>(size,1);
153 ROL::Ptr<ROL::DualAtomVector<RealT> > ad
154 = ROL::makePtr<ROL::DualAtomVector<RealT>>(ad_ptr,bman,numMyAtoms,dimension,aW_ptr);
155 RealT adnorm = ad->norm();
156 outStream << "DualAtomVector Norm Error: "
157 << std::abs(adnorm - anorm/sqrt2) << std::endl;
158 if ( std::abs(adnorm - anorm/sqrt2) > std::sqrt(errtol) ) {
159 errorFlag++;
160 }
161
162 // Create probability vectors
163 ROL::Ptr<std::vector<RealT> > pp_ptr = ROL::makePtr<std::vector<RealT>>(numMyAtoms,1);
164 ROL::Ptr<ROL::PrimalProbabilityVector<RealT> > pp
165 = ROL::makePtr<ROL::PrimalProbabilityVector<RealT>>(pp_ptr,bman,pW_ptr);
166 RealT ppnorm = pp->norm();
167 outStream << "PrimalProbabilityVector Norm Error: "
168 << std::abs(ppnorm - sqrt2*pnorm) << std::endl;
169 if ( std::abs(ppnorm - sqrt2*pnorm) > std::sqrt(errtol) ) {
170 errorFlag++;
171 }
172 ROL::Ptr<std::vector<RealT> > pd_ptr = ROL::makePtr<std::vector<RealT>>(numMyAtoms,1);
173 ROL::Ptr<ROL::DualProbabilityVector<RealT> > pd
174 = ROL::makePtr<ROL::DualProbabilityVector<RealT>>(pd_ptr,bman,pW_ptr);
175 RealT pdnorm = pd->norm();
176 outStream << "DualProbabilityVector Norm Error: "
177 << std::abs(pdnorm - pnorm/sqrt2) << std::endl;
178 if ( std::abs(pdnorm - pnorm/sqrt2) > std::sqrt(errtol) ) {
179 errorFlag++;
180 }
181
182 // Create SROM vectors
183 ROL::SROMVector<RealT> xp(pp,ap);
184 RealT xpnorm = xp.norm();
185 outStream << "PrimalSROMVector Norm Error: "
186 << std::abs(xpnorm - sqrt2*norm) << std::endl;
187 if ( std::abs(xpnorm - sqrt2*norm) > std::sqrt(errtol) ) {
188 errorFlag++;
189 }
190 ROL::SROMVector<RealT> xd(pd,ad);
191 RealT xdnorm = xd.norm();
192 outStream << "DualSROMVector Norm Error: "
193 << std::abs(xdnorm - norm/sqrt2) << std::endl;
194 if ( std::abs(xdnorm - norm/sqrt2) > std::sqrt(errtol) ) {
195 errorFlag++;
196 }
197 outStream << std::endl;
198 }
199
200 catch (std::logic_error& err) {
201 outStream << err.what() << "\n";
202 errorFlag = -1000;
203 }; // end try
204
205 if (errorFlag != 0)
206 std::cout << "End Result: TEST FAILED\n";
207 else
208 std::cout << "End Result: TEST PASSED\n";
209
210 return 0;
211 }