Skip to content
Snippets Groups Projects
Commit 86fda3df authored by Konstantin Kutscher's avatar Konstantin Kutscher
Browse files

add new averaging workflow for fluctuations and stresses

parent 5ba98523
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
source/Applications/bChannelVA/Averaging.cpp
+ 84
− 19
View file @ 86fda3df
......@@ -579,6 +579,7 @@ void Averaging::volumeAveragingWithMPI(double l_real)
//#pragma omp parallel num_threads(4) //private(i)
{
int i = 0;
#pragma omp parallel for //private(i)//scheduler(dynamic, 1)
for (int x3 = 0; x3 < dimensions[2]; x3++)
for (int x2 = 0; x2 < dimensions[1]; x2++)
......@@ -596,9 +597,15 @@ void Averaging::volumeAveragingWithMPI(double l_real)
double pr = 0.0;
int ll = (int)l;
int llz1 = ll;
int llz2 = ll;
if (x3 - ll < 0) llz1 = x3;
if (x3 + ll >= dimensions[2]) llz1 = dimensions[2] - 1 - x3;
//#pragma omp parallel for
for (int z = -ll; z <= +ll; z++)
for (int z = -llz1; z <= +llz2; z++)
for (int y = -ll; y <= +ll; y++)
for (int x = -ll; x <= +ll; x++)
{
......@@ -613,7 +620,7 @@ void Averaging::volumeAveragingWithMPI(double l_real)
if (yy < 0) yy = dimensions[1] + yy;
if (yy >= dimensions[1]) yy = yy - dimensions[1];
if (zz < 0) zz = 0;
if (zz < 0) zz = 0;
if (zz >= dimensions[2]) zz = dimensions[2] - 1;
double mm = (G((double)x, l)*G((double)y, l)*G((double)z, l)) / lNorm;
......@@ -942,6 +949,10 @@ void Averaging::initFluctuations()
FlucVyMatrix.resize(dimensions[0], dimensions[1], dimensions[2], 0);
FlucVzMatrix.resize(dimensions[0], dimensions[1], dimensions[2], 0);
FlucPrMatrix.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaFlucVxMatrix.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaFlucVyMatrix.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaFlucVzMatrix.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaFlucPrMatrix.resize(dimensions[0], dimensions[1], dimensions[2], 0);
}
void Averaging::initSumOfVaFluctuations()
{
......@@ -997,7 +1008,49 @@ void Averaging::fluctuationsStress()
XZStress[i] = vxFluc[i] * vzFluc[i];
YZStress[i] = vyFluc[i] * vzFluc[i];
}
}
}
void Averaging::fluctuationsStress2()
{
vector<double>& vxVa = vaVxMatrix.getDataVector();
vector<double>& vyVa = vaVyMatrix.getDataVector();
vector<double>& vzVa = vaVzMatrix.getDataVector();
vector<double>& prVa = vaPrMatrix.getDataVector();
vector<double>& vxMean = meanVaVxMatrix.getDataVector();
vector<double>& vyMean = meanVaVyMatrix.getDataVector();
vector<double>& vzMean = meanVaVzMatrix.getDataVector();
vector<double>& prMean = meanVaPrMatrix.getDataVector();
vector<double>& vxFluc = vaFlucVxMatrix.getDataVector();
vector<double>& vyFluc = vaFlucVyMatrix.getDataVector();
vector<double>& vzFluc = vaFlucVzMatrix.getDataVector();
vector<double>& prFluc = vaFlucPrMatrix.getDataVector();
vector<double>& XXStress = vaStressXX.getDataVector();
vector<double>& YYStress = vaStressYY.getDataVector();
vector<double>& ZZStress = vaStressZZ.getDataVector();
vector<double>& XYStress = vaStressXY.getDataVector();
vector<double>& XZStress = vaStressXZ.getDataVector();
vector<double>& YZStress = vaStressYZ.getDataVector();
int size = (int)vxVa.size();
for (int i = 0; i < size; i++)
{
vxFluc[i] = vxVa[i] - vxMean[i];
vyFluc[i] = vyVa[i] - vyMean[i];
vzFluc[i] = vzVa[i] - vzMean[i];
prFluc[i] = prVa[i] - prMean[i];
XXStress[i] = vxFluc[i] * vxFluc[i];
YYStress[i] = vyFluc[i] * vyFluc[i];
ZZStress[i] = vzFluc[i] * vzFluc[i];
XYStress[i] = vxFluc[i] * vyFluc[i];
XZStress[i] = vxFluc[i] * vzFluc[i];
YZStress[i] = vyFluc[i] * vzFluc[i];
}
}
void Averaging::sumOfVaFluctuations()
{
......@@ -1048,10 +1101,10 @@ void Averaging::meanOfVaFluctuations(int numberOfTimeSteps)
}
void Averaging::writeVaFluctuationsToBinaryFiles(std::string fname, int timeStep)
{
writeMatrixToBinaryFiles<double>(vaFlucVxMatrix, fname + "fluctVx" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaFlucVyMatrix, fname + "fluctVy" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaFlucVzMatrix, fname + "fluctVz" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaFlucPrMatrix, fname + "fluctPr" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaFlucVxMatrix, fname + "Vx" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaFlucVyMatrix, fname + "Vy" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaFlucVzMatrix, fname + "Vz" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaFlucPrMatrix, fname + "Pr" + UbSystem::toString(timeStep) + ".bin");
}
void Averaging::readVaFluctuationsFromBinaryFiles(std::string fname, int timeStep)
{
......@@ -1099,6 +1152,12 @@ void Averaging::initStresses()
StressXY.resize(dimensions[0], dimensions[1], dimensions[2], 0);
StressXZ.resize(dimensions[0], dimensions[1], dimensions[2], 0);
StressYZ.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaStressXX.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaStressYY.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaStressZZ.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaStressXY.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaStressXZ.resize(dimensions[0], dimensions[1], dimensions[2], 0);
vaStressYZ.resize(dimensions[0], dimensions[1], dimensions[2], 0);
}
void Averaging::initSumOfVaStresses()
{
......@@ -1176,21 +1235,21 @@ void Averaging::meanOfVaStresses(int numberOfTimeSteps)
}
void Averaging::writeVaStressesToBinaryFiles(std::string fname, int timeStep)
{
writeMatrixToBinaryFiles<double>(vaStressXX, fname + UbSystem::toString(timeStep) + "stressXX" + ".bin");
writeMatrixToBinaryFiles<double>(vaStressYY, fname + UbSystem::toString(timeStep) + "stressYY" + ".bin");
writeMatrixToBinaryFiles<double>(vaStressZZ, fname + UbSystem::toString(timeStep) + "stressZZ" + ".bin");
writeMatrixToBinaryFiles<double>(vaStressXY, fname + UbSystem::toString(timeStep) + "stressXY" + ".bin");
writeMatrixToBinaryFiles<double>(vaStressXZ, fname + UbSystem::toString(timeStep) + "stressXZ" + ".bin");
writeMatrixToBinaryFiles<double>(vaStressYZ, fname + UbSystem::toString(timeStep) + "stressYZ" + ".bin");
writeMatrixToBinaryFiles<double>(vaStressXX, fname + "XX" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaStressYY, fname + "YY" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaStressZZ, fname + "ZZ" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaStressXY, fname + "XY" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaStressXZ, fname + "XZ" + UbSystem::toString(timeStep) + ".bin");
writeMatrixToBinaryFiles<double>(vaStressYZ, fname + "YZ" + UbSystem::toString(timeStep) + ".bin");
}
void Averaging::readVaStressesFromBinaryFiles(std::string fname, int timeStep)
{
readMatrixFromBinaryFiles<double>(fname + UbSystem::toString(timeStep) + "XX" + ".bin", vaStressXX);
readMatrixFromBinaryFiles<double>(fname + UbSystem::toString(timeStep) + "YY" + ".bin", vaStressYY);
readMatrixFromBinaryFiles<double>(fname + UbSystem::toString(timeStep) + "ZZ" + ".bin", vaStressZZ);
readMatrixFromBinaryFiles<double>(fname + UbSystem::toString(timeStep) + "XY" + ".bin", vaStressXY);
readMatrixFromBinaryFiles<double>(fname + UbSystem::toString(timeStep) + "XZ" + ".bin", vaStressXZ);
readMatrixFromBinaryFiles<double>(fname + UbSystem::toString(timeStep) + "YZ" + ".bin", vaStressYZ);
readMatrixFromBinaryFiles<double>(fname + "XX" + UbSystem::toString(timeStep) + ".bin", vaStressXX);
readMatrixFromBinaryFiles<double>(fname + "YY" + UbSystem::toString(timeStep) + ".bin", vaStressYY);
readMatrixFromBinaryFiles<double>(fname + "ZZ" + UbSystem::toString(timeStep) + ".bin", vaStressZZ);
readMatrixFromBinaryFiles<double>(fname + "XY" + UbSystem::toString(timeStep) + ".bin", vaStressXY);
readMatrixFromBinaryFiles<double>(fname + "XZ" + UbSystem::toString(timeStep) + ".bin", vaStressXZ);
readMatrixFromBinaryFiles<double>(fname + "YZ" + UbSystem::toString(timeStep) + ".bin", vaStressYZ);
}
void Averaging::writeMeanVaStressesToBinaryFiles(std::string fname)
{
......@@ -1211,6 +1270,12 @@ void Averaging::readMeanVaStressesFromBinaryFiles(std::string fname)
readMatrixFromBinaryFiles<double>(fname + "YZ" + ".bin", meanVaStressYZ);
}
void Averaging::writeMeanOfVaStressesToImageFile(std::string ffname)
{
array < CbArray3D<double>, 4 > matrix = { meanVaStressXX, meanVaStressYY, meanVaStressZZ, meanVaStressXY };
writeMatrixToImageFile(ffname, matrix);
}
//------------------------------------ planar --------------------------
void Averaging::initPlanarAveraging()
{
......
source/Applications/bChannelVA/Averaging.h
+ 2
− 0
View file @ 86fda3df
......@@ -41,6 +41,7 @@ public:
void initMeanOfVaFluctuations();
void initSumOfVaFluctuations();
void fluctuationsStress();
void fluctuationsStress2();
void meanOfVaFluctuations(int numberOfTimeSteps);
void sumOfVaFluctuations();
void writeVaFluctuationsToBinaryFiles(std::string fname, int timeStep);
......@@ -60,6 +61,7 @@ public:
void readVaStressesFromBinaryFiles(std::string fname, int timeStep);
void writeMeanVaStressesToBinaryFiles(std::string ffname);
void readMeanVaStressesFromBinaryFiles(std::string ffname);
void writeMeanOfVaStressesToImageFile(std::string ffname);
void initPlanarAveraging();
void planarAveraging();
......
source/Applications/bChannelVA/bChannelVA.cpp
+ 222
− 134
View file @ 86fda3df
......@@ -10,139 +10,227 @@ using namespace std;
//////////////////////////////////////////////////////////////////////////
int main(int argc, char* argv[])
{
try
{
SPtr<Communicator> comm = MPICommunicator::getInstance();
int myid = comm->getProcessID();
//Pheonix
//double deltaX = 1;
//double halfDeltaX = deltaX / 2.0;
//std::array<int, 3> dimensions = { 600 / (int)deltaX, 400 / (int)deltaX, 400 / (int)deltaX };
//std::array<double, 3> geo_origin = { halfDeltaX, halfDeltaX, halfDeltaX };
//std::array<double, 3> geo_spacing = { 1,1,1 };
//std::array<int, 6> geo_extent = { 0, dimensions[0] - 1, 0, dimensions[1] - 1, 0, dimensions[2] - 1 };
//double real_l = 40;
//double l = 40;
//int startTimeStep = 600000;
//int timeStep = 10000;
//int numberOfTimeSteps = 610000; //1200000;
//int numberOfSamples = numberOfTimeSteps / startTimeStep;
//int numberOfGridPoints = dimensions[0] * dimensions[1] * dimensions[2];
//Bombadil
string pathIn = "d:/temp/BreugemChannelAnisotrop";
string pathOut = "d:/temp/BreugemChannelAnisotrop";
double deltaX = 10;
double halfDeltaX = deltaX / 2.0;
std::array<int, 3> dimensions = { 600/(int)deltaX, 400/(int)deltaX, 400/(int)deltaX };
std::array<double, 3> geo_origin = { halfDeltaX, halfDeltaX, halfDeltaX };
std::array<double, 3> geo_spacing = { 10,10,10 };
std::array<int, 6> geo_extent = { 0, dimensions[0] - 1, 0, dimensions[1] - 1, 0, dimensions[2] - 1 };
double real_l = 40;
double l = 40;
int startTimeStep = 100;
int timeStep = 100;
int numberOfTimeSteps = 500;
int numberOfSamples = (numberOfTimeSteps - startTimeStep)/timeStep + 1;
int numberOfGridPoints = dimensions[0] * dimensions[1] * dimensions[2];
Averaging av;
av.setDimensions(dimensions);
av.setExtent(geo_extent);
av.setOrigin(geo_origin);
av.setSpacing(geo_spacing);
av.setDeltaX(deltaX);
av.createGeoMatrix(pathIn + "/bc/bc0.pvtu");
if (myid == 0) av.writeGeoMatrixToBinaryFiles(pathOut + "/va/geomatrix.bin");
//av.readGeoMatrixFromBinaryFiles(pathOut + "/va/geomatrix.bin");
av.initVolumeAveragingValues();
for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
{
av.createMQMatrix(pathIn + "/mq/mq" + UbSystem::toString(t) + ".pvtu");
if (myid == 0) av.writeMqMatrixToBinaryFiles(pathOut + "/va/mq/mq" + UbSystem::toString(t) + "/mq", t);
av.volumeAveragingWithMPI(real_l);
if (myid == 0)
{
av.sumOfVolumeAveragingValues();
av.writeVolumeAveragingValuesToBinaryFiles(pathOut + "/va/vav/vav", t);
}
}
//av.writeMqMatrixToImageFile(pathOut + "/va/vav/mq");
//if (myid == 0) av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", 60000);
//if (myid == 0) av.writeVaMatrixToImageFile(pathOut + "/va/vav/vav");
if (myid == 0)
{
av.initMeanVolumeAveragingValues();
av.meanOfVolumeAveragingValues(numberOfSamples);
av.writeMeanVolumeAveragingValuesToBinaryFiles(pathOut + "/va/mean/mean");
av.writeMeanMatrixToImageFile(pathOut + "/va/vav/vavMean");
}
//for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
//{
// av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", t);
// av.sumOfVolumeAveragingValues();
//}
//av.initMeanVolumeAveragingValues();
//av.meanOfVolumeAveragingValues(numberOfSamples);
//av.writeMeanVolumeAveragingValuesToBinaryFiles(pathOut + "/va/mean/mean");
//av.writeMeanMatrixToImageFile(pathOut + "/va/vav/vavMean");
av.initFluctuations();
av.initSumOfVaFluctuations();
av.initMeanOfVaFluctuations();
av.initStresses();
av.initSumOfVaStresses();
av.initMeanOfVaStresses();
av.initPlanarAveraging();
av.initVolumeAveragingFluctStressValues();
for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
{
//av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", t);
//av.readMqMatrixFromBinaryFiles(pathOut + "/va/mq/mq" + UbSystem::toString(t) + "/mq", t);
av.fluctuationsStress();
av.writeFluctuationsToImageFile(pathOut + "/va/vav/vaFluct");
av.volumeAveragingFluctStressWithMPI(real_l);
av.writeVaFluctuationsToBinaryFiles(pathOut + "/va/av/Fluc", t);
av.writeVaStressesToBinaryFiles(pathOut + "/va/av/Stresses", t);
av.writeVaFluctuationsToImageFile(pathOut + "/va/vav/vaVAFluct");
av.sumOfVaFluctuations();
av.sumOfVaStresses();
}
av.meanOfVaFluctuations(numberOfSamples);
av.meanOfVaStresses(numberOfSamples);
av.writeMeanOfVaFluctuationsToImageFile(pathOut + "/va/vav/vaMeanFluct");
av.planarAveraging();
av.writeToCSV(pathOut + "/va/av", geo_origin[2], deltaX);
}
catch (const std::exception& e)
{
cerr << e.what() << endl << flush;
}
catch (std::string& s)
{
cerr << s << endl;
}
catch (...)
{
cerr << "unknown exception" << endl;
}
try
{
SPtr<Communicator> comm = MPICommunicator::getInstance();
int myid = comm->getProcessID();
//Pheonix
//double deltaX = 1;
//double halfDeltaX = deltaX / 2.0;
//std::array<int, 3> dimensions = { 600 / (int)deltaX, 400 / (int)deltaX, 400 / (int)deltaX };
//std::array<double, 3> geo_origin = { halfDeltaX, halfDeltaX, halfDeltaX };
//std::array<double, 3> geo_spacing = { 1,1,1 };
//std::array<int, 6> geo_extent = { 0, dimensions[0] - 1, 0, dimensions[1] - 1, 0, dimensions[2] - 1 };
//double real_l = 40;
//double l = 40;
//int startTimeStep = 600000;
//int timeStep = 10000;
//int numberOfTimeSteps = 610000; //1200000;
//int numberOfSamples = numberOfTimeSteps / startTimeStep;
//int numberOfGridPoints = dimensions[0] * dimensions[1] * dimensions[2];
//Bombadil
string pathIn = "d:/temp/BreugemChannelAnisotrop2";
string pathOut = "d:/temp/BreugemChannelAnisotrop2";
double deltaX = 10;
double halfDeltaX = deltaX / 2.0;
std::array<int, 3> dimensions = { 600 / (int)deltaX, 400 / (int)deltaX, 400 / (int)deltaX };
std::array<double, 3> geo_origin = { halfDeltaX, halfDeltaX, halfDeltaX };
std::array<double, 3> geo_spacing = { 10,10,10 };
std::array<int, 6> geo_extent = { 0, dimensions[0] - 1, 0, dimensions[1] - 1, 0, dimensions[2] - 1 };
double real_l = 40;
double l = 40;
int startTimeStep = 60000;
int timeStep = 1000;
int numberOfTimeSteps = 65000;
int numberOfSamples = (numberOfTimeSteps - startTimeStep) / timeStep + 1;
int numberOfGridPoints = dimensions[0] * dimensions[1] * dimensions[2];
//Averaging av;
//av.setDimensions(dimensions);
//av.setExtent(geo_extent);
//av.setOrigin(geo_origin);
//av.setSpacing(geo_spacing);
//av.setDeltaX(deltaX);
//av.createGeoMatrix(pathIn + "/bc/bc0.pvtu");
//if (myid == 0) av.writeGeoMatrixToBinaryFiles(pathOut + "/va/geomatrix.bin");
////av.readGeoMatrixFromBinaryFiles(pathOut + "/va/geomatrix.bin");
//av.initVolumeAveragingValues();
//for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
//{
// av.createMQMatrix(pathIn + "/mq/mq" + UbSystem::toString(t) + ".pvtu");
// if (myid == 0) av.writeMqMatrixToBinaryFiles(pathOut + "/va/mq/mq" + UbSystem::toString(t) + "/mq", t);
// av.volumeAveragingWithMPI(real_l);
// if (myid == 0)
// {
// av.sumOfVolumeAveragingValues();
// av.writeVolumeAveragingValuesToBinaryFiles(pathOut + "/va/vav/vav", t);
// }
//}
////av.writeMqMatrixToImageFile(pathOut + "/va/vav/mq");
////if (myid == 0) av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", 60000);
////if (myid == 0) av.writeVaMatrixToImageFile(pathOut + "/va/vav/vav");
//if (myid == 0)
//{
// av.initMeanVolumeAveragingValues();
// av.meanOfVolumeAveragingValues(numberOfSamples);
// av.writeMeanVolumeAveragingValuesToBinaryFiles(pathOut + "/va/mean/mean");
// av.writeMeanMatrixToImageFile(pathOut + "/va/vav/vavMean");
//}
////for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
////{
//// av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", t);
//// av.sumOfVolumeAveragingValues();
////}
////av.initMeanVolumeAveragingValues();
////av.meanOfVolumeAveragingValues(numberOfSamples);
////av.writeMeanVolumeAveragingValuesToBinaryFiles(pathOut + "/va/mean/mean");
////av.writeMeanMatrixToImageFile(pathOut + "/va/vav/vavMean");
//av.initFluctuations();
//av.initSumOfVaFluctuations();
//av.initMeanOfVaFluctuations();
//av.initStresses();
//av.initSumOfVaStresses();
//av.initMeanOfVaStresses();
//av.initPlanarAveraging();
//av.initVolumeAveragingFluctStressValues();
//for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
//{
// //av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", t);
// //av.readMqMatrixFromBinaryFiles(pathOut + "/va/mq/mq" + UbSystem::toString(t) + "/mq", t);
// av.fluctuationsStress();
// av.writeFluctuationsToImageFile(pathOut + "/va/vav/vaFluct");
// av.volumeAveragingFluctStressWithMPI(real_l);
// av.writeVaFluctuationsToBinaryFiles(pathOut + "/va/av/Fluc", t);
// av.writeVaStressesToBinaryFiles(pathOut + "/va/av/Stresses", t);
// av.writeVaFluctuationsToImageFile(pathOut + "/va/vav/vaVAFluct");
// av.sumOfVaFluctuations();
// av.sumOfVaStresses();
//}
//av.meanOfVaFluctuations(numberOfSamples);
//av.meanOfVaStresses(numberOfSamples);
//av.writeMeanOfVaFluctuationsToImageFile(pathOut + "/va/vav/vaMeanFluct");
//av.planarAveraging();
//av.writeToCSV(pathOut + "/va/av", geo_origin[2], deltaX);
Averaging av;
av.setDimensions(dimensions);
av.setExtent(geo_extent);
av.setOrigin(geo_origin);
av.setSpacing(geo_spacing);
av.setDeltaX(deltaX);
av.readGeoMatrixFromBinaryFiles(pathOut + "/va/geomatrix.bin");
av.initFluctuations();
av.initSumOfVaFluctuations();
av.initMeanOfVaFluctuations();
av.initStresses();
av.initSumOfVaStresses();
av.initMeanOfVaStresses();
av.initPlanarAveraging();
//av.initVolumeAveragingFluctStressValues();
av.readMeanVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/mean/mean");
av.writeMeanMatrixToImageFile(pathOut + "/va/vav/vavMean");
//for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
//{
// av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", t);
// av.readMqMatrixFromBinaryFiles(pathOut + "/va/mq/mq" + UbSystem::toString(t) + "/mq", t);
// av.fluctuationsStress();
// //av.writeFluctuationsToImageFile(pathOut + "/va/vav/vaFluct");
// av.volumeAveragingFluctStressWithMPI(real_l);
// av.writeVaFluctuationsToBinaryFiles(pathOut + "/va/vaFluc/vaFluc" + UbSystem::toString(t) + "/vaFluc", t);
// av.writeVaStressesToBinaryFiles(pathOut + "/va/vaStress/vaStress" + UbSystem::toString(t) + "/vaStress", t);
// //av.writeVaFluctuationsToImageFile(pathOut + "/va/vav/vaVAFluct");
// //av.sumOfVaFluctuations();
// //av.sumOfVaStresses();
//}
av.initVolumeAveragingValues();
for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
{
av.createMQMatrix(pathIn + "/mq/mq" + UbSystem::toString(t) + ".pvtu");
//av.readMqMatrixFromBinaryFiles(pathOut + "/va/mq/mq" + UbSystem::toString(t) + "/mq", t);
av.volumeAveragingWithMPI(real_l);
if (myid == 0)
{
av.sumOfVolumeAveragingValues();
av.writeVolumeAveragingValuesToBinaryFiles(pathOut + "/va/vav/vav", t);
av.writeVaMatrixToImageFile(pathOut + "/va/vav/vav" + UbSystem::toString(t));
}
}
if (myid == 0)
{
av.initMeanVolumeAveragingValues();
av.meanOfVolumeAveragingValues(numberOfSamples);
av.writeMeanVolumeAveragingValuesToBinaryFiles(pathOut + "/va/mean/mean");
av.writeMeanMatrixToImageFile(pathOut + "/va/vav/vavMean");
}
av.initVolumeAveragingFluctStressValues();
for (int t = startTimeStep; t <= numberOfTimeSteps; t += timeStep)
{
av.readVolumeAveragingValuesFromBinaryFiles(pathOut + "/va/vav/vav", t);
//av.readMqMatrixFromBinaryFiles(pathOut + "/va/mq/mq" + UbSystem::toString(t) + "/mq", t);
av.fluctuationsStress2();
//av.writeFluctuationsToImageFile(pathOut + "/va/vav/vaFluct");
//av.volumeAveragingFluctStressWithMPI(real_l);
av.writeVaFluctuationsToBinaryFiles(pathOut + "/va/vaFluc/vaFluc" + UbSystem::toString(t) + "/vaFluc", t);
av.writeVaStressesToBinaryFiles(pathOut + "/va/vaStress/vaStress" + UbSystem::toString(t) + "/vaStress", t);
//av.writeVaFluctuationsToImageFile(pathOut + "/va/vav/vaVAFluct");
av.sumOfVaFluctuations();
av.sumOfVaStresses();
}
av.meanOfVaFluctuations(numberOfSamples);
av.meanOfVaStresses(numberOfSamples);
av.writeMeanOfVaFluctuationsToImageFile(pathOut + "/va/vav/vaMeanFluct");
av.planarAveraging();
av.writeToCSV(pathOut + "/va/av", geo_origin[2], deltaX);
}
catch (const std::exception& e)
{
cerr << e.what() << endl << flush;
}
catch (std::string& s)
{
cerr << s << endl;
}
catch (...)
{
cerr << "unknown exception" << endl;
}
}
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment