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