def _create_output_df(phase_advances, model, plane, tot=False):
meas = phase_advances["MEAS"]
mod = phase_advances["MODEL"]
err = phase_advances["ERRMEAS"]
if tot:
output_data = model.loc[:, ["S", f"MU{plane}"]].iloc[:, :]
output_data["NAME"] = output_data.index
output_data = output_data.assign(S2=model.at[model.index[0], "S"],
NAME2=model.index[0])
output_data[f"PHASE{plane}"] = meas.to_numpy()[0, :]
output_data[f"{ERR}PHASE{plane}"] = err.to_numpy()[0, :]
output_data[f"PHASE{plane}{MDL}"] = mod.to_numpy()[0, :]
else:
output_data = model.loc[:, ["S", f"MU{plane}"]].iloc[:-1, :]
output_data["NAME"] = output_data.index
output_data = output_data.assign(S2=model.loc[:, "S"].to_numpy()[1:],
NAME2=model.index[1:].to_numpy())
output_data[f"PHASE{plane}"] = np.diag(meas.to_numpy(), k=1)
output_data[f"{ERR}PHASE{plane}"] = np.diag(err.to_numpy(), k=1)
output_data[f"PHASE{plane}{MDL}"] = np.diag(mod.to_numpy(), k=1)
output_data.rename(columns={f"MU{plane}": f"MU{plane}{MDL}"}, inplace=True)
output_data[f"{DELTA}PHASE{plane}"] = df_ang_diff(output_data,
f"PHASE{plane}",
f"PHASE{plane}{MDL}")
output_data[
f"{ERR}{DELTA}PHASE{plane}"] = output_data.loc[:,
f"{ERR}PHASE{plane}"].to_numpy(
)
return output_data
def test_ang():
a, b = _arand(), _arand()
diff = toolbox.df_ang_diff(*_df(a, b))
sum_angles = toolbox.ang_sum(a, b)
for res in (diff, sum_angles):
assert len(res) == len(a)
assert all(-0.5 <= res)
assert all(res <= 0.5)
def convert_old_total_phase(
inputdir: Union[Path, str],
outputdir: Union[Path, str],
suffix: str,
plane: str,
old_file_name: str = "phasetot",
new_file_name: str = TOTAL_PHASE_NAME,
) -> None:
"""
Looks in the provided directory for expected total phase file from ``BetaBeat.src`` for a given
plane, converts it to the output format used by ``omc3`` and write them to the new location.
The file naming should be getphasetot(x,y).out, with the following expected columns: NAME, NAME2, S,
S1, COUNT, PHASEX, STDPHX, PHXMDL, MUXMDL.
Args:
inputdir (Union[Path, str]): Location of the directory with BetaBeat.src output files.
outputdir (Union[Path, str]): Location of the output directory for converted files.
suffix (str): Compensation suffix used in the provided BetaBeat.src output files.
plane (str): the transverse plane for which to look for the output file.
old_file_name (str): the standard naming for the old output file.
new_file_name (str): the standard naming for the new converted file.
"""
LOGGER.info("Converting old total phase file")
old_file_path = Path(
inputdir) / f"get{old_file_name}{plane.lower()}{suffix}{OLD_EXT}"
if not old_file_path.is_file():
LOGGER.debug(
f"Expected BetaBeat.src output at '{old_file_path.absolute()}' is not a file, skipping"
)
return
dframe = tfs.read(old_file_path)
dframe = dframe.rename(columns={
f"STDPH{plane}": f"{ERR}{PHASE}{plane}",
f"PH{plane}{MDL}": f"{PHASE}{plane}{MDL}",
"S1": "S2",
}, )
dframe[f"{DELTA}{PHASE}{plane}"] = df_ang_diff(dframe, f"{PHASE}{plane}",
f"{PHASE}{plane}{MDL}")
dframe[
f"{ERR}{DELTA}{PHASE}{plane}"] = dframe.loc[:,
f"{ERR}{PHASE}{plane}"].to_numpy(
)
tfs.write(Path(outputdir) / f"{new_file_name}{plane.lower()}{EXT}", dframe)
def create_total_phase(df_twiss: pd.DataFrame, df_model: pd.DataFrame,
parameter: str, relative_error: float,
randomize: Sequence[str], headers: Dict):
""" Creates total phase measurements. """
LOG.debug(f"Creating fake total phase for {parameter}.")
plane = parameter[-1]
df_tot = tfs.TfsDataFrame(index=df_twiss.index)
element0 = df_twiss.index[0]
df_tot[NAME2] = element0
values = df_twiss[f"{PHASE_ADV}{plane}"] - df_twiss.loc[
element0, f"{PHASE_ADV}{plane}"]
errors = relative_error * np.ones_like(values)
if ERRORS in randomize:
errors = _get_random_errors(errors, np.ones_like(values)) % 0.5
errors[0] = 0.
if VALUES in randomize:
rand_val = np.random.normal(values, errors) % 1
values += ang_diff(rand_val, values)
df_tot[parameter] = values % 1
df_tot[f'{ERR}{parameter}'] = errors
# tot model
df_tot[S] = df_model[S]
df_tot[f'{S}2'] = df_model.loc[df_tot.index[0], S]
df_tot[f'{parameter}{MDL}'] = (
df_model[f"{PHASE_ADV}{plane}"] -
df_model.loc[element0, f"{PHASE_ADV}{plane}"]) % 1
df_tot[f'{PHASE_ADV}{plane}{MDL}'] = df_model[f'{PHASE_ADV}{plane}']
df_tot[f"{ERR}{DELTA}{parameter}"] = df_tot[f'{ERR}{parameter}']
df_tot[f"{DELTA}{parameter}"] = df_ang_diff(df_tot, parameter,
f'{parameter}{MDL}')
df_tot = df_tot.fillna(0)
df_tot.headers = headers.copy()
return {f'{TOTAL_PHASE_NAME}{plane.lower()}': df_tot}
def create_phase_advance(df_twiss: pd.DataFrame, df_model: pd.DataFrame,
parameter: str, relative_error: float,
randomize: Sequence[str], headers: Dict):
""" Creates phase advance measurements. """
LOG.debug(f"Creating fake phase advance for {parameter}.")
plane = parameter[-1]
df_adv = tfs.TfsDataFrame(index=df_twiss.index[:-1])
df_adv[NAME2] = df_twiss.index[1:].to_numpy()
def get_phase_advances(df_source):
return ang_diff(
df_source.loc[df_adv[NAME2], f"{PHASE_ADV}{plane}"].to_numpy(),
df_source.loc[df_adv.index, f"{PHASE_ADV}{plane}"].to_numpy())
values = get_phase_advances(df_twiss)
errors = relative_error * np.ones_like(values)
if ERRORS in randomize:
errors = _get_random_errors(errors, np.ones_like(values)) % 0.5
if VALUES in randomize:
values = np.random.normal(values, errors)
values = ang_interval_check(values)
df_adv[parameter] = values
df_adv[f'{ERR}{parameter}'] = errors
# adv model
df_adv[S] = df_model.loc[df_adv.index, S]
df_adv[f'{S}2'] = df_model.loc[df_adv[NAME2], S].to_numpy()
df_adv[f'{parameter}{MDL}'] = get_phase_advances(df_model)
df_adv[f'{PHASE_ADV}{plane}{MDL}'] = df_model.loc[df_adv.index,
f'{PHASE_ADV}{plane}']
df_adv[f"{ERR}{DELTA}{parameter}"] = df_adv[f'{ERR}{parameter}']
df_adv[f"{DELTA}{parameter}"] = df_ang_diff(df_adv, parameter,
f'{parameter}{MDL}')
df_adv.headers = headers.copy()
return {f'{PHASE_NAME}{plane.lower()}': df_adv}