// @HEADER // ***************************************************************************** // Rapid Optimization Library (ROL) Package // // Copyright 2014 NTESS and the ROL contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER /*! \file example_01.cpp \brief Shows how to solve the Poisson topology optimization problem. */ #include "Teuchos_Comm.hpp" #include "ROL_Stream.hpp" #include "Teuchos_GlobalMPISession.hpp" #include "Teuchos_XMLParameterListHelpers.hpp" #include "Tpetra_Core.hpp" #include "Tpetra_Version.hpp" #include #include #include "ROL_Solver.hpp" #include "ROL_Bounds.hpp" #include "../../TOOLS/pdevector.hpp" #include "pde_poisson_topOpt.hpp" #include "mesh_poisson_topOpt.hpp" #include "../src/filtered_compliance_robj.hpp" #include "../src/volume_con.hpp" #include "../src/obj_volume.hpp" #include "../src/pde_filter.hpp" typedef double RealT; int main(int argc, char *argv[]) { // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided. int iprint = argc - 1; ROL::Ptr outStream; ROL::nullstream bhs; // outputs nothing /*** Initialize communicator. ***/ Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs); ROL::Ptr> comm = Tpetra::getDefaultComm(); const int myRank = comm->getRank(); if ((iprint > 0) && (myRank == 0)) { outStream = ROL::makePtrFromRef(std::cout); } else { outStream = ROL::makePtrFromRef(bhs); } int errorFlag = 0; // *** Example body. try { RealT tol(1.e-8); /*** Read in XML input ***/ std::string filename = "input_ex01.xml"; Teuchos::RCP parlist = Teuchos::rcp( new Teuchos::ParameterList() ); Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() ); // Retrieve parameters. const RealT volFraction = parlist->sublist("Problem").get("Volume Fraction", 0.4); const RealT initDens = parlist->sublist("Problem").get("Initial Density",volFraction); const bool useFilter = parlist->sublist("Problem").get("Use Filter", true); const bool normalizeObj = parlist->sublist("Problem").get("Normalize Compliance", true); const bool volEq = parlist->sublist("Problem").get("Use Volume Equality Constraint",true); /*** Initialize main data structure. ***/ ROL::Ptr> meshMgr = ROL::makePtr>(*parlist); // Initialize PDE describe Poisson's equation ROL::Ptr> pde = ROL::makePtr>(*parlist); // Initialize the filter PDE. ROL::Ptr> pdeFilter = pde; // Initialize "filtered" of "unfiltered" constraint. ROL::Ptr> robj; ROL::Ptr> assembler, assemblerFilter; if (useFilter) { pdeFilter = ROL::makePtr>(*parlist); pde->setDensityFields(pdeFilter->getFields()); robj = ROL::makePtr>( pde,pdeFilter,meshMgr,comm,*parlist,*outStream); assembler = ROL::dynamicPtrCast>(robj)->getAssembler(); assemblerFilter = ROL::dynamicPtrCast>(robj)->getFilterAssembler(); } else { robj = ROL::makePtr>( pde,meshMgr,comm,*parlist,*outStream); assembler = ROL::dynamicPtrCast>(robj)->getAssembler(); assemblerFilter = assembler; } // Create vectors ROL::Ptr> u_ptr, p_ptr, r_ptr, z_ptr; u_ptr = assembler->createStateVector(); u_ptr->putScalar(0.0); p_ptr = assembler->createStateVector(); p_ptr->putScalar(0.0); r_ptr = assembler->createResidualVector(); r_ptr->putScalar(0.0); z_ptr = assemblerFilter->createControlVector(); z_ptr->putScalar(1.0); ROL::Ptr> up, pp, rp, zp; up = ROL::makePtr>(u_ptr,pde,assembler,*parlist); pp = ROL::makePtr>(p_ptr,pde,assembler,*parlist); rp = ROL::makePtr>(r_ptr,pde,assembler,*parlist); zp = ROL::makePtr>(z_ptr,pdeFilter,assemblerFilter,*parlist); // Build volume objective function. ROL::Ptr> qoi_vol; if (useFilter) qoi_vol = ROL::makePtr>(ROL::dynamicPtrCast>(pdeFilter)->getDensityFE(), volFraction); else qoi_vol = ROL::makePtr>(pde->getDensityFE(), volFraction); ROL::Ptr> con_vol = ROL::makePtr>(qoi_vol,assemblerFilter,zp); ROL::Ptr> imul = ROL::makePtr>(0); ROL::Ptr> ilp = ROL::makePtr>(0); ROL::Ptr> iup = ROL::makePtr>(0); zp->zero(); con_vol->value(*ilp,*zp,tol); ROL::Ptr> ibnd = ROL::makePtr>(ilp,iup); // Define bound constraint ROL::Ptr> zlo = zp->clone(); zlo->setScalar(0.0); ROL::Ptr> zhi = zp->clone(); zhi->setScalar(1.0); ROL::Ptr> bnd = ROL::makePtr>(zlo,zhi); // Normalize compliance objective function zp->setScalar(initDens); RealT cs(1); if (normalizeObj) { if (useFilter) cs = ROL::dynamicPtrCast>(robj)->normalize(*zp,tol); else cs = ROL::dynamicPtrCast>(robj)->normalize(*zp,tol); } *outStream << std::endl; *outStream << "Problem Data" << std::endl; *outStream << " SIMP Power: " << parlist->sublist("Problem").get("SIMP Power",3.0) << std::endl; *outStream << " Use Filter: " << useFilter << std::endl; *outStream << " Volume Fraction: " << volFraction << std::endl; *outStream << " Initial Density: " << initDens << std::endl; *outStream << " Use Equality: " << volEq << std::endl; *outStream << " Compliance Scale: " << cs << std::endl; *outStream << std::endl; // Initialize optimization problem. ROL::Ptr> opt = ROL::makePtr>(robj,zp); opt->addBoundConstraint(bnd); if (volEq) opt->addLinearConstraint("Volume",con_vol,imul); else opt->addLinearConstraint("Volume",con_vol,imul,ibnd); opt->setProjectionAlgorithm(*parlist); opt->finalize(false,true,*outStream); // Run derivative checks bool checkDeriv = parlist->sublist("Problem").get("Check derivatives",false); if ( checkDeriv ) opt->check(true,*outStream); // Solve optimization problem ROL::Solver solver(opt,*parlist); Teuchos::Time algoTimer("Algorithm Time", true); solver.solve(*outStream); algoTimer.stop(); *outStream << "Total optimization time = " << algoTimer.totalElapsedTime() << " seconds.\n"; // Output. ROL::dynamicPtrCast>(robj)->summarize(*outStream); con_vol->summarize(*outStream); ROL::dynamicPtrCast>(robj)->printToFile(*zp,*outStream); // Get a summary from the time monitor. Teuchos::TimeMonitor::summarize(); } catch (std::logic_error& err) { *outStream << err.what() << "\n"; errorFlag = -1000; }; // end try if (errorFlag != 0) std::cout << "End Result: TEST FAILED\n"; else std::cout << "End Result: TEST PASSED\n"; return 0; }