Source local_weather cloud_placement_lowlevel.nas

########################################################
# routines to set up, transform and manage advanced weather
# Thorsten Renk, April 2012
########################################################

# function			purpose
#
# create_undulatus		to create an undulating cloud pattern
# create_cumulus_alleys		to create an alley pattern of Cumulus clouds
# create_layer			to create a cloud layer with optional precipitation

###########################################################
# place an undulatus pattern 
###########################################################

var create_undulatus = func (type, blat, blong, balt, alt_var, nx, xoffset, edgex, x_var, ny, yoffset, edgey, y_var, und_strength, direction, tri) {

var flag = 0;
var path = "Models/Weather/blank.ac";
local_weather.calc_geo(blat);
var dir = direction * math.pi/180.0;

var ymin = -0.5 * ny * yoffset;
var xmin = -0.5 * nx * xoffset;
var xinc = xoffset * (tri-1.0) /ny;
 
var jlow = int(nx*edgex);
var ilow = int(ny*edgey);

var und = 0.0;
var und_array = [];

for (var i=0; i<ny; i=i+1)
	{
	und = und + 2.0 * (rand() -0.5) * und_strength;
	append(und_array,und);
	}

for (var i=0; i<ny; i=i+1)
	{
	var y = ymin + i * yoffset + 2.0 * (rand() -0.5) * 0.2 * yoffset; 
	
	for (var j=0; j<nx; j=j+1)
		{
		var y0 = y + y_var * 2.0 * (rand() -0.5);
		var x = xmin + j * (xoffset + i * xinc) + x_var * 2.0 * (rand() -0.5) + und_array[i];
		var lat = blat + m_to_lat * (y0 * math.cos(dir) - x * math.sin(dir));
		var long = blong + m_to_lon * (x * math.cos(dir) + y0 * math.sin(dir));

		var alt = balt + alt_var * 2 * (rand() - 0.5);
		
		flag = 0;
		var rn = 6.0 * rand();

		if (((j<jlow) or (j>(nx-jlow-1))) and ((i<ilow) or (i>(ny-ilow-1)))) # select a small or no cloud		
			{
			if (rn > 2.0) {flag = 1;} else {path = select_cloud_model(type,"small");}
			}
		if ((j<jlow) or (j>(nx-jlow-1)) or (i<ilow) or (i>(ny-ilow-1))) 	
			{
			if (rn > 5.0) {flag = 1;} else {path = select_cloud_model(type,"small");}
			}
		else	{ # select a large cloud
			if (rn > 5.0) {flag = 1;} else {path = select_cloud_model(type,"large");}
			}


		if (flag==0){
			if (thread_flag == 1)
				{create_cloud_vec(path, lat, long, alt, 0.0);}
			else
				{local_weather.create_cloud(path, lat, long, alt, 0.0);}
			

				}
		}

	} 

}


###########################################################
# place an advanced undulatus pattern 
###########################################################

var create_adv_undulatus = func (arg) {

var markov_array = [];
var rnd_array = [];
var max_num_clouds = int(arg.xsize/arg.cloud_spacing)+1;
var max_num_streaks = int(arg.ysize/arg.undulatus_spacing)+1;
var path = "Models/Weather/blank.ac";
var counter = 0;

append(markov_array,0.0);

var rn = 0.0;
arg.dir = arg.dir + 90.0;

for (var i=1; i<max_num_clouds; i=i+1)
	{
	rn = rand();
	append(markov_array, markov_array[i-1] + 2.0 * (rn -0.5) * arg.undulatus_amplitude + arg.undulatus_slant);
	append(rnd_array, rn);
	}

for (i=0; i< max_num_streaks; i=i+1)
	{
	var streak_ypos = -0.5 * arg.ysize + i * arg.undulatus_spacing;
	var aspect_num_clouds = int((arg.aspect + (1.0-arg.aspect) * i/max_num_streaks) * max_num_clouds);
	
	for (var j = 0; j< aspect_num_clouds; j=j+1)
		{
		var y = streak_ypos + markov_array[j];
		var x = -0.5 * arg.xsize + j * arg.cloud_spacing;
		
		x = x - arg.Dx + 2.0 * rand() * arg.Dx;
		y = y - arg.Dy + 2.0 * rand() * arg.Dy;
		
		var flag = 0;
		var bias =1.0 - (math.abs(i-0.5 * max_num_streaks)/max_num_streaks +  math.abs(j-0.5 * aspect_num_clouds)/aspect_num_clouds);
		var comp = -.25 * rnd_array[j] + 0.75 * bias;
		
		comp = comp + arg.size_bias;
		if (comp > 0.7)
			{
			flag = 1;
			path = select_cloud_model(arg.type,"large")
			}
		else if (comp > 0.4)
			{
			flag = 1;
			path = select_cloud_model(arg.type,"small")
			}
		
		var edge = math.pow(bias, arg.edge_power);
		local_weather.alpha_factor = edge * arg.core_alpha + (1.0-edge) * arg.edge_alpha;
			
		var lat = arg.blat + m_to_lat * (y * math.cos(arg.dir) - x * math.sin(arg.dir));
		var lon = arg.blon + m_to_lon * (x * math.cos(arg.dir) + y * math.sin(arg.dir));

		var alt = arg.balt + arg.alt_var * 2 * (rand() - 0.5);
		
		if (flag > 0)
			{create_cloud_vec(path, lat, lon, alt, 0.0); counter = counter +1;}
		}
	
	}
	#print("Cloud count: ",counter);
	local_weather.alpha_factor = 1.0;
}


