float *
avtR2Fvariance::FinalizePass(int pass)
{
float *rv = NULL;
if (pass == 0)
{
double *rt2 = new double[nBins];
int *cnt2 = new int[nBins];
SumIntArrayAcrossAllProcessors(count, cnt2, nBins);
SumDoubleArrayAcrossAllProcessors(running_total_ave, rt2, nBins);
for (int i = 0 ; i < nBins ; i++)
{
if (cnt2[i] > 0)
running_total_ave[i] = rt2[i] / cnt2[i];
else
running_total_ave[i] = undefinedVal;
}
delete [] rt2;
delete [] cnt2;
}
else
{
rv = new float[nBins];
double *rt2 = new double[nBins];
int *cnt2 = new int[nBins];
SumIntArrayAcrossAllProcessors(count, cnt2, nBins);
SumDoubleArrayAcrossAllProcessors(running_total_variance, rt2, nBins);
for (int i = 0 ; i < nBins ; i++)
{
if (cnt2[i] > 0)
rv[i] = rt2[i] / cnt2[i];
else
rv[i] = undefinedVal;
}
delete [] rt2;
delete [] cnt2;
}
this->pass++;
return rv;
}
float *
avtR2Frms::FinalizePass(int pass)
{
float *rv = new float[nBins];
double *rt2 = new double[nBins];
int *cnt2 = new int[nBins];
SumIntArrayAcrossAllProcessors(count, cnt2, nBins);
SumDoubleArrayAcrossAllProcessors(running_total, rt2, nBins);
for (int i = 0 ; i < nBins ; i++)
{
if (cnt2[i] > 0)
rv[i] = sqrt(rt2[i] / cnt2[i]);
else
rv[i] = undefinedVal;
}
delete [] rt2;
delete [] cnt2;
return rv;
}
void
avtAggregateChordLengthDistributionQuery::PostExecute(void)
{
int i;
int times = 0;
char name[1024];
sprintf(name, "cld_a%d.ult", times++);
if (PAR_Rank() == 0)
{
bool lookingForUnused = true;
while (lookingForUnused)
{
ifstream ifile(name);
if (ifile.fail())
lookingForUnused = false;
else
sprintf(name, "cld_a%d.ult", times++);
}
}
char msg[1024];
sprintf(msg, "The aggregate chord length distribution has been outputted "
"as an Ultra file (%s), which can then be imported into VisIt.",
name);
SetResultMessage(msg);
SetResultValue(0.);
int *nc2 = new int[numBins];
SumIntArrayAcrossAllProcessors(numChords, nc2, numBins);
delete [] numChords;
numChords = nc2;
if (PAR_Rank() == 0)
{
double binWidth = (maxLength-minLength) / numBins;
double totalArea = 0.;
for (i = 0 ; i < numBins ; i++)
totalArea += binWidth*numChords[i];
if (totalArea == 0.)
{
sprintf(msg, "The chord length distribution could not be "
"calculated because none of the lines intersected the data"
" set. If you have used a fairly large number of lines, "
"then this may be indicative of an error state.");
SetResultMessage(msg);
return;
}
ofstream ofile(name);
if (ofile.fail())
{
sprintf(msg, "Unable to write out file containing distribution.");
SetResultMessage(msg);
return;
}
ofile << "# Chord length distribution - aggregate" << endl;
for (int i = 0 ; i < numBins ; i++)
{
//double x = minLength + (i+0.5)*binWidth;
double x1 = minLength + (i)*binWidth;
double x2 = minLength + (i+1)*binWidth;
double y = numChords[i] / totalArea; // Make it be
// a distribution ... the area under the curve: 1
ofile << x1 << " " << y << endl;
ofile << x2 << " " << y << endl;
}
}
}
void
avtConnComponentsCentroidQuery::PostExecute(void)
{
// get # of cells per component (from all processors)
int *sum_res_int = new int[nComps];
SumIntArrayAcrossAllProcessors(&nCellsPerComp[0], sum_res_int, nComps);
memcpy(&nCellsPerComp[0],sum_res_int,nComps * sizeof(int));
delete [] sum_res_int;
// get centroid values (from all processors)
double *sum_res_dbl = new double[nComps];
SumDoubleArrayAcrossAllProcessors(&xCentroidPerComp[0],
sum_res_dbl,
nComps);
memcpy(&xCentroidPerComp[0],sum_res_dbl,nComps * sizeof(double));
SumDoubleArrayAcrossAllProcessors(&yCentroidPerComp[0],
sum_res_dbl,
nComps);
memcpy(&yCentroidPerComp[0],sum_res_dbl,nComps * sizeof(double));
SumDoubleArrayAcrossAllProcessors(&zCentroidPerComp[0],
sum_res_dbl,
nComps);
memcpy(&zCentroidPerComp[0],sum_res_dbl,nComps * sizeof(double));
delete [] sum_res_dbl;
// create output message
if(PAR_Rank() == 0)
{
std::string msg = "";
char buff[2048];
if(nComps == 1)
{SNPRINTF(buff,2048,"Found %d connected component\n",nComps);}
else
{SNPRINTF(buff,2048,"Found %d connected components\n",nComps);}
msg += buff;
// pack values into a a single vector for query output
std::vector<double> result_vec(nComps *3);
for(int i=0;i<nComps;i++)
{
// get number of cells for current component
double n_comp_cells = (double)nCellsPerComp[i];
// calculate centriod values for the current component
xCentroidPerComp[i] /= n_comp_cells;
yCentroidPerComp[i] /= n_comp_cells;
zCentroidPerComp[i] /= n_comp_cells;
// pack into result vector
result_vec[i*3 + 0] = xCentroidPerComp[i];
result_vec[i*3 + 1] = yCentroidPerComp[i];
result_vec[i*3 + 2] = zCentroidPerComp[i];
}
std::string format = "Component %d [%d cells] Centroid = ("
+ queryAtts.GetFloatFormat() +","
+ queryAtts.GetFloatFormat() +","
+ queryAtts.GetFloatFormat() +")\n";
// prepare the output message
for(int i=0;i<nComps;i++)
{
SNPRINTF(buff,1024,
format.c_str(),
i,
nCellsPerComp[i],
xCentroidPerComp[i],
yCentroidPerComp[i],
zCentroidPerComp[i]);
msg += buff;
}
// set result message
SetResultMessage(msg);
// set result values
SetResultValues(result_vec);
}
}
void
avtImagePartition::EstablishPartitionBoundaries(int *samples)
{
int i, j;
int first_scanline = (shouldDoTiling ? tile_height_min : 0);
int last_scanline = (shouldDoTiling ? tile_height_max : height);
//
// Find out how many samples there are in each scanline across all procs.
//
const int n_scanlines = last_scanline - first_scanline;
if (numProcessors > n_scanlines)
{
for (i = 0 ; i < n_scanlines ; i++)
{
partitionStartsOnScanline[i] = i;
partitionStopsOnScanline[i] = i;
stpAssignments[i] = i;
}
for (i = n_scanlines ; i < numProcessors ; i++)
{
partitionStartsOnScanline[i] = n_scanlines+1;
partitionStopsOnScanline[i] = n_scanlines;
}
establishedPartitionBoundaries = true;
return;
}
else if (numProcessors >= 32)
{
int numScanlinesPerProc = n_scanlines/numProcessors;
int numExtraUntil = (n_scanlines % numProcessors);
for (i = 0 ; i < numProcessors ; i++)
{
partitionStartsOnScanline[i] = numScanlinesPerProc*i;
partitionStartsOnScanline[i] +=
(i > numExtraUntil ? numExtraUntil : i);
partitionStopsOnScanline[i] =
partitionStartsOnScanline[i] + numScanlinesPerProc-1;
partitionStopsOnScanline[i] +=
(i < numExtraUntil ? 1 : 0);
for (j = partitionStartsOnScanline[i] ;
j <= partitionStopsOnScanline[i] ; j++)
stpAssignments[j] = i;
}
establishedPartitionBoundaries = true;
return;
}
std::vector<int> allSamples(n_scanlines);
stpAssignments.resize(n_scanlines, 0);
SumIntArrayAcrossAllProcessors(samples, &allSamples[0], n_scanlines);
//
// Find out how many total samples there are and what the target is.
//
int totalSamples = 0;
for (i = first_scanline ; i < last_scanline ; i++)
{
// We need to iterate over scanlines, but our arrays are (of course)
// 0-based. Construct a value which gives the array index that
// corresponds to the current scanline.
size_t idx = i - first_scanline;
//
// There has been some problems with overflows when we have lots of
// sample points and we are in send cells mode (since send cells
// overestimates pretty dramatically how many samples it has).
//
// Normalize the number of samples.
//
if (allSamples[idx] > 0 && allSamples[idx] < 1000)
{
allSamples[idx] = 1;
}
else
{
allSamples[idx] /= 1000;
}
totalSamples += allSamples[idx];
}
int target = totalSamples / numProcessors;
target = (target <= 0 ? 1 : target); // Correction for when we have
// nothing to render.
int tooHigh = (int) (target*1.5);
int tooLow = (int) (target*1.);
int currentPartition = 0;
int amountForCurrentPartition = 0;
partitionStartsOnScanline[currentPartition] = first_scanline;
for (i = first_scanline ; i < last_scanline ; i++)
{
// Need 0-based array index; see comment above.
size_t idx = i - first_scanline;
if (amountForCurrentPartition + allSamples[idx] > tooHigh)
{
if (amountForCurrentPartition > tooLow &&
currentPartition+1 < numProcessors)
{
//
// If we added the next scanline, we would be too high. Also,
// the number of scanlines added to the current partition is
// sufficient to not be ridiculously low. Declare this
// partition closed off and start the next one.
//
partitionStopsOnScanline[currentPartition] = i-1;
currentPartition++;
amountForCurrentPartition = 0;
partitionStartsOnScanline[currentPartition] = i;
}
}
stpAssignments[idx] = currentPartition;
amountForCurrentPartition += allSamples[idx];
}
partitionStopsOnScanline[currentPartition] = last_scanline-1;
currentPartition++;
//
// We may have not assigned the last few processors some partitions, so
// give them the equivalent of nothing.
//
while (currentPartition < numProcessors)
{
partitionStartsOnScanline[currentPartition] = last_scanline+1;
partitionStopsOnScanline[currentPartition] = last_scanline;
currentPartition++;
}
establishedPartitionBoundaries = true;
}
void
avtIndividualChordLengthDistributionQuery::PostExecute(void)
{
int i;
int times = 0;
char name[1024];
sprintf(name, "cld_i%d.ult", times++);
if (PAR_Rank() == 0)
{
bool lookingForUnused = true;
while (lookingForUnused)
{
ifstream ifile(name);
if (ifile.fail())
lookingForUnused = false;
else
sprintf(name, "cld_i%d.ult", times++);
}
}
char msg[1024];
sprintf(msg, "The chord length distribution has been outputted as an "
"Ultra file (%s), which can then be imported into VisIt.",
name);
SetResultMessage(msg);
SetResultValue(0.);
int *nc2 = new int[numBins];
SumIntArrayAcrossAllProcessors(numChords, nc2, numBins);
delete [] numChords;
numChords = nc2;
if (PAR_Rank() == 0)
{
double binWidth = (maxLength-minLength) / numBins;
double totalArea = 0.;
for (i = 0 ; i < numBins ; i++)
totalArea += binWidth*numChords[i];
if (totalArea == 0.)
{
sprintf(msg, "The chord length distribution could not be "
"calculated because none of the lines intersected "
"the data set. If you have used a fairly large number "
"of lines, then this may be indicative of an error state.");
SetResultMessage(msg);
return;
}
ofstream ofile(name);
if (ofile.fail())
{
sprintf(msg, "Unable to write out file containing distribution.");
SetResultMessage(msg);
}
if (!ofile.fail())
ofile << "# Chord length distribution - individual" << endl;
MapNode result_node;
doubleVector curve;
for (int i = 0 ; i < numBins ; i++)
{
double x1 = minLength + (i)*binWidth;
double x2 = minLength + (i+1)*binWidth;
double y = numChords[i] / totalArea; // Make it be a distribution ...
// the area under the curve: 1
curve.push_back(x1);
curve.push_back(y);
curve.push_back(x2);
curve.push_back(y);
if (!ofile.fail())
{
ofile << x1 << " " << y << endl;
ofile << x2 << " " << y << endl;
}
}
result_node["chord_length_distribution_individual"] = curve;
SetXmlResult(result_node.ToXML());
SetResultValues(curve);
}
}
