//=========================================================================
std::string hTreeBrowser::getObjectType(TObject* obj)
{
// STDLINE("",ACRed);
std::string objectType = "Unknown" ;
TKey* keyH = 0 ;
TIter bases(obj->IsA()->GetListOfBases());
int count = 0 ;
while((keyH = (TKey*)bases()))
{
if( count++ == 0 )
objectType = keyH->GetName() ;
}
return objectType ;
}
Basis_HGRAD_QUAD_Cn_FEM<Scalar,ArrayScalar>::Basis_HGRAD_QUAD_Cn_FEM( const int order,
const EPointType &pointType ):
ptsx_( order+1 , 1 ) ,
ptsy_( order+1 , 1 )
{
Array<Array<RCP<Basis<Scalar,ArrayScalar> > > > bases(1);
bases[0].resize(2);
bases[0][0] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM<Scalar,ArrayScalar>( order , pointType ) );
bases[0][1] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM<Scalar,ArrayScalar>( order , pointType ) );
this->setBases( bases );
this->basisCardinality_ = (order+1)*(order+1);
this->basisDegree_ = order;
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
// fill up the pt arrays with calls to the lattice
EPointType pt = (pointType==POINTTYPE_EQUISPACED)?pointType:POINTTYPE_WARPBLEND;
PointTools::getLattice<Scalar,ArrayScalar >( ptsx_ ,
shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
order ,
0 ,
pt );
for (int i=0;i<order+1;i++)
{
ptsy_(i,0) = ptsx_(i,0);
}
initializeTags();
this->basisTagsAreSet_ = true;
}
size_t WHtreeProcesser::baseNodes2Leaves()
{
if( !m_tree.testRootBaseNodes() )
{
std::cerr << "ERROR @ WHtreeProcesser::baseNodes2Leaves(): base nodes have both leaves and other nodes as children,";
std::cerr << " tree wont be processed" << std::endl;
return m_tree.getNumLeaves();
}
std::vector <size_t> bases( m_tree.getRootBaseNodes() );
for( size_t i = 0; i < bases.size(); ++i )
{
std::vector <size_t> leaves4node( m_tree.getLeaves4node( bases[i] ) );
// start in j=1 so that we always leave one leaf not pruned
for( size_t j = 1; j < leaves4node.size(); ++j )
{
WHnode* currentLeaf( m_tree.fetchLeaf( leaves4node[j] ) );
currentLeaf->setFlag( true );
}
}
m_tree.cleanup();
m_tree.m_treeName += ( "_bases" );
return m_tree.getNumLeaves();
} // end "baseNodes2Leaves()" -----------------------------------------------------------------
int main(int argc, char **argv)
{
try {
const int d = 7;
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(1);
bases[0] = Teuchos::rcp(new Stokhos::HermiteBasis<int,double>(d));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
Teuchos::RCP<Teuchos::SerialDenseMatrix<int,double> > Bij =
basis->computeDerivDoubleProductTensor();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk =
basis->computeTripleProductTensor(basis->size());
Teuchos::RCP<Stokhos::Dense3Tensor<int,double> > Dijk =
basis->computeDerivTripleProductTensor(Bij, Cijk);
Stokhos::DerivOrthogPolyExpansion<int,double> expn(basis, Bij, Cijk, Dijk);
Stokhos::OrthogPolyApprox<int,double> u(basis),v(basis),w(basis);
u[0] = 1.0;
u[1] = 0.4;
u[2] = 0.06;
u[3] = 0.002;
expn.log(v,u);
expn.times(w,v,v);
expn.plusEqual(w,1.0);
expn.divide(v,1.0,w);
expn.sinh(w,v);
std::cout << "u (orthogonal basis) = " << u << std::endl;
std::cout.precision(12);
std::cout << "w (orthogonal basis) = " << w << std::endl;
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
}
Basis_HDIV_HEX_In_FEM<Scalar,ArrayScalar>::Basis_HDIV_HEX_In_FEM( int order ,
const ArrayScalar & ptsClosed ,
const ArrayScalar & ptsOpen):
closedBasis_( order , ptsClosed ),
openBasis_( order-1 , ptsOpen ),
closedPts_( ptsClosed ),
openPts_( ptsOpen )
{
this -> basisDegree_ = order;
this -> basisCardinality_ = 3 * closedBasis_.getCardinality() * openBasis_.getCardinality() * openBasis_.getCardinality();
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
Array<Array<RCP<Basis<Scalar,ArrayScalar > > > > bases(3);
bases[0].resize(3); bases[1].resize(3); bases[2].resize(3);
bases[0][0] = rcp( &closedBasis_ , false );
bases[0][1] = rcp( &openBasis_ , false );
bases[0][2] = rcp( &openBasis_ , false );
bases[1][0] = rcp( &openBasis_ , false );
bases[1][1] = rcp( &closedBasis_ , false );
bases[1][2] = rcp( &openBasis_ , false );
bases[2][0] = rcp( &openBasis_ , false );
bases[2][1] = rcp( &openBasis_ , false );
bases[2][2] = rcp( &closedBasis_ , false );
this->setBases( bases );
initializeTags();
this->basisTagsAreSet_ = true;
}
Basis_HCURL_QUAD_In_FEM<Scalar,ArrayScalar>::Basis_HCURL_QUAD_In_FEM( int order ,
const ArrayScalar & ptsClosed ,
const ArrayScalar & ptsOpen):
closedBasis_( order , ptsClosed ),
openBasis_( order-1 , ptsOpen ) ,
closedPts_( ptsClosed ),
openPts_( ptsOpen )
{
this -> basisDegree_ = order;
this -> basisCardinality_ = 2 * closedBasis_.getCardinality() * openBasis_.getCardinality();
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
Array<Array<RCP<Basis<Scalar,ArrayScalar > > > > bases(2);
bases[0].resize(2); bases[1].resize(2);
bases[0][0] = rcp( &openBasis_ , false );
bases[0][1] = rcp( &closedBasis_ , false );
bases[1][0] = rcp( &closedBasis_ , false );
bases[1][1] = rcp( &openBasis_ , false );
this->setBases( bases );
}
Basis_HGRAD_QUAD_Cn_FEM<Scalar,ArrayScalar>::Basis_HGRAD_QUAD_Cn_FEM( const int orderx , const int ordery,
const ArrayScalar &pts_x ,
const ArrayScalar &pts_y ):
ptsx_( pts_x.dimension(0) , 1 ) ,
ptsy_( pts_y.dimension(0) , 1 )
{
Array<Array<RCP<Basis<Scalar,ArrayScalar> > > > bases(1);
bases[0].resize(2);
bases[0][0] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM<Scalar,ArrayScalar>( orderx , pts_x ) );
bases[0][1] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM<Scalar,ArrayScalar>( ordery , pts_y ) );
this->setBases( bases );
this->basisCardinality_ = (orderx+1)*(ordery+1);
if (orderx > ordery) {
this->basisDegree_ = orderx;
}
else {
this->basisDegree_ = ordery;
}
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
for (int i=0;i<pts_x.dimension(0);i++)
{
ptsx_(i,0) = pts_x(i,0);
}
for (int i=0;i<pts_y.dimension(0);i++)
{
ptsy_(i,0) = pts_y(i,0);
}
}
void MainVisitor::Inspect()
{
#define Dump(coll) dump(#coll, _##coll)
Dump(pointerClasses);
Dump(barrieredClasses);
Log::outs() << "Recycler allocations\n";
for (auto item : _allocatorTypeMap)
{
dump(item.first.c_str(), item.second);
}
std::queue<const Type*> queue; // queue of types to check
std::unordered_set<const Type*> barrierTypes; // set of types queued
auto pushBarrierType = [&](const Type* type) -> bool
{
if (barrierTypes.insert(type).second)
{
queue.push(type);
return true;
}
return false;
};
for (auto item : _allocationTypes)
{
if (item.second & AllocationTypes::WriteBarrier)
{
pushBarrierType(item.first);
}
}
dump("WriteBarrier allocation types", barrierTypes);
// Examine all barrierd types. They should be fully wb annotated.
while (!queue.empty())
{
auto type = queue.front();
queue.pop();
auto r = type->getCanonicalTypeInternal()->getAsCXXRecordDecl();
if (r)
{
auto typeName = r->getQualifiedNameAsString();
ProcessUnbarrieredFields(r, pushBarrierType);
// queue the type's base classes
for (const auto& base: r->bases())
{
if (pushBarrierType(base.getType().getTypePtr()))
{
Log::outs() << "Queue base type: " << base.getType().getAsString()
<< " (base of " << typeName << ")\n";
}
}
}
}
#undef Dump
}
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > buildBasis(int num_KL,int porder)
{
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for(int i=0; i<num_KL; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(porder));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis
= Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
return basis;
}
Basis_HDIV_HEX_In_FEM<Scalar,ArrayScalar>::Basis_HDIV_HEX_In_FEM( int order , const EPointType &pointType ):
closedBasis_( order , pointType==POINTTYPE_SPECTRAL?POINTTYPE_SPECTRAL:POINTTYPE_EQUISPACED ),
openBasis_( order-1 , pointType==POINTTYPE_SPECTRAL?POINTTYPE_SPECTRAL_OPEN:POINTTYPE_EQUISPACED ),
closedPts_( order+1 , 1 ),
openPts_( order , 1 )
{
this -> basisDegree_ = order;
this -> basisCardinality_ = 3 * closedBasis_.getCardinality() * openBasis_.getCardinality() * openBasis_.getCardinality();
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
PointTools::getLattice<Scalar,ArrayScalar >( closedPts_ ,
shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
order ,
0 ,
pointType==POINTTYPE_SPECTRAL?POINTTYPE_WARPBLEND:POINTTYPE_EQUISPACED );
if (pointType == POINTTYPE_SPECTRAL)
{
PointTools::getGaussPoints<Scalar,ArrayScalar >( openPts_ ,
order - 1 );
}
else
{
PointTools::getLattice<Scalar,ArrayScalar >( openPts_ ,
shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
order - 1,
0 ,
POINTTYPE_EQUISPACED );
}
Array<Array<RCP<Basis<Scalar,ArrayScalar > > > > bases(3);
bases[0].resize(3); bases[1].resize(3); bases[2].resize(3);
bases[0][0] = rcp( &closedBasis_ , false );
bases[0][1] = rcp( &openBasis_ , false );
bases[0][2] = rcp( &openBasis_ , false );
bases[1][0] = rcp( &openBasis_ , false );
bases[1][1] = rcp( &closedBasis_ , false );
bases[1][2] = rcp( &openBasis_ , false );
bases[2][0] = rcp( &openBasis_ , false );
bases[2][1] = rcp( &openBasis_ , false );
bases[2][2] = rcp( &closedBasis_ , false );
this->setBases( bases );
initializeTags();
this->basisTagsAreSet_ = true;
}
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> >
buildBasis(int num_KL,const std::vector<int> & order)
{
TEUCHOS_ASSERT(num_KL==int(order.size()));
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for(int i=0; i<num_KL; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(order[i]));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis
= Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
return basis;
}
Basis_HGRAD_HEX_Cn_FEM<Scalar,ArrayScalar>::Basis_HGRAD_HEX_Cn_FEM( const int orderx ,
const int ordery ,
const int orderz ,
const ArrayScalar &pts_x ,
const ArrayScalar &pts_y ,
const ArrayScalar &pts_z ):
ptsx_( pts_x.dimension(0) , 1 ),
ptsy_( pts_y.dimension(0) , 1 ),
ptsz_( pts_z.dimension(0) , 1 )
{
for (int i=0;i<pts_x.dimension(0);i++)
{
ptsx_(i,0) = pts_x(i,0);
}
for (int i=0;i<pts_y.dimension(0);i++)
{
ptsy_(i,0) = pts_y(i,0);
}
for (int i=0;i<pts_z.dimension(0);i++)
{
ptsz_(i,0) = pts_z(i,0);
}
Array<Array<RCP<Basis<Scalar,ArrayScalar> > > > bases(1);
bases[0].resize(3);
bases[0][0] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM< Scalar , ArrayScalar >( orderx , pts_x ) );
bases[0][1] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM< Scalar , ArrayScalar >( ordery , pts_y ) );
bases[0][2] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM< Scalar , ArrayScalar >( orderz , pts_z ) );
this->setBases( bases );
this->basisCardinality_ = (orderx+1)*(ordery+1)*(orderz+1);
if (orderx >= ordery && orderx >= orderz ) {
this->basisDegree_ = orderx;
}
else if (ordery >= orderx && ordery >= orderz) {
this->basisDegree_ = ordery;
}
else {
this->basisDegree_ = orderz;
}
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
initializeTags();
this->basisTagsAreSet_ = true;
}
void MustOverrideChecker::check(const MatchFinder::MatchResult &Result) {
auto D = Result.Nodes.getNodeAs<CXXRecordDecl>("class");
// Look through all of our immediate bases to find methods that need to be
// overridden
typedef std::vector<CXXMethodDecl *> OverridesVector;
OverridesVector MustOverrides;
for (const auto &Base : D->bases()) {
// The base is either a class (CXXRecordDecl) or it's a templated class...
CXXRecordDecl *Parent = Base.getType()
.getDesugaredType(D->getASTContext())
->getAsCXXRecordDecl();
// The parent might not be resolved to a type yet. In this case, we can't
// do any checking here. For complete correctness, we should visit
// template instantiations, but this case is likely to be rare, so we will
// ignore it until it becomes important.
if (!Parent) {
continue;
}
Parent = Parent->getDefinition();
for (const auto &M : Parent->methods()) {
if (hasCustomAnnotation(M, "moz_must_override"))
MustOverrides.push_back(M);
}
}
for (auto &O : MustOverrides) {
bool Overridden = false;
for (const auto &M : D->methods()) {
// The way that Clang checks if a method M overrides its parent method
// is if the method has the same name but would not overload.
if (getNameChecked(M) == getNameChecked(O) &&
!CI->getSema().IsOverload(M, O, false)) {
Overridden = true;
break;
}
}
if (!Overridden) {
diag(D->getLocation(), "%0 must override %1", DiagnosticIDs::Error)
<< D->getDeclName() << O->getDeclName();
diag(O->getLocation(), "function to override is here",
DiagnosticIDs::Note);
}
}
}
Basis_HGRAD_HEX_Cn_FEM<Scalar,ArrayScalar>::Basis_HGRAD_HEX_Cn_FEM( const int order ,
const EPointType & pointType ):
ptsx_( order+1 , 1 ),
ptsy_( order+1 , 1 ),
ptsz_( order+1 , 1 )
{
Array<Array<RCP<Basis<Scalar,ArrayScalar> > > > bases(1);
bases[0].resize(3);
bases[0][0] = Teuchos::rcp( new Basis_HGRAD_LINE_Cn_FEM< Scalar , ArrayScalar >( order , pointType ) );
// basis is same in each direction, so I only need to instantiate it once!
bases[0][1] = bases[0][0];
bases[0][2] = bases[0][0];
this->setBases( bases );
this->basisCardinality_ = (order+1)*(order+1)*(order+1);
this->basisDegree_ = order;
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
// get points
EPointType pt = (pointType==POINTTYPE_EQUISPACED)?pointType:POINTTYPE_WARPBLEND;
PointTools::getLattice<Scalar,ArrayScalar >( ptsx_ ,
shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
order ,
0 ,
pt );
for (int i=0;i<order+1;i++)
{
ptsy_(i,0) = ptsx_(i,0);
ptsz_(i,0) = ptsx_(i,0);
}
initializeTags();
this->basisTagsAreSet_ = true;
}
TEUCHOS_UNIT_TEST( TensorProduct, IsotropicPoints ) {
success = true;
// Build tensor product basis of dimension d and order p
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
for (ordinal_type i=0; i<setup.d; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
*basis);
Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
*basis, quad);
success = Stokhos::testPseudoSpectralPoints(
tp_op, quad_op, setup.rtol, setup.atol, out);
}
TEUCHOS_UNIT_TEST( TotalOrder, AnisotropicDiscreteOrthogonality ) {
success = true;
// Build tensor product basis of dimension d and order p
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
for (ordinal_type i=0; i<setup.d; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
*basis);
success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
*basis, tp_op, setup.rtol, setup.atol, out);
}
TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_Trans_TotalOrder ) {
success = true;
// Build anisotropic tensor product basis of dimension d
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
for (ordinal_type i=0; i<setup.d; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
*basis, true);
Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
*basis, quad);
success = Stokhos::testPseudoSpectralApplyTrans(
tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
}
UnitTestSetup() {
rtol = 1e-4;
atol = 1e-5;
crtol = 1e-12;
catol = 1e-12;
a = 3.1;
const int d = 2;
const int p = 7;
// Create product basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
for (int i=0; i<d; i++)
bases[i] =
Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p));
basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
// Tensor product quadrature
quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis));
// Triple product tensor
Cijk = basis->computeTripleProductTensor(basis->size());
// Quadrature expansion
exp =
Teuchos::rcp(new Stokhos::QuadOrthogPolyExpansion<int,double>(basis, Cijk, quad));
// Create approximation
sz = basis->size();
x.reset(exp);
y.reset(exp);
u.reset(exp);
u2.reset(exp);
cx.reset(exp, 1);
x.term(0, 0) = 1.0;
cx.term(0, 0) = a;
cu.reset(exp);
cu2.reset(exp, 1);
sx.reset(exp, d+1);
su.reset(exp, d+1);
su2.reset(exp, d+1);
for (int i=0; i<d; i++) {
x.term(i, 1) = 0.1;
sx.term(i, 1) = 0.0;
}
y.term(0, 0) = 2.0;
for (int i=0; i<d; i++)
y.term(i, 1) = 0.25;
}
int main(int argc, char *argv[]) {
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
int MyPID;
try {
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
MyPID = globalComm->MyPID();
// Create Stochastic Galerkin basis and expansion
int p = 5;
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(1);
bases[0] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
Cijk = basis->computeTripleProductTensor();
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
int num_spatial_procs = -1;
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application model evaluator
Teuchos::RCP<EpetraExt::ModelEvaluator> model =
Teuchos::rcp(new SimpleME(app_comm));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
sgParams->set("Jacobian Method", "Matrix Free");
sgParams->set("Mean Preconditioner Type", "Ifpack");
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams));
// Stochastic Galerkin initial guess
// Set the mean to the deterministic initial guess, higher-order terms
// to zero
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> x_init_sg =
sg_model->create_x_sg();
x_init_sg->init(0.0);
(*x_init_sg)[0] = *(model->get_x_init());
sg_model->set_x_sg_init(*x_init_sg);
// Stochastic Galerkin parameters
// Linear expansion with the mean given by the deterministic initial
// parameter values, linear terms equal to 1, and higher order terms
// equal to zero.
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> p_init_sg =
sg_model->create_p_sg(0);
p_init_sg->init(0.0);
(*p_init_sg)[0] = *(model->get_p_init(0));
for (int i=0; i<model->get_p_map(0)->NumMyElements(); i++)
(*p_init_sg)[i+1][i] = 1.0;
sg_model->set_p_sg_init(0, *p_init_sg);
std::cout << "Stochatic Galerkin parameter expansion = " << std::endl
<< *p_init_sg << std::endl;
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
//NOX::Utils::Parameters +
//NOX::Utils::Details +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 100);
lsParams.set("Size of Krylov Subspace", 100);
lsParams.set("Tolerance", 1e-4);
lsParams.set("Output Frequency", 10);
lsParams.set("Preconditioner", "Ifpack");
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", 1e-10);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 10);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linsys;
Teuchos::RCP<Epetra_Operator> M = sg_model->create_WPrec()->PrecOp;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec = nox_interface;
lsParams.set("Preconditioner", "User Defined");
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iJac, A, iPrec, M,
*u));
// linsys =
// Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
// iReq, iJac, A, *u));
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status = solver->solve();
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Convert block Epetra_Vector to orthogonal polynomial of Epetra_Vector's
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> x_sg =
sg_model->create_x_sg(View, &finalSolution);
utils.out() << "Final Solution (block vector) = " << std::endl;
std::cout << finalSolution << std::endl;
utils.out() << "Final Solution (polynomial) = " << std::endl;
std::cout << *x_sg << std::endl;
if (status == NOX::StatusTest::Converged && MyPID == 0)
utils.out() << "Example Passed!" << std::endl;
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
int main(int argc, char *argv[]) {
int n = 32; // spatial discretization (per dimension)
int num_KL = 2; // number of KL terms
int p = 3; // polynomial order
double mu = 0.1; // mean of exponential random field
double s = 0.2; // std. dev. of exponential r.f.
bool nonlinear_expansion = false; // nonlinear expansion of diffusion coeff
// (e.g., log-normal)
bool matrix_free = true; // use matrix-free stochastic operator
bool symmetric = false; // use symmetric formulation
double g_mean_exp = 0.172988; // expected response mean
double g_std_dev_exp = 0.0380007; // expected response std. dev.
double g_tol = 1e-6; // tolerance on determining success
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
int MyPID;
try {
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
MyPID = globalComm->MyPID();
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p, true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor();
else
Cijk = basis->computeLinearTripleProductTensor();
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
int num_spatial_procs = -1;
if (argc > 1)
num_spatial_procs = std::atoi(argv[1]);
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, mu, s, basis,
nonlinear_expansion, symmetric));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList& sgOpParams =
sgParams->sublist("SG Operator");
Teuchos::ParameterList& sgPrecParams =
sgParams->sublist("SG Preconditioner");
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
if (matrix_free) {
sgOpParams.set("Operator Method", "Matrix Free");
sgPrecParams.set("Preconditioner Method", "Approximate Gauss-Seidel");
sgPrecParams.set("Symmetric Gauss-Seidel", symmetric);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams.set("default values", "SA");
precParams.set("ML output", 0);
precParams.set("max levels",5);
precParams.set("increasing or decreasing","increasing");
precParams.set("aggregation: type", "Uncoupled");
precParams.set("smoother: type","ML symmetric Gauss-Seidel");
precParams.set("smoother: sweeps",2);
precParams.set("smoother: pre or post", "both");
precParams.set("coarse: max size", 200);
#ifdef HAVE_ML_AMESOS
precParams.set("coarse: type","Amesos-KLU");
#else
precParams.set("coarse: type","Jacobi");
#endif
}
else {
sgOpParams.set("Operator Method", "Fully Assembled");
sgPrecParams.set("Preconditioner Method", "None");
}
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams));
// Set up stochastic parameters
// The current implementation of the model doesn't actually use these
// values, but is hard-coded to certain uncertainty models
Teuchos::Array<double> point(num_KL, 1.0);
Teuchos::Array<double> basis_vals(sz);
basis->evaluateBases(point, basis_vals);
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_init =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_init->term(i,0)[i] = 0.0;
sg_p_init->term(i,1)[i] = 1.0 / basis_vals[i+1];
}
sg_model->set_p_sg_init(0, *sg_p_init);
// Setup stochastic initial guess
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_init =
sg_model->create_x_sg();
sg_x_init->init(0.0);
sg_model->set_x_sg_init(*sg_x_init);
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
if (symmetric)
lsParams.set("Aztec Solver", "CG");
else
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 1000);
lsParams.set("Size of Krylov Subspace", 100);
lsParams.set("Tolerance", 1e-12);
lsParams.set("Output Frequency", 1);
if (matrix_free)
lsParams.set("Preconditioner", "User Defined");
else {
lsParams.set("Preconditioner", "ML");
Teuchos::ParameterList& precParams =
lsParams.sublist("ML");
ML_Epetra::SetDefaults("DD", precParams);
lsParams.set("Write Linear System", false);
}
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", 1e-10);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 1);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linsys;
if (matrix_free) {
Teuchos::RCP<Epetra_Operator> M = sg_model->create_WPrec()->PrecOp;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec = nox_interface;
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iJac, A, iPrec, M,
*u));
}
else {
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iReq, iJac, A,
*u));
}
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status = solver->solve();
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Save final solution to file
EpetraExt::VectorToMatrixMarketFile("nox_stochastic_solution.mm",
finalSolution);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, &finalSolution);
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal.mm", std_dev);
// Evaluate SG responses at SG parameters
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs =
sg_model->createOutArgs();
Teuchos::RCP<const Epetra_Vector> sg_p = sg_model->get_p_init(1);
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(Teuchos::rcp(&finalSolution,false));
sg_outArgs.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs);
// Print mean and standard deviation of response
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << std::endl;
std::cout << "Response Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
// Determine if example passed
bool passed = false;
if (status == NOX::StatusTest::Converged &&
std::abs(g_mean[0]-g_mean_exp) < g_tol &&
std::abs(g_std_dev[0]-g_std_dev_exp) < g_tol)
passed = true;
if (MyPID == 0) {
if (passed)
std::cout << "Example Passed!" << std::endl;
else
std::cout << "Example Failed!" << std::endl;
}
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
void GUICutRenderWindow::renderImage(wxImage* image) {
//Speichern der Zeit für die Laufzeitmessung
timeval tm1;
gettimeofday(&tm1, NULL);
int width = imgWidthEdit->GetValue();
int height = imgHeightEdit->GetValue();
//aktualisieren der Skala
canvas->getScalePanel()->refresh(width, height);
//die Anzahl der zur Berechnung zu verwendenden Kerne
core_count = threadcountedit->GetValue();
/*
* Versuchen, die Interpolation durch vorgezogenes Testen des zuletzt verwendeten Tetraeders zu beschleunigen.
* Diese Option ist verursacht Ungenauigkeiten und bietet zumeist wenig Performancegewinn.
* Sie ist deshalb standardmäßig deaktiviert und nicht über die Programmoberfläche aktivierbar.
*/
bool use_last_tet = false;
//zurücksetzen der Grafik
delete image;
image = new wxImage(width, height, true);
image->InitAlpha();
//Punkt als Dezimaltrennzeichen
setlocale(LC_NUMERIC, "C");
//Eigenschaften der Temperaturverteilung
CutRender_info* info = getCutRenderProperties();
Triangle* tri = info->tri;
//X-Achse der Ebene im 3D-Raum
Vector3D* xvec = tri->getV2()->copy();
xvec->sub(tri->getV1());
//Normale der Ebene
Vector3D* tri_nor = tri->getNormal();
//Y-Achse der Ebene im 3D-Raum
Vector3D* yvec = xvec->crossProduct(tri_nor);
delete tri_nor;
xvec->normalize();
yvec->normalize();
//Das aktive Objekt
ObjectData* obj = wxGetApp().getActiveObject();
//Erstellen möglichst einfacher Geometrien für die Materialien
vector<tetgenio*> bases(obj->getMaterials()->size());
for (unsigned int i = 0; i < obj->getMaterials()->size(); i++) {
tetgenio* tri_io = new tetgenio();
string args = "Q";
tetrahedralize(const_cast<char*>(args.c_str()),
obj->getMaterials()->at(i).tetgeninput, tri_io, NULL, NULL);
bases.at(i) = tri_io;
}
//Zurücksetzen des Datenarrays für die Temperaturverteilung
if (value_img != NULL) {
delete[] value_img;
}
value_img = new float[width * height];
//Verknüpfen der Ausgabe mit den Temperaturverteilungsdaten und der Grafik
canvas->setImage(image);
canvas->setValueImg(value_img);
//Erstellen des Statusregisters für die Berechnungsthreads
bool thread_running[core_count];
for (int i = 0; i < core_count; i++) {
thread_running[i] = 1;
}
//Array für die Thread-Objekts
vector<thread*> threads = vector<thread*>(0);
//Array für die Kopierten Sensordaten. Das Kopieren ist erforderlich, da die Threads die Daten verändern (sortieren).
vector<vector<SensorPoint>> copied_sensor_data =
vector<vector<SensorPoint>>(core_count);
//Höhe für die Streifen, die die einzelnen Threads berechnen
int delta_h = height / core_count;
//Für alle Threads...
for (int i = 0; i < core_count; i++) {
//Die Starthöhe des Threads in der Temperaturverteilung
int startheight = delta_h * i;
//eventuelle Korrektur der Streifenhöhe für den letzten Thread
if (i == core_count - 1) {
if (startheight + delta_h < height) {
delta_h = height - startheight;
}
}
//Aktueller Sensordatensatz
SensorData* dataset = &obj->getSensorDataList()->at(
obj->getCurrentSensorIndex());
vector<SensorPoint>* original_sd = &dataset->data.at(
dataset->current_time_index);
copied_sensor_data.at(i).resize(original_sd->size());
//Kopieren der Sensordaten den Thread
for (int p = 0; p < int(original_sd->size()); p++) {
copySensorPoint(&original_sd->at(p),
&copied_sensor_data.at(i).at(p));
}
//Starten des Threads
threads.resize(threads.size() + 1,
new thread(render_thread, &thread_running[i], value_img, image,
width, height, startheight, delta_h, info, xvec, yvec,
tri->getV1(), &bases, obj, &copied_sensor_data.at(i),
use_last_tet));
}
//Pfüfzahl, ob noch Threads laufen
unsigned int running = 0;
//Solange threads laufen...
do {
//Ausgabe aktualisieren
canvas->Update();
canvas->Refresh();
//ermitteln der Pfüfzahl, ob noch Threads laufen. Wenn diese 0 bleibt, sind alle Threads fertig.
running = 0;
for (int i = 0; i < core_count; i++) {
running = running << 1;
running += thread_running[i];
};
} while (running);
//Threads zusammenführen
for (int i = 0; i < core_count; i++) {
threads.at(i)->join();
delete threads.at(i);
}
//Freigeben des Ebenendreiecks
for (int i = 0; i < 3; i++) {
delete tri->getVert(i);
}
delete tri;
//Zeitmessung beenden
timeval tm2;
gettimeofday(&tm2, NULL);
unsigned long long t = 1000 * (tm2.tv_sec - tm1.tv_sec)
+ (tm2.tv_usec - tm1.tv_usec) / 1000;
//Ausgeben der Berechnungsdauer auf
SetTitle(
wxT(
"Berechnung abgeschlossen. ( ") + floattowxstr(t / 1000.)+wxT( "s )"));
//Freigeben der Ressourcen
delete xvec;
delete yvec;
for (unsigned int i = 0; i < obj->getMaterials()->size(); i++) {
delete bases.at(i);
}
delete info;
}
UnitTestSetup() {
rtol = 1e-4;
atol = 1e-5;
crtol = 1e-12;
catol = 1e-12;
a = 3.1;
const ordinal_type d = 2;
const ordinal_type p = 7;
// Create product basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(d);
for (ordinal_type i=0; i<d; i++)
bases[i] =
Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(p, true));
basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<ordinal_type,value_type>(bases));
// Triple product tensor
Cijk = basis->computeTripleProductTensor();
// Kokkos triple product tensor
cijk = Stokhos::create_product_tensor<execution_space>(*basis, *Cijk);
// Algebraic expansion
exp = Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<ordinal_type,value_type>(basis, Cijk));
// Quad expansion for initialization
Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis));
Teuchos::RCP< Stokhos::QuadOrthogPolyExpansion<int,double> > quad_exp =
Teuchos::rcp(new Stokhos::QuadOrthogPolyExpansion<int,double>(basis, Cijk, quad));
// Create approximation
x_opa.reset(basis);
y_opa.reset(basis);
sin_x_opa.reset(basis);
cos_y_opa.reset(basis);
cx_opa.reset(basis,1);
x_opa.term(0, 0) = 1.0;
y_opa.term(0, 0) = 2.0;
cx_opa.term(0, 0) = a;
for (int i=0; i<d; i++) {
x_opa.term(i, 1) = 0.1;
y_opa.term(i, 1) = 0.25;
}
quad_exp->sin(sin_x_opa, x_opa);
quad_exp->cos(cos_y_opa, y_opa);
// Create PCEs
x.reset(cijk);
y.reset(cijk);
sin_x.reset(cijk);
cos_y.reset(cijk);
cx.reset(cijk, 1);
x.load(x_opa.coeff());
y.load(y_opa.coeff());
sin_x.load(sin_x_opa.coeff());
cos_y.load(cos_y_opa.coeff());
cx.load(cx_opa.coeff());
u.reset(cijk);
u2.reset(cijk);
cu.reset(cijk);
cu2.reset(cijk, 1);
sx.reset(cijk, d+1);
su.reset(cijk, d+1);
su2.reset(cijk, d+1);
for (ordinal_type i=0; i<d; i++) {
sx.fastAccessCoeff(i+1) = 0.0;
}
}
UnitTestSetup() {
rtol = 1e-4;
atol = 1e-5;
crtol = 1e-12;
catol = 1e-12;
a = 3.1;
const OrdinalType d = 2;
const OrdinalType p = 7;
// Create product basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<OrdinalType,ValueType> > > bases(d);
for (OrdinalType i=0; i<d; i++)
bases[i] =
Teuchos::rcp(new Stokhos::LegendreBasis<OrdinalType,ValueType>(p));
basis =
Teuchos::rcp(new product_basis_type(bases));
// Tensor product quadrature
quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<OrdinalType,ValueType>(basis));
// Tensor product pseudospectral operator
Teuchos::Array< Stokhos::EvenGrowthRule<OrdinalType> > point_growth(d);
ps_op =
Teuchos::rcp(new Stokhos::QuadraturePseudoSpectralOperator<OrdinalType,ValueType>(*basis, *quad));
// Triple product tensor
Cijk = basis->computeTripleProductTensor();
Cijk_linear = basis->computeLinearTripleProductTensor();
// Quadrature expansion
exp =
Teuchos::rcp(new Stokhos::PseudoSpectralOrthogPolyExpansion<OrdinalType,ValueType>(basis, Cijk, ps_op));
exp_linear =
Teuchos::rcp(new Stokhos::PseudoSpectralOrthogPolyExpansion<OrdinalType,ValueType>(basis, Cijk_linear, ps_op));
// Create approximation
sz = basis->size();
x.reset(basis);
y.reset(basis);
u.reset(basis);
u2.reset(basis);
cx.reset(basis, 1);
x.term(0, 0) = 1.0;
cx.term(0, 0) = a;
cu.reset(basis);
cu2.reset(basis, 1);
sx.reset(basis, d+1);
su.reset(basis, d+1);
su2.reset(basis, d+1);
for (OrdinalType i=0; i<d; i++) {
x.term(i, 1) = 0.1;
sx.term(i, 1) = 0.0;
}
y.term(0, 0) = 2.0;
for (OrdinalType i=0; i<d; i++)
y.term(i, 1) = 0.25;
}
int main(int argc, char **argv)
{
try {
const unsigned int d = 2;
const unsigned int pmin = 2;
const unsigned int pmax = 10;
const unsigned int np = pmax-pmin+1;
bool use_pce_quad_points = false;
bool normalize = true;
bool sparse_grid = true;
bool project_integrals = false;
#ifndef HAVE_STOKHOS_DAKOTA
sparse_grid = false;
#endif
Teuchos::Array<double> mean(np), mean_st(np), std_dev(np), std_dev_st(np);
Teuchos::Array<double> pt(np), pt_st(np);
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
Teuchos::Array<double> eval_pt(d, 0.5);
double pt_true;
// Loop over orders
unsigned int n = 0;
for (unsigned int p=pmin; p<=pmax; p++) {
std::cout << "p = " << p << std::endl;
// Create product basis
for (unsigned int i=0; i<d; i++)
bases[i] = Teuchos::rcp(new basis_type(p));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
// Create approximation
Stokhos::OrthogPolyApprox<int,double> x(basis), u(basis), v(basis),
w(basis), w2(basis);
for (unsigned int i=0; i<d; i++) {
x.term(i, 1) = 1.0;
}
double x_pt = x.evaluate(eval_pt);
pt_true = std::exp(std::sin(x_pt));
// Quadrature
Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad;
#ifdef HAVE_STOKHOS_DAKOTA
if (sparse_grid)
quad =
Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(basis, p));
#endif
if (!sparse_grid)
quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis));
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk =
basis->computeTripleProductTensor(basis->size());
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<int,double> quad_exp(basis, Cijk, quad);
// Compute PCE via quadrature expansion
quad_exp.sin(u,x);
//quad_exp.times(u,u,10.0);
quad_exp.exp(w,u);
// Compute Stieltjes basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > st_bases(1);
Teuchos::RCP<const Stokhos::LanczosProjPCEBasis<int,double> > st_1d_basis
= Teuchos::rcp(new Stokhos::LanczosProjPCEBasis<int,double>(
p, Teuchos::rcp(&u,false), Cijk, normalize));
st_bases[0] = st_1d_basis;
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> >
st_basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(st_bases));
//std::cout << *st_basis << std::endl;
Stokhos::OrthogPolyApprox<int,double> u_st(st_basis), w_st(st_basis);
u_st.term(0, 0) = st_1d_basis->getNewCoeffs(0);
u_st.term(0, 1) = st_1d_basis->getNewCoeffs(1);
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > st_Cijk =
st_basis->computeTripleProductTensor(st_basis->size());
// Tensor product quadrature
Teuchos::RCP<const Stokhos::Quadrature<int,double> > st_quad;
if (!use_pce_quad_points) {
#ifdef HAVE_STOKHOS_DAKOTA
if (sparse_grid)
st_quad = Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(st_basis, p));
#endif
if (!sparse_grid)
st_quad = Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(st_basis));
}
else {
Teuchos::Array<double> st_points_0;
Teuchos::Array<double> st_weights_0;
Teuchos::Array< Teuchos::Array<double> > st_values_0;
st_bases[0]->getQuadPoints(p+1, st_points_0, st_weights_0, st_values_0);
Teuchos::Array<double> st_points_1;
Teuchos::Array<double> st_weights_1;
Teuchos::Array< Teuchos::Array<double> > st_values_1;
st_bases[1]->getQuadPoints(p+1, st_points_1, st_weights_1, st_values_1);
Teuchos::RCP< Teuchos::Array< Teuchos::Array<double> > > st_points =
Teuchos::rcp(new Teuchos::Array< Teuchos::Array<double> >(st_points_0.size()));
for (int i=0; i<st_points_0.size(); i++) {
(*st_points)[i].resize(2);
(*st_points)[i][0] = st_points_0[i];
(*st_points)[i][1] = st_points_1[i];
}
Teuchos::RCP< Teuchos::Array<double> > st_weights =
Teuchos::rcp(new Teuchos::Array<double>(st_weights_0));
Teuchos::RCP< const Stokhos::OrthogPolyBasis<int,double> > st_b =
st_basis;
st_quad =
Teuchos::rcp(new Stokhos::UserDefinedQuadrature<int,double>(st_b,
st_points,
st_weights));
}
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<int,double> st_quad_exp(st_basis,
st_Cijk,
st_quad);
// Compute w_st = u_st*v_st in Stieltjes basis
st_quad_exp.exp(w_st, u_st);
// Project w_st back to original basis
pce_quad_func st_func(w_st, *st_basis);
quad_exp.unary_op(st_func, w2, u);
// std::cout.precision(12);
// std::cout << w;
// std::cout << w2;
// std::cout << w_st;
mean[n] = w.mean();
mean_st[n] = w2.mean();
std_dev[n] = w.standard_deviation();
std_dev_st[n] = w2.standard_deviation();
pt[n] = w.evaluate(eval_pt);
pt_st[n] = w2.evaluate(eval_pt);
n++;
}
n = 0;
int wi=10;
std::cout << "Statistical error:" << std::endl;
std::cout << "p "
<< std::setw(wi) << "mean" << " "
<< std::setw(wi) << "mean_st" << " "
<< std::setw(wi) << "std_dev" << " "
<< std::setw(wi) << "std_dev_st" << " "
<< std::setw(wi) << "point" << " "
<< std::setw(wi) << "point_st" << std::endl;
for (unsigned int p=pmin; p<pmax; p++) {
std::cout.precision(3);
std::cout.setf(std::ios::scientific);
std::cout << p << " "
<< std::setw(wi) << rel_err(mean[n], mean[np-1]) << " "
<< std::setw(wi) << rel_err(mean_st[n], mean[np-1]) << " "
<< std::setw(wi) << rel_err(std_dev[n], std_dev[np-1]) << " "
<< std::setw(wi) << rel_err(std_dev_st[n], std_dev[np-1])
<< " "
<< std::setw(wi) << rel_err(pt[n], pt_true) << " "
<< std::setw(wi) << rel_err(pt_st[n], pt_true)
<< std::endl;
n++;
}
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
}
UnitTestSetup() {
rtol = 1e-10;//4
atol = 1e-10;//5
crtol = 1e-12;
catol = 1e-12;
a = 3.1;
const OrdinalType d = 2;
const OrdinalType p = 7;
// Create product basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<OrdinalType,ValueType> > > bases(d);
for (OrdinalType i=0; i<d; i++)
bases[i] =
Teuchos::rcp(new Stokhos::LegendreBasis<OrdinalType,ValueType>(p));
basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<OrdinalType,ValueType>(bases));
// Tensor product quadrature
quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<OrdinalType,ValueType>(basis));
// Triple product tensor
Cijk = basis->computeTripleProductTensor(basis->size());
Cijk_linear = basis->computeTripleProductTensor(basis->dimension()+1);
// Algebraic expansion
exp =
Teuchos::rcp(new Stokhos::QuadOrthogPolyExpansion<OrdinalType,ValueType>(basis, Cijk, quad));
exp_linear =
Teuchos::rcp(new Stokhos::QuadOrthogPolyExpansion<OrdinalType,ValueType>(basis, Cijk_linear, quad));
// Quadrature expansion
qexp =
Teuchos::rcp(new Stokhos::QuadOrthogPolyExpansion<OrdinalType,ValueType>(basis, Cijk, quad));
//Dense Direct Division Operator
direct_division_strategy =
Teuchos::rcp(new Stokhos::DenseDirectDivisionExpansionStrategy<int,double,Stokhos::StandardStorage<int, double> >(basis, Cijk));
// Create approximation
// sz = basis->size();
x.reset(basis);
y.reset(basis);
u.reset(basis);
u2.reset(basis);
cx.reset(basis, 1);
x.term(0, 0) = 1.0;
// y.term(0, 0) = 1.0:
cx.term(0, 0) = a;
cu.reset(basis);
// cu2.reset(basis, 1);
// sx.reset(basis, d+1);
// su.reset(basis, d+1);
// su2.reset(basis, d+1);
for (OrdinalType i=0; i<d; i++) {
x.term(i, 1) = 1.0;
// y.term(i, 1) = 0.1;
}
// y.term(0, 0) = 2.0;
// for (OrdinalType i=0; i<d; i++)
// y.term(i, 1) = 0.25;
c1.reset(basis);
c1.term(0,0)=1;
exp->exp(cu, x);
}
int main(int argc, char *argv[]) {
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
int MyPID = globalComm->MyPID();
try {
// Setup command line options
Teuchos::CommandLineProcessor CLP;
CLP.setDocString(
"This example runs a variety of stochastic Galerkin solvers.\n");
int n = 32;
CLP.setOption("num_mesh", &n, "Number of mesh points in each direction");
bool symmetric = false;
CLP.setOption("symmetric", "unsymmetric", &symmetric,
"Symmetric discretization");
int num_spatial_procs = -1;
CLP.setOption("num_spatial_procs", &num_spatial_procs, "Number of spatial processors (set -1 for all available procs)");
bool rebalance_stochastic_graph = false;
CLP.setOption("rebalance", "no-rebalance", &rebalance_stochastic_graph,
"Rebalance parallel stochastic graph (requires Isorropia)");
SG_RF randField = UNIFORM;
CLP.setOption("rand_field", &randField,
num_sg_rf, sg_rf_values, sg_rf_names,
"Random field type");
double mean = 0.2;
CLP.setOption("mean", &mean, "Mean");
double sigma = 0.1;
CLP.setOption("std_dev", &sigma, "Standard deviation");
double weightCut = 1.0;
CLP.setOption("weight_cut", &weightCut, "Weight cut");
int num_KL = 2;
CLP.setOption("num_kl", &num_KL, "Number of KL terms");
int p = 3;
CLP.setOption("order", &p, "Polynomial order");
bool normalize_basis = true;
CLP.setOption("normalize", "unnormalize", &normalize_basis,
"Normalize PC basis");
SG_Solver solve_method = SG_KRYLOV;
CLP.setOption("sg_solver", &solve_method,
num_sg_solver, sg_solver_values, sg_solver_names,
"SG solver method");
Krylov_Method outer_krylov_method = GMRES;
CLP.setOption("outer_krylov_method", &outer_krylov_method,
num_krylov_method, krylov_method_values, krylov_method_names,
"Outer Krylov method (for Krylov-based SG solver)");
Krylov_Solver outer_krylov_solver = AZTECOO;
CLP.setOption("outer_krylov_solver", &outer_krylov_solver,
num_krylov_solver, krylov_solver_values, krylov_solver_names,
"Outer linear solver");
double outer_tol = 1e-12;
CLP.setOption("outer_tol", &outer_tol, "Outer solver tolerance");
int outer_its = 1000;
CLP.setOption("outer_its", &outer_its, "Maximum outer iterations");
Krylov_Method inner_krylov_method = GMRES;
CLP.setOption("inner_krylov_method", &inner_krylov_method,
num_krylov_method, krylov_method_values, krylov_method_names,
"Inner Krylov method (for G-S, Jacobi, etc...)");
Krylov_Solver inner_krylov_solver = AZTECOO;
CLP.setOption("inner_krylov_solver", &inner_krylov_solver,
num_krylov_solver, krylov_solver_values, krylov_solver_names,
"Inner linear solver");
double inner_tol = 3e-13;
CLP.setOption("inner_tol", &inner_tol, "Inner solver tolerance");
int inner_its = 1000;
CLP.setOption("inner_its", &inner_its, "Maximum inner iterations");
SG_Op opMethod = MATRIX_FREE;
CLP.setOption("sg_operator_method", &opMethod,
num_sg_op, sg_op_values, sg_op_names,
"Operator method");
SG_Prec precMethod = AGS;
CLP.setOption("sg_prec_method", &precMethod,
num_sg_prec, sg_prec_values, sg_prec_names,
"Preconditioner method");
double gs_prec_tol = 1e-1;
CLP.setOption("gs_prec_tol", &gs_prec_tol, "Gauss-Seidel preconditioner tolerance");
int gs_prec_its = 1;
CLP.setOption("gs_prec_its", &gs_prec_its, "Maximum Gauss-Seidel preconditioner iterations");
CLP.parse( argc, argv );
if (MyPID == 0) {
std::cout << "Summary of command line options:" << std::endl
<< "\tnum_mesh = " << n << std::endl
<< "\tsymmetric = " << symmetric << std::endl
<< "\tnum_spatial_procs = " << num_spatial_procs << std::endl
<< "\trebalance = " << rebalance_stochastic_graph
<< std::endl
<< "\trand_field = " << sg_rf_names[randField]
<< std::endl
<< "\tmean = " << mean << std::endl
<< "\tstd_dev = " << sigma << std::endl
<< "\tweight_cut = " << weightCut << std::endl
<< "\tnum_kl = " << num_KL << std::endl
<< "\torder = " << p << std::endl
<< "\tnormalize_basis = " << normalize_basis << std::endl
<< "\tsg_solver = " << sg_solver_names[solve_method]
<< std::endl
<< "\touter_krylov_method = "
<< krylov_method_names[outer_krylov_method] << std::endl
<< "\touter_krylov_solver = "
<< krylov_solver_names[outer_krylov_solver] << std::endl
<< "\touter_tol = " << outer_tol << std::endl
<< "\touter_its = " << outer_its << std::endl
<< "\tinner_krylov_method = "
<< krylov_method_names[inner_krylov_method] << std::endl
<< "\tinner_krylov_solver = "
<< krylov_solver_names[inner_krylov_solver] << std::endl
<< "\tinner_tol = " << inner_tol << std::endl
<< "\tinner_its = " << inner_its << std::endl
<< "\tsg_operator_method = " << sg_op_names[opMethod]
<< std::endl
<< "\tsg_prec_method = " << sg_prec_names[precMethod]
<< std::endl
<< "\tgs_prec_tol = " << gs_prec_tol << std::endl
<< "\tgs_prec_its = " << gs_prec_its << std::endl;
}
bool nonlinear_expansion = false;
if (randField == UNIFORM || randField == RYS)
nonlinear_expansion = false;
else if (randField == LOGNORMAL)
nonlinear_expansion = true;
bool scaleOP = true;
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
if (randField == UNIFORM)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p,normalize_basis));
else if (randField == RYS)
bases[i] = Teuchos::rcp(new Stokhos::RysBasis<int,double>(p,weightCut,normalize_basis));
else if (randField == LOGNORMAL)
bases[i] = Teuchos::rcp(new Stokhos::HermiteBasis<int,double>(p,normalize_basis));
// bases[i] = Teuchos::rcp(new Stokhos::DiscretizedStieltjesBasis<int,double>("beta",p,&uniform_weight,-weightCut,weightCut,true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor(sz);
else
Cijk = basis->computeTripleProductTensor(num_KL+1);
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
parallelParams.set("Rebalance Stochastic Graph",
rebalance_stochastic_graph);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, sigma,
mean, basis, nonlinear_expansion,
symmetric));
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
//NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
// Alternative linear solver list for Stratimikos
Teuchos::ParameterList& stratLinSolParams =
newtonParams.sublist("Stratimikos Linear Solver");
// Teuchos::ParameterList& noxStratParams =
// stratLinSolParams.sublist("NOX Stratimikos Options");
Teuchos::ParameterList& stratParams =
stratLinSolParams.sublist("Stratimikos");
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", outer_tol);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 1);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> det_nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> det_u = model->get_x_init();
Teuchos::RCP<Epetra_Operator> det_A = model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> det_iReq = det_nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> det_iJac = det_nox_interface;
Teuchos::ParameterList det_printParams;
det_printParams.set("MyPID", MyPID);
det_printParams.set("Output Precision", 3);
det_printParams.set("Output Processor", 0);
det_printParams.set("Output Information", NOX::Utils::Error);
Teuchos::ParameterList det_lsParams;
Teuchos::ParameterList& det_stratParams =
det_lsParams.sublist("Stratimikos");
if (inner_krylov_solver == AZTECOO) {
det_stratParams.set("Linear Solver Type", "AztecOO");
Teuchos::ParameterList& aztecOOParams =
det_stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("Forward Solve");
Teuchos::ParameterList& aztecOOSettings =
aztecOOParams.sublist("AztecOO Settings");
if (inner_krylov_method == GMRES) {
aztecOOSettings.set("Aztec Solver","GMRES");
}
else if (inner_krylov_method == CG) {
aztecOOSettings.set("Aztec Solver","CG");
}
aztecOOSettings.set("Output Frequency", 0);
aztecOOSettings.set("Size of Krylov Subspace", 100);
aztecOOParams.set("Max Iterations", inner_its);
aztecOOParams.set("Tolerance", inner_tol);
Teuchos::ParameterList& verbParams =
det_stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("VerboseObject");
verbParams.set("Verbosity Level", "none");
}
else if (inner_krylov_solver == BELOS) {
det_stratParams.set("Linear Solver Type", "Belos");
Teuchos::ParameterList& belosParams =
det_stratParams.sublist("Linear Solver Types").sublist("Belos");
Teuchos::ParameterList* belosSolverParams = NULL;
if (inner_krylov_method == GMRES || inner_krylov_method == FGMRES) {
belosParams.set("Solver Type","Block GMRES");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block GMRES"));
if (inner_krylov_method == FGMRES)
belosSolverParams->set("Flexible Gmres", true);
}
else if (inner_krylov_method == CG) {
belosParams.set("Solver Type","Block CG");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block CG"));
}
else if (inner_krylov_method == RGMRES) {
belosParams.set("Solver Type","GCRODR");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("GCRODR"));
}
belosSolverParams->set("Convergence Tolerance", inner_tol);
belosSolverParams->set("Maximum Iterations", inner_its);
belosSolverParams->set("Output Frequency",0);
belosSolverParams->set("Output Style",1);
belosSolverParams->set("Verbosity",0);
Teuchos::ParameterList& verbParams = belosParams.sublist("VerboseObject");
verbParams.set("Verbosity Level", "none");
}
det_stratParams.set("Preconditioner Type", "ML");
Teuchos::ParameterList& det_ML =
det_stratParams.sublist("Preconditioner Types").sublist("ML").sublist("ML Settings");
ML_Epetra::SetDefaults("SA", det_ML);
det_ML.set("ML output", 0);
det_ML.set("max levels",5);
det_ML.set("increasing or decreasing","increasing");
det_ML.set("aggregation: type", "Uncoupled");
det_ML.set("smoother: type","ML symmetric Gauss-Seidel");
det_ML.set("smoother: sweeps",2);
det_ML.set("smoother: pre or post", "both");
det_ML.set("coarse: max size", 200);
#ifdef HAVE_ML_AMESOS
det_ML.set("coarse: type","Amesos-KLU");
#else
det_ML.set("coarse: type","Jacobi");
#endif
Teuchos::RCP<NOX::Epetra::LinearSystem> det_linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
det_printParams, det_lsParams, det_iJac,
det_A, *det_u));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList& sgOpParams =
sgParams->sublist("SG Operator");
Teuchos::ParameterList& sgPrecParams =
sgParams->sublist("SG Preconditioner");
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
if (opMethod == MATRIX_FREE)
sgOpParams.set("Operator Method", "Matrix Free");
else if (opMethod == KL_MATRIX_FREE)
sgOpParams.set("Operator Method", "KL Matrix Free");
else if (opMethod == KL_REDUCED_MATRIX_FREE) {
sgOpParams.set("Operator Method", "KL Reduced Matrix Free");
if (randField == UNIFORM || randField == RYS)
sgOpParams.set("Number of KL Terms", num_KL);
else
sgOpParams.set("Number of KL Terms", basis->size());
sgOpParams.set("KL Tolerance", outer_tol);
sgOpParams.set("Sparse 3 Tensor Drop Tolerance", outer_tol);
sgOpParams.set("Do Error Tests", true);
}
else if (opMethod == FULLY_ASSEMBLED)
sgOpParams.set("Operator Method", "Fully Assembled");
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error! Unknown operator method " << opMethod
<< "." << std::endl);
if (precMethod == MEAN) {
sgPrecParams.set("Preconditioner Method", "Mean-based");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if(precMethod == GS) {
sgPrecParams.set("Preconditioner Method", "Gauss-Seidel");
sgPrecParams.sublist("Deterministic Solver Parameters") = det_lsParams;
sgPrecParams.set("Deterministic Solver", det_linsys);
sgPrecParams.set("Max Iterations", gs_prec_its);
sgPrecParams.set("Tolerance", gs_prec_tol);
}
else if (precMethod == AGS) {
sgPrecParams.set("Preconditioner Method", "Approximate Gauss-Seidel");
if (outer_krylov_method == CG)
sgPrecParams.set("Symmetric Gauss-Seidel", true);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if (precMethod == AJ) {
sgPrecParams.set("Preconditioner Method", "Approximate Jacobi");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
Teuchos::ParameterList& jacobiOpParams =
sgPrecParams.sublist("Jacobi SG Operator");
jacobiOpParams.set("Only Use Linear Terms", true);
}
else if (precMethod == ASC) {
sgPrecParams.set("Preconditioner Method", "Approximate Schur Complement");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if (precMethod == KP) {
sgPrecParams.set("Preconditioner Method", "Kronecker Product");
sgPrecParams.set("Only Use Linear Terms", true);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& meanPrecParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
meanPrecParams = det_ML;
sgPrecParams.set("G Preconditioner Type", "Ifpack");
Teuchos::ParameterList& GPrecParams =
sgPrecParams.sublist("G Preconditioner Parameters");
if (outer_krylov_method == GMRES || outer_krylov_method == FGMRES)
GPrecParams.set("Ifpack Preconditioner", "ILUT");
if (outer_krylov_method == CG)
GPrecParams.set("Ifpack Preconditioner", "ICT");
GPrecParams.set("Overlap", 1);
GPrecParams.set("fact: drop tolerance", 1e-4);
GPrecParams.set("fact: ilut level-of-fill", 1.0);
GPrecParams.set("schwarz: combine mode", "Add");
}
else if (precMethod == NONE) {
sgPrecParams.set("Preconditioner Method", "None");
}
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error! Unknown preconditioner method " << precMethod
<< "." << std::endl);
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams, scaleOP));
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs =
sg_model->createOutArgs();
// Set up stochastic parameters
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_init =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_init->term(i,0)[i] = 0.0;
sg_p_init->term(i,1)[i] = 1.0;
}
sg_model->set_p_sg_init(0, *sg_p_init);
// Setup stochastic initial guess
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_init =
sg_model->create_x_sg();
sg_x_init->init(0.0);
sg_model->set_x_sg_init(*sg_x_init);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX stochastic linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<const Epetra_Map> base_map = model->get_x_map();
Teuchos::RCP<const Epetra_Map> sg_map = sg_model->get_x_map();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
// Build linear solver
Teuchos::RCP<NOX::Epetra::LinearSystem> linsys;
if (solve_method==SG_KRYLOV) {
bool has_M =
sg_outArgs.supports(EpetraExt::ModelEvaluator::OUT_ARG_WPrec);
Teuchos::RCP<Epetra_Operator> M;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec;
if (has_M) {
M = sg_model->create_WPrec()->PrecOp;
iPrec = nox_interface;
}
stratParams.set("Preconditioner Type", "None");
if (outer_krylov_solver == AZTECOO) {
stratParams.set("Linear Solver Type", "AztecOO");
Teuchos::ParameterList& aztecOOParams =
stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("Forward Solve");
Teuchos::ParameterList& aztecOOSettings =
aztecOOParams.sublist("AztecOO Settings");
if (outer_krylov_method == GMRES) {
aztecOOSettings.set("Aztec Solver","GMRES");
}
else if (outer_krylov_method == CG) {
aztecOOSettings.set("Aztec Solver","CG");
}
aztecOOSettings.set("Output Frequency", 1);
aztecOOSettings.set("Size of Krylov Subspace", 100);
aztecOOParams.set("Max Iterations", outer_its);
aztecOOParams.set("Tolerance", outer_tol);
stratLinSolParams.set("Preconditioner", "User Defined");
if (has_M)
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, iPrec, M,
*u, true));
else
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, *u));
}
else if (outer_krylov_solver == BELOS){
stratParams.set("Linear Solver Type", "Belos");
Teuchos::ParameterList& belosParams =
stratParams.sublist("Linear Solver Types").sublist("Belos");
Teuchos::ParameterList* belosSolverParams = NULL;
if (outer_krylov_method == GMRES || outer_krylov_method == FGMRES) {
belosParams.set("Solver Type","Block GMRES");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block GMRES"));
if (outer_krylov_method == FGMRES)
belosSolverParams->set("Flexible Gmres", true);
}
else if (outer_krylov_method == CG) {
belosParams.set("Solver Type","Block CG");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block CG"));
}
else if (inner_krylov_method == RGMRES) {
belosParams.set("Solver Type","GCRODR");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("GCRODR"));
}
belosSolverParams->set("Convergence Tolerance", outer_tol);
belosSolverParams->set("Maximum Iterations", outer_its);
belosSolverParams->set("Output Frequency",1);
belosSolverParams->set("Output Style",1);
belosSolverParams->set("Verbosity",33);
stratLinSolParams.set("Preconditioner", "User Defined");
if (has_M)
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, iPrec, M,
*u, true));
else
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, *u));
}
}
else if (solve_method==SG_GS) {
lsParams.sublist("Deterministic Solver Parameters") = det_lsParams;
lsParams.set("Max Iterations", outer_its);
lsParams.set("Tolerance", outer_tol);
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemSGGS(
printParams, lsParams, det_linsys, iReq, iJac,
basis, sg_parallel_data, A, base_map, sg_map));
}
else {
lsParams.sublist("Deterministic Solver Parameters") = det_lsParams;
lsParams.set("Max Iterations", outer_its);
lsParams.set("Tolerance", outer_tol);
Teuchos::ParameterList& jacobiOpParams =
lsParams.sublist("Jacobi SG Operator");
jacobiOpParams.set("Only Use Linear Terms", true);
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemSGJacobi(
printParams, lsParams, det_linsys, iReq, iJac,
basis, sg_parallel_data, A, base_map, sg_map));
}
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status;
{
TEUCHOS_FUNC_TIME_MONITOR("Total Solve Time");
status = solver->solve();
}
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Save final solution to file
EpetraExt::VectorToMatrixMarketFile("nox_solver_stochastic_solution.mm",
finalSolution);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, &finalSolution);
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal.mm", std_dev);
// Evaluate SG responses at SG parameters
Teuchos::RCP<const Epetra_Vector> sg_p = sg_model->get_p_init(1);
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(Teuchos::rcp(&finalSolution,false));
sg_outArgs.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs);
// Print mean and standard deviation of response
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << "\nResponse Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
if (status == NOX::StatusTest::Converged && MyPID == 0)
utils.out() << "Example Passed!" << std::endl;
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
int main(int argc, char **argv)
{
try {
// Basis of dimension 3, order 5
const int d = 3;
const int p = 5;
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
for (int i=0; i<d; i++) {
bases[i] = Teuchos::rcp(new Stokhos::HermiteBasis<int,double>(p));
}
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
// Quadrature method
Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis));
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk =
basis->computeTripleProductTensor(basis->size());
// Expansion method
Stokhos::QuadOrthogPolyExpansion<int,double> expn(basis, Cijk, quad);
// Polynomial expansions
Stokhos::OrthogPolyApprox<int,double> u(basis), v(basis), w(basis);
u.term(0,0) = 1.0;
for (int i=0; i<d; i++) {
u.term(i,1) = 0.4 / d;
u.term(i,2) = 0.06 / d;
u.term(i,3) = 0.002 / d;
}
// Compute expansion
expn.log(v,u);
expn.times(w,v,v);
expn.plusEqual(w,1.0);
expn.divide(v,1.0,w);
// Print u and v
std::cout << "v = 1.0 / (log(u)^2 + 1):" << std::endl;
std::cout << "\tu = ";
u.print(std::cout);
std::cout << "\tv = ";
v.print(std::cout);
// Compute moments
double mean = v.mean();
double std_dev = v.standard_deviation();
// Evaluate PCE and function at a point = 0.25 in each dimension
Teuchos::Array<double> pt(d);
for (int i=0; i<d; i++)
pt[i] = 0.25;
double up = u.evaluate(pt);
double vp = 1.0/(std::log(up)*std::log(up)+1.0);
double vp2 = v.evaluate(pt);
// Print results
std::cout << "\tv mean = " << mean << std::endl;
std::cout << "\tv std. dev. = " << std_dev << std::endl;
std::cout << "\tv(0.25) (true) = " << vp << std::endl;
std::cout << "\tv(0.25) (pce) = " << vp2 << std::endl;
// Check the answer
if (std::abs(vp - vp2) < 1e-2)
std::cout << "\nExample Passed!" << std::endl;
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
}
Lanczos_PCE_Setup(bool normalize, bool project) :
func()
{
rtol = 1e-8;
atol = 1e-12;
const OrdinalType d = 3;
const OrdinalType p = 5;
// Create product basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<OrdinalType,ValueType> > > bases(d);
for (OrdinalType i=0; i<d; i++)
bases[i] =
Teuchos::rcp(new Stokhos::LegendreBasis<OrdinalType,ValueType>(p));
basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<OrdinalType,ValueType>(bases));
// Create approximation
sz = basis->size();
Stokhos::OrthogPolyApprox<OrdinalType,ValueType> x(basis);
for (OrdinalType i=0; i<d; i++)
x.term(i, 1) = 1.0;
// Tensor product quadrature
Teuchos::RCP<const Stokhos::Quadrature<OrdinalType,ValueType> > quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<OrdinalType,ValueType>(basis, 4*p));
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk =
basis->computeTripleProductTensor(basis->size());
// Quadrature expansion
exp = Teuchos::rcp(new Stokhos::QuadOrthogPolyExpansion<OrdinalType,ValueType>(basis, Cijk, quad));
// Compute PCE via quadrature expansion
u.reset(basis);
v.reset(basis);
func.eval(*exp, x, u);
exp->times(v,u,u);
// Compute Lanczos basis
st_bases.resize(1);
if (project) {
st_1d_proj_basis =
Teuchos::rcp(new Stokhos::LanczosProjPCEBasis<OrdinalType,ValueType>(
p, Teuchos::rcp(&u,false), Cijk, normalize));
st_bases[0] = st_1d_proj_basis;
}
else {
st_1d_basis =
Teuchos::rcp(new Stokhos::LanczosPCEBasis<OrdinalType,ValueType>(
p, Teuchos::rcp(&u,false), quad, normalize, false));
st_bases[0] = st_1d_basis;
}
st_basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<OrdinalType,ValueType>(st_bases, 1e-15));
st_sz = st_basis->size();
u_st.reset(st_basis);
v_st.reset(st_basis);
if (project) {
u_st[0] = st_1d_proj_basis->getNewCoeffs(0);
u_st[1] = st_1d_proj_basis->getNewCoeffs(1);
}
else {
u_st[0] = st_1d_basis->getNewCoeffs(0);
u_st[1] = st_1d_basis->getNewCoeffs(1);
}
// Tensor product quadrature
st_quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<OrdinalType,ValueType>(st_basis));
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > st_Cijk =
st_basis->computeTripleProductTensor(st_basis->size());
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<OrdinalType,ValueType> st_exp(st_basis,
st_Cijk,
st_quad);
st_exp.times(v_st, u_st, u_st);
}
int main(int argc, char *argv[]) {
int n = 32; // spatial discretization (per dimension)
int num_KL = 2; // number of KL terms
int p = 3; // polynomial order
double mu = 0.1; // mean of exponential random field
double s = 0.2; // std. dev. of exponential r.f.
bool nonlinear_expansion = false; // nonlinear expansion of diffusion coeff
// (e.g., log-normal)
bool symmetric = false; // use symmetric formulation
double g_mean_exp = 0.172988; // expected response mean
double g_std_dev_exp = 0.0380007; // expected response std. dev.
double g_tol = 1e-6; // tolerance on determining success
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
int MyPID;
try {
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
MyPID = globalComm->MyPID();
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p,true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases,
1e-12));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor(sz);
else
Cijk = basis->computeTripleProductTensor(num_KL+1);
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
int num_spatial_procs = -1;
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
// parallelParams.set("Rebalance Stochastic Graph", true);
// Teuchos::ParameterList& isorropia_params =
// parallelParams.sublist("Isorropia");
// isorropia_params.set("Balance objective", "nonzeros");
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, mu, s, basis,
nonlinear_expansion, symmetric));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
Teuchos::ParameterList precParams;
precParams.set("default values", "SA");
precParams.set("ML output", 0);
precParams.set("max levels",5);
precParams.set("increasing or decreasing","increasing");
precParams.set("aggregation: type", "Uncoupled");
precParams.set("smoother: type","ML symmetric Gauss-Seidel");
precParams.set("smoother: sweeps",2);
precParams.set("smoother: pre or post", "both");
precParams.set("coarse: max size", 200);
//precParams.set("PDE equations",sz);
#ifdef HAVE_ML_AMESOS
precParams.set("coarse: type","Amesos-KLU");
#else
precParams.set("coarse: type","Jacobi");
#endif
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator_Interlaced> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator_Interlaced(
model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams));
// Set up stochastic parameters
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_poly =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_poly->term(i,0)[i] = 0.0;
sg_p_poly->term(i,1)[i] = 1.0;
}
// Create vectors and operators
Teuchos::RCP<const Epetra_Vector> sg_p = sg_p_poly->getBlockVector();
Teuchos::RCP<Epetra_Vector> sg_x =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_x_map())));
sg_x->PutScalar(0.0);
Teuchos::RCP<Epetra_Vector> sg_f =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_f_map())));
Teuchos::RCP<Epetra_Vector> sg_dx =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_x_map())));
Teuchos::RCP<Epetra_CrsMatrix> sg_J =
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(sg_model->create_W());
Teuchos::RCP<ML_Epetra::MultiLevelPreconditioner> sg_M =
Teuchos::rcp(new ML_Epetra::MultiLevelPreconditioner(*sg_J, precParams,
false));
// Setup InArgs and OutArgs
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs = sg_model->createOutArgs();
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(sg_x);
sg_outArgs.set_f(sg_f);
sg_outArgs.set_W(sg_J);
// Evaluate model
sg_model->evalModel(sg_inArgs, sg_outArgs);
sg_M->ComputePreconditioner();
// Print initial residual norm
double norm_f;
sg_f->Norm2(&norm_f);
if (MyPID == 0)
std::cout << "\nInitial residual norm = " << norm_f << std::endl;
// Setup AztecOO solver
AztecOO aztec;
if (symmetric)
aztec.SetAztecOption(AZ_solver, AZ_cg);
else
aztec.SetAztecOption(AZ_solver, AZ_gmres);
aztec.SetAztecOption(AZ_precond, AZ_none);
aztec.SetAztecOption(AZ_kspace, 20);
aztec.SetAztecOption(AZ_conv, AZ_r0);
aztec.SetAztecOption(AZ_output, 1);
aztec.SetUserOperator(sg_J.get());
aztec.SetPrecOperator(sg_M.get());
aztec.SetLHS(sg_dx.get());
aztec.SetRHS(sg_f.get());
// Solve linear system
aztec.Iterate(1000, 1e-12);
// Update x
sg_x->Update(-1.0, *sg_dx, 1.0);
// Save solution to file
EpetraExt::VectorToMatrixMarketFile("stochastic_solution_interlaced.mm",
*sg_x);
// Save RHS to file
EpetraExt::VectorToMatrixMarketFile("stochastic_RHS_interlaced.mm",
*sg_f);
// Save operator to file
EpetraExt::RowMatrixToMatrixMarketFile("stochastic_operator_interlaced.mm",
*sg_J);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, sg_x.get());
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal_interlaced.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal_interlaced.mm", std_dev);
// Compute new residual & response function
EpetraExt::ModelEvaluator::OutArgs sg_outArgs2 = sg_model->createOutArgs();
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_f->PutScalar(0.0);
sg_outArgs2.set_f(sg_f);
sg_outArgs2.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs2);
// Print initial residual norm
sg_f->Norm2(&norm_f);
if (MyPID == 0)
std::cout << "\nFinal residual norm = " << norm_f << std::endl;
// Print mean and standard deviation of responses
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << "\nResponse Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
// Determine if example passed
bool passed = false;
if (norm_f < 1.0e-10 &&
std::abs(g_mean[0]-g_mean_exp) < g_tol &&
std::abs(g_std_dev[0]-g_std_dev_exp) < g_tol)
passed = true;
if (MyPID == 0) {
if (passed)
std::cout << "Example Passed!" << std::endl;
else
std::cout << "Example Failed!" << std::endl;
}
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
int main(int argc, char **argv)
{
try {
// Compute "true" 1-D mean, std. dev using quadrature
const unsigned int true_quad_order = 200;
basis_type tmp_basis(1);
Teuchos::Array<double> true_quad_points, true_quad_weights;
Teuchos::Array< Teuchos::Array<double> > true_quad_values;
tmp_basis.getQuadPoints(true_quad_order, true_quad_points,
true_quad_weights, true_quad_values);
double mean_1d = 0.0;
double sd_1d = 0.0;
for (unsigned int qp=0; qp<true_quad_points.size(); qp++) {
double t = std::exp(true_quad_points[qp]);
mean_1d += t*true_quad_weights[qp];
sd_1d += t*t*true_quad_weights[qp];
}
const unsigned int dmin = 1;
const unsigned int dmax = 4;
const unsigned int pmin = 1;
const unsigned int pmax = 5;
// Loop over dimensions
for (unsigned int d=dmin; d<=dmax; d++) {
// compute "true" values
double true_mean = std::pow(mean_1d,static_cast<double>(d));
double true_sd = std::pow(sd_1d,static_cast<double>(d)) -
true_mean*true_mean;
true_sd = std::sqrt(true_sd);
std::cout.precision(12);
std::cout << "true mean = " << true_mean << "\t true std. dev. = "
<< true_sd << std::endl;
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
// Loop over orders
for (unsigned int p=pmin; p<=pmax; p++) {
// Create product basis
for (unsigned int i=0; i<d; i++)
bases[i] = Teuchos::rcp(new basis_type(p));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
// Create approximation
int sz = basis->size();
Stokhos::OrthogPolyApprox<int,double> x(basis), u(basis);
for (unsigned int i=0; i<d; i++) {
x.term(i,1) = 1.0;
}
// Tensor product quadrature
Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis));
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk =
basis->computeTripleProductTensor();
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<int,double> quad_exp(basis, Cijk,
quad);
// Compute PCE via quadrature expansion
quad_exp.exp(u,x);
double mean = u.mean();
double sd = u.standard_deviation();
std::cout.precision(4);
std::cout.setf(std::ios::scientific);
std::cout << "d = " << d << " p = " << p
<< " sz = " << sz
<< "\tmean err = "
<< std::fabs(true_mean-mean) << "\tstd. dev. err = "
<< std::fabs(true_sd-sd) << std::endl;
}
}
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
}
