Vector<DataType> computeNormal(unsigned int ind1, unsigned int ind2, DataType blend, const Array3D<DataType, IndexType> & A)
{
DataType dx,dy,dz;
int i,j,k;
A.ind2sub(ind1, i,j,k);
dx = (A(i+1,j,k) - A(i-1,j,k)) * 0.5;
dy = (A(i,j+1,k) - A(i,j-1,k)) * 0.5;
dz = (A(i,j,k+1) - A(i,j,k-1)) * 0.5;
Vector<DataType> n1(dx,dy,dz);
n1.normalize();
A.ind2sub(ind2, i,j,k);
dx = (A(i+1,j,k) - A(i-1,j,k)) * 0.5;
dy = (A(i,j+1,k) - A(i,j-1,k)) * 0.5;
dz = (A(i,j,k+1) - A(i,j,k-1)) * 0.5;
Vector<DataType> n2(dx,dy,dz);
n2.normalize();
Vector<DataType> n = n1*(1-blend) + n2*blend;
n.normalize();
return n;
}
int Application::main(int argc,char *argv[])
{
// Process command line
CommandLine cmd(argc,argv,"");
if(cmd.numArgs()!=2)
throw String("train-3state <alignment-file> <outfile>");
String infile=cmd.arg(0);
String outfile=cmd.arg(1);
// Initialization
transCounts.resize(4,4);
emitCounts.resize(4,nAlpha,nAlpha);
transCounts.setAllTo(0);
emitCounts.setAllTo(0);
// Process all alignments (pairs of sequences in fasta file)
FastaReader reader(infile,alphabet);
String def1, seq1, def2, seq2;
while(reader.nextSequence(def1,seq1) &&
reader.nextSequence(def2,seq2)) {
Sequence S1(seq1,alphabet), S2(seq2,alphabet);
updateCounts(S1,S2);
}
// Compute HMM parameters
PairHMM hmm(alphabet,gapSymbol,4);
hmm.setStateType(INSERTION_STATE,PHMM_INSERT);
hmm.setStateType(DELETION_STATE,PHMM_DELETE);
hmm.setStateType(MATCH_STATE,PHMM_MATCH);
hmm.setStateType(0,PHMM_OTHER);
for(STATE i=0 ; i<4 ; ++i) {
double sum=0;
for(STATE j=0 ; j<4 ; ++j)
sum+=transCounts[i][j];
for(STATE j=0 ; j<4 ; ++j)
hmm.setTransP(i,j,transCounts[i][j]/sum);
}
for(STATE k=0 ; k<4 ; ++k) {
double sum=0;
for(Symbol i=0 ; i<nAlpha ; ++i)
for(Symbol j=0 ; j<nAlpha ; ++j)
sum+=emitCounts(k,i,j);
if(sum==0) sum=1;
for(Symbol i=0 ; i<nAlpha ; ++i)
for(Symbol j=0 ; j<nAlpha ; ++j)
hmm.setEmitP(k,i,j,emitCounts(k,i,j)/sum);
}
// Save HMM
hmm.save(outfile);
return 0;
}
//----------------------------------------------------------------------
int Array3D::copyTo(Array3D& a)
// copy to "a" from "this"
// return 0 if 0k, -1 otherwise
{
//- printf("inside copyTo\n");
int* dims = a.getDims();
if (dims[0] != np1 || dims[1] != np2 || dims[2] != np3) {
return(-1);
}
GE_FLOAT* ptr = a.getDataPtr();
//- printf("copyTo:: npts= %d\n", npts);
memcpy(ptr, data, sizeof(GE_FLOAT)*npts);
return(0);
}
//----------------------------------------------------------------------
int Array3D::copyFrom(Array3D& a)
// copy from "a" to "this"
{
// //- printf("enter copyFrom\n");
int* dims = a.getDims();
// //- printf("dims= %d, %d, %d\n", dims[0], dims[1], dims[2]);
if (dims[0] != np1 || dims[1] != np2 || dims[2] != np3) {
// //- printf("dims from: %d, %d, %d\n", dims[0], dims[1], dims[2]);
// //- printf("dims to: %d, %d, %d\n", np1, np2, np3);
//- printf("error in copyFrom (array3D.cpp)\n");
return(-1);
}
GE_FLOAT* ptr = a.getDataPtr();
memcpy(data, ptr, sizeof(GE_FLOAT)*npts);
return(0);
}
//----------------------------------------------------------------------
int Array3D::copyFrom(Array3D& a, Vec3i& fromOrig, Vec3i& fromRange, Vec3i& toOrigin)
{
Vec3i fromMaxDims = fromOrig + fromRange;
fromMaxDims.clampMaxTo(a.getMaxDims());
fromOrig.clampMinTo(a.getOrigin());
fromRange = fromMaxDims - fromOrig;
Vec3i toMaxDims = toOrigin + fromRange;
if (toOrigin < this->origin) return -1;
if ((toOrigin+fromRange) > maxDims) return -1;
for (int k=0; k < fromRange[2]; k++) {
for (int j=0; j < fromRange[1]; j++) {
for (int i=0; i < fromRange[0]; i++) {
set(i+toOrigin.x(), j+toOrigin.y(), k+toOrigin.z(), a.get(i+fromOrig.x(), j+fromOrig.y(), k+fromOrig.z()));
}}}
return(0);
}
//----------------------------------------------------------------------
int Array3D::copyTo(Array3D& a, Vec3i& toOrigin, Vec3i& fromRange, Vec3i& fromOrigin)
// copy from "this" to "a"
{
Vec3i fromMaxDims = fromOrigin + fromRange;
fromMaxDims.clampMaxTo(maxDims);
fromOrigin.clampMinTo(origin);
fromRange = fromMaxDims - fromOrigin;
Vec3i toMaxDims = toOrigin + fromRange;
if (toOrigin < a.getOrigin()) return -1;
if ((toOrigin+fromRange) > a.getMaxDims()) return -1;
for (int k=0; k < fromRange.z(); k++) {
for (int j=0; j < fromRange.y(); j++) {
for (int i=0; i < fromRange.x(); i++) {
a.set(i+toOrigin.x(), j+toOrigin.y(), k+toOrigin.z(),
get(i+fromOrigin.x(), j+fromOrigin.y(), k+fromOrigin.z()));
}}}
return(0);
}
bool exporter::Export( string filename, settings &gen, Array3D &_map )
{
ofstream mFile( filename );
if( !mFile.good() )
return 1;
//Map Size
mFile << "size " << gen.sizeX << " "
<< gen.sizeY << " "
<< gen.sizeZ << endl;
// Map Data
for( gSize y = 0; y < gen.sizeY; y++ ){
for( gSize z = 0; z < gen.sizeZ; z++ ){
mFile << "voxline " << y << " " << z;
for( gSize x = 0; x < gen.sizeX; x++ ){
mFile << " " << _map.get( x, y, z );
}
mFile << endl;
}
}
// Materials
for( gSize i = 0; i < gen.materials.size(); i++ )
{
mFile << "material " << gen.materials[ i ].name << " "
<< gen.materials[ i ].sizeX << " "
<< gen.materials[ i ].sizeY << endl;
}
// Sky and Sun
mFile << "sky mc" << endl;
mFile << "sun " << gen.sunlight.dx << " "
<< gen.sunlight.dy << " "
<< gen.sunlight.dz << " "
<< gen.sunlight.r << " "
<< gen.sunlight.g << " "
<< gen.sunlight.b << " "
<< gen.sunlight.ar << " "
<< gen.sunlight.ag << " "
<< gen.sunlight.ab << endl;
// Player Spawn
mFile << "startpos " << gen.player.x << " "
<< gen.player.y << " "
<< gen.player.z << " "
<< gen.player.direction << " "
<< gen.player.physics << " "
<< gen.player.torchLevel << " "
<< gen.player.testLightning << endl;
mFile.close();
return 0;
}
int WangTilesProcessor::SanitizeSmall(const TilePack & tiles,
const Array3D<Pixel> & input,
Array3D<Pixel> & output)
{
if((tiles.size() <= 0) ||
(input.Size(0)%tiles.size()) || (input.Size(1)%tiles[0].size()))
{
// small image, just make it a constant average of input
output = input;
for(int cha = 0; cha < input.Size(2); cha++)
{
Pixel sum = 0;
{
for(int row = 0; row < input.Size(0); row++)
for(int col = 0; col < input.Size(1); col++)
{
sum += input[row][col][cha];
}
sum /= (input.Size(0)*input.Size(1));
}
{
for(int row = 0; row < output.Size(0); row++)
for(int col = 0; col < output.Size(1); col++)
{
output[row][col][cha] = sum;
}
}
}
return 1;
}
else
{
return 0;
}
}
T Mask3D<T>::get(size_t n, Array3D<V> array, size_t h, size_t w, size_t d) {
#ifdef __CUDA_ARCH__
h += this->deviceMask[this->dimension*n];
w += this->deviceMask[this->dimension*n+1];
d += this->deviceMask[this->dimension*n+2];
return (w<array.getWidth() && h<array.getHeight() && d<array.getDepth())?array(h,w,d):this->haloValue;
#else
h += this->hostMask[this->dimension*n];
w += this->hostMask[this->dimension*n+1];
d += this->hostMask[this->dimension*n+2];
return (w<array.getWidth() && h<array.getHeight() && d<array.getDepth())?array(h,w,d):this->haloValue;
#endif
}
int WangTilesProcessor::TileMismatch(const TilePack & tiles,
const Array3D<Pixel> & input)
{
int mismatch = 0;
// count the number of edge colors
int e_colors[4] = {0, 0, 0, 0};
if(!CountEdgeColors(tiles,
e_colors[0],
e_colors[1],
e_colors[2],
e_colors[3]))
{
return 0;
}
// compute tile size
const int tile_height = (tiles.size() > 0) ? input.Size(0)/tiles.size() : 0;
const int tile_width = (tiles.size() > 0 && tiles[0].size() > 0) ? input.Size(1)/tiles[0].size() : 0;
const int tile_depth = input.Size(2);
// make sure all edges with
// (1) the same S/E/N/W orientations and
// (2) same edge id
// have identical images
for(int e_index = 0; e_index < 4; e_index++)
for(int e_color = 0; e_color < e_colors[e_index]; e_color++)
{
// find a tile with e_color in e_index
int t_row = -1; int t_col = -1;
{
for(unsigned int i = 0; i < tiles.size(); i++)
for(unsigned int j = 0; j < tiles[i].size(); j++)
{
const WangTiles::Tile & tile = tiles[i][j];
const int my_e_colors[4] = {tile.e0(), tile.e1(), tile.e2(), tile.e3()};
if(my_e_colors[e_index] == e_color)
{
// found the tile
t_row = i; t_col = j;
break;
}
}
}
if((t_row >= 0) && (t_col >= 0))
{
const WangTiles::Tile & sample_tile = tiles[t_row][t_col];
const int row_offset1 = t_row*tile_height;
const int col_offset1 = t_col*tile_width;
for(unsigned int i = 0; i < tiles.size(); i++)
for(unsigned int j = 0; j < tiles[i].size(); j++)
{
const WangTiles::Tile & tile = tiles[i][j];
const int my_e_colors[4] = {tile.e0(), tile.e1(), tile.e2(), tile.e3()};
if(my_e_colors[e_index] == e_color)
{
// try to see if they match
const int row_offset2 = i*tile_height;
const int col_offset2 = j*tile_width;
int row_start, row_end, col_start, col_end;
EdgeIndices(e_index, tile_height, tile_width,
row_start, row_end,
col_start, col_end);
for(int row = row_start; row <= row_end; row++)
for(int col = col_start; col <= col_end; col++)
for(int cha = 0; cha < tile_depth; cha++)
{
if(input[row+row_offset1][col+col_offset1][cha] != input[row+row_offset2][col+col_offset2][cha])
{
mismatch = 1;
}
}
}
}
}
}
// done
return mismatch;
}
int WangTilesProcessor::SanitizeCorners(const TilePack & tiles,
const Array3D<Pixel> & input,
Array3D<Pixel> & output)
{
if(SanitizeSmall(tiles, input, output))
{
return 1;
}
const int tile_height = input.Size(0)/tiles.size();
const int tile_width = input.Size(1)/tiles[0].size();
const int tile_depth = input.Size(2);
// initialize
// note that for each row we have all possible corner combinations
MeanTile mean_corner_tile;
{
Array3D<Pixel> image(tile_height, tile_width, tile_depth);
for(int row = 0; row < image.Size(0); row++)
for(int col = 0; col < image.Size(1); col++)
for(int cha = 0; cha < image.Size(2); cha++)
{
image[row][col][cha] = 0;
}
mean_corner_tile.image = image;
mean_corner_tile.count = 0;
}
// compute mean/average tiles for corner
// note that we need to consider all tiles to get correct results!
{
for(unsigned int i = 0; i < tiles.size(); i++)
for(unsigned int j = 0; j < tiles[i].size(); j++)
{
const WangTiles::Tile & tile = tiles[i][j];
const int input_row_start = i*tile_height;
const int input_col_start = j*tile_width;
for(int row = 0; row < tile_height; row++)
for(int col = 0; col < tile_width; col++)
for(int cha = 0; cha < tile_depth; cha++)
{
mean_corner_tile.image[row][col][cha] += input[row+input_row_start][col+input_col_start][cha];
}
mean_corner_tile.count++;
}
}
// normalization
{
if(mean_corner_tile.count > 0)
{
Array3D<Pixel> & image = mean_corner_tile.image;
for(int row = 0; row < image.Size(0); row++)
for(int col = 0; col < image.Size(1); col++)
for(int cha = 0; cha < image.Size(2); cha++)
{
image[row][col][cha] /= mean_corner_tile.count;
}
mean_corner_tile.count = 1;
}
}
// assign to the output
{
for(unsigned int i = 0; i < tiles.size(); i++)
for(unsigned int j = 0; j < tiles[i].size(); j++)
{
const WangTiles::Tile & tile = tiles[i][j];
const int tile_edges[4] = {tile.e0(), tile.e1(), tile.e2(), tile.e3()};
const int output_row_start = i*tile_height;
const int output_col_start = j*tile_width;
for(int k = 0; k < 4; k++)
{
int row, col;
CornerIndices(k, tile_height, tile_width, row, col);
// only touch the corners
for(int cha = 0; cha < tile_depth; cha++)
{
output[row+output_row_start][col+output_col_start][cha] = mean_corner_tile.image[row][col][cha];
}
}
}
}
// done
return 1;
}
int WangTilesProcessor::SanitizeEdges(const TilePack & tiles,
const Array3D<Pixel> & input,
Array3D<Pixel> & output)
{
// error checking
if(SanitizeSmall(tiles, input, output))
{
return 1;
}
const int tile_height = input.Size(0)/tiles.size();
const int tile_width = input.Size(1)/tiles[0].size();
const int tile_depth = input.Size(2);
// count the number of edge colors
int e_colors[4] = {0, 0, 0, 0};
{
if(!CountEdgeColors(tiles,
e_colors[0],
e_colors[1],
e_colors[2],
e_colors[3]))
{
return 0;
}
// check consistency
if((e_colors[0] != e_colors[2]) || (e_colors[1] != e_colors[3]))
{
return 0;
}
}
// initialize
vector< vector<MeanTile> > mean_tiles(4);
{
Array3D<Pixel> image(tile_height, tile_width, tile_depth);
for(int row = 0; row < image.Size(0); row++)
for(int col = 0; col < image.Size(1); col++)
for(int cha = 0; cha < image.Size(2); cha++)
{
image[row][col][cha] = 0;
}
for(unsigned int i = 0; i < mean_tiles.size(); i++)
{
mean_tiles[i] = vector< MeanTile >(e_colors[i]);
for(unsigned int j = 0; j < mean_tiles[i].size(); j++)
{
mean_tiles[i][j].image = image;
mean_tiles[i][j].count = 0;
}
}
}
// compute mean/average tiles per edge color
{
for(unsigned int i = 0; i < tiles.size(); i++)
for(unsigned int j = 0; j < tiles[i].size(); j++)
{
const WangTiles::Tile & tile = tiles[i][j];
const int input_row_start = i*tile_height;
const int input_col_start = j*tile_width;
const int tile_edges[4] = {tile.e0(), tile.e1(), tile.e2(), tile.e3()};
for(int k = 0; k < 4; k++)
{
MeanTile & output_tile = mean_tiles[k][tile_edges[k]];
for(int row = 0; row < tile_height; row++)
for(int col = 0; col < tile_width; col++)
for(int cha = 0; cha < tile_depth; cha++)
{
output_tile.image[row][col][cha] += input[row+input_row_start][col+input_col_start][cha];
}
output_tile.count++;
}
}
}
{
for(unsigned int i = 0; i < mean_tiles.size(); i++)
for(unsigned int j = 0; j < mean_tiles[i].size(); j++)
{
MeanTile & tile = mean_tiles[i][j];
if(tile.count > 0)
{
Array3D<Pixel> & image = tile.image;
for(int row = 0; row < image.Size(0); row++)
for(int col = 0; col < image.Size(1); col++)
for(int cha = 0; cha < image.Size(2); cha++)
{
image[row][col][cha] /= tile.count;
}
tile.count = 1;
}
}
}
// fix the output tile boundaries
output = input;
Array3D<Pixel> boundary(output);
Array3D<Pixel> boundary_count(output);
{
// initialization
for(int i = 0; i < boundary.Size(0); i++)
for(int j = 0; j < boundary.Size(1); j++)
for(int k = 0; k < boundary.Size(2); k++)
{
boundary[i][j][k] = 0;
boundary_count[i][j][k] = 0;
}
}
{
// compute the correct tile boundary
for(unsigned int i = 0; i < tiles.size(); i++)
for(unsigned int j = 0; j < tiles[i].size(); j++)
{
const WangTiles::Tile & tile = tiles[i][j];
const int output_row_offset = i*tile_height;
const int output_col_offset = j*tile_width;
const int tile_edges[4] = {tile.e0(), tile.e1(), tile.e2(), tile.e3()};
for(int k = 0; k < 4; k++)
{
const Array3D<Pixel> & mean_tile = mean_tiles[k][tile_edges[k]].image;
int row_start, row_end, col_start, col_end;
EdgeIndices(k, tile_height, tile_width,
row_start, row_end, col_start, col_end);
for(int row = row_start; row <= row_end; row++)
for(int col = col_start; col <= col_end; col++)
for(int cha = 0; cha < tile_depth; cha++)
{
boundary[row+output_row_offset][col+output_col_offset][cha] += mean_tile[row][col][cha];
boundary_count[row+output_row_offset][col+output_col_offset][cha] += 1.0;
}
}
}
}
{
// normalization and assign to the output
for(int i = 0; i < boundary.Size(0); i++)
for(int j = 0; j < boundary.Size(1); j++)
for(int k = 0; k < boundary.Size(2); k++)
{
if(boundary_count[i][j][k] > 0)
{
output[i][j][k] = boundary[i][j][k]/boundary_count[i][j][k];
}
}
}
// done
return 1;
}
void FM_Freeman(
const Array2D<E> &elevations,
Array3D<float> &props,
const double xparam
){
RDLOG_ALG_NAME<<"Freeman (1991) Flow Accumulation (aka MFD, MD8)";
RDLOG_CITATION<<"Freeman, T.G., 1991. Calculating catchment area with divergent flow based on a regular grid. Computers & Geosciences 17, 413–422.";
RDLOG_CONFIG<<"p = "<<xparam;
props.setAll(NO_FLOW_GEN);
props.setNoData(NO_DATA_GEN);
ProgressBar progress;
progress.start(elevations.size());
#pragma omp parallel for collapse(2)
for(int y=0;y<elevations.height();y++)
for(int x=0;x<elevations.width();x++){
++progress;
if(elevations.isNoData(x,y)){
props(x,y,0) = NO_DATA_GEN;
continue;
}
if(elevations.isEdgeCell(x,y))
continue;
const E e = elevations(x,y);
double C = 0;
for(int n=1;n<=8;n++){
const int nx = x+dx[n];
const int ny = y+dy[n];
if(!elevations.inGrid(nx,ny))
continue;
if(elevations.isNoData(nx,ny)) //TODO: Don't I want water to drain this way?
continue;
const E ne = elevations(nx,ny);
if(ne<e){
const double rise = e-ne;
const double run = dr[n];
const double grad = rise/run;
const auto cval = std::pow(grad,xparam);
props(x,y,n) = cval;
C += cval;
}
}
if(C>0){
props(x,y,0) = HAS_FLOW_GEN;
C = 1/C; //TODO
for(int n=1;n<=8;n++){
auto &this_por = props(x,y,n);
if(this_por>0)
this_por *= C;
else
this_por = 0;
}
}
}
progress.stop();
}
void Strand2dFCBlockSolver::gradSetupSub(Array3D<double>& gx)
{
// initialize coefficient array
gx.set(0.);
// form quadratic sub elements
int meshOrderL=2,nElemLocalL=meshOrder-1,nSurfElemL=nSurfElem*nElemLocalL;
Array3D<int> surfElemL(nSurfElemL,meshOrderL+1,2);
Array3D<int> elemLocalL(nElemLocalL,meshOrderL+1,2);
if (meshOrder == 2){
elemLocalL(0,0,0) = 0; elemLocalL(0,0,1) = 1;
elemLocalL(0,1,0) = 1; elemLocalL(0,1,1) = 1;
elemLocalL(0,2,0) = 2; elemLocalL(0,2,1) = 1;
}
else if (meshOrder == 3){
elemLocalL(0,0,0) = 0; elemLocalL(0,0,1) = 1;
elemLocalL(0,1,0) = 3; elemLocalL(0,1,1) = 0;
elemLocalL(0,2,0) = 2; elemLocalL(0,2,1) = 1;
elemLocalL(1,0,0) = 2; elemLocalL(1,0,1) = 0;
elemLocalL(1,1,0) = 1; elemLocalL(1,1,1) = 1;
elemLocalL(1,2,0) = 3; elemLocalL(1,2,1) = 1;
}
else if (meshOrder == 4){
elemLocalL(0,0,0) = 0; elemLocalL(0,0,1) = 1;
elemLocalL(0,1,0) = 3; elemLocalL(0,1,1) = 0;
elemLocalL(0,2,0) = 2; elemLocalL(0,2,1) = 1;
elemLocalL(1,0,0) = 2; elemLocalL(1,0,1) = 0;
elemLocalL(1,1,0) = 4; elemLocalL(1,1,1) = 0;
elemLocalL(1,2,0) = 3; elemLocalL(1,2,1) = 1;
elemLocalL(2,0,0) = 3; elemLocalL(2,0,1) = 0;
elemLocalL(2,1,0) = 1; elemLocalL(2,1,1) = 1;
elemLocalL(2,2,0) = 4; elemLocalL(2,2,1) = 1;
}
int k=0;
for (int n=0; n<nSurfElem; n++)
for (int i=0; i<nElemLocalL; i++){
for (int m=0; m<meshOrderL+1; m++){
surfElemL(k,m,0) = surfElem(n,elemLocalL(i,m,0));
surfElemL(k,m,1) = elemLocalL(i,m,1);
}
k++;
}
if (k != nSurfElemL){
cout << "\n***Problem forming sub-elements in initialize.C***"
<< endl;
exit(0);
}
// Lagrange polynomial derivatives for lower order elements
int spacing=0; // assume equally spaced points in surface elements for now
Array1D<double> ss(meshOrderL+1);
solutionPoints1D(meshOrderL,
spacing,
&ss(0));
bool test=false;
Array2D<double> lc(meshOrderL+1,meshOrderL+1);
lagrangePoly1D(test, // coefficients to form Lagrange polynomials
meshOrderL,
&ss(0),
&lc(0,0));
// ls(i,j) = (dl_j/ds)_i (a row is all Lagrange polynomials (derivatives)
// evaluated at a single mesh point i)
Array2D<double> lsL(meshOrderL+1,meshOrderL+1);
lsL.set(0.);
int km;
for (int i=0; i<meshOrderL+1; i++) // ith mesh point
for (int j=0; j<meshOrderL+1; j++) // jth Lagrange polynomial
for (int k=0; k<meshOrderL+1; k++){
km = max(0,k-1);
lsL(i,j) +=((double)k)*pow(ss(i),km)*lc(j,k);
}
// mapping terms for lower order elements
Array3D<double> xsL(nSurfElemL,meshOrderL+1,nStrandNode);
Array3D<double> ysL(nSurfElemL,meshOrderL+1,nStrandNode);
Array3D<double> jacL(nSurfElemL,meshOrderL+1,nStrandNode);
xsL.set(0.);
ysL.set(0.);
int ni,nm;
double x0,y0,nx,ny;
for (int n=0; n<nSurfElemL; n++)
for (int i=0; i<meshOrderL+1; i++){ // ith point in the element
ni = surfElemL(n,i,0);
for (int m=0; m<meshOrderL+1; m++){ // mth Lagrange poly. in mapping
nm = surfElemL(n,m,0);
x0 = surfX(nm,0);
y0 = surfX(nm,1);
nx = pointingVec(nm,0);
ny = pointingVec(nm,1);
for (int j=0; j<nStrandNode; j++){
xsL(n,i,j) += lsL(i,m)*(x0+nx*strandX(j));
ysL(n,i,j) += lsL(i,m)*(y0+ny*strandX(j));
}}
for (int j=0; j<nStrandNode; j++)
jacL(n,i,j) = xsL(n,i,j)*yn(ni,j)-ysL(n,i,j)*xn(ni,j);
}
// degree at each surface node
Array1D<int> sum(nSurfNode);
sum.set(0);
for (int n=0; n<nSurfElemL; n++)
for (int i=0; i<meshOrderL+1; i++)
sum(surfElemL(n,i,0)) += surfElemL(n,i,1);
// use elements to form gradient coefficients
double xnj,ynj;
Array3D<double> a(nSurfNode,nStrandNode,2);
a.set(0.);
for (int n=0; n<nSurfElemL; n++)
for (int i=0; i<meshOrderL+1; i++){ //ith point in the element
if (surfElemL(n,i,1) == 1){ //if a contributing node
ni = surfElemL(n,i,0);
for (int m=0; m<meshOrderL+1; m++){ //mth Lagrange poly. in mapping
nm = surfElemL(n,m,0);
for (int j=0; j<nStrandNode; j++){ //local gradient coefficients
xnj = xn(ni,j)/(jacL(n,i,j)*(double)sum(ni));
ynj = yn(ni,j)/(jacL(n,i,j)*(double)sum(ni));
a(nm,j,0) = lsL(i,m)*ynj;
a(nm,j,1) =-lsL(i,m)*xnj;
}}
for (int m=psp2(ni); m<psp2(ni+1); m++){ //add to coefficient array
nm = psp1(m);
for (int j=0; j<nStrandNode; j++){
gx(m,j,0) += a(nm,j,0);
gx(m,j,1) += a(nm,j,1);
}}
for (int m=0; m<meshOrderL+1; m++){ //reset helper array to zero
nm = surfElemL(n,m,0);
for (int j=0; j<nStrandNode; j++){
a(nm,j,0) = 0.;
a(nm,j,1) = 0.;
}}}}
// clean up
sum.deallocate();
a.deallocate();
surfElemL.deallocate();
elemLocalL.deallocate();
xsL.deallocate();
ysL.deallocate();
ss.deallocate();
lc.deallocate();
lsL.deallocate();
}
int shadow_preset(Array3D & shadow, VoxelBox vb, V3f sta, std::vector<CylData> & cyls, int nCyl)
{
shadow.Reset(0.0);//Reset to 0.0 the shadow voxel box
//********************************************
//Below is the any pattern for the shadow box.
//********************************************
float sh_dist = 4.0;//dist at which the environment shades
int xv,yv,zv;
V3f cyl_point;
// Average shadow field exerted by the surrounding
// for(int i=0; i<nCyl; i++){
// if(cyls[i].is_deleted || cyls[i].order == 0)
// continue;
// if( ( cyls[i].end - sta ).Length() > (sh_dist - (float)SHLEN ) ){
// //cyl_point = cyls[i].start + 0.5*cyls[i].length*cyls[i].axis;
// cyl_point = cyls[i].end;
// xv = ceil( (cyl_point.x - vb.offset.x) / vb.vdx ) - 1;
// if(xv < 0 || xv >= shadow.m_width)
// continue;
// yv = ceil( (cyl_point.y - vb.offset.y) / vb.vdy ) - 1;
// if(yv < 0 || yv >= shadow.m_height)
// continue;
// zv = ceil( (cyl_point.z - vb.offset.z) / vb.vdz ) - 1;
// if(zv < 0 || zv >= (shadow.m_data.size()/(shadow.m_width*shadow.m_height)))
// continue;
// shadow(xv,zv,yv) = (float)SH;
// }
// }
//Bright cube
// for(int i = 0; i < GSY; i++){
// for(int j = 0; j < GSX; j++){
// for(int k = 0; k < GSZ; k++){
// if( k >= 60 && k <= 130 && j >= 60 && j <= 130)
// continue;
// shadow(j,k,i) = 1000*QRAD;
// }
// }
// }
//External layer of the voxel box is dark
// int thick = 150;
// for(int i = 0; i < GSY; i++){
// for(int j = 0; j < GSX; j++){
// for(int k = 0; k < GSZ; k++){
// if( j < thick || j >= (GSX-thick) )
// shadow(j,k,i) = QRAD;
// else{
// if(k < thick || k >= (GSZ-thick))
// shadow(j,k,i) = QRAD;
// }
// }
// }
// }
//Centered pyramidal penumbra
// float highest = 0.0;
// float distal_x = 0.0;
// float distal_z = 0.0;
// for(int i=0;i<nCyl;i++){
// if(cyls[i].is_deleted)
// continue;
// if(highest < cyls[i].end.y){
// highest = cyls[i].end.y;
// }
// if(distal_x < fabs(cyls[i].end.x))
// distal_x = fabs(cyls[i].end.x);
// if(distal_z < fabs(cyls[i].end.z))
// distal_z = fabs(cyls[i].end.z);
// }
// int yv = ceil( (highest - vb.offset.y) / vb.vdy ) - 1;
// int dxv = ceil( (fabs(distal_x-sta.x)) / vb.vdx ) - 1;
// int dzv = ceil( (fabs(distal_z-sta.z)) / vb.vdz ) - 1;
// //(0,0,0) point base or other sta
// int yb = ceil( (sta.y - vb.offset.y) / vb.vdy ) - 1;
// int xb = ceil( (sta.x - vb.offset.x) / vb.vdx ) - 1;
// int zb = ceil( (sta.z - vb.offset.z) / vb.vdz ) - 1;
// //std::cout << yv << ", " << dxv << ", " << dzv << ", " << yb << std::endl;
// // float pivot_x[] = {0.5,-0.1,0.1,-0.1};
// // float pivot_z[] = {0.5,0.5,-0.5,-0.5};
// // std::cout << "Iterate over Y: " << yv-1 << ":" << yb << std::endl;
// // std::cout << "Iterate over X: " << xb-dxv << ":" << dxv+xb << std::endl;
// // std::cout << "Iterate over Z: " << zb-dzv << ":" << dzv+zb << std::endl;
// // std::cout << yv << ", " << yb << ", " << std::endl;
// for(int iy = yv; iy >= yb; iy--){//Iterate over the layers down, Y-span
// for(int ix = xb-dxv; ix <= dxv+xb; ix++){//Iterate over X-span
// for(int iz = zb-dzv; iz <= dzv+zb; iz++){//Iterate over Z-span
// if( (ix < 0) || (ix >= GSX) || (iy < 0) || \
// (iy >= GSY) || (iz < 0) || (iz >= GSZ) )
// continue;
// //shadow(ix,iz,iy) += QRAD * pow(1.1,-(iy-yb));
// shadow(ix,iz,iy) += QRAD * \
// -(float)(iy-yb) * (float)(iy-yb) / ((float)(yv-yb)*(yv-yb)) + 1.0;
// }
// }
// }
return 0;
}
template <typename PointT> void
pcl::FastBilateralFilter<PointT>::applyFilter (PointCloud &output)
{
if (!input_->isOrganized ())
{
PCL_ERROR ("[pcl::FastBilateralFilter] Input cloud needs to be organized.\n");
return;
}
copyPointCloud (*input_, output);
float base_max = std::numeric_limits<float>::min (),
base_min = std::numeric_limits<float>::max ();
for (size_t x = 0; x < output.width; ++x)
for (size_t y = 0; y < output.height; ++y)
if (pcl_isfinite (output (x, y).z))
{
if (base_max < output (x, y).z)
base_max = output (x, y).z;
if (base_min > output (x, y).z)
base_min = output (x, y).z;
}
for (size_t x = 0; x < output.width; ++x)
for (size_t y = 0; y < output.height; ++y)
if (!pcl_isfinite (output (x, y).z))
output (x, y).z = base_max;
const float base_delta = base_max - base_min;
const size_t padding_xy = 2;
const size_t padding_z = 2;
const size_t small_width = static_cast<size_t> (static_cast<float> (input_->width - 1) / sigma_s_) + 1 + 2 * padding_xy;
const size_t small_height = static_cast<size_t> (static_cast<float> (input_->height - 1) / sigma_s_) + 1 + 2 * padding_xy;
const size_t small_depth = static_cast<size_t> (base_delta / sigma_r_) + 1 + 2 * padding_z;
Array3D data (small_width, small_height, small_depth);
for (size_t x = 0; x < input_->width; ++x)
{
const size_t small_x = static_cast<size_t> (static_cast<float> (x) / sigma_s_ + 0.5f) + padding_xy;
for (size_t y = 0; y < input_->height; ++y)
{
const float z = output (x,y).z - base_min;
const size_t small_y = static_cast<size_t> (static_cast<float> (y) / sigma_s_ + 0.5f) + padding_xy;
const size_t small_z = static_cast<size_t> (static_cast<float> (z) / sigma_r_ + 0.5f) + padding_z;
Eigen::Vector2f& d = data (small_x, small_y, small_z);
d[0] += output (x,y).z;
d[1] += 1.0f;
}
}
std::vector<long int> offset (3);
offset[0] = &(data (1,0,0)) - &(data (0,0,0));
offset[1] = &(data (0,1,0)) - &(data (0,0,0));
offset[2] = &(data (0,0,1)) - &(data (0,0,0));
Array3D buffer (small_width, small_height, small_depth);
for (size_t dim = 0; dim < 3; ++dim)
{
const long int off = offset[dim];
for (size_t n_iter = 0; n_iter < 2; ++n_iter)
{
std::swap (buffer, data);
for(size_t x = 1; x < small_width - 1; ++x)
for(size_t y = 1; y < small_height - 1; ++y)
{
Eigen::Vector2f* d_ptr = &(data (x,y,1));
Eigen::Vector2f* b_ptr = &(buffer (x,y,1));
for(size_t z = 1; z < small_depth - 1; ++z, ++d_ptr, ++b_ptr)
*d_ptr = (*(b_ptr - off) + *(b_ptr + off) + 2.0 * (*b_ptr)) / 4.0;
}
}
}
if (early_division_)
{
for (std::vector<Eigen::Vector2f >::iterator d = data.begin (); d != data.end (); ++d)
*d /= ((*d)[0] != 0) ? (*d)[1] : 1;
for (size_t x = 0; x < input_->width; x++)
for (size_t y = 0; y < input_->height; y++)
{
const float z = output (x,y).z - base_min;
const Eigen::Vector2f D = data.trilinear_interpolation (static_cast<float> (x) / sigma_s_ + padding_xy,
static_cast<float> (y) / sigma_s_ + padding_xy,
z / sigma_r_ + padding_z);
output(x,y).z = D[0];
}
}
else
{
for (size_t x = 0; x < input_->width; ++x)
for (size_t y = 0; y < input_->height; ++y)
{
const float z = output (x,y).z - base_min;
const Eigen::Vector2f D = data.trilinear_interpolation (static_cast<float> (x) / sigma_s_ + padding_xy,
static_cast<float> (y) / sigma_s_ + padding_xy,
z / sigma_r_ + padding_z);
output (x,y).z = D[0] / D[1];
}
}
}
int
main (int argc, char **argv)
{
/* Allocate a 2d array */
ofstream fout;
ofstream gout;
ofstream fin;
ofstream logfile;
ifstream init;
int inject_jet=0;
int ii = 0, jj = 0, kk = 0, hh = 0;
int rc;
int timestep = 0;
int maxstep = 0;
int printtime = 10;
int second = 0;
double max_speed = 0.0;
double maxtime = 0.0;
double *maximumspeed = &max_speed;
double time = 0.0;
double delta_t = 0.0;
double dtodx = 0.0;
double del = 0.0;
double delh = 0.0;
double cfl = 0.80;
double gammam1 = gammag - 1;
double fn[8];
zone maxvar;
zone minvar;
#ifdef DEBUG
double px, py, et, ri, rl, ul, vl, ke, pl, al;
#endif /* DEBUG */
clock_t start, end;
double elapsed;
double den_temp[4];
string probtype;
start = clock ();
gammag = 5.0 / 3.0;
// gammag =1.4;
//
/*
init.open ("input/init.dat");
init >> nx >> ny;
init >> maxstep;
init >> cfl;
init.close ();
*/
logfile.open ("output/roe.log");
logfile.close ();
logfile.open ("output/falle.log");
logfile.close ();
logfile.open ("logfile.txt");
logfile.close ();
ne = 8;
if (argc > 1)
{
init.open (argv[1]);
}
else
{
init.open ("input/gaz1");
}
init >> nx;
init.ignore (256, '\n');
init >> ny;
init.ignore (256, '\n');
init >> maxstep;
init.ignore (256, '\n');
init >> cfl;
init.ignore (256, '\n');
init >> printtime;
init.ignore (256, '\n');
init >> delta_x;
init.ignore (256, '\n');
init >> gammag;
init.ignore (256, '\n');
init >> maxtime;
init.ignore (256, '\n');
init >> probtype;
init.close ();
gammam1 = gammag - 1;
nz = 1;
Array3D < zone > grid (nx, ny, nz);
Array3D < zone > gridh (nx, ny, nz);
Array3D < zone > gridn (nx, ny, nz);
Array3D < zone > fx (nx, ny, nz);
Array3D < zone > fy (nx, ny, nz);
Array3D < zone > xResState (nx, ny, nz);
Array3D < zone > yResState (nx, ny, nz);
delta_x = 1.0 / nx;
cout << "\t\t\t2D Roe Solver Code" << endl;
cout << "\t\t\tVersion 2.0" << endl;
cout << "\t\t\tNo of steps = " << maxstep << endl;
cout << "\t\t\tNX = " << nx << endl;
cout << "\t\t\tNY = " << ny << endl;
cout << "\t\t\tNE = " << ne << endl;
cout << "\t\t\tCFL = " << cfl << endl;
cout << "\t\t\tdel_x = " << delta_x << endl;
cout << "\t\t\tGamma = " << gammag << endl;
#ifdef SECOND_ORDER_TIME
cout << "\t\t\t2nd Order Time and Space " << endl;
#endif /* SECOND_ORDER_TIME */
#ifdef LAPIDUS_VISCOSITY
cout << "\t\t\tLapidus Viscosity " << endl;
#endif /* LAPIDUS_VISCOSITY */
cout << endl;
cout << endl;
// Set up initial values of conserved variables on the grid */
if (probtype == "Shock")
{
if (argc > 1)
{
rc = initialise (argv[1], grid, &maxstep, &cfl);
}
else
{
rc = initialise ("input/gaz1", grid, &maxstep, &cfl);
}
}
else if (probtype == "Jet")
{
if (argc > 1)
{
rc = initialise_jet (argv[1], grid, &maxstep, &cfl);
}
else
{
rc = initialise_jet ("input/input.jet", grid, &maxstep, &cfl);
}
}
else if (probtype == "Blast")
{
if (argc > 1)
{
rc = initialise_blast (argv[1], grid, &maxstep, &cfl);
}
else
{
rc = initialise_blast ("input/input.jet", grid, &maxstep, &cfl);
}
}
/* Print out the initial array */
fin.open ("infile.txt");
for (ii = 0; ii < nx; ii++)
{
for (jj = 0; jj < ny; jj++)
{
fin << ii
<< " " << jj
<< " " << grid[ii][jj][kk] _MASS
<< " " << grid[ii][jj][kk] _MOMX
<< " " << grid[ii][jj][kk] _MOMY
<< " " << grid[ii][jj][kk] _MOMZ
<< " " << grid[ii][jj][kk] _ENER
<< " " << grid[ii][jj][kk] _B_X
<< " " << grid[ii][jj][kk] _B_Y
<< " " << grid[ii][jj][kk] _B_Z << endl;
}
}
fin.close ();
#ifdef DEBUG1
for (ii = 0; ii < nx; ii++)
{
for (jj = 0; jj < ny; jj++)
{
cout << grid[ii][jj][kk] _MASS << "\t";
}
cout << endl;
}
#endif
/* Using a second order in time Runge-Kutta method, advect the array */
rc = output (grid, fx, fy, 0, "out_2d_");
for (timestep = 1; timestep < maxstep; timestep++)
{
for (int k = 0; k < ne; k++)
{
maxvar.array[k] = 0.;
minvar.array[k] = 999.;
}
/* Set the maximum wave speed to zero */
*maximumspeed = 0;
/* Determine the maximum wave speed for use in
* the time step */
rc = maxspeed (grid, maximumspeed);
/* Determine a value for time advance and courant number based on the
* maximum wave speed */
del = cfl / *maximumspeed;
delh = 0.5 * del;
delta_t = del * delta_x;
dtodx = 1.0/ *maximumspeed;
time = time + delta_t;
#ifdef VERBOSE_OUTPUT
cout << "Tstep= " << setiosflags (ios::scientific) << timestep;
cout << "\tTime= " << setiosflags (ios::scientific) << time;
cout << "\tMaxspeed= " << setiosflags (ios::
scientific) << *maximumspeed;
cout << "\t dt = " << setiosflags (ios::scientific) << delta_t;
cout << "\tCFL= " << setiosflags (ios::scientific) << del;
cout << endl;
#endif /* VERBOSE_OUTPUT */
// rc = output ( grid, fx, fy, timestep, "oldg_2d_");
#ifdef SECOND_ORDER_TIME
jj = 0;
#ifdef TWODIM
for (jj = 2; jj < ny - 1; jj++)
#endif /* TWODIM */
{
for (ii = 2; ii < nx - 1; ii++)
{
rc =
flux (grid, fx[ii][jj][kk].array, xResState[ii][jj][kk].array, dtodx,
ii, jj, timestep, 1, 0);
#ifdef TWODIM
rc =
flux (grid, fy[ii][jj][kk].array, yResState[ii][jj][kk].array,dtodx,
ii, jj, timestep, 2, 0);
#endif /* TWODIM */
}
}
//#ifdef TWODIM
// for (jj = 2; jj < ny - 2; jj++)
//#endif /* TWODIM */
// {
// for (ii = 2; ii < nx - 2; ii++)
// {
rc =
update (gridh, grid, fx, fy, xResState, yResState, delh, ii, jj,
timestep, grid, delta_t, 0);
// }
// }
/* Boundary Conditions */
rc = boundary (gridh, inject_jet);
/* End Boundary Conditions */
#ifdef DEBUG_HALFSTEP
if (timestep % printtime == 0)
{
rc = output (gridh, fx, fy, timestep, "hout_2d_");
}
#endif /* DEBUG HALFSTEP */
#ifdef TWODIM
for (jj = 2; jj < ny - 1; jj++)
#endif /* TWODIM */
{
for (ii = 2; ii < nx - 1; ii++)
{
rc =
flux (gridh, fx[ii][jj][kk].array,
xResState[ii][jj][kk].array,dtodx, ii, jj, timestep, 1, 1);
#ifdef TWODIM
rc =
flux (gridh, fy[ii][jj][kk].array,
yResState[ii][jj][kk].array,dtodx, ii, jj, timestep, 2, 1);
#endif /* TWODIM */
}
}
rc =
update (gridn, grid, fx, fy, xResState, yResState, del, ii, jj,
timestep, gridh, delta_t, 1);
#ifdef TWODIM
for (jj = 2; jj < ny - 2; jj++)
#endif /* TWODIM */
{
for (ii = 2; ii < nx - 2; ii++)
{
for (int k = 0; k < ne; k++)
{
maxvar.array[k] =
(maxvar.array[k] >
gridn[ii][jj][kk].array[k] ? maxvar.
array[k] : gridn[ii][jj][kk].array[k]);
minvar.array[k] =
(minvar.array[k] <
gridn[ii][jj][kk].array[k] ? minvar.
array[k] : gridn[ii][jj][kk].array[k]);
}
}
}
grid = gridn.copy ();
// rc = output ( gridh, fx, fy, timestep, "hout_2d_");
#else /* First order */
#ifdef TWODIM
for (jj = 2; jj < ny - 1; jj++)
#endif /* TWODIM */
{
for (ii = 2; ii < nx - 1; ii++)
{
rc =
flux (grid, fx[ii][jj][kk].array, xResState[ii][jj][kk].array,dtodx,
ii, jj, timestep, 1, 0);
#ifdef TWODIM
rc =
flux (grid, fy[ii][jj][kk].array, yResState[ii][jj][kk].array,dtodx,
ii, jj, timestep, 2, 0);
#endif /* TWODIM */
}
}
rc =
update (gridn, grid, fx, fy, xResState, yResState, del, ii, jj,
timestep, grid, delta_t, 0);
#ifdef TWODIM
for (jj = 2; jj < ny - 2; jj++)
#endif /* TWODIM */
{
for (ii = 2; ii < nx - 2; ii++)
{
for (int k = 0; k < ne; k++)
{
maxvar.array[k] =
(maxvar.array[k] >
gridn[ii][jj][kk].array[k] ? maxvar.
array[k] : gridn[ii][jj][kk].array[k]);
minvar.array[k] =
(minvar.array[k] <
gridn[ii][jj][kk].array[k] ? minvar.
array[k] : gridn[ii][jj][kk].array[k]);
}
}
}
grid = gridn.copy ();
#endif
/* Boundary Conditions */
rc = boundary (grid, inject_jet);
/* End Boundary Conditions */
cout << setiosflags (ios::fixed);
for (int k = 0; k < ne; k++)
{
cout << k +
1 << " " << maxvar.array[k] << " " << minvar.array[k] << endl;
}
if (timestep % printtime == 0)
{
// cout << "outputting " << endl;
rc = output (grid, fx, fy, timestep, "out_2d_");
}
if (time > maxtime)
{
rc = output (grid, fx, fy, timestep, "out_2d_");
break;
}
/* ------------- */
/* End of loop through timestep */
}
/* ------------- */
end = clock ();
elapsed = ((double) (end - start)) / CLOCKS_PER_SEC;
cout << "\n\n Elapsed time = " << elapsed << " sec\n\n" << endl;
return 0;
}
void Tri2dFCBlockSolver::output(const int& nBlocks,
const int& step)
{
// create output directory for this unsteady step
stringstream a;
a.str("");
a.clear();
a << "mkdir -p output." << step;
system(a.str().c_str());
a.str("");
a.clear();
// output solution file
if (nOutputVars > 0){
// determine error at the plotting points
Array2D<double> qe(nNode,nq),er(nNode,nq);
sys->initFlow(nNode,
&x(0,0),
&qe(0,0));
for (int n=0; n<nNode; n++)
for (int k=0; k<nq; k++) er(n,k) =(q(n,k)-qe(n,k))/rmsNorm(k);
// output the step header information if on block 0
if (ID == 0){
ofstream ffile;
a << "triSolution" << step << ".pvtu";
ffile.open (a.str().c_str());
a.str("");
a.clear();
ffile.setf(ios::scientific);
ffile.precision(14);
ffile << "<?xml version=\"1.0\"?>"
<< endl
<< "<VTKFile type=\"PUnstructuredGrid\" "
<< "version=\"0.1\" byte_order=\"LittleEndian\">"
<< endl
<< "<PUnstructuredGrid GhostLevel=\"0\">"
<< endl
<< "<PPointData ";
if (nOutputScalars > 0){
ffile << "Scalars=\"";
int k=0;
for (int n=0; n<nOutputVars; n++)
if (outputVarLength(n) == 1){
if (k != 0) ffile << " ";
k++;
ffile << outputVars(n);
}
ffile << "\"";
if (nOutputVectors > 0) ffile << " ";
}
if (nOutputVectors > 0){
ffile << "Vectors=\"";
int k=0;
for (int n=0; n<nOutputVars; n++)
if (outputVarLength(n) == 3){
if (k != 0) ffile << " ";
k++;
ffile << outputVars(n);
}
ffile << "\"";
}
ffile << ">"
<< endl;
for (int n=0; n<nOutputVars; n++){
ffile << "<PDataArray type=\"Float32\" Name=\""
<< outputVars(n) << "\"";
if (outputVarLength(n) == 3) ffile << " NumberOfComponents=\"3\"";
ffile << "/>"
<< endl;
}
ffile << "</PPointData>"
<< endl
<< "<PPoints>"
<< endl
<< "<PDataArray type=\"Float32\" NumberOfComponents=\"3\"/>"
<< endl
<< "</PPoints>"
<< endl;
for (int n=0; n<nBlocks; n++){
a << "<Piece Source=\"output." << step
<< "/triSolutionBlock" << n << ".vtu\"/>";
ffile << a.str()
<< endl;
a.str("");
a.clear();
}
ffile << "</PUnstructuredGrid>"
<< endl
<< "</VTKFile>"
<< endl;
ffile.close();
}
// write data to file for this block
ofstream ffile;
a << "triSolutionBlock" << ID << ".vtu";
ffile.open (a.str().c_str());
ffile.setf(ios::scientific);
ffile.precision(14);
a.str("");
a.clear();
ffile << "<?xml version=\"1.0\"?>"
<< endl
<< "<VTKFile type=\"UnstructuredGrid\" version=\"0.1"
<<"\" byte_order=\"LittleEndian\">"
<< endl
<< "<UnstructuredGrid>"
<< endl
<< "<Piece NumberOfPoints=\""
<< nNode
<<"\" NumberOfCells=\""
<< nTri << "\">"
<< endl
<< "<PointData ";
if (nOutputScalars > 0){
ffile << "Scalars=\"";
int k=0;
for (int n=0; n<nOutputVars; n++)
if (outputVarLength(n) == 1){
if (k != 0) ffile << " ";
k++;
ffile << outputVars(n);
}
ffile << "\"";
if (nOutputVectors > 0) ffile << " ";
}
if (nOutputVectors > 0){
ffile << "Vectors=\"";
int k=0;
for (int n=0; n<nOutputVars; n++)
if (outputVarLength(n) == 3){
if (k != 0) ffile << " ";
k++;
ffile << outputVars(n);
}
ffile << "\"";
}
ffile << ">"
<< endl;
for (int n=0; n<nOutputVars; n++){
if (outputVarLength(n) == 1){
ffile << "<DataArray type=\"Float32\" Name=\""
<< outputVars(n)
<< "\" format=\"ascii\">"
<< endl;
}
else{
ffile << "<DataArray type=\"Float32\" Name=\""
<< outputVars(n)
<< "\" NumberOfComponents=\"3\" format=\"ascii\">"
<< endl;
}
sys->outputSolution(nNode,
ffile,
outputVars(n),
&q(0,0),
&qa(0,0),
&er(0,0),
&r(0,0));
ffile << "</DataArray>" << endl;
}
ffile << "</PointData>" << endl
<< "<Points>" << endl
<< "<DataArray type=\"Float32\" NumberOfComponents"
<< "=\"3\" format=\"ascii\">" << endl;
double xn,yn,eps=1.e-14;
for (int n=0; n<nNode; n++){
xn = x(n,0);
yn = x(n,1);
if (fabs(x(n,0)) < eps) xn = 0.;
if (fabs(x(n,1)) < eps) yn = 0.;
ffile << xn << "\t" << yn << "\t" << 0. << endl;
}
ffile << "</DataArray>" << endl
<< "</Points>" << endl
<< "<Cells>" << endl
<< "<DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">"
<< endl;
for (int n=0; n<nTri; n++)
ffile << tri(n,0) << "\t"
<< tri(n,1) << "\t"
<< tri(n,2) << endl;
ffile << "</DataArray>" << endl
<<"<DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">"
<< endl;
int k = 0;
for (int n=0; n<nTri; n++){
k += 3;
ffile << k << endl;
}
ffile << "</DataArray>" << endl
<< "<DataArray type=\"Int32\" Name=\"types\" format=\"ascii\">"
<< endl;
for (int n=0; n<nTri; n++) ffile << 5 << endl;
ffile << "</DataArray>" << endl
<< "</Cells>" << endl
<< "</Piece>" << endl
<< "</UnstructuredGrid>" << endl
<< "</VTKFile>" << endl;
ffile.close();
a << "mv triSolutionBlock" << ID << ".vtu output." << step;
system(a.str().c_str());
a.str("");
a.clear();
// output L2 norm of solution error
if (iErrFile != 0){
ofstream efile;
//a << "triErrorBlock" << ID << ".dat";
a << "error.dat";
efile.open(a.str().c_str(),ios::app);
efile.setf(ios::scientific);
efile.precision(14);
a.str("");
a.clear();
double erms[nq];
for (int k=0; k<nq; k++) erms[k] = 0.;
for (int n=0; n<nNode; n++)
for (int k=0; k<nq; k++) erms[k] += pow(er(n,k),2);
for (int k=0; k<nq; k++) erms[k] = sqrt(erms[k]/(double)nNode);
efile << sqrt((double)nNode) << "\t";
for (int k=0; k<nq; k++) efile << erms[k] << "\t";
efile << endl;
efile.close();
//a << "mv triErrorBlock" << ID << ".dat output." << step;
//system(a.str().c_str());
//a.str("");
//a.clear();
cout.setf(ios::scientific);
cout << "\nError statistics: " << endl;
cout << sqrt((double)nNode) << "\t";
for (int k=0; k<nq; k++) cout << erms[k] << "\t";
cout << endl;
}
// deallocate work arrays
qe.deallocate();
er.deallocate();
}
// output surface data to file
if (iSurfFile != 0){
ofstream sfile;
a << "triSurfaceBlock" << ID << ".dat";
if (step == 0) sfile.open (a.str().c_str());
else sfile.open (a.str().c_str(),ios::app);
sfile.setf(ios::scientific);
sfile.precision(14);
a.str("");
a.clear();
Array3D<double> qax;
qax.allocate(nNode,2,nqa);
gradient(nq,&q(0,0),&qx(0,0,0));
gradient(nqa,&qa(0,0),&qax(0,0,0));
int m=0;
for (int n=nNode-nNodeBd; n<nNode; n++)
sys->outputSurfaceSolution(1,
sfile,
&nodeBd(m++),
&x(n,0),
&x(n,1),
&q(n,0),
&qa(n,0),
&qx(n,0,0),
&qx(n,1,0),
&qax(n,0,0),
&qax(n,1,0));
qax.deallocate();
a << "mv triSurfaceBlock" << ID << ".dat output." << step;
system(a.str().c_str());
a.str("");
a.clear();
ofstream ffile; //force file
a << "forces.dat";
if (step == 0) ffile.open (a.str().c_str());
else ffile.open (a.str().c_str(),ios::app);
ffile.setf(ios::scientific);
ffile.precision(14);
a.str("");
a.clear();
forcex = 0.;
forcey = 0.;
int jj,nn,tag;
double dd,dx,dy,
qQ[nq],qxQ[nq],qyQ[nq],qaQ[nqa],qaxQ[nqa],qayQ[nqa],force[ndim];
for (int n=0; n<nEdgeQ; n++){
nn = edgeQ(n,0); // element on which lies this edge
jj = edgeQ(n,1); // edge number on the element
tag = edgeQ(n,2); // boundary tag for the edge
for (int i=0; i<nsq; i++){ //for each surface quadrature point
// interpolate solution and gradients to the quadrature points
for (int k=0; k<nq ; k++) qQ[k] = 0.;
for (int k=0; k<nq ; k++) qxQ[k] = 0.;
for (int k=0; k<nq ; k++) qyQ[k] = 0.;
for (int k=0; k<nqa; k++) qaQ[k] = 0.;
for (int k=0; k<nqa; k++) qaxQ[k] = 0.;
for (int k=0; k<nqa; k++) qayQ[k] = 0.;
for (int j=0; j<nne; j++){
dd = gxS(n,i,j,0);
dx = gxS(n,i,j,1);
dy = gxS(n,i,j,2);
m = elem(nn,j);
for (int k=0; k<nq ; k++){
qQ [k] += q (m,k)*dd;
qxQ [k] += q (m,k)*dx;
qyQ [k] += q (m,k)*dy;
}
for (int k=0; k<nqa; k++){
qaQ [k] += qa(m,k)*dd;
qaxQ[k] += qa(m,k)*dx;
qayQ[k] += qa(m,k)*dy;
}}
// compute surface force contribution
sys->outputSurfaceForces(1,
&tag,
&nxQ(n,i,0),
&qQ[0],
&qxQ[0],
&qyQ[0],
&qaQ[0],
&qaxQ[0],
&qayQ[0],
&force[0]);
forcex += force[0];
forcey += force[1];
}}
cout << "\nx-component force: " << forcex << endl;
cout << "y-component force: " << forcey << endl;
cout << "\n";
ffile << step << " " << double(step)*dtUnsteady
<< " " << forcex << " " << forcey << endl;
ffile.close();
}
}
