My title

00001 /* ****************************************************************** **
00002 **    OpenSees - Open System for Earthquake Engineering Simulation    **
00003 **          Pacific Earthquake Engineering Research Center            **
00004 **                                                                    **
00005 **                                                                    **
00006 ** (C) Copyright 1999, The Regents of the University of California    **
00007 ** All Rights Reserved.                                               **
00008 **                                                                    **
00009 ** Commercial use of this program without express permission of the   **
00010 ** University of California, Berkeley, is strictly prohibited.  See   **
00011 ** file 'COPYRIGHT'  in main directory for information on usage and   **
00012 ** redistribution,  and for a DISCLAIMER OF ALL WARRANTIES.           **
00013 **                                                                    **
00014 ** Developed by:                                                      **
00015 **   Frank McKenna (fmckenna@ce.berkeley.edu)                         **
00016 **   Gregory L. Fenves (fenves@ce.berkeley.edu)                       **
00017 **   Filip C. Filippou (filippou@ce.berkeley.edu)                     **
00018 **                                                                    **
00019 ** ****************************************************************** */
00020                                                                         
00021 // $Revision: 1.5 $
00022 // $Date: 2001/07/18 22:03:18 $
00023 // $Source: /usr/local/cvs/OpenSees/SRC/actor/objectBroker/FEM_ObjectBroker.cpp,v $
00024                                                                         
00025                                                                         
00026 // File: ~/actor/broker/FEM_ObjectBroker.C
00027 //
00028 // Written: fmk
00029 // Created: 10/96
00030 // Revision: A
00031 //
00032 // Purpose: This file contains the class definition for FEM_ObjectBroker.
00033 // FEM_ObjectBroker is is an object broker class for the finite element
00034 // method. All methods are virtual to allow for subclasses; which can be
00035 // used by programmers when introducing new subclasses of the main objects.
00036 //
00037 // What: "@(#) FEM_ObjectBroker.C, revA"
00038 
00039 #include <FEM_ObjectBroker.h>
00040 
00041 // Convergence tests
00042 #include <CTestNormUnbalance.h>
00043 #include <CTestNormDispIncr.h>
00044 #include <CTestEnergyIncr.h>
00045 
00046 // graph numbering schemes
00047 #include <RCM.h>
00048 #include <MyRCM.h>
00049 #include <SimpleNumberer.h>
00050 
00051 // uniaxial material model header files
00052 #include <ElasticMaterial.h>
00053 #include <ElasticPPMaterial.h>
00054 #include <ParallelMaterial.h>
00055 #include <Concrete01.h>
00056 #include <Steel01.h>
00057 #include <HardeningMaterial.h>
00058 #include <HystereticMaterial.h>
00059 #include <EPPGapMaterial.h>
00060 #include <ViscousMaterial.h>
00061 #include <PathIndependentMaterial.h>
00062 #include <SeriesMaterial.h>
00063 #include <CableMaterial.h>
00064 
00065 // Sections
00066 #include <ElasticSection2d.h>
00067 #include <ElasticSection3d.h>
00068 #include <GenericSection1d.h>
00069 #include <GenericSectionNd.h>
00070 #include <SectionAggregator.h>
00071 #include <FiberSection.h>
00072 #include <FiberSection2d.h>
00073 #include <FiberSection3d.h>
00074 
00075 // NDMaterials
00076 #include <ElasticIsotropicPlaneStrain2D.h>
00077 #include <ElasticIsotropicPlaneStress2D.h>
00078 
00079 // Fibers
00080 #include <UniaxialFiber2d.h>
00081 #include <UniaxialFiber3d.h>
00082 
00083 // element header files
00084 #include <Element.h>
00085 #include <beam2d02.h>
00086 #include <beam2d03.h>
00087 #include <beam2d04.h>
00088 #include <beam3d01.h>
00089 #include <beam3d02.h>
00090 #include <Truss.h>
00091 #include <TrussSection.h>
00092 #include <ZeroLength.h>
00093 #include <ZeroLengthSection.h>
00094 #include <ZeroLengthND.h>
00095 #include <FourNodeQuad.h>
00096 #include <ElasticBeam2d.h>
00097 #include <ElasticBeam3d.h>
00098 #include <BeamWithHinges2d.h>
00099 #include <BeamWithHinges3d.h>
00100 #include <NLBeamColumn2d.h>
00101 #include <NLBeamColumn3d.h>
00102 
00103 #include <LinearCrdTransf2d.h>
00104 #include <PDeltaCrdTransf2d.h>
00105 #include <LinearCrdTransf3d.h>
00106 
00107 // node header files
00108 #include <Node.h>
00109 
00110 // mp_constraint header files
00111 #include <MP_Constraint.h>
00112 
00113 // sp_constraint header files
00114 #include <SP_Constraint.h>
00115 
00116 // nodal load header files
00117 #include <NodalLoad.h>
00118 
00119 // elemental load header files
00120 #include <ElementalLoad.h>
00121 
00122 // matrix, vector & id header files
00123 #include <Matrix.h>
00124 #include <Vector.h>
00125 #include <ID.h>
00126 
00127 // subdomain header files
00128 #include <Subdomain.h>
00129 
00130 // constraint handler header files
00131 #include <ConstraintHandler.h>
00132 #include <PlainHandler.h>
00133 
00134 // dof numberer header files
00135 #include <DOF_Numberer.h>   
00136 #include <PlainNumberer.h>
00137 
00138 // analysis model header files
00139 #include <AnalysisModel.h>    
00140 
00141 // equi soln algo header files
00142 #include <EquiSolnAlgo.h>
00143 #include <Linear.h>
00144 #include <NewtonRaphson.h>
00145 #include <ModifiedNewton.h>
00146 
00147 // domain decomp soln algo header files
00148 #include <DomainDecompAlgo.h>
00149 
00150 // integrator header files
00151 #include <LoadControl.h>
00152 #include <ArcLength.h>
00153 #include <TransientIntegrator.h>
00154 #include <Newmark.h>
00155 
00156 // system of eqn header files
00157 #include <LinearSOE.h>
00158 #include <DomainSolver.h>
00159 #include <FullGenLinSOE.h>
00160 #include <FullGenLinLapackSolver.h>
00161 #include <BandGenLinSOE.h>
00162 #include <BandGenLinLapackSolver.h>
00163 #include <BandSPDLinSOE.h>
00164 #include <BandSPDLinLapackSolver.h>
00165 #include <ProfileSPDLinSOE.h>
00166 #include <ProfileSPDLinDirectSolver.h>
00167 #include <ProfileSPDLinSubstrSolver.h>
00168 
00169 
00170 #include <DomainDecompositionAnalysis.h>
00171 
00172 // load patterns
00173 #include <LoadPattern.h>
00174 #include <GroundMotion.h>
00175 
00176 // time series
00177 #include <LinearSeries.h>
00178 #include <PathSeries.h>
00179 #include <PathTimeSeries.h>
00180 #include <RectangularSeries.h>
00181 #include <ConstantSeries.h>
00182 #include <TrigSeries.h>
00183 
00184 FEM_ObjectBroker::FEM_ObjectBroker()
00185 :lastLinearSolver(0),lastDomainSolver(0)
00186 {
00187 
00188 }
00189 
00190 
00191 FEM_ObjectBroker::~FEM_ObjectBroker()
00192 {
00193 
00194 }
00195 
00196 
00197 
00198 PartitionedModelBuilder          *
00199 FEM_ObjectBroker::getPtrNewPartitionedModelBuilder(Subdomain &theSubdomain,
00200          int classTag)
00201 {
00202     switch(classTag) {
00203  /*
00204  case PartitionedModelBuilder_TAGS_PartitionedQuick2dFrameModel:  
00205       return new PartitionedQuick2dFrame(theSubdomain);
00206       */
00207 
00208  default:
00209       cerr << "FEM_ObjectBroker::getPtrNewPartitionedModelBuilder - ";
00210       cerr << " - no PartitionedModelBuilder type exists for class tag ";
00211       cerr << classTag << endl;
00212       return 0;
00213       
00214   }    
00215 }
00216 
00217 
00218 GraphNumberer *
00219 FEM_ObjectBroker::getPtrNewGraphNumberer(int classTag)
00220 {
00221     switch(classTag) {
00222  case GraphNUMBERER_TAG_RCM:  
00223        return new RCM();
00224       
00225       
00226  case GraphNUMBERER_TAG_MyRCM:  
00227       return new MyRCM();
00228             
00229       
00230  case GraphNUMBERER_TAG_SimpleNumberer:  
00231       return new SimpleNumberer();    
00232       
00233       
00234  default:
00235       cerr << "ObjectBroker::getPtrNewGraphNumberer - ";
00236       cerr << " - no GraphNumberer type exists for class tag " ;
00237       cerr << classTag << endl;
00238       return 0;
00239       
00240   }
00241 }
00242 
00243 /*****************************************
00244  *
00245  * METHODS TO GET NEW MODELLING CLASSES
00246  *
00247  *****************************************/
00248 
00249 
00250 
00251 
00252 
00253 
00254 
00255 
00256 Element       *
00257 FEM_ObjectBroker::getNewElement(int classTag)
00258 {
00259     switch(classTag) {
00260       
00261  case ELE_TAG_Truss:  
00262       return new Truss(); 
00263       
00264  case ELE_TAG_TrussSection:  
00265       return new TrussSection();       
00266       
00267  case ELE_TAG_ZeroLength:  
00268       return new ZeroLength();       
00269 
00270  case ELE_TAG_ZeroLengthSection:  
00271       return new ZeroLengthSection();       
00272 
00273  case ELE_TAG_ZeroLengthND:  
00274       return new ZeroLengthND();       
00275       
00276  case ELE_TAG_FourNodeQuad:  
00277       return new FourNodeQuad();       
00278       
00279  case ELE_TAG_ElasticBeam2d:
00280   return new ElasticBeam2d();
00281 
00282  case ELE_TAG_ElasticBeam3d:
00283   return new ElasticBeam3d();
00284 
00285  case ELE_TAG_BeamWithHinges2d:  
00286       return new BeamWithHinges2d();             
00287 
00288  case ELE_TAG_BeamWithHinges3d:  
00289       return new BeamWithHinges3d();             
00290 
00291  case ELE_TAG_NLBeamColumn2d:  
00292       return new NLBeamColumn2d();          
00293 
00294  case ELE_TAG_NLBeamColumn3d:  
00295       return new NLBeamColumn3d();  
00296     
00297  default:
00298       cerr << "FEM_ObjectBroker::getNewElement - ";
00299       cerr << " - no Element type exists for class tag " ;
00300       cerr << classTag << endl;
00301       return 0;
00302       
00303   }
00304 }
00305     
00306 Node          *
00307 FEM_ObjectBroker::getNewNode(int classTag)
00308 {
00309     switch(classTag) {
00310  case NOD_TAG_Node:  
00311       return new Node(classTag);
00312       
00313       
00314  default:
00315       cerr << "FEM_ObjectBroker::getNewNode - ";
00316       cerr << " - no Node type exists for class tag ";
00317       cerr << classTag << endl;
00318       return 0;
00319       
00320   }    
00321 }
00322 
00323 
00324 MP_Constraint *
00325 FEM_ObjectBroker::getNewMP(int classTag)
00326 {
00327     switch(classTag) {
00328  case CNSTRNT_TAG_MP_Constraint:  
00329       return new MP_Constraint(classTag);
00330       
00331       
00332  default:
00333       cerr << "FEM_ObjectBroker::getNewMP - ";
00334       cerr << " - no SP_Constraint type exists for class tag ";
00335       cerr << classTag << endl;
00336       return 0;
00337       
00338   }    
00339 }
00340 
00341 
00342 SP_Constraint *
00343 FEM_ObjectBroker::getNewSP(int classTag)
00344 {
00345     switch(classTag) {
00346  case CNSTRNT_TAG_SP_Constraint:  
00347       return new SP_Constraint(classTag);
00348       
00349       
00350  default:
00351       cerr << "FEM_ObjectBroker::getNewSP - ";
00352       cerr << " - no SP_Constraint type exists for class tag ";
00353       cerr << classTag << endl;
00354       return 0;
00355       
00356   }    
00357 }
00358 
00359 NodalLoad     *
00360 FEM_ObjectBroker::getNewNodalLoad(int classTag)
00361 {
00362     switch(classTag) {
00363  case LOAD_TAG_NodalLoad:  
00364       return new NodalLoad(classTag);
00365       
00366       
00367  default:
00368       cerr << "FEM_ObjectBroker::getNewNodalLoad - ";
00369       cerr << " - no NodalLoad type exists for class tag ";
00370       cerr << classTag << endl;
00371       return 0;
00372       
00373   }    
00374 }
00375 
00376 
00377 ElementalLoad *
00378 FEM_ObjectBroker::getNewElementalLoad(int classTag)
00379 {
00380     cerr << "FEM_ObjectBroker: NOT IMPLEMENTED YET";
00381     return 0;
00382 }
00383 
00384 CrdTransf2d*
00385 FEM_ObjectBroker::getNewCrdTransf2d(int classTag)
00386 {
00387  switch(classTag) {
00388  case CRDTR_TAG_LinearCrdTransf2d:
00389   return new LinearCrdTransf2d();
00390  case CRDTR_TAG_PDeltaCrdTransf2d:
00391   return new PDeltaCrdTransf2d();
00392  //case CRDTR_TAG_CorotCrdTransf2d :
00393  // return new CorotCrdTransf2d();
00394  default:
00395   cerr << "FEM_ObjectBroker::getPtrNewCrdTransf2d - ";
00396      cerr << " - no CrdTransf2d type exists for class tag ";
00397      cerr << classTag << endl;
00398      return 0;
00399  }
00400 
00401 }
00402 
00403 CrdTransf3d*
00404 FEM_ObjectBroker::getNewCrdTransf3d(int classTag)
00405 {
00406  switch(classTag) {
00407  case CRDTR_TAG_LinearCrdTransf3d:
00408   return new LinearCrdTransf3d();
00409  //case CRDTR_TAG_CorotCrdTransf3d :
00410  // return new CorotCrdTransf3d();
00411  default:
00412   cerr << "FEM_ObjectBroker::getPtrNewCrdTransf3d - ";
00413      cerr << " - no CrdTransf3d type exists for class tag ";
00414      cerr << classTag << endl;
00415      return 0;
00416  }
00417 
00418 }
00419 
00420 UniaxialMaterial *
00421 FEM_ObjectBroker::getNewUniaxialMaterial(int classTag)
00422 {
00423     switch(classTag) {
00424  case MAT_TAG_ElasticMaterial:  
00425       return new ElasticMaterial(); // values set in recvSelf
00426       
00427  case MAT_TAG_ElasticPPMaterial:  
00428       return new ElasticPPMaterial(); // values set in recvSelf
00429             
00430  case MAT_TAG_ParallelMaterial:  
00431       return new ParallelMaterial();
00432 
00433  case MAT_TAG_Concrete01:  
00434       return new Concrete01();
00435 
00436  case MAT_TAG_Steel01:  
00437       return new Steel01();
00438 
00439  case MAT_TAG_Hardening:
00440   return new HardeningMaterial();
00441 
00442  case MAT_TAG_Hysteretic:
00443   return new HystereticMaterial();
00444 
00445  case MAT_TAG_EPPGap:
00446   return new EPPGapMaterial();
00447 
00448  case MAT_TAG_Viscous:
00449   return new ViscousMaterial();
00450 
00451  case MAT_TAG_PathIndependent:
00452   return new PathIndependentMaterial();
00453 
00454  case MAT_TAG_SeriesMaterial:
00455   return new SeriesMaterial();
00456 
00457  case MAT_TAG_CableMaterial:
00458   return new CableMaterial();
00459       
00460  default:
00461       cerr << "FEM_ObjectBroker::getPtrNewUniaxialMaterial - ";
00462       cerr << " - no UniaxialMaterial type exists for class tag ";
00463       cerr << classTag << endl;
00464       return 0;
00465       
00466   }        
00467 }
00468 
00469 SectionForceDeformation *
00470 FEM_ObjectBroker::getNewSection(int classTag)
00471 {
00472     switch(classTag) {
00473  case SEC_TAG_Elastic2d:
00474       return new ElasticSection2d();
00475       
00476  case SEC_TAG_Elastic3d:
00477       return new ElasticSection3d();      
00478       
00479  case SEC_TAG_Generic1d:
00480       return new GenericSection1d();
00481       
00482  case SEC_TAG_GenericNd:
00483       return new GenericSectionNd();      
00484 
00485  case SEC_TAG_Aggregator:
00486       return new SectionAggregator();
00487 
00488  case SEC_TAG_Fiber:
00489    return new FiberSection();
00490 
00491         case SEC_TAG_FiberSection2d:
00492    return new FiberSection2d();
00493       
00494         case SEC_TAG_FiberSection3d:
00495    return new FiberSection3d();
00496 
00497  default:
00498       cerr << "FEM_ObjectBroker::getNewSection - ";
00499       cerr << " - no section type exists for class tag ";
00500       cerr << classTag << endl;
00501       return 0;
00502       
00503   }        
00504 }
00505 
00506 NDMaterial*
00507 FEM_ObjectBroker::getNewNDMaterial(int classTag)
00508 {
00509     switch(classTag) {
00510   case ND_TAG_ElasticIsotropicPlaneStrain2d:
00511    return new ElasticIsotropicPlaneStrain2D();
00512   
00513   case ND_TAG_ElasticIsotropicPlaneStress2d:
00514    return new ElasticIsotropicPlaneStress2D();
00515   
00516   default:
00517    cerr << "FEM_ObjectBroker::getNewNDMaterial - ";
00518    cerr << " - no NDMaterial type exists for class tag ";
00519    cerr << classTag << endl;
00520    return 0;   
00521   }
00522 }
00523 
00524 Fiber*
00525 FEM_ObjectBroker::getNewFiber(int classTag)
00526 {
00527  switch(classTag) {
00528  case FIBER_TAG_Uniaxial2d:
00529   return new UniaxialFiber2d();
00530 
00531  case FIBER_TAG_Uniaxial3d:
00532   return new UniaxialFiber3d();
00533 
00534  default:
00535   cerr << "FEM_ObjectBroker::getNewFiber - ";
00536   cerr << " - no Fiber type exists for class tag ";
00537   cerr << classTag << endl;
00538   return 0;
00539  }
00540 }
00541 
00542 ConvergenceTest *
00543 FEM_ObjectBroker::getNewConvergenceTest(int classTag)
00544 {
00545     switch(classTag) {
00546  case CONVERGENCE_TEST_CTestNormUnbalance:  
00547       return new CTestNormUnbalance();
00548       
00549  case CONVERGENCE_TEST_CTestNormDispIncr:  
00550       return new CTestNormDispIncr();
00551             
00552  case CONVERGENCE_TEST_CTestEnergyIncr:  
00553       return new CTestEnergyIncr();
00554                   
00555       
00556  default:
00557       cerr << "FEM_ObjectBroker::getPtrNewConvergenceTest - ";
00558       cerr << " - no ConvergenceTest type exists for class tag ";
00559       cerr << classTag << endl;
00560       return 0;
00561       
00562   }        
00563 }
00564 
00565 
00566 LoadPattern *
00567 FEM_ObjectBroker::getNewLoadPattern(int classTag)
00568 {
00569     switch(classTag) {
00570  case PATTERN_TAG_LoadPattern:
00571       return new LoadPattern();
00572 
00573  default:
00574       cerr << "FEM_ObjectBroker::getPtrLoadPattern - ";
00575       cerr << " - no Load type exists for class tag ";
00576       cerr << classTag << endl;
00577       return 0;
00578       
00579   }        
00580 }
00581 
00582 
00583 GroundMotion *
00584 FEM_ObjectBroker::getNewGroundMotion(int classTag)
00585 {
00586     switch(classTag) {
00587  default:
00588       cerr << "FEM_ObjectBroker::getPtrGroundMotion - ";
00589       cerr << " - no Load type exists for class tag ";
00590       cerr << classTag << endl;
00591       return 0;
00592       
00593   }        
00594 }
00595 
00596 TimeSeries *
00597 FEM_ObjectBroker::getNewTimeSeries(int classTag)
00598 {
00599     switch(classTag) {
00600         case TSERIES_TAG_LinearSeries:
00601    return new LinearSeries;
00602       
00603         case TSERIES_TAG_RectangularSeries:
00604    return new RectangularSeries;
00605 
00606         case TSERIES_TAG_PathTimeSeries:
00607    return new PathTimeSeries;
00608 
00609         case TSERIES_TAG_PathSeries:
00610    return new PathSeries;
00611 
00612         case TSERIES_TAG_ConstantSeries:
00613    return new ConstantSeries;
00614 
00615   case TSERIES_TAG_TrigSeries:
00616    return new TrigSeries;
00617 
00618  default:
00619       cerr << "FEM_ObjectBroker::getPtrTimeSeries - ";
00620       cerr << " - no Load type exists for class tag ";
00621       cerr << classTag << endl;
00622       return 0;
00623       
00624   }        
00625 }
00626 
00627 
00628 Matrix   *
00629 FEM_ObjectBroker::getPtrNewMatrix(int classTag, int noRows, int noCols)
00630 {
00631     switch(classTag) {
00632  case MATRIX_TAG_Matrix:  
00633       return new Matrix(noRows,noCols);
00634       
00635       
00636  default:
00637       cerr << "FEM_ObjectBroker::getPtrNewMatrix - ";
00638       cerr << " - no NodalLoad type exists for class tag ";
00639       cerr << classTag << endl;
00640       return 0;
00641       
00642   }        
00643 }
00644 
00645 
00646 Vector   *
00647 FEM_ObjectBroker::getPtrNewVector(int classTag, int size)
00648 {
00649     switch(classTag) {
00650  case VECTOR_TAG_Vector:  
00651       return new Vector(size);
00652       
00653       
00654  default:
00655       cerr << "FEM_ObjectBroker::getPtrNewVector - ";
00656       cerr << " - no Vector type exists for class tag ";
00657       cerr << classTag << endl;
00658       return 0;
00659       
00660   }        
00661 }
00662 
00663 
00664 ID           *
00665 FEM_ObjectBroker::getPtrNewID(int classTag, int size)
00666 {
00667     switch(classTag) {
00668  case ID_TAG_ID:  
00669       return new ID(size);
00670       
00671       
00672  default:
00673       cerr << "FEM_ObjectBroker::getPtrNewID - ";
00674       cerr << " - no ID type exists for class tag ";
00675       cerr << classTag << endl;
00676       return 0;
00677       
00678   }        
00679 }
00680 
00681 
00682 
00683 /*****************************************
00684  *
00685  * METHODS TO GET NEW ANALYSIS CLASSES
00686  *
00687  *****************************************/
00688 
00689 ConstraintHandler   *
00690 FEM_ObjectBroker::getNewConstraintHandler(int classTag)
00691 {
00692     switch(classTag) {
00693  case HANDLER_TAG_PlainHandler:  
00694       return new PlainHandler();
00695       
00696       
00697  default:
00698       cerr << "FEM_ObjectBroker::getNewConstraintHandler - ";
00699       cerr << " - no ConstraintHandler type exists for class tag ";
00700       cerr << classTag << endl;
00701       return 0;
00702       
00703   }        
00704 }
00705 
00706 
00707 DOF_Numberer        *
00708 FEM_ObjectBroker::getNewNumberer(int classTag)
00709 {
00710     switch(classTag) {
00711  case NUMBERER_TAG_DOF_Numberer:  
00712       return new DOF_Numberer();
00713       
00714       
00715  case NUMBERER_TAG_PlainNumberer:  
00716       return new PlainNumberer();
00717       
00718       
00719  default:
00720       cerr << "FEM_ObjectBroker::getNewConstraintHandler - ";
00721       cerr << " - no ConstraintHandler type exists for class tag ";
00722       cerr << classTag << endl;
00723       return 0;
00724       
00725   }
00726 }
00727 
00728 
00729 AnalysisModel       *
00730 FEM_ObjectBroker::getNewAnalysisModel(int classTag)
00731 {
00732     switch(classTag) {
00733  case AnaMODEL_TAGS_AnalysisModel:  
00734       return new AnalysisModel();
00735       
00736       
00737  default:
00738       cerr << "FEM_ObjectBroker::getNewAnalysisModel - ";
00739       cerr << " - no AnalysisModel type exists for class tag ";
00740       cerr << classTag << endl;
00741       return 0;
00742       
00743   }        
00744 }
00745 
00746 
00747 EquiSolnAlgo        *
00748 FEM_ObjectBroker::getNewEquiSolnAlgo(int classTag)
00749 {
00750     switch(classTag) {
00751  case EquiALGORITHM_TAGS_Linear:  
00752       return new Linear();
00753       
00754       
00755  case EquiALGORITHM_TAGS_NewtonRaphson:  
00756       return new NewtonRaphson();
00757       
00758       
00759  case EquiALGORITHM_TAGS_ModifiedNewton:  
00760       return new ModifiedNewton();
00761       
00762       
00763  default:
00764       cerr << "FEM_ObjectBroker::getNewEquiSolnAlgo - ";
00765       cerr << " - no EquiSolnAlgo type exists for class tag ";
00766       cerr << classTag << endl;
00767       return 0;
00768       
00769   }        
00770 }
00771 
00772 
00773 DomainDecompAlgo    *
00774 FEM_ObjectBroker::getNewDomainDecompAlgo(int classTag)
00775 {
00776     switch(classTag) {
00777  case DomDecompALGORITHM_TAGS_DomainDecompAlgo:  
00778       return new DomainDecompAlgo();
00779       
00780       
00781  default:
00782       cerr << "FEM_ObjectBroker::getNewDomainDecompAlgo - ";
00783       cerr << " - no DomainDecompAlgo type exists for class tag ";
00784       cerr << classTag << endl;
00785       return 0;
00786       
00787   }
00788 }
00789 
00790 
00791 StaticIntegrator    *
00792 FEM_ObjectBroker::getNewStaticIntegrator(int classTag)
00793 {
00794     switch(classTag) {
00795  case INTEGRATOR_TAGS_LoadControl:  
00796       return new LoadControl(1.0,1.0,1.0,.10); // must recvSelf
00797       
00798       
00799  case INTEGRATOR_TAGS_ArcLength:  
00800       return new ArcLength(1.0);      // must recvSelf
00801             
00802       
00803  default:
00804       cerr << "FEM_ObjectBroker::getNewStaticIntegrator - ";
00805       cerr << " - no StaticIntegrator type exists for class tag ";
00806       cerr << classTag << endl;
00807       return 0;
00808       
00809   }
00810 }
00811 
00812 
00813 TransientIntegrator *
00814 FEM_ObjectBroker::getNewTransientIntegrator(int classTag)
00815 {
00816     switch(classTag) {
00817  case INTEGRATOR_TAGS_Newmark:  
00818       return new Newmark();
00819       
00820       
00821  default:
00822       cerr << "FEM_ObjectBroker::getNewTransientIntegrator - ";
00823       cerr << " - no TransientIntegrator type exists for class tag ";
00824       cerr << classTag << endl;
00825       return 0;
00826       
00827   }
00828 }
00829 
00830 
00831 IncrementalIntegrator *
00832 FEM_ObjectBroker::getNewIncrementalIntegrator(int classTag)
00833 {
00834     switch(classTag) {
00835  case INTEGRATOR_TAGS_LoadControl:  
00836       return new LoadControl(1.0,1.0,1.0,1.0); // must recvSelf
00837      
00838       
00839  case INTEGRATOR_TAGS_ArcLength:  
00840       return new ArcLength(1.0);      // must recvSelf
00841             
00842       
00843  case INTEGRATOR_TAGS_Newmark:  
00844       return new Newmark();
00845       
00846       
00847  default:
00848       cerr << "FEM_ObjectBroker::getNewIncrementalIntegrator - ";
00849       cerr << " - no IncrementalIntegrator type exists for class tag ";
00850       cerr << classTag << endl;
00851       return 0;
00852       
00853   }
00854 }
00855 
00856 
00857 LinearSOESolver *
00858 FEM_ObjectBroker::getNewLinearSolver(void)
00859 {
00860     return lastLinearSolver;
00861 }
00862 
00863 LinearSOE *
00864 FEM_ObjectBroker::getNewLinearSOE(int classTagSOE, 
00865          int classTagSolver)
00866 {
00867     LinearSOE *theSOE =0;
00868 //    SlowLinearSOESolver *theSlowSolver =0;     
00869     FullGenLinSolver *theGenSolver =0;
00870     BandGenLinSolver *theGenBandSolver =0;
00871     BandSPDLinSolver *theBandSPDSolver =0;
00872     ProfileSPDLinSolver *theProfileSPDSolver =0;    
00873 
00874     /*
00875       case LinSOE_TAGS_SlowLinearSOE:  
00876  if (classTagSolver == SOLVER_TAGS_SlowLinearSOESolver) {
00877      theSlowSolver = new SlowLinearSOESolver();
00878      theSOE = new SlowLinearSOE(*theSlowSolver);
00879      lastLinearSolver = theSlowSolver;
00880      return theSOE;
00881  } else {
00882      cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
00883      cerr << " - no SlowLinearSOESolver type exists for class tag ";
00884      cerr << classTagSolver << endl;
00885      return 0;   
00886  }
00887  
00888  */
00889 
00890     
00891     switch(classTagSOE) {
00892       case LinSOE_TAGS_FullGenLinSOE:  
00893 
00894  if (classTagSolver == SOLVER_TAGS_FullGenLinLapackSolver) {
00895      theGenSolver = new FullGenLinLapackSolver();
00896      theSOE = new FullGenLinSOE(*theGenSolver);
00897      lastLinearSolver = theGenSolver;
00898      return theSOE;
00899  } else {
00900      cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
00901      cerr << " - no FullGenLinSOESolver type exists for class tag ";
00902      cerr << classTagSolver << endl;
00903      return 0;   
00904  }      
00905  
00906       
00907       case LinSOE_TAGS_BandGenLinSOE:  
00908 
00909    if (classTagSolver == SOLVER_TAGS_BandGenLinLapackSolver) {
00910        theGenBandSolver = new BandGenLinLapackSolver();
00911        theSOE = new BandGenLinSOE(*theGenBandSolver);
00912        lastLinearSolver = theGenBandSolver;
00913        return theSOE;
00914    } else {
00915        cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
00916        cerr << " - no BandGenLinSolver type exists for class tag ";
00917        cerr << classTagSolver << endl;
00918        return 0;
00919    }       
00920    
00921       
00922  case LinSOE_TAGS_BandSPDLinSOE:  
00923 
00924    if (classTagSolver == SOLVER_TAGS_BandSPDLinLapackSolver) {
00925        theBandSPDSolver = new BandSPDLinLapackSolver();
00926        theSOE = new BandSPDLinSOE(*theBandSPDSolver);
00927        lastLinearSolver = theBandSPDSolver;
00928        return theSOE;
00929    } else {
00930        cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
00931        cerr << " - no BandSPDLinSOESolver type exists for class tag ";
00932        cerr << classTagSolver << endl;
00933        return 0;
00934    }      
00935    
00936       
00937  case LinSOE_TAGS_ProfileSPDLinSOE:  
00938 
00939    if (classTagSolver == SOLVER_TAGS_ProfileSPDLinDirectSolver) {
00940        theProfileSPDSolver = new ProfileSPDLinDirectSolver();
00941        theSOE = new ProfileSPDLinSOE(*theProfileSPDSolver);
00942        lastLinearSolver = theProfileSPDSolver;
00943        return theSOE;
00944    } else if (classTagSolver == SOLVER_TAGS_ProfileSPDLinSubstrSolver) {
00945        theProfileSPDSolver = new ProfileSPDLinSubstrSolver();
00946        theSOE = new ProfileSPDLinSOE(*theProfileSPDSolver);
00947        lastLinearSolver = theProfileSPDSolver;
00948        return 0;   
00949    } 
00950    else {
00951        cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
00952        cerr << " - no ProfileSPD_LinSolver type exists for class tag ";
00953        cerr << classTagSolver << endl;
00954        return 0;   
00955    }      
00956    
00957 
00958  default:
00959    cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
00960    cerr << " - no LinearSOE type exists for class tag ";
00961    cerr << classTagSOE << endl;
00962    return 0;
00963    
00964       
00965     }
00966 }
00967 
00968 
00969 
00970 
00971 DomainSolver *
00972 FEM_ObjectBroker::getNewDomainSolver(void)
00973 {
00974     return lastDomainSolver;
00975 }
00976     
00977 LinearSOE *
00978 FEM_ObjectBroker::getPtrNewDDLinearSOE(int classTagSOE, 
00979            int classTagDDSolver)
00980 {
00981     ProfileSPDLinSubstrSolver *theProfileSPDSolver =0;    
00982 
00983     switch(classTagSOE) {
00984       case LinSOE_TAGS_ProfileSPDLinSOE:  
00985 
00986  if (classTagDDSolver == SOLVER_TAGS_ProfileSPDLinSubstrSolver) {
00987      theProfileSPDSolver = new ProfileSPDLinSubstrSolver();
00988      LinearSOE *theSOE = new ProfileSPDLinSOE(*theProfileSPDSolver);
00989      lastDomainSolver = theProfileSPDSolver;
00990      return theSOE;   
00991  }
00992  else {
00993      cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
00994      cerr << " - no ProfileSPD Domain Solver type exists for class tag ";
00995      cerr << classTagDDSolver << endl;
00996      return 0;   
00997  }      
00998  
00999          
01000       default:
01001  cerr << "FEM_ObjectBroker::getNewLinearSOE - ";
01002  cerr << " - no LinearSOE type exists for class tag ";
01003  cerr << classTagSOE << endl;
01004  return 0;
01005  
01006     }
01007 }
01008 
01009 
01010 DomainDecompositionAnalysis *
01011 FEM_ObjectBroker::getNewDomainDecompAnalysis(int classTag, 
01012       Subdomain &theSubdomain)
01013 {
01014     switch(classTag) {
01015       case DomDecompANALYSIS_TAGS_DomainDecompositionAnalysis:  
01016  return new DomainDecompositionAnalysis(theSubdomain);
01017  
01018  
01019       default:
01020  cerr << "ObjectBroker::getNewDomainDecompAnalysis ";
01021  cerr << " - no DomainDecompAnalysis type exists for class tag " ;
01022  cerr << classTag << endl;
01023  return 0;
01024  
01025     }
01026 }
01027 
01028 
01029 Subdomain    *
01030 FEM_ObjectBroker::getSubdomainPtr(int classTag)
01031 {
01032     cerr << "FEM_ObjectBroker: NOT IMPLEMENTED YET";
01033     return 0;
01034 }
01035 
01036 
01037 
01038