# coding=utf-8
import time

from nom_client.nom_client import NoMClient

nom_client = NoMClient(project_name="MULASSIS example",
                       default_server_id="ext_rest_server", debug_output=False)

mulassis_model = nom_client.get_model('mulassis')

particle='proton'
energies=[20.0, 30.0]
material='aluminium'

dz =0.05    # mm
TotThick=3 # mm
for i,z in enumerate([dz for x in range(int(TotThick // dz))]):
    mulassis_model.new_input_group(
        input_group_name="layers",
        unique_group_name=f"al_{i+1}",
        params={
        "layer_thickness": z,
        "layer_material": f'{material}',
        "thickness_unit": "mm"
        }
    )

run_ids = []

for energy in energies:

    mulassis_model.set_params(geometryType="user-defined",
                              environmentForm="mono",
                              monoenergeticParticleEnergyUnit='MeV',
                              monoenergeticParticleEnergy=energy,
                              monoenergeticParticleFlux=1.0,
                              particleAngularDistribution="planar",
                              particleType=particle,
                              analysisType="tid",
                              fluenceAnalysisBoundaries="all",
                              fluenceAnalysisParticles='proton',
                              TIDAnalysisLayers="all",
                              #fluxMultiplier=1,
                              numberPrimaryParticles=10000
                             )

    print(f"Running with energy {energy}")

    _result = nom_client.run_model(mulassis_model, wait_for_result=False, model_timeout=1, tag=f"energy_{energy}")

    run_ids.append(_result['run_id'])

all_complete = False
# loop over run IDs

while not all_complete:
    for run_id in run_ids:
        poll_result = nom_client.get_model_run_by_id(run_id=run_id, include_data=True)

        all_complete = poll_result.has_completed()
        if poll_result.has_completed():
            print(f"Run with tag {poll_result['run_id']} has completed.")
        else:
            print(f"Run with tag {poll_result['run_id']} has not completed.")

    time.sleep(1)


         

# coding=utf-8
import json
from os import path
from pathlib import Path

from nom_client.nom_client import NoMClient

nom_client = NoMClient("MULASSIS macro example")
nom_client.set_default_server("ext_dev_rest_server")


_here = path.abspath(path.dirname(__file__))

with Path(_here + "/main_macro.g4mac").open() as f:
    macro_str = f.read()

mulassis_model = nom_client.get_model('mulassis')

mulassis_model.set_params(
    macro=json.dumps({"macro": macro_str})
)

results = nom_client.run_model(model=mulassis_model)
print(results)

print(nom_client.get_file_outputs("mulassis"))

results.write_output_files(file_key=None, location=_here)

         

# coding=utf-8

from os import path


from nom_client.nom_client import NoMClient

_here = path.abspath(path.dirname(__file__))

# -------------------------------------------------------------------------------
# Example to show importing trapped proton and solar proton spectra into Mulassis
#
nom_client = NoMClient(project_name="MULASSIS example",
                       default_server_id="local_server", debug_output=False)

missionDurationYears = 4
YearsToSecs = 365.0 * 24.0 * 3600.0  # pedantically...this should be 365.2425 days

sapre_model = nom_client.get_model('sapre')
sapre_model.set_params(orbitType="GEN", missionDuration=missionDurationYears, missionDurationUnits=0)
sapre_result = nom_client.run_model(sapre_model)

print("Running trapped model")
ap8ae8_model = nom_client.get_model('irene')
ap8ae8_model.set_params(mode="mean_percentiles", percentiles=[95], includePlasmaEnergies="false")
ap8ae8_model.set_external_input(external_input_name="trajectory", external_input=sapre_result)
ap8ae8_results = nom_client.run_model(ap8ae8_model)
print(ap8ae8_results)

sapphire_worst_event_fluence_model = nom_client.get_model('sapphire-worst-event-fluence')
sapphire_worst_event_fluence_model.set_params(solarCycleOffsetFlag=1, solarCycleOffset=0)
sapphire_worst_event_fluence_model.set_external_input(external_input_name="trajectory", external_input=sapre_result)
sapphire_worst_event_fluence_results = nom_client.run_model(sapphire_worst_event_fluence_model)
print(sapphire_worst_event_fluence_results)


mulassis_model = nom_client.get_model('mulassis')

mulassis_model.new_input_group(input_group_name="input_spectra", unique_group_name="trapped_spectrum", params={
    "spectrum": ap8ae8_results,
    "resultName": "orbit_averaged_proton_spectrum",
    "toflux": missionDurationYears * YearsToSecs   # convert flux spectrum to fluence
})

mulassis_model.new_input_group(input_group_name="input_spectra", unique_group_name="solar_spectrum", params={
    "spectrum": sapphire_worst_event_fluence_results,
    "resultName": "sep_proton_spectrum",
    "toflux": 1                                    # already a fluence spectrum!
})

mulassis_model.new_input_group(input_group_name="layers", unique_group_name="al_layer", params={
    "layer_thickness": 1.0,
    "layer_material": "aluminium",
    "thickness_unit": "mm"
})

mulassis_model.new_input_group(input_group_name="layers", unique_group_name="ta_layer", params={
    "layer_thickness": 1.0,
    "layer_material": {
        "name": "Tantalum",
        "formula": "Ta",
        "density": 12.3
    },
    "thickness_unit": "mm"
})


mulassis_model.set_params(geometryType="user-defined",
                          particleAngularDistribution="iso",
                          minimumAngle=2,
                          maximumAngle=89,
                          analysisType="fluence",
                          fluenceAnalysisBoundaries="all",
                          TIDAnalysisLayers="all"
                          )

mulassis_result = nom_client.run_model(mulassis_model)
print(mulassis_result)

print(mulassis_result.file_outputs.keys())

mulassis_result.write_output_files(file_key=None, location=_here)