Albany: a Trilinos-based PDE code: QCAD_MaterialDatabase.cpp Source File

Go to the documentation of this file.
00001 //*****************************************************************//
00002 //    Albany 2.0:  Copyright 2012 Sandia Corporation               //
00003 //    This Software is released under the BSD license detailed     //
00004 //    in the file "license.txt" in the top-level Albany directory  //
00005 //*****************************************************************//
00006 
00007 #include "QCAD_MaterialDatabase.hpp"
00008 #include "Teuchos_XMLParameterListHelpers.hpp"
00009 #include "Teuchos_TestForException.hpp"
00010 #include "Albany_Utils.hpp"
00011 
00012 QCAD::MaterialDatabase::
00013 MaterialDatabase( const std::string& inputFile,
00014       const Teuchos::RCP<const Epetra_Comm>& ecomm)
00015   : data_("Material Parameters")
00016 {
00017   if(inputFile.length() == 0) {
00018     pMaterialsList_ = NULL;
00019     pEBList_        = NULL;
00020     pNSList_        = NULL;
00021     pSSList_        = NULL;
00022     return;
00023   }
00024 
00025   const Albany_MPI_Comm& mcomm = Albany::getMpiCommFromEpetraComm(*ecomm);
00026   Teuchos::RCP<Teuchos::Comm<int> > tcomm = Albany::createTeuchosCommFromMpiComm(mcomm);
00027 
00028   if(ecomm->MyPID() == 0)
00029     std::cout << "Initializing material database from " << inputFile << std::endl;
00030 
00031   Teuchos::updateParametersFromXmlFileAndBroadcast(inputFile, Teuchos::ptrFromRef(data_), *tcomm);
00032 //  Teuchos::updateParametersFromXmlFileAndBroadcast(inputFile, &data_, *tcomm);
00033   //Teuchos::updateParametersFromXmlFile(inputFile, &data_);
00034   
00035   //Check for and Set element block and materials sublists
00036   TEUCHOS_TEST_FOR_EXCEPTION(!data_.isSublist("Materials"), Teuchos::Exceptions::InvalidParameter,
00037     std::endl << "Material Database Error: Materials sublist required" << std::endl);
00038   TEUCHOS_TEST_FOR_EXCEPTION(!data_.isSublist("ElementBlocks"), Teuchos::Exceptions::InvalidParameter,
00039     std::endl << "Material Database Error: ElementBlocks sublist required" << std::endl);
00040   // Make the presence of NodeSet info in the material database optional
00041   //TEUCHOS_TEST_FOR_EXCEPTION(!data_.isSublist("NodeSets"), Teuchos::Exceptions::InvalidParameter,
00042   //  std::endl << "Material Database Error: NodeSets sublist required" << std::endl);
00043 
00044   pMaterialsList_ = &(data_.sublist("Materials"));
00045   pEBList_        = &(data_.sublist("ElementBlocks"));
00046 
00047   if(data_.isSublist("NodeSets"))
00048     pNSList_        = &(data_.sublist("NodeSets"));
00049 
00050   if(data_.isSublist("SideSets"))
00051     pSSList_        = &(data_.sublist("SideSets"));
00052 }
00053 
00054 QCAD::MaterialDatabase::
00055 ~MaterialDatabase()
00056 {
00057 }
00058 
00059 
00060 template<typename T> T 
00061 QCAD::MaterialDatabase:: 
00062 getParam(const std::string& paramName)
00063 {
00064   return data_.get<T>(paramName);
00065 }
00066 
00067 template<typename T> T 
00068 QCAD::MaterialDatabase:: 
00069 getParam(const std::string& paramName, T def_value)
00070 {
00071   return data_.get<T>(paramName, def_value);
00072 }
00073 
00074 bool QCAD::MaterialDatabase:: 
00075 isParam(const std::string& paramName)
00076 {
00077   return data_.isParameter(paramName);
00078 }
00079 
00080 
00081 
00082 template<typename T> T 
00083 QCAD::MaterialDatabase:: 
00084 getMaterialParam(const std::string& materialName, const std::string& paramName)
00085 {
00086   TEUCHOS_TEST_FOR_EXCEPTION(pMaterialsList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00087          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00088 
00089   TEUCHOS_TEST_FOR_EXCEPTION(materialName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00090          std::endl << "MaterialDB Error! Empty material name" << std::endl);
00091 
00092   TEUCHOS_TEST_FOR_EXCEPTION(!pMaterialsList_->isSublist(materialName), 
00093          Teuchos::Exceptions::InvalidParameter, std::endl 
00094          << "MaterialDB Error! Invalid material name " 
00095          << materialName <<  std::endl);
00096 
00097   Teuchos::ParameterList& subList = pMaterialsList_->sublist(materialName);
00098   return subList.get<T>(paramName);
00099 }
00100 
00101 template<typename T> T 
00102 QCAD::MaterialDatabase:: 
00103 getMaterialParam(const std::string& materialName, const std::string& paramName, T def_value)
00104 {
00105   if(pMaterialsList_ == NULL) return def_value;
00106 
00107   TEUCHOS_TEST_FOR_EXCEPTION(materialName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00108          std::endl << "MaterialDB Error! Empty material name" << std::endl);
00109 
00110   TEUCHOS_TEST_FOR_EXCEPTION(!pMaterialsList_->isSublist(materialName), 
00111          Teuchos::Exceptions::InvalidParameter, std::endl 
00112          << "MaterialDB Error! Invalid material name " 
00113          << materialName <<  std::endl);
00114 
00115   Teuchos::ParameterList& subList = pMaterialsList_->sublist(materialName);
00116   return subList.get<T>(paramName, def_value);
00117 }
00118 
00119 bool QCAD::MaterialDatabase:: 
00120 isMaterialParam(const std::string& materialName, const std::string& paramName)
00121 {
00122   TEUCHOS_TEST_FOR_EXCEPTION(pMaterialsList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00123          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00124   if(!pMaterialsList_->isSublist(materialName)) return false;
00125   Teuchos::ParameterList& subList = pMaterialsList_->sublist(materialName);
00126   return subList.isParameter(paramName);
00127 }
00128 
00129 
00130 
00131 template<typename T> T 
00132 QCAD::MaterialDatabase:: 
00133 getNodeSetParam(const std::string& nsName, const std::string& paramName)
00134 {
00135   TEUCHOS_TEST_FOR_EXCEPTION(pNSList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00136          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00137 
00138   TEUCHOS_TEST_FOR_EXCEPTION(nsName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00139          std::endl << "MaterialDB Error! Empty nodeset name" << std::endl);
00140 
00141   TEUCHOS_TEST_FOR_EXCEPTION(!pNSList_->isSublist(nsName), 
00142          Teuchos::Exceptions::InvalidParameter, std::endl 
00143          << "MaterialDB Error! Invalid nodeset name " 
00144          << nsName <<  std::endl);
00145 
00146   Teuchos::ParameterList& subList = pNSList_->sublist(nsName);
00147   return subList.get<T>(paramName);
00148 }
00149 
00150 template<typename T> T 
00151 QCAD::MaterialDatabase:: 
00152 getNodeSetParam(const std::string& nsName, const std::string& paramName, T def_value)
00153 {
00154   if(pNSList_ == NULL) return def_value;
00155 
00156   TEUCHOS_TEST_FOR_EXCEPTION(nsName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00157          std::endl << "MaterialDB Error! Empty nodeset name" << std::endl);
00158 
00159   TEUCHOS_TEST_FOR_EXCEPTION(!pNSList_->isSublist(nsName), 
00160          Teuchos::Exceptions::InvalidParameter, std::endl 
00161          << "MaterialDB Error! Invalid nodeset name " 
00162          << nsName <<  std::endl);
00163   
00164   Teuchos::ParameterList& subList = pNSList_->sublist(nsName);
00165   return subList.get<T>(paramName, def_value);
00166 }
00167 
00168 bool QCAD::MaterialDatabase:: 
00169 isNodeSetParam(const std::string& nsName, const std::string& paramName)
00170 {
00171   TEUCHOS_TEST_FOR_EXCEPTION(pNSList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00172          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00173 
00174   if(!pNSList_->isSublist(nsName)) return false;
00175   Teuchos::ParameterList& subList = pNSList_->sublist(nsName);
00176   return subList.isParameter(paramName);
00177 }
00178 
00179 
00180 
00181 template<typename T> T 
00182 QCAD::MaterialDatabase:: 
00183 getSideSetParam(const std::string& ssName, const std::string& paramName)
00184 {
00185   TEUCHOS_TEST_FOR_EXCEPTION(pSSList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00186          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00187 
00188   TEUCHOS_TEST_FOR_EXCEPTION(ssName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00189          std::endl << "MaterialDB Error! Empty sideset name" << std::endl);
00190 
00191   TEUCHOS_TEST_FOR_EXCEPTION(!pSSList_->isSublist(ssName), 
00192          Teuchos::Exceptions::InvalidParameter, std::endl 
00193          << "MaterialDB Error! Invalid sideset name " 
00194          << ssName <<  std::endl);
00195 
00196   Teuchos::ParameterList& subList = pSSList_->sublist(ssName);
00197   return subList.get<T>(paramName);
00198 }
00199 
00200 template<typename T> T 
00201 QCAD::MaterialDatabase:: 
00202 getSideSetParam(const std::string& ssName, const std::string& paramName, T def_value)
00203 {
00204   if(pSSList_ == NULL) return def_value;
00205 
00206   TEUCHOS_TEST_FOR_EXCEPTION(ssName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00207          std::endl << "MaterialDB Error! Empty sideset name" << std::endl);
00208 
00209   TEUCHOS_TEST_FOR_EXCEPTION(!pSSList_->isSublist(ssName), 
00210          Teuchos::Exceptions::InvalidParameter, std::endl 
00211          << "MaterialDB Error! Invalid sideset name " 
00212          << ssName <<  std::endl);
00213   
00214   Teuchos::ParameterList& subList = pSSList_->sublist(ssName);
00215   return subList.get<T>(paramName, def_value);
00216 }
00217 
00218 bool QCAD::MaterialDatabase:: 
00219 isSideSetParam(const std::string& ssName, const std::string& paramName)
00220 {
00221   TEUCHOS_TEST_FOR_EXCEPTION(pSSList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00222          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00223 
00224   if(!pSSList_->isSublist(ssName)) return false;
00225   Teuchos::ParameterList& subList = pSSList_->sublist(ssName);
00226   return subList.isParameter(paramName);
00227 }
00228 
00229 
00230 
00231 template<typename T> T 
00232 QCAD::MaterialDatabase:: 
00233 getElementBlockParam(const std::string& ebName, const std::string& paramName)
00234 {
00235   TEUCHOS_TEST_FOR_EXCEPTION(pEBList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00236          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00237 
00238   TEUCHOS_TEST_FOR_EXCEPTION(ebName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00239          std::endl << "MaterialDB Error! Empty element block name" << std::endl);
00240 
00241   std::string newname = translateDBSublistName(pEBList_, ebName);
00242 
00243   TEUCHOS_TEST_FOR_EXCEPTION(newname.length() == 0, Teuchos::Exceptions::InvalidParameter,
00244                     std::endl << "MaterialDB Error! Invalid element block name \"" 
00245                     << ebName << "\"."<< std::endl);
00246 
00247   // This call returns the sublist for the particular EB within the "ElementBlocks" list
00248   Teuchos::ParameterList& subList = pEBList_->sublist(newname);
00249 
00250   if( subList.isParameter(paramName) )
00251     return subList.get<T>(paramName);
00252 
00253   //check if related material exists (it always should)
00254   TEUCHOS_TEST_FOR_EXCEPTION(!subList.isParameter("material"), 
00255          Teuchos::Exceptions::InvalidParameter, std::endl 
00256          << "MaterialDB Error! Param " << paramName
00257          << " not found in " << ebName << " list and there"
00258          << " is no related material." << std::endl);
00259 
00260   //Parameter not directly in element block sublist, so try related material
00261   std::string materialName = subList.get<std::string>("material");
00262   TEUCHOS_TEST_FOR_EXCEPTION(!pMaterialsList_->isSublist(materialName), 
00263          Teuchos::Exceptions::InvalidParameter, std::endl 
00264          << "MaterialDB Error! Param " << paramName
00265          << " not found in " << ebName << " list, and related"
00266          << " material " << materialName << "is invalid." << std::endl);
00267 
00268   Teuchos::ParameterList& matSubList = pMaterialsList_->sublist(materialName);
00269   TEUCHOS_TEST_FOR_EXCEPTION(!matSubList.isParameter(paramName), 
00270          Teuchos::Exceptions::InvalidParameter, std::endl 
00271          << "MaterialDB Error! Param " << paramName
00272          << " not found in " << ebName << " list or related"
00273          << " material " << materialName << "list." << std::endl);
00274   return matSubList.get<T>(paramName);
00275 }
00276 
00277 std::string
00278 QCAD::MaterialDatabase:: 
00279 translateDBSublistName(Teuchos::ParameterList *list, const std::string& listname){
00280   /* 
00281     NOTE: STK Ioss lowercases all names in the Exodus file, including element block names. Lets
00282     lowercase the names used for the search so users are not confounded when they name the materials
00283     using mixed case when they enter mixed case names in as element blocks in CUbit.
00284   */
00285 
00286   std::string newname;
00287 
00288   for( Teuchos::ParameterList::ConstIterator i = list->begin(); i != list->end(); ++i ) {
00289     std::string name_i = list->name(i);
00290     const Teuchos::ParameterEntry &entry_i = list->entry(i);
00291 
00292     if(listname == name_i && entry_i.isList()){ // found it
00293 
00294       newname = list->name(i);
00295 
00296       return newname; 
00297 
00298     }
00299 
00300     // Try to lowercase the list entry
00301 
00302     std::transform(name_i.begin(), name_i.end(), name_i.begin(), (int (*)(int))std::tolower);
00303 
00304     if(listname == name_i && entry_i.isList()){ // found it
00305 
00306       newname = list->name(i);
00307 
00308       return newname; 
00309 
00310     }
00311 
00312   }
00313 
00314   return newname; // return string of length zero
00315 
00316 }
00317 
00318 Teuchos::ParameterList&
00319 QCAD::MaterialDatabase:: 
00320 getElementBlockSublist(const std::string& ebName, const std::string& subListName)
00321 {
00322   TEUCHOS_TEST_FOR_EXCEPTION(pEBList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00323                     std::endl << "MaterialDB Error! material subList requested but no DB." << std::endl);
00324 
00325   TEUCHOS_TEST_FOR_EXCEPTION(ebName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00326                     std::endl << "MaterialDB Error! Empty element block name." << std::endl);
00327 
00328   std::string newname = translateDBSublistName(pEBList_, ebName);
00329 
00330   TEUCHOS_TEST_FOR_EXCEPTION(newname.length() == 0, Teuchos::Exceptions::InvalidParameter,
00331                     std::endl << "MaterialDB Error! Invalid element block name \"" 
00332                     << ebName << "\"."<< std::endl);
00333 
00334   // This call returns the sublist for the particular EB within the "ElementBlocks" list
00335   Teuchos::ParameterList& subList = pEBList_->sublist(newname);
00336 
00337   if( subList.isSublist(subListName) )
00338     return subList.sublist(subListName);
00339 
00340   // Didn't find the requested sublist directly in the EB sublist. Drill down to the material next.
00341 
00342   //check if related material exists (it always should)
00343   TEUCHOS_TEST_FOR_EXCEPTION(!subList.isParameter("material"), 
00344                     Teuchos::Exceptions::InvalidParameter, std::endl 
00345                     << "MaterialDB Error! Param " << subListName
00346                     << " not found in " << ebName << " list and there"
00347                     << " is no related material." << std::endl);
00348 
00349   //Parameter not directly in element block sublist, so try related material
00350   std::string materialName = subList.get<std::string>("material");
00351 
00352   TEUCHOS_TEST_FOR_EXCEPTION(!pMaterialsList_->isSublist(materialName), 
00353                     Teuchos::Exceptions::InvalidParameter, std::endl 
00354                     << "MaterialDB Error! Param " << subListName
00355                     << " not found in " << ebName << " list, and related"
00356                     << " material " << materialName << "is invalid." << std::endl);
00357 
00358   Teuchos::ParameterList& matSubList = pMaterialsList_->sublist(materialName);
00359 
00360   // In case the entire material subList is desired
00361   if (materialName == subListName) {
00362     return matSubList;
00363   }
00364 
00365   // Does the requested sublist appear in the material sublist?
00366 
00367   TEUCHOS_TEST_FOR_EXCEPTION(!matSubList.isParameter(subListName), 
00368                     Teuchos::Exceptions::InvalidParameter, std::endl 
00369                     << "MaterialDB Error! Param " << subListName
00370                     << " not found in " << ebName << " list or related"
00371                     << " material " << materialName << "list." << std::endl);
00372 
00373   // If so, return the requested sublist
00374 
00375   return matSubList.sublist(subListName);
00376 
00377 }
00378 
00379 template<typename T> T 
00380 QCAD::MaterialDatabase:: 
00381 getElementBlockParam(const std::string& ebName, const std::string& paramName, T def_value)
00382 {
00383   if(pEBList_ == NULL) return def_value;
00384 
00385   TEUCHOS_TEST_FOR_EXCEPTION(ebName.length() == 0, Teuchos::Exceptions::InvalidParameter,
00386          std::endl << "MaterialDB Error! Empty element block name" << std::endl);
00387 
00388   std::string newname = translateDBSublistName(pEBList_, ebName);
00389 
00390   //check if element block exists - if not return default
00391   if(newname.length() == 0) return def_value;
00392 
00393   Teuchos::ParameterList& subList = pEBList_->sublist(newname);
00394 
00395   if( subList.isParameter(paramName) )
00396     return subList.get<T>(paramName);
00397 
00398   //check if related material exists - if not return default
00399   if(!subList.isParameter("material")) return def_value;
00400 
00401   //Parameter not directly in element block sublist, so try related material
00402   std::string materialName = subList.get<std::string>("material");
00403   TEUCHOS_TEST_FOR_EXCEPTION(!pMaterialsList_->isSublist(materialName), 
00404          Teuchos::Exceptions::InvalidParameter, std::endl 
00405          << "MaterialDB Error! Param " << paramName
00406          << " not found in " << ebName << " list, and related"
00407          << " material " << materialName << "is invalid." << std::endl);
00408 
00409   Teuchos::ParameterList& matSubList = pMaterialsList_->sublist(materialName);
00410   return matSubList.get<T>(paramName, def_value);
00411 }
00412 
00413 bool QCAD::MaterialDatabase:: 
00414 isElementBlockParam(const std::string& ebName, const std::string& paramName)
00415 {
00416   TEUCHOS_TEST_FOR_EXCEPTION(pEBList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00417          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00418 
00419   std::string newname = translateDBSublistName(pEBList_, ebName);
00420 
00421   if(newname.length() == 0) return false;
00422   Teuchos::ParameterList& subList = pEBList_->sublist(newname);
00423 
00424   if(subList.isParameter(paramName)) return true;
00425 
00426   //check if related material exists (it always should)
00427   if(!subList.isParameter("material")) return false;
00428 
00429   //Parameter not directly in element block sublist, so try related material
00430   std::string materialName = subList.get<std::string>("material");
00431   if(!pMaterialsList_->isSublist(materialName)) return false;
00432 
00433   Teuchos::ParameterList& matSubList = pMaterialsList_->sublist(materialName);
00434   return matSubList.isParameter(paramName);
00435 }
00436 
00437 bool QCAD::MaterialDatabase:: 
00438 isElementBlockSublist(const std::string& ebName, const std::string& subListName)
00439 {
00440   TEUCHOS_TEST_FOR_EXCEPTION(pEBList_ == NULL, Teuchos::Exceptions::InvalidParameter,
00441          std::endl << "MaterialDB Error! param required but no DB." << std::endl);
00442 
00443   std::string newname = translateDBSublistName(pEBList_, ebName);
00444 
00445   if(newname.length() == 0) return false;
00446   Teuchos::ParameterList& subList = pEBList_->sublist(newname);
00447 
00448   if(subList.isParameter(subListName)) return true;
00449 
00450   //check if related material exists (it always should)
00451   if(!subList.isParameter("material")) return false;
00452 
00453   //Parameter not directly in element block sublist, so try related material
00454   std::string materialName = subList.get<std::string>("material");
00455   if(!pMaterialsList_->isSublist(materialName)) return false;
00456 
00457   Teuchos::ParameterList& matSubList = pMaterialsList_->sublist(materialName);
00458   return matSubList.isSublist(subListName);
00459 }
00460 
00461 
00462 
00463 template<typename T> std::vector<T>
00464 QCAD::MaterialDatabase:: 
00465 getAllMatchingParams(const std::string& paramName)
00466 {
00467   std::vector<T> results;
00468   getAllMatchingParams_helper(paramName, results, data_);
00469   return results;
00470 }
00471 
00472 template<typename T> void
00473 QCAD::MaterialDatabase:: 
00474 getAllMatchingParams_helper(const std::string& paramName, std::vector<T>& results, Teuchos::ParameterList& list)
00475 {
00476   Teuchos::ParameterList::ConstIterator it;
00477   Teuchos::ParameterList* list_type = NULL;
00478   T* param_type = NULL;
00479 
00480   for(it = list.begin(); it != list.end(); it++) {
00481     if( it->second.isList() ) {
00482       Teuchos::ParameterList& subList = it->second.getValue(list_type);
00483       getAllMatchingParams_helper(paramName, results, subList);
00484       continue;
00485     }
00486 
00487     if( it->second.isType<T>() && it->first == paramName )
00488       results.push_back( it->second.getValue(param_type) );
00489   }
00490 }
00491 
00492 
00493 
00494 //explicit instantiation of functions above; otherwise they never
00495 // seems to get intantiated by compiler
00496 
00497 //double
00498 template double QCAD::MaterialDatabase:: 
00499 getParam<double>(const std::string& paramName);
00500 template double QCAD::MaterialDatabase:: 
00501 getParam<double>(const std::string& paramName, double def_val);
00502 
00503 template double QCAD::MaterialDatabase:: 
00504 getMaterialParam<double>(const std::string& materialName, const std::string& paramName);
00505 template double QCAD::MaterialDatabase:: 
00506 getMaterialParam<double>(const std::string& materialName, const std::string& paramName, double def_val);
00507 
00508 template double QCAD::MaterialDatabase:: 
00509 getNodeSetParam<double>(const std::string& nsName, const std::string& paramName);
00510 template double QCAD::MaterialDatabase:: 
00511 getNodeSetParam<double>(const std::string& nsName, const std::string& paramName, double def_val);
00512 
00513 template double QCAD::MaterialDatabase:: 
00514 getElementBlockParam<double>(const std::string& materialName, const std::string& paramName);
00515 template double QCAD::MaterialDatabase:: 
00516 getElementBlockParam<double>(const std::string& materialName, const std::string& paramName, double def_val);
00517 
00518 //int
00519 template int QCAD::MaterialDatabase:: 
00520 getParam<int>(const std::string& paramName);
00521 template int QCAD::MaterialDatabase:: 
00522 getParam<int>(const std::string& paramName, int def_val);
00523 
00524 template int QCAD::MaterialDatabase:: 
00525 getMaterialParam<int>(const std::string& materialName, const std::string& paramName);
00526 template int QCAD::MaterialDatabase:: 
00527 getMaterialParam<int>(const std::string& materialName, const std::string& paramName, int def_val);
00528 
00529 template int QCAD::MaterialDatabase:: 
00530 getNodeSetParam<int>(const std::string& nsName, const std::string& paramName);
00531 template int QCAD::MaterialDatabase:: 
00532 getNodeSetParam<int>(const std::string& nsName, const std::string& paramName, int def_val);
00533 
00534 template int QCAD::MaterialDatabase:: 
00535 getElementBlockParam<int>(const std::string& materialName, const std::string& paramName);
00536 template int QCAD::MaterialDatabase:: 
00537 getElementBlockParam<int>(const std::string& materialName, const std::string& paramName, int def_val);
00538 
00539 
00540 //bool
00541 template bool QCAD::MaterialDatabase:: 
00542 getParam<bool>(const std::string& paramName);
00543 template bool QCAD::MaterialDatabase:: 
00544 getParam<bool>(const std::string& paramName, bool def_val);
00545 
00546 template bool QCAD::MaterialDatabase:: 
00547 getMaterialParam<bool>(const std::string& materialName, const std::string& paramName);
00548 template bool QCAD::MaterialDatabase:: 
00549 getMaterialParam<bool>(const std::string& materialName, const std::string& paramName, bool def_val);
00550 
00551 template bool QCAD::MaterialDatabase:: 
00552 getNodeSetParam<bool>(const std::string& nsName, const std::string& paramName);
00553 template bool QCAD::MaterialDatabase:: 
00554 getNodeSetParam<bool>(const std::string& nsName, const std::string& paramName, bool def_val);
00555 
00556 template bool QCAD::MaterialDatabase:: 
00557 getSideSetParam<bool>(const std::string& ssName, const std::string& paramName);
00558 template bool QCAD::MaterialDatabase:: 
00559 getSideSetParam<bool>(const std::string& ssName, const std::string& paramName, bool def_val);
00560 
00561 template bool QCAD::MaterialDatabase:: 
00562 getElementBlockParam<bool>(const std::string& materialName, const std::string& paramName);
00563 template bool QCAD::MaterialDatabase:: 
00564 getElementBlockParam<bool>(const std::string& materialName, const std::string& paramName, bool def_val);
00565 
00566 //string
00567 template std::string QCAD::MaterialDatabase:: 
00568 getParam<std::string>(const std::string& paramName);
00569 template std::string QCAD::MaterialDatabase:: 
00570 getParam<std::string>(const std::string& paramName, std::string def_val);
00571 
00572 template std::string QCAD::MaterialDatabase:: 
00573 getMaterialParam<std::string>(const std::string& materialName, const std::string& paramName);
00574 template std::string QCAD::MaterialDatabase:: 
00575 getMaterialParam<std::string>(const std::string& materialName, const std::string& paramName, std::string def_val);
00576 
00577 template std::string QCAD::MaterialDatabase:: 
00578 getNodeSetParam<std::string>(const std::string& nsName, const std::string& paramName);
00579 template std::string QCAD::MaterialDatabase:: 
00580 getNodeSetParam<std::string>(const std::string& nsName, const std::string& paramName, std::string def_val);
00581 
00582 template std::string QCAD::MaterialDatabase:: 
00583 getSideSetParam<std::string>(const std::string& ssName, const std::string& paramName);
00584 template std::string QCAD::MaterialDatabase:: 
00585 getSideSetParam<std::string>(const std::string& ssName, const std::string& paramName, std::string def_val);
00586 
00587 template std::string QCAD::MaterialDatabase:: 
00588 getElementBlockParam<std::string>(const std::string& materialName, const std::string& paramName);
00589 template std::string QCAD::MaterialDatabase:: 
00590 getElementBlockParam<std::string>(const std::string& materialName, const std::string& paramName, std::string def_val);
00591 
00592 template std::vector<std::string> QCAD::MaterialDatabase:: 
00593 getAllMatchingParams(const std::string& paramName);
00594