SIDA_generator_script/generater.py

"""
This script generates input files for ALPACA simulations of LIDE by varying key parameters using a Sobol sequence for sampling.
Change the parameters in the 'param_bounds' array to modify the ranges for high pressure, low pressure, laser width, and droplet radii.
First creates a set of .xml input files using "create_alpaca_input" function, then runs ALPACA on each generated input file using "run_alpaca" function.
For this change the number of simualtions and paths at the end of the script.
Keep the default.xml file in the same directory as this script as the code overwrites it to create new input files.


This problem setup is based on Weber number, We=(rho_g_2 * u_g_2^2 * D0 / sigma) and 
Shock Mach number, Ma_s = u_s / c1
By having these two at hand 
1. we use Ma_s to calculate all the conditions on post-shock region 
using normal shock relations; the results will be initial condition for air in post-shock part.
2. we use We to calculate corresponding sigma, surface tension coefficient. 

"""

import os
import subprocess
import logging
import time
import math
import html
import re
from scipy.stats.qmc import Sobol, scale
from scipy.stats import qmc
import xmltodict
import numpy as np
import warnings




def run_alpaca(
        xml_file,
        output_dir: str = None,
        mpiexec_path: str = None,
        exec_file_path: str = None,
        num_workers: int = 10,
):
    """
    Runs ALPACA with different parameters in .xml file. 

    Args:
        xml_file (str): Path to the input .xml file to be processed.
        mpiexec_path (str): Path to the mpiexec executable. Find using command "which mpiexec" in terminal.
        exec_file_path (str): Path to the ALPACA executable file. Default is "./build/ALPACA".
        num_workers (int): Number of cpu workers for parallel processing.
        output_dir (str): Directory where output files will be saved. 
    """

     # Setup logging
    logging.basicConfig(
    filename=os.path.join(str(output_dir), 'data_generator.log'),
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s'
    )

    # Check for executable ALAPACA location in command
    command = [str(mpiexec_path), "-n", str(num_workers), str(exec_file_path), str(xml_file), str(output_dir)]


    logging.info(f"Starting: {' '.join(command)}")
    start_time = time.time()
    result = subprocess.run(command, capture_output=True, text=True)
    end_time = time.time()

    elapsed = end_time - start_time
    length = math.ceil(elapsed / 60)


    if result.returncode == 0:
        logging.info(f"Completed {xml_file} successfully in {length:.2f} minutes; [{elapsed:.2f} seconds.]")
        logging.debug(f"Output:\n{result.stdout}")
    else:
        logging.error(f"ALPACA failed on {xml_file} with return code {result.returncode}")
        logging.error(f"stderr:\n{result.stderr}")

def round_sig(x, sig=4):
    return float(f"{x:.{sig}g}")

