bool
TensorMechanicsPlasticModel::returnMap(const RankTwoTensor & trial_stress,
Real intnl_old,
const RankFourTensor & /*E_ijkl*/,
Real /*ep_plastic_tolerance*/,
RankTwoTensor & /*returned_stress*/,
Real & /*returned_intnl*/,
std::vector<Real> & /*dpm*/,
RankTwoTensor & /*delta_dp*/,
std::vector<Real> & yf,
bool & trial_stress_inadmissible) const
{
trial_stress_inadmissible = false;
yieldFunctionV(trial_stress, intnl_old, yf);
for (unsigned sf = 0; sf < numberSurfaces(); ++sf)
if (yf[sf] > _f_tol)
trial_stress_inadmissible = true;
// example of checking Kuhn-Tucker
std::vector<Real> dpm(numberSurfaces(), 0);
for (unsigned sf = 0; sf < numberSurfaces(); ++sf)
if (!KuhnTuckerSingleSurface(yf[sf], dpm[sf], 0))
return false;
return true;
}
//*****************************************************************************
// METHOD: rspfMapProjection::computeDegreesPerPixel
//
//*****************************************************************************
void rspfLlxyProjection::computeDegreesPerPixel(const rspfGpt& ground,
const rspfDpt& metersPerPixel,
double &deltaLat,
double &deltaLon)
{
rspfDpt mpd = ground.metersPerDegree();
rspfDpt dpm(1.0/mpd.x,
1.0/mpd.y);
deltaLat = metersPerPixel.y*dpm.y;
deltaLon = metersPerPixel.x*dpm.x;
}
void
TensorMechanicsPlasticTensileMulti::activeConstraints(const std::vector<Real> & f, const RankTwoTensor & stress, const Real & intnl, const RankFourTensor & Eijkl, std::vector<bool> & act, RankTwoTensor & returned_stress) const
{
act.assign(3, false);
if (f[0] <= _f_tol && f[1] <= _f_tol && f[2] <= _f_tol)
{
returned_stress = stress;
return;
}
Real returned_intnl;
std::vector<Real> dpm(3);
RankTwoTensor delta_dp;
std::vector<Real> yf(3);
bool trial_stress_inadmissible;
doReturnMap(stress, intnl, Eijkl, 0.0, returned_stress, returned_intnl, dpm, delta_dp, yf, trial_stress_inadmissible);
for (unsigned i = 0 ; i < 3 ; ++i)
act[i] = (dpm[i] > 0);
}
void renderGraph(QPainter & paint, const QRect & rect, ORGraphData & gData, XSqlQuery * query, const QMap<QString, QColor> & _colorMap) {
QPaintDeviceMetrics dpm(paint.device());
int dpi = dpm.logicalDpiX();
QFont fnt;
tGraph graph(rect);
fnt = gData.font;
fnt.setPointSizeFloat((100.0/dpi)*fnt.pointSize());
graph.setFont(fnt);
if(gData.title.string.length() > 0) {
graph.setTitle(gData.title.string);
if(gData.title.font_defined) {
fnt = gData.title.font;
fnt.setPointSizeFloat((100.0/dpi)*fnt.pointSize());
graph.setTitleFont(&fnt);
}
}
QString lbl_clmn = gData.dataaxis.column;
if(lbl_clmn.length() > 0 && gData.dataaxis.font_defined) {
fnt = gData.dataaxis.font;
fnt.setPointSizeFloat((100.0/dpi)*fnt.pointSize());
graph.setDataFont(&fnt);
}
if(gData.dataaxis.title.string.length() > 0) {
graph.setDataLabel(gData.dataaxis.title.string);
if(gData.dataaxis.title.font_defined) {
fnt = gData.dataaxis.title.font;
fnt.setPointSizeFloat((100.0/dpi)*fnt.pointSize());
graph.setDataLabelFont(&fnt);
}
}
graph.setAutoMinMax(gData.valueaxis.autominmax);
graph.setMinValue(gData.valueaxis.min);
graph.setMaxValue(gData.valueaxis.max);
if(gData.valueaxis.font_defined) {
fnt = gData.valueaxis.font;
fnt.setPointSizeFloat((100.0/dpi)*fnt.pointSize());
graph.setValueFont(&fnt);
}
if(gData.valueaxis.title.string.length() > 0) {
graph.setValueLabel(gData.valueaxis.title.string);
if(gData.valueaxis.title.font_defined) {
fnt = gData.valueaxis.title.font;
fnt.setPointSizeFloat((100.0/dpi)*fnt.pointSize());
graph.setValueLabelFont(&fnt);
}
}
// setup the sets/series
unsigned int snum = 0;
ORSeriesData * sd = 0;
for(snum = 0; snum < gData.series.count(); snum++) {
sd = gData.series.at(snum);
if(sd) {
graph.setSetColor(snum, &_colorMap[sd->color]);
graph.setSetStyle(snum, sd->style);
}
}
// populate the data
if(query->first()) {
do {
if(lbl_clmn.length() > 0) {
graph.setReferenceLabel(query->at(), query->value(lbl_clmn).toString());
}
for(snum = 0; snum < gData.series.count(); snum++) {
sd = gData.series.at(snum);
if(sd) {
graph.setSetValue(query->at(), snum, query->value(sd->column).toDouble());
}
}
} while(query->next());
}
// draw the graph
graph.draw(paint);
}
