snl_fei_Factory.cpp

00001 /*--------------------------------------------------------------------*/
00002 /*    Copyright 2005 Sandia Corporation.                              */
00003 /*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
00004 /*    non-exclusive license for use of this work by or on behalf      */
00005 /*    of the U.S. Government.  Export of this program may require     */
00006 /*    a license from the United States Government.                    */
00007 /*--------------------------------------------------------------------*/
00008 #ifndef _snl_fei_Factory_cpp_
00009 #define _snl_fei_Factory_cpp_
00010 
00011 #include <fei_macros.hpp>
00012 
00013 #include <snl_fei_Factory.hpp>
00014 
00015 //----------------------------------------------------------------------------
00016 snl_fei::Factory::Factory(MPI_Comm comm,
00017                           fei::SharedPtr<LibraryWrapper> wrapper)
00018   : fei::Factory(comm),
00019     comm_(comm),
00020     broker_(),
00021     matrixGraph_(),
00022     nodeIDType_(0),
00023     lsc_(),
00024     feData_(),
00025     wrapper_(wrapper),
00026     outputLevel_(0),
00027     blockMatrix_(false)
00028 {
00029   if (wrapper_.get() != NULL) {
00030     lsc_ = wrapper->getLinearSystemCore();
00031     feData_ = wrapper->getFiniteElementData();
00032   }
00033 }
00034 
00035 //----------------------------------------------------------------------------
00036 snl_fei::Factory::Factory(MPI_Comm comm,
00037                           fei::SharedPtr<LinearSystemCore> lsc)
00038   : fei::Factory(comm),
00039     comm_(comm),
00040     broker_(),
00041     matrixGraph_(),
00042     nodeIDType_(0),
00043     lsc_(lsc),
00044     feData_(),
00045     wrapper_(),
00046     outputLevel_(0)
00047 {
00048 }
00049 
00050 //----------------------------------------------------------------------------
00051 snl_fei::Factory::Factory(MPI_Comm comm,
00052                           fei::SharedPtr<FiniteElementData> feData, int nodeIDType)
00053   : fei::Factory(comm),
00054     comm_(comm),
00055     broker_(),
00056     matrixGraph_(),
00057     nodeIDType_(nodeIDType),
00058     lsc_(),
00059     feData_(feData),
00060     wrapper_(NULL),
00061     outputLevel_(0)
00062 {
00063 }
00064 
00065 //----------------------------------------------------------------------------
00066 snl_fei::Factory::~Factory()
00067 {
00068 }
00069 
00070 //----------------------------------------------------------------------------
00071 fei::SharedPtr<fei::Factory>
00072 snl_fei::Factory::clone() const
00073 {
00074   fei::SharedPtr<fei::Factory> factory;
00075   if (wrapper_.get() != NULL) {
00076     factory.reset(new snl_fei::Factory(comm_, wrapper_));
00077   }
00078   else if (lsc_.get() != NULL) {
00079     factory.reset(new snl_fei::Factory(comm_, lsc_));
00080   }
00081   else if (feData_.get() != NULL) {
00082     factory.reset(new snl_fei::Factory(comm_, feData_, nodeIDType_));
00083   }
00084 
00085   return(factory);
00086 }
00087 
00088 //----------------------------------------------------------------------------
00089 void
00090 snl_fei::Factory::parameters(const fei::ParameterSet& parameterset)
00091 {
00092   fei::Factory::parameters(parameterset);
00093 
00094   int err = 0;
00095   if (lsc_.get() != NULL || feData_.get() != NULL) {
00096     int numParams = 0;
00097     const char** paramStrings = NULL;
00098     std::vector<std::string> stdstrings;
00099     fei::utils::convert_ParameterSet_to_strings(&parameterset, stdstrings);
00100     fei::utils::strings_to_char_ptrs(stdstrings, numParams, paramStrings);
00101     char** nc_paramStrings = const_cast<char**>(paramStrings);
00102     if (lsc_.get() != NULL) {
00103       err += lsc_->parameters(numParams, nc_paramStrings);
00104     }
00105     if (feData_.get() != NULL) {
00106       err += feData_->parameters(numParams, nc_paramStrings);
00107     }
00108 
00109     delete [] paramStrings;
00110 
00111     if (err != 0) {
00112       FEI_OSTRINGSTREAM osstr;
00113       osstr << "snl_fei::Factory::parameters received err="<<err
00114             << " from either feiData_->parameters or lsc_->parameters.";
00115       throw std::runtime_error(osstr.str());
00116     }
00117   }
00118 
00119   parameterset.getIntParamValue("outputLevel", outputLevel_);
00120 
00121   const fei::Param* param = 0;
00122   fei::Param::ParamType ptype = fei::Param::BAD_TYPE;
00123 
00124   param = parameterset.get("BLOCK_GRAPH");
00125   ptype = param != NULL ? param->getType() : fei::Param::BAD_TYPE;
00126   if (ptype != fei::Param::BAD_TYPE) {
00127     blockMatrix_ = true;
00128   }
00129 
00130   param = parameterset.get("BLOCK_MATRIX");
00131   ptype = param != NULL ? param->getType() : fei::Param::BAD_TYPE;
00132   if (ptype != fei::Param::BAD_TYPE) {
00133     if (ptype == fei::Param::BOOL) {
00134       blockMatrix_ = param->getBoolValue();
00135     }
00136     else {
00137       blockMatrix_ = true;
00138     }
00139   }
00140 
00141   param = parameterset.get("AZ_matrix_type");
00142   ptype = param != NULL ? param->getType() : fei::Param::BAD_TYPE;
00143   if (ptype != fei::Param::BAD_TYPE) {
00144     if (ptype == fei::Param::STRING) {
00145       if (param->getStringValue() == "AZ_VBR_MATRIX") {
00146         blockMatrix_ = true;
00147       }
00148     }
00149   }
00150 }
00151 
00152 //----------------------------------------------------------------------------
00153 fei::SharedPtr<fei::MatrixGraph>
00154 snl_fei::Factory::createMatrixGraph(fei::SharedPtr<fei::VectorSpace> rowSpace,
00155                         fei::SharedPtr<fei::VectorSpace> columnSpace,
00156                         const char* name)
00157 {
00158   static fei::MatrixGraph_Impl2::Factory factory;
00159   matrixGraph_ = factory.createMatrixGraph(rowSpace, columnSpace, name);
00160   return(matrixGraph_);
00161 }
00162 
00163 //----------------------------------------------------------------------------
00164 fei::SharedPtr<fei::Vector>
00165 snl_fei::Factory::createVector(fei::SharedPtr<fei::VectorSpace> vecSpace,
00166                    int numVectors)
00167 {
00168   (void)vecSpace;
00169   fei::SharedPtr<fei::Vector> dummy;
00170   if (matrixGraph_.get() == NULL) {
00171     FEI_CERR << "snl_fei::Factory ERROR: when using LinearSystemCore or FiniteElementData"
00172          << ", you must create a MatrixGraph before you can create vectors"<<FEI_ENDL;
00173     return(dummy);
00174   }
00175 
00176   if (matrixGraph_->getGlobalNumSlaveConstraints() > 0 &&
00177       reducer_.get() == NULL) {
00178     reducer_ = matrixGraph_->getReducer();
00179   }
00180 
00181   createBroker(matrixGraph_);
00182 
00183   return( broker_->createVector() );
00184 }
00185 
00186 //----------------------------------------------------------------------------
00187 fei::SharedPtr<fei::Vector>
00188 snl_fei::Factory::createVector(fei::SharedPtr<fei::VectorSpace> vecSpace,
00189                                                      bool isSolutionVector,
00190                                                      int numVectors)
00191 {
00192   fei::SharedPtr<fei::Vector> dummy;
00193   (void)vecSpace;
00194   if (matrixGraph_.get() == NULL) {
00195     FEI_CERR << "snl_fei::Factory ERROR: when using LinearSystemCore"
00196          << ", you must create a MatrixGraph before you can create vectors"<<FEI_ENDL;
00197     return(dummy);
00198   }
00199 
00200   if (matrixGraph_->getGlobalNumSlaveConstraints() > 0 &&
00201       reducer_.get() == NULL) {
00202     reducer_ = matrixGraph_->getReducer();
00203   }
00204 
00205   createBroker(matrixGraph_);
00206 
00207   return( broker_->createVector(isSolutionVector) );
00208 }
00209 
00210 //----------------------------------------------------------------------------
00211 fei::SharedPtr<fei::Vector>
00212 snl_fei::Factory::createVector(fei::SharedPtr<fei::MatrixGraph> matrixGraph,
00213                                                      int numVectors)
00214 {
00215   matrixGraph_ = matrixGraph;
00216 
00217   if (matrixGraph_->getGlobalNumSlaveConstraints() > 0 &&
00218       reducer_.get() == NULL) {
00219     reducer_ = matrixGraph_->getReducer();
00220   }
00221 
00222   createBroker(matrixGraph_);
00223 
00224   return( broker_->createVector() );
00225 }
00226 
00227 //----------------------------------------------------------------------------
00228 fei::SharedPtr<fei::Vector>
00229 snl_fei::Factory::createVector(fei::SharedPtr<fei::MatrixGraph> matrixGraph,
00230                      bool isSolutionVector,
00231                      int numVectors)
00232 {
00233   matrixGraph_ = matrixGraph;
00234 
00235   if (matrixGraph_->getGlobalNumSlaveConstraints() > 0 &&
00236       reducer_.get() == NULL) {
00237     reducer_ = matrixGraph_->getReducer();
00238   }
00239 
00240   createBroker(matrixGraph_);
00241 
00242   return( broker_->createVector(isSolutionVector) );
00243 }
00244 
00245 //----------------------------------------------------------------------------
00246 fei::SharedPtr<fei::Matrix>
00247 snl_fei::Factory::createMatrix(fei::SharedPtr<fei::MatrixGraph> matrixGraph)
00248 {
00249   matrixGraph_ = matrixGraph;
00250   fei::SharedPtr<fei::Matrix> mptr;
00251 
00252   if (matrixGraph_.get() == NULL) {
00253     FEI_CERR << "snl_fei::Factory ERROR: when using LinearSystemCore"
00254          << ", you must create a MatrixGraph before you can create matrices"<<FEI_ENDL;
00255     return(mptr);
00256   }
00257 
00258   if (matrixGraph_->getGlobalNumSlaveConstraints() > 0 &&
00259       reducer_.get() == NULL) {
00260     reducer_ = matrixGraph_->getReducer();
00261   }
00262 
00263   createBroker(matrixGraph_);
00264 
00265   broker_->setMatrixGraph(matrixGraph);
00266 
00267   return(broker_->createMatrix());
00268 }
00269 
00270 //----------------------------------------------------------------------------
00271 fei::SharedPtr<fei::LinearSystem>
00272 snl_fei::Factory::createLinearSystem(fei::SharedPtr<fei::MatrixGraph>& matrixGraph)
00273 {
00274   matrixGraph_ = matrixGraph;
00275 
00276   if (matrixGraph_.get() == NULL) {
00277     FEI_CERR << "snl_fei::Factory ERROR: you may not create a LinearSystem with "
00278          << "a NULL MatrixGraph object." << FEI_ENDL;
00279     fei::SharedPtr<fei::LinearSystem> linsys;
00280     return(linsys);
00281   }
00282 
00283   if (matrixGraph_->getGlobalNumSlaveConstraints() > 0 &&
00284       reducer_.get() == NULL) {
00285     reducer_ = matrixGraph_->getReducer();
00286   }
00287 
00288   createBroker(matrixGraph_);
00289 
00290   broker_->setMatrixGraph(matrixGraph);
00291 
00292   return( broker_->createLinearSystem() );
00293 }
00294 
00295 //----------------------------------------------------------------------------
00296 fei::SharedPtr<fei::Solver>
00297 snl_fei::Factory::createSolver(const char* name)
00298 {
00299   fei::SharedPtr<fei::Solver> solver(new fei::Solver);
00300   return(solver);
00301 }
00302 
00303 //----------------------------------------------------------------------------
00304 fei::SharedPtr<LibraryWrapper>
00305 snl_fei::Factory::get_LibraryWrapper() const
00306 {
00307   return( wrapper_ );
00308 }
00309 
00310 //----------------------------------------------------------------------------
00311 int snl_fei::Factory::getOutputLevel() const
00312 {
00313   return(outputLevel_);
00314 }
00315 
00316 //----------------------------------------------------------------------------
00317 int
00318 snl_fei::Factory::createBroker(fei::SharedPtr<fei::MatrixGraph> matrixGraph)
00319 {
00320   int err = -1;
00321   if (lsc_.get() != NULL) {
00322     err = createBroker_LinSysCore(matrixGraph, lsc_);
00323   }
00324   if (feData_.get() != NULL) {
00325     err = createBroker_FEData(matrixGraph, feData_);
00326   }
00327 
00328   return(err);
00329 }
00330 
00331 //----------------------------------------------------------------------------
00332 int
00333 snl_fei::Factory::createBroker_LinSysCore(fei::SharedPtr<fei::MatrixGraph> matrixGraph,
00334                                 fei::SharedPtr<LinearSystemCore> lsc)
00335 {
00336   if (broker_.get() == NULL) {
00337     fei::SharedPtr<snl_fei::Broker> brokerptr(new snl_fei::Broker_LinSysCore(lsc, matrixGraph, reducer_, blockMatrix_));
00338     broker_ = brokerptr;
00339   }
00340 
00341   return(0);
00342 }
00343 
00344 //----------------------------------------------------------------------------
00345 int
00346 snl_fei::Factory::createBroker_FEData(fei::SharedPtr<fei::MatrixGraph> matrixGraph,
00347                             fei::SharedPtr<FiniteElementData> feData)
00348 {
00349   if (broker_.get() == NULL) {
00350     fei::SharedPtr<snl_fei::Broker>
00351       brokerptr(new snl_fei::Broker_FEData(feData, matrixGraph,
00352                                            nodeIDType_));
00353     broker_ = brokerptr;
00354   }
00355 
00356   return(0);
00357 }
00358 
00359 
00360 #endif
00361 

Generated on Wed May 12 21:30:42 2010 for FEI by  doxygen 1.4.7