def _get_model_phases(model: pd.DataFrame, meas: pd.DataFrame, key: str) -> pd.DataFrame:
model_column = f"{PHASE_ADV}{key[-1]}"
with logging_tools.log_pandas_settings_with_copy(LOG.debug):
meas[MODEL] = (model.loc[meas["NAME2"].to_numpy(), model_column].to_numpy() -
model.loc[meas.index.to_numpy(), model_column].to_numpy())
meas[DIFF] = df_diff(meas, VALUE, MODEL)
return meas
def _compensate_by_model(input_files, meas_input, df, plane):
df = pd.merge(df, pd.DataFrame(meas_input.accelerator.model_driven.loc[:, [f"MU{plane}"]]),
how='inner', left_index=True, right_index=True, suffixes=("", "comp"))
phase_compensation = df_diff(df, f"MU{plane}", f"MU{plane}comp")
df[input_files.get_columns(df, f"MU{plane}")] = ang_sum(
input_files.get_data(df, f"MU{plane}"), phase_compensation[:, np.newaxis])
return df
def convert_old_closed_orbit(
inputdir: Union[Path, str],
outputdir: Union[Path, str],
plane: str,
old_file_name: str = "CO",
new_file_name: str = ORBIT_NAME,
) -> None:
"""
Looks in the provided directory for expected closed orbit 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 getCO(x,y).out, with the following expected columns: NAME, S, COUNT,
X, STDX, XMDL, 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.
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 closed orbit file")
old_file_path = Path(
inputdir) / f"get{old_file_name}{plane.lower()}{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"STD{plane}": f"{ERR}{plane}"})
dframe[f"{DELTA}{plane}"] = df_diff(dframe, f"{plane}", f"{plane}{MDL}")
dframe[f"{ERR}{DELTA}{plane}"] = dframe.loc[:, f"{ERR}{plane}"].to_numpy()
tfs.write(Path(outputdir) / f"{new_file_name}{plane.lower()}{EXT}", dframe)
def _add_tunes_if_in_second_turn(df, input_files, line, phase2):
mask = df_diff(df, "S", "S2") > 0
tunes = np.empty((2, len(input_files.dpp_frames("X", 0))))
for i, plane in enumerate(PLANES):
tunes[i] = np.array([
lin.headers[f"Q{i+1}"] for lin in input_files.dpp_frames(plane, 0)
])
phase2[mask, :] = phase2[mask, :] + line[0] * tunes[0] + line[1] * tunes[1]
return phase2
def convert_old_beta_from_phase(
inputdir: Union[Path, str],
outputdir: Union[Path, str],
suffix: str,
plane: str,
old_file_name: str = "beta",
new_file_name: str = BETA_NAME,
) -> None:
"""
Looks in the provided directory for expected beta from 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 getbeta(x,y).out, with the following expected columns: NAME, S, COUNT,
BETX, SYSBETX, STATBETX, ERRBETX, CORR_ALFABETA, ALFX, SYSALFX, STATALFX, ERRALFX, BETXMDL, ALFXMDL,
MUXMDL, NCOMBINATIONS.
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 beta from 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)
if "CORR_ALFABETA" in dframe.columns.to_numpy():
dframe = dframe.drop(columns=[
f"STATBET{plane}", f"SYSBET{plane}", "CORR_ALFABETA",
f"STATALF{plane}", f"SYSALF{plane}"
])
else:
dframe[f"{ERR}BET{plane}"] = df_err_sum(dframe, f"{ERR}BET{plane}",
f"STDBET{plane}")
dframe[f"{ERR}ALF{plane}"] = df_err_sum(dframe, f"{ERR}ALF{plane}",
f"STDALF{plane}")
dframe[f"{DELTA}BET{plane}"] = df_rel_diff(dframe, f"BET{plane}",
f"BET{plane}{MDL}")
dframe[f"{ERR}{DELTA}BET{plane}"] = df_ratio(dframe, f"{ERR}BET{plane}",
f"BET{plane}{MDL}")
dframe[f"{DELTA}ALF{plane}"] = df_diff(dframe, f"ALF{plane}",
f"ALF{plane}{MDL}")
dframe[
f"{ERR}{DELTA}ALF{plane}"] = dframe.loc[:,
f"{ERR}ALF{plane}"].to_numpy()
tfs.write(Path(outputdir) / f"{new_file_name}{plane.lower()}{EXT}", dframe)
def _get_delta_columns(beta_df, plane):
beta_df[f"{DELTA}BET{plane}"] = df_rel_diff(beta_df, f"BET{plane}",
f"BET{plane}{MDL}")
beta_df[f"{ERR}{DELTA}BET{plane}"] = df_ratio(beta_df, f"{ERR}BET{plane}",
f"BET{plane}{MDL}")
beta_df[f"{DELTA}ALF{plane}"] = df_diff(beta_df, f"ALF{plane}",
f"ALF{plane}{MDL}")
beta_df[
f"{ERR}{DELTA}ALF{plane}"] = beta_df.loc[:,
f"{ERR}ALF{plane}"].to_numpy(
)
return beta_df
def append_model(df: pd.DataFrame,
df_model: pd.DataFrame,
parameter: str,
planes: str = '',
beat: bool = False) -> pd.DataFrame:
""" Add the values to the measurement. """
LOG.debug(f"Appending model to fake measurement for {parameter}.")
df[S] = df_model[S]
for plane in planes:
df[f'{PHASE_ADV}{plane}{MDL}'] = df_model[f'{PHASE_ADV}{plane}']
df[f"{parameter}{MDL}"] = df_model[f'{parameter}']
if beat:
df[f"{DELTA}{parameter}"] = df_rel_diff(df, parameter,
f"{parameter}{MDL}")
df[f"{ERR}{DELTA}{parameter}"] = df_ratio(df, f"{ERR}{parameter}",
f"{parameter}{MDL}")
else:
df[f"{DELTA}{parameter}"] = df_diff(df, f'{parameter}',
f'{parameter}{MDL}')
df[f"{ERR}{DELTA}{parameter}"] = df[f'{ERR}{parameter}']
return df
def test_df_sum_diff():
a, b = _arand(), _arand()
sum_of_columns = toolbox.df_sum(*_df(a, b))
diff = toolbox.df_diff(*_df(sum_of_columns, b))
assert _numerically_equal(a, diff)
def test_df_diff_zero(random, zeros):
assert all(random == toolbox.df_diff(*_df(random, zeros)))
def _get_model_generic(model: pd.DataFrame, meas: pd.DataFrame, key: str) -> pd.DataFrame:
with logging_tools.log_pandas_settings_with_copy(LOG.debug):
meas[MODEL] = model.loc[meas.index.to_numpy(), key].to_numpy()
meas[DIFF] = df_diff(meas, VALUE, MODEL)
return meas
