void testIteration()
{
IntArray a;
assert(a.begin() == a.end());
assert(a.rbegin() == a.rend());
a = IntArray(10000);
for (int i = 0; i < 10000; i++) {
a[i] = i;
}
int counter = 0;
IntArray::iterator aIter;
for (aIter = a.begin(); aIter != a.end(); ++aIter) {
assert(*aIter == counter);
++counter;
}
for (IntArray::reverse_iterator aReverseIter = a.rbegin();
aReverseIter != a.rend(); ++aReverseIter) {
--counter;
--aIter;
assert(*aReverseIter == counter);
}
assert(aIter == a.begin());
}
int main(int argc, char *argv[])
{
// The data for the bar chart
double data[] = {450, 560, 630, 800, 1100, 1350, 1600, 1950, 2300, 2700};
// The labels for the bar chart
const char *labels[] = {"1996", "1997", "1998", "1999", "2000", "2001", "2002",
"2003", "2004", "2005"};
// Create a XYChart object of size 600 x 380 pixels. Set background color to
// brushed silver, with a 2 pixel 3D border. Use rounded corners of 20 pixels
// radius.
XYChart *c = new XYChart(600, 380, Chart::brushedSilverColor(),
Chart::Transparent, 2);
// Add a title to the chart using 18pts Times Bold Italic font. Set top/bottom
// margins to 8 pixels.
c->addTitle("Annual Revenue for Star Tech", "timesbi.ttf", 18)->setMargin(0, 0,
8, 8);
// Set the plotarea at (70, 55) and of size 460 x 280 pixels. Use transparent
// border and black grid lines. Use rounded frame with radius of 20 pixels.
c->setPlotArea(70, 55, 460, 280, -1, -1, Chart::Transparent, 0x000000);
c->setRoundedFrame(0xffffff, 20);
// Add a multi-color bar chart layer using the supplied data. Set cylinder bar
// shape.
c->addBarLayer(DoubleArray(data, sizeof(data)/sizeof(data[0])), IntArray(0, 0)
)->setBarShape(Chart::CircleShape);
// Set the labels on the x axis.
c->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
// Show the same scale on the left and right y-axes
c->syncYAxis();
// Set the left y-axis and right y-axis title using 10pt Arial Bold font
c->yAxis()->setTitle("USD (millions)", "arialbd.ttf", 10);
c->yAxis2()->setTitle("USD (millions)", "arialbd.ttf", 10);
// Set y-axes to transparent
c->yAxis()->setColors(Chart::Transparent);
c->yAxis2()->setColors(Chart::Transparent);
// Disable ticks on the x-axis by setting the tick color to transparent
c->xAxis()->setTickColor(Chart::Transparent);
// Set the label styles of all axes to 8pt Arial Bold font
c->xAxis()->setLabelStyle("arialbd.ttf", 8);
c->yAxis()->setLabelStyle("arialbd.ttf", 8);
c->yAxis2()->setLabelStyle("arialbd.ttf", 8);
// Output the chart
c->makeChart("cylinderlightbar.jpg");
//free up resources
delete c;
return 0;
}
int main(int argc, char *argv[])
{
// The data for the area chart
double data[] = {3.0, 2.8, 4.0, 5.5, 7.5, 6.8, 5.4, 6.0, 5.0, 6.2, 7.5, 6.5, 7.5,
8.1, 6.0, 5.5, 5.3, 3.5, 5.0, 6.6, 5.6, 4.8, 5.2, 6.5, 6.2};
// The labels for the area chart
const char *labels[] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23",
"24"};
// Create a XYChart object of size 300 x 180 pixels. Set the background to pale
// yellow (0xffffa0) with a black border (0x0)
XYChart *c = new XYChart(300, 180, 0xffffa0, 0x000000);
// Set the plotarea at (45, 35) and of size 240 x 120 pixels. Set the background
// to white (0xffffff). Set both horizontal and vertical grid lines to black
// (&H0&) dotted lines (pattern code 0x0103)
c->setPlotArea(45, 35, 240, 120, 0xffffff, -1, -1, c->dashLineColor(0x000000,
0x000103), c->dashLineColor(0x000000, 0x000103));
// Add a title to the chart using 10 pts Arial Bold font. Use a 1 x 2 bitmap
// pattern as the background. Set the border to black (0x0).
int pattern1[] = {0xb0b0f0, 0xe0e0ff};
c->addTitle("Snow Percipitation (Dec 12)", "arialbd.ttf", 10)->setBackground(
c->patternColor(IntArray(pattern1, sizeof(pattern1)/sizeof(pattern1[0])), 2),
0x000000);
// Add a title to the y axis
c->yAxis()->setTitle("mm per hour");
// Set the labels on the x axis.
c->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
// Display 1 out of 3 labels on the x-axis.
c->xAxis()->setLabelStep(3);
// Add an area layer to the chart
AreaLayer *layer = c->addAreaLayer();
// Load a snow pattern from an external file "snow.png".
int snowPattern = c->patternColor("snow.png");
// Add a data set to the area layer using the snow pattern as the fill color. Use
// deep blue (0x0000ff) as the area border line color (&H0000ff&)
layer->addDataSet(DoubleArray(data, sizeof(data)/sizeof(data[0])))->setDataColor(
snowPattern, 0x0000ff);
// Set the line width to 2 pixels to highlight the line
layer->setLineWidth(2);
// output the chart
c->makeChart("patternarea.png");
//free up resources
delete c;
return 0;
}
void createChart(int img, const char *filename)
{
// The data for the pie chart
double data[] = {25, 18, 15, 12, 8, 30, 35};
// The labels for the pie chart
const char *labels[] = {"Labor", "Licenses", "Taxes", "Legal", "Insurance",
"Facilities", "Production"};
// Colors of the sectors if custom coloring is used
int colors[] = {0xb8bc9c, 0xecf0b9, 0x999966, 0x333366, 0xc3c3e6, 0x594330,
0xa0bdc4};
// Create a PieChart object of size 280 x 240 pixels
PieChart *c = new PieChart(280, 240);
// Set the center of the pie at (140, 120) and the radius to 80 pixels
c->setPieSize(140, 120, 80);
// Draw the pie in 3D
c->set3D();
// Set the coloring schema
if (img == 0) {
c->addTitle("Custom Colors");
// set the LineColor to light gray
c->setColor(Chart::LineColor, 0xc0c0c0);
// use given color array as the data colors (sector colors)
c->setColors(Chart::DataColor, IntArray(colors,
sizeof(colors)/sizeof(colors[0])));
} else if (img == 1) {
c->addTitle("Dark Background Colors");
// use the standard white on black palette
c->setColors(Chart::whiteOnBlackPalette);
} else if (img == 2) {
c->addTitle("Wallpaper As Background");
c->setWallpaper("bg.png");
} else {
c->addTitle("Transparent Colors");
c->setWallpaper("bg.png");
// use semi-transparent colors to allow the background to be seen
c->setColors(Chart::transparentPalette);
}
// Set the pie data and the pie labels
c->setData(DoubleArray(data, sizeof(data)/sizeof(data[0])), StringArray(labels,
sizeof(labels)/sizeof(labels[0])));
// Explode the 1st sector (index = 0)
c->setExplode(0);
// output the chart
c->makeChart(filename);
//free up resources
delete c;
}
void createChart(int img, const char *filename)
{
// The data for the pie chart
double data[] = {18, 30, 20, 15};
// The colors to use for the sectors
int colors[] = {0x66aaee, 0xeebb22, 0xbbbbbb, 0x8844ff};
// Create a PieChart object of size 200 x 220 pixels. Use a vertical gradient
// color from blue (0000cc) to deep blue (000044) as background. Use rounded
// corners of 16 pixels radius.
PieChart *c = new PieChart(200, 220);
c->setBackground(c->linearGradientColor(0, 0, 0, c->getHeight(), 0x0000cc,
0x000044));
c->setRoundedFrame(0xffffff, 16);
// Set the center of the pie at (100, 120) and the radius to 80 pixels
c->setPieSize(100, 120, 80);
// Set the pie data
c->setData(DoubleArray(data, sizeof(data)/sizeof(data[0])));
// Set the sector colors
c->setColors(Chart::DataColor, IntArray(colors, sizeof(colors)/sizeof(colors[0]))
);
// Demonstrates various shading modes
if (img == 0) {
c->addTitle("Default Shading", "bold", 12, 0xffffff);
} else if (img == 1) {
c->addTitle("Local Gradient", "bold", 12, 0xffffff);
c->setSectorStyle(Chart::LocalGradientShading);
} else if (img == 2) {
c->addTitle("Global Gradient", "bold", 12, 0xffffff);
c->setSectorStyle(Chart::GlobalGradientShading);
} else if (img == 3) {
c->addTitle("Concave Shading", "bold", 12, 0xffffff);
c->setSectorStyle(Chart::ConcaveShading);
} else if (img == 4) {
c->addTitle("Rounded Edge", "bold", 12, 0xffffff);
c->setSectorStyle(Chart::RoundedEdgeShading);
} else if (img == 5) {
c->addTitle("Radial Gradient", "bold", 12, 0xffffff);
c->setSectorStyle(Chart::RadialShading);
}
// Disable the sector labels by setting the color to Transparent
c->setLabelStyle("", 8, Chart::Transparent);
// Output the chart
c->makeChart(filename);
//free up resources
delete c;
}
void SlaveNode :: postInitialize()
{
Node :: postInitialize();
// initialize slave dofs (inside check of consistency of receiver and master dof)
for ( Dof *dof: *this ) {
SlaveDof *sdof = dynamic_cast< SlaveDof * >(dof);
if ( sdof ) {
sdof->initialize(masterDofManagers, IntArray(), masterWeights);
}
}
}
int main(int argc, char *argv[])
{
// The data for the line chart
double data0[] = {60.2, 51.7, 81.3, 48.6, 56.2, 68.9, 52.8};
double data1[] = {30.0, 32.7, 33.9, 29.5, 32.2, 28.4, 29.8};
const char *labels[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
// Create a XYChart object of size 300 x 180 pixels, with a pale yellow (0xffffc0) background, a
// black border, and 1 pixel 3D border effect.
XYChart *c = new XYChart(300, 180, 0xffffc0, 0x000000, 1);
// Set the plotarea at (45, 35) and of size 240 x 120 pixels, with white background. Turn on
// both horizontal and vertical grid lines with light grey color (0xc0c0c0)
c->setPlotArea(45, 35, 240, 120, 0xffffff, -1, -1, 0xc0c0c0, -1);
// Add a legend box at (45, 12) (top of the chart) using horizontal layout and 8pt Arial font
// Set the background and border color to Transparent.
c->addLegend(45, 12, false, "", 8)->setBackground(Chart::Transparent);
// Add a title to the chart using 9pt Arial Bold/white font. Use a 1 x 2 bitmap pattern as the
// background.
int pattern1[] = {0x004000, 0x008000};
c->addTitle("Server Load (Jun 01 - Jun 07)", "arialbd.ttf", 9, 0xffffff)->setBackground(
c->patternColor(IntArray(pattern1, (int)(sizeof(pattern1) / sizeof(pattern1[0]))), 2));
// Set the y axis label format to nn%
c->yAxis()->setLabelFormat("{value}%");
// Set the labels on the x axis
c->xAxis()->setLabels(StringArray(labels, (int)(sizeof(labels) / sizeof(labels[0]))));
// Add a line layer to the chart
LineLayer *layer = c->addLineLayer();
// Add the first line. Plot the points with a 7 pixel square symbol
layer->addDataSet(DoubleArray(data0, (int)(sizeof(data0) / sizeof(data0[0]))), 0xcf4040, "Peak"
)->setDataSymbol(Chart::SquareSymbol, 7);
// Add the second line. Plot the points with a 9 pixel dismond symbol
layer->addDataSet(DoubleArray(data1, (int)(sizeof(data1) / sizeof(data1[0]))), 0x40cf40,
"Average")->setDataSymbol(Chart::DiamondSymbol, 9);
// Enable data label on the data points. Set the label format to nn%.
layer->setDataLabelFormat("{value|0}%");
// Output the chart
c->makeChart("symbolline.png");
//free up resources
delete c;
return 0;
}
int main(int argc, char *argv[])
{
// The data for the bar chart
double data[] = {450, 560, 630, 800, 1100, 1350, 1600, 1950, 2300, 2700};
// The labels for the bar chart
const char *labels[] = {"1996", "1997", "1998", "1999", "2000", "2001", "2002",
"2003", "2004", "2005"};
// Create a XYChart object of size 600 x 360 pixels
XYChart *c = new XYChart(600, 360);
// Add a title to the chart using 18pts Times Bold Italic font
c->addTitle("Annual Revenue for Star Tech", "timesbi.ttf", 18);
// Set the plotarea at (60, 40) and of size 500 x 280 pixels. Use a vertical
// gradient color from light blue (eeeeff) to deep blue (0000cc) as background.
// Set border and grid lines to white (ffffff).
c->setPlotArea(60, 40, 500, 280, c->linearGradientColor(60, 40, 60, 280,
0xeeeeff, 0x0000cc), -1, 0xffffff, 0xffffff);
// Add a multi-color bar chart layer using the supplied data. Use soft lighting
// effect with light direction from left.
c->addBarLayer(DoubleArray(data, sizeof(data)/sizeof(data[0])), IntArray(0, 0)
)->setBorderColor(Chart::Transparent, Chart::softLighting(Chart::Left));
// Set x axis labels using the given labels
c->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
// Draw the ticks between label positions (instead of at label positions)
c->xAxis()->setTickOffset(0.5);
// Add a title to the y axis with 10pts Arial Bold font
c->yAxis()->setTitle("USD (millions)", "arialbd.ttf", 10);
// Set axis label style to 8pts Arial Bold
c->xAxis()->setLabelStyle("arialbd.ttf", 8);
c->yAxis()->setLabelStyle("arialbd.ttf", 8);
// Set axis line width to 2 pixels
c->xAxis()->setWidth(2);
c->yAxis()->setWidth(2);
// Output the chart
c->makeChart("softlightbar.png");
//free up resources
delete c;
return 0;
}
// Reset for next plot
void PlotAgent::reset()
{
// Clear storage
titles = StringArray();
values = StringArray();
dims = IntArray();
ndim = 0;
// Clear range
x_min = y_min = v_min = +DBL_MAX;
x_max = y_max = v_max = -DBL_MAX;
need_reset = false;
}
IntArray^ IndexedMesh::TriangleIndices::get()
{
int count = _native->m_numTriangles * _native->m_triangleIndexStride / sizeof(int);
int* triangleIndexBase = (int*)_native->m_triangleIndexBase;
if (_triangleIndices != nullptr &&
(int*)_triangleIndices->_native == triangleIndexBase &&
_triangleIndices->Count == count)
{
return _triangleIndices;
}
_triangleIndices = gcnew IntArray(triangleIndexBase, count);
return _triangleIndices;
}
int main(int argc, char *argv[])
{
// The data for the pyramid chart
double data[] = {156, 123, 211, 179};
// The labels for the pyramid chart
const char *labels[] = {"Funds", "Bonds", "Stocks", "Cash"};
// The semi-transparent colors for the pyramid layers
int colors[] = {0x60000088, 0x6066aaee, 0x60ffbb00, 0x60ee6622};
// Create a PyramidChart object of size 480 x 400 pixels
PyramidChart *c = new PyramidChart(480, 400);
// Set the cone center at (280, 180), and width x height to 150 x 300 pixels
c->setConeSize(280, 180, 150, 300);
// Set the elevation to 15 degrees
c->setViewAngle(15);
// Set the pyramid data and labels
c->setData(DoubleArray(data, sizeof(data)/sizeof(data[0])), StringArray(labels,
sizeof(labels)/sizeof(labels[0])));
// Set the layer colors to the given colors
c->setColors(Chart::DataColor, IntArray(colors, sizeof(colors)/sizeof(colors[0]))
);
// Leave 1% gaps between layers
c->setLayerGap(0.01);
// Add labels at the left side of the pyramid layers using Arial Bold font. The
// labels will have 3 lines showing the layer name, value and percentage.
c->setLeftLabel("{label}\nUS ${value}K\n({percent}%)", "arialbd.ttf");
// Output the chart
c->makeChart("cone.png");
//free up resources
return 0;
}
int main(int argc, char *argv[])
{
// The tasks for the gantt chart
const char *labels[] = {"Market Research", "Define Specifications",
"Overall Archiecture", "Project Planning", "Detail Design",
"Software Development", "Test Plan", "Testing and QA", "User Documentation"};
// The task index, start date, end date and color for each bar
double taskNo[] = {0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 8};
double startDate[] = {chartTime(2004, 8, 16), chartTime(2004, 10, 4), chartTime(
2004, 8, 30), chartTime(2004, 9, 13), chartTime(2004, 9, 20), chartTime(2004,
9, 27), chartTime(2004, 10, 4), chartTime(2004, 10, 4), chartTime(2004, 10,
25), chartTime(2004, 11, 1), chartTime(2004, 10, 18), chartTime(2004, 11, 8)}
;
double endDate[] = {chartTime(2004, 8, 30), chartTime(2004, 10, 18), chartTime(
2004, 9, 13), chartTime(2004, 9, 27), chartTime(2004, 10, 4), chartTime(2004,
10, 11), chartTime(2004, 11, 8), chartTime(2004, 10, 18), chartTime(2004, 11,
8), chartTime(2004, 11, 22), chartTime(2004, 11, 1), chartTime(2004, 11, 22)}
;
int colors[] = {0x00cc00, 0x00cc00, 0x00cc00, 0x0000cc, 0x0000cc, 0xcc0000,
0xcc0000, 0x0000cc, 0xcc0000, 0xcc0000, 0x00cc00, 0xcc0000};
// Create a XYChart object of size 620 x 325 pixels. Set background color to
// light red (0xffcccc), with 1 pixel 3D border effect.
XYChart *c = new XYChart(620, 325, 0xffcccc, 0x000000, 1);
// Add a title to the chart using 15 points Times Bold Itatic font, with white
// (ffffff) text on a dark red (800000) background
c->addTitle("Mutli-Color Gantt Chart Demo", "timesbi.ttf", 15, 0xffffff
)->setBackground(0x800000);
// Set the plotarea at (140, 55) and of size 460 x 200 pixels. Use alternative
// white/grey background. Enable both horizontal and vertical grids by setting
// their colors to grey (c0c0c0). Set vertical major grid (represents month
// boundaries) 2 pixels in width
c->setPlotArea(140, 55, 460, 200, 0xffffff, 0xeeeeee, Chart::LineColor, 0xc0c0c0,
0xc0c0c0)->setGridWidth(2, 1, 1, 1);
// swap the x and y axes to create a horziontal box-whisker chart
c->swapXY();
// Set the y-axis scale to be date scale from Aug 16, 2004 to Nov 22, 2004, with
// ticks every 7 days (1 week)
c->yAxis()->setDateScale(chartTime(2004, 8, 16), chartTime(2004, 11, 22), 86400 *
7);
// Set multi-style axis label formatting. Month labels are in Arial Bold font in
// "mmm d" format. Weekly labels just show the day of month and use minor tick
// (by using '-' as first character of format string).
c->yAxis()->setMultiFormat(Chart::StartOfMonthFilter(),
"<*font=arialbd.ttf*>{value|mmm d}", Chart::StartOfDayFilter(), "-{value|d}")
;
// Set the y-axis to shown on the top (right + swapXY = top)
c->setYAxisOnRight();
// Set the labels on the x axis
c->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
// Reverse the x-axis scale so that it points downwards.
c->xAxis()->setReverse();
// Set the horizontal ticks and grid lines to be between the bars
c->xAxis()->setTickOffset(0.5);
// Add some symbols to the chart to represent milestones. The symbols are added
// using scatter layers. We need to specify the task index, date, name, symbol
// shape, size and color.
double coor1[] = {1};
double date1[] = {chartTime(2004, 9, 13)};
c->addScatterLayer(DoubleArray(coor1, sizeof(coor1)/sizeof(coor1[0])),
DoubleArray(date1, sizeof(date1)/sizeof(date1[0])), "Milestone 1",
Chart::Cross2Shape(), 13, 0xffff00);
double coor2[] = {3};
double date2[] = {chartTime(2004, 10, 4)};
c->addScatterLayer(DoubleArray(coor2, sizeof(coor2)/sizeof(coor2[0])),
DoubleArray(date2, sizeof(date2)/sizeof(date2[0])), "Milestone 2",
Chart::StarShape(5), 15, 0xff00ff);
double coor3[] = {5};
double date3[] = {chartTime(2004, 11, 8)};
c->addScatterLayer(DoubleArray(coor3, sizeof(coor3)/sizeof(coor3[0])),
DoubleArray(date3, sizeof(date3)/sizeof(date3[0])), "Milestone 3",
Chart::TriangleSymbol, 13, 0xff9933);
// Add a multi-color box-whisker layer to represent the gantt bars
BoxWhiskerLayer *layer = c->addBoxWhiskerLayer2(DoubleArray(startDate,
sizeof(startDate)/sizeof(startDate[0])), DoubleArray(endDate,
sizeof(endDate)/sizeof(endDate[0])), DoubleArray(), DoubleArray(),
DoubleArray(), IntArray(colors, sizeof(colors)/sizeof(colors[0])));
layer->setXData(DoubleArray(taskNo, sizeof(taskNo)/sizeof(taskNo[0])));
layer->setBorderColor(Chart::SameAsMainColor);
// Divide the plot area height ( = 200 in this chart) by the number of tasks to
// get the height of each slot. Use 80% of that as the bar height.
layer->setDataWidth(200 * 4 / 5 / (sizeof(labels) / sizeof(labels[0])));
// Add a legend box at (140, 265) - bottom of the plot area. Use 8 pts Arial Bold
// as the font with auto-grid layout. Set the width to the same width as the plot
// area. Set the backgorund to grey (dddddd).
LegendBox *legendBox = c->addLegend2(140, 265, Chart::AutoGrid, "arialbd.ttf", 8)
;
legendBox->setWidth(461);
legendBox->setBackground(0xdddddd);
// The keys for the scatter layers (milestone symbols) will automatically be
// added to the legend box. We just need to add keys to show the meanings of the
// bar colors.
legendBox->addKey("Market Team", 0x00cc00);
legendBox->addKey("Planning Team", 0x0000cc);
legendBox->addKey("Development Team", 0xcc0000);
// Output the chart
c->makeChart("colorgantt.png");
//free up resources
delete c;
return 0;
}
int main(int argc, char *argv[])
{
// the names of the tasks
const char *labels[] = {"Market Research", "Define Specifications",
"Overall Archiecture", "Project Planning", "Detail Design",
"Software Development", "Test Plan", "Testing and QA", "User Documentation"};
// the planned start dates and end dates for the tasks
double startDate[] = {chartTime(2004, 8, 16), chartTime(2004, 8, 30), chartTime(
2004, 9, 13), chartTime(2004, 9, 20), chartTime(2004, 9, 27), chartTime(2004,
10, 4), chartTime(2004, 10, 25), chartTime(2004, 11, 1), chartTime(2004, 11,
8)};
double endDate[] = {chartTime(2004, 8, 30), chartTime(2004, 9, 13), chartTime(
2004, 9, 27), chartTime(2004, 10, 4), chartTime(2004, 10, 11), chartTime(
2004, 11, 8), chartTime(2004, 11, 8), chartTime(2004, 11, 22), chartTime(
2004, 11, 22)};
// the actual start dates and end dates for the tasks up to now
double actualStartDate[] = {chartTime(2004, 8, 16), chartTime(2004, 8, 27),
chartTime(2004, 9, 9), chartTime(2004, 9, 18), chartTime(2004, 9, 22)};
double actualEndDate[] = {chartTime(2004, 8, 27), chartTime(2004, 9, 9),
chartTime(2004, 9, 27), chartTime(2004, 10, 2), chartTime(2004, 10, 8)};
// Create a XYChart object of size 620 x 280 pixels. Set background color to
// light green (ccffcc) with 1 pixel 3D border effect.
XYChart *c = new XYChart(620, 280, 0xccffcc, 0x000000, 1);
// Add a title to the chart using 15 points Times Bold Itatic font, with white
// (ffffff) text on a dark green (0x6000) background
c->addTitle("Mutli-Layer Gantt Chart Demo", "timesbi.ttf", 15, 0xffffff
)->setBackground(0x006000);
// Set the plotarea at (140, 55) and of size 460 x 200 pixels. Use alternative
// white/grey background. Enable both horizontal and vertical grids by setting
// their colors to grey (c0c0c0). Set vertical major grid (represents month
// boundaries) 2 pixels in width
c->setPlotArea(140, 55, 460, 200, 0xffffff, 0xeeeeee, Chart::LineColor, 0xc0c0c0,
0xc0c0c0)->setGridWidth(2, 1, 1, 1);
// swap the x and y axes to create a horziontal box-whisker chart
c->swapXY();
// Set the y-axis scale to be date scale from Aug 16, 2004 to Nov 22, 2004, with
// ticks every 7 days (1 week)
c->yAxis()->setDateScale(chartTime(2004, 8, 16), chartTime(2004, 11, 22), 86400 *
7);
// Add a red (ff0000) dash line to represent the current day
c->yAxis()->addMark(chartTime(2004, 10, 8), c->dashLineColor(0xff0000,
Chart::DashLine));
// Set multi-style axis label formatting. Month labels are in Arial Bold font in
// "mmm d" format. Weekly labels just show the day of month and use minor tick
// (by using '-' as first character of format string).
c->yAxis()->setMultiFormat(Chart::StartOfMonthFilter(),
"<*font=arialbd.ttf*>{value|mmm d}", Chart::StartOfDayFilter(), "-{value|d}")
;
// Set the y-axis to shown on the top (right + swapXY = top)
c->setYAxisOnRight();
// Set the labels on the x axis
c->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
// Reverse the x-axis scale so that it points downwards.
c->xAxis()->setReverse();
// Set the horizontal ticks and grid lines to be between the bars
c->xAxis()->setTickOffset(0.5);
// Use blue (0000aa) as the color for the planned schedule
int plannedColor = 0x0000aa;
// Use a red hash pattern as the color for the actual dates. The pattern is
// created as a 4 x 4 bitmap defined in memory as an array of colors.
int pattern1[] = {0xffffff, 0xffffff, 0xffffff, 0xff0000, 0xffffff, 0xffffff,
0xff0000, 0xffffff, 0xffffff, 0xff0000, 0xffffff, 0xffffff, 0xff0000,
0xffffff, 0xffffff, 0xffffff};
int actualColor = c->patternColor(IntArray(pattern1,
sizeof(pattern1)/sizeof(pattern1[0])), 4);
// Add a box whisker layer to represent the actual dates. We add the actual dates
// layer first, so it will be the top layer.
BoxWhiskerLayer *actualLayer = c->addBoxLayer(DoubleArray(actualStartDate,
sizeof(actualStartDate)/sizeof(actualStartDate[0])), DoubleArray(
actualEndDate, sizeof(actualEndDate)/sizeof(actualEndDate[0])), actualColor,
"Actual");
// Set the bar height to 8 pixels so they will not block the bottom bar
actualLayer->setDataWidth(8);
// Add a box-whisker layer to represent the planned schedule date
c->addBoxLayer(DoubleArray(startDate, sizeof(startDate)/sizeof(startDate[0])),
DoubleArray(endDate, sizeof(endDate)/sizeof(endDate[0])), plannedColor,
"Planned")->setBorderColor(Chart::SameAsMainColor);
// Add a legend box on the top right corner (595, 60) of the plot area with 8 pt
// Arial Bold font. Use a semi-transparent grey (80808080) background.
LegendBox *b = c->addLegend(595, 60, false, "arialbd.ttf", 8);
b->setAlignment(Chart::TopRight);
b->setBackground(0x80808080, -1, 2);
// output the chart
c->makeChart("layergantt.png");
//free up resources
delete c;
return 0;
}
void PrescribedGradientBCWeak :: assembleGPContrib(SparseMtrx &answer, TimeStep *tStep,
CharType type, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s, TracSegArray &iEl, GaussPoint &iGP)
{
SpatialLocalizer *localizer = domain->giveSpatialLocalizer();
///////////////
// Gamma_plus
FloatMatrix contrib;
assembleTangentGPContributionNew(contrib, iEl, iGP, -1.0, iGP.giveGlobalCoordinates());
// Compute vector of traction unknowns
FloatArray tracUnknowns;
iEl.mFirstNode->giveUnknownVector(tracUnknowns, giveTracDofIDs(), VM_Total, tStep);
IntArray trac_rows;
iEl.giveTractionLocationArray(trac_rows, type, r_s);
FloatArray dispElLocCoord, closestPoint;
Element *dispEl = localizer->giveElementClosestToPoint(dispElLocCoord, closestPoint, iGP.giveGlobalCoordinates() );
IntArray disp_cols;
dispEl->giveLocationArray(disp_cols, c_s);
answer.assemble(trac_rows, disp_cols, contrib);
FloatMatrix contribT;
contribT.beTranspositionOf(contrib);
answer.assemble(disp_cols, trac_rows, contribT);
///////////////
// Gamma_minus
contrib.clear();
FloatArray xMinus;
this->giveMirroredPointOnGammaMinus(xMinus, iGP.giveGlobalCoordinates() );
assembleTangentGPContributionNew(contrib, iEl, iGP, 1.0, xMinus);
// Compute vector of traction unknowns
tracUnknowns.clear();
iEl.mFirstNode->giveUnknownVector(tracUnknowns, giveTracDofIDs(), VM_Total, tStep);
trac_rows.clear();
iEl.giveTractionLocationArray(trac_rows, type, r_s);
dispElLocCoord.clear(); closestPoint.clear();
dispEl = localizer->giveElementClosestToPoint(dispElLocCoord, closestPoint, xMinus );
disp_cols.clear();
dispEl->giveLocationArray(disp_cols, c_s);
answer.assemble(trac_rows, disp_cols, contrib);
contribT.clear();
contribT.beTranspositionOf(contrib);
answer.assemble(disp_cols, trac_rows, contribT);
// Assemble zeros on diagonal (required by PETSc solver)
FloatMatrix KZero(1,1);
KZero.zero();
for( int i : trac_rows) {
answer.assemble(IntArray({i}), IntArray({i}), KZero);
}
}
BaseChart * CDefineChart::showHistogram()
{
/*
// The data for the bar chart
double data[] = {450, 560, 630, 800, 1100, 1350, 1600, 1950, 2300, 700};
// The labels for the bar chart
const char *labels[] = {"项目1", "项目2", "1998", "1999", "2000", "2001", "2002",
"2003", "2004", "2005"};
*/
// Create a XYChart object of size 600 x 380 pixels. Set background color to
// brushed silver, with a 2 pixel 3D border. Use rounded corners of 20 pixels
// radius.
m_xychart = new XYChart(700, 480);
//XYChart *c = new XYChart(600, 380, Chart::brushedSilverColor(),Chart::Transparent, 2);
// Add a title to the chart using 18pts Times Bold Italic font. Set top/bottom
// margins to 8 pixels.
//c->setDefaultFonts("simsun.ttc", "simsun.ttc", "simsun.ttc", "simsun.ttc");
m_xychart->setDefaultFonts("mingliu.ttc", "mingliu.ttc Bold");
//QByteArray str=QString("柱形图统计表").toUtf8();
m_xychart->addTitle("柱形图统计表","mingliu.ttc Bold",18)->setMargin(0,0,8,8);
//c->addTitle("柱形图统计表","timesbi.ttf",18)->setMargin(0, 0,
// 8, 8);
// Set the plotarea at (70, 55) and of size 460 x 280 pixels. Use transparent
// border and black grid lines. Use rounded frame with radius of 20 pixels.
m_xychart->setPlotArea(70, 55, 560, 380, -1, -1, Chart::Transparent, 0x000000);
m_xychart->setRoundedFrame(0xffffff, 20);
// Add a multi-color bar chart layer using the supplied data. Set cylinder bar
// shape.
m_xychart->addBarLayer(DoubleArray(data, sizeof(data)/sizeof(data[0])), IntArray(0, 0)
)->setBarShape(Chart::CircleShape);
// Set the labels on the x axis.
m_xychart->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
//c->xAxis()->setLabels(labels);
// Show the same scale on the left and right y-axes
m_xychart->syncYAxis();
// Set the left y-axis and right y-axis title using 10pt Arial Bold font
//c->yAxis()->setTitle("USD (millions)", "arialbd.ttf", 10);
//c->yAxis2()->setTitle("USD (millions)", "arialbd.ttf", 10);
// Set y-axes to transparent
m_xychart->yAxis()->setColors(Chart::Transparent);
m_xychart->yAxis2()->setColors(Chart::Transparent);
// Disable ticks on the x-axis by setting the tick color to transparent
m_xychart->xAxis()->setTickColor(Chart::Transparent);
// Set the label styles of all axes to 8pt Arial Bold font
//c->xAxis()->setLabelStyle("arialbd.ttf", 8);
//c->yAxis()->setLabelStyle("arialbd.ttf", 8);
//c->yAxis2()->setLabelStyle("arialbd.ttf", 8);
m_xychart->makeChart();
return m_xychart;
}
IntArray USB_DIO_32_Family::getSupportedProductIDs() {
initialize();
return IntArray( supportedProductIDs );
} // USB_DIO_32_Family::getSupportedProductIDs()
void HangingNode :: postInitialize()
{
Node :: postInitialize();
Element *e;
FEInterpolation *fei;
FloatArray lcoords, masterContribution;
#ifdef __OOFEG
if ( initialized ) {
return;
}
initialized = true;
#endif
// First check element and interpolation
if ( masterElement == -1 ) { // Then we find it by taking the closest (probably containing element)
FloatArray closest;
SpatialLocalizer *sp = this->domain->giveSpatialLocalizer();
sp->init();
// Closest point or containing point? It should be contained, but with numerical errors it might be slightly outside
// so the closest point is more robust.
if ( !( e = sp->giveElementClosestToPoint(lcoords, closest, coordinates, this->masterRegion) ) ) {
OOFEM_ERROR("Couldn't find closest element (automatically).");
}
this->masterElement = e->giveNumber();
} else if ( !( e = this->giveDomain()->giveElement(this->masterElement) ) ) {
OOFEM_ERROR("Requested element %d doesn't exist.", this->masterElement);
}
if ( !( fei = e->giveInterpolation() ) ) {
OOFEM_ERROR("Requested element %d doesn't have a interpolator.", this->masterElement);
}
if ( lcoords.giveSize() == 0 ) { // we don't need to do this again if the spatial localizer was used.
fei->global2local( lcoords, coordinates, FEIElementGeometryWrapper(e) );
}
// Initialize slave dofs (inside check of consistency of receiver and master dof)
const IntArray &masterNodes = e->giveDofManArray();
for ( Dof *dof: *this ) {
SlaveDof *sdof = dynamic_cast< SlaveDof * >(dof);
if ( sdof ) {
DofIDItem id = sdof->giveDofID();
fei = e->giveInterpolation(id);
if ( !fei ) {
OOFEM_ERROR("Requested interpolation for dof id %d doesn't exist in element %d.",
id, this->masterElement);
}
#if 0 // This won't work (yet), as it requires some more general FEI classes, or something similar.
if ( fei->hasMultiField() ) {
FloatMatrix multiContribution;
IntArray masterDofIDs, masterNodesDup, dofids;
fei->evalMultiN(multiContribution, dofids, lcoords, FEIElementGeometryWrapper(e), 0.0);
masterContribution.flatten(multiContribution);
masterDofIDs.clear();
for ( int i = 0; i <= multiContribution.giveNumberOfColumns(); ++i ) {
masterDofIDs.followedBy(dofids);
masterNodesDup.followedBy(masterNodes);
}
sdof->initialize(masterNodesDup, & masterDofIDs, masterContribution);
} else { }
#else
// Note: There can be more masterNodes than masterContributions, since all the
// FEI classes are based on that the first nodes correspond to the simpler/linear interpolation.
// If this assumption is changed in FEIElementGeometryWrapper + friends,
// masterNode will also need to be modified for each dof accordingly.
fei->evalN( masterContribution, lcoords, FEIElementGeometryWrapper(e) );
sdof->initialize(masterNodes, IntArray(), masterContribution);
#endif
}
}
}
int main(int argc, char *argv[])
{
// The data for the pie chart
double data[] = {21, 18, 15, 12, 8, 24};
// The labels for the pie chart
const char *labels[] = {"Labor", "Licenses", "Taxes", "Legal", "Facilities", "Production"};
// The colors to use for the sectors
int colors[] = {0x66aaee, 0xeebb22, 0xbbbbbb, 0x8844ff, 0xdd2222, 0x009900};
// Create a PieChart object of size 600 x 320 pixels. Use a vertical gradient color from light
// blue (99ccff) to white (ffffff) spanning the top 100 pixels as background. Set border to grey
// (888888). Use rounded corners. Enable soft drop shadow.
PieChart *c = new PieChart(600, 320);
c->setBackground(c->linearGradientColor(0, 0, 0, 100, 0x99ccff, 0xffffff), 0x888888);
c->setRoundedFrame();
c->setDropShadow();
// Add a title using 18pt Times New Roman Bold Italic font. Add 16 pixels top margin to the
// title.
c->addTitle("Pie Chart With Legend Demonstration", "timesbi.ttf", 18)->setMargin(0, 0, 16, 0);
// Set the center of the pie at (160, 165) and the radius to 110 pixels
c->setPieSize(160, 165, 110);
// Draw the pie in 3D with a pie thickness of 25 pixels
c->set3D(25);
// Set the pie data and the pie labels
c->setData(DoubleArray(data, (int)(sizeof(data) / sizeof(data[0]))), StringArray(labels, (int)(
sizeof(labels) / sizeof(labels[0]))));
// Set the sector colors
c->setColors(Chart::DataColor, IntArray(colors, (int)(sizeof(colors) / sizeof(colors[0]))));
// Use local gradient shading for the sectors
c->setSectorStyle(Chart::LocalGradientShading);
// Use the side label layout method, with the labels positioned 16 pixels from the pie bounding
// box
c->setLabelLayout(Chart::SideLayout, 16);
// Show only the sector number as the sector label
c->setLabelFormat("{={sector}+1}");
// Set the sector label style to Arial Bold 10pt, with a dark grey (444444) border
c->setLabelStyle("arialbd.ttf", 10)->setBackground(Chart::Transparent, 0x444444);
// Add a legend box, with the center of the left side anchored at (330, 175), and using 10pt
// Arial Bold Italic font
LegendBox *b = c->addLegend(330, 175, true, "arialbi.ttf", 10);
b->setAlignment(Chart::Left);
// Set the legend box border to dark grey (444444), and with rounded conerns
b->setBackground(Chart::Transparent, 0x444444);
b->setRoundedCorners();
// Set the legend box margin to 16 pixels, and the extra line spacing between the legend entries
// as 5 pixels
b->setMargin(16);
b->setKeySpacing(0, 5);
// Set the legend box icon to have no border (border color same as fill color)
b->setKeyBorder(Chart::SameAsMainColor);
// Set the legend text to show the sector number, followed by a 120 pixels wide block showing
// the sector label, and a 40 pixels wide block showing the percentage
b->setText(
"<*block,valign=top*>{={sector}+1}.<*advanceTo=22*><*block,width=120*>{label}<*/*>"
"<*block,width=40,halign=right*>{percent}<*/*>%");
// Output the chart
c->makeChart("legendpie2.png");
//free up resources
delete c;
return 0;
}
int main(int argc, char *argv[])
{
// The data for the bar chart
double data[] = {85, 156, 179.5, 211, 123, 176, 195};
// The labels for the bar chart
const char *labels[] = {"Square", "Star(8)", "Polygon(6)", "Cross", "Cross2",
"Diamond", "Custom"};
// Create a XYChart object of size 500 x 280 pixels.
XYChart *c = new XYChart(500, 280);
// Set the plotarea at (50, 40) with alternating light grey (f8f8f8) / white
// (ffffff) background
c->setPlotArea(50, 40, 400, 200, 0xf8f8f8, 0xffffff);
// Add a title to the chart using 14 pts Arial Bold Italic font
c->addTitle(" Bar Shape Demonstration", "arialbi.ttf", 14);
// Add a multi-color bar chart layer
BarLayer *layer = c->addBarLayer(DoubleArray(data, sizeof(data)/sizeof(data[0])),
IntArray(0, 0));
// Set layer to 3D with 10 pixels 3D depth
layer->set3D(10);
// Set bar shape to circular (cylinder)
layer->setBarShape(Chart::CircleShape);
// Set the first bar (index = 0) to square shape
layer->setBarShape(Chart::SquareShape, 0, 0);
// Set the second bar to 8-pointed star
layer->setBarShape(Chart::StarShape(8), 0, 1);
// Set the third bar to 6-sided polygon
layer->setBarShape(Chart::PolygonShape(6), 0, 2);
// Set the next 3 bars to cross shape, X shape and diamond shape
layer->setBarShape(Chart::CrossShape(), 0, 3);
layer->setBarShape(Chart::Cross2Shape(), 0, 4);
layer->setBarShape(Chart::DiamondShape, 0, 5);
// Set the last bar to a custom shape, specified as an array of (x, y) points in
// normalized coordinates
int pattern1[] = {-500, 0, 0, 500, 500, 0, 500, 1000, 0, 500, -500, 1000};
layer->setBarShape(IntArray(pattern1, sizeof(pattern1)/sizeof(pattern1[0])), 0, 6
);
// Set the labels on the x axis.
c->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
// Add a title to the y axis
c->yAxis()->setTitle("Frequency");
// Add a title to the x axis
c->xAxis()->setTitle("Shapes");
// output the chart
c->makeChart("polygonbar.png");
//free up resources
delete c;
return 0;
}
int main(int argc, char *argv[])
{
// The data for the chart
double data[] = {40, 15, 7, 5, 2};
// The labels for the chart
const char *labels[] = {"Hard Disk", "PCB", "Printer", "CDROM", "Keyboard"};
// In the pareto chart, the line data are just the accumulation of the raw data,
// scaled to a range of 0 - 100%
ArrayMath lineData = ArrayMath(DoubleArray(data, sizeof(data)/sizeof(data[0])));
lineData.acc();
double scaleFactor = lineData.max() / 100;
if (scaleFactor == 0) {
// Avoid division by zero error for zero data
scaleFactor = 1;
}
lineData.div(scaleFactor);
// Create a XYChart object of size 480 x 300 pixels. Set background color to
// brushed silver, with a grey (bbbbbb) border and 2 pixel 3D raised effect. Use
// rounded corners. Enable soft drop shadow.
XYChart *c = new XYChart(400, 300, Chart::brushedSilverColor(), 0xbbbbbb, 2);
c->setRoundedFrame();
c->setDropShadow();
// Add a title to the chart using 15 points Arial Italic. Set top/bottom margins
// to 12 pixels.
TextBox *title = c->addTitle("Pareto Chart Demonstration", "ariali.ttf", 15);
title->setMargin(0, 0, 12, 12);
// Tentatively set the plotarea at (50, 40). Set the width to 100 pixels less
// than the chart width, and the height to 80 pixels less than the chart height.
// Use pale grey (f4f4f4) background, transparent border, and dark grey (444444)
// dotted grid lines.
c->setPlotArea(50, 40, c->getWidth() - 100, c->getHeight() - 80, 0xf4f4f4, -1,
Chart::Transparent, c->dashLineColor(0x444444, Chart::DotLine));
// Add a line layer for the pareto line
LineLayer *lineLayer = c->addLineLayer();
// Add the pareto line using deep blue (0000ff) as the color, with circle symbols
lineLayer->addDataSet(lineData.result(), 0x0000ff)->setDataSymbol(
Chart::CircleShape, 9, 0x0000ff, 0x0000ff);
// Set the line width to 2 pixel
lineLayer->setLineWidth(2);
// Bind the line layer to the secondary (right) y-axis.
lineLayer->setUseYAxis2();
// Add a multi-color bar layer using the given data.
BarLayer *barLayer = c->addBarLayer(DoubleArray(data,
sizeof(data)/sizeof(data[0])), IntArray(0, 0));
// Set soft lighting for the bars with light direction from the right
barLayer->setBorderColor(Chart::Transparent, Chart::softLighting(Chart::Right));
// Set the labels on the x axis.
c->xAxis()->setLabels(StringArray(labels, sizeof(labels)/sizeof(labels[0])));
// Set the secondary (right) y-axis scale as 0 - 100 with a tick every 20 units
c->yAxis2()->setLinearScale(0, 100, 20);
// Set the format of the secondary (right) y-axis label to include a percentage
// sign
c->yAxis2()->setLabelFormat("{value}%");
// Set the relationship between the two y-axes, which only differ by a scaling
// factor
c->yAxis()->syncAxis(c->yAxis2(), scaleFactor);
// Set the format of the primary y-axis label foramt to show no decimal point
c->yAxis()->setLabelFormat("{value|0}");
// Add a title to the primary y-axis
c->yAxis()->setTitle("Frequency");
// Set all axes to transparent
c->xAxis()->setColors(Chart::Transparent);
c->yAxis()->setColors(Chart::Transparent);
c->yAxis2()->setColors(Chart::Transparent);
// Adjust the plot area size, such that the bounding box (inclusive of axes) is
// 10 pixels from the left edge, just below the title, 10 pixels from the right
// edge, and 20 pixels from the bottom edge.
c->packPlotArea(10, title->getHeight(), c->getWidth() - 10, c->getHeight() - 20);
// Output the chart
c->makeChart("pareto.jpg");
//free up resources
delete c;
return 0;
}
/**
Provides a copy of the specified element.
@param aId The element identifier.
@param aValue On successful completion, a copy of the element value.
@panic CMTPMetaData 0 In debug builds, if the specified element is not of
the requested type.
@leave One of the system wide error codes, if a processing failure occurs.
*/
EXPORT_C void CMTPMetaData::GetIntArrayL(TUint aId, RArray<TInt>& aValue)
{
__ASSERT_DEBUG((iElements[aId].iType == EUintArray), Panic(EPanicTypeMismatch));
CopyL(IntArray(aId), aValue);
}
namespace oofem {
// Set up interpolation coordinates
FEI2dTrLin Tr21Stokes :: interpolation_lin(1, 2);
FEI2dTrQuad Tr21Stokes :: interpolation_quad(1, 2);
// Set up ordering vectors (for assembling)
IntArray Tr21Stokes :: ordering(15);
IntArray Tr21Stokes :: edge_ordering [ 3 ] = {
IntArray(6), IntArray(6), IntArray(6)
};
bool Tr21Stokes :: __initialized = Tr21Stokes :: initOrdering();
Tr21Stokes :: Tr21Stokes(int n, Domain *aDomain) : FMElement(n, aDomain)
{
this->numberOfDofMans = 6;
if (aDomain->giveEngngModel()->giveProblemScale() == macroScale) // Pick the lowest default value for multiscale computations.
this->numberOfGaussPoints = 3;
else
this->numberOfGaussPoints = 4;
this->computeGaussPoints();
}
Tr21Stokes :: ~Tr21Stokes()
{}
IRResultType Tr21Stokes :: initializeFrom(InputRecord *ir)
{
this->FMElement :: initializeFrom(ir);
return IRRT_OK;
}
void Tr21Stokes :: computeGaussPoints()
{
if ( !integrationRulesArray ) {
numberOfIntegrationRules = 1;
integrationRulesArray = new IntegrationRule * [ 2 ];
integrationRulesArray [ 0 ] = new GaussIntegrationRule(1, this, 1, 3);
integrationRulesArray [ 0 ]->setUpIntegrationPoints(_Triangle, this->numberOfGaussPoints, _2dFlow);
}
}
int Tr21Stokes :: computeNumberOfDofs(EquationID ut)
{
if ( ut == EID_MomentumBalance_ConservationEquation ) {
return 15;
} else if ( ut == EID_MomentumBalance ) {
return 12;
} else if ( ut == EID_ConservationEquation ) {
return 3;
} else {
OOFEM_ERROR("computeNumberOfDofs: Unknown equation id encountered");
}
return 0;
}
void Tr21Stokes :: giveDofManDofIDMask(int inode, EquationID ut, IntArray &answer) const
{
// Returns the mask for node number inode of this element. The mask tells what quantities
// are held by each node. Since this element holds velocities (both in x and y direction),
// in six nodes and pressure in three nodes the answer depends on which node is requested.
if ( ( inode == 1 ) || ( inode == 2 ) || ( inode == 3 ) ) {
if ( ( ut == EID_MomentumBalance ) || ( ut == EID_AuxMomentumBalance ) ) {
answer.setValues(2, V_u, V_v);
} else if ( ut == EID_ConservationEquation ) {
answer.setValues(1, P_f);
} else if ( ut == EID_MomentumBalance_ConservationEquation ) {
answer.setValues(3, V_u, V_v, P_f);
} else {
_error("giveDofManDofIDMask: Unknown equation id encountered");
}
} else if ( ( inode == 4 ) || ( inode == 5 ) || ( inode == 6 ) ) {
if ( ( ut == EID_MomentumBalance ) || ( ut == EID_AuxMomentumBalance ) ) {
answer.setValues(2, V_u, V_v);
} else if ( ut == EID_ConservationEquation ) {
answer.resize(0);
} else if ( ut == EID_MomentumBalance_ConservationEquation ) {
answer.setValues(2, V_u, V_v);
} else {
_error("giveDofManDofIDMask: Unknown equation id encountered");
}
}
}
double Tr21Stokes :: computeVolumeAround(GaussPoint *gp)
{
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(*gp->giveCoordinates(), FEIElementGeometryWrapper(this)));
return detJ * gp->giveWeight();
}
void Tr21Stokes :: giveCharacteristicVector(FloatArray &answer, CharType mtrx, ValueModeType mode,
TimeStep *tStep)
{
// Compute characteristic vector for this element. I.e the load vector(s)
if ( mtrx == ExternalForcesVector ) {
this->computeLoadVector(answer, tStep);
} else if ( mtrx == InternalForcesVector ) {
this->computeInternalForcesVector(answer, tStep);
} else {
OOFEM_ERROR("giveCharacteristicVector: Unknown Type of characteristic mtrx.");
}
}
void Tr21Stokes :: giveCharacteristicMatrix(FloatMatrix &answer,
CharType mtrx, TimeStep *tStep)
{
// Compute characteristic matrix for this element. The only option is the stiffness matrix...
if ( mtrx == StiffnessMatrix ) {
this->computeStiffnessMatrix(answer, tStep);
} else {
OOFEM_ERROR("giveCharacteristicMatrix: Unknown Type of characteristic mtrx.");
}
}
void Tr21Stokes :: computeInternalForcesVector(FloatArray &answer, TimeStep *tStep)
{
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FluidDynamicMaterial *mat = ( FluidDynamicMaterial * ) this->domain->giveMaterial(this->material);
FloatArray a_pressure, a_velocity, devStress, epsp, BTs, Nh, dNv(12);
double r_vol, pressure;
FloatMatrix dN, B(3, 12);
B.zero();
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, a_velocity);
this->computeVectorOf(EID_ConservationEquation, VM_Total, tStep, a_pressure);
FloatArray momentum(12), conservation(3);
momentum.zero();
conservation.zero();
GaussPoint *gp;
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
FloatArray *lcoords = gp->giveCoordinates();
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)));
this->interpolation_quad.evaldNdx(dN, * lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(Nh, * lcoords, FEIElementGeometryWrapper(this));
double dA = detJ * gp->giveWeight();
for ( int j = 0, k = 0; j < 6; j++, k += 2 ) {
dNv(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dNv(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
pressure = Nh.dotProduct(a_pressure);
epsp.beProductOf(B, a_velocity);
mat->computeDeviatoricStressVector(devStress, r_vol, gp, epsp, pressure, tStep);
BTs.beTProductOf(B, devStress);
momentum.add(dA, BTs);
momentum.add(-pressure*dA, dNv);
conservation.add(r_vol*dA, Nh);
}
FloatArray temp(15);
temp.zero();
temp.addSubVector(momentum, 1);
temp.addSubVector(conservation, 13);
answer.resize(15);
answer.zero();
answer.assemble(temp, this->ordering);
}
void Tr21Stokes :: computeLoadVector(FloatArray &answer, TimeStep *tStep)
{
int i, load_number, load_id;
Load *load;
bcGeomType ltype;
FloatArray vec;
int nLoads = this->boundaryLoadArray.giveSize() / 2;
answer.resize(15);
answer.zero();
for ( i = 1; i <= nLoads; i++ ) { // For each Neumann boundary condition
load_number = this->boundaryLoadArray.at(2 * i - 1);
load_id = this->boundaryLoadArray.at(2 * i);
load = this->domain->giveLoad(load_number);
ltype = load->giveBCGeoType();
if ( ltype == EdgeLoadBGT ) {
this->computeEdgeBCSubVectorAt(vec, load, load_id, tStep);
answer.add(vec);
}
}
nLoads = this->giveBodyLoadArray()->giveSize();
for ( i = 1; i <= nLoads; i++ ) {
load = domain->giveLoad( bodyLoadArray.at(i) );
ltype = load->giveBCGeoType();
if ( ltype == BodyLoadBGT && load->giveBCValType() == ForceLoadBVT ) {
this->computeBodyLoadVectorAt(vec, load, tStep);
answer.add(vec);
}
}
}
void Tr21Stokes :: computeBodyLoadVectorAt(FloatArray &answer, Load *load, TimeStep *tStep)
{
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
GaussPoint *gp;
FloatArray N, gVector, *lcoords, temparray(15);
double dA, detJ, rho;
load->computeComponentArrayAt(gVector, tStep, VM_Total);
temparray.zero();
if ( gVector.giveSize() ) {
for ( int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
gp = iRule->getIntegrationPoint(k);
lcoords = gp->giveCoordinates();
rho = this->giveMaterial()->giveCharacteristicValue(MRM_Density, gp, tStep);
detJ = fabs( this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)) );
dA = detJ * gp->giveWeight();
this->interpolation_quad.evalN(N, * lcoords, FEIElementGeometryWrapper(this));
for ( int j = 0; j < 6; j++ ) {
temparray(2 * j) += N(j) * rho * gVector(0) * dA;
temparray(2 * j + 1) += N(j) * rho * gVector(1) * dA;
}
}
}
answer.resize(15);
answer.zero();
answer.assemble( temparray, this->ordering );
}
void Tr21Stokes :: computeEdgeBCSubVectorAt(FloatArray &answer, Load *load, int iEdge, TimeStep *tStep)
{
answer.resize(15);
answer.zero();
if ( load->giveType() == TransmissionBC ) { // Neumann boundary conditions (traction)
BoundaryLoad *boundaryLoad = ( BoundaryLoad * ) load;
int numberOfEdgeIPs = ( int ) ceil( ( boundaryLoad->giveApproxOrder() + 1. ) / 2. ) * 2;
GaussIntegrationRule iRule(1, this, 1, 1);
GaussPoint *gp;
FloatArray N, t, f(6);
IntArray edge_mapping;
f.zero();
iRule.setUpIntegrationPoints(_Line, numberOfEdgeIPs, _Unknown);
for ( int i = 0; i < iRule.getNumberOfIntegrationPoints(); i++ ) {
gp = iRule.getIntegrationPoint(i);
FloatArray *lcoords = gp->giveCoordinates();
this->interpolation_quad.edgeEvalN(N, * lcoords, FEIElementGeometryWrapper(this));
double detJ = fabs(this->interpolation_quad.edgeGiveTransformationJacobian(iEdge, * lcoords, FEIElementGeometryWrapper(this)));
double dS = gp->giveWeight() * detJ;
if ( boundaryLoad->giveFormulationType() == BoundaryLoad :: BL_EntityFormulation ) { // Edge load in xi-eta system
boundaryLoad->computeValueAt(t, tStep, * lcoords, VM_Total);
} else { // Edge load in x-y system
FloatArray gcoords;
this->interpolation_quad.edgeLocal2global(gcoords, iEdge, * lcoords, FEIElementGeometryWrapper(this));
boundaryLoad->computeValueAt(t, tStep, gcoords, VM_Total);
}
// Reshape the vector
for ( int j = 0; j < 3; j++ ) {
f(2 * j) += N(j) * t(0) * dS;
f(2 * j + 1) += N(j) * t(1) * dS;
}
}
answer.assemble(f, this->edge_ordering [ iEdge - 1 ]);
} else {
OOFEM_ERROR("Tr21Stokes :: computeEdgeBCSubVectorAt - Strange boundary condition type");
}
}
void Tr21Stokes :: computeStiffnessMatrix(FloatMatrix &answer, TimeStep *tStep)
{
// Note: Working with the components; [K, G+Dp; G^T+Dv^T, C] . [v,p]
FluidDynamicMaterial *mat = ( FluidDynamicMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
GaussPoint *gp;
FloatMatrix B(3, 12), EdB, K(12,12), G, Dp, DvT, C, Ed, dN;
FloatArray *lcoords, dN_V(12), Nlin, Ep, Cd, tmpA, tmpB;
double Cp;
K.zero();
G.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
// Compute Gauss point and determinant at current element
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)));
double dA = detJ * gp->giveWeight();
this->interpolation_quad.evaldNdx(dN, * lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(Nlin, * lcoords, FEIElementGeometryWrapper(this));
for ( int j = 0, k = 0; j < 6; j++, k += 2 ) {
dN_V(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dN_V(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
// Computing the internal forces should have been done first.
mat->giveDeviatoricStiffnessMatrix(Ed, TangentStiffness, gp, tStep); // dsigma_dev/deps_dev
mat->giveDeviatoricPressureStiffness(Ep, TangentStiffness, gp, tStep); // dsigma_dev/dp
mat->giveVolumetricDeviatoricStiffness(Cd, TangentStiffness, gp, tStep); // deps_vol/deps_dev
mat->giveVolumetricPressureStiffness(Cp, TangentStiffness, gp, tStep); // deps_vol/dp
EdB.beProductOf(Ed,B);
K.plusProductSymmUpper(B, EdB, dA);
G.plusDyadUnsym(dN_V, Nlin, -dA);
C.plusDyadSymmUpper(Nlin, Nlin, Cp*dA);
tmpA.beTProductOf(B, Ep);
Dp.plusDyadUnsym(tmpA, Nlin, dA);
tmpB.beTProductOf(B, Cd);
DvT.plusDyadUnsym(Nlin, tmpB, dA);
}
K.symmetrized();
C.symmetrized();
FloatMatrix GTDvT, GDp;
GTDvT.beTranspositionOf(G);
GTDvT.add(DvT);
GDp = G;
GDp.add(Dp);
FloatMatrix temp(15, 15);
temp.setSubMatrix(K, 1, 1);
temp.setSubMatrix(GTDvT, 13, 1);
temp.setSubMatrix(GDp, 1, 13);
temp.setSubMatrix(C, 13, 13);
answer.resize(15, 15);
answer.zero();
answer.assemble(temp, this->ordering);
}
FEInterpolation *Tr21Stokes :: giveInterpolation()
{
return &interpolation_quad;
}
FEInterpolation *Tr21Stokes :: giveInterpolation(DofIDItem id)
{
if (id == P_f) return &interpolation_lin; else return &interpolation_quad;
}
void Tr21Stokes :: updateYourself(TimeStep *tStep)
{
Element :: updateYourself(tStep);
}
// Some extension Interfaces to follow:
Interface *Tr21Stokes :: giveInterface(InterfaceType it)
{
switch (it) {
case NodalAveragingRecoveryModelInterfaceType:
return static_cast< NodalAveragingRecoveryModelInterface * >(this);
case ZZNodalRecoveryModelInterfaceType:
return static_cast< ZZNodalRecoveryModelInterface * >(this);
case SpatialLocalizerInterfaceType:
return static_cast< SpatialLocalizerInterface * >(this);
case EIPrimaryUnknownMapperInterfaceType:
return static_cast< EIPrimaryUnknownMapperInterface * >(this);
default:
return FMElement :: giveInterface(it);
}
}
int Tr21Stokes :: SpatialLocalizerI_containsPoint(const FloatArray &coords)
{
FloatArray lcoords;
return this->computeLocalCoordinates(lcoords, coords);
}
void Tr21Stokes :: EIPrimaryUnknownMI_computePrimaryUnknownVectorAtLocal(ValueModeType mode,
TimeStep *tStep, const FloatArray &lcoords, FloatArray &answer)
{
FloatArray n, n_lin;
this->interpolation_quad.evalN(n, lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(n_lin, lcoords, FEIElementGeometryWrapper(this));
answer.resize(3);
answer.zero();
for (int i = 1; i <= n.giveSize(); i++) {
answer(0) += n.at(i)*this->giveNode(i)->giveDofWithID(V_u)->giveUnknown(EID_MomentumBalance_ConservationEquation, mode, tStep);
answer(1) += n.at(i)*this->giveNode(i)->giveDofWithID(V_v)->giveUnknown(EID_MomentumBalance_ConservationEquation, mode, tStep);
}
for (int i = 1; i <= n_lin.giveSize(); i++) {
answer(2) += n_lin.at(i)*this->giveNode(i)->giveDofWithID(P_f)->giveUnknown(EID_MomentumBalance_ConservationEquation, mode, tStep);
}
}
int Tr21Stokes :: EIPrimaryUnknownMI_computePrimaryUnknownVectorAt(ValueModeType mode, TimeStep *tStep, const FloatArray &gcoords, FloatArray &answer)
{
bool ok;
FloatArray lcoords, n, n_lin;
ok = this->computeLocalCoordinates(lcoords, gcoords);
if (!ok) {
answer.resize(0);
return false;
}
this->EIPrimaryUnknownMI_computePrimaryUnknownVectorAtLocal(mode, tStep, lcoords, answer);
return true;
}
void Tr21Stokes :: EIPrimaryUnknownMI_givePrimaryUnknownVectorDofID(IntArray &answer)
{
answer.setValues(3, V_u, V_v, P_f);
}
double Tr21Stokes :: SpatialLocalizerI_giveDistanceFromParametricCenter(const FloatArray &coords)
{
FloatArray center;
FloatArray lcoords;
lcoords.setValues(3, 0.333333, 0.333333, 0.333333);
interpolation_quad.local2global(center, lcoords, FEIElementGeometryWrapper(this));
return center.distance(coords);
}
void Tr21Stokes :: NodalAveragingRecoveryMI_computeSideValue(FloatArray &answer, int side, InternalStateType type, TimeStep *tStep)
{
answer.resize(0);
}
int Tr21Stokes :: NodalAveragingRecoveryMI_giveDofManRecordSize(InternalStateType type)
{
if ( type == IST_Pressure ) {
return 1;
}
return 0;
}
void Tr21Stokes :: NodalAveragingRecoveryMI_computeNodalValue(FloatArray &answer, int node, InternalStateType type, TimeStep *tStep)
{
if ( type == IST_Pressure ) {
answer.resize(1);
if ( node == 1 || node == 2 || node == 3 ) {
answer.at(1) = this->giveNode(node)->giveDofWithID(P_f)->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
} else {
double a, b;
if ( node == 4 ) {
a = this->giveNode(1)->giveDofWithID(P_f)->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
b = this->giveNode(2)->giveDofWithID(P_f)->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
} else if ( node == 5 ) {
a = this->giveNode(2)->giveDofWithID(P_f)->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
b = this->giveNode(3)->giveDofWithID(P_f)->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
} else /*if ( node == 6 )*/ {
a = this->giveNode(3)->giveDofWithID(P_f)->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
b = this->giveNode(1)->giveDofWithID(P_f)->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
}
answer.at(1) = ( a + b ) / 2;
}
} else {
answer.resize(0);
}
}
int Tr21Stokes :: ZZNodalRecoveryMI_giveDofManRecordSize(InternalStateType type)
{
GaussPoint *gp = integrationRulesArray [ 0 ]->getIntegrationPoint(0);
return this->giveIPValueSize(type, gp);
}
void Tr21Stokes :: giveGradP(FloatMatrix &answer, TimeStep * tStep )
{
/*
* Integrate gradient of P over element
*/
answer.resize(2,1);
answer.zero();
/*
GaussIntegrationRule iRuleEdge(1, this, 1, 1);
GaussPoint *gpEdge;
FloatArray Normal, N, *lcoords, p;
FloatMatrix temp, int_Np_edge;
iRuleEdge.setUpIntegrationPoints(_Line, this->numberOfGaussPoints, _Unknown);
this->computeVectorOf(EID_ConservationEquation, VM_Total, tStep, p);
answer.resize(2,1);
answer.zero();
for (int i=1; i<=integrationEdges->giveSize(); i++ ) {
int iEdge = integrationEdges->at(i);
givePressureGradientBoundaryIntegral(int_Np_edge, iEdge);
temp.resize(2,1);
temp.zero();
if (iEdge==1) {
temp.at(1,1)=int_Np_edge.at(1,1)*p.at(1)+int_Np_edge.at(1,2)*p.at(2);
temp.at(2,1)=int_Np_edge.at(2,1)*p.at(1)+int_Np_edge.at(2,2)*p.at(2);
} else if (iEdge==2) {
temp.at(1,1)=int_Np_edge.at(1,1)*p.at(2)+int_Np_edge.at(1,2)*p.at(3);
temp.at(2,1)=int_Np_edge.at(2,1)*p.at(2)+int_Np_edge.at(2,2)*p.at(3);
} else if (iEdge==3) {
temp.at(1,1)=int_Np_edge.at(1,1)*p.at(3)+int_Np_edge.at(1,2)*p.at(1);
temp.at(2,1)=int_Np_edge.at(2,1)*p.at(3)+int_Np_edge.at(2,2)*p.at(1);
} else {
printf ("iEdge != {1,2,3}\n");
}
answer.add(temp);
}
*/
}
void Tr21Stokes :: giveIntegratedVelocity(FloatMatrix &answer, TimeStep *tStep )
{
/*
* Integrate velocity over element
*/
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FloatMatrix v, v_gamma, ThisAnswer, boundaryV, Nmatrix;
double detJ;
FloatArray *lcoords, N;
int i, j, k=0;
Dof *d;
GaussPoint *gp;
v.resize(12,1);
v.zero();
boundaryV.resize(2,1);
for (i=1; i<=this->giveNumberOfDofManagers(); i++) {
for (j=1; j<=this->giveDofManager(i)->giveNumberOfDofs(); j++) {
d = this->giveDofManager(i)->giveDof(j);
if ((d->giveDofID()==V_u) || (d->giveDofID()==V_v)) {
k=k+1;
v.at(k,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
/*} else if (d->giveDofID()==A_x) {
boundaryV.at(1,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
} else if (d->giveDofID()==A_y) {
boundaryV.at(2,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);*/
}
}
}
answer.resize(2,1);
answer.zero();
Nmatrix.resize(2,12);
for (i=0; i<iRule->getNumberOfIntegrationPoints(); i++) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
this->interpolation_quad.evalN(N, *lcoords, FEIElementGeometryWrapper(this));
detJ = this->interpolation_quad.giveTransformationJacobian(*lcoords, FEIElementGeometryWrapper(this));
N.times(detJ*gp->giveWeight());
for (j=1; j<=6;j++) {
Nmatrix.at(1,j*2-1)=N.at(j);
Nmatrix.at(2,j*2)=N.at(j);
}
ThisAnswer.beProductOf(Nmatrix,v);
answer.add(ThisAnswer);
}
}
void Tr21Stokes :: giveElementFMatrix(FloatMatrix &answer)
{
IntegrationRule *iRule = integrationRulesArray [ 0 ];
GaussPoint *gp;
double detJ;
FloatArray N, N2, *lcoords;
IntArray col;
FloatMatrix temp;
N2.resize(6); N2.zero();
col.resize(2); col.at(1)=1; col.at(2)=2;
temp.resize(15,2);
temp.zero();
for (int i=0; i<iRule->getNumberOfIntegrationPoints(); i++) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
this->interpolation_quad.evalN(N, *lcoords, FEIElementGeometryWrapper(this));
detJ = this->interpolation_quad.giveTransformationJacobian(*lcoords, FEIElementGeometryWrapper(this));
N.times(gp->giveWeight()*detJ);
//N.printYourself();
N2.add(N);
}
for (int i=1; i<=6; i++) {
temp.at(i*2-1, 1)=N2.at(i);
temp.at(i*2, 2)=N2.at(i);
}
answer.resize(17,2);
answer.zero();
answer.assemble(temp, this->ordering, col);
}
} // end namespace oofem
//Pyramid 金字塔
QWidget * Widget::addPyramid()
{
// The data for the pyramid chart
double data[] = {156, 123, 211, 179};
// The labels for the pyramid chart
const char *labels[] = {"Funds", "Bonds", "Stocks", "Cash"};
// Create a PyramidChart object of size 360 x 360 pixels
PyramidChart *c = new PyramidChart(800, 800);
// Set the pyramid center at (180, 180), and width x height to 150 x 180 pixels
// c->setPyramidSize(180, 180, 150, 300);//设置金字塔
c->setConeSize(280, 180, 150, 300);//设置圆柱形
// Set the funnel center at (200, 210), and width x height to 150 x 300 pixels
// c->setFunnelSize(200, 210, 150, 300);//设置漏斗形状
// Set the pyramid data and labels
c->setData(DoubleArray(data, (int)(sizeof(data) / sizeof(data[0]))), StringArray(labels, (int)(
sizeof(labels) / sizeof(labels[0]))));
// Add labels at the center of the pyramid layers using Arial Bold font. The labels will have
// two lines showing the layer name and percentage.
c->setCenterLabel("{label}\n{percent}%", "arialbd.ttf");
// Set the elevation to 30 degrees.rotate 70
c->setViewAngle(30,70);
// The colors for the pyramid layers
int colors[] = {0x66aaee, 0xeebb22, 0xcccccc, 0xcc88ff};
// Set the layer colors to the given colors
c->setColors(Chart::DataColor, IntArray(colors, (int)(sizeof(colors) / sizeof(colors[0]))));
// Leave 1% gaps between layers
c->setLayerGap(0.01);
// Add labels at the center of the pyramid layers using Arial Bold font. The labels will show
// the percentage of the layers.
c->setCenterLabel("{percent}%", "arialbd.ttf");
// Add labels at the right side of the pyramid layers using Arial Bold font. The labels will
// have two lines showing the layer name and value.
c->setRightLabel("{label}\nUS$ {value}M", "arialbd.ttf");
//addBox
LegendBox *legendBox = c->addLegend(600, 60);
legendBox->setBackground(0xeeeeee, 0x888888);
legendBox->setRoundedCorners(10, 0, 10, 0);
// Add labels at the center of the pyramid layers using Arial Bold font. The labels will show
// the percentage of the layers.
c->setCenterLabel("{percent}%", "arialbd.ttf");
// Output the chart
c->makeChart("simplepyramid.png");
QWidget * _widget= new QWidget();
QChartViewer * _v= new QChartViewer(_widget);
_v->setChart(c);
return _widget;
}
