| 1 |
+ |
#include "color.h" |
| 2 |
|
#ifndef lint |
| 3 |
< |
static const char RCSid[] = "$Id$"; |
| 3 |
> |
static const char RCSid[] = |
| 4 |
> |
"$Id$"; |
| 5 |
|
#endif |
| 6 |
|
/* Main function for generating spectral sky */ |
| 7 |
|
/* Cloudy sky computed as weight average of clear and cie overcast sky */ |
| 8 |
|
|
| 7 |
– |
#include "atmos.h" |
| 9 |
|
#include "copyright.h" |
| 10 |
+ |
#include "paths.h" |
| 11 |
+ |
#include "atmos.h" |
| 12 |
|
#include "resolu.h" |
| 13 |
|
#include "rtio.h" |
| 14 |
|
#include <ctype.h> |
| 20 |
|
#include <sys/types.h> |
| 21 |
|
#endif |
| 22 |
|
|
| 20 |
– |
char *progname; |
| 21 |
– |
|
| 23 |
|
const double ARCTIC_LAT = 67.; |
| 24 |
|
const double TROPIC_LAT = 23.; |
| 25 |
|
const int SUMMER_START = 4; |
| 161 |
|
return (a * x + b * y) / (a + b); |
| 162 |
|
} |
| 163 |
|
|
| 164 |
< |
static double get_zenith_brightness(const double sundir[3]) { |
| 164 |
> |
static double get_overcast_zenith_brightness(const double sundir[3]) { |
| 165 |
|
double zenithbr; |
| 166 |
|
if (sundir[2] < 0) { |
| 167 |
|
zenithbr = 0; |
| 180 |
|
|
| 181 |
|
static void write_header(const int argc, char **argv, const double cloud_cover, |
| 182 |
|
const double grefl, const int res) { |
| 183 |
+ |
int i; |
| 184 |
|
printf("# "); |
| 185 |
< |
for (int i = 0; i < argc; i++) { |
| 185 |
> |
for (i = 0; i < argc; i++) { |
| 186 |
|
printf("%s ", argv[i]); |
| 187 |
|
} |
| 188 |
|
printf("\n"); |
| 191 |
|
cloud_cover, grefl, res); |
| 192 |
|
} |
| 193 |
|
|
| 194 |
< |
static void write_rad(const double *sun_radiance, const FVECT sundir, |
| 195 |
< |
const char *ddir, const char *skyfile) { |
| 194 |
> |
static void write_rad(const double *sun_radiance, const double intensity, |
| 195 |
> |
const FVECT sundir, const char *ddir, |
| 196 |
> |
const char *skyfile) { |
| 197 |
|
if (sundir[2] > 0) { |
| 198 |
|
printf("void spectrum sunrad\n0\n0\n22 380 780 "); |
| 199 |
< |
/* Normalize to one */ |
| 200 |
< |
double sum = 0.0; |
| 201 |
< |
for (int i = 0; i < NSSAMP; ++i) { |
| 199 |
< |
sum += sun_radiance[i]; |
| 199 |
> |
int i; |
| 200 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 201 |
> |
printf("%.3f ", sun_radiance[i]); |
| 202 |
|
} |
| 201 |
– |
double mean = sum / NSSAMP; |
| 202 |
– |
for (int i = 0; i < NSSAMP; ++i) { |
| 203 |
– |
printf("%.3f ", sun_radiance[i] / mean); |
| 204 |
– |
} |
| 205 |
– |
double intensity = mean * WVLSPAN; |
| 203 |
|
printf("\n\nsunrad light solar\n0\n0\n3 %.1f %.1f %.1f\n\n", intensity, |
| 204 |
|
intensity, intensity); |
| 205 |
|
printf("solar source sun\n0\n0\n4 %f %f %f 0.533\n\n", sundir[0], sundir[1], |
| 206 |
|
sundir[2]); |
| 207 |
|
} |
| 208 |
< |
printf("void specpict skyfunc\n5 noop %s . 'atan2(Dy,Dx)/PI+1' " |
| 209 |
< |
"'acos(Dz)/PI'\n0\n0\n\n", |
| 208 |
> |
printf("void specpict skyfunc\n5 noop %s . 'Atan2(Dy,Dx)/PI+1' " |
| 209 |
> |
"'1-Acos(Dz)/PI'\n0\n0\n\n", |
| 210 |
|
skyfile); |
| 211 |
|
} |
| 212 |
|
|
| 226 |
|
DATARRAY *scat1m_clear, DATARRAY *irrad_clear, |
| 227 |
|
const double cloud_cover, const FVECT sundir, |
| 228 |
|
const double grefl, const int res, const char *outname, |
| 229 |
< |
const char *ddir) { |
| 229 |
> |
const char *ddir, const double dirnorm, const double difhor) { |
| 230 |
|
char skyfile[PATH_MAX]; |
| 234 |
– |
char grndfile[PATH_MAX]; |
| 231 |
|
if (!snprintf(skyfile, sizeof(skyfile), "%s%c%s_sky.hsr", ddir, DIRSEP, |
| 232 |
|
outname)) { |
| 233 |
|
fprintf(stderr, "Error setting sky file name\n"); |
| 244 |
|
FVECT view_point = {0, 0, ER + 10}; |
| 245 |
|
const double radius = VLEN(view_point); |
| 246 |
|
const double sun_ct = fdot(view_point, sundir) / radius; |
| 247 |
< |
for (int j = 0; j < yres; ++j) { |
| 248 |
< |
for (int i = 0; i < xres; ++i) { |
| 247 |
> |
|
| 248 |
> |
double overcast_zenithbr = get_overcast_zenith_brightness(sundir); |
| 249 |
> |
double overcast_grndbr = overcast_zenithbr * GNORM; |
| 250 |
> |
|
| 251 |
> |
double dif_ratio = 1; |
| 252 |
> |
if (difhor > 0) { |
| 253 |
> |
DATARRAY *indirect_irradiance_clear = get_indirect_irradiance(irrad_clear, radius, sun_ct); |
| 254 |
> |
double overcast_ghi = overcast_zenithbr * 7.0 * PI / 9.0; |
| 255 |
> |
double diffuse_irradiance = 0; |
| 256 |
> |
int l; |
| 257 |
> |
for (l = 0; l < NSSAMP; ++l) { |
| 258 |
> |
diffuse_irradiance += indirect_irradiance_clear->arr.d[l] * 20; /* 20nm interval */ |
| 259 |
> |
} |
| 260 |
> |
free(indirect_irradiance_clear); |
| 261 |
> |
diffuse_irradiance = wmean2(diffuse_irradiance, overcast_ghi, cloud_cover); |
| 262 |
> |
if (diffuse_irradiance > 0) { |
| 263 |
> |
dif_ratio = difhor / WHTEFFICACY / diffuse_irradiance / 1.15; /* fudge */ |
| 264 |
> |
} |
| 265 |
> |
} |
| 266 |
> |
int i, j, k; |
| 267 |
> |
for (j = 0; j < yres; ++j) { |
| 268 |
> |
for (i = 0; i < xres; ++i) { |
| 269 |
|
SCOLOR radiance = {0}; |
| 270 |
|
SCOLR sky_sclr = {0}; |
| 271 |
|
|
| 290 |
|
radiance); |
| 291 |
|
} |
| 292 |
|
|
| 293 |
< |
for (int k = 0; k < NSSAMP; ++k) { |
| 293 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 294 |
|
radiance[k] *= WVLSPAN; |
| 295 |
|
} |
| 296 |
|
|
| 297 |
|
if (cloud_cover > 0) { |
| 298 |
< |
double zenithbr = get_zenith_brightness(sundir); |
| 283 |
< |
double grndbr = zenithbr * GNORM; |
| 284 |
< |
double skybr = get_overcast_brightness(rdir[2], zenithbr); |
| 298 |
> |
double skybr = get_overcast_brightness(rdir[2], overcast_zenithbr); |
| 299 |
|
if (rdir[2] < 0) { |
| 300 |
< |
for (int k = 0; k < NSSAMP; ++k) { |
| 301 |
< |
radiance[k] = wmean2(radiance[k], grndbr * D6415[k], cloud_cover); |
| 300 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 301 |
> |
radiance[k] = wmean2(radiance[k], overcast_grndbr * D6415[k], cloud_cover); |
| 302 |
|
} |
| 303 |
|
} else { |
| 304 |
< |
for (int k = 0; k < NSSAMP; ++k) { |
| 304 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 305 |
|
radiance[k] = wmean2(radiance[k], skybr * D6415[k], cloud_cover); |
| 306 |
|
} |
| 307 |
|
} |
| 308 |
|
} |
| 309 |
|
|
| 310 |
< |
scolor2scolr(sky_sclr, radiance, 20); |
| 310 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 311 |
> |
radiance[k] *= dif_ratio; |
| 312 |
> |
} |
| 313 |
> |
|
| 314 |
> |
scolor2scolr(sky_sclr, radiance, NSSAMP); |
| 315 |
|
putbinary(sky_sclr, LSCOLR, 1, skyfp); |
| 316 |
|
} |
| 317 |
|
} |
| 322 |
|
get_solar_radiance(tau_clear, scat_clear, scat1m_clear, sundir, radius, |
| 323 |
|
sun_ct, sun_radiance); |
| 324 |
|
if (cloud_cover > 0) { |
| 325 |
< |
double zenithbr = get_zenith_brightness(sundir); |
| 326 |
< |
double skybr = get_overcast_brightness(sundir[2], zenithbr); |
| 327 |
< |
for (int i = 0; i < NSSAMP; ++i) { |
| 325 |
> |
double skybr = get_overcast_brightness(sundir[2], overcast_zenithbr); |
| 326 |
> |
int i; |
| 327 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 328 |
|
sun_radiance[i] = |
| 329 |
|
wmean2(sun_radiance[i], D6415[i] * skybr / WVLSPAN, cloud_cover); |
| 330 |
|
} |
| 331 |
|
} |
| 332 |
|
|
| 333 |
< |
write_rad(sun_radiance, sundir, ddir, skyfile); |
| 333 |
> |
/* Normalize */ |
| 334 |
> |
double sum = 0.0; |
| 335 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 336 |
> |
sum += sun_radiance[i]; |
| 337 |
> |
} |
| 338 |
> |
double mean = sum / NSSAMP; |
| 339 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 340 |
> |
sun_radiance[i] /= mean; |
| 341 |
> |
} |
| 342 |
> |
double intensity = mean * WVLSPAN; |
| 343 |
> |
if (dirnorm > 0) { |
| 344 |
> |
intensity = dirnorm / SOLOMG / WHTEFFICACY; |
| 345 |
> |
} |
| 346 |
> |
|
| 347 |
> |
write_rad(sun_radiance, intensity, sundir, ddir, skyfile); |
| 348 |
|
return 1; |
| 349 |
|
} |
| 350 |
|
|
| 428 |
|
} |
| 429 |
|
|
| 430 |
|
int main(int argc, char *argv[]) { |
| 399 |
– |
progname = argv[0]; |
| 431 |
|
int month, day; |
| 432 |
|
double hour; |
| 433 |
|
FVECT sundir; |
| 445 |
|
char mie_name[20] = "mie_ca"; |
| 446 |
|
char lstag[3]; |
| 447 |
|
char *ddir = "."; |
| 448 |
+ |
int i; |
| 449 |
+ |
double dirnorm = 0; /* direct normal illuminance */ |
| 450 |
+ |
double difhor = 0; /* diffuse horizontal illuminance */ |
| 451 |
|
|
| 452 |
+ |
fixargv0(argv[0]); |
| 453 |
|
if (argc == 2 && !strcmp(argv[1], "-defaults")) { |
| 454 |
|
printf("-i %d\t\t\t\t#scattering order\n", sorder); |
| 455 |
|
printf("-g %f\t\t\t#ground reflectance\n", grefl); |
| 464 |
|
if (argc < 4) { |
| 465 |
|
fprintf(stderr, |
| 466 |
|
"Usage: %s month day hour -y year -a lat -o lon -m tz -d aod -r " |
| 467 |
< |
"res -n nproc -c ccover -l mie -g grefl -f outpath\n", |
| 467 |
> |
"res -n nproc -c ccover -l mie -L dirnorm_illum difhor_illum " |
| 468 |
> |
"-g grefl -f outpath\n", |
| 469 |
|
argv[0]); |
| 470 |
|
return 0; |
| 471 |
|
} |
| 487 |
|
exit(1); |
| 488 |
|
} |
| 489 |
|
|
| 490 |
< |
for (int i = 4; i < argc; i++) { |
| 490 |
> |
for (i = 4; i < argc; i++) { |
| 491 |
|
if (argv[i][0] == '-') { |
| 492 |
|
switch (argv[i][1]) { |
| 493 |
|
case 'a': |
| 525 |
|
case 'o': |
| 526 |
|
s_longitude = atof(argv[++i]) * (PI / 180.0); |
| 527 |
|
break; |
| 528 |
+ |
case 'L': |
| 529 |
+ |
dirnorm = atof(argv[++i]); |
| 530 |
+ |
difhor = atof(argv[++i]); |
| 531 |
+ |
break; |
| 532 |
|
case 'p': |
| 533 |
|
ddir = argv[++i]; |
| 534 |
|
break; |
| 598 |
|
write_header(argc, argv, ccover, grefl, res); |
| 599 |
|
|
| 600 |
|
if (!gen_spect_sky(tau_clear_dp, scat_clear_dp, scat1m_clear_dp, |
| 601 |
< |
irrad_clear_dp, ccover, sundir, grefl, res, outname, |
| 602 |
< |
ddir)) { |
| 601 |
> |
irrad_clear_dp, ccover, sundir, grefl, res, outname, ddir, |
| 602 |
> |
dirnorm, difhor)) { |
| 603 |
|
fprintf(stderr, "gen_spect_sky failed\n"); |
| 604 |
|
exit(1); |
| 605 |
|
} |
