Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/poisson/example_01.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 example_01.cpp
11 \brief Shows how to solve the Poisson topology optimization problem.
12 */
13
14 #include "Teuchos_Comm.hpp"
15 #include "ROL_Stream.hpp"
16 #include "Teuchos_GlobalMPISession.hpp"
17 #include "Teuchos_XMLParameterListHelpers.hpp"
18
19 #include "Tpetra_Core.hpp"
20 #include "Tpetra_Version.hpp"
21
22 #include <iostream>
23 #include <algorithm>
24
25 #include "ROL_Solver.hpp"
26 #include "ROL_Bounds.hpp"
27
28 #include "../../TOOLS/pdevector.hpp"
29
30 #include "pde_poisson_topOpt.hpp"
31 #include "mesh_poisson_topOpt.hpp"
32 #include "../src/filtered_compliance_robj.hpp"
33 #include "../src/volume_con.hpp"
34 #include "../src/obj_volume.hpp"
35 #include "../src/pde_filter.hpp"
36
37 typedef double RealT;
38
39 int main(int argc, char *argv[]) {
40 // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
41 int iprint = argc - 1;
42 ROL::Ptr<std::ostream> outStream;
43 ROL::nullstream bhs; // outputs nothing
44
45 /*** Initialize communicator. ***/
46 Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs);
47 ROL::Ptr<const Teuchos::Comm<int>> comm
48 = Tpetra::getDefaultComm();
49 const int myRank = comm->getRank();
50 if ((iprint > 0) && (myRank == 0)) {
51 outStream = ROL::makePtrFromRef(std::cout);
52 }
53 else {
54 outStream = ROL::makePtrFromRef(bhs);
55 }
56 int errorFlag = 0;
57
58 // *** Example body.
59 try {
60 RealT tol(1.e-8);
61
62 /*** Read in XML input ***/
63 std::string filename = "input_ex01.xml";
64 Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
65 Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
66
67 // Retrieve parameters.
68 const RealT volFraction = parlist->sublist("Problem").get("Volume Fraction", 0.4);
69 const RealT initDens = parlist->sublist("Problem").get("Initial Density",volFraction);
70 const bool useFilter = parlist->sublist("Problem").get("Use Filter", true);
71 const bool normalizeObj = parlist->sublist("Problem").get("Normalize Compliance", true);
72 const bool volEq = parlist->sublist("Problem").get("Use Volume Equality Constraint",true);
73
74 /*** Initialize main data structure. ***/
75 ROL::Ptr<MeshManager<RealT>>
76 meshMgr = ROL::makePtr<MeshManager_Poisson_TopOpt<RealT>>(*parlist);
77
78 // Initialize PDE describe Poisson's equation
79 ROL::Ptr<PDE_Poisson_TopOpt<RealT>>
80 pde = ROL::makePtr<PDE_Poisson_TopOpt<RealT>>(*parlist);
81
82 // Initialize the filter PDE.
83 ROL::Ptr<PDE<RealT>> pdeFilter = pde;
84
85 // Initialize "filtered" of "unfiltered" constraint.
86 ROL::Ptr<ROL::Objective<RealT>> robj;
87 ROL::Ptr<Assembler<RealT>> assembler, assemblerFilter;
88 if (useFilter) {
89 pdeFilter = ROL::makePtr<PDE_Filter<RealT>>(*parlist);
90 pde->setDensityFields(pdeFilter->getFields());
91 robj = ROL::makePtr<TopOptFilteredComplianceObjective<RealT>>(
92 pde,pdeFilter,meshMgr,comm,*parlist,*outStream);
93 assembler = ROL::dynamicPtrCast<TopOptFilteredComplianceObjective<RealT>>(robj)->getAssembler();
94 assemblerFilter = ROL::dynamicPtrCast<TopOptFilteredComplianceObjective<RealT>>(robj)->getFilterAssembler();
95 }
96 else {
97 robj = ROL::makePtr<TopOptComplianceObjective<RealT>>(
98 pde,meshMgr,comm,*parlist,*outStream);
99 assembler = ROL::dynamicPtrCast<TopOptComplianceObjective<RealT>>(robj)->getAssembler();
100 assemblerFilter = assembler;
101 }
102
103 // Create vectors
104 ROL::Ptr<Tpetra::MultiVector<>> u_ptr, p_ptr, r_ptr, z_ptr;
105 u_ptr = assembler->createStateVector(); u_ptr->putScalar(0.0);
106 p_ptr = assembler->createStateVector(); p_ptr->putScalar(0.0);
107 r_ptr = assembler->createResidualVector(); r_ptr->putScalar(0.0);
108 z_ptr = assemblerFilter->createControlVector(); z_ptr->putScalar(1.0);
109 ROL::Ptr<ROL::Vector<RealT>> up, pp, rp, zp;
110 up = ROL::makePtr<PDE_PrimalSimVector<RealT>>(u_ptr,pde,assembler,*parlist);
111 pp = ROL::makePtr<PDE_PrimalSimVector<RealT>>(p_ptr,pde,assembler,*parlist);
112 rp = ROL::makePtr<PDE_DualSimVector<RealT>>(r_ptr,pde,assembler,*parlist);
113 zp = ROL::makePtr<PDE_PrimalOptVector<RealT>>(z_ptr,pdeFilter,assemblerFilter,*parlist);
114
115 // Build volume objective function.
116 ROL::Ptr<QoI<RealT>> qoi_vol;
117 if (useFilter)
118 qoi_vol = ROL::makePtr<QoI_Volume_TopoOpt<RealT>>(ROL::dynamicPtrCast<PDE_Filter<RealT>>(pdeFilter)->getDensityFE(),
119 volFraction);
120 else
121 qoi_vol = ROL::makePtr<QoI_Volume_TopoOpt<RealT>>(pde->getDensityFE(), volFraction);
122 ROL::Ptr<TopOptVolumeConstraint<RealT>>
123 con_vol = ROL::makePtr<TopOptVolumeConstraint<RealT>>(qoi_vol,assemblerFilter,zp);
124 ROL::Ptr<ROL::Vector<RealT>> imul = ROL::makePtr<ROL::SingletonVector<RealT>>(0);
125 ROL::Ptr<ROL::Vector<RealT>> ilp = ROL::makePtr<ROL::SingletonVector<RealT>>(0);
126 ROL::Ptr<ROL::Vector<RealT>> iup = ROL::makePtr<ROL::SingletonVector<RealT>>(0);
127 zp->zero(); con_vol->value(*ilp,*zp,tol);
128 ROL::Ptr<ROL::BoundConstraint<RealT>> ibnd = ROL::makePtr<ROL::Bounds<RealT>>(ilp,iup);
129
130 // Define bound constraint
131 ROL::Ptr<ROL::Vector<RealT>> zlo = zp->clone(); zlo->setScalar(0.0);
132 ROL::Ptr<ROL::Vector<RealT>> zhi = zp->clone(); zhi->setScalar(1.0);
133 ROL::Ptr<ROL::BoundConstraint<RealT>>
134 bnd = ROL::makePtr<ROL::Bounds<RealT>>(zlo,zhi);
135
136 // Normalize compliance objective function
137 zp->setScalar(initDens);
138 RealT cs(1);
139 if (normalizeObj) {
140 if (useFilter)
141 cs = ROL::dynamicPtrCast<TopOptFilteredComplianceObjective<RealT>>(robj)->normalize(*zp,tol);
142 else
143 cs = ROL::dynamicPtrCast<TopOptComplianceObjective<RealT>>(robj)->normalize(*zp,tol);
144 }
145 *outStream << std::endl;
146 *outStream << "Problem Data" << std::endl;
147 *outStream << " SIMP Power: "
148 << parlist->sublist("Problem").get("SIMP Power",3.0) << std::endl;
149 *outStream << " Use Filter: " << useFilter << std::endl;
150 *outStream << " Volume Fraction: " << volFraction << std::endl;
151 *outStream << " Initial Density: " << initDens << std::endl;
152 *outStream << " Use Equality: " << volEq << std::endl;
153 *outStream << " Compliance Scale: " << cs << std::endl;
154 *outStream << std::endl;
155
156 // Initialize optimization problem.
157 ROL::Ptr<ROL::Problem<RealT>>
158 opt = ROL::makePtr<ROL::Problem<RealT>>(robj,zp);
159 opt->addBoundConstraint(bnd);
160 if (volEq) opt->addLinearConstraint("Volume",con_vol,imul);
161 else opt->addLinearConstraint("Volume",con_vol,imul,ibnd);
162 opt->setProjectionAlgorithm(*parlist);
163 opt->finalize(false,true,*outStream);
164
165 // Run derivative checks
166 bool checkDeriv = parlist->sublist("Problem").get("Check derivatives",false);
167 if ( checkDeriv ) opt->check(true,*outStream);
168
169 // Solve optimization problem
170 ROL::Solver<RealT> solver(opt,*parlist);
171 Teuchos::Time algoTimer("Algorithm Time", true);
172 solver.solve(*outStream);
173 algoTimer.stop();
174 *outStream << "Total optimization time = " << algoTimer.totalElapsedTime() << " seconds.\n";
175
176 // Output.
177 ROL::dynamicPtrCast<TopOptFilteredComplianceObjective<RealT>>(robj)->summarize(*outStream);
178 con_vol->summarize(*outStream);
179 ROL::dynamicPtrCast<TopOptFilteredComplianceObjective<RealT>>(robj)->printToFile(*zp,*outStream);
180
181 // Get a summary from the time monitor.
182 Teuchos::TimeMonitor::summarize();
183 }
184 catch (std::logic_error& err) {
185 *outStream << err.what() << "\n";
186 errorFlag = -1000;
187 }; // end try
188
189 if (errorFlag != 0)
190 std::cout << "End Result: TEST FAILED\n";
191 else
192 std::cout << "End Result: TEST PASSED\n";
193
194 return 0;
195 }