void ComboSelection::processRender(const GsRect<float> &RectDispCoordFloat)
{
// Transform to the display coordinates
GsRect<float> displayRect = mRect;
displayRect.transform(RectDispCoordFloat);
SDL_Rect lRect = displayRect.SDLRect();
GsWeakSurface sfc(gVideoDriver.getBlitSurface());
if(!mEnabled)
{
mTextDisabledSfc.blitTo(sfc, lRect);
}
else
{
if(mHovered)
{
mTextLightSfc.blitTo(sfc, lRect);
}
else // Button is not hovered
{
mTextDarkSfc.blitTo(sfc, lRect);
}
}
drawBlinker(lRect);
}
float msl ( float height )
/*************************************************************/
/* MSL */
/* John Hart NSSFC KCMO */
/* */
/* Converts height (meters) AGL to MSL. */
/*************************************************************/
{
if ( sndgp == NULL ) return ( -999.0F );
if( height <= -998.0F )
{ return -999; }
else
{ return sndgp->sndg[sfc()].hght + height; }
}
float agl ( float height )
/*************************************************************/
/* AGL */
/* John Hart NSSFC KCMO */
/* */
/* Converts height (meters) MSL to AGL. */
/*************************************************************/
{
if ( sndgp == NULL ) return ( -999.0F );
if( height <= -998.0F )
{ return -999; }
else
{ return height - sndgp->sndg[sfc()].hght; }
}
Surface* Surface::createSurface(const Polyline &ply)
{
if (!ply.isClosed())
{
std::cout << "Error in Surface::createSurface() - Polyline is not closed..." <<
"\n";
return NULL;
}
if (ply.getNumberOfPoints() > 2)
{
// create empty surface
Surface* sfc(new Surface(ply.getPointsVec()));
Polygon* polygon (new Polygon (ply));
polygon->computeListOfSimplePolygons ();
// create surfaces from simple polygons
const std::list<GEOLIB::Polygon*>& list_of_simple_polygons (
polygon->getListOfSimplePolygons());
for (std::list<GEOLIB::Polygon*>::const_iterator simple_polygon_it (
list_of_simple_polygons.begin());
simple_polygon_it != list_of_simple_polygons.end(); ++simple_polygon_it)
{
std::list<GEOLIB::Triangle> triangles;
std::cout << "triangulation of surface: ... " << std::flush;
MathLib::EarClippingTriangulation(*simple_polygon_it, triangles);
std::cout << "done - " << triangles.size () << " triangles " << "\n";
// add Triangles to Surface
std::list<GEOLIB::Triangle>::const_iterator it (triangles.begin());
while (it != triangles.end())
{
sfc->addTriangle ((*it)[0], (*it)[1], (*it)[2]);
it++;
}
}
delete polygon;
return sfc;
}
else
{
std::cout <<
"Error in Surface::createSurface() - Polyline consists of less than three points and therefore cannot be triangulated..."
<< "\n";
return NULL;
}
}
void testSoftICADriver2()
{
const int numPatches = 20000;
const int patchWidth = 8;
NaturalImageDataFunction nidf(numPatches, patchWidth);
Config config;
const int numFeatures = 50;
const double lambda = 0.0005f;
const double epsilon = 1e-2;
SoftICACostFunction sfc(numFeatures, lambda, epsilon);
LIBLBFGSOptimizer lbfgs;
Driver drv(&config, &nidf, &sfc, &lbfgs);
drv.drive();
}
int main (int argc, char* argv[])
{
LOGOG_INITIALIZE();
logog::Cout* logog_cout (new logog::Cout);
BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter);
logog_cout->SetFormatter(*custom_format);
TCLAP::CmdLine cmd("Converts TIN file into VTU file.", ' ', BaseLib::BuildInfo::git_describe);
TCLAP::ValueArg<std::string> inArg("i", "input-tin-file",
"the name of the file containing the input TIN", true,
"", "string");
cmd.add(inArg);
TCLAP::ValueArg<std::string> outArg("o", "output-vtu-file",
"the name of the file the mesh will be written to", true,
"", "string");
cmd.add(outArg);
cmd.parse(argc, argv);
INFO("reading the TIN file...");
const std::string tinFileName(inArg.getValue());
auto pnt_vec = std::unique_ptr<std::vector<GeoLib::Point*>>(
new std::vector<GeoLib::Point*>);
GeoLib::PointVec point_vec("SurfacePoints", std::move(pnt_vec));
std::unique_ptr<GeoLib::Surface> sfc(FileIO::TINInterface::readTIN(tinFileName, point_vec));
if (!sfc)
return 1;
INFO("TIN read: %d points, %d triangles", pnt_vec->size(), sfc->getNTriangles());
INFO("converting to mesh data");
std::unique_ptr<MeshLib::Mesh> mesh(MeshLib::convertSurfaceToMesh(*sfc, BaseLib::extractBaseNameWithoutExtension(tinFileName), std::numeric_limits<double>::epsilon()));
INFO("Mesh created: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements());
INFO("Write it into VTU");
FileIO::VtuInterface writer(mesh.get());
writer.writeToFile(outArg.getValue());
delete custom_format;
delete logog_cout;
LOGOG_SHUTDOWN();
return 0;
}
Surface* Surface::createSurface(const Polyline &ply)
{
if (!ply.isClosed()) {
WARN("Error in Surface::createSurface() - Polyline is not closed.");
return NULL;
}
if (ply.getNumberOfPoints() > 2) {
// create empty surface
Surface *sfc(new Surface(ply.getPointsVec()));
Polygon* polygon (new Polygon (ply));
polygon->computeListOfSimplePolygons ();
// create surfaces from simple polygons
const std::list<GeoLib::Polygon*>& list_of_simple_polygons (polygon->getListOfSimplePolygons());
for (std::list<GeoLib::Polygon*>::const_iterator simple_polygon_it (list_of_simple_polygons.begin());
simple_polygon_it != list_of_simple_polygons.end(); ++simple_polygon_it) {
std::list<GeoLib::Triangle> triangles;
GeoLib::EarClippingTriangulation(*simple_polygon_it, triangles);
// add Triangles to Surface
std::list<GeoLib::Triangle>::const_iterator it (triangles.begin());
while (it != triangles.end()) {
sfc->addTriangle ((*it)[0], (*it)[1], (*it)[2]);
it++;
}
}
delete polygon;
if (sfc->getNTriangles() == 0) {
WARN("Surface::createSurface(): Triangulation does not contain any triangle.");
delete sfc;
return nullptr;
}
return sfc;
} else {
WARN("Error in Surface::createSurface() - Polyline consists of less than three points and therefore cannot be triangulated.");
return nullptr;
}
}
int main (int argc, char* argv[])
{
ApplicationsLib::LogogSetup logog_setup;
TCLAP::CmdLine cmd(
"Converts TIN file into VTU file.\n\n"
"OpenGeoSys-6 software, version " +
BaseLib::BuildInfo::git_describe +
".\n"
"Copyright (c) 2012-2018, OpenGeoSys Community "
"(http://www.opengeosys.org)",
' ', BaseLib::BuildInfo::git_describe);
TCLAP::ValueArg<std::string> inArg("i", "input-tin-file",
"the name of the file containing the input TIN", true,
"", "string");
cmd.add(inArg);
TCLAP::ValueArg<std::string> outArg("o", "output-vtu-file",
"the name of the file the mesh will be written to", true,
"", "string");
cmd.add(outArg);
cmd.parse(argc, argv);
INFO("reading the TIN file...");
const std::string tinFileName(inArg.getValue());
auto pnt_vec = std::make_unique<std::vector<GeoLib::Point*>>();
GeoLib::PointVec point_vec("SurfacePoints", std::move(pnt_vec));
std::unique_ptr<GeoLib::Surface> sfc(
GeoLib::IO::TINInterface::readTIN(tinFileName, point_vec));
if (!sfc)
return EXIT_FAILURE;
INFO("TIN read: %d points, %d triangles", pnt_vec->size(), sfc->getNumberOfTriangles());
INFO("converting to mesh data");
std::unique_ptr<MeshLib::Mesh> mesh(MeshLib::convertSurfaceToMesh(*sfc, BaseLib::extractBaseNameWithoutExtension(tinFileName), std::numeric_limits<double>::epsilon()));
INFO("Mesh created: %d nodes, %d elements.", mesh->getNumberOfNodes(), mesh->getNumberOfElements());
INFO("Write it into VTU");
MeshLib::IO::VtuInterface writer(mesh.get());
writer.writeToFile(outArg.getValue());
return EXIT_SUCCESS;
}
void testSoftICADriver()
{
const int numPatches = 200000; // 200000 10000
const int patchWidth = 8;
MNISTSamplePatchesDataFunction mnistdf(numPatches, patchWidth);
Config config;
config.setValue("addBiasTerm", false);
config.setValue("meanStddNormalize", false);
config.setValue("configurePolicyTesting", false);
config.setValue("trainingMeanAndStdd", false);
updateMNISTConfig(config);
const int numFeatures = 50;
const double lambda = 0.0005f;
const double epsilon = 1e-2;
SoftICACostFunction sfc(numFeatures, lambda, epsilon);
LIBLBFGSOptimizer lbfgs(1000);
Driver drv(&config, &mnistdf, &sfc, &lbfgs);
drv.drive();
}
void
draw_hodo (void)
/*************************************************************/
/* DRAW_HODO */
/* John Hart NSSFC KCMO */
/* */
/* Draws a standard Hodograph display. */
/*************************************************************/
{
short x1, y1, x2, y2, i, y3;
float wdir, wspd, mnu, mnv, ix1, ix2, ix3, ix4;
char st[10];
setcolor (0, draw_reg, gc);
rectangle (1, 1, 1, hov.brx + 14, hov.bry + 14);
setcolor (1, draw_reg, gc);
set_font (2);
setcliprgn (hov.tlx, hov.tly, hov.brx, hov.bry, draw_reg, gc);
setlinestyle (1, 1);
rectangle (0, hov.tlx, hov.tly, hov.brx, hov.bry);
/* ----- Plot crosshairs ----- */
setcolor (31, draw_reg, gc);
hodo_to_pix (180.0F, 60.0F, &x1, &y1);
moveto (x1, hov.tly);
lineto (x1, hov.bry);
setcolor (31, draw_reg, gc);
hodo_to_pix (270.0F, 60.0F, &x1, &y1);
moveto (hov.tlx, y1);
lineto (hov.brx, y1);
/* ----- Plot Radius circles ----- */
setcolor (24, draw_reg, gc);
setlinestyle (2, 1);
hodo_to_pix (0.0F, 0.0F, &x1, &y1);
x2 = x1;
y2 = y1;
for (i = hov.scale; i <= hov.hodomag; i = i + hov.scale)
{
hodo_to_pix (0.0F, (float) i, &x1, &y1);
y3 = (y1 - y2);
ellipse (0, x2 - y3, y2 - y3, x2 + y3, y2 + y3);
}
setcolor (1, draw_reg, gc);
/* ----- Plot X-Coord hash marks ----- */
for (i = hov.scale; i <= hov.hodomag; i = i + hov.scale)
{
hodo_to_pix (180.0F, (float) i, &x1, &y1);
moveto (x1 - 3, y1);
lineto (x1 + 3, y1);
itoa (i, st, 10);
outgtext (st, x1 - getgtextextent (st) - 4, y1 - 5);
hodo_to_pix (360.0F, (float) i, &x1, &y1);
moveto (x1 - 3, y1);
lineto (x1 + 3, y1);
itoa (i, st, 10);
outgtext (st, x1 - getgtextextent (st) - 4, y1 - 5);
}
/* ----- Plot Y-Coord hash marks ----- */
setcolor (1, draw_reg, gc);
for (i = hov.scale; i <= hov.hodomag; i = i + hov.scale)
{
hodo_to_pix (90.0F, (float) i, &x1, &y1);
moveto (x1, y1 - 3);
lineto (x1, y1 + 3);
itoa (i, st, 10);
outgtext (st, x1 - (getgtextextent (st) / 2), y1 + 5);
hodo_to_pix (270.0F, (float) i, &x1, &y1);
moveto (x1, y1 - 3);
lineto (x1, y1 + 3);
itoa (i, st, 10);
outgtext (st, x1 - (getgtextextent (st) / 2), y1 + 5);
}
/* ----- Plot Hodograph (Shear Vectors) ----- */
setcolor (2, draw_reg, gc);
setlinestyle (1, 2);
if ((sndgp != NULL) && (sndgp->numlev > 0))
{
trace_hodo (3);
/* ----- Plot Mean Wind Vector ----- */
setcolor (5, draw_reg, gc);
mean_wind (-1.0F, -1.0F, &mnu, &mnv, &wdir, &wspd);
hodo_to_pix (wdir, wspd, &x1, &y1);
moveto (x1, y1);
rectangle (0, (short) (x1 - 4), (short) (y1 - 4), (short) (x1 + 4),
(short) (y1 + 4));
/* ----- Plot 30/75 Storm Motion Vector ----- */
mean_wind (sndgp->sndg[sfc ()].pres, i_pres (msl (6000.0F)), &ix1, &ix2,
&ix3, &ix4);
setcolor (11, draw_reg, gc);
setlinestyle (1, 1);
ix4 *= .75F;
ix3 += 30.0F;
if (ix3 > 360.0F)
ix3 -= 360.0F;
hodo_to_pix (ix3, ix4, &x1, &y1);
moveto (x1 - 3, y1);
lineto (x1 + 3, y1);
moveto (x1, y1 - 3);
lineto (x1, y1 + 3);
ellipse (0, x1 - 3, y1 - 3, x1 + 3, y1 + 3);
/* ----- Plot 15/85 Storm Motion Vector ----- */
mean_wind (sndgp->sndg[sfc ()].pres, i_pres (msl (6000.0F)), &ix1, &ix2,
&ix3, &ix4);
setcolor (12, draw_reg, gc);
setlinestyle (1, 1);
ix4 *= .85F;
ix3 += 15.0F;
if (ix3 > 360.0F)
ix3 -= 360.0F;
hodo_to_pix (ix3, ix4, &x1, &y1);
moveto (x1 - 3, y1);
lineto (x1 + 3, y1);
moveto (x1, y1 - 3);
lineto (x1, y1 + 3);
ellipse (0, x1 - 3, y1 - 3, x1 + 3, y1 + 3);
/* ----- Plot Current Storm Motion Vector ----- */
setcolor (31, draw_reg, gc);
setlinestyle (1, 1);
hodo_to_pix (sndgp->st_dir, sndgp->st_spd, &x1, &y1);
moveto (x1 - 6, y1);
lineto (x1 + 6, y1);
moveto (x1, y1 - 6);
lineto (x1, y1 + 6);
ellipse (0, x1 - 6, y1 - 6, x1 + 6, y1 + 6);
/* ----- Display Hodograph Inset ----- */
draw_hoinset ();
setcolor (1, draw_reg, gc);
set_font (1);
outgtext (sndgp->title, skv.tlx, 1);
}
/* ----- Draw final outline of hodograph ----- */
setcolor (1, draw_reg, gc);
setlinestyle (1, 1);
rectangle (0, hov.tlx, hov.tly, hov.brx, hov.bry);
/* reset clip region */
setcliprgn (1, 1, xwdth, xhght, draw_reg, gc);
XCopyArea (XtDisplay (draw_reg), canvas, XtWindow (draw_reg),
gc, 0, 0, xwdth, xhght, 0, 0);
}
/*NP*/
void posneg_temperature(float start, float *pos, float *neg, float *top,
float *bot)
/***********************************************************************/
/* POSNEG */
/* Calculates positive and negative areas as related to winter weather */
/* forecasting. Search begins at 500mb, but only returns results if */
/* a positive area is found, overlaying a negative area. */
/* START is the upper limit of search.(default=init_phase) */
/***********************************************************************/
{
float upper, lower, pe1, h1, te1, tp1, totp, totn, pe2, h2, te2,
tp2, tdef1, tdef2;
float lyrlast, lyre, tote, pelast, ptop, pbot, lvl;
short i, lptr, uptr, warmlayer=0, coldlayer=0, phase;
short pIndex, zIndex, tdIndex;
/* ----- If there is no sounding, do not compute ----- */
if (!qc(i_temp(500, I_PRES)) && !qc(i_temp(850, I_PRES))) return;
pIndex = getParmIndex("PRES");
zIndex = getParmIndex("HGHT");
tdIndex = getParmIndex("DWPT");
if (!sndg || pIndex == -1 || zIndex == -1 || tdIndex == -1)
return;
/* ----- Find lowest observation in layer ----- */
lower=sndg[sfc()][pIndex];
lptr = sfc();
/* ----- Find highest observation in layer ----- */
if (start=-1) {
(void)init_phase(&lvl, &phase);
/*
strcpy( st, init_phase( &lvl, &phase ));
*/
if (lvl > 0.0)
upper = lvl;
else
upper = 500.0;
}
else {
upper = start;
}
i=numlvl-1;
while(sndg[i][pIndex] < upper) {
i--;
if (i < 0) {
fprintf(stderr,
"Warning: posneg_temp: Could not find a pressure greater than %.2f\n",
upper);
fprintf(stderr, "Using %.2f as the upper level.\n",
sndg[0][pIndex]);
i = 0;
break;
}
}
uptr = i;
if (sndg[i][pIndex] == upper)
uptr--;
/* ----- Start with top layer ----- */
pe1 = upper;
h1 = i_hght(pe1, I_PRES);
te1 = i_temp(pe1, I_PRES);
tp1 = 0;
totp = totn = tote = ptop = pbot = 0;
for( i = uptr; i >= lptr; i--) {
if (qc(sndg[i][tdIndex])) {
/* ----- Calculate every level that reports a temp ----- */
pe2 = sndg[i][pIndex];
h2 = sndg[i][zIndex];
te2 = i_temp(pe2, I_PRES);
tp2 = 0;
tdef1 = (0 - te1) / (te1 + 273.15);
tdef2 = (0 - te2) / (te2 + 273.15);
lyrlast = lyre;
lyre = 9.8F * (tdef1 + tdef2) / 2.0F * (h2 - h1);
/* Has a warm layer been found yet? */
if (te2>0)
if (warmlayer==0) {
warmlayer=1;
ptop=pe2;
}
/* Has a cold layer been found yet? */
if (te2<0)
if ((warmlayer==1) && (coldlayer==0)) {
coldlayer=1;
pbot=pe2;
}
if (warmlayer>0) {
if (lyre>0)
totp += lyre;
else
totn += lyre;
tote += lyre;
printf("%4.0f - %4.0f E=%6.0f TOT=%6.0f Top=%6.0f Bot=%6.0f\n",
pe1, pe2, lyre, tote, ptop, pbot);
}
pelast = pe1;
pe1 = pe2;
h1 = h2;
te1 = te2;
tp1 = tp2;
}
}
if ((warmlayer==1) && (coldlayer==1)) {
*pos = totp;
*neg = totn;
*top = ptop;
*bot = pbot;
printf("Tot= %.0f J/kg Pos= %.0f J/kg Neg= %.0f J/kg\n",
tote, totp, totn);
printf("Top= %.0f Bot= %.0f\n", ptop, pbot);
}
else {
printf ("Warm/Cold Layers not found.\n" );
*pos = 0;
*neg = 0;
*top = 0;
*bot = 0;
}
}
/*NP*/
void plot_thetae(void)
/*************************************************************/
/* PLOT_THETAE */
/* John Hart NSSFC KCMO */
/* */
/* Plots vertical profile of Theta-E (sfc-500mb) */
/*************************************************************/
{
float bothgt, tophgt, h, cthe, ix1;
short x1, y1, x2, y2, i, tlx, tly;
short pIndex, zIndex, tIndex, tdIndex;
char st[10];
pIndex = getParmIndex("PRES");
zIndex = getParmIndex("HGHT");
tIndex = getParmIndex("TEMP");
tdIndex = getParmIndex("DWPT");
if (!sndg || pIndex == -1 || tIndex == -1 || tdIndex == -1 ||
zIndex == -1)
return;
/* tlx = hov.brx - 150;
tly = hov.tly; */
tlx = hov.tlx + 120;
tly = hov.bry;
setcliprgn(tlx, tly, tlx+134, tly+120);
setcolor(0);
setlinestyle( 1, 1 );
rectangle(1,tlx, tly, tlx+134, tly+120);
setcolor(1);
rectangle(0, tlx, tly, tlx+134, tly+120);
/* ----- Set Layer (AGL) ----- */
bothgt = 0;
tophgt = agl(i_hght(500, I_PRES));
/* ----- Plot Label ----- */
setcolor(1);
set_font(4);
outgtext("Theta-E vs", tlx+55, tly+3);
outgtext("Pressure", tlx+55, tly+15);
/* ----- Plot horizontal legend ----- */
if (800 < pIndex < 850){
cthe = (thetae(800, i_temp(800, I_PRES), i_dwpt(800, I_PRES)) +
thetae(650, i_temp(650, I_PRES), i_dwpt(650, I_PRES)) +
thetae(sndg[sfc()][pIndex], sndg[sfc()][tIndex],
sndg[sfc()][tdIndex])) / 3.0;
}
if (750 < pIndex < 800){
cthe = (thetae(750, i_temp(750, I_PRES), i_dwpt(750, I_PRES)) +
thetae(600, i_temp(600, I_PRES), i_dwpt(600, I_PRES)) +
thetae(sndg[sfc()][pIndex], sndg[sfc()][tIndex],
sndg[sfc()][tdIndex])) / 3.0;
}
if (700 < pIndex < 750){
cthe = (thetae(700, i_temp(700, I_PRES), i_dwpt(700, I_PRES)) +
thetae(500, i_temp(500, I_PRES), i_dwpt(500, I_PRES)) +
thetae(sndg[sfc()][pIndex], sndg[sfc()][tIndex],
sndg[sfc()][tdIndex])) / 3.0;
}
if (pIndex >= 850){
cthe = (thetae(850, i_temp(850, I_PRES), i_dwpt(850, I_PRES)) +
thetae(700, i_temp(700, I_PRES), i_dwpt(700, I_PRES)) +
thetae(sndg[sfc()][pIndex], sndg[sfc()][tIndex],
sndg[sfc()][tdIndex])) / 3.0;
}
setcolor(19);
set_font(5);
for(h=cthe - 30.0; h<=cthe + 30.0; h += 10) {
x1 = (short)(tlx + 60 + ((h-cthe)*2.5));
y1 = tly+120;
moveto( x1, y1);
lineto( x1, y1-5);
sprintf(st, "%.0f", h + 273.15);
outgtext(st, x1-6, y1-14);
}
/* ----- Plot vertical theta-e profile ----- */
setlinestyle(1, 2);
setcolor(2);
x2 = 999;
if (sndg[numlvl-1][pIndex] < 500) {
for (i=0; sndg[i][pIndex] >= 500; i++) {
/*printf ("i = %d, PRES = %.1f\n", i, sndg[i][pIndex]);*/
if (qc(sndg[i][tdIndex])) {
x1 = (short)(tlx + 60 + ((thetae(sndg[i][pIndex],
sndg[i][tIndex], sndg[i][tdIndex])-cthe)*2.5));
y1 = vert_coords(agl(sndg[i][zIndex]), tophgt, tly);
if(x2 == 999) { x2=x1; y2=y1; }
moveto(x1, y1);
lineto(x2, y2);
x2=x1;
y2=y1;
}
}
}
/* ----- Plot Vertical Legend ----- */
setlinestyle(1, 1);
setcolor(1);
set_font(5);
x2 = 999;
for(i=1000; i >= 600; i -= 100) {
x1 = tlx;
y1 = vert_coords(agl(i_hght(i, I_PRES)), tophgt, tly);
moveto( x1, y1);
lineto( x1+5, y1);
sprintf(st, "%d", i);
if (i<1000) outgtext(st, x1+6, y1-5);
}
setcliprgn(1, 1, xwdth, xhght);
copytodisplay();
/* plot theta-e index */
setcolor(19);
set_font(4);
sprintf( st, "TEI = %s", qc2( ThetaE_diff(&ix1), "", 0));
outgtext( st, tlx + 80, tly + 50);
}
/*NP*/
float visual1(float lower, float upper, float pres, float temp, float dwpt, int ulx, int uly, int vwid)
/*************************************************************/
/* VISUAL1 */
/* John Hart NSSFC KCMO */
/* */
/* Lifts specified parcel, given an initial 5 m/s push. */
/* parcel trajectory is then calculated, using strict */
/* parcel theory. Updraft size is assumed 1km dia. */
/* */
/* All calculations use the virtual temperature correction. */
/* */
/* lower = Bottom level of layer (mb) [ -1=SFC] */
/* upper = Top level of layer (mb) [ -1=TOP] */
/* pres = LPL pressure (mb) */
/* temp = LPL temperature (c) */
/* dwpt = LPL dew point (c) */
/*************************************************************/
{
short i, lptr, uptr, pIndex, zIndex, tIndex, tdIndex;
float te1, pe1, te2, pe2, h1, h2, lyre, tdef1, tdef2, totp, totn;
float te3, pe3, h3, tp1, tp2, tp3, tdef3, lyrf, lyrlast, pelast;
float tote, dh, restim, uvv, ix1, ix2, tottim;
float u, v, du, dv, tsu, tsv, tdist, tangle, disp, angl;
short colrx;
lyre = -1;
totp = 25;
totn = 0;
pIndex = getParmIndex("PRES");
zIndex = getParmIndex("HGHT");
tIndex = getParmIndex("TEMP");
tdIndex = getParmIndex("DWPT");
if (!sndg || pIndex == -1 || zIndex == -1 || tIndex == -1 || tdIndex == -1) return RMISSD;
/* ----- See if default layer is specified ----- */
if (lower == -1) { lower = sndg[sfc()][pIndex]; }
if (upper == -1) { upper = sndg[numlvl-1][pIndex]; }
/* ----- Make sure this is a valid layer ----- */
if( lower > pres ) { lower = pres; }
if( !qc( i_vtmp( upper , I_PRES))) { return RMISSD; }
if( !qc( i_vtmp( lower , I_PRES))) { return RMISSD; }
/* ----- Begin with Mixing Layer (LPL-LCL) ----- */
te1 = i_vtmp(pres , I_PRES);
pe1 = lower;
h1 = i_hght(pe1 , I_PRES);
tp1 = virtemp(pres, temp, dwpt);
drylift(pres, temp, dwpt, &pe2, &tp2);
h2 = i_hght(pe2 , I_PRES);
te2 = i_vtmp(pe2 , I_PRES);
if( lower > pe2 ) { lower = pe2; }
/* ----- Find lowest observation in layer ----- */
i = 0;
while( sndg[i][pIndex] > lower) { i++; }
while ( !qc(sndg[i][tdIndex]) ) { i++; }
lptr = i;
if( sndg[i][pIndex] == lower ) { lptr++; }
/* ----- Find highest observation in layer ----- */
i=numlvl-1;
while(sndg[i][pIndex] < upper) { i--; }
uptr = i;
if( sndg[i][pIndex] == upper ) { uptr--; }
/* ----- Start with interpolated bottom layer ----- */
pe1 = lower;
h1 = i_hght( pe1 , I_PRES);
te1 = i_vtmp( pe1 , I_PRES);
tp1 = wetlift(pe2, tp2, pe1);
totp = 25;
totn = 0;
tsu = 0;
tsv = 0;
restim = 0;
tottim = 0;
for (i = lptr; i < numlvl; i++) {
if (qc(sndg[i][tIndex])) {
/* ----- Calculate every level that reports a temp ----- */
pe2 = sndg[i][pIndex];
h2 = sndg[i][zIndex];
te2 = i_vtmp( pe2 , I_PRES);
tp2 = wetlift(pe1, tp1, pe2);
tdef1 = (virtemp(pe1, tp1, tp1) - te1) / (te1 + 273.15);
tdef2 = (virtemp(pe2, tp2, tp2) - te2) / (te2 + 273.15);
lyrlast = lyre;
lyre = 9.8F * (tdef1 + tdef2) / 2.0F * (h2 - h1);
if( lyre > 0 ) { totp += lyre; }
else { if(pe2 > 500) { totn += lyre; } }
tote += lyre;
uvv = (float)sqrt( totp * 2 );
dh = h2 - h1;
restim = dh / uvv;
tottim += restim;
sr_wind( pe1, pe2, st_dir, st_spd, &u, &v, &ix1, &ix2);
du = kt_to_mps(u) * restim;
dv = kt_to_mps(v) * restim;
tsu -= du;
tsv += dv;
tdist = (float)sqrt((tsu*tsu) + (tsv*tsv));
tangle = angle(tsu, tsv);
pelast = pe1;
pe1 = pe2;
h1 = h2;
te1 = te2;
tp1 = tp2;
/* ----- Is this the top of given layer ----- */
if(i >= uptr) {
pe3 = pe1;
h3 = h1;
te3 = te1;
tp3 = tp1;
lyrf = lyre;
if( lyrf > 0 )
{ totp -= lyrf; }
else
{ if(pe2 > 500) { totn -= lyrf; } }
pe2 = upper;
h2 = i_hght( pe2 , I_PRES);
te2 = i_vtmp( pe2 , I_PRES);
tp2 = wetlift(pe3, tp3, pe2);
tdef3 = (virtemp(pe3, tp3, tp3) - te3) / (te3 + 273.15);
tdef2 = (virtemp(pe2, tp2, tp2) - te2) / (te2 + 273.15);
lyrf = 9.8F * (tdef3 + tdef2) / 2.0F * (h2 - h3);
if( lyrf > 0 )
{ totp += lyrf; }
else
{ if(pe2 > 500) { totn -= lyrf; } }
if( totp == 0 ) { totn = 0; }
uvv = (float)sqrt( totp * 2 );
dh = h2 - h1;
restim = dh / uvv;
tottim += restim;
sr_wind( pe1, pe2, st_dir, st_spd, &u, &v, &ix1, &ix2);
du = kt_to_mps(u) * restim;
dv = kt_to_mps(v) * restim;
tsu -= du;
tsv += dv;
tdist = (float)sqrt((tsu*tsu) + (tsv*tsv));
tangle = angle(tsu, tsv);
colrx = 7;
vis_xy( -tsu, -tsv, colrx, ulx, uly, vwid);
angl = 90 - angle( tdist, agl(h2));
write_vis_data( tottim, angl, ulx, uly, vwid );
return 1;
}
colrx = 13;
if (h2>msl(3000)) colrx=3;
if (h2>msl(6000)) colrx=27;
if (h2>msl(9000)) colrx=20;
if (h2>msl(12000)) colrx=6;
vis_xy(-tsu, -tsv, colrx, ulx, uly, vwid);
if (sndg[i][pIndex] == 500) {
disp = tdist;
angl = 90 - angle( tdist, agl(sndg[i][zIndex]));
}
}
}
return 1.0; /* ? mkay. there was no value before. bad thing */
}
/* NP */
short ww_type(short *wwtype, short *dcp)
/********************************************************************/
/* Watch type guidance */
/* A decision tree to help with ww issuance */
/* */
/* Rich Thompson SPC OUN */
/********************************************************************/
{
float ix1, ix2, ix3, ix4, lr75, shr6, t500, fzlh, mumixr, lowrh, midrh, low_mid_rh;
float mucn, mlcn, mlcp, sbcp, mucp, lr1, lr3, shr6_dir, sr46_dir, sr46_spd, shr6_sr46_diff, mmp;
float sig_tor, sig_tor_winter, sighail, wind_dmg, rm_scp, cbsig, dncp, srh1, sblcl, mllcl;
float oldlplpres, pres, pbot, ptop, shr8, bot, top, esrh, lm_scp;
short oldlplchoice, ww_choice;
short pIndex, tIndex, zIndex, tdIndex;
short x1, y1, x2, y2, tlx, tly, wid;
struct _parcel pcl;
char st[40];
tlx = hov.tlx + 409;
tly = hov.bry;
wid = 119;
setcliprgn( tlx+2, tly+2, tlx+wid+24, tly+wid+1);
setcolor(0);
setlinestyle( 1, 1 );
rectangle( 1,tlx, tly, tlx+wid+27, tly+wid+1);
setcolor(1);
rectangle( 0, tlx, tly, tlx+wid+27, tly+wid+1);
setlinestyle( 1, 1 );
moveto( tlx + 2, tly + 18);
lineto(tlx + wid + 27, tly + 18);
/* ----- Plot Label ----- */
set_font(6);
setcolor(1);
outgtext( "Psbl Watch Type", tlx + 20, tly + 3 );
*wwtype = 0;
*dcp = 0;
oldlplchoice = lplvals.flag;
tIndex = getParmIndex("TEMP");
pIndex = getParmIndex("PRES");
zIndex = getParmIndex("HGHT");
tdIndex = getParmIndex("DWPT");
/* 24 Mar 2008 */
/* effective_inflow_layer(100, -250, &pbot, &ptop);*/
/* sb parcel */
define_parcel(1,0);
ix1 = parcel(-1, -1, lplvals.pres, lplvals.temp, lplvals.dwpt, &pcl);
sbcp = pcl.bplus;
sblcl = agl(i_hght(pcl.lclpres, I_PRES));
sig_tor_winter = sigtorn_fixed(st_dir, st_spd);
/* ml parcel */
define_parcel(4,100);
ix1 = parcel(-1, -1, lplvals.pres, lplvals.temp, lplvals.dwpt, &pcl);
mlcn = pcl.bminus;
mlcp = pcl.bplus;
mllcl = agl(i_hght(pcl.lclpres, I_PRES));
sig_tor = sigtorn_cin(st_dir, st_spd);
/* mu parcel */
define_parcel(3,400);
mucp = parcel(-1, -1, lplvals.pres, lplvals.temp, lplvals.dwpt, &pcl);
mucn = pcl.bminus;
dncp = dcape(&ix1, &ix2);
/* sighail ingredients */
lr75 = lapse_rate(&ix1, 700, 500);
wind_shear(sndg[sfc()][pIndex], i_pres(msl(6000)), &ix1, &ix2, &ix3, &ix4);
shr6 = ix4;
shr6_dir = ix3;
wind_shear(sndg[sfc()][pIndex], i_pres(msl(8000)), &ix1, &ix2, &ix3, &ix4);
shr8 = ix4;
mumixr = mixratio(lplvals.pres, lplvals.dwpt);
t500 = i_temp(500, I_PRES);
fzlh = mtof(agl(i_hght(temp_lvl(0, &ix1), I_PRES)));
sighail = sig_hail(pcl.bplus, mumixr, lr75, t500, kt_to_mps(shr6), fzlh, pcl.bminus, 0, 0, 25, mlcp);
rm_scp = scp(st_dir, st_spd);
wind_dmg = damaging_wind();
sr_wind( i_pres(msl(4000)), i_pres(msl(6000)), st_dir, st_spd, &ix1, &ix2, &ix3, &ix4);
sr46_dir = ix3;
sr46_spd = ix4;
shr6_sr46_diff = (shr6_dir - sr46_dir);
srh1 = helicity(0, 1000, st_dir, st_spd, &ix1, &ix2);
bot = agl(i_hght(p_bot, I_PRES));
top = agl(i_hght(p_top, I_PRES));
esrh = helicity(bot, top, st_dir, st_spd, &ix1, &ix2);
lapse_rate(&ix2, sndg[sfc()][pIndex], i_pres(sndg[sfc()][zIndex]+1000));
lr1 = ix2;
lapse_rate(&ix2, sndg[sfc()][pIndex], i_pres(sndg[sfc()][zIndex]+3000));
lr3 = ix2;
mean_relhum(&ix1, sndg[sfc()][pIndex]-150, sndg[sfc()][pIndex]-350);
midrh = ix1;
mean_relhum(&ix1, sndg[sfc()][pIndex], sndg[sfc()][pIndex]-150);
lowrh = ix1;
low_mid_rh = ((lowrh + midrh)/2);
mmp = coniglio1();
cbsig = (mlcp * kt_to_mps(shr6));
/* 24 Mar 2008 */
/* all "p_bot" below were changed from "pbot" */
/* Decision tree below is identical to the operational "ww_type" flow chart documentation 9/23/09 RLT */
if ((sig_tor >= 3.0) && (sig_tor_winter >= 3.0) && (srh1 >= 150) && (esrh >= 150) && (sr46_spd >= 15.0) && (shr8 >= 40.0) && (sblcl < 1000) && (mllcl < 1100) && (lr1 >= 5.0) && (bot == 0.0)) {
*dcp = 1;
*wwtype = 5;
ww_choice = 5;
/*printf("\n dcp (in PDS) = %d", *dcp);*/
set_font(6);
setcolor(7);
outgtext( "PDS TOR", tlx + 45, tly + 60 );
}
/* else
if ((sig_tor_winter >= 4.0) && (sr46_spd >= 15.0) && (shr8 >= 40.0) && (sblcl < 1000) && (lr1 >= 5.0) && (bot == 0.0)) {
*dcp = 2;
*wwtype = 5;
ww_choice = 5;
set_font(6);
setcolor(7);
outgtext( "PDS TOR", tlx + 45, tly + 60 );
}
*/
else
if (((sig_tor >= 3.0) || (sig_tor_winter >= 4.0)) && (bot == 0.0)) {
*dcp = 3;
*wwtype = 4;
ww_choice = 4;
/*printf("\n dcp (in TOR) = %d", *dcp);*/
set_font(6);
setcolor(2);
outgtext( "TOR", tlx + 45, tly + 60 );
}
else
if (((sig_tor >= 1.0) || (sig_tor_winter >= 1.0)) && ((sr46_spd >= 15.0) || (shr8 >= 40.0)) && (bot == 0.0)) {
*dcp = 4;
*wwtype = 4;
ww_choice = 4;
/*printf("\n dcp (in TOR) = %d", *dcp);*/
set_font(6);
setcolor(2);
outgtext( "TOR", tlx + 45, tly + 60 );
}
else
if (((sig_tor >= 1.0) || (sig_tor_winter >= 1.0)) && (low_mid_rh >= 60) && (lr1 >= 5.0) && (bot == 0.0)) {
*dcp = 5;
*wwtype = 4;
ww_choice = 4;
/*printf("\n dcp (in TOR) = %d", *dcp);*/
set_font(6);
setcolor(2);
outgtext( "TOR", tlx + 45, tly + 60 );
}
else
if ((( sig_tor >= 1.0) || (sig_tor_winter >= 1.0)) && (bot == 0.0)) {
*dcp = 6;
*wwtype = 3;
ww_choice = 3;
/*printf("\n dcp (in mrgl TOR) = %d", *dcp);*/
set_font(6);
setcolor(2);
outgtext( "mrgl TOR", tlx + 40, tly + 60 );
}
else
if (((( sig_tor >= 0.5) && (esrh >= 150)) || ((sig_tor_winter >= 0.5) && (srh1 >= 150))) && (bot == 0.0)) {
*dcp = 7;
*wwtype = 3;
ww_choice = 3;
/*printf("\n dcp (in mrgl TOR) = %d", *dcp);*/
set_font(6);
setcolor(2);
outgtext( "mrgl TOR", tlx + 40, tly + 60 );
}
else
if ((( sig_tor_winter >= 1.0) || (rm_scp >= 4.0) || (sig_tor >= 1.0)) && (mucn >= -50.0)) {
*dcp = 8;
*wwtype = 2;
ww_choice = 2;
/*printf("\n dcp (in SVR) = %d", *dcp);*/
set_font(6);
setcolor(6);
outgtext( "SVR", tlx + 60, tly + 60 );
}
else
if ((rm_scp >= 2.0) && ((sighail >= 1.0) || (dncp >= 750)) && (mucn >= -50.0)) {
*dcp = 9;
*wwtype = 2;
ww_choice = 2;
/*printf("\n dcp (in SVR) = %d", *dcp);*/
set_font(6);
setcolor(6);
outgtext( "SVR", tlx + 60, tly + 60 );
}
else
if ((cbsig >= 30000) && (mmp >= 0.6) && (mucn >= -50.0)) {
*dcp = 10;
*wwtype = 2;
ww_choice = 2;
/*printf("\n dcp (in SVR) = %d", *dcp);*/
set_font(6);
setcolor(6);
outgtext( "SVR", tlx + 60, tly + 60 );
}
else
if ((mucn >= -75.0) && ((wind_dmg >= 0.5) || (sighail >= 0.5) || (rm_scp >= 0.5))) {
*dcp = 11;
*wwtype = 1;
ww_choice = 1;
/*printf("\n dcp (in mrgl SVR) = %d", *dcp);*/
set_font(6);
setcolor(26);
outgtext( "MRGL SVR", tlx + 40, tly + 60 );
}
else {
*dcp = 0;
/*printf("\n dcp (after logic checks) = %d", *dcp);*/
*wwtype = 0;
ww_choice = 0;
}
if (*wwtype == 0) {
set_font(6);
setcolor(19);
outgtext( "NONE", tlx + 50, tly + 60 );
}
//printf("sig_tor=%f sig_tor_winter=%f srh1=%f esrh=%f sr46_spd=%f shr8=%f sblcl=%f\n mllcl=%f lr1=%f bot=%f low_mid_rh=%f rm_scp=%f\n mucn=%f dncp=%f sighail=%f cbsig=%f wind_dmg=%f",
// sig_tor,sig_tor_winter,srh1,esrh,sr46_spd,shr8, sblcl, mllcl, lr1, bot, low_mid_rh, rm_scp,mucn, dncp, sighail, cbsig, wind_dmg);
/* define_parcel(oldlplchoice, oldlplpres); */
/* set parcel back to user selection */
if (oldlplchoice == 1)
pres = 0;
else if (oldlplchoice == 2)
pres = 0;
else if (oldlplchoice == 3)
pres = mu_layer;
else if (oldlplchoice == 4)
pres = mml_layer;
else if (oldlplchoice == 5)
pres = user_level;
else if (oldlplchoice == 6)
pres = mu_layer;
define_parcel(oldlplchoice, pres);
return ww_choice;
}
/*NP*/
void plot_advectionprofile(void)
/*************************************************************/
/* PLOT_ADVECTIONPROFILE */
/* John Hart SPC Norman */
/* */
/* Plots vertical profile of Wind Speeds */
/*************************************************************/
{
float bothgt, tophgt, h, wsp, advt, ix1, z;
short x1, y1, x2, y2, x3, i, tlx, tly, wid, hgt;
short pIndex, zIndex, wsIndex, wdIndex;
char st[10];
pIndex = getParmIndex("PRES");
zIndex = getParmIndex("HGHT");
wsIndex = getParmIndex("SPED");
if (!sndg || pIndex == -1 || zIndex == -1 || wsIndex == -1) return;
tlx = skv.brx + 93;
tly = skv.tly;
wid = 67;
hgt = skv.bry - skv.tly;
setcliprgn(tlx, tly, tlx+wid, tly+hgt+15);
setcolor(0);
setlinestyle( 1, 1 );
rectangle(1,tlx, tly, tlx+wid, tly+hgt);
setcolor(1);
rectangle(0, tlx, tly, tlx+wid, tly+hgt);
/* Draw centerline */
setlinestyle( 2, 1 );
moveto( tlx + (wid/2), tly); lineto(tlx + (wid/2), tly + hgt);
set_font(4);
setlinestyle( 1, 1 );
for (h=sndg[sfc()][pIndex]; h>=200; h-=100) {
advt = advection_layer(&ix1, h, h - 100);
/* Draw tick marks
x1 = tlx + (wid/2) + 5;
x2 = tlx + (wid/2) - 5;
y2 = pres_to_pix(h);
y1 = pres_to_pix(h - 100);
setcolor(1);
moveto( x1, y1); lineto(x2, y1);
moveto( x1, y2); lineto(x2, y2);
*/
x1 = tlx + (wid/2);
x2 = tlx + (wid/2) + (advt*2.5);
y2 = pres_to_pix(h);
y1 = pres_to_pix(h - 100);
setcolor(1);
moveto( x1, y1); lineto(x2, y1);
moveto( x1, y2); lineto(x2, y2);
setcolor(26);
if (advt > 0) setcolor(13);
sprintf( st, "%.1f", advt);
if(advt > 0) rectangle(0, x1, y1, x2, y2); else rectangle(0, x2, y1, x1, y2);
if (advt > 0) {
x3 = x2 + 3;
if (advt > 2) x3 = x1 + 3;
}
else {
x3 = x2 - getgtextextent(st);
if (advt < -2) x3 = x1 - getgtextextent(st);
}
if (advt > -999) outgtext( st, x3, ((y1+y2)/2)-4);
}
/* ----- Plot Label ----- */
setcolor(1);
set_font(5);
outgtext("Inferred", tlx+5, tly+3);
outgtext("Temp Advection", tlx+5, tly+13);
outgtext("(C / hr)", tlx+5, tly+23);
setcliprgn(1, 1, xwdth, xhght);
copytodisplay();
}
void testStlDriver()
{
const int numPatches = 200000; // 200000
const int patchWidth = 9;
const int numFeatures = 50;
const double lambda = 0.0005f;
const double epsilon = 1e-2;
Config config;
config.setValue("addBiasTerm", false);
config.setValue("meanStddNormalize", false);
config.setValue("configurePolicyTesting", false);
config.setValue("trainingMeanAndStdd", false);
updateMNISTConfig(config);
if (false)
{
MNISTSamplePatchesUnlabeledDataFunction mnistUnlabeled(numPatches, patchWidth);
SoftICACostFunction sfc(numFeatures, lambda, epsilon);
LIBLBFGSOptimizer lbfgs(200); // 1000
Driver drv1(&config, &mnistUnlabeled, &sfc, &lbfgs);
const Vector_t optThetaRica = drv1.drive();
Matrix_t Wrica(
Eigen::Map<const Matrix_t>(optThetaRica.data(), numFeatures, pow(patchWidth, 2)));
std::ofstream ofs_wrica("../W2.txt");
ofs_wrica << Wrica << std::endl;
}
Matrix_t Wrica;
// debug: read off the values
std::ifstream in("/home/sam/School/online/stanford_dl_ex/W2.txt");
if (in.is_open())
{
std::string str;
int nbRows = 0;
while (std::getline(in, str))
{
if (str.size() == 0)
continue;
std::istringstream iss(str);
std::vector<double> tokens //
{ std::istream_iterator<double> { iss }, std::istream_iterator<double> { } };
Wrica.conservativeResize(nbRows + 1, tokens.size());
for (size_t i = 0; i < tokens.size(); ++i)
Wrica(nbRows, i) = tokens[i];
++nbRows;
}
}
else
{
std::cerr << "file W.txt failed" << std::endl;
exit(EXIT_FAILURE);
}
const int imageDim = 28;
Eigen::Vector2i imageConfig;
imageConfig << imageDim, imageDim;
const int numFilters = numFeatures;
const int poolDim = 5;
const int filterDim = patchWidth;
const int convDim = (imageDim - filterDim + 1);
assert(convDim % poolDim == 0);
const int outputDim = (convDim / poolDim);
StlFilterFunction stlFilterFunction(filterDim, Wrica);
SigmoidFunction sigmoidFunction;
ConvolutionFunction convolutionFunction(&stlFilterFunction, &sigmoidFunction);
MeanPoolFunction meanPoolFunction(numFilters, outputDim);
MNISTSamplePatchesLabeledDataFunction mnistLabeled(&convolutionFunction, &meanPoolFunction,
imageConfig, numFilters, poolDim, outputDim);
SoftmaxCostFunction mnistcf(0.01f);
LIBLBFGSOptimizer lbfgs2(300);
config.setValue("configurePolicyTesting", false);
config.setValue("trainingMeanAndStdd", true);
config.setValue("meanStddNormalize", true);
config.setValue("addBiasTerm", true);
config.setValue("numGrd", true);
config.setValue("training_accuracy", true);
config.setValue("testing_accuracy", true);
//config.setValue("addBiasTerm", false);
Driver drv2(&config, &mnistLabeled, &mnistcf, &lbfgs2);
drv2.drive();
}
