FEM_ObjectBroker.cppGo to the documentation of this file.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.34 $ 00022 // $Date: 2006/08/04 22:37:15 $ 00023 // $Source: /usr/local/cvs/OpenSees/SRC/actor/objectBroker/FEM_ObjectBroker.cpp,v $ 00024 00025 00026 // Written: fmk 00027 // Revision: A 00028 // 00029 // Purpose: This file contains the class definition for FEM_ObjectBroker. 00030 // FEM_ObjectBroker is is an object broker class for the finite element 00031 // method. All methods are virtual to allow for subclasses; which can be 00032 // used by programmers when introducing new subclasses of the main objects. 00033 // 00034 // What: "@(#) FEM_ObjectBroker.C, revA" 00035 00036 00037 #include <FEM_ObjectBroker.h> 00038 00039 // ActorTypes 00040 #include <ActorSubdomain.h> 00041 00042 // Convergence tests 00043 #include <CTestNormUnbalance.h> 00044 #include <CTestNormDispIncr.h> 00045 #include <CTestEnergyIncr.h> 00046 00047 // graph numbering schemes 00048 #include <RCM.h> 00049 #include <MyRCM.h> 00050 #include <SimpleNumberer.h> 00051 00052 00053 // uniaxial material model header files 00054 #include <ElasticMaterial.h> 00055 #include <ElasticPPMaterial.h> 00056 #include <ParallelMaterial.h> 00057 #include <Concrete01.h> 00058 #include <Steel01.h> 00059 #include <HardeningMaterial.h> 00060 #include <HystereticMaterial.h> 00061 #include <EPPGapMaterial.h> 00062 #include <ViscousMaterial.h> 00063 #include <PathIndependentMaterial.h> 00064 #include <SeriesMaterial.h> 00065 #include <CableMaterial.h> 00066 #include <ENTMaterial.h> 00067 #include <MinMaxMaterial.h> 00068 00069 //PY springs: RWBoulanger and BJeremic 00070 #include <PySimple1.h> 00071 #include <TzSimple1.h> 00072 #include <QzSimple1.h> 00073 #include <PyLiq1.h> 00074 #include <TzLiq1.h> 00075 00076 00077 #include <FedeasBond1Material.h> 00078 #include <FedeasBond2Material.h> 00079 #include <FedeasConcr1Material.h> 00080 #include <FedeasConcr2Material.h> 00081 #include <FedeasConcr3Material.h> 00082 #include <FedeasHardeningMaterial.h> 00083 #include <FedeasHyster1Material.h> 00084 #include <FedeasHyster2Material.h> 00085 #include <FedeasSteel1Material.h> 00086 #include <FedeasSteel2Material.h> 00087 00088 #include <DrainBilinearMaterial.h> 00089 #include <DrainClough1Material.h> 00090 #include <DrainClough2Material.h> 00091 #include <DrainPinch1Material.h> 00092 00093 // Sections 00094 #include <ElasticSection2d.h> 00095 #include <ElasticSection3d.h> 00096 #include <GenericSection1d.h> 00097 //#include <GenericSectionNd.h> 00098 #include <SectionAggregator.h> 00099 //#include <FiberSection.h> 00100 #include <FiberSection2d.h> 00101 #include <FiberSection3d.h> 00102 #include <ElasticPlateSection.h> 00103 #include <ElasticMembranePlateSection.h> 00104 #include <MembranePlateFiberSection.h> 00105 #include <Bidirectional.h> 00106 00107 // NDMaterials 00108 #include <ElasticIsotropicPlaneStrain2D.h> 00109 #include <ElasticIsotropicPlaneStress2D.h> 00110 #include <ElasticIsotropicPlateFiber.h> 00111 #include <ElasticIsotropicAxiSymm.h> 00112 #include <ElasticIsotropic3D.h> 00113 #include <J2PlaneStrain.h> 00114 #include <J2PlaneStress.h> 00115 #include <J2PlateFiber.h> 00116 #include <J2AxiSymm.h> 00117 #include <J2ThreeDimensional.h> 00118 #include <PlaneStressMaterial.h> 00119 #include <PlateFiberMaterial.h> 00120 #include <FeapMaterial03.h> 00121 00122 #include <FluidSolidPorousMaterial.h> 00123 #include <PressureDependMultiYield.h> 00124 #include <PressureIndependMultiYield.h> 00125 00126 // Fibers 00127 #include <UniaxialFiber2d.h> 00128 #include <UniaxialFiber3d.h> 00129 // element header files 00130 #include <Element.h> 00131 #include <beam2d02.h> 00132 #include <beam2d03.h> 00133 #include <beam2d04.h> 00134 #include <beam3d01.h> 00135 #include <beam3d02.h> 00136 #include <Truss.h> 00137 #include <TrussSection.h> 00138 #include <CorotTruss.h> 00139 #include <CorotTrussSection.h> 00140 #include <ZeroLength.h> 00141 #include <ZeroLengthSection.h> 00142 //#include <ZeroLengthND.h> 00143 #include <FourNodeQuad.h> 00144 #include <EnhancedQuad.h> 00145 #include <NineNodeMixedQuad.h> 00146 #include <ConstantPressureVolumeQuad.h> 00147 #include <ElasticBeam2d.h> 00148 #include <ElasticBeam3d.h> 00149 #include <ForceBeamColumn2d.h> 00150 #include <ForceBeamColumn3d.h> 00151 00152 #include <DispBeamColumn2d.h> 00153 #include <DispBeamColumn3d.h> 00154 #include <ShellMITC4.h> 00155 #include <Brick.h> 00156 #include <BbarBrick.h> 00157 #include <Joint2D.h> // Arash 00158 00159 00160 #include <LinearCrdTransf2d.h> 00161 #include <LinearCrdTransf3d.h> 00162 #include <PDeltaCrdTransf2d.h> 00163 #include <PDeltaCrdTransf3d.h> 00164 #include <CorotCrdTransf2d.h> 00165 #include <CorotCrdTransf3d.h> 00166 00167 #include <HingeMidpointBeamIntegration.h> 00168 #include <HingeEndpointBeamIntegration.h> 00169 #include <HingeRadauBeamIntegration.h> 00170 #include <HingeRadauTwoBeamIntegration.h> 00171 #include <LobattoBeamIntegration.h> 00172 #include <LegendreBeamIntegration.h> 00173 #include <RadauBeamIntegration.h> 00174 #include <NewtonCotesBeamIntegration.h> 00175 00176 // node header files 00177 #include <Node.h> 00178 00179 00180 #include <FileStream.h> 00181 #include <StandardStream.h> 00182 #include <XmlFileStream.h> 00183 #include <DataFileStream.h> 00184 #include <DatabaseStream.h> 00185 00186 #include <NodeRecorder.h> 00187 #include <ElementRecorder.h> 00188 #include <EnvelopeNodeRecorder.h> 00189 #include <EnvelopeElementRecorder.h> 00190 00191 // mp_constraint header files 00192 #include <MP_Constraint.h> 00193 #include <MP_Joint2D.h> 00194 00195 // sp_constraint header files 00196 #include <SP_Constraint.h> 00197 #include <SP_Constraint.h> 00198 #include <ImposedMotionSP.h> 00199 #include <ImposedMotionSP1.h> 00200 00201 // nodal load header files 00202 #include <NodalLoad.h> 00203 00204 // elemental load header files 00205 #include <ElementalLoad.h> 00206 #include<Beam2dUniformLoad.h> 00207 #include<Beam2dPointLoad.h> 00208 #include<Beam3dUniformLoad.h> 00209 #include<Beam3dPointLoad.h> 00210 #include<BrickSelfWeight.h> 00211 00212 // matrix, vector & id header files 00213 #include <Matrix.h> 00214 #include <Vector.h> 00215 #include <ID.h> 00216 00217 // subdomain header files 00218 #include <Subdomain.h> 00219 00220 // constraint handler header files 00221 #include <ConstraintHandler.h> 00222 #include <PlainHandler.h> 00223 #include <PenaltyConstraintHandler.h> 00224 #include <LagrangeConstraintHandler.h> 00225 #include <TransformationConstraintHandler.h> 00226 00227 // dof numberer header files 00228 #include <DOF_Numberer.h> 00229 #include <PlainNumberer.h> 00230 00231 // analysis model header files 00232 #include <AnalysisModel.h> 00233 00234 // equi soln algo header files 00235 #include <EquiSolnAlgo.h> 00236 #include <Linear.h> 00237 #include <NewtonRaphson.h> 00238 #include <ModifiedNewton.h> 00239 00240 // domain decomp soln algo header files 00241 #include <DomainDecompAlgo.h> 00242 00243 // integrator header files 00244 #include <LoadControl.h> 00245 #include <ArcLength.h> 00246 #include <TransientIntegrator.h> 00247 #include <Newmark.h> 00248 #include <DisplacementControl.h> 00249 #include <CentralDifferenceNoDamping.h> 00250 #include <CentralDifferenceAlternative.h> 00251 00252 #ifdef _PARALLEL_PROCESSING 00253 #include <DistributedDisplacementControl.h> 00254 #endif 00255 // system of eqn header files 00256 #include <LinearSOE.h> 00257 #include <DomainSolver.h> 00258 #include <FullGenLinSOE.h> 00259 #include <FullGenLinLapackSolver.h> 00260 #include <BandGenLinSOE.h> 00261 00262 #include <BandGenLinLapackSolver.h> 00263 #include <BandSPDLinSOE.h> 00264 #include <BandSPDLinLapackSolver.h> 00265 #include <ProfileSPDLinSOE.h> 00266 #include <ProfileSPDLinDirectSolver.h> 00267 #include <ProfileSPDLinSubstrSolver.h> 00268 00269 #include <SparseGenColLinSOE.h> 00270 #include <SuperLU.h> 00271 00272 #include <DomainDecompositionAnalysis.h> 00273 00274 // load patterns 00275 #include <LoadPattern.h> 00276 #include <UniformExcitation.h> 00277 #include <MultiSupportPattern.h> 00278 #include <GroundMotion.h> 00279 #include <InterpolatedGroundMotion.h> 00280 00281 // time series 00282 #include <LinearSeries.h> 00283 #include <PathSeries.h> 00284 #include <PathTimeSeries.h> 00285 #include <RectangularSeries.h> 00286 #include <ConstantSeries.h> 00287 #include <TrigSeries.h> 00288 00289 // time series integrators 00290 #include <TrapezoidalTimeSeriesIntegrator.h> 00291 00292 #ifdef _PETSC 00293 #include <PetscSOE.h> 00294 #include <PetscSolver.h> 00295 #include <SparseGenColLinSOE.h> 00296 #include <PetscSparseSeqSolver.h> 00297 #endif 00298 00299 00300 #ifdef _MUMPS 00301 #include <MumpsSOE.h> 00302 #include <MumpsSolver.h> 00303 #ifdef _PARALLEL_PROCESSING 00304 #include <MumpsParallelSOE.h> 00305 #include <MumpsParallelSolver.h> 00306 #endif 00307 #endif 00308 00309 #ifdef _PARALLEL_PROCESSING 00310 #include <DistributedBandSPDLinSOE.h> 00311 #include <DistributedProfileSPDLinSOE.h> 00312 #include <DistributedSparseGenColLinSOE.h> 00313 #include <DistributedSparseGenRowLinSOE.h> 00314 #include <DistributedSparseGenRowLinSolver.h> 00315 #include <DistributedBandGenLinSOE.h> 00316 #include <DistributedSuperLU.h> 00317 #include <ParallelNumberer.h> 00318 #include <StaticDomainDecompositionAnalysis.h> 00319 #include <TransientDomainDecompositionAnalysis.h> 00320 #include <DistributedDiagonalSOE.h> 00321 #include <DistributedDiagonalSolver.h> 00322 #endif 00323 00324 #include <packages.h> 00325 00326 typedef struct uniaxialPackage { 00327 int classTag; 00328 char *libName; 00329 char *funcName; 00330 UniaxialMaterial *(*funcPtr)(void); 00331 struct uniaxialPackage *next; 00332 } UniaxialPackage; 00333 00334 static UniaxialPackage *theUniaxialPackage = NULL; 00335 00336 00337 00338 FEM_ObjectBroker::FEM_ObjectBroker() 00339 :lastLinearSolver(0),lastDomainSolver(0) 00340 { 00341 00342 } 00343 00344 00345 FEM_ObjectBroker::~FEM_ObjectBroker() 00346 { 00347 00348 } 00349 00350 00351 Actor * 00352 FEM_ObjectBroker::getNewActor(int classTag, Channel *theChannel) 00353 { 00354 switch(classTag) { 00355 00356 #ifdef _PARALLEL_PROCESSING 00357 case ACTOR_TAGS_SUBDOMAIN: 00358 return new ActorSubdomain(*theChannel, *this); 00359 #endif 00360 00361 default: 00362 opserr << "FEM_ObjectBroker::getNewActor - "; 00363 opserr << " - no ActorType type exists for class tag "; 00364 opserr << classTag << endln; 00365 return 0; 00366 } 00367 } 00368 00369 00370 PartitionedModelBuilder * 00371 FEM_ObjectBroker::getPtrNewPartitionedModelBuilder(Subdomain &theSubdomain, 00372 int classTag) 00373 { 00374 switch(classTag) { 00375 /* 00376 case PartitionedModelBuilder_TAGS_PartitionedQuick2dFrameModel: 00377 return new PartitionedQuick2dFrame(theSubdomain); 00378 */ 00379 00380 default: 00381 opserr << "FEM_ObjectBroker::getPtrNewPartitionedModelBuilder - "; 00382 opserr << " - no PartitionedModelBuilder type exists for class tag "; 00383 opserr << classTag << endln; 00384 return 0; 00385 00386 } 00387 } 00388 00389 00390 GraphNumberer * 00391 FEM_ObjectBroker::getPtrNewGraphNumberer(int classTag) 00392 { 00393 switch(classTag) { 00394 case GraphNUMBERER_TAG_RCM: 00395 return new RCM(); 00396 00397 00398 case GraphNUMBERER_TAG_MyRCM: 00399 return new MyRCM(); 00400 00401 00402 case GraphNUMBERER_TAG_SimpleNumberer: 00403 return new SimpleNumberer(); 00404 00405 00406 default: 00407 opserr << "ObjectBroker::getPtrNewGraphNumberer - "; 00408 opserr << " - no GraphNumberer type exists for class tag " ; 00409 opserr << classTag << endln; 00410 return 0; 00411 00412 } 00413 } 00414 00415 /***************************************** 00416 * 00417 * METHODS TO GET NEW MODELLING CLASSES 00418 * 00419 *****************************************/ 00420 00421 00422 00423 00424 00425 00426 00427 00428 Element * 00429 FEM_ObjectBroker::getNewElement(int classTag) 00430 { 00431 switch(classTag) { 00432 00433 case ELE_TAG_Truss: 00434 return new Truss(); 00435 00436 case ELE_TAG_TrussSection: 00437 return new TrussSection(); 00438 00439 case ELE_TAG_CorotTruss: 00440 return new CorotTruss(); 00441 00442 case ELE_TAG_CorotTrussSection: 00443 return new CorotTrussSection(); 00444 00445 case ELE_TAG_ZeroLength: 00446 return new ZeroLength(); 00447 00448 case ELE_TAG_ZeroLengthSection: 00449 return new ZeroLengthSection(); 00450 00451 //case ELE_TAG_ZeroLengthND: 00452 //return new ZeroLengthND(); 00453 00454 case ELE_TAG_FourNodeQuad: 00455 return new FourNodeQuad(); 00456 00457 case ELE_TAG_ElasticBeam2d: 00458 return new ElasticBeam2d(); 00459 00460 case ELE_TAG_ElasticBeam3d: 00461 return new ElasticBeam3d(); 00462 00463 case ELE_TAG_ForceBeamColumn2d: 00464 return new ForceBeamColumn2d(); 00465 00466 case ELE_TAG_ForceBeamColumn3d: 00467 return new ForceBeamColumn3d(); 00468 00469 case ELE_TAG_DispBeamColumn2d: 00470 return new DispBeamColumn2d(); 00471 00472 case ELE_TAG_DispBeamColumn3d: 00473 return new DispBeamColumn3d(); 00474 00475 case ELE_TAG_EnhancedQuad: 00476 return new EnhancedQuad(); 00477 00478 case ELE_TAG_NineNodeMixedQuad: 00479 return new NineNodeMixedQuad(); 00480 00481 case ELE_TAG_ConstantPressureVolumeQuad: 00482 return new ConstantPressureVolumeQuad(); 00483 00484 case ELE_TAG_Brick: 00485 return new Brick(); 00486 00487 case ELE_TAG_ShellMITC4: 00488 return new ShellMITC4(); 00489 00490 case ELE_TAG_BbarBrick: 00491 return new BbarBrick(); 00492 00493 case ELE_TAG_Joint2D: // Arash 00494 return new Joint2D(); // Arash 00495 00496 default: 00497 opserr << "FEM_ObjectBroker::getNewElement - "; 00498 opserr << " - no Element type exists for class tag " ; 00499 opserr << classTag << endln; 00500 return 0; 00501 00502 } 00503 } 00504 00505 Node * 00506 FEM_ObjectBroker::getNewNode(int classTag) 00507 { 00508 switch(classTag) { 00509 case NOD_TAG_Node: 00510 return new Node(classTag); 00511 00512 00513 default: 00514 opserr << "FEM_ObjectBroker::getNewNode - "; 00515 opserr << " - no Node type exists for class tag "; 00516 opserr << classTag << endln; 00517 return 0; 00518 00519 } 00520 } 00521 00522 00523 MP_Constraint * 00524 FEM_ObjectBroker::getNewMP(int classTag) 00525 { 00526 switch(classTag) { 00527 case CNSTRNT_TAG_MP_Constraint: 00528 return new MP_Constraint( 0 , classTag); 00529 00530 case CNSTRNT_TAG_MP_Joint2D: // Arash 00531 return new MP_Joint2D(); // Arash 00532 00533 default: 00534 opserr << "FEM_ObjectBroker::getNewMP - "; 00535 opserr << " - no MP_Constraint type exists for class tag "; 00536 opserr << classTag << endln; 00537 return 0; 00538 00539 } 00540 } 00541 00542 00543 SP_Constraint * 00544 FEM_ObjectBroker::getNewSP(int classTag) 00545 { 00546 switch(classTag) { 00547 case CNSTRNT_TAG_SP_Constraint: 00548 return new SP_Constraint(classTag); 00549 00550 case CNSTRNT_TAG_ImposedMotionSP: 00551 return new ImposedMotionSP(); 00552 00553 case CNSTRNT_TAG_ImposedMotionSP1: 00554 return new ImposedMotionSP1(); 00555 00556 default: 00557 opserr << "FEM_ObjectBroker::getNewSP - "; 00558 opserr << " - no SP_Constraint type exists for class tag "; 00559 opserr << classTag << endln; 00560 return 0; 00561 00562 } 00563 } 00564 00565 NodalLoad * 00566 FEM_ObjectBroker::getNewNodalLoad(int classTag) 00567 { 00568 switch(classTag) { 00569 case LOAD_TAG_NodalLoad: 00570 return new NodalLoad(classTag); 00571 00572 00573 default: 00574 opserr << "FEM_ObjectBroker::getNewNodalLoad - "; 00575 opserr << " - no NodalLoad type exists for class tag "; 00576 opserr << classTag << endln; 00577 return 0; 00578 00579 } 00580 } 00581 00582 00583 ElementalLoad * 00584 FEM_ObjectBroker::getNewElementalLoad(int classTag) 00585 { 00586 switch(classTag) { 00587 00588 case LOAD_TAG_Beam2dUniformLoad: 00589 return new Beam2dUniformLoad(); 00590 00591 case LOAD_TAG_Beam2dPointLoad: 00592 return new Beam2dPointLoad(); 00593 00594 case LOAD_TAG_Beam3dUniformLoad: 00595 return new Beam3dUniformLoad(); 00596 00597 case LOAD_TAG_Beam3dPointLoad: 00598 return new Beam3dPointLoad(); 00599 00600 case LOAD_TAG_BrickSelfWeight: 00601 return new BrickSelfWeight(); 00602 00603 default: 00604 opserr << "FEM_ObjectBroker::getNewNodalLoad - "; 00605 opserr << " - no NodalLoad type exists for class tag "; 00606 opserr << classTag << endln; 00607 return 0; 00608 00609 } 00610 00611 return 0; 00612 } 00613 00614 CrdTransf2d* 00615 FEM_ObjectBroker::getNewCrdTransf2d(int classTag) 00616 { 00617 switch(classTag) { 00618 case CRDTR_TAG_LinearCrdTransf2d: 00619 return new LinearCrdTransf2d(); 00620 case CRDTR_TAG_PDeltaCrdTransf2d: 00621 return new PDeltaCrdTransf2d(); 00622 #ifdef _COROTATIONAL 00623 case CRDTR_TAG_CorotCrdTransf2d: 00624 return new CorotCrdTransf2d(); 00625 #endif 00626 default: 00627 opserr << "FEM_ObjectBroker::getCrdTransf2d - "; 00628 opserr << " - no CrdTransf2d type exists for class tag "; 00629 opserr << classTag << endln; 00630 return 0; 00631 } 00632 00633 } 00634 00635 CrdTransf3d* 00636 FEM_ObjectBroker::getNewCrdTransf3d(int classTag) 00637 { 00638 switch(classTag) { 00639 case CRDTR_TAG_LinearCrdTransf3d: 00640 return new LinearCrdTransf3d(); 00641 case CRDTR_TAG_PDeltaCrdTransf3d: 00642 return new PDeltaCrdTransf3d(); 00643 #ifdef _COROTATIONAL 00644 case CRDTR_TAG_CorotCrdTransf3d: 00645 return new CorotCrdTransf3d(); 00646 #endif 00647 default: 00648 opserr << "FEM_ObjectBroker::getCrdTransf3d - "; 00649 opserr << " - no CrdTransf3d type exists for class tag "; 00650 opserr << classTag << endln; 00651 return 0; 00652 } 00653 00654 } 00655 00656 BeamIntegration * 00657 FEM_ObjectBroker::getNewBeamIntegration(int classTag) 00658 { 00659 switch(classTag) { 00660 case BEAM_INTEGRATION_TAG_Lobatto: 00661 return new LobattoBeamIntegration(); 00662 00663 case BEAM_INTEGRATION_TAG_Legendre: 00664 return new LegendreBeamIntegration(); 00665 00666 case BEAM_INTEGRATION_TAG_Radau: 00667 return new RadauBeamIntegration(); 00668 00669 case BEAM_INTEGRATION_TAG_NewtonCotes: 00670 return new NewtonCotesBeamIntegration(); 00671 00672 case BEAM_INTEGRATION_TAG_HingeMidpoint: 00673 return new HingeMidpointBeamIntegration(); 00674 00675 case BEAM_INTEGRATION_TAG_HingeRadau: 00676 return new HingeRadauBeamIntegration(); 00677 00678 case BEAM_INTEGRATION_TAG_HingeRadauTwo: 00679 return new HingeRadauTwoBeamIntegration(); 00680 00681 case BEAM_INTEGRATION_TAG_HingeEndpoint: 00682 return new HingeEndpointBeamIntegration(); 00683 00684 default: 00685 opserr << "FEM_ObjectBroker::getBeamIntegration - "; 00686 opserr << " - no BeamIntegration type exists for class tag "; 00687 opserr << classTag << endln; 00688 return 0; 00689 } 00690 } 00691 00692 00693 UniaxialMaterial * 00694 FEM_ObjectBroker::getNewUniaxialMaterial(int classTag) 00695 { 00696 switch(classTag) { 00697 case MAT_TAG_ElasticMaterial: 00698 return new ElasticMaterial(); // values set in recvSelf 00699 00700 case MAT_TAG_ElasticPPMaterial: 00701 return new ElasticPPMaterial(); // values set in recvSelf 00702 00703 case MAT_TAG_ParallelMaterial: 00704 return new ParallelMaterial(); 00705 00706 case MAT_TAG_Concrete01: 00707 return new Concrete01(); 00708 00709 case MAT_TAG_Steel01: 00710 return new Steel01(); 00711 00712 case MAT_TAG_Hardening: 00713 return new HardeningMaterial(); 00714 00715 //PY springs: RWBoulanger and BJeremic 00716 case MAT_TAG_PySimple1: 00717 return new PySimple1(); 00718 00719 case MAT_TAG_PyLiq1: 00720 return new PyLiq1(); 00721 00722 case MAT_TAG_TzSimple1: 00723 return new TzSimple1(); 00724 00725 case MAT_TAG_TzLiq1: 00726 return new TzLiq1(); 00727 00728 case MAT_TAG_QzSimple1: 00729 return new QzSimple1(); 00730 00731 00732 case MAT_TAG_Hysteretic: 00733 return new HystereticMaterial(); 00734 00735 case MAT_TAG_EPPGap: 00736 return new EPPGapMaterial(); 00737 00738 case MAT_TAG_Viscous: 00739 return new ViscousMaterial(); 00740 00741 case MAT_TAG_PathIndependent: 00742 return new PathIndependentMaterial(); 00743 00744 case MAT_TAG_SeriesMaterial: 00745 return new SeriesMaterial(); 00746 00747 case MAT_TAG_CableMaterial: 00748 return new CableMaterial(); 00749 00750 case MAT_TAG_ENTMaterial: 00751 return new ENTMaterial(); 00752 00753 case MAT_TAG_FedeasBond1: 00754 return new FedeasBond1Material(); 00755 00756 case MAT_TAG_FedeasBond2: 00757 return new FedeasBond2Material(); 00758 00759 case MAT_TAG_FedeasConcrete1: 00760 return new FedeasConcr1Material(); 00761 00762 case MAT_TAG_FedeasConcrete2: 00763 return new FedeasConcr2Material(); 00764 00765 case MAT_TAG_FedeasConcrete3: 00766 return new FedeasConcr3Material(); 00767 00768 case MAT_TAG_FedeasHardening: 00769 return new FedeasHardeningMaterial(); 00770 00771 case MAT_TAG_FedeasHysteretic1: 00772 return new FedeasHyster1Material(); 00773 00774 case MAT_TAG_FedeasHysteretic2: 00775 return new FedeasHyster2Material(); 00776 00777 case MAT_TAG_FedeasSteel1: 00778 return new FedeasSteel1Material(); 00779 00780 case MAT_TAG_FedeasSteel2: 00781 return new FedeasSteel2Material(); 00782 00783 case MAT_TAG_DrainBilinear: 00784 return new DrainBilinearMaterial(); 00785 00786 case MAT_TAG_DrainClough1: 00787 return new DrainClough1Material(); 00788 00789 case MAT_TAG_DrainClough2: 00790 return new DrainClough2Material(); 00791 00792 case MAT_TAG_DrainPinch1: 00793 return new DrainPinch1Material(); 00794 00795 case MAT_TAG_MinMax: 00796 return new MinMaxMaterial(); 00797 00798 default: 00799 00800 UniaxialPackage *matCommands = theUniaxialPackage; 00801 bool found = false; 00802 while (matCommands != NULL && found == false) { 00803 if ((matCommands->classTag == classTag) && (matCommands->funcPtr != 0)){ 00804 UniaxialMaterial *result = (*(matCommands->funcPtr))(); 00805 return result; 00806 } 00807 matCommands = matCommands->next; 00808 } 00809 00810 opserr << "FEM_ObjectBroker::getNewUniaxialMaterial - "; 00811 opserr << " - no UniaxialMaterial type exists for class tag "; 00812 opserr << classTag << endln; 00813 return 0; 00814 00815 } 00816 } 00817 00818 SectionForceDeformation * 00819 FEM_ObjectBroker::getNewSection(int classTag) 00820 { 00821 switch(classTag) { 00822 case SEC_TAG_Elastic2d: 00823 return new ElasticSection2d(); 00824 00825 case SEC_TAG_Elastic3d: 00826 return new ElasticSection3d(); 00827 00828 case SEC_TAG_Generic1d: 00829 return new GenericSection1d(); 00830 00831 //case SEC_TAG_GenericNd: 00832 //return new GenericSectionNd(); 00833 00834 case SEC_TAG_Aggregator: 00835 return new SectionAggregator(); 00836 00837 //case SEC_TAG_Fiber: 00838 //return new FiberSection(); 00839 00840 case SEC_TAG_FiberSection2d: 00841 return new FiberSection2d(); 00842 00843 case SEC_TAG_FiberSection3d: 00844 return new FiberSection3d(); 00845 00846 case SEC_TAG_ElasticPlateSection: 00847 return new ElasticPlateSection(); 00848 00849 case SEC_TAG_ElasticMembranePlateSection: 00850 return new ElasticMembranePlateSection(); 00851 00852 case SEC_TAG_MembranePlateFiberSection: 00853 return new MembranePlateFiberSection(); 00854 00855 case SEC_TAG_Bidirectional: 00856 return new Bidirectional(); 00857 00858 default: 00859 opserr << "FEM_ObjectBroker::getNewSection - "; 00860 opserr << " - no section type exists for class tag "; 00861 opserr << classTag << endln; 00862 return 0; 00863 00864 } 00865 } 00866 00867 NDMaterial* 00868 FEM_ObjectBroker::getNewNDMaterial(int classTag) 00869 { 00870 switch(classTag) { 00871 case ND_TAG_ElasticIsotropicPlaneStrain2d: 00872 return new ElasticIsotropicPlaneStrain2D(); 00873 00874 case ND_TAG_ElasticIsotropicPlaneStress2d: 00875 return new ElasticIsotropicPlaneStress2D(); 00876 00877 case ND_TAG_ElasticIsotropicAxiSymm: 00878 return new ElasticIsotropicAxiSymm(); 00879 00880 case ND_TAG_ElasticIsotropicPlateFiber: 00881 return new ElasticIsotropicPlateFiber(); 00882 00883 case ND_TAG_ElasticIsotropic3D: 00884 return new ElasticIsotropic3D(); 00885 00886 case ND_TAG_J2PlaneStrain: 00887 return new J2PlaneStrain(); 00888 00889 case ND_TAG_J2PlaneStress: 00890 return new J2PlaneStress(); 00891 00892 case ND_TAG_J2AxiSymm: 00893 return new J2AxiSymm(); 00894 00895 case ND_TAG_J2PlateFiber: 00896 return new J2PlateFiber(); 00897 00898 case ND_TAG_J2ThreeDimensional: 00899 return new J2ThreeDimensional(); 00900 00901 case ND_TAG_PlaneStressMaterial: 00902 return new PlaneStressMaterial(); 00903 00904 case ND_TAG_PlateFiberMaterial: 00905 return new PlateFiberMaterial(); 00906 00907 case ND_TAG_FluidSolidPorousMaterial: 00908 return new FluidSolidPorousMaterial(); 00909 00910 case ND_TAG_PressureDependMultiYield: 00911 return new PressureDependMultiYield(); 00912 00913 case ND_TAG_PressureIndependMultiYield: 00914 return new PressureIndependMultiYield(); 00915 00916 case ND_TAG_FeapMaterial03: 00917 return new FeapMaterial03(); 00918 00919 default: 00920 opserr << "FEM_ObjectBroker::getNewNDMaterial - "; 00921 opserr << " - no NDMaterial type exists for class tag "; 00922 opserr << classTag << endln; 00923 return 0; 00924 } 00925 } 00926 00927 Fiber* 00928 FEM_ObjectBroker::getNewFiber(int classTag) 00929 { 00930 switch(classTag) { 00931 case FIBER_TAG_Uniaxial2d: 00932 return new UniaxialFiber2d(); 00933 00934 case FIBER_TAG_Uniaxial3d: 00935 return new UniaxialFiber3d(); 00936 00937 default: 00938 opserr << "FEM_ObjectBroker::getNewFiber - "; 00939 opserr << " - no Fiber type exists for class tag "; 00940 opserr << classTag << endln; 00941 return 0; 00942 } 00943 } 00944 00945 ConvergenceTest * 00946 FEM_ObjectBroker::getNewConvergenceTest(int classTag) 00947 { 00948 switch(classTag) { 00949 case CONVERGENCE_TEST_CTestNormUnbalance: 00950 return new CTestNormUnbalance(); 00951 00952 case CONVERGENCE_TEST_CTestNormDispIncr: 00953 return new CTestNormDispIncr(); 00954 00955 case CONVERGENCE_TEST_CTestEnergyIncr: 00956 return new CTestEnergyIncr(); 00957 00958 00959 default: 00960 opserr << "FEM_ObjectBroker::getNewConvergenceTest - "; 00961 opserr << " - no ConvergenceTest type exists for class tag "; 00962 opserr << classTag << endln; 00963 return 0; 00964 00965 } 00966 } 00967 00968 00969 LoadPattern * 00970 FEM_ObjectBroker::getNewLoadPattern(int classTag) 00971 { 00972 switch(classTag) { 00973 case PATTERN_TAG_LoadPattern: 00974 return new LoadPattern(); 00975 00976 case PATTERN_TAG_UniformExcitation: 00977 return new UniformExcitation(); 00978 00979 case PATTERN_TAG_MultiSupportPattern: 00980 return new MultiSupportPattern(); 00981 00982 default: 00983 opserr << "FEM_ObjectBroker::getPtrLoadPattern - "; 00984 opserr << " - no Load type exists for class tag "; 00985 opserr << classTag << endln; 00986 return 0; 00987 00988 } 00989 } 00990 00991 00992 GroundMotion * 00993 FEM_ObjectBroker::getNewGroundMotion(int classTag) 00994 { 00995 switch(classTag) { 00996 00997 case GROUND_MOTION_TAG_GroundMotion: 00998 return new GroundMotion(GROUND_MOTION_TAG_GroundMotion); 00999 01000 case GROUND_MOTION_TAG_InterpolatedGroundMotion: 01001 return new GroundMotion(GROUND_MOTION_TAG_InterpolatedGroundMotion); 01002 01003 default: 01004 opserr << "FEM_ObjectBroker::getPtrGroundMotion - "; 01005 opserr << " - no Load type exists for class tag "; 01006 opserr << classTag << endln; 01007 return 0; 01008 01009 } 01010 } 01011 01012 TimeSeries * 01013 FEM_ObjectBroker::getNewTimeSeries(int classTag) 01014 { 01015 switch(classTag) { 01016 case TSERIES_TAG_LinearSeries: 01017 return new LinearSeries; 01018 01019 case TSERIES_TAG_RectangularSeries: 01020 return new RectangularSeries; 01021 01022 case TSERIES_TAG_PathTimeSeries: 01023 return new PathTimeSeries; 01024 01025 case TSERIES_TAG_PathSeries: 01026 return new PathSeries; 01027 01028 case TSERIES_TAG_ConstantSeries: 01029 return new ConstantSeries; 01030 01031 case TSERIES_TAG_TrigSeries: 01032 return new TrigSeries; 01033 01034 default: 01035 opserr << "FEM_ObjectBroker::getPtrTimeSeries - "; 01036 opserr << " - no Load type exists for class tag "; 01037 opserr << classTag << endln; 01038 return 0; 01039 01040 } 01041 } 01042 01043 TimeSeriesIntegrator * 01044 FEM_ObjectBroker::getNewTimeSeriesIntegrator(int classTag) 01045 { 01046 switch(classTag) { 01047 case TIMESERIES_INTEGRATOR_TAG_Trapezoidal: 01048 return new TrapezoidalTimeSeriesIntegrator(); 01049 01050 default: 01051 opserr << "FEM_ObjectBroker::getPtrTimeSeriesIntegrator - "; 01052 opserr << " - no Load type exists for class tag "; 01053 opserr << classTag << endln; 01054 return 0; 01055 01056 } 01057 } 01058 01059 01060 Matrix * 01061 FEM_ObjectBroker::getPtrNewMatrix(int classTag, int noRows, int noCols) 01062 { 01063 switch(classTag) { 01064 case MATRIX_TAG_Matrix: 01065 return new Matrix(noRows,noCols); 01066 01067 01068 default: 01069 opserr << "FEM_ObjectBroker::getPtrNewMatrix - "; 01070 opserr << " - no NodalLoad type exists for class tag "; 01071 opserr << classTag << endln; 01072 return 0; 01073 01074 } 01075 } 01076 01077 01078 Vector * 01079 FEM_ObjectBroker::getPtrNewVector(int classTag, int size) 01080 { 01081 switch(classTag) { 01082 case VECTOR_TAG_Vector: 01083 return new Vector(size); 01084 01085 01086 default: 01087 opserr << "FEM_ObjectBroker::getPtrNewVector - "; 01088 opserr << " - no Vector type exists for class tag "; 01089 opserr << classTag << endln; 01090 return 0; 01091 01092 } 01093 } 01094 01095 01096 ID * 01097 FEM_ObjectBroker::getPtrNewID(int classTag, int size) 01098 { 01099 switch(classTag) { 01100 case ID_TAG_ID: 01101 return new ID(size); 01102 01103 01104 default: 01105 opserr << "FEM_ObjectBroker::getPtrNewID - "; 01106 opserr << " - no ID type exists for class tag "; 01107 opserr << classTag << endln; 01108 return 0; 01109 01110 } 01111 } 01112 01113 /***************************************** 01114 * 01115 * METHODS TO GET NEW OUTPUT CLASS OBJECTS 01116 * 01117 *****************************************/ 01118 01119 OPS_Stream * 01120 FEM_ObjectBroker::getPtrNewStream(int classTag) 01121 { 01122 switch(classTag) { 01123 case OPS_STREAM_TAGS_StandardStream: 01124 return new StandardStream(); 01125 01126 case OPS_STREAM_TAGS_FileStream: 01127 return new FileStream(); 01128 01129 case OPS_STREAM_TAGS_XmlFileStream: 01130 return new XmlFileStream(); 01131 01132 case OPS_STREAM_TAGS_DataFileStream: 01133 return new DataFileStream(); 01134 01135 case OPS_STREAM_TAGS_DatabaseStream: 01136 return new DatabaseStream(); 01137 01138 01139 01140 default: 01141 opserr << "FEM_ObjectBroker::getPtrNewStream - "; 01142 opserr << " - no DataOutputHandler type exists for class tag "; 01143 opserr << classTag << endln; 01144 return 0; 01145 01146 } 01147 } 01148 01149 Recorder * 01150 FEM_ObjectBroker::getPtrNewRecorder(int classTag) 01151 { 01152 switch(classTag) { 01153 case RECORDER_TAGS_ElementRecorder: 01154 return new ElementRecorder(); 01155 01156 case RECORDER_TAGS_NodeRecorder: 01157 return new NodeRecorder(); 01158 01159 case RECORDER_TAGS_EnvelopeNodeRecorder: 01160 return new EnvelopeNodeRecorder(); 01161 01162 case RECORDER_TAGS_EnvelopeElementRecorder: 01163 return new EnvelopeElementRecorder(); 01164 01165 default: 01166 opserr << "FEM_ObjectBroker::getNewConstraintHandler - "; 01167 opserr << " - no ConstraintHandler type exists for class tag "; 01168 opserr << classTag << endln; 01169 return 0; 01170 01171 } 01172 } 01173 01174 01175 01176 /***************************************** 01177 * 01178 * METHODS TO GET NEW ANALYSIS CLASSES 01179 * 01180 *****************************************/ 01181 01182 ConstraintHandler * 01183 FEM_ObjectBroker::getNewConstraintHandler(int classTag) 01184 { 01185 switch(classTag) { 01186 case HANDLER_TAG_PlainHandler: 01187 return new PlainHandler(); 01188 01189 case HANDLER_TAG_PenaltyConstraintHandler: 01190 return new PenaltyConstraintHandler(1.0e12, 1.0e12); 01191 01192 case HANDLER_TAG_LagrangeConstraintHandler: 01193 return new LagrangeConstraintHandler(1.0, 1.0); 01194 01195 case HANDLER_TAG_TransformationConstraintHandler: 01196 return new TransformationConstraintHandler(); 01197 01198 default: 01199 opserr << "FEM_ObjectBroker::getNewConstraintHandler - "; 01200 opserr << " - no ConstraintHandler type exists for class tag "; 01201 opserr << classTag << endln; 01202 return 0; 01203 01204 } 01205 } 01206 01207 01208 DOF_Numberer * 01209 FEM_ObjectBroker::getNewNumberer(int classTag) 01210 { 01211 switch(classTag) { 01212 case NUMBERER_TAG_DOF_Numberer: 01213 return new DOF_Numberer(); 01214 01215 01216 case NUMBERER_TAG_PlainNumberer: 01217 return new PlainNumberer(); 01218 01219 01220 #ifdef _PARALLEL_PROCESSING 01221 case NUMBERER_TAG_ParallelNumberer: 01222 return new ParallelNumberer(); 01223 #endif 01224 01225 default: 01226 opserr << "FEM_ObjectBroker::getNewConstraintHandler - "; 01227 opserr << " - no ConstraintHandler type exists for class tag "; 01228 opserr << classTag << endln; 01229 return 0; 01230 01231 } 01232 } 01233 01234 01235 AnalysisModel * 01236 FEM_ObjectBroker::getNewAnalysisModel(int classTag) 01237 { 01238 switch(classTag) { 01239 case AnaMODEL_TAGS_AnalysisModel: 01240 return new AnalysisModel(); 01241 01242 01243 default: 01244 opserr << "FEM_ObjectBroker::getNewAnalysisModel - "; 01245 opserr << " - no AnalysisModel type exists for class tag "; 01246 opserr << classTag << endln; 01247 return 0; 01248 01249 } 01250 } 01251 01252 01253 EquiSolnAlgo * 01254 FEM_ObjectBroker::getNewEquiSolnAlgo(int classTag) 01255 { 01256 switch(classTag) { 01257 case EquiALGORITHM_TAGS_Linear: 01258 return new Linear(); 01259 01260 01261 case EquiALGORITHM_TAGS_NewtonRaphson: 01262 return new NewtonRaphson(); 01263 01264 01265 case EquiALGORITHM_TAGS_ModifiedNewton: 01266 return new ModifiedNewton(); 01267 01268 01269 default: 01270 opserr << "FEM_ObjectBroker::getNewEquiSolnAlgo - "; 01271 opserr << " - no EquiSolnAlgo type exists for class tag "; 01272 opserr << classTag << endln; 01273 return 0; 01274 01275 } 01276 } 01277 01278 01279 DomainDecompAlgo * 01280 FEM_ObjectBroker::getNewDomainDecompAlgo(int classTag) 01281 { 01282 switch(classTag) { 01283 case DomDecompALGORITHM_TAGS_DomainDecompAlgo: 01284 return new DomainDecompAlgo(); 01285 01286 default: 01287 opserr << "FEM_ObjectBroker::getNewDomainDecompAlgo - "; 01288 opserr << " - no DomainDecompAlgo type exists for class tag "; 01289 opserr << classTag << endln; 01290 return 0; 01291 01292 } 01293 } 01294 01295 01296 StaticIntegrator * 01297 FEM_ObjectBroker::getNewStaticIntegrator(int classTag) 01298 { 01299 switch(classTag) { 01300 case INTEGRATOR_TAGS_LoadControl: 01301 return new LoadControl(1.0,1,1.0,.10); // must recvSelf 01302 01303 #ifdef _PARALLEL_PROCESSING 01304 case INTEGRATOR_TAGS_DistributedDisplacementControl: 01305 return new DistributedDisplacementControl(); // must recvSelf 01306 #endif 01307 01308 case INTEGRATOR_TAGS_ArcLength: 01309 return new ArcLength(1.0); // must recvSelf 01310 01311 01312 default: 01313 opserr << "FEM_ObjectBroker::getNewStaticIntegrator - "; 01314 opserr << " - no StaticIntegrator type exists for class tag "; 01315 opserr << classTag << endln; 01316 return 0; 01317 01318 } 01319 } 01320 01321 01322 TransientIntegrator * 01323 FEM_ObjectBroker::getNewTransientIntegrator(int classTag) 01324 { 01325 switch(classTag) { 01326 case INTEGRATOR_TAGS_Newmark: 01327 return new Newmark(); 01328 01329 case INTEGRATOR_TAGS_CentralDifferenceNoDamping: 01330 return new CentralDifferenceNoDamping(); // must recvSelf 01331 01332 case INTEGRATOR_TAGS_CentralDifferenceAlternative: 01333 return new CentralDifferenceAlternative(); // must recvSelf 01334 01335 default: 01336 opserr << "FEM_ObjectBroker::getNewTransientIntegrator - "; 01337 opserr << " - no TransientIntegrator type exists for class tag "; 01338 opserr << classTag << endln; 01339 return 0; 01340 01341 } 01342 } 01343 01344 01345 IncrementalIntegrator * 01346 FEM_ObjectBroker::getNewIncrementalIntegrator(int classTag) 01347 { 01348 switch(classTag) { 01349 case INTEGRATOR_TAGS_LoadControl: 01350 return new LoadControl(1.0,1,1.0,1.0); // must recvSelf 01351 01352 01353 case INTEGRATOR_TAGS_ArcLength: 01354 return new ArcLength(1.0); // must recvSelf 01355 01356 01357 case INTEGRATOR_TAGS_Newmark: 01358 return new Newmark(); 01359 01360 #ifdef _PARALLEL_PROCESSING 01361 case INTEGRATOR_TAGS_DistributedDisplacementControl: 01362 return new DistributedDisplacementControl(); // must recvSelf 01363 #endif 01364 01365 default: 01366 opserr << "FEM_ObjectBroker::getNewIncrementalIntegrator - "; 01367 opserr << " - no IncrementalIntegrator type exists for class tag "; 01368 opserr << classTag << endln; 01369 return 0; 01370 01371 } 01372 } 01373 01374 01375 LinearSOESolver * 01376 FEM_ObjectBroker::getNewLinearSolver(void) 01377 { 01378 return lastLinearSolver; 01379 } 01380 01381 LinearSOE * 01382 FEM_ObjectBroker::getNewLinearSOE(int classTagSOE, 01383 int classTagSolver) 01384 { 01385 LinearSOE *theSOE =0; 01386 // SlowLinearSOESolver *theSlowSolver =0; 01387 FullGenLinSolver *theGenSolver =0; 01388 BandGenLinSolver *theGenBandSolver =0; 01389 BandSPDLinSolver *theBandSPDSolver =0; 01390 ProfileSPDLinSolver *theProfileSPDSolver =0; 01391 SuperLU *theSparseGenLinSolver =0; 01392 01393 #ifdef _PETSC 01394 PetscSolver *thePetscSolver = 0; 01395 #endif 01396 01397 #ifdef _PARALLEL_PROCESSING 01398 DistributedSuperLU *theDistributedSparseGenLinSolver =0; 01399 DistributedDiagonalSolver *theDistributedDiagonalSolver =0; 01400 #ifdef _MUMPS 01401 MumpsParallelSolver *theMumpsSolver = 0; 01402 #endif 01403 #endif 01404 01405 /* 01406 case LinSOE_TAGS_SlowLinearSOE: 01407 if (classTagSolver == SOLVER_TAGS_SlowLinearSOESolver) { 01408 theSlowSolver = new SlowLinearSOESolver(); 01409 theSOE = new SlowLinearSOE(*theSlowSolver); 01410 lastLinearSolver = theSlowSolver; 01411 return theSOE; 01412 } else { 01413 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01414 opserr << " - no SlowLinearSOESolver type exists for class tag "; 01415 opserr << classTagSolver << endln; 01416 return 0; 01417 } 01418 01419 */ 01420 01421 01422 switch(classTagSOE) { 01423 case LinSOE_TAGS_FullGenLinSOE: 01424 01425 if (classTagSolver == SOLVER_TAGS_FullGenLinLapackSolver) { 01426 theGenSolver = new FullGenLinLapackSolver(); 01427 theSOE = new FullGenLinSOE(*theGenSolver); 01428 lastLinearSolver = theGenSolver; 01429 return theSOE; 01430 } else { 01431 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01432 opserr << " - no FullGenLinSOESolver type exists for class tag "; 01433 opserr << classTagSolver << endln; 01434 return 0; 01435 } 01436 01437 01438 case LinSOE_TAGS_BandGenLinSOE: 01439 01440 if (classTagSolver == SOLVER_TAGS_BandGenLinLapackSolver) { 01441 theGenBandSolver = new BandGenLinLapackSolver(); 01442 theSOE = new BandGenLinSOE(*theGenBandSolver); 01443 lastLinearSolver = theGenBandSolver; 01444 return theSOE; 01445 } else { 01446 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01447 opserr << " - no BandGenLinSolver type exists for class tag "; 01448 opserr << classTagSolver << endln; 01449 return 0; 01450 } 01451 01452 case LinSOE_TAGS_BandSPDLinSOE: 01453 01454 if (classTagSolver == SOLVER_TAGS_BandSPDLinLapackSolver) { 01455 theBandSPDSolver = new BandSPDLinLapackSolver(); 01456 theSOE = new BandSPDLinSOE(*theBandSPDSolver); 01457 lastLinearSolver = theBandSPDSolver; 01458 return theSOE; 01459 } else { 01460 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01461 opserr << " - no BandSPDLinSOESolver type exists for class tag "; 01462 opserr << classTagSolver << endln; 01463 return 0; 01464 } 01465 01466 case LinSOE_TAGS_ProfileSPDLinSOE: 01467 01468 if (classTagSolver == SOLVER_TAGS_ProfileSPDLinDirectSolver) { 01469 theProfileSPDSolver = new ProfileSPDLinDirectSolver(); 01470 theSOE = new ProfileSPDLinSOE(*theProfileSPDSolver); 01471 lastLinearSolver = theProfileSPDSolver; 01472 return theSOE; 01473 } else if (classTagSolver == SOLVER_TAGS_ProfileSPDLinSubstrSolver) { 01474 theProfileSPDSolver = new ProfileSPDLinSubstrSolver(); 01475 theSOE = new ProfileSPDLinSOE(*theProfileSPDSolver); 01476 lastLinearSolver = theProfileSPDSolver; 01477 return 0; 01478 } 01479 else { 01480 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01481 opserr << " - no ProfileSPD_LinSolver type exists for class tag "; 01482 opserr << classTagSolver << endln; 01483 return 0; 01484 } 01485 01486 01487 #ifdef _PETSC 01488 case LinSOE_TAGS_PetscSOE: 01489 01490 if (classTagSolver == SOLVER_TAGS_PetscSolver) { 01491 thePetscSolver = new PetscSolver(); 01492 theSOE = new PetscSOE(*thePetscSolver); 01493 return theSOE; 01494 } else { 01495 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01496 opserr << " - no PetscSolver type exists for class tag "; 01497 opserr << classTagSolver << endln; 01498 return 0; 01499 } 01500 #endif 01501 01502 #ifdef _PARALLEL_PROCESSING 01503 01504 #ifdef _MUMPS 01505 case LinSOE_TAGS_MumpsParallelSOE: 01506 if (classTagSolver == SOLVER_TAGS_MumpsParallelSolver) { 01507 theMumpsSolver = new MumpsParallelSolver(); 01508 theSOE = new MumpsParallelSOE(*theMumpsSolver); 01509 lastLinearSolver = theMumpsSolver; 01510 return theSOE; 01511 } else { 01512 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01513 opserr << " - no DistributedBandGenLinSolver type exists for class tag "; 01514 opserr << classTagSolver << endln; 01515 return 0; 01516 } 01517 #endif 01518 01519 case LinSOE_TAGS_DistributedBandGenLinSOE: 01520 01521 if (classTagSolver == SOLVER_TAGS_BandGenLinLapackSolver) { 01522 theGenBandSolver = new BandGenLinLapackSolver(); 01523 theSOE = new DistributedBandGenLinSOE(*theGenBandSolver); 01524 lastLinearSolver = theGenBandSolver; 01525 return theSOE; 01526 } else { 01527 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01528 opserr << " - no DistributedBandGenLinSolver type exists for class tag "; 01529 opserr << classTagSolver << endln; 01530 return 0; 01531 } 01532 01533 case LinSOE_TAGS_DistributedBandSPDLinSOE: 01534 01535 if (classTagSolver == SOLVER_TAGS_BandSPDLinLapackSolver) { 01536 theBandSPDSolver = new BandSPDLinLapackSolver(); 01537 theSOE = new DistributedBandSPDLinSOE(*theBandSPDSolver); 01538 lastLinearSolver = theBandSPDSolver; 01539 return theSOE; 01540 } else { 01541 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01542 opserr << " - no DistributedBandSPDLinSolver type exists for class tag "; 01543 opserr << classTagSolver << endln; 01544 return 0; 01545 } 01546 01547 01548 case LinSOE_TAGS_DistributedProfileSPDLinSOE: 01549 01550 if (classTagSolver == SOLVER_TAGS_ProfileSPDLinDirectSolver) { 01551 theProfileSPDSolver = new ProfileSPDLinDirectSolver(); 01552 theSOE = new DistributedProfileSPDLinSOE(*theProfileSPDSolver); 01553 lastLinearSolver = theProfileSPDSolver; 01554 return theSOE; 01555 } else if (classTagSolver == SOLVER_TAGS_ProfileSPDLinSubstrSolver) { 01556 theProfileSPDSolver = new ProfileSPDLinSubstrSolver(); 01557 theSOE = new DistributedProfileSPDLinSOE(*theProfileSPDSolver); 01558 lastLinearSolver = theProfileSPDSolver; 01559 return 0; 01560 } 01561 else { 01562 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01563 opserr << " - no ProfileSPD_LinSolver type exists for class tag "; 01564 opserr << classTagSolver << endln; 01565 return 0; 01566 } 01567 01568 case LinSOE_TAGS_DistributedDiagonalSOE: 01569 01570 if (classTagSolver == SOLVER_TAGS_DistributedDiagonalSolver) { 01571 theDistributedDiagonalSolver = new DistributedDiagonalSolver(); 01572 theSOE = new DistributedDiagonalSOE(*theDistributedDiagonalSolver); 01573 lastLinearSolver = theDistributedDiagonalSolver; 01574 return theSOE; 01575 } else { 01576 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01577 opserr << " - no DistributedSparseGenLinSolverSolver type exists for class tag "; 01578 opserr << classTagSolver << endln; 01579 return 0; 01580 } 01581 01582 case LinSOE_TAGS_DistributedSparseGenColLinSOE: 01583 01584 if (classTagSolver == SOLVER_TAGS_SuperLU) { 01585 theSparseGenLinSolver = new SuperLU(); 01586 theSOE = new DistributedSparseGenColLinSOE(*theSparseGenLinSolver); 01587 lastLinearSolver = theSparseGenLinSolver; 01588 return theSOE; 01589 } else if (classTagSolver == SOLVER_TAGS_DistributedSuperLU) { 01590 theDistributedSparseGenLinSolver = new DistributedSuperLU(); 01591 theSOE = new DistributedSparseGenColLinSOE(*theDistributedSparseGenLinSolver); 01592 lastLinearSolver = theSparseGenLinSolver; 01593 return theSOE; 01594 } else { 01595 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01596 opserr << " - no DistributedSparseGenLinSolverSolver type exists for class tag "; 01597 opserr << classTagSolver << endln; 01598 return 0; 01599 } 01600 01601 #else 01602 case LinSOE_TAGS_SparseGenColLinSOE: 01603 01604 if (classTagSolver == SOLVER_TAGS_SuperLU) { 01605 theSparseGenLinSolver = new SuperLU(); 01606 theSOE = new SparseGenColLinSOE(*theSparseGenLinSolver); 01607 lastLinearSolver = theSparseGenLinSolver; 01608 return theSOE; 01609 } else { 01610 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01611 opserr << " - no SparseGenLinSolverSolver type exists for class tag "; 01612 opserr << classTagSolver << endln; 01613 return 0; 01614 } 01615 01616 #endif 01617 01618 default: 01619 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01620 opserr << " - no LinearSOE type exists for class tag "; 01621 opserr << classTagSOE << endln; 01622 return 0; 01623 01624 01625 } 01626 } 01627 01628 01629 01630 01631 DomainSolver * 01632 FEM_ObjectBroker::getNewDomainSolver(void) 01633 { 01634 return lastDomainSolver; 01635 } 01636 01637 LinearSOE * 01638 FEM_ObjectBroker::getPtrNewDDLinearSOE(int classTagSOE, 01639 int classTagDDSolver) 01640 { 01641 ProfileSPDLinSubstrSolver *theProfileSPDSolver =0; 01642 01643 switch(classTagSOE) { 01644 case LinSOE_TAGS_ProfileSPDLinSOE: 01645 01646 if (classTagDDSolver == SOLVER_TAGS_ProfileSPDLinSubstrSolver) { 01647 theProfileSPDSolver = new ProfileSPDLinSubstrSolver(); 01648 LinearSOE *theSOE = new ProfileSPDLinSOE(*theProfileSPDSolver); 01649 lastDomainSolver = theProfileSPDSolver; 01650 return theSOE; 01651 } 01652 else { 01653 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01654 opserr << " - no ProfileSPD Domain Solver type exists for class tag "; 01655 opserr << classTagDDSolver << endln; 01656 return 0; 01657 } 01658 01659 01660 default: 01661 opserr << "FEM_ObjectBroker::getNewLinearSOE - "; 01662 opserr << " - no LinearSOE type exists for class tag "; 01663 opserr << classTagSOE << endln; 01664 return 0; 01665 01666 } 01667 } 01668 01669 01670 DomainDecompositionAnalysis * 01671 FEM_ObjectBroker::getNewDomainDecompAnalysis(int classTag, 01672 Subdomain &theSubdomain) 01673 { 01674 switch(classTag) { 01675 case DomDecompANALYSIS_TAGS_DomainDecompositionAnalysis: 01676 return new DomainDecompositionAnalysis(theSubdomain); 01677 01678 #ifdef _PARALLEL_PROCESSING 01679 case ANALYSIS_TAGS_StaticDomainDecompositionAnalysis: 01680 return new StaticDomainDecompositionAnalysis(theSubdomain); 01681 01682 case ANALYSIS_TAGS_TransientDomainDecompositionAnalysis: 01683 return new TransientDomainDecompositionAnalysis(theSubdomain); 01684 #endif 01685 01686 default: 01687 opserr << "ObjectBroker::getNewDomainDecompAnalysis "; 01688 opserr << " - no DomainDecompAnalysis type exists for class tag " ; 01689 opserr << classTag << endln; 01690 return 0; 01691 01692 } 01693 } 01694 01695 01696 Subdomain * 01697 FEM_ObjectBroker::getSubdomainPtr(int classTag) 01698 { 01699 opserr << "FEM_ObjectBroker: NOT IMPLEMENTED YET"; 01700 return 0; 01701 } 01702 01703 01704 int 01705 FEM_ObjectBroker::addUniaxialMaterial(int classTag, 01706 const char *lib, 01707 const char *funcName, 01708 UniaxialMaterial *(*funcPtr)(void)) 01709 { 01710 // check to see if it's already added 01711 01712 UniaxialPackage *matCommands = theUniaxialPackage; 01713 bool found = false; 01714 while (matCommands != NULL && found == false) { 01715 if ((strcmp(lib, matCommands->libName) == 0) && (strcmp(funcName, matCommands->funcName) == 0)) { 01716 return 0; 01717 } 01718 } 01719 01720 // 01721 // if funPtr == 0; go get the handle 01722 // 01723 01724 void *libHandle; 01725 if (funcPtr == 0) { 01726 if (getLibraryFunction(lib, funcName, &libHandle, (void **)&funcPtr) != 0) { 01727 opserr << "FEM_ObjectBroker::addUniaxialMaterial - could not find function\n"; 01728 return -1; 01729 } 01730 } 01731 01732 // 01733 // add the new funcPtr 01734 // 01735 01736 char *libNameCopy = new char[strlen(lib)+1]; 01737 char *funcNameCopy = new char[strlen(funcName)+1]; 01738 UniaxialPackage *theMat = new UniaxialPackage; 01739 if (libNameCopy == 0 || funcNameCopy == 0 || theMat == 0) { 01740 opserr << "FEM_ObjectBroker::addUniaxialMaterial - could not add lib, out of memory\n"; 01741 return -1; 01742 } 01743 strcpy(libNameCopy, lib); 01744 strcpy(funcNameCopy, funcName); 01745 01746 theMat->classTag = classTag; 01747 theMat->funcName = funcNameCopy; 01748 theMat->libName = libNameCopy; 01749 theMat->funcPtr = funcPtr; 01750 theMat->next = theUniaxialPackage; 01751 theUniaxialPackage = theMat; 01752 01753 return 0; 01754 01755 }
Generated on Mon Oct 23 15:04:56 2006 for OpenSees by |
opensees-support @ berkeley.edu
Supported by the National Science Foundation
©2006, UC Regents