void* OPS_CTestNormDispIncr()
{
if(OPS_GetNumRemainingInputArgs() < 2) {
opserr<<"insufficient number of arguments\n";
return 0;
}
// tolerance
double tol = 1e-6;
int numData = 1;
if(OPS_GetDoubleInput(&numData,&tol) < 0) return 0;
// maxIter
numData = OPS_GetNumRemainingInputArgs();
if(numData > 3) numData = 3;
int data[3] = {0,0,2};
if(OPS_GetIntInput(&numData,&data[0]) < 0) return 0;
// maxTol
double maxTol = OPS_MAXTOL;
if(OPS_GetNumRemainingInputArgs() > 0) {
numData = 1;
if(OPS_GetDoubleInput(&numData,&maxTol) < 0) return 0;
}
// create test
return new CTestNormDispIncr(tol,data[0],data[1],data[2],maxTol);
}
void* OPS_PDeltaCrdTransf2d()
{
if(OPS_GetNumRemainingInputArgs() < 1) {
opserr<<"insufficient arguments for PDeltaCrdTransf2d\n";
return 0;
}
// get tag
int tag;
int numData = 1;
if(OPS_GetIntInput(&numData,&tag) < 0) return 0;
// get option
Vector jntOffsetI(2), jntOffsetJ(2);
double *iptr=&jntOffsetI(0), *jptr=&jntOffsetJ(0);
while(OPS_GetNumRemainingInputArgs() > 4) {
std::string type = OPS_GetString();
if(type == "-jntOffset") {
numData = 2;
if(OPS_GetDoubleInput(&numData,iptr) < 0) return 0;
if(OPS_GetDoubleInput(&numData,jptr) < 0) return 0;
}
}
return new PDeltaCrdTransf2d(tag,jntOffsetI,jntOffsetJ);
}
void* OPS_ElasticBeam2d()
{
if(OPS_GetNumRemainingInputArgs() < 7) {
opserr<<"insufficient arguments:eleTag,iNode,jNode,A,E,Iz,transfTag\n";
return 0;
}
int ndm = OPS_GetNDM();
int ndf = OPS_GetNDF();
if(ndm != 2 || ndf != 3) {
opserr<<"ndm must be 2 and ndf must be 3\n";
return 0;
}
// inputs:
int iData[3];
int numData = 3;
if(OPS_GetIntInput(&numData,&iData[0]) < 0) return 0;
double data[3];
if(OPS_GetDoubleInput(&numData,&data[0]) < 0) return 0;
numData = 1;
int transfTag;
if(OPS_GetIntInput(&numData,&transfTag) < 0) return 0;
// options
double mass = 0.0, alpha=0.0, depth=0.0;
int cMass = 0;
while(OPS_GetNumRemainingInputArgs() > 0) {
std::string type = OPS_GetString();
if(type == "-alpha") {
if(OPS_GetNumRemainingInputArgs() > 0) {
if(OPS_GetDoubleInput(&numData,&alpha) < 0) return 0;
}
} else if(type == "-depth") {
if(OPS_GetNumRemainingInputArgs() > 0) {
if(OPS_GetDoubleInput(&numData,&depth) < 0) return 0;
}
} else if(type == "-mass") {
if(OPS_GetNumRemainingInputArgs() > 0) {
if(OPS_GetDoubleInput(&numData,&mass) < 0) return 0;
}
} else if(type == "-cMass") {
cMass = 1;
}
}
// check transf
CrdTransf* theTransf = OPS_GetCrdTransf(transfTag);
if(theTransf == 0) {
opserr<<"coord transfomration not found\n";
return 0;
}
return new ElasticBeam2d(iData[0],data[0],data[1],data[2],iData[1],iData[2],
*theTransf,alpha,depth,mass,cMass);
}
void* OPS_UniformExcitationPattern()
{
TimeSeries* accelSeries = 0;
TimeSeries* velSeries = 0;
TimeSeries* dispSeries = 0;
TimeSeriesIntegrator* seriesIntegrator = 0;
double fact = 1.0;
double vel0 = 0.0;
int iData[2];
if(OPS_GetNumRemainingInputArgs() < 2) {
opserr<<"insufficient number of args\n";
return 0;
}
// get tag and direction
int numData = 2;
if(OPS_GetIntInput(&numData,&iData[0]) < 0) return 0;
iData[1]--; // subtract 1 for c indexing
// get options
numData = 1;
while(OPS_GetNumRemainingInputArgs() > 1) {
std::string type = OPS_GetString();
if(type == "-accel"||type == "-acceleration") {
int tstag;
if(OPS_GetIntInput(&numData,&tstag) < 0) return 0;
accelSeries = OPS_getTimeSeries(tstag);
} else if(type == "-vel"||type == "-velocity") {
int tstag;
if(OPS_GetIntInput(&numData,&tstag) < 0) return 0;
velSeries = OPS_getTimeSeries(tstag);
} else if(type == "-disp"||type == "-displacement") {
int tstag;
if(OPS_GetIntInput(&numData,&tstag) < 0) return 0;
dispSeries = OPS_getTimeSeries(tstag);
} else if(type == "-fact"||type == "-factor") {
if(OPS_GetDoubleInput(&numData,&fact) < 0) return 0;
} else if(type == "-vel0"||type == "-initialVel") {
if(OPS_GetDoubleInput(&numData,&vel0) < 0) return 0;
}
}
// create groundmotion
if(accelSeries==0&&dispSeries==0&&velSeries==0) {
opserr<<"no time series is specified\n";
return 0;
}
GroundMotion* theMotion = new GroundMotion(dispSeries,velSeries,accelSeries,seriesIntegrator);
if(theMotion == 0) {
opserr << "WARNING ran out of memory creating ground motion - pattern UniformExcitation\n";
return 0;
}
//
return new UniformExcitation(*theMotion,iData[1],iData[0],vel0,fact);
}
void *
OPS_ElasticMaterial(void)
{
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
if (OPS_GetNumRemainingInputArgs() < 2) {
opserr << "Invalid #args, want: uniaxialMaterial Elastic tag? E? <eta?> <Eneg?> ... " << endln;
return 0;
}
int iData[1];
double dData[3];
int numData = 1;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid tag for uniaxialMaterial Elastic" << endln;
return 0;
}
numData = OPS_GetNumRemainingInputArgs();
if (numData >= 3) {
numData = 3;
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "Invalid data for uniaxial Elastic " << iData[0] << endln;
return 0;
}
} else if (numData >= 2) {
numData = 2;
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "Invalid data for uniaxial Elastic " << iData[0] << endln;
return 0;
}
dData[2] = dData[0];
} else {
numData = 1;
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "Invalid data for uniaxialMaterial Elastic " << iData[0] << endln;
return 0;
}
dData[1] = 0.0;
dData[2] = dData[0];
}
// Parsing was successful, allocate the material
theMaterial = new ElasticMaterial(iData[0], dData[0], dData[1], dData[2]);
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type ElasticMaterial\n";
return 0;
}
return theMaterial;
}
void* OPS_NDFiber2d()
{
if(OPS_GetNumRemainingInputArgs() < 4) {
opserr<<"insufficient arguments for NDFiber2d\n";
return 0;
}
// get data
int numData = 3;
double data[3];
if(OPS_GetDoubleInput(&numData,&data[0]) < 0) return 0;
// get mat tag
int tag;
numData = 1;
if(OPS_GetIntInput(&numData,&tag) < 0) return 0;
// get material
NDMaterial* theMat = OPS_getNDMaterial(tag);
if(theMat == 0) {
opserr<<"invalid NDMaterial tag\n";
return 0;
}
return new NDFiber2d(numNDFiber2d++,*theMat,data[2],data[0]);
}
int OPS_setStrain()
{
if (OPS_GetNumRemainingInputArgs() != 1) {
opserr<<"testUniaxialMaterial - You must provide a strain value.\n";
return -1;
}
UniaxialMaterial* material = theTestingUniaxialMaterial;
if (material == 0) {
opserr<<"setStrain WARNING no active UniaxialMaterial - use testUniaxialMaterial command.\n";
return -1;
}
double strain;
int numData = 1;
if (OPS_GetDoubleInput(&numData, &strain) < 0) {
opserr<<"invalid double value\n";
return -1;
}
material->setTrialStrain(strain);
material->commitState();
return 0;
}
void* OPS_ElasticMembranePlateSection()
{
if (OPS_GetNumRemainingInputArgs() < 4) {
opserr << "WARNING insufficient arguments\n";
opserr << "Want: section ElasticMembranePlateSection tag? E? nu? h? <rho?>\n";
return 0;
}
int tag;
int numdata = 1;
if (OPS_GetIntInput(&numdata, &tag) < 0) {
opserr << "WARNING invalid tag\n";
return 0;
}
double data[4] = {0,0,0,0.0};
numdata = OPS_GetNumRemainingInputArgs();
if (numdata > 4) numdata = 4;
if (OPS_GetDoubleInput(&numdata, data) < 0) {
opserr << "WARNING invalid double values\n";
return 0;
}
return new ElasticMembranePlateSection(tag,data[0],data[1],data[2],data[3]);
}
void* OPS_InterpolatedGroundMotion(MultiSupportPattern& thePattern)
{
int numArgs = OPS_GetNumRemainingInputArgs();
int numMotions = (numArgs-1)/2;
GroundMotion* motions[numMotions];
// get ground motion tags
int gmTags[numMotions];
if(OPS_GetIntInput(&numMotions,&gmTags[0]) < 0) return 0;
// get factors
Vector facts(numMotions);
double* fact_ptr = &facts(0);
std::string type = OPS_GetString();
if(type == "-fact") {
if(OPS_GetDoubleInput(&numMotions,fact_ptr) < 0) return 0;
}
// get ground motions
for(int i=0; i<numMotions; i++) {
motions[i] = thePattern.getMotion(gmTags[i]);
if(motions[i] == 0) {
opserr<<"ground motion "<<gmTags[i]<<" is not found\n";
return 0;
}
}
return new InterpolatedGroundMotion(motions,facts,false);
}
void* OPS_ElasticWarpingShearSection2d()
{
if (OPS_GetNumRemainingInputArgs() < 9) {
opserr << "WARNING insufficient arguments\n";
opserr << "Want: section ElasticWarpingShear tag? E? A? Iz? G? alpha? J? B? C?>" << endln;
return 0;
}
int tag;
int numdata = 1;
if (OPS_GetIntInput(&numdata, &tag) < 0) {
opserr << "WARNING invalid section ElasticWarpingShearSection2d tag" << endln;
return 0;
}
numdata = 8;
double data[8];
if (OPS_GetDoubleInput(&numdata, data) < 0) {
opserr << "WARNING invalid double inputs" << endln;
opserr << "ElasticWarpingShearSection2d section: " << tag << endln;
return 0;
}
double E = data[0];
double A = data[1];
double Iz = data[2];
double G = data[3];
double alpha = data[4];
double J = data[5];
double B = data[6];
double C = data[7];
return new ElasticWarpingShearSection2d(tag, E, A, Iz, G, alpha, J, B, C);
}
void* OPS_ElasticPlateSection()
{
if (OPS_GetNumRemainingInputArgs() < 4) {
opserr << "WARNING insufficient arguments\n";
opserr << "Want: section ElasticPlateSection tag? E? nu? h? " << endln;
return 0;
}
int tag;
int numdata = 1;
if (OPS_GetIntInput(&numdata, &tag) < 0) {
opserr << "WARNING invalid section ElasticPlateSection tag" << endln;
return 0;
}
numdata = 3;
double data[3];
if (OPS_GetDoubleInput(&numdata, data) < 0) {
opserr << "WARNING invalid section ElasticPlateSection double inputs" << endln;
return 0;
}
double E = data[0];
double nu = data[1];
double h = data[2];
return new ElasticPlateSection (tag, E, nu, h);
}
void* OPS_CTestRelativeNormUnbalance()
{
if(OPS_GetNumRemainingInputArgs() < 2) {
opserr<<"insufficient number of arguments\n";
return 0;
}
// tolerance
double tol = 1e-6;
int numData = 1;
if(OPS_GetDoubleInput(&numData,&tol) < 0) {
opserr << "WARNING NormUnbalance failed to read tol\n";
return 0;
}
// maxIter
numData = OPS_GetNumRemainingInputArgs();
if(numData > 3) numData = 3;
int data[3] = {0,0,2};
if(OPS_GetIntInput(&numData,&data[0]) < 0) {
opserr << "WARNING NormUnbalance failed to read int values\n";
return 0;
}
// create test
return new CTestRelativeNormUnbalance(tol,data[0],data[1],data[2]);
}
OPS_Export void *
OPS_NewTendonL01Material(void)
{
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
int numRemainingArgs = OPS_GetNumRemainingInputArgs();
if (numRemainingArgs < 6) {
opserr << "Invalid Args want: uniaxialMaterial TendonL01 tag? fpy? Eps? fpu? rou? epsp? <ac?> <rc?>" << endln;
return 0;
}
int iData[1];
double dData[7];
int numData = 1;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid uniaxialMaterial TendonL01 tag" << endln;
return 0;
}
numRemainingArgs = OPS_GetNumRemainingInputArgs();
if (numRemainingArgs == 5) {
if (OPS_GetDoubleInput(&numRemainingArgs, dData) != 0) {
opserr << "Invalid Args want: uniaxialMaterial TendonL01 tag? fpy? Eps? fpu? rou? epsp? <ac?> <rc?>" << endln;
return 0;
} else
theMaterial = new TendonL01(iData[0], dData[0], dData[1], dData[2], dData[3], dData[4]);
} else if (numRemainingArgs == 7) {
if (OPS_GetDoubleInput(&numRemainingArgs, dData) != 0) {
opserr << "Invalid Args want: uniaxialMaterial TendonL01 tag? fpy? Eps? fpu? rou? epsp? <ac?> <rc?>" << endln;
return 0;
} else
theMaterial = new TendonL01(iData[0], dData[0], dData[1], dData[2], dData[3], dData[4], dData[5], dData[6]);
} else {
opserr << "Invalid Args want: uniaxialMaterial TendonL01 tag? fpy? Eps? fpu? rou? epsp? <ac?> <rc?>" << endln;
return 0;
}
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type TendonL01\n";
return 0;
}
return theMaterial;
}
OPS_Export void *
OPS_NewSteelZ02Material(void)
{
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
int numRemainingArgs = OPS_GetNumRemainingInputArgs();
if (numRemainingArgs < 5) {
opserr << "Invalid Args want: uniaxialMaterial SteelZ02 tag? fy? E0? fpc? rou? <ac?> <rc?>" << endln;
return 0;
}
int iData[1];
double dData[6];
int numData = 1;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid uniaxialMaterial SteelZ02 tag" << endln;
return 0;
}
numRemainingArgs = OPS_GetNumRemainingInputArgs();
if (numRemainingArgs == 4) {
if (OPS_GetDoubleInput(&numRemainingArgs, dData) != 0) {
opserr << "Invalid Args want: uniaxialMaterial SteelZ02 tag? fy? E0? fpc? rou? <ac?> <rc?>" << endln;
return 0;
} else
theMaterial = new SteelZ02(iData[0], dData[0], dData[1], dData[2], dData[3]);
} else if (numRemainingArgs == 6) {
if (OPS_GetDoubleInput(&numRemainingArgs, dData) != 0) {
opserr << "Invalid Args want: uniaxialMaterial SteelZ02 tag? fy? E0? fpc? rou? <ac?> <rc?>" << endln;
return 0;
} else
theMaterial = new SteelZ02(iData[0], dData[0], dData[1], dData[2], dData[3], dData[4], dData[5]);
} else {
return 0;
}
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type SteelZ02\n";
return 0;
}
return theMaterial;
}
void *
OPS_Quad4FiberOverlay(void)
{
if (num_Quad4FiberOverlay == 0) {
num_Quad4FiberOverlay++;
OPS_Error("Quad4FiberOverlay element - Written: M.Chiaramonte, P.Arduino, P.Mackenzie-Helnwein, U.Washington\n", 1);
}
Element *theElement = 0;
if (OPS_GetNumRemainingInputArgs() != 9) {
opserr << "Want: Quad4FiberOverlay ?tag ?nd1 ?nd2 ?nd3 ?nd4 ?matTag ?AreaFiber B1 B2 \n";
return 0;
}
int iData[6];
double dData[3];
int matTag = 0;
int eleTag = 0;
int numData = 0;
numData = 5;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid integer data: element Quad4FiberOverlay" << endln;
return 0;
}
eleTag = iData[0];
numData = 1;
if (OPS_GetIntInput(&numData, &matTag) != 0) {
opserr << "WARNING element Quad4FiberOverlay: invalid matTag for element: " << eleTag << "\n";
return 0;
}
numData = 3;
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "WARNING invalid data: element Quad4FiberOverlay " << eleTag << endln;
return 0;
}
UniaxialMaterial *theMaterial = OPS_GetUniaxialMaterial(matTag);
if (theMaterial == 0) {
opserr << "WARNING material with tag " << matTag << "not found for element " << eleTag << endln;
return 0;
}
// Parsing was successful, allocate the material
theElement = new Quad4FiberOverlay(iData[0], iData[1], iData[2], iData[3], iData[4], *theMaterial, dData[0], dData[1], dData[2]);
if (theElement == 0) {
opserr << "WARNING could not create element of type Quad4FiberOverlay\n";
return 0;
}
return theElement;
opserr << "Element Passed First Inspection" << endln;
}
void* OPS_PressureDependentElastic3D()
{
int argc = OPS_GetNumRemainingInputArgs() + 2;
if (argc < 6) {
opserr << "WARNING insufficient arguments\n";
opserr << "Want: nDMaterial PressureDependentElastic3D tag? E? v? rho?\n";
return 0;
}
int tag = 0;
int numdata = 1;
if (OPS_GetIntInput(&numdata, &tag) < 0) {
opserr << "WARNING invalid PressureDependentElastic3D tag\n";
return 0;
}
// double E = 0.0;
// double v = 0.0;
// double rho = 0.0;
// double expp = 0.0;
// double prp = 0.0;
// double pop = 0.0;
double data[6] = {0,0,0,0,0,0};
numdata = OPS_GetNumRemainingInputArgs();
if (numdata > 6) numdata = 6;
if (OPS_GetDoubleInput(&numdata, data) < 0) {
opserr << "WARNING invalid PressureDependentElastic3D double inputs\n";
return 0;
}
//////////////////////////////////////////////////////////////////////////////////
if( argc == 6 )
{
return new PressureDependentElastic3D (tag, data[0], data[1], data[2]);
//opserr << "nDMaterial PressureDependentElastic3D: expp =" << expp << endln;
}
//////////////////////////////////////////////////////////////////////////////////
else if( argc == 7 )
{
return new PressureDependentElastic3D (tag, data[0], data[1], data[2], data[3]);
//opserr << "nDMaterial PressureDependentElastic3D: expp =" << expp << endln;
}
//////////////////////////////////////////////////////////////////////////////////
else if (argc == 8 )
{
return new PressureDependentElastic3D (tag, data[0], data[1], data[2], data[3],
data[4]);
}
//////////////////////////////////////////////////////////////////////////////////
else if (argc >= 9 )
{
return new PressureDependentElastic3D (tag, data[0], data[1], data[2], data[3],
data[4], data[5]);
}
return 0;
}
void *
OPS_TPB1D()
{
// print out a message about who wrote this element & any copyright info wanted
if (numMyTPB1D == 0) {
opserr << "TPB1D2D element - Written by Troy/Fenz UC Berkeley Copyright 2011 - Use at your Own Peril\n";
numMyTPB1D++;
}
Element *theEle = 0;
int numRemainingArgs = OPS_GetNumRemainingInputArgs();
if (numRemainingArgs == 0) { // parallel processing
theEle = new TPB1D();
return theEle;
}
if (numRemainingArgs != 20) {
opserr << "ERROR - TPB1D2D not enough args provided, want: element TPB1D2D tag? iNode? jNode? direction? mu1? mu2? mu3? R1? R2? R3? h1? h2? h3? D1? D2? D3? d1? d2? d3? W?\n";
numMyTPB1D++;
}
// get the id and end nodes
int iData[4];
double dData[16];
int numData;
numData = 4;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid element data\n";
return 0;
}
int eleTag = iData[0];
numData = 16;
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "WARNING error reading element area for element" << eleTag << endln;
return 0;
}
// now create the truss and add it to the Domain
theEle = new TPB1D(eleTag, iData[1], iData[2], iData[3]-1,
&dData[0],
&dData[3],
&dData[6],
&dData[9],
&dData[12],
dData[15]);
if (theEle == 0) {
opserr << "WARNING ran out of memory creating element type TPB1D with tag " << eleTag << endln;
return 0;
}
return theEle;
}
OPS_Export void *
OPS_BeamEndContact3D(void)
{
if (num_BeamEndContact3D == 0) {
num_BeamEndContact3D++;
opserr<<"BeamEndContact3D element - Written: C.McGann, P.Arduino, P.Mackenzie-Helnwein, U.Washington\n";
}
// Pointer to an element that will be returned
Element *theElement = 0;
int numRemainingInputArgs = OPS_GetNumRemainingInputArgs();
if (numRemainingInputArgs < 8) {
opserr << "Invalid #args, want: element BeamEndContact3D eleTag? iNode? jNode? slaveNode? lambdaNode? radius? gapTol? forceTol <cFlag>?\n";
return 0;
}
int iData[5];
double dData[3];
int icSwitch = 0;
int numData = 5;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid integer data: element BeamEndContact3D " << iData[0] << endln;
return 0;
}
numData = 3;
if (OPS_GetDoubleInput(&numData, dData) !=0) {
opserr << "WARNING invalid double data: element BeamEndContact3D " << iData[0] << endln;
return 0;
}
numRemainingInputArgs -= 8;
while (numRemainingInputArgs >= 1) {
numData = 1;
if (OPS_GetIntInput(&numData, &icSwitch) != 0) {
opserr << "WARNING invalid initial contact flag: element BeamEndContact3D " << iData[0] << endln;
return 0;
}
numRemainingInputArgs -= 1;
}
// Parsing was successful, allocate the element
theElement = new BeamEndContact3D(iData[0], iData[1], iData[2], iData[3], iData[4],
dData[0], dData[1], dData[2], icSwitch);
if (theElement == 0) {
opserr << "WARNING could not create element of type BeamEndContact3DElement\n";
return 0;
}
return theElement;
}
void* OPS_LoadPattern()
{
if(OPS_GetNumRemainingInputArgs() < 2) {
opserr<<"insufficient number of args\n";
return 0;
}
LoadPattern *thePattern = 0;
// get tags
int tags[2];
int numData = 2;
if(OPS_GetIntInput(&numData, &tags[0]) < 0) {
opserr << "WARNING failed to get load pattern tag\n";
return 0;
}
// get factor
double fact = 1.0;
if(OPS_GetNumRemainingInputArgs() > 1) {
std::string type = OPS_GetString();
if(type=="-fact" || type=="-factor") {
numData = 1;
if(OPS_GetDoubleInput(&numData,&fact) < 0) {
opserr << "WARNING failed to get load pattern factor\n";
return 0;
}
}
}
// create pattern
thePattern = new LoadPattern(tags[0], fact);
TimeSeries *theSeries = OPS_getTimeSeries(tags[1]);
// check
if(thePattern == 0 || theSeries == 0) {
if(thePattern == 0) {
opserr << "WARNING - out of memory creating LoadPattern \n";
} else {
opserr << "WARNING - problem creating TimeSeries for LoadPattern \n";
}
// clean up the memory and return an error
if(thePattern != 0)
delete thePattern;
return 0;
}
thePattern->setTimeSeries(theSeries);
return thePattern;
}
OPS_Export void *
OPS_ratchet()
{
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
int numData;
int sDataLength = 40;
char *sData = new char[sDataLength];
int tag;
double E;
double direction;
int numSurfaces;
numData = 1;
if (OPS_GetIntInput(&numData, &tag) != 0) {
opserr << "WARNING invalid uniaxialMaterial ratchet tag \n" << endln;
return 0;
}
if ( OPS_GetStringCopy(&sData) != 0 ) {
opserr << "WARNING invalid input";
return 0;
}
if ( strcmp(sData,"tension") == 0 ) {
direction = 1.0;
} else if ( strcmp(sData,"compression") == 0 ) {
direction = -1.0;
} else {
opserr << "WARNING invalid direction: " << sData << "\n";
return 0;
}
numData = 1;
if (OPS_GetDoubleInput(&numData, &E) != 0) {
opserr << "WARNING invalid input, want: uniaxialMaterial ratchet tag direction E \n";
return 0;
}
// Create material
theMaterial = new ratchet(tag, direction, E);
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type ratchet\n";
return 0;
}
return theMaterial;
}
void *
OPS_ViscousDamper(void)
{
if (numViscousDamperMaterials == 0) {
numViscousDamperMaterials++;
opserr << "ViscousDamper Model by Sarven Akcelyan and Dimitrios G. Lignos, PhD, McGill University\n";
}
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
int iData[1];
double dData[6];
int numData = 1;
// Check tag
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid uniaxialMaterial ViscousDamper tag" << endln;
return 0;
}
// Check if we have 6 input variables for K, C, Alpha, NM, Tol, MaxHalf
numData = OPS_GetNumRemainingInputArgs();
if (numData != 3 && numData != 6) {
opserr << "Invalid #args, want: uniaxialMaterial ViscousDamper " << iData[0] << "K? C? Alpha? <NM? Tol? MaxHalf?>" << endln;
return 0;
}
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "Invalid #args want: uniaxialMaterial ViscousDamper " << iData[0] << "K? C? Alpha? <NM? Tol? MaxHalf?>" << endln;
return 0;
}
if (numData == 3) {
// Default variables
dData[3] = 1;
dData[4] = 0.000001;
dData[5] = 15;
}
// Parsing was successful, allocate the material with zero index
theMaterial = new ViscousDamper(iData[0],
dData[0], dData[1], dData[2], dData[3], dData[4], dData[5]);
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type ViscousDamper Material\n";
return 0;
}
return theMaterial;
}
void* OPS_CTestNormUnbalance()
{
if(OPS_GetNumRemainingInputArgs() < 2) {
opserr<<"insufficient number of arguments\n";
return 0;
}
// tolerance
double tol = 1e-6;
int numData = 1;
if(OPS_GetDoubleInput(&numData,&tol) < 0) {
opserr << "WARNING NormUnbalance failed to read tol\n";
return 0;
}
// maxIter
numData = OPS_GetNumRemainingInputArgs();
if(numData > 4) numData = 4;
int data[4] = {0,0,2,-1};
if(OPS_GetIntInput(&numData,&data[0]) < 0) {
opserr << "WARNING NormUnbalance failed to read int values\n";
return 0;
}
// maxTol
double maxTol = OPS_MAXTOL;
if(OPS_GetNumRemainingInputArgs() > 0) {
numData = 1;
if(OPS_GetDoubleInput(&numData,&maxTol) < 0) {
opserr << "WARNING NormUnbalance failed to read maxTol\n";
return 0;
}
}
// create test
return new CTestNormUnbalance(tol,data[0],data[1],data[2],data[3],maxTol);
}
int OPS_TriMesh(Domain& domain)
{
if (OPS_GetNumRemainingInputArgs() < 4) {
opserr<<"WARNING: want rtag? ndf? size? numnodes? nd1? ... bound1? ... eletype? ...\n";
return -1;
}
int num = 2;
int rtag[2];
if (OPS_GetIntInput(&num,&rtag[0]) < 0) {
opserr<<"WARNING: failed to read region tag\n";
return -1;
}
num = 1;
double size;
if (OPS_GetDoubleInput(&num,&size) < 0) {
opserr<<"WARNING: failed to read mesh size\n";
return -1;
}
num = 1;
int numnodes;
if (OPS_GetIntInput(&num,&numnodes) < 0) {
opserr<<"WARNING: failed to read number of nodes\n";
return -1;
}
if (OPS_GetNumRemainingInputArgs() < 2*numnodes) {
opserr<<"WARNING: insufficient input args\n";
return -1;
}
ID nodes(numnodes);
if (OPS_GetIntInput(&numnodes, &nodes(0)) < 0) {
opserr<<"WARNING: failed to read node tags\n";
return -1;
}
ID bound(numnodes);
if (OPS_GetIntInput(&numnodes, &bound(0)) < 0) {
opserr<<"WARNING: failed to read boundary values\n";
return -1;
}
TriMesh mesh(domain,rtag[1]);
return mesh.mesh(rtag[0],size,nodes,bound);
}
void *
OPS_Dodd_Restrepo(void)
{
if (numDoddRestrepo == 0) {
numDoddRestrepo++;
opserr << "Dodd_Restrepo unaxial material - Written by L.L. Dodd & J. Restepo\n";
}
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
int numArgs = OPS_GetNumRemainingInputArgs();
if (numArgs < 8 || numArgs > 10) {
opserr << "WARNING wrong # args: uniaxialMaterial $tag $Fy $Fsu $ESH $ESU $Youngs $ESHI $FSHI <$OmegaFac>" << endln;
return 0;
}
int iData[1];
double dData[9];
int numData;
dData[7]=1.0; // omegaFac
dData[8]=1.0; // Conv
numData = 1;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid uniaxialMaterial ElasticPP tag" << endln;
return 0;
}
numData = numArgs-1;
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "WARNING invalid E & ep\n";
return 0;
}
theMaterial = new Dodd_Restrepo(iData[0], dData[0], dData[1], dData[2],
dData[3], dData[4], dData[5], dData[6],
dData[7], dData[8]);
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type ElasticPPCpp\n";
return 0;
}
return theMaterial;
}
void *
OPS_DoddRestr(void)
{
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
int iData[1];
double dData[12];
int numData = 1;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid uniaxialMaterial DoddRestr tag" << endln;
return 0;
}
numData = OPS_GetNumRemainingInputArgs();
if (numData != 9 && numData != 12) {
opserr << "Invalid #args, want: uniaxialMaterial DoddRestr " << iData[0] << " Eo? fy? esh? esh1? fsh1? esu? fsu? Pmajor? Pminor? <slcf? tlcf? Dcrit?>>" << endln;
return 0;
}
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "Invalid #args, want: uniaxialMaterial DoddRestr " << iData[0] << " Eo? fy? esh? esh1? fsh1? esu? fsu? Pmajor? Pminor? <slcf? tlcf? Dcrit?>>" << endln;
return 0;
}
if (numData == 9) {
dData[9] = 0.;
dData[10] = 0.;
dData[11] = 0.;
}
// Parsing was successful, allocate the material
theMaterial = new DoddRestr(iData[0], dData[0], dData[1], dData[2],
dData[3], dData[4], dData[5], dData[6],
dData[7], dData[8], dData[9], dData[10], dData[11]);
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type DoddRestr Material\n";
return 0;
}
return theMaterial;
}
void *
OPS_HystereticMaterial(void)
{
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
int numArgs = OPS_GetNumRemainingInputArgs();
if (numArgs != 18 && numArgs != 17 && numArgs != 14 && numArgs != 13) {
opserr << "Want: uniaxialMaterial Hysteretic tag? mom1p? rot1p? mom2p? rot2p? <mom3p? rot3p?> "
<< "\nmom1n? rot1n? mom2n? rot2n? <mom3n? rot3n?> pinchX? pinchY? damfc1? damfc2? <beta?>";
return 0;
}
int iData[1];
double dData[17];
for (int i=0; i<17; i++)
dData[i] = 0.0;
int numData = 1;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid tag for uniaxialMaterial Hysteretic" << endln;
return 0;
}
numData = numArgs-1;
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "Invalid data for uniaxial Hysteretic " << iData[0] << endln;
return 0;
}
// Parsing was successful, allocate the material
if (numData > 13)
theMaterial = new HystereticMaterial(iData[0], dData[0], dData[1], dData[2], dData[3], dData[4], dData[5],
dData[6], dData[7], dData[8], dData[9], dData[10], dData[11], dData[12],
dData[13], dData[14], dData[15], dData[16]);
else
theMaterial = new HystereticMaterial(iData[0], dData[0], dData[1], dData[2], dData[3], dData[4], dData[5],
dData[6], dData[7], dData[8], dData[9], dData[10], dData[11], dData[12]);
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type Hysteretic\n";
return 0;
}
return theMaterial;
}
void* OPS_NodalLoad()
{
// check inputs
int ndm = OPS_GetNDM();
int ndf = OPS_GetNDF();
if(ndm<=0 || ndf<=0) {
opserr<<"zero ndm or ndf\n";
return 0;
}
if(OPS_GetNumRemainingInputArgs() < 1+ndf) {
opserr<<"insufficient number of args\n";
return 0;
}
// get node tag
int ndtag;
int numData = 1;
if(OPS_GetIntInput(&numData, &ndtag) < 0) return 0;
// get load vector
Vector forces(ndf);
if(OPS_GetDoubleInput(&ndf, &forces(0)) < 0) return 0;
// get load const
bool isLoadConst = false;
if(OPS_GetNumRemainingInputArgs() > 0) {
std::string type = OPS_GetString();
if(type == "-const") {
isLoadConst = true;
}
}
// create the load
NodalLoad* theLoad = new NodalLoad(nodeLoadTag, ndtag, forces, isLoadConst);
if(theLoad == 0) return 0;
nodeLoadTag++;
return theLoad;
}
void *
OPS_New_MultiLinear(void)
{
// Pointer to a uniaxial material that will be returned
UniaxialMaterial *theMaterial = 0;
if (OPS_GetNumRemainingInputArgs() < 5) {
opserr << "Invalid #args, want: uniaxialMaterial MultiLinear tag? e1 s1 e2 s2 ... " << endln;
return 0;
}
int iData[1];
int numData = 1;
if (OPS_GetIntInput(&numData, iData) != 0) {
opserr << "WARNING invalid tag or soilType uniaxialMaterial MultiLinearMaterial" << endln;
return 0;
}
numData = OPS_GetNumRemainingInputArgs();
int numSlope = numData/2;
double *dData = new double[numData];
if (OPS_GetDoubleInput(&numData, dData) != 0) {
opserr << "Invalid pyData data for material uniaxial MultiLinear " << iData[0] << endln;
return 0;
}
Vector e(numSlope);
Vector s(numSlope);
for (int i=0; i<numSlope; i++) {
e(i) = dData[2*i];
s(i) = dData[2*i+1];
}
// Parsing was successful, allocate the material
theMaterial = new MultiLinear(iData[0], s, e);
if (theMaterial == 0) {
opserr << "WARNING could not create uniaxialMaterial of type MultiLinear\n";
return 0;
}
return theMaterial;
}
void* OPS_ElasticSection2d()
{
if(OPS_GetNumRemainingInputArgs() < 4) {
opserr<<"insufficient arguments for ealstic section\n";
return 0;
}
// get tag
int tag;
int numData = 1;
if(OPS_GetIntInput(&numData,&tag) < 0) return 0;
// get data
numData = 3;
double data[3];
if(OPS_GetDoubleInput(&numData,&data[0]) < 0) return 0;
return new ElasticSection2d(tag,data[0],data[1],data[2]);
}
void* OPS_fElmt02()
{
int ndm = OPS_GetNDM();
int ndf = OPS_GetNDF();
if (ndm != 2 && ndf != 2) {
opserr << "WARNING - fTruss eleTag? iNode? jNode? A? E? needs ndm=2, ndf=2\n";
return 0;
}
// check the number of arguments is correct
int argc = OPS_GetNumRemainingInputArgs() + 2;
int eleArgStart = 2;
if ((argc-eleArgStart) < 5) {
opserr << "WARNING insufficient arguments\n";
opserr << "Want: element fTruss eleTag? iNode? jNode? A? E?\n";
return 0;
}
// get the id and end nodes
int idata[3];
int numdata = 3;
if (OPS_GetIntInput(&numdata, idata) < 0) {
opserr << "WARNING invalid truss eleTag, iNode or jNode" << endln;
return 0;
}
int trussId=idata[0], iNode=idata[1], jNode=idata[2];
double ddata[2];
numdata = 2;
if (OPS_GetDoubleInput(&numdata, ddata) < 0) {
opserr << "WARNING invalid truss A or E" << endln;
return 0;
}
double A=ddata[0],E=ddata[1];
// now create the truss and add it to the Domain
return new fElmt02(trussId,iNode,jNode,A,E);
}
