How to use remote machines to analyze?

[liangyiqiu]

From the desktop ui i can use a remote machine to analyze. However, from pyaedt the computation is always performed on the localhost.

I tried the "machine" parameter of the function "hfss.analyze", but it doesn't work. I also tried "acf_file", but the simulation won't start due to errors.

And any edit in the desktop ui makes no sense. It seems that pyaedt will always create a new setup in HPC options, and only "localhost" is enabled.

[Samuelopez-ansys]

Hi @liangyiqiu ,

If you want to analyze the design using remote machines not in batch, you just need only the .ACF file, please try that the ACF file is working when you import it manually.

The other option is launching in batch, which will close the project, in this case, you need to pass the machine name too. Please check the API reference:

https://aedt.docs.pyansys.com/version/0.9/API/_autosummary/pyaedt.icepak.Icepak.analyze.html#analyze

And also the code, because then you will see what parameters you are not passing correctly:

https://github.com/ansys/pyaedt/blob/main/pyaedt/application/Analysis.py#L1560

[JonathonMcMullan]

I have a similar issue with PyAEDT 0.9.7. Neither the "machine" nor the "gpus" keys change the settings, only the "cores" key changes. If I switch to an ACF file, exported from the GUI, it correctly loads the ACF configuration but doesn't correctly solve (it gives the same print output "PyAEDT INFO: Design setup 'pyaedt_config' solved correctly in 0.0h 0.0m 0.0s" with nothing in the profile). I observed similar behaviour in PyAEDT 0.9.1 prior to upgrading to 0.9.7. Is there a workaround for this?

# Original Config:
setupMultiAdapt.analyze(cores=12,
             gpus=0,
             machine="Honshu",
             use_auto_settings=True,
             revert_to_initial_mesh=True)

# ACF Config:
setupMultiAdapt.analyze(acf_file=hpcACFPath)

[Samuelopez-ansys]

This issue is going to be investigated thanks

[JonathonMcMullan]

Thanks. As a workaround, executing it with an ACF file in the older fashion still works:

``
Function to take in machine HPC configuration and create an ACF file for use with the pre-PyAEDT execution commands
acfFilePath = Path to write the ACF file to
designType = Design type for the HPC configuration (e.g. "HFSS")
machineList = [[machineName, coreNumber, gpuNumber, ramPercentage, isEnabled]]
autoSolveEnabled = Use AutoHPC or not (e.g "true")
numVariations = Number of parametric variations to solve (e.g. "1")

def acfWriter(acfFilePath, designType, machineList, autoSolveEnabled, numVariations):
# Open new text file writer
f = open(acfFilePath, "w")

# Write initial headers
f.writelines("$begin 'Configs'\n")
f.writelines("\t$begin 'Configs'\n")
f.writelines("\t\t$begin 'DSOonfigs'\n")
f.writelines("\t\t\tConfigName='pyaedt_ACF'\n")
f.writelines("\t\t\tDesignType='" + designType + "'\n")
f.writelines("\t\t\t$begin 'DSOMachineList'\n")

# Write configuration for machines in the list
for machine in machineList:
    f.writelines("\t\t\t\t$begin 'DSOMachineInfo'\n")
    f.writelines("\t\t\t\t\tMachineName='" + machine[0] + "'\n")
    f.writelines("\t\t\t\t\tNumEngines=" + "1" + "\n")
    f.writelines("\t\t\t\t\tNumCores=" + machine[1] + "\n")
    f.writelines("\t\t\t\t\tIsEnabled=" + machine[4] + "\n")
    f.writelines("\t\t\t\t\tRAMPercent=" + machine[3] + "\n")
    f.writelines("\t\t\t\t\tNumJobCores=" + "0" + "\n")
    f.writelines("\t\t\t\t\tNumGPUs=" + machine[2] + "\n")
    f.writelines("\t\t\t\t$end 'DSOMachineInfo'\n")

f.writelines("\t\t\t$end 'DSOMachineList'\n")
f.writelines("\t\t\tUseAutoSettings=" + autoSolveEnabled + "\n")
f.writelines("\t\t\tNumVariationsToDistribute=" + numVariations + "\n")