###########################################################
# place a stick bundle pattern 
###########################################################

var sgn = func (x) {

if (x<0.0) {return -1.0;}
else {return 1.0;}
}

var create_stick_bundle = func (arg) {

var path = "Models/Weather/blank.ac";
var base_size_scale = local_weather.cloud_size_scale;

for (var i = 0; i<arg.n_sticks; i=i+1)
	{
	var stick_x = 0.5 * math.pow(rand(),2.0) * arg.xsize * sgn(rand()-0.5);
	var stick_y = 0.5 * math.pow(rand(),2.0) * arg.ysize * sgn(rand()-0.5);
		
	var stick_length = arg.stick_length_min + int(rand() * (arg.stick_length_max - arg.stick_length_min) );
	var stick_Dphi = arg.stick_Dphi_min + rand() * (arg.stick_Dphi_max - arg.stick_Dphi_min);
	var stick_size_scale = 0.8 + 0.2 * rand();
	for (var j=0; j<stick_length;j=j+1)
		{
		var y = stick_y;
		var x = stick_x - 0.5 * stick_length * arg.cloud_spacing;
		var inc = j * arg.cloud_spacing;
		var pos_size_scale = base_size_scale +  base_size_scale * 2.0* (1.0 - 2.0* math.abs(0.5 * stick_length - j)/stick_length);
		local_weather.cloud_size_scale = pos_size_scale;
		local_weather.cloud_size_scale = stick_size_scale * local_weather.cloud_size_scale;
		inc = inc *  stick_size_scale;
		
		x = x + inc * math.cos(stick_Dphi);
		y = y + inc * math.sin(stick_Dphi);

		x = x - arg.Dx + 2.0 * rand() * arg.Dx;
		y = y - arg.Dy + 2.0 * rand() * arg.Dy;

		path = select_cloud_model(arg.type,"large");

		var lat = arg.blat + m_to_lat * (y * math.cos(arg.dir) - x * math.sin(arg.dir));
		var lon = arg.blon + m_to_lon * (x * math.cos(arg.dir) + y * math.sin(arg.dir));

		var alt = arg.balt + arg.alt_var * 2 * (rand() - 0.5);

		create_cloud_vec(path, lat, lon, alt, 0.0);
		}
	}

}

###########################################################
# place a nested domains pattern 
###########################################################

