int main(int argc, char** argv) {
// Initialize Tempest
TempestInitialize(&argc, &argv);
try {
// Uniform +X flow field.
double dU0;
// Reference temperature
double dT0;
// Parameter reference height for temperature disturbance
double dhC;
// Parameter reference length a for temperature disturbance
double daC;
// Parameter reference length for mountain profile
double dxC;
// Parameter Archimede's Constant (essentially Pi but to some digits)
double dpiC;
// No Rayleigh friction
bool fNoRayleighFriction;
// Parse the command line
BeginTempestCommandLine("HydrostaticMountainCartesianTest");
SetDefaultResolutionX(40);
SetDefaultResolutionY(1);
SetDefaultLevels(48);
SetDefaultOutputDeltaT("1800s");
SetDefaultDeltaT("1s");
SetDefaultEndTime("36000s");
SetDefaultHorizontalOrder(4);
SetDefaultVerticalOrder(4);
CommandLineDouble(dU0, "u0", 20.0);
CommandLineDouble(dT0, "T0", 250.0);
CommandLineDouble(dhC, "hC", 1.0);
CommandLineDouble(daC, "aC", 10000.0);
CommandLineDouble(dxC, "xC", 1.2E+5);
CommandLineDouble(dpiC, "piC", 3.14159265);
CommandLineBool(fNoRayleighFriction, "norayleigh");
ParseCommandLine(argc, argv);
EndCommandLine(argv)
// Create a new instance of the test
HydrostaticMountainCartesianTest * test =
new HydrostaticMountainCartesianTest(
dT0,
dU0,
dhC,
dxC,
daC,
dpiC,
fNoRayleighFriction);
// Setup the Model
AnnounceBanner("MODEL SETUP");
Model model(EquationSet::PrimitiveNonhydrostaticEquations);
// Setup the cartesian model with dimensions and reference latitude
TempestSetupCartesianModel(model, test->m_dGDim, 0.0,
test->m_iLatBC);
// Set the reference length to reduce diffusion relative to global scale
const double XL = std::abs(test->m_dGDim[1] - test->m_dGDim[0]);
const double oneDegScale = 110000.0;
if (XL < oneDegScale) {
model.GetGrid()->SetReferenceLength(XL);
}
else {
model.GetGrid()->SetReferenceLength(oneDegScale);
}
// Set the test case for the model
AnnounceStartBlock("Initializing test case");
model.SetTestCase(test);
AnnounceEndBlock("Done");
// Begin execution
AnnounceBanner("SIMULATION");
model.Go();
// Compute error norms
AnnounceBanner("RESULTS");
model.ComputeErrorNorms();
AnnounceBanner();
} catch(Exception & e) {
std::cout << e.ToString() << std::endl;
}
// Deinitialize Tempest
TempestDeinitialize();
}
int main(int argc, char** argv) {
// Initialize Tempest
TempestInitialize(&argc, &argv);
try {
// Model height cap
double dZtop;
// Grid rotation angle
double dAlpha;
// Include tracer field
bool fTracersOn;
// Rayleigh layer
bool fRayleighFriction;
// Deep atmosphere flag
bool fDeepAtmosphere;
// Perturbation type
std::string strPerturbationType;
// Parse the command line
BeginTempestCommandLine("BaroclinicWaveUMJS");
SetDefaultResolution(20);
SetDefaultLevels(10);
SetDefaultOutputDeltaT("200s");
SetDefaultDeltaT("200s");
SetDefaultEndTime("200s");
SetDefaultHorizontalOrder(4);
SetDefaultVerticalOrder(1);
CommandLineDouble(dZtop, "ztop", 10000.0);
CommandLineDouble(dAlpha, "alpha", 0.0);
CommandLineBool(fDeepAtmosphere, "deep_atmosphere");
CommandLineBool(fRayleighFriction, "rayleigh");
CommandLineStringD(strPerturbationType, "pert",
"None", "(None | Exp | Sfn)");
ParseCommandLine(argc, argv);
EndTempestCommandLine(argv)
// Setup the Model
AnnounceBanner("MODEL SETUP");
Model model(EquationSet::PrimitiveNonhydrostaticEquations);
TempestSetupCubedSphereModel(model);
// Set the test case for the model
AnnounceStartBlock("Initializing test case");
BaroclinicWaveUMJSTest::PerturbationType ePerturbationType;
STLStringHelper::ToLower(strPerturbationType);
if (strPerturbationType == "none") {
ePerturbationType = BaroclinicWaveUMJSTest::PerturbationType_None;
} else if (strPerturbationType == "exp") {
ePerturbationType = BaroclinicWaveUMJSTest::PerturbationType_Exp;
} else if (strPerturbationType == "sfn") {
ePerturbationType = BaroclinicWaveUMJSTest::PerturbationType_StreamFn;
} else {
_EXCEPTIONT("Invalid perturbation type:"
" Expected \"None\", \"Exp\" or \"SFn\"");
}
model.SetTestCase(
new BaroclinicWaveUMJSTest(
dAlpha,
fDeepAtmosphere,
dZtop,
ePerturbationType,
fRayleighFriction));
AnnounceEndBlock("Done");
// Begin execution
AnnounceBanner("SIMULATION");
model.Go();
// Compute error norms
AnnounceBanner("RESULTS");
model.ComputeErrorNorms();
AnnounceBanner();
} catch(Exception & e) {
std::cout << e.ToString() << std::endl;
}
// Deinitialize
TempestDeinitialize();
}
int main(int argc, char** argv) {
// Initialize Tempest
TempestInitialize(&argc, &argv);
try {
// Model cap.
double dZtop;
// Earth radius scaling parameter.
double dEarthScaling;
// Deactivate physics
bool fNoPhysics;
// Bryan Boundary Layer
bool fBryanPBL;
// Reed-Jablonowksi precipitation
bool fReedJablonowskiPrecip;
// Parse the command line
BeginTempestCommandLine("TropicalCycloneTest");
SetDefaultResolution(20);
SetDefaultLevels(30);
SetDefaultOutputDeltaT("1h");
SetDefaultDeltaT("200s");
SetDefaultEndTime("10d");
SetDefaultHorizontalOrder(4);
SetDefaultVerticalOrder(1);
CommandLineDouble(dZtop, "ztop", 30000.0);
CommandLineDouble(dEarthScaling, "X", 1.0);
CommandLineBool(fNoPhysics, "nophys");
CommandLineBool(fBryanPBL, "bryanpbl");
CommandLineBool(fReedJablonowskiPrecip, "rjprecip");
ParseCommandLine(argc, argv);
EndTempestCommandLine(argv)
// Setup the Model
AnnounceBanner("MODEL SETUP");
EquationSet eqn(EquationSet::PrimitiveNonhydrostaticEquations);
eqn.InsertTracer("RhoQv", "RhoQv");
eqn.InsertTracer("RhoQc", "RhoQc");
eqn.InsertTracer("RhoQr", "RhoQr");
UserDataMeta metaUserData;
metaUserData.InsertDataItem2D("PRECT");
Model model(eqn, metaUserData);
TempestSetupCubedSphereModel(model);
// Set the test case for the model
AnnounceStartBlock("Initializing test case");
model.SetTestCase(
new TropicalCycloneTest(
dZtop,
dEarthScaling));
AnnounceEndBlock("Done");
// Add DCMIP physics
if (!fNoPhysics) {
model.AttachWorkflowProcess(
new DCMIPPhysics(
model,
model.GetDeltaT(),
2,
(fBryanPBL)?(1):(0),
(fReedJablonowskiPrecip)?(1):(0)));
}
// Begin execution
AnnounceBanner("SIMULATION");
model.Go();
// Compute error norms
AnnounceBanner("RESULTS");
model.ComputeErrorNorms();
AnnounceBanner();
} catch(Exception & e) {
std::cout << e.ToString() << std::endl;
}
// Deinitialize Tempest
TempestDeinitialize();
}
int main(int argc, char** argv) {
NcError error(NcError::silent_nonfatal);
try {
// Input data file
std::string strInputData;
// Input map file
std::string strInputMap;
// List of variables
std::string strVariables;
// Input data file (second instance)
std::string strInputData2;
// Input map file (second instance)
std::string strInputMap2;
// List of variables (second instance)
std::string strVariables2;
// Output data file
std::string strOutputData;
// Name of the ncol variable
std::string strNColName;
// Output as double
bool fOutputDouble;
// List of variables to preserve
std::string strPreserveVariables;
// Preserve all non-remapped variables
bool fPreserveAll;
// Fill value override
double dFillValueOverride;
// Parse the command line
BeginCommandLine()
CommandLineString(strInputData, "in_data", "");
CommandLineString(strInputMap, "map", "");
CommandLineString(strVariables, "var", "");
CommandLineString(strInputData2, "in_data2", "");
CommandLineString(strInputMap2, "map2", "");
CommandLineString(strVariables2, "var2", "");
CommandLineString(strOutputData, "out_data", "");
CommandLineString(strNColName, "ncol_name", "ncol");
CommandLineBool(fOutputDouble, "out_double");
CommandLineString(strPreserveVariables, "preserve", "");
CommandLineBool(fPreserveAll, "preserveall");
CommandLineDouble(dFillValueOverride, "fillvalue", 0.0);
ParseCommandLine(argc, argv);
EndCommandLine(argv)
AnnounceBanner();
// Check parameters
if (strInputMap == "") {
_EXCEPTIONT("No map specified");
}
if (strInputData == "") {
_EXCEPTIONT("No input data specified");
}
if (strOutputData == "") {
_EXCEPTIONT("No output data specified");
}
// Parse variable list
std::vector< std::string > vecVariableStrings;
ParseVariableList(strVariables, vecVariableStrings);
// Parse preserve variable list
std::vector< std::string > vecPreserveVariableStrings;
ParseVariableList(strPreserveVariables, vecPreserveVariableStrings);
if (fPreserveAll && (vecPreserveVariableStrings.size() != 0)) {
_EXCEPTIONT("--preserveall and --preserve cannot both be specified");
}
// Second input data file
std::vector< std::string > vecVariableStrings2;
if (strInputData2 != "") {
ParseVariableList(strVariables2, vecVariableStrings2);
if (vecVariableStrings2.size() == 0) {
_EXCEPTIONT("No variables specified for --in_data2");
}
if (strInputMap2 == "") {
_EXCEPTIONT("No map specified for --in_data2");
}
}
if ((strInputMap2 != "") && (strInputData2 == "")) {
_EXCEPTIONT("No input data specified for --map2");
}
// Apply OfflineMap to data
if (strInputMap2 == "") {
AnnounceStartBlock("Applying offline map to data");
} else {
AnnounceStartBlock("Applying first offline map to data");
}
// OfflineMap
OfflineMap mapRemap;
mapRemap.Read(strInputMap);
mapRemap.SetFillValueOverride(static_cast<float>(dFillValueOverride));
mapRemap.Apply(
strInputData,
strOutputData,
vecVariableStrings,
strNColName,
fOutputDouble,
false);
AnnounceEndBlock(NULL);
if (strInputMap2 != "") {
AnnounceStartBlock("Applying second offline map to data");
// OfflineMap
OfflineMap mapRemap2;
mapRemap2.Read(strInputMap2);
// Verify consistency of maps
SparseMatrix<double> & smatRemap = mapRemap .GetSparseMatrix();
SparseMatrix<double> & smatRemap2 = mapRemap2.GetSparseMatrix();
if ((smatRemap.GetRows() != smatRemap2.GetRows()) ||
(smatRemap.GetColumns() != smatRemap2.GetColumns())
) {
_EXCEPTIONT("Mismatch in dimensions of input maps "
"--map and --map2");
}
mapRemap2.Apply(
strInputData2,
strOutputData,
vecVariableStrings2,
strNColName,
false,
true);
AnnounceEndBlock(NULL);
}
// Copy variables from input file to output file
if (fPreserveAll) {
AnnounceStartBlock("Preserving variables");
mapRemap.PreserveAllVariables(strInputData, strOutputData);
AnnounceEndBlock(NULL);
} else if (vecPreserveVariableStrings.size() != 0) {
AnnounceStartBlock("Preserving variables");
mapRemap.PreserveVariables(
strInputData,
strOutputData,
vecPreserveVariableStrings);
AnnounceEndBlock(NULL);
}
AnnounceBanner();
return (0);
} catch(Exception & e) {
Announce(e.ToString().c_str());
return (-1);
} catch(...) {
return (-2);
}
}
int main(int argc, char** argv) {
// Initialize Tempest
TempestInitialize(&argc, &argv);
try {
// Nondimensional vertical width parameter
double dbC;
// Uniform zonal velocity
double dU0;
// Magnitude of the zonal wind perturbation
double dUp;
// Lapse rate
double ddTdz;
// Reference absolute temperature
double dT0;
// Width parameter for the perturbation
double dLpC;
// Center position of the perturbation
double dXC;
// Center position of the perturbation
double dYC;
// No Rayleigh friction
bool fNoRayleighFriction;
// Parse the command line
BeginTempestCommandLine("Baroclinic3DCartesianTest");
SetDefaultResolutionX(288);
SetDefaultResolutionY(48);
SetDefaultLevels(32);
SetDefaultOutputDeltaT("3h");
SetDefaultDeltaT("300s");
SetDefaultEndTime("12d");
SetDefaultHorizontalOrder(4);
SetDefaultVerticalOrder(1);
CommandLineDouble(dbC, "b", 2.0);
CommandLineDouble(dU0, "u0", 35.0);
CommandLineDouble(dUp, "up", 1.0);
CommandLineDouble(ddTdz, "gamma", 0.005);
CommandLineDouble(dT0, "T0", 288.0);
CommandLineDouble(dLpC, "Lp", 600000.0);
CommandLineDouble(dXC, "Xc", 2000000.0);
CommandLineDouble(dYC, "Yc", 2500000.0);
CommandLineBool(fNoRayleighFriction, "norayleigh");
ParseCommandLine(argc, argv);
EndCommandLine(argv)
// Create a new instance of the test
Baroclinic3DCartesianTest * test =
new Baroclinic3DCartesianTest(dbC,
dU0,
dUp,
ddTdz,
dT0,
dLpC,
dXC,
dYC,
fNoRayleighFriction);
// Setup the Model
AnnounceBanner("MODEL SETUP");
Model model(EquationSet::PrimitiveNonhydrostaticEquations);
// Setup the cartesian model with dimensions and reference latitude
TempestSetupCartesianModel(model, test->m_dGDim, test->m_dRefLat,
test->m_iLatBC);
// Set the reference length to reduce diffusion relative to global scale
const double XL = std::abs(test->m_dGDim[1] - test->m_dGDim[0]);
const double oneDegScale = 110000.0;
if (XL < oneDegScale) {
model.GetGrid()->SetReferenceLength(XL);
}
else {
model.GetGrid()->SetReferenceLength(oneDegScale);
}
// Set the test case for the model
AnnounceStartBlock("Initializing test case");
model.SetTestCase(test);
AnnounceEndBlock("Done");
// Begin execution
AnnounceBanner("SIMULATION");
model.Go();
// Compute error norms
AnnounceBanner("RESULTS");
model.ComputeErrorNorms();
AnnounceBanner();
} catch(Exception & e) {
std::cout << e.ToString() << std::endl;
std::cout << "Try/catch block in the main program!" << std::endl;
}
// Deinitialize Tempest
TempestDeinitialize();
}
int main(int argc, char ** argv) {
try {
// Parameters
Parameters param;
// Output filename
std::string strOutputFile;
// Horizontal minimum wave number
int nKmin;
// Horizontal maximum wave number
int nKmax;
// Parse the command line
BeginCommandLine()
CommandLineInt(param.nPhiElements, "n", 40);
CommandLineInt(nKmin, "kmin", 1);
CommandLineInt(nKmax, "kmax", 20);
CommandLineDouble(param.dXscale, "X", 1.0);
CommandLineDouble(param.dT0, "T0", 300.0);
CommandLineDouble(param.dU0, "U0", 20.0);
CommandLineDouble(param.dG, "G", 9.80616);
CommandLineDouble(param.dOmega, "omega", 7.29212e-5);
CommandLineDouble(param.dGamma, "gamma", 1.4);
CommandLineString(strOutputFile, "out", "wave.nc");
ParseCommandLine(argc, argv);
EndCommandLine(argv)
AnnounceBanner();
// Generate latitude values
param.GenerateLatituteArray(param.nPhiElements);
// Open NetCDF file
NcFile ncdf_out(strOutputFile.c_str(), NcFile::Replace);
NcDim *dimK = ncdf_out.add_dim("k", nKmax - nKmin + 1);
NcDim *dimLat = ncdf_out.add_dim("lat", param.nPhiElements);
NcDim *dimEig = ncdf_out.add_dim("eig", param.nPhiElements);
// Write parameters and latitudes to file
param.WriteToNcFile(ncdf_out, dimLat, dimLatS);
// Wave numbers
NcVar *varK = ncdf_out.add_var("k", ncInt, dimK);
DataVector<int> vecK;
vecK.Initialize(nKmax - nKmin + 1);
for (int nK = nKmin; nK <= nKmax; nK++) {
vecK[nK - nKmin] = nK;
}
varK->set_cur((long)0);
varK->put(vecK, nKmax - nKmin + 1);
// Eigenvalues
NcVar *varMR = ncdf_out.add_var("mR", ncDouble, dimK, dimEig);
NcVar *varMI = ncdf_out.add_var("mI", ncDouble, dimK, dimEig);
NcVar *varUR = ncdf_out.add_var("uR", ncDouble, dimK, dimEig, dimLat);
NcVar *varUI = ncdf_out.add_var("uI", ncDouble, dimK, dimEig, dimLat);
NcVar *varVR = ncdf_out.add_var("vR", ncDouble, dimK, dimEig, dimLatS);
NcVar *varVI = ncdf_out.add_var("vI", ncDouble, dimK, dimEig, dimLatS);
NcVar *varPR = ncdf_out.add_var("pR", ncDouble, dimK, dimEig, dimLat);
NcVar *varPI = ncdf_out.add_var("pI", ncDouble, dimK, dimEig, dimLat);
NcVar *varWR = ncdf_out.add_var("wR", ncDouble, dimK, dimEig, dimLat);
NcVar *varWI = ncdf_out.add_var("wI", ncDouble, dimK, dimEig, dimLat);
NcVar *varRhoR = ncdf_out.add_var("rhoR", ncDouble, dimK, dimEig, dimLat);
NcVar *varRhoI = ncdf_out.add_var("rhoI", ncDouble, dimK, dimEig, dimLat);
// Allocate temporary arrays
DataVector<double> dUR;
dUR.Initialize(param.nPhiElements);
DataVector<double> dUI;
dUI.Initialize(param.nPhiElements);
DataVector<double> dVR;
dVR.Initialize(param.nPhiElements-1);
DataVector<double> dVI;
dVI.Initialize(param.nPhiElements-1);
DataVector<double> dPR;
dPR.Initialize(param.nPhiElements);
DataVector<double> dPI;
dPI.Initialize(param.nPhiElements);
DataVector<double> dWR;
dWR.Initialize(param.nPhiElements);
DataVector<double> dWI;
dWI.Initialize(param.nPhiElements);
DataVector<double> dRhoR;
dRhoR.Initialize(param.nPhiElements);
DataVector<double> dRhoI;
dRhoI.Initialize(param.nPhiElements);
// Loop over all horizontal wave numbers
for (int nK = nKmin; nK <= nKmax; nK++) {
// Build matrices
char szMessage[100];
sprintf(szMessage, "Building evolution matrices (k = %i)", nK);
AnnounceStartBlock(szMessage);
DataMatrix<double> matM;
DataMatrix<double> matB;
GenerateEvolutionMatrix(nK, param, matM, matB);
AnnounceEndBlock("Done");
// Solve the matrices
AnnounceStartBlock("Solving evolution matrices");
DataVector<double> vecAlphaR;
DataVector<double> vecAlphaI;
DataVector<double> vecBeta;
DataMatrix<double> matVR;
vecAlphaR.Initialize(matM.GetRows());
vecAlphaI.Initialize(matM.GetRows());
vecBeta .Initialize(matM.GetRows());
matVR .Initialize(matM.GetRows(), matM.GetColumns());
SolveEvolutionMatrix(
matM,
matB,
vecAlphaR,
vecAlphaI,
vecBeta,
matVR);
// Sort eigenvalues
std::multimap<double, int> mapSortedRows;
for (int i = 0; i < vecBeta.GetRows(); i++) {
if (vecBeta[i] != 0.0) {
double dLambdaR = vecAlphaR[i] / vecBeta[i];
double dLambdaI = vecAlphaI[i] / vecBeta[i];
double dMR = dLambdaI;
double dMI = - dLambdaR - 1.0;
double dEvalMagnitude = fabs(dMR);
//printf("\n%1.5e %1.5e ", dMR, dMI);
// Purely imaginary eigenvalue
if (dMR == 0.0) {
// Wave must decay with height
if (dMI < 0.0) {
continue;
}
// Complex-conjugate pair of eigenvalues
} else {
// Phase propagation must be downward, and energy
// propagation upwards
if (dMR < 0.0) {
continue;
}
}
//printf("(OK)");
mapSortedRows.insert(
std::pair<double, int>(dEvalMagnitude, i));
// Only store one entry for complex-conjugate pairs
if (vecAlphaI[i] != 0.0) {
i++;
}
}
}
Announce("%i eigenmodes found to satisfy entropy condition",
mapSortedRows.size());
/*
if (mapSortedRows.size() != param.nPhiElements) {
_EXCEPTIONT("Mismatch between eigenmode count and latitude count");
}
*/
AnnounceEndBlock("Done");
// Write the matrices to a file
AnnounceStartBlock("Writing results");
int iKix = nK - nKmin;
int iWave = 0;
std::map<double, int>::const_iterator it;
for (it = mapSortedRows.begin(); it != mapSortedRows.end(); it++) {
int i = it->second;
double dLambdaR = vecAlphaR[i] / vecBeta[i];
double dLambdaI = vecAlphaI[i] / vecBeta[i];
double dMR = dLambdaI;
double dMI = - dLambdaR - 1.0;
// Dump eigenvalue to NetCDF file
varMR->set_cur(iKix, iWave);
varMR->put(&dMR, 1, 1);
varMI->set_cur(iKix, iWave);
varMI->put(&dMI, 1, 1);
// Store real part of eigenfunction
for (int j = 0; j < param.nPhiElements; j++) {
dUR [j] = matVR[i][4*j ];
dPR [j] = matVR[i][4*j+1];
dWR [j] = matVR[i][4*j+2];
dRhoR[j] = matVR[i][4*j+3];
}
for (int j = 0; j < param.nPhiElements-1; j++) {
dVR[j] = matVR[i][4 * param.nPhiElements + j];
}
// Complex eigenvalue / eigenfunction pair
if (dLambdaI != 0.0) {
// Eigenvalue Lambda is complex conjugate
dMR = -dMR;
// Dump eigenvalue to NetCDF file
varMR->set_cur(iKix, iWave+1);
varMR->put(&dMR, 1, 1);
varMI->set_cur(iKix, iWave+1);
varMI->put(&dMI, 1, 1);
// Store imaginary component of vector
for (int j = 0; j < param.nPhiElements; j++) {
dUI [j] = matVR[i+1][4*j ];
dPI [j] = matVR[i+1][4*j+1];
dWI [j] = matVR[i+1][4*j+2];
dRhoI[j] = matVR[i+1][4*j+3];
}
for (int j = 0; j < param.nPhiElements-1; j++) {
dVI[j] = matVR[i+1][4 * param.nPhiElements + j];
}
// Real eigenvalue / eigenvector pair
} else {
dUI.Zero();
dPI.Zero();
dWI.Zero();
dRhoI.Zero();
dVI.Zero();
}
// Dump the first eigenfunction to the file
varUR->set_cur(iKix, iWave, 0);
varUR->put(dUR, 1, 1, param.nPhiElements);
varVR->set_cur(iKix, iWave, 0);
varVR->put(dVR, 1, 1, param.nPhiElements-1);
varPR->set_cur(iKix, iWave, 0);
varPR->put(dPR, 1, 1, param.nPhiElements);
varWR->set_cur(iKix, iWave, 0);
varWR->put(dWR, 1, 1, param.nPhiElements);
varRhoR->set_cur(iKix, iWave, 0);
varRhoR->put(dRhoR, 1, 1, param.nPhiElements);
varUI->set_cur(iKix, iWave, 0);
varUI->put(dUI, 1, 1, param.nPhiElements);
varVI->set_cur(iKix, iWave, 0);
varVI->put(dVI, 1, 1, param.nPhiElements-1);
varPI->set_cur(iKix, iWave, 0);
varPI->put(dPI, 1, 1, param.nPhiElements);
varWI->set_cur(iKix, iWave, 0);
varWI->put(dWI, 1, 1, param.nPhiElements);
varRhoI->set_cur(iKix, iWave, 0);
varRhoI->put(dRhoI, 1, 1, param.nPhiElements);
// Complex eigenvalue / eigenvector pair
if (dLambdaI != 0.0) {
for (int j = 0; j < param.nPhiElements; j++) {
dUI [j] = - dUI [j];
dPI [j] = - dPI [j];
dWI [j] = - dWI [j];
dRhoI[j] = - dRhoI[j];
}
for (int j = 0; j < param.nPhiElements-1; j++) {
dVI[j] = - dVI[j];
}
varUR->set_cur(iKix, iWave+1, 0);
varUR->put(dUR, 1, 1, param.nPhiElements);
varVR->set_cur(iKix, iWave+1, 0);
varVR->put(dVR, 1, 1, param.nPhiElements-1);
varPR->set_cur(iKix, iWave+1, 0);
varPR->put(dPR, 1, 1, param.nPhiElements);
varWR->set_cur(iKix, iWave+1, 0);
varWR->put(dWR, 1, 1, param.nPhiElements);
varRhoR->set_cur(iKix, iWave+1, 0);
varRhoR->put(dRhoR, 1, 1, param.nPhiElements);
varUI->set_cur(iKix, iWave+1, 0);
varUI->put(dUI, 1, 1, param.nPhiElements);
varVI->set_cur(iKix, iWave+1, 0);
varVI->put(dVI, 1, 1, param.nPhiElements-1);
varPI->set_cur(iKix, iWave+1, 0);
varPI->put(dPI, 1, 1, param.nPhiElements);
varWI->set_cur(iKix, iWave+1, 0);
varWI->put(dWI, 1, 1, param.nPhiElements);
varRhoI->set_cur(iKix, iWave+1, 0);
varRhoI->put(dRhoI, 1, 1, param.nPhiElements);
}
// Increment wave index
iWave++;
if (dLambdaI != 0.0) {
iWave++;
}
}
AnnounceEndBlock("Done");
AnnounceBanner();
}
} catch(Exception & e) {
Announce(e.ToString().c_str());
}
}
int main(int argc, char** argv) {
// UTM zone
int nZone;
// Number of columns in mesh
int nCols;
// Number of rows in mesh
int nRows;
// XLL Corner of the mesh
double dXLLCorner;
// YLL Corner of the mesh
double dYLLCorner;
// Cell size (in meters)
double dCellSize;
// Output filename
std::string strOutputFile;
// Verbose output
bool fVerbose;
// Parse the command line
BeginCommandLine()
CommandLineInt(nZone, "zone", 0);
CommandLineInt(nCols, "cols", 128);
CommandLineInt(nRows, "rows", 64);
CommandLineDouble(dXLLCorner, "xllcorner", 0.0);
CommandLineDouble(dYLLCorner, "yllcorner", 0.0);
CommandLineDouble(dCellSize, "cellsize", 1000.0);
CommandLineString(strOutputFile, "file", "outUTMMesh.g");
CommandLineBool(fVerbose, "verbose");
ParseCommandLine(argc, argv);
EndCommandLine(argv)
// Verify input arguments
if (nCols <= 0) {
_EXCEPTIONT("--cols must be positive");
}
if (nRows <= 0) {
_EXCEPTIONT("--rows must be positive");
}
if (dCellSize <= 0.0) {
_EXCEPTIONT("--cellsize must be positive");
}
std::cout << "=========================================================";
std::cout << std::endl;
// Call the actual mesh generator
Mesh mesh;
int err = GenerateUTMMesh(mesh, nZone, nCols, nRows, dXLLCorner, dYLLCorner, dCellSize, strOutputFile, fVerbose);
if (err) exit(err);
return 0;
}
int main(int argc, char** argv) {
// Initialize MPI
TempestInitialize(&argc, &argv);
try {
// Model height cap.
double dZtop;
// Model scaling parameter
double dEarthScaling;
// Rotation rate of the Earth with X = 1.
double dOmega;
// Reference temperature.
double dT0;
// Temperature lapse rate.
double dGamma;
// Longitude of Schar-type mountain centerpoint.
double dLonM;
// Latitude of Schar-type mountain centerpoint.
double dLatM;
// Maximum Schar-type mountain height.
double dH0;
// Schar-type mountain radius (radians).
double dRM;
// Schar-type mountain oscillation half-width (radians).
double dZetaM;
// Parse the command line
BeginTempestCommandLine("StationaryMountainFlowTest");
SetDefaultResolution(30);
SetDefaultLevels(30);
SetDefaultOutputDeltaT("1d");
SetDefaultDeltaT("300s");
SetDefaultEndTime("6d");
SetDefaultHorizontalOrder(4);
SetDefaultVerticalOrder(1);
CommandLineDouble(dZtop, "ztop", 30000.0);
CommandLineDouble(dEarthScaling, "X", 1.0);
CommandLineDouble(dOmega, "omega", 0.0);
CommandLineDouble(dT0, "T0", 300.0);
CommandLineDouble(dGamma, "Gamma", 0.0065);
CommandLineDouble(dLonM, "lonm", 270.0);
CommandLineDouble(dLatM, "latm", 0.0);
CommandLineDouble(dH0, "h0", 2000.0);
CommandLineDouble(dRM, "rm", 135.0);
CommandLineDouble(dZetaM, "zetam", 11.25);
ParseCommandLine(argc, argv);
EndTempestCommandLine(argv)
// Setup the Model
AnnounceBanner("MODEL SETUP");
Model model(EquationSet::PrimitiveNonhydrostaticEquations);
TempestSetupCubedSphereModel(model);
// Set the test case for the model
AnnounceStartBlock("Initializing test case");
model.SetTestCase(
new StationaryMountainFlowTest(
dZtop,
dEarthScaling,
dOmega,
dT0,
dGamma,
dLonM,
dLatM,
dH0,
dRM,
dZetaM));
AnnounceEndBlock("Done");
// Set the reference length
model.GetGrid()->SetReferenceLength(0.5 * M_PI / 30.0 * dEarthScaling);
// Begin execution
AnnounceBanner("SIMULATION");
model.Go();
// Compute error norms
AnnounceBanner("RESULTS");
model.ComputeErrorNorms();
AnnounceBanner();
} catch(Exception & e) {
std::cout << e.ToString() << std::endl;
}
// Deinitialize Tempest
TempestDeinitialize();
}
int main(int argc, char** argv) {
NcError error(NcError::verbose_nonfatal);
try {
// Input file
std::string strInputFile;
// Input file list
std::string strInputFileList;
// Input file format
std::string strInputFormat;
// NetCDF file containing latitude and longitude arrays
std::string strLatLonFile;
// Output file (NetCDF)
std::string strOutputFile;
// Output variable name
std::string strOutputVariable;
// Column in which the longitude index appears
int iLonIxCol;
// Column in which the latitude index appears
int iLatIxCol;
// Begin latitude
double dLatBegin;
// End latitude
double dLatEnd;
// Begin longitude
double dLonBegin;
// End longitude
double dLonEnd;
// Number of latitudes in output
int nLat;
// Number of longitudes in output
int nLon;
// Parse the command line
BeginCommandLine()
CommandLineString(strInputFile, "in", "");
CommandLineString(strInputFileList, "inlist", "");
CommandLineStringD(strInputFormat, "in_format", "std", "(std|visit)");
CommandLineString(strOutputFile, "out", "");
CommandLineString(strOutputVariable, "outvar", "density");
CommandLineInt(iLonIxCol, "iloncol", 8);
CommandLineInt(iLatIxCol, "ilatcol", 9);
CommandLineDouble(dLatBegin, "lat_begin", -90.0);
CommandLineDouble(dLatEnd, "lat_end", 90.0);
CommandLineDouble(dLonBegin, "lon_begin", 0.0);
CommandLineDouble(dLonEnd, "lon_end", 360.0);
CommandLineInt(nLat, "nlat", 180);
CommandLineInt(nLon, "nlon", 360);
ParseCommandLine(argc, argv);
EndCommandLine(argv)
AnnounceBanner();
// Check input
if ((strInputFile == "") && (strInputFileList == "")) {
_EXCEPTIONT("No input file (--in) or (--inlist) specified");
}
if ((strInputFile != "") && (strInputFileList != "")) {
_EXCEPTIONT("Only one input file (--in) or (--inlist) allowed");
}
if (strInputFormat != "std") {
_EXCEPTIONT("UNIMPLEMENTED: Only \"--in_format std\" supported");
}
// Check output
if (strOutputFile == "") {
_EXCEPTIONT("No output file (--out) specified");
}
// Check output variable
if (strOutputVariable == "") {
_EXCEPTIONT("No output variable name (--outvar) specified");
}
// Number of latitudes and longitudes
if (nLat == 0) {
_EXCEPTIONT("UNIMPLEMENTED: --nlat must be specified currently");
}
if (nLon == 0) {
_EXCEPTIONT("UNIMPLEMENTED: --nlon must be specified currently");
}
// Input file list
std::vector<std::string> vecInputFiles;
if (strInputFile != "") {
vecInputFiles.push_back(strInputFile);
}
if (strInputFileList != "") {
GetInputFileList(strInputFileList, vecInputFiles);
}
int nFiles = vecInputFiles.size();
// Density
DataMatrix<int> nCounts;
nCounts.Initialize(nLat, nLon);
// Loop through all files in list
AnnounceStartBlock("Processing files");
std::string strBuffer;
strBuffer.reserve(1024);
for (int f = 0; f < nFiles; f++) {
Announce("File \"%s\"", vecInputFiles[f].c_str());
FILE * fp = fopen(vecInputFiles[f].c_str(), "r");
if (fp == NULL) {
_EXCEPTION1("Unable to open input file \"%s\"",
vecInputFiles[f].c_str());
}
for (;;) {
// Read in the next line
fgets(&(strBuffer[0]), 1024, fp);
int nLength = strlen(&(strBuffer[0]));
// Check for end of file
if (feof(fp)) {
break;
}
// Check for comment line
if (strBuffer[0] == '#') {
continue;
}
// Check for new storm
if (strncmp(&(strBuffer[0]), "start", 5) == 0) {
continue;
}
// Parse line
double dLon;
double dLat;
int iCol = 0;
int iLast = 0;
bool fWhitespace = true;
for (int i = 0; i <= nLength; i++) {
if ((strBuffer[i] == ' ') ||
(strBuffer[i] == ',') ||
(strBuffer[i] == '\t') ||
(strBuffer[i] == '\0')
) {
if (!fWhitespace) {
if (iCol == iLonIxCol) {
strBuffer[i] = '\0';
dLon = atof(&(strBuffer[iLast]));
}
if (iCol == iLatIxCol) {
strBuffer[i] = '\0';
dLat = atof(&(strBuffer[iLast]));
}
}
fWhitespace = true;
} else {
if (fWhitespace) {
iLast = i;
iCol++;
}
fWhitespace = false;
}
}
// Latitude and longitude index
int iLon =
static_cast<int>(static_cast<double>(nLon)
* (dLon - dLonBegin) / (dLonEnd - dLonBegin));
int iLat =
static_cast<int>(static_cast<double>(nLat)
* (dLat - dLatBegin) / (dLatEnd - dLatBegin));
if (iLon == (-1)) {
iLon = 0;
}
if (iLon == nLon) {
iLon = nLon - 1;
}
if (iLat == (-1)) {
iLat = 0;
}
if (iLat == nLat) {
iLat = nLat - 1;
}
if ((iLat < 0) || (iLat >= nLat)) {
_EXCEPTION1("Latitude index (%i) out of range", iLat);
}
if ((iLon < 0) || (iLon >= nLon)) {
_EXCEPTION1("Longitude index (%i) out of range", iLon);
}
nCounts[iLat][iLon]++;
}
fclose(fp);
}
AnnounceEndBlock("Done");
// Output results
AnnounceStartBlock("Output results");
// Load the netcdf output file
NcFile ncOutput(strOutputFile.c_str(), NcFile::Replace);
if (!ncOutput.is_valid()) {
_EXCEPTION1("Unable to open output file \"%s\"",
strOutputFile.c_str());
}
// Create output
NcDim * dimLat = ncOutput.add_dim("lat", nLat);
NcDim * dimLon = ncOutput.add_dim("lon", nLon);
NcVar * varLat = ncOutput.add_var("lat", ncDouble, dimLat);
NcVar * varLon = ncOutput.add_var("lon", ncDouble, dimLon);
varLat->add_att("units", "degrees_north");
varLon->add_att("units", "degrees_east");
DataVector<double> dLat(nLat);
DataVector<double> dLon(nLon);
for (int j = 0; j < nLat; j++) {
dLat[j] = dLatBegin
+ (dLatEnd - dLatBegin)
* (static_cast<double>(j) + 0.5)
/ static_cast<double>(nLat);
}
for (int i = 0; i < nLon; i++) {
dLon[i] = dLonBegin
+ (dLonEnd - dLonBegin)
* (static_cast<double>(i) + 0.5)
/ static_cast<double>(nLon);
}
varLat->put(&(dLat[0]), nLat);
varLon->put(&(dLon[0]), nLon);
// Output counts
NcVar * varCount =
ncOutput.add_var(
strOutputVariable.c_str(),
ncInt,
dimLat,
dimLon);
varCount->put(&(nCounts[0][0]), nLat, nLon);
ncOutput.close();
AnnounceEndBlock("Done");
AnnounceBanner();
} catch(Exception & e) {
Announce(e.ToString().c_str());
}
}
int main(int argc, char** argv) {
NcError error(NcError::silent_nonfatal);
try {
// Input / Output types
enum DiscretizationType {
DiscretizationType_FV,
DiscretizationType_CGLL,
DiscretizationType_DGLL
};
// Input mesh file
std::string strInputMesh;
// Overlap mesh file
std::string strOverlapMesh;
// Input metadata file
std::string strInputMeta;
// Output metadata file
std::string strOutputMeta;
// Input data type
std::string strInputType;
// Output data type
std::string strOutputType;
// Order of polynomial in each element
int nPin;
// Order of polynomial in each output element
int nPout;
// Use bubble on interior of spectral element nodes
bool fBubble;
// Enforce monotonicity
bool fMonotoneType1;
// Enforce monotonicity
bool fMonotoneType2;
// Enforce monotonicity
bool fMonotoneType3;
// Volumetric remapping
bool fVolumetric;
// No conservation
bool fNoConservation;
// Turn off checking for conservation / consistency
bool fNoCheck;
// Output mesh file
std::string strOutputMesh;
// Variable list
std::string strVariables;
// Output map file
std::string strOutputMap;
// Input data file
std::string strInputData;
// Output data file
std::string strOutputData;
// Name of the ncol variable
std::string strNColName;
// Output as double
bool fOutputDouble;
// List of variables to preserve
std::string strPreserveVariables;
// Preserve all non-remapped variables
bool fPreserveAll;
// Fill value override
double dFillValueOverride;
// Parse the command line
BeginCommandLine()
//CommandLineStringD(strMethod, "method", "", "[se]");
CommandLineString(strInputMesh, "in_mesh", "");
CommandLineString(strOutputMesh, "out_mesh", "");
CommandLineString(strOverlapMesh, "ov_mesh", "");
CommandLineString(strInputMeta, "in_meta", "");
CommandLineString(strOutputMeta, "out_meta", "");
CommandLineStringD(strInputType, "in_type", "fv", "[fv|cgll|dgll]");
CommandLineStringD(strOutputType, "out_type", "fv", "[fv|cgll|dgll]");
CommandLineInt(nPin, "in_np", 4);
CommandLineInt(nPout, "out_np", 4);
CommandLineBool(fBubble, "bubble");
CommandLineBool(fMonotoneType1, "mono");
CommandLineBool(fMonotoneType2, "mono2");
CommandLineBool(fMonotoneType3, "mono3");
CommandLineBool(fVolumetric, "volumetric");
CommandLineBool(fNoConservation, "noconserve");
CommandLineBool(fNoCheck, "nocheck");
CommandLineString(strVariables, "var", "");
CommandLineString(strOutputMap, "out_map", "");
CommandLineString(strInputData, "in_data", "");
CommandLineString(strOutputData, "out_data", "");
CommandLineString(strNColName, "ncol_name", "ncol");
CommandLineBool(fOutputDouble, "out_double");
CommandLineString(strPreserveVariables, "preserve", "");
CommandLineBool(fPreserveAll, "preserveall");
CommandLineDouble(dFillValueOverride, "fillvalue", 0.0);
ParseCommandLine(argc, argv);
EndCommandLine(argv)
AnnounceBanner();
// Check command line parameters (mesh arguments)
if (strInputMesh == "") {
_EXCEPTIONT("No input mesh (--in_mesh) specified");
}
if (strOutputMesh == "") {
_EXCEPTIONT("No output mesh (--out_mesh) specified");
}
// Overlap mesh
if (strOverlapMesh == "") {
_EXCEPTIONT("No overlap mesh specified");
}
// Check command line parameters (data arguments)
if ((strInputData != "") && (strOutputData == "")) {
_EXCEPTIONT("--in_data specified without --out_data");
}
if ((strInputData == "") && (strOutputData != "")) {
_EXCEPTIONT("--out_data specified without --in_data");
}
// Check metadata parameters
if ((strInputMeta != "") && (strInputType == "fv")) {
_EXCEPTIONT("--in_meta cannot be used with --in_type fv");
}
if ((strOutputMeta != "") && (strOutputType == "fv")) {
_EXCEPTIONT("--out_meta cannot be used with --out_type fv");
}
// Check command line parameters (data type arguments)
STLStringHelper::ToLower(strInputType);
STLStringHelper::ToLower(strOutputType);
DiscretizationType eInputType;
DiscretizationType eOutputType;
if (strInputType == "fv") {
eInputType = DiscretizationType_FV;
} else if (strInputType == "cgll") {
eInputType = DiscretizationType_CGLL;
} else if (strInputType == "dgll") {
eInputType = DiscretizationType_DGLL;
} else {
_EXCEPTION1("Invalid \"in_type\" value (%s), expected [fv|cgll|dgll]",
strInputType.c_str());
}
if (strOutputType == "fv") {
eOutputType = DiscretizationType_FV;
} else if (strOutputType == "cgll") {
eOutputType = DiscretizationType_CGLL;
} else if (strOutputType == "dgll") {
eOutputType = DiscretizationType_DGLL;
} else {
_EXCEPTION1("Invalid \"out_type\" value (%s), expected [fv|cgll|dgll]",
strOutputType.c_str());
}
// Monotonicity flags
int nMonotoneType = 0;
if (fMonotoneType1) {
nMonotoneType = 1;
}
if (fMonotoneType2) {
if (nMonotoneType != 0) {
_EXCEPTIONT("Only one of --mono, --mono2 and --mono3 may be set");
}
nMonotoneType = 2;
}
if (fMonotoneType3) {
if (nMonotoneType != 0) {
_EXCEPTIONT("Only one of --mono, --mono2 and --mono3 may be set");
}
nMonotoneType = 3;
}
/*
// Volumetric
if (fVolumetric && (nMonotoneType != 0)) {
_EXCEPTIONT("--volumetric cannot be used in conjunction with --mono#");
}
*/
// Create Offline Map
OfflineMap mapRemap;
// Initialize dimension information from file
AnnounceStartBlock("Initializing dimensions of map");
Announce("Input mesh");
mapRemap.InitializeSourceDimensionsFromFile(strInputMesh);
Announce("Output mesh");
mapRemap.InitializeTargetDimensionsFromFile(strOutputMesh);
AnnounceEndBlock(NULL);
// Parse variable list
std::vector< std::string > vecVariableStrings;
ParseVariableList(strVariables, vecVariableStrings);
// Parse preserve variable list
std::vector< std::string > vecPreserveVariableStrings;
ParseVariableList(strPreserveVariables, vecPreserveVariableStrings);
if (fPreserveAll && (vecPreserveVariableStrings.size() != 0)) {
_EXCEPTIONT("--preserveall and --preserve cannot both be specified");
}
// Load input mesh
AnnounceStartBlock("Loading input mesh");
Mesh meshInput(strInputMesh);
meshInput.RemoveZeroEdges();
AnnounceEndBlock(NULL);
// Calculate Face areas
AnnounceStartBlock("Calculating input mesh Face areas");
double dTotalAreaInput = meshInput.CalculateFaceAreas();
Announce("Input Mesh Geometric Area: %1.15e", dTotalAreaInput);
AnnounceEndBlock(NULL);
// Input mesh areas
if (eInputType == DiscretizationType_FV) {
mapRemap.SetSourceAreas(meshInput.vecFaceArea);
}
// Load output mesh
AnnounceStartBlock("Loading output mesh");
Mesh meshOutput(strOutputMesh);
meshOutput.RemoveZeroEdges();
AnnounceEndBlock(NULL);
// Calculate Face areas
AnnounceStartBlock("Calculating output mesh Face areas");
Real dTotalAreaOutput = meshOutput.CalculateFaceAreas();
Announce("Output Mesh Geometric Area: %1.15e", dTotalAreaOutput);
AnnounceEndBlock(NULL);
// Output mesh areas
if (eOutputType == DiscretizationType_FV) {
mapRemap.SetTargetAreas(meshOutput.vecFaceArea);
}
// Load overlap mesh
AnnounceStartBlock("Loading overlap mesh");
Mesh meshOverlap(strOverlapMesh);
meshOverlap.RemoveZeroEdges();
// Verify that overlap mesh is in the correct order
int ixSourceFaceMax = (-1);
int ixTargetFaceMax = (-1);
if (meshOverlap.vecSourceFaceIx.size() !=
meshOverlap.vecTargetFaceIx.size()
) {
_EXCEPTIONT("Invalid overlap mesh:\n"
" Possible mesh file corruption?");
}
for (int i = 0; i < meshOverlap.vecSourceFaceIx.size(); i++) {
if (meshOverlap.vecSourceFaceIx[i] + 1 > ixSourceFaceMax) {
ixSourceFaceMax = meshOverlap.vecSourceFaceIx[i] + 1;
}
if (meshOverlap.vecTargetFaceIx[i] + 1 > ixTargetFaceMax) {
ixTargetFaceMax = meshOverlap.vecTargetFaceIx[i] + 1;
}
}
// Check for forward correspondence in overlap mesh
if (ixSourceFaceMax == meshInput.faces.size() //&&
//(ixTargetFaceMax == meshOutput.faces.size())
) {
Announce("Overlap mesh forward correspondence found");
// Check for reverse correspondence in overlap mesh
} else if (
ixSourceFaceMax == meshOutput.faces.size() //&&
//(ixTargetFaceMax == meshInput.faces.size())
) {
Announce("Overlap mesh reverse correspondence found (reversing)");
// Reorder overlap mesh
meshOverlap.ExchangeFirstAndSecondMesh();
// No correspondence found
} else {
_EXCEPTION2("Invalid overlap mesh:\n"
" No correspondence found with input and output meshes (%i,%i)",
ixSourceFaceMax, ixTargetFaceMax);
}
AnnounceEndBlock(NULL);
// Calculate Face areas
AnnounceStartBlock("Calculating overlap mesh Face areas");
Real dTotalAreaOverlap = meshOverlap.CalculateFaceAreas();
Announce("Overlap Mesh Area: %1.15e", dTotalAreaOverlap);
AnnounceEndBlock(NULL);
// Partial cover
if (fabs(dTotalAreaOverlap - dTotalAreaInput) > 1.0e-10) {
if (!fNoCheck) {
Announce("WARNING: Significant mismatch between overlap mesh area "
"and input mesh area.\n Automatically enabling --nocheck");
fNoCheck = true;
}
}
/*
// Recalculate input mesh area from overlap mesh
if (fabs(dTotalAreaOverlap - dTotalAreaInput) > 1.0e-10) {
AnnounceStartBlock("Overlap mesh only covers a sub-area of the sphere");
Announce("Recalculating source mesh areas");
dTotalAreaInput = meshInput.CalculateFaceAreasFromOverlap(meshOverlap);
Announce("New Input Mesh Geometric Area: %1.15e", dTotalAreaInput);
AnnounceEndBlock(NULL);
}
*/
// Finite volume input / Finite volume output
if ((eInputType == DiscretizationType_FV) &&
(eOutputType == DiscretizationType_FV)
) {
// Generate reverse node array and edge map
meshInput.ConstructReverseNodeArray();
meshInput.ConstructEdgeMap();
// Initialize coordinates for map
mapRemap.InitializeSourceCoordinatesFromMeshFV(meshInput);
mapRemap.InitializeTargetCoordinatesFromMeshFV(meshOutput);
// Construct OfflineMap
AnnounceStartBlock("Calculating offline map");
LinearRemapFVtoFV(
meshInput, meshOutput, meshOverlap, nPin, mapRemap);
// Finite volume input / Finite element output
} else if (eInputType == DiscretizationType_FV) {
DataMatrix3D<int> dataGLLNodes;
DataMatrix3D<double> dataGLLJacobian;
if (strOutputMeta != "") {
AnnounceStartBlock("Loading meta data file");
LoadMetaDataFile(strOutputMeta, dataGLLNodes, dataGLLJacobian);
AnnounceEndBlock(NULL);
} else {
AnnounceStartBlock("Generating output mesh meta data");
double dNumericalArea =
GenerateMetaData(
meshOutput,
nPout,
fBubble,
dataGLLNodes,
dataGLLJacobian);
Announce("Output Mesh Numerical Area: %1.15e", dNumericalArea);
AnnounceEndBlock(NULL);
}
// Initialize coordinates for map
mapRemap.InitializeSourceCoordinatesFromMeshFV(meshInput);
mapRemap.InitializeTargetCoordinatesFromMeshFE(
meshOutput, nPout, dataGLLNodes);
// Generate the continuous Jacobian
bool fContinuous = (eOutputType == DiscretizationType_CGLL);
if (eOutputType == DiscretizationType_CGLL) {
GenerateUniqueJacobian(
dataGLLNodes,
dataGLLJacobian,
mapRemap.GetTargetAreas());
} else {
GenerateDiscontinuousJacobian(
dataGLLJacobian,
mapRemap.GetTargetAreas());
}
// Generate reverse node array and edge map
meshInput.ConstructReverseNodeArray();
meshInput.ConstructEdgeMap();
// Generate remap weights
AnnounceStartBlock("Calculating offline map");
if (fVolumetric) {
LinearRemapFVtoGLL_Volumetric(
meshInput,
meshOutput,
meshOverlap,
dataGLLNodes,
dataGLLJacobian,
mapRemap.GetTargetAreas(),
nPin,
mapRemap,
nMonotoneType,
fContinuous,
fNoConservation);
} else {
LinearRemapFVtoGLL(
meshInput,
meshOutput,
meshOverlap,
dataGLLNodes,
dataGLLJacobian,
mapRemap.GetTargetAreas(),
nPin,
mapRemap,
nMonotoneType,
fContinuous,
fNoConservation);
}
// Finite element input / Finite volume output
} else if (
(eInputType != DiscretizationType_FV) &&
(eOutputType == DiscretizationType_FV)
) {
DataMatrix3D<int> dataGLLNodes;
DataMatrix3D<double> dataGLLJacobian;
if (strInputMeta != "") {
AnnounceStartBlock("Loading meta data file");
LoadMetaDataFile(strInputMeta, dataGLLNodes, dataGLLJacobian);
AnnounceEndBlock(NULL);
} else {
AnnounceStartBlock("Generating input mesh meta data");
double dNumericalArea =
GenerateMetaData(
meshInput,
nPin,
fBubble,
dataGLLNodes,
dataGLLJacobian);
Announce("Input Mesh Numerical Area: %1.15e", dNumericalArea);
AnnounceEndBlock(NULL);
if (fabs(dNumericalArea - dTotalAreaInput) > 1.0e-12) {
Announce("WARNING: Significant mismatch between input mesh "
"numerical area and geometric area");
}
}
if (dataGLLNodes.GetSubColumns() != meshInput.faces.size()) {
_EXCEPTIONT("Number of element does not match between metadata and "
"input mesh");
}
// Initialize coordinates for map
mapRemap.InitializeSourceCoordinatesFromMeshFE(
meshInput, nPin, dataGLLNodes);
mapRemap.InitializeTargetCoordinatesFromMeshFV(meshOutput);
// Generate the continuous Jacobian for input mesh
bool fContinuousIn = (eInputType == DiscretizationType_CGLL);
if (eInputType == DiscretizationType_CGLL) {
GenerateUniqueJacobian(
dataGLLNodes,
dataGLLJacobian,
mapRemap.GetSourceAreas());
} else {
GenerateDiscontinuousJacobian(
dataGLLJacobian,
mapRemap.GetSourceAreas());
}
// Generate offline map
AnnounceStartBlock("Calculating offline map");
if (fVolumetric) {
_EXCEPTIONT("Unimplemented: Volumetric currently unavailable for"
"GLL input mesh");
}
LinearRemapSE4(
meshInput,
meshOutput,
meshOverlap,
dataGLLNodes,
dataGLLJacobian,
nMonotoneType,
fContinuousIn,
fNoConservation,
mapRemap
);
// Finite element input / Finite element output
} else if (
(eInputType != DiscretizationType_FV) &&
(eOutputType != DiscretizationType_FV)
) {
DataMatrix3D<int> dataGLLNodesIn;
DataMatrix3D<double> dataGLLJacobianIn;
DataMatrix3D<int> dataGLLNodesOut;
DataMatrix3D<double> dataGLLJacobianOut;
// Input metadata
if (strInputMeta != "") {
AnnounceStartBlock("Loading input meta data file");
LoadMetaDataFile(
strInputMeta, dataGLLNodesIn, dataGLLJacobianIn);
AnnounceEndBlock(NULL);
} else {
AnnounceStartBlock("Generating input mesh meta data");
double dNumericalAreaIn =
GenerateMetaData(
meshInput,
nPin,
fBubble,
dataGLLNodesIn,
dataGLLJacobianIn);
Announce("Input Mesh Numerical Area: %1.15e", dNumericalAreaIn);
AnnounceEndBlock(NULL);
if (fabs(dNumericalAreaIn - dTotalAreaInput) > 1.0e-12) {
Announce("WARNING: Significant mismatch between input mesh "
"numerical area and geometric area");
}
}
// Output metadata
if (strOutputMeta != "") {
AnnounceStartBlock("Loading output meta data file");
LoadMetaDataFile(
strOutputMeta, dataGLLNodesOut, dataGLLJacobianOut);
AnnounceEndBlock(NULL);
} else {
AnnounceStartBlock("Generating output mesh meta data");
double dNumericalAreaOut =
GenerateMetaData(
meshOutput,
nPout,
fBubble,
dataGLLNodesOut,
dataGLLJacobianOut);
Announce("Output Mesh Numerical Area: %1.15e", dNumericalAreaOut);
AnnounceEndBlock(NULL);
if (fabs(dNumericalAreaOut - dTotalAreaOutput) > 1.0e-12) {
Announce("WARNING: Significant mismatch between output mesh "
"numerical area and geometric area");
}
}
// Initialize coordinates for map
mapRemap.InitializeSourceCoordinatesFromMeshFE(
meshInput, nPin, dataGLLNodesIn);
mapRemap.InitializeTargetCoordinatesFromMeshFE(
meshOutput, nPout, dataGLLNodesOut);
// Generate the continuous Jacobian for input mesh
bool fContinuousIn = (eInputType == DiscretizationType_CGLL);
if (eInputType == DiscretizationType_CGLL) {
GenerateUniqueJacobian(
dataGLLNodesIn,
dataGLLJacobianIn,
mapRemap.GetSourceAreas());
} else {
GenerateDiscontinuousJacobian(
dataGLLJacobianIn,
mapRemap.GetSourceAreas());
}
// Generate the continuous Jacobian for output mesh
bool fContinuousOut = (eOutputType == DiscretizationType_CGLL);
if (eOutputType == DiscretizationType_CGLL) {
GenerateUniqueJacobian(
dataGLLNodesOut,
dataGLLJacobianOut,
mapRemap.GetTargetAreas());
} else {
GenerateDiscontinuousJacobian(
dataGLLJacobianOut,
mapRemap.GetTargetAreas());
}
// Generate offline map
AnnounceStartBlock("Calculating offline map");
LinearRemapGLLtoGLL2(
meshInput,
meshOutput,
meshOverlap,
dataGLLNodesIn,
dataGLLJacobianIn,
dataGLLNodesOut,
dataGLLJacobianOut,
mapRemap.GetTargetAreas(),
nPin,
nPout,
nMonotoneType,
fContinuousIn,
fContinuousOut,
fNoConservation,
mapRemap
);
} else {
_EXCEPTIONT("Not implemented");
}
//#pragma warning "NOTE: VERIFICATION DISABLED"
// Verify consistency, conservation and monotonicity
if (!fNoCheck) {
AnnounceStartBlock("Verifying map");
mapRemap.IsConsistent(1.0e-8);
mapRemap.IsConservative(1.0e-8);
if (nMonotoneType != 0) {
mapRemap.IsMonotone(1.0e-12);
}
AnnounceEndBlock(NULL);
}
AnnounceEndBlock(NULL);
// Initialize element dimensions from input/output Mesh
AnnounceStartBlock("Writing output");
// Output the Offline Map
if (strOutputMap != "") {
AnnounceStartBlock("Writing offline map");
mapRemap.Write(strOutputMap);
AnnounceEndBlock(NULL);
}
// Apply Offline Map to data
if (strInputData != "") {
AnnounceStartBlock("Applying offline map to data");
mapRemap.SetFillValueOverride(static_cast<float>(dFillValueOverride));
mapRemap.Apply(
strInputData,
strOutputData,
vecVariableStrings,
strNColName,
fOutputDouble,
false);
AnnounceEndBlock(NULL);
}
AnnounceEndBlock(NULL);
// Copy variables from input file to output file
if ((strInputData != "") && (strOutputData != "")) {
if (fPreserveAll) {
AnnounceStartBlock("Preserving variables");
mapRemap.PreserveAllVariables(strInputData, strOutputData);
AnnounceEndBlock(NULL);
} else if (vecPreserveVariableStrings.size() != 0) {
AnnounceStartBlock("Preserving variables");
mapRemap.PreserveVariables(
strInputData,
strOutputData,
vecPreserveVariableStrings);
AnnounceEndBlock(NULL);
}
}
AnnounceBanner();
return (0);
} catch(Exception & e) {
Announce(e.ToString().c_str());
return (-1);
} catch(...) {
return (-2);
}
}