f.writelines("\t\t\t$begin 'DSOJobDistributionInfo'\n")
f.writelines("\t\t\t\tAllowedDistributionTypes[0:]\n")
f.writelines("\t\t\t\tEnable2LevelDistribution=false\n")
f.writelines("\t\t\t\tNumL1Engines=0\n")
f.writelines("\t\t\t\tUseDefaultsForDistributionTypes=false\n")
f.writelines("\t\t\t\tContext()\n")
f.writelines("\t\t\t$end 'DSOJobDistributionInfo'\n")

f.writelines("\t\t\t$begin 'DSOMachineOptionsInfo'\n")
f.writelines("\t\t\t\tMenuValues()\n")
f.writelines("\t\t\t\tIntValues()\n")
f.writelines("\t\t\t\tBoolValues(AllowOffCore=true)\n")
f.writelines("\t\t\t\tDoubleValues()\n")
f.writelines("\t\t\t$end 'DSOMachineOptionsInfo'\n")

# Write ending headers
f.writelines("\t\t$end 'DSOConfig'\n")
f.writelines("\t$end 'Configs'\n")
f.writelines("$end 'Configs'\n")

print(a.SetRegistryFromFile(os.path.join(projectDir,"test.acf")))
print(a.SetRegistryString('Desktop/ActiveDSOConfigurations/HFSS', 'pyaedt_ACF'))
print(a.GetRegistryString('Desktop/ActiveDSOConfigurations/HFSS'))
b.Analyze("MultiAdaptive")
`

[mchoi327]

@Samuelopez-ansys
Hi, is this issue resolved?

I’m experiencing a similar problem.

I'm currently accessing a cluster node named ABCDE. The default HPC configuration is shown in the attached image.

What I want to set up is an HPC configuration with 24 tasks, 24 cores, and 0 GPUs, compatible with all three AllowedDistributionTypes for Icepak. However, configuring this through ipk.analyze hasn’t been successful, which led me to this discussion.

Following the information here, I tried to extract the machine name, create an ACF, and configure HPC from that, but unlike on my personal laptop where using 'localhost' or identifying the laptop’s name works, registering the machine name for ABCDEF still doesn’t succeed.

It seems like the configuration name "Interactive Scheduler Job" might require a different approach, as I can’t even create the configuration I named pyaedt_ACF.

Is there a way to automate this HPC setup? Or could you help identify what I might be doing wrong?

It would be great if you can provide me the solution at your earliest convenience.

"""

import os
import socket

# def create_acf_file(acf_file_path, design_type, machine_list, auto_solve_enabled="false", num_variations="1"):
def create_acf_file(acf_file_path, design_type, machine_list, auto_solve_enabled, num_variations, distribution_list=None):
    """Generate an ACF file for HPC configuration.

    Parameters
    ----------
    acf_file_path : str
        Path to write the ACF file.
    design_type : str
        Design type for the HPC configuration (e.g., "HFSS", "Icepak").
    machine_list : list of list
        List of machine configurations. Each sublist contains:
        [machine_name, num_cores, num_engines, num_gpus, ram_percent, is_enabled, num_job_cores]
    auto_solve_enabled : str, optional
        Use AutoHPC or not (default is "true").
    num_variations : str, optional
        Number of parametric variations to solve (default is "1").
    distribution_list : list, optional
        List of distribution settings, containing:
        [allowed_distribution_types, enable_two_level, num_l1_engines, use_defaults_for_distribution_types].
    """
    # AllowedDistributionTypes
    if distribution_list and len(distribution_list) > 0 and isinstance(distribution_list[0], list):
        allowed_types_count = len(distribution_list[0])
        allowed_distribution_types = f"{allowed_types_count}: " + ", ".join(f"'{item}'" for item in distribution_list[0])
    else:
        allowed_distribution_types = "0:"
        
    with open(acf_file_path, "w") as f:
        # Write the initial ACF headers
        f.writelines("$begin 'Configs'\n")
        f.writelines("\t$begin 'Configs'\n")
        f.writelines("\t\t$begin 'DSOConfig'\n")
        f.writelines("\t\t\tConfigName='pyaedt_ACF'\n")
        f.writelines(f"\t\t\tDesignType='{design_type}'\n")
        f.writelines("\t\t\t$begin 'DSOMachineList'\n")

        # Write machine configurations
        for machine in machine_list:
            f.writelines("\t\t\t\t$begin 'DSOMachineInfo'\n")
            f.writelines(f"\t\t\t\t\tMachineName='{machine[0]}'\n")
            f.writelines(f"\t\t\t\t\tNumCores={machine[1]}\n")
            f.writelines(f"\t\t\t\t\tNumEngines={machine[2]}\n")
            f.writelines(f"\t\t\t\t\tNumGPUs={machine[3]}\n")
            f.writelines(f"\t\t\t\t\tRAMPercent={machine[4]}\n")
            f.writelines(f"\t\t\t\t\tIsEnabled={machine[5]}\n")
            f.writelines(f"\t\t\t\t\tNumJobCores={machine[6]}\n")
            f.writelines("\t\t\t\t$end 'DSOMachineInfo'\n")

        # Close machine list and add additional configuration options
        f.writelines("\t\t\t$end 'DSOMachineList'\n")
        f.writelines(f"\t\t\tUseAutoSettings={auto_solve_enabled}\n")
        f.writelines(f"\t\t\tNumVariationsToDistribute={num_variations}\n")
        
        # Distribution and machine options
        f.writelines("\t\t\t$begin 'DSOJobDistributionInfo'\n")
        f.writelines(f"\t\t\t\tAllowedDistributionTypes[{allowed_distribution_types}]\n")
        f.writelines(f"\t\t\t\tEnable2LevelDistribution={str(distribution_list[1]).lower()}\n")
        f.writelines(f"\t\t\t\tNumL1Engines={distribution_list[2]}\n")
        f.writelines(f"\t\t\t\tUseDefaultsForDistributionTypes={str(distribution_list[3]).lower()}\n")
        f.writelines("\t\t\t\tContext()\n")
        f.writelines("\t\t\t$end 'DSOJobDistributionInfo'\n")

        f.writelines("\t\t\t$begin 'DSOMachineOptionsInfo'\n")
        f.writelines("\t\t\t\tMenuValues()\n")
        f.writelines("\t\t\t\tIntValues()\n")
        f.writelines("\t\t\t\tBoolValues(AllowOffCore=true)\n")
        f.writelines("\t\t\t\tDoubleValues()\n")
        f.writelines("\t\t\t$end 'DSOMachineOptionsInfo'\n")

        # Close ACF configuration sections
        f.writelines("\t\t$end 'DSOConfig'\n")
        f.writelines("\t$end 'Configs'\n")
        f.writelines("$end 'Configs'\n")
    print(f"ACF file created at {acf_file_path}")


# Get the hostname of the machine
machine_name = socket.gethostname()

# Output ACF file path
acf_file_path = os.path.join(os.getcwd(), "hpc_config.acf")

# Machine configuration list [machine_name, num_cores, num_engines, num_gpus, ram_percent, is_enabled, num_job_cores]
machine_list = [
    [machine_name, 24, 24, 0, 90, "true", 0]
]

# Distribution configuration list [allowed_distribution_types, enable_two_level, num_l1_engines, use_defaults_for_distribution_types]
distribution_list = [
    ["Variations", "Mesher", "Solver"],  # Allowed distribution types
    False,                                           # Enable two-level distribution
    1,                                               # Number of L1 engines
    False                                            # Use defaults for distribution types
]

# Create ACF file
create_acf_file(acf_file_path, design_type="Icepak", machine_list=machine_list, auto_solve_enabled="false", num_variations="1", distribution_list=distribution_list)

... Omitted ...

    # Conduct analysis for the last setup in the list
    setup_names = ipk.ooptimetrics.GetSetupNames()

    print(f"Available setups: {setup_names}")
    if setup_names:
        latest_setup_name = setup_names[-1]
        print(f"Initiating analysis for setup: {latest_setup_name}")

        success = ipk.analyze(
            setup=latest_setup_name,
            acf_file=acf_file_path,
            revert_to_initial_mesh=False,
            blocking=True,
            solve_in_batch=False
        )

        if success:
            print(f"Analysis of setup '{latest_setup_name}' completed successfully.")
        else:
            print(f"Analysis of setup '{latest_setup_name}' failed.")

        # Save the project
        ipk.save_project()

"""

[mchoi327]

@Samuelopez-ansys

For your information, all hpc configuration buttons are deactivated (unclickable), unlike a non-hpc environment.