def create_alpaca_input(
        count: int,
        base_path: str ,
        output_path: str 
):
    
    """
    Generates a set of ALPACA input files with varying parameters for high pressure, low pressure, laser width, and the two radii of the droplet.

    Args:
        count (int): Number of samples to generate.
        base_path (str): Path to the base .xml file that will be modified.
        output_path (str): Directory where the generated .xml files will be saved. Create the directory if it does not exist.
    """
    warnings.warn(f"[WARNING] Make sure the default base_input file {base_path} exists and untouched !!!.")

   ### fixed IC ###
    D0 = 2*1e-3 #for now; may change to 10e-6 later
    rho_drop = 1000 # [kg/m^3]
    rho_gas_1 = 1.20 # [kg/m^3]
    gamma = 1.4
    p_gas_1 = 101325 # [Pa]
    p_drop = p_gas_1
    Temp_1 = 300 # [Kelvin]
    c_1 = np.sqrt(gamma * 287 * Temp_1)  # Speed of sound at Tempearture in Region 1 [m/s]

    ### Main params range ###
    param_bounds = np.array([
            [3.5, 5],       # Ma_s
            [500, 4e4],       # We 
        ])

    n_samples = count
    n_dims = param_bounds.shape[0] 
    sampler = qmc.Sobol(d=n_dims, scramble=True, seed=50)
    samples_unit = sampler.random(n=n_samples)
    params = qmc.scale(samples_unit, param_bounds[:, 0], param_bounds[:, 1]) #[N, D] = [count, n_dims]
    params = np.vectorize(round_sig)(params, sig=4) # round them to have only 4 float digits

    Ma_2 = [] # add post-shock flow Mach number

    ### calculations for IC and Write the default input.xml###
    for i in range(n_samples):

        with open(base_path) as f:
            data = xmltodict.parse(f.read())

            # parama[:, 0] = Ma_s
            # parama[:, 1] = We
            # Ref. normal shock relations

            u_s = params[i, 0] * c_1
            u_1_rel = - u_s
            u_gas_1 = u_1_rel + u_s
            Temp_2 = Temp_1 * ( 1 + (2*gamma*(params[i, 0]*params[i, 0]-1)) / (gamma+1) ) * ( (2+(gamma-1)*params[i, 0]*params[i, 0]) / ((gamma+1)*params[i, 0]*params[i, 0]) )
            c_2 = np.sqrt(gamma * 287 * Temp_2)
            Ma_2_rel = np.sqrt( (1+((gamma-1)/2)*params[i, 0]*params[i, 0]) / (gamma*params[i, 0]*params[i, 0]-((gamma-1)/2)) )
            u_2_rel = Ma_2_rel * c_2
            u_gas_2 =  u_s - u_2_rel # >>> needed 
            rho_gas_2 = rho_gas_1 * ((gamma+1)*params[i, 0]*params[i, 0]) / (2+(gamma-1)*params[i, 0]*params[i, 0]) # >>> needed
            p_gas_2 = p_gas_1 * (1 + (2*gamma*(params[i, 0]*params[i, 0]-1))/(gamma+1)) # >>> needed
            Ma_2.append(u_gas_2 / c_2)
            sigma = rho_gas_2 * u_gas_2*u_gas_2 * D0 / params[i, 1] # >>> needed


            # BC
            data["configuration"]["domain"]["boundaryConditions"]["material"]["valuesSouth"]["density"] = rho_gas_2
            data["configuration"]["domain"]["boundaryConditions"]["material"]["valuesSouth"]["pressure"] = p_gas_2
            data["configuration"]["domain"]["boundaryConditions"]["material"]["valuesSouth"]["velocityY"] = u_gas_2

            # IC - Air
            air_0 = data["configuration"]["domain"]["initialConditions"]["material1"]
            air_1 = air_0.replace("density :=1.61;", f"density := {rho_gas_2};")
            air_2 = air_1.replace("pressure :=153338.5;", f"pressure := {p_gas_2};")
            air_3 = air_2.replace("velocityY :=106.07;", f"velocityY := {u_gas_2};")
            data["configuration"]["domain"]["initialConditions"]["material1"] = air_3

            # IC - Water drop is fixed

            # Surface Tension
            data["configuration"]["materialPairings"]["material1_2"]["surfaceTensionCoefficient"] = sigma


            with open(output_path+ f"/Mas{"{:.4f}".format(params[i, 0])}_We{"{:.4f}".format(params[i, 1])}_Maf{"{:.4f}".format(Ma_2[i])}.xml", 'w') as f:
                f.write(xmltodict.unparse(data, pretty=True))

    Ma_2 = np.array(Ma_2).reshape(-1, 1)
    params = np.hstack((params, Ma_2)) #turns into [N, D] = [count, 3]





count = 2 # Number of samples to generate. keep it multiple of 2 for Sobol sequence
inputs_output_path = "."
data_output_path = "."


create_alpaca_input(count=count, 
                    base_path="./default.xml", 
                    output_path=inputs_output_path)


inputs = []
for file in os.listdir(inputs_output_path):
    if file.endswith(".xml"):
        inputs.append(os.path.join(".", file))
        run_alpaca(xml_file=os.path.join(str(inputs_output_path), str(inputs[-1])), 
                   output_dir=str(data_output_path),
                   mpiexec_path="mpiexec",
                   exec_file_path="./build/ALPACA",
                   num_workers=10)