var create_domains = func (arg) {

var path = "Models/Weather/blank.ac";

for (var j=0; j<arg.n_domains; j=j+1)
	{
	var domain_pos_x = -0.5 * arg.xsize + rand() * arg.xsize;
	var domain_pos_y = -0.5 * arg.ysize + rand() * arg.ysize;

	var domain_size_x = arg.min_domain_size_x + rand() * (arg.max_domain_size_x - arg.min_domain_size_x);
	var domain_size_y = arg.min_domain_size_y + rand() * (arg.max_domain_size_y - arg.min_domain_size_y);

	var n_node = int(arg.node_fraction * arg.n);
	var n_halo = int(arg.halo_fraction * arg.n);
	var n_bulk = arg.n - n_node - n_halo;
	
	for (var i=0; i<n_halo; i=i+1)
		{
		var x = domain_pos_x - 0.5 * domain_size_x + rand() * domain_size_x;
		var y = domain_pos_y - 0.5 * domain_size_y + rand() * domain_size_y;
		var lat = arg.blat + m_to_lat * (y * math.cos(arg.dir) - x * math.sin(arg.dir));
		var lon = arg.blon + m_to_lon * (x * math.cos(arg.dir) + y * math.sin(arg.dir));
		var alt = arg.balt + arg.alt_var * 2 * (rand() - 0.5);
		local_weather.alpha_factor = arg.halo_alpha - 0.2 + rand() * 0.2;		
		if ((math.abs(x-domain_pos_x) < 0.3 * domain_size_x) or (math.abs(y-domain_pos_y) < 0.3 * domain_size_y))
			{path = select_cloud_model(arg.htype,arg.hsubtype);
			create_cloud_vec(path, lat, lon, alt, 0.0);}

		}
	for (i=0; i<n_bulk; i=i+1)
		{
		x = domain_pos_x - 0.5 * 0.4* domain_size_x + rand() * 0.4* domain_size_x;
		y = domain_pos_y - 0.5 * 0.4* domain_size_y + rand() * 0.4* domain_size_y;
		lat = arg.blat + m_to_lat * (y * math.cos(arg.dir) - x * math.sin(arg.dir));
		lon = arg.blon + m_to_lon * (x * math.cos(arg.dir) + y * math.sin(arg.dir));
		alt = arg.balt + arg.alt_var * 2 * (rand() - 0.5);
		local_weather.alpha_factor = arg.bulk_alpha - 0.2 + rand() * 0.2;				
		if ((math.abs(x-domain_pos_x) < 0.4 * domain_size_x) or (math.abs(y-domain_pos_y) < 0.4 * domain_size_y))
			{
			path = select_cloud_model(arg.type,arg.subtype);
			create_cloud_vec(path, lat, lon, alt, 0.0);
			}
		}
	for (i=0; i<n_node; i=i+1)
		{
		x = domain_pos_x - 0.5 * 0.1* domain_size_x + rand() * 0.1* domain_size_x;
		y = domain_pos_y - 0.5 * 0.1* domain_size_y + rand() * 0.1* domain_size_y;
		lat = arg.blat + m_to_lat * (y * math.cos(arg.dir) - x * math.sin(arg.dir));
		lon = arg.blon + m_to_lon * (x * math.cos(arg.dir) + y * math.sin(arg.dir));
		alt = arg.balt + arg.alt_var * 2 * (rand() - 0.5);
		local_weather.alpha_factor = arg.node_alpha - 0.2 + rand() * 0.2;				
		path = select_cloud_model(arg.ntype,arg.nsubtype);
		create_cloud_vec(path, lat, lon, alt, 0.0);
		}

	}

	local_weather.alpha_factor = 1.0;

}




###########################################################
# place a Cumulus alley pattern 
###########################################################

