MaterialParameter.cppGo to the documentation of this file.00001 00002 // COPYLEFT (C): Woody's viral GPL-like license (by BJ): 00003 // ``This source code is Copyrighted in 00004 // U.S., for an indefinite period, and anybody 00005 // caught using it without our permission, will be 00006 // mighty good friends of ourn, cause we don't give 00007 // a darn. Hack it. Compile it. Debug it. Run it. 00008 // Yodel it. Enjoy it. We wrote it, that's all we 00009 // wanted to do.'' 00010 // 00011 // 00012 // COPYRIGHT (C): :-)) 00013 // PROJECT: Object Oriented Finite Element Program 00014 // FILE: 00015 // CLASS: 00016 // MEMBER FUNCTIONS: 00017 // 00018 // MEMBER VARIABLES 00019 // 00020 // PURPOSE: 00021 // 00022 // RETURN: 00023 // VERSION: 00024 // LANGUAGE: C++ 00025 // TARGET OS: 00026 // DESIGNER: Zhao Cheng, Boris Jeremic 00027 // PROGRAMMER: Zhao Cheng, 00028 // DATE: Fall 2005 00029 // UPDATE HISTORY: 00030 // 00032 // 00033 00034 // This is the container to store material constants: 00035 // Material_Parameter: to store fixed scalar material constants; 00036 // Note: the first one should be the density, input 0.0 if not involved; 00037 // Num_Material_Parameter: the number of Material_Parameter, should not less than 2, 00038 // given the 1st is the density and the 2nd is void ratio; 00039 // Internal_Scalar: to store initial evolution scalar variables first time, 00040 // and scalar variables thereafter; 00041 // Num_Internal_Scalar: the number of Internal_Scalar; 00042 // Internal_Tensor: to store initial evolution tensor variables first time (usually zero tensor), 00043 // and tensor variables thereafter; 00044 // Num_Internal_Tensor: the number of Internal_Tensor; 00045 00046 00047 #ifndef MaterialParameter_CPP 00048 #define MaterialParameter_CPP 00049 00050 #include "MaterialParameter.h" 00051 00052 // Constructor 1 00053 MaterialParameter::MaterialParameter(const double *Material_Parameter_in, 00054 int Num_Material_Parameter_in, 00055 const double *Internal_Scalar_in, 00056 int Num_Internal_Scalar_in, 00057 const stresstensor *Internal_Tensor_in, 00058 int Num_Internal_Tensor_in) 00059 { 00060 // Material Constants 00061 if (Num_Material_Parameter_in > 0) { 00062 Material_Parameter = new double [Num_Material_Parameter = Num_Material_Parameter_in]; 00063 if (!Material_Parameter) { 00064 opserr << "MaterialParameter::Insufficient memory! " << endln; 00065 exit (1); 00066 } 00067 for (int i = 0; i < Num_Material_Parameter; i++) 00068 Material_Parameter[i] = Material_Parameter_in[i]; 00069 } 00070 else { 00071 Num_Material_Parameter = 0; 00072 Material_Parameter = NULL; 00073 } 00074 00075 // Scalar (Isotropic) Internal Variables 00076 if (Num_Internal_Scalar_in > 0) { 00077 Internal_Scalar = new double [Num_Internal_Scalar = Num_Internal_Scalar_in]; 00078 if (!Internal_Scalar) { 00079 opserr << "MaterialParameter::Insufficient memory! " << endln; 00080 exit (1); 00081 } 00082 for (int i = 0; i < Num_Internal_Scalar; i++) 00083 Internal_Scalar[i] = Internal_Scalar_in[i]; 00084 } 00085 else { 00086 Num_Internal_Scalar = 0; 00087 Internal_Scalar = NULL; 00088 } 00089 00090 // Tensor (Kinematic) Internal Variables 00091 if (Num_Internal_Tensor_in > 0) { 00092 Internal_Tensor = new stresstensor[Num_Internal_Tensor = Num_Internal_Tensor_in]; 00093 if (!Internal_Tensor) { 00094 opserr << "MaterialParameter::Insufficient memory! " << endln; 00095 exit (1); 00096 } 00097 for (int i = 0; i < Num_Internal_Tensor; i++) 00098 Internal_Tensor[i] = Internal_Tensor_in[i]; 00099 } 00100 else { 00101 Num_Internal_Tensor = 0; 00102 Internal_Tensor = NULL; 00103 } 00104 } 00105 00106 // Constructor 2 00107 MaterialParameter::MaterialParameter(const double *Material_Parameter_in, 00108 int Num_Material_Parameter_in, 00109 const stresstensor *Internal_Tensor_in, 00110 int Num_Internal_Tensor_in) 00111 : Internal_Scalar(NULL), Num_Internal_Scalar(0) 00112 { 00113 // Material Constants 00114 if (Num_Material_Parameter_in > 0) { 00115 Material_Parameter = new double [Num_Material_Parameter = Num_Material_Parameter_in]; 00116 if (!Material_Parameter) { 00117 opserr << "MaterialParameter::Insufficient memory! " << endln; 00118 exit (1); 00119 } 00120 for (int i = 0; i < Num_Material_Parameter; i++) 00121 Material_Parameter[i] = Material_Parameter_in[i]; 00122 } 00123 else { 00124 Num_Material_Parameter = 0; 00125 Material_Parameter = NULL; 00126 } 00127 00128 // Tensor (Kinematic) Internal Variables 00129 if (Num_Internal_Tensor_in > 0) { 00130 Internal_Tensor = new stresstensor[Num_Internal_Tensor = Num_Internal_Tensor_in]; 00131 if (!Internal_Tensor) { 00132 opserr << "MaterialParameter::Insufficient memory! " << endln; 00133 exit (1); 00134 } 00135 for (int i = 0; i < Num_Internal_Tensor; i++) 00136 Internal_Tensor[i] = Internal_Tensor_in[i]; 00137 } 00138 else { 00139 Num_Internal_Tensor = 0; 00140 Internal_Tensor = NULL; 00141 } 00142 } 00143 00144 // Constructor 3 00145 MaterialParameter::MaterialParameter( ) 00146 : Material_Parameter(NULL), Num_Material_Parameter(0), 00147 Internal_Scalar(NULL), Num_Internal_Scalar(0), 00148 Internal_Tensor(NULL), Num_Internal_Tensor(0) 00149 { 00150 00151 } 00152 00153 // Destructor 00154 MaterialParameter::~MaterialParameter( ) 00155 { 00156 if (Material_Parameter) 00157 delete [] Material_Parameter; 00158 00159 if (Internal_Scalar) 00160 delete [] Internal_Scalar; 00161 00162 if (Internal_Tensor) 00163 delete [] Internal_Tensor; 00164 } 00165 00166 // Copy constructor 00167 MaterialParameter::MaterialParameter(const MaterialParameter &refer_MaterialParameter ) 00168 { 00169 // Material Constants 00170 if (refer_MaterialParameter.getNum_Material_Parameter() > 0) { 00171 Material_Parameter = new double [Num_Material_Parameter = refer_MaterialParameter.getNum_Material_Parameter()]; 00172 if (!Material_Parameter) { 00173 opserr << "MaterialParameter::Insufficient memory! " << endln; 00174 exit (1); 00175 } 00176 for (int i = 0; i < Num_Material_Parameter; i++) 00177 Material_Parameter[i] = refer_MaterialParameter.getMaterial_Parameter(i); 00178 } 00179 else { 00180 Num_Material_Parameter = 0; 00181 Material_Parameter = NULL; 00182 } 00183 00184 // Scalar (Isotropic) Internal Variables 00185 if (refer_MaterialParameter.getNum_Internal_Scalar() > 0) { 00186 Internal_Scalar = new double [Num_Internal_Scalar = refer_MaterialParameter.getNum_Internal_Scalar()]; 00187 if (!Internal_Scalar) { 00188 opserr << "MaterialParameter::Insufficient memory! " << endln; 00189 exit (1); 00190 } 00191 for (int i = 0; i < Num_Internal_Scalar; i++) 00192 Internal_Scalar[i] = refer_MaterialParameter.getInternal_Scalar(i); 00193 } 00194 else { 00195 Num_Internal_Scalar = 0; 00196 Internal_Scalar = NULL; 00197 } 00198 00199 // Tensor (Kinematic) Internal Variables 00200 if (refer_MaterialParameter.getNum_Internal_Tensor() > 0) { 00201 Internal_Tensor = new stresstensor[Num_Internal_Tensor = refer_MaterialParameter.getNum_Internal_Tensor()]; 00202 if (!Internal_Tensor) { 00203 opserr << "MaterialParameter::Insufficient memory! " << endln; 00204 exit (1); 00205 } 00206 for (int i = 0; i < Num_Internal_Tensor; i++) 00207 Internal_Tensor[i] = refer_MaterialParameter.getInternal_Tensor(i); 00208 } 00209 else { 00210 Num_Internal_Tensor = 0; 00211 Internal_Tensor = NULL; 00212 } 00213 00214 } 00215 00216 // Create a new class pointer 00217 MaterialParameter* MaterialParameter::newObj() { 00218 MaterialParameter *ptr_MaterialParameter = new MaterialParameter ( this->Material_Parameter, 00219 this->Num_Material_Parameter, 00220 this->Internal_Scalar, 00221 this->Num_Internal_Scalar, 00222 this->Internal_Tensor, 00223 this->Num_Internal_Tensor ); 00224 return ptr_MaterialParameter; 00225 } 00226 00227 // getNum_Material_Parameter 00228 int MaterialParameter::getNum_Material_Parameter() const 00229 { 00230 return Num_Material_Parameter; 00231 } 00232 00233 // getNum_Internal_Scalar 00234 int MaterialParameter::getNum_Internal_Scalar() const 00235 { 00236 return Num_Internal_Scalar; 00237 } 00238 00239 // getNum_Internal_Tensor 00240 int MaterialParameter::getNum_Internal_Tensor() const 00241 { 00242 return Num_Internal_Tensor; 00243 } 00244 00245 // getMaterial_Parameter 00246 double MaterialParameter::getMaterial_Parameter(int which) const 00247 { 00248 if (which < 0 || which > Num_Material_Parameter) { 00249 opserr << "Error! MaterialParameter::getMaterial_Parameter - Invalid index of material constants. " << endln; 00250 exit(1); 00251 } 00252 00253 return Material_Parameter[which]; 00254 } 00255 00256 // getInternal_Scalar 00257 double MaterialParameter::getInternal_Scalar(int which) const 00258 { 00259 if (which < 0 || which > Num_Internal_Scalar) { 00260 opserr << "Error! MaterialParameter::getInternal_Scalar - Invalid index of internal scalars. " << endln; 00261 exit(1); 00262 } 00263 00264 return Internal_Scalar[which]; 00265 } 00266 00267 // getInternal_Tensor 00268 const stresstensor& MaterialParameter::getInternal_Tensor(int which) const 00269 { 00270 if (which < 0 || which > Num_Internal_Tensor) { 00271 opserr << "Error! MaterialParameter::getInternal_Tensor - Invalid index of internal tensors. " << endln; 00272 exit (1); 00273 } 00274 00275 return Internal_Tensor[which]; 00276 } 00277 00278 // setMaterial_Parameter 00279 int MaterialParameter::setMaterial_Parameter(int which, double newMaterial_Parameter) 00280 { 00281 if (which < 0 || which > Num_Material_Parameter) { 00282 opserr << "Error! MaterialParameter::setMaterial_Parameter - Invalid index of material constants. " << endln; 00283 return (1); 00284 } 00285 00286 Material_Parameter[which] = newMaterial_Parameter; 00287 00288 return 0; 00289 } 00290 00291 // setInternal_Scalar 00292 int MaterialParameter::setInternal_Scalar(int which, double newInternal_Scalar) 00293 { 00294 if (which < 0 || which > Num_Internal_Scalar) { 00295 opserr << "Error! MaterialParameter::setInternal_Scalar - Invalid index of internal scalars. " << endln; 00296 exit (1); 00297 } 00298 00299 Internal_Scalar[which] = newInternal_Scalar; 00300 00301 return 0; 00302 } 00303 00304 // setInternal_Tensor 00305 int MaterialParameter::setInternal_Tensor(int which, const stresstensor &newInternal_Tensor) 00306 { 00307 if (which < 0 || which > Num_Internal_Tensor) { 00308 opserr << "Error! MaterialParameter::setInternal_Tensor - Invalid index of internal tensors. " << endln; 00309 exit (1); 00310 } 00311 00312 Internal_Tensor[which] = newInternal_Tensor; 00313 00314 return 0; 00315 } 00316 00317 00318 #endif 00319
Generated on Mon Oct 23 15:05:15 2006 for OpenSees by |
opensees-support @ berkeley.edu
Supported by the National Science Foundation
©2006, UC Regents