| 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 |
} |