var create_cumulus_alleys = func (blat, blon, balt, alt_var, nx, xoffset, edgex, x_var, ny, yoffset, edgey, y_var, und_strength, direction, tri) {

var flag = 0;
var path = "Models/Weather/blank.ac";
local_weather.calc_geo(blat);
var dir = direction * math.pi/180.0;

var ymin = -0.5 * ny * yoffset;
var xmin = -0.5 * nx * xoffset;
var xinc = xoffset * (tri-1.0) /ny;
 
var jlow = int(nx*edgex);
var ilow = int(ny*edgey);

var und = 0.0;
var und_array = [];

var spacing = 0.0;
var spacing_array = [];


for (var i=0; i<ny; i=i+1)
	{
	und = und + 2.0 * (rand() -0.5) * und_strength;
	append(und_array,und);
	}

for (var i=0; i<nx; i=i+1)
	{
	spacing = spacing + 2.0 * (rand() -0.5) * 0.5 * xoffset;
	append(spacing_array,spacing);
	}


for (var i=0; i<ny; i=i+1)
	{
	var y = ymin + i * yoffset; 
	var xshift = 2.0 * (rand() -0.5) * 0.5 * xoffset; 
	x_var = 0.0; xshift = 0.0;

	for (var j=0; j<nx; j=j+1)
		{
		var y0 = y + y_var * 2.0 * (rand() -0.5);
		var x = xmin + j * (xoffset + i * xinc) + x_var * 2.0 * (rand() -0.5) + spacing_array[j] + und_array[i];
		var lat = blat + m_to_lat * (y0 * math.cos(dir) - x * math.sin(dir));
		var lon = blon + m_to_lon * (x * math.cos(dir) + y0 * math.sin(dir));

		var alt = balt + alt_var * 2 * (rand() - 0.5);
		
		flag = 0;
		var strength = 0.0;
		var rn = 6.0 * rand();

		if (((j<jlow) or (j>(nx-jlow-1))) and ((i<ilow) or (i>(ny-ilow-1)))) # select a small or no cloud		
			{
			if (rn > 2.0) {flag = 1;} else {strength = 0.3 + rand() * 0.5;}
			}
		if ((j<jlow) or (j>(nx-jlow-1)) or (i<ilow) or (i>(ny-ilow-1))) 	
			{
			if (rn > 5.0) {flag = 1;} else {strength = 0.7 + rand() * 0.5;}
			}
		else	{ # select a large cloud
			if (rn > 5.0) {flag = 1;} else {strength = 1.1 + rand() * 0.6;}
			}


		if (flag==0){create_detailed_cumulus_cloud(lat, lon, alt, strength); }
		}

	} 

}



###########################################################
# place a Cumulus alley pattern 
###########################################################

var create_developing_cumulus_alleys = func (blat, blon, balt, alt_var, nx, xoffset, edgex, x_var, ny, yoffset, edgey, y_var, und_strength, direction, tri) {

var flag = 0;
var path = "Models/Weather/blank.ac";
local_weather.calc_geo(blat);
var dir = direction * math.pi/180.0;

var ymin = -0.5 * ny * yoffset;
var xmin = -0.5 * nx * xoffset;
var xinc = xoffset * (tri-1.0) /ny;
 
var jlow = int(nx*edgex);
var ilow = int(ny*edgey);

var und = 0.0;
var und_array = [];

var spacing = 0.0;
var spacing_array = [];


for (var i=0; i<ny; i=i+1)
	{
	und = und + 2.0 * (rand() -0.5) * und_strength;
	append(und_array,und);
	}

for (var i=0; i<nx; i=i+1)
	{
	spacing = spacing + 2.0 * (rand() -0.5) * 0.5 * xoffset;
	append(spacing_array,spacing);
	}


for (var i=0; i<ny; i=i+1)
	{
	var y = ymin + i * yoffset; 
	var xshift = 2.0 * (rand() -0.5) * 0.5 * xoffset; 
	x_var = 0.0; xshift = 0.0;

	for (var j=0; j<nx; j=j+1)
		{
		var y0 = y + y_var * 2.0 * (rand() -0.5);
		var x = xmin + j * (xoffset + i * xinc) + x_var * 2.0 * (rand() -0.5) + spacing_array[j] + und_array[i];
		var lat = blat + m_to_lat * (y0 * math.cos(dir) - x * math.sin(dir));
		var lon = blon + m_to_lon * (x * math.cos(dir) + y0 * math.sin(dir));

		var alt = balt + alt_var * 2 * (rand() - 0.5);
		
		flag = 0;
		var strength = 0.0;
		var rn = 6.0 * rand();

		if (((j<jlow) or (j>(nx-jlow-1))) and ((i<ilow) or (i>(ny-ilow-1)))) # select a small or no cloud		
			{
			if (rn > 2.0) {flag = 1;} else {strength = 0.1 + rand() * 0.5;}
			}
		if ((j<jlow) or (j>(nx-jlow-1)) or (i<ilow) or (i>(ny-ilow-1))) 	
			{
			if (rn > 5.0) {flag = 1;} else {strength = 0.4 + rand() * 0.5;}
			}
		else	{ # select a large cloud
			if (rn > 5.0) {flag = 1;} else {strength = 0.6 + rand() * 0.6;}
			}


		if (flag==0){create_detailed_cumulus_cloud(lat, lon, alt, strength); }
		}

	} 

}


###########################################################
# place a cloud layer 
###########################################################

var create_layer = func (type, blat, blon, balt, bthick, rx, ry, phi, density, edge, rainflag, rain_density) {


var i = 0;
var area = math.pi * rx * ry;
var circ = math.pi * (rx + ry); # that's just an approximation
var n = int(area/80000000.0 * 100 * density);
var m = int(circ/63000.0 * 40 * rain_density);
var path = "Models/Weather/blank.ac";

#print("density: ",n);

phi = phi * math.pi/180.0;

if (contains(local_weather.cloud_vertical_size_map, type)) 
		{var alt_offset = cloud_vertical_size_map[type]/2.0 * m_to_ft;}
	else {var alt_offset = 0.0;}

while(i<n)
	{
	var x = rx * (2.0 * rand() - 1.0); 
	var y = ry * (2.0 * rand() - 1.0); 
	var alt = balt + bthick * rand() + 0.8 * alt_offset;
	var res = (x*x)/(rx*rx) + (y*y)/(ry*ry);

	if (res < 1.0)
		{
		var lat = blat + m_to_lat * (y * math.cos(phi) - x * math.sin(phi));
		var lon = blon + m_to_lon * (x * math.cos(phi) + y * math.sin(phi));
		if (res > ((1.0 - edge) * (1.0- edge)))
			{
			if (rand() > 0.4) {
				path = select_cloud_model(type,"small");
			if (thread_flag == 1)
				{create_cloud_vec(path, lat, lon, alt, 0.0);}
			else
				{compat_layer.create_cloud(path, lat, lon, alt, 0.0);}
				}
			}
		else {
			path = select_cloud_model(type,"large");
			if (thread_flag == 1)
				{create_cloud_vec(path, lat, lon, alt, 0.0);}
			else 
				{compat_layer.create_cloud(path, lat, lon, alt, 0.0);}
			}
		i = i + 1;
		}
	}

i = 0;

if (rainflag ==1){

if (local_weather.hardcoded_clouds_flag == 1) {balt = balt + local_weather.offset_map[type]; }

	while(i<m)
		{
		var alpha = rand() * 2.0 * math.pi;
		x = 0.8 * (1.0 - edge) * (1.0-edge) * rx * math.cos(alpha);
		y = 0.8 * (1.0 - edge) * (1.0-edge) * ry * math.sin(alpha);

		lat = blat + m_to_lat * (y * math.cos(phi) - x * math.sin(phi));
		lon = blon + m_to_lon * (x * math.cos(phi) + y * math.sin(phi));	
	
		path = "Models/Weather/rain1.xml";
 		if (contains(cloud_vertical_size_map,type)) {var alt_shift = cloud_vertical_size_map[type];}
		else {var alt_shift = 0.0;}
		
		if (thread_flag == 1)
		{create_cloud_vec(path, lat, lon,balt +0.5*bthick+ alt_shift, 0.0);}		
		else		
		{compat_layer.create_cloud(path, lat, lon, balt + 0.5 * bthick + alt_shift, 0.0);}
		i = i + 1;
		} # end while	
	} # end if (rainflag ==1)
}


###########################################################
# place a Cumulus layer with excluded regions
# to avoid placing cumulus underneath a thunderstorm
###########################################################

var cumulus_exclusion_layer = func (blat, blon, balt, n, size_x, size_y, alpha, s_min, s_max, n_ex, exlat, exlon, exrad) {


var strength = 0;
var flag = 1;
var phi = alpha * math.pi/180.0;

var i_max = int(0.35*n);



for (var i =0; i< i_max; i=i+1)
	{
	var x = (2.0 * rand() - 1.0) * size_x;
	var y = (2.0 * rand() - 1.0) * size_y; 

	var lat = blat + (y * math.cos(phi) - x * math.sin(phi)) * m_to_lat;
	var lon = blon + (x * math.cos(phi) + y * math.sin(phi)) * m_to_lon;

	flag = 1;

	for (var j=0; j<n_ex; j=j+1)
		{
		if (calc_d_sq(lat, lon, exlat[j], exlon[j]) < (exrad[j] * exrad[j])) {flag = 0;}
		}
	if (flag == 1)
		{
		strength = s_min + rand() * (s_max - s_min);		
		create_detailed_cumulus_cloud(lat, lon, balt, strength);
		} 

	} # end for i

}