Ejemplo n.º 1
0
    def xmlrpc_run(self,
                   array_kind='TWELVE-M',
                   prj_status=('Ready', 'InProgress'),
                   sb_status=('Ready', 'Suspend', 'Running', 'CalibratorCheck',
                              'Waiting'),
                   cycle=('2013.A', '2013.1', '2015.1', '2015.A'),
                   letter_grade=('A', 'B', 'C'),
                   bands=('ALMA_RB_03', 'ALMA_RB_04', 'ALMA_RB_06',
                          'ALMA_RB_07', 'ALMA_RB_08', 'ALMA_RB_09',
                          'ALMA_RB_10'),
                   check_count=True,
                   conf=None,
                   cal_blratio=False,
                   numant=None,
                   array_id=None,
                   horizon=20,
                   minha=-3.,
                   maxha=3.,
                   pwv=0.5,
                   timestring=None):
        import DsaAlgorithm3 as Wto
        import DsaScorers3 as WtoScor

        self.data.update_status()
        dsa = Wto.WtoAlgorithm3(self.data)
        dsa.write_ephem_coords()
        dsa.static_param()

        if timestring:
            dsa.set_time(timestring)
        else:
            dsa.set_time_now() #Parametrized

        dsa.selector(
            cycle=['2015.1', '2015.A'], minha=-4., maxha=4., letterg=['A', 'B'],
            array_id='last', pwv=0.5)

        scorer = dsa.master_wto_df.apply(
            lambda x: WtoScor.calc_all_scores(
                pwv, x['maxPWVC'], x['Exec. Frac'], x['sbName'], x['array'], x['ARcor'],
                x['DEC'], x['array_ar_cond'], x['minAR'], x['maxAR'], x['Observed'],
                x['EXECOUNT'], x['PRJ_SCIENTIFIC_RANK'], x['DC_LETTER_GRADE'],
                x['CYCLE'], x['HA']), axis=1)

        import pandas as pd
        fin = pd.merge(pd.merge(dsa.master_wto_df, dsa.selection_df, on='SB_UID'),
                       scorer.reset_index(), on='SB_UID').set_index(
            'SB_UID', drop=False).sort('Score', ascending=0)
        return fin.to_json(orient='index');
Ejemplo n.º 2
0
def rundsa(dsa_instance,
           array_kind='TWELVE-M',
           array_id='',
           conf='',
           pwv=0.5,
           numant=0,
           letterg=("A", "B", "C"),
           update=False):

    if conf == '' or array_kind != 'TWELVE-M':
        conf = None
    else:
        conf = [conf]

    if numant == 0 or array_kind == 'TWELVE-M':
        numant = None

    dsa_instance.selector(
            array_kind=array_kind, minha=-3., maxha=3.,
            conf=conf, array_id=array_id, letterg=letterg,
            pwv=pwv, horizon=20, numant=numant,
            sb_status=("Ready", "Running"), sim=True)

    scorer = dsa_instance.master_dsa_df.apply(
        lambda x: DsaScore.calc_all_scores(
            pwv, x['maxPWVC'], x['Exec. Frac'], x['sbName'], x['array'],
            x['ARcor'], x['DEC'], x['array_ar_cond'], x['minAR'],
            x['maxAR'], x['Observed'], x['EXECOUNT'],
            x['PRJ_SCIENTIFIC_RANK'], x['DC_LETTER_GRADE'], x['CYCLE'],
            x['HA']), axis=1)

    fin = pd.merge(
            pd.merge(
                dsa_instance.master_dsa_df[
                    dsa_instance.selection_df.ix[:, 1:11].sum(axis=1) == 10],
                dsa_instance.selection_df, on='SB_UID'),
            scorer.reset_index(), on='SB_UID').set_index(
        'SB_UID', drop=False).sort_values(by='Score', ascending=0)

    return fin
Ejemplo n.º 3
0
dsa.selection_df["PWV now"] = pwv
dsa.selection_df["PWV now date"] = (
    pd.read_sql("pwv_data", engine).date.values[0] + " " + pd.read_sql("pwv_data", engine).time.values[0]
)
dsa.selection_df["date"] = str(dsa._ALMA_ephem.date)
dsa.selection_df["arrayname"] = "TP-Array"
scorer = dsa.master_dsa_df.apply(
    lambda x: WtoScor.calc_all_scores(
        pwv,
        x["maxPWVC"],
        x["Exec. Frac"],
        x["sbName"],
        x["array"],
        x["ARcor"],
        x["DEC"],
        x["array_ar_cond"],
        x["minAR"],
        x["maxAR"],
        x["Observed"],
        x["EXECOUNT"],
        x["PRJ_SCIENTIFIC_RANK"],
        x["DC_LETTER_GRADE"],
        x["CYCLE"],
        x["HA"],
    ),
    axis=1,
)

dsa.master_dsa_df["allconfs"] = dsa.obs_param.apply(
    lambda x: ",".join(
        [
            str(x["C36_1"]),
Ejemplo n.º 4
0
    def xmlrpc_run(self,
                   array_kind='TWELVE-M',
                   bands=('ALMA_RB_03', 'ALMA_RB_04', 'ALMA_RB_06',
                          'ALMA_RB_07', 'ALMA_RB_08', 'ALMA_RB_09',
                          'ALMA_RB_10'),
                   conf='',
                   cal_blratio=False,
                   numant=0,
                   array_id='',
                   horizon=20,
                   minha=-3.,
                   maxha=3.,
                   pwv=0.5,
                   timestring=''):

        with self.lock:
            dsa = Dsa.DsaAlgorithm3(self.data)

        if conf == '' or array_kind != 'TWELVE-M':
            conf = None
        else:
            conf = [conf]

        if array_id == '' or array_kind != 'TWELVE-M':
            array_id = None
        elif array_id != '' and array_kind == 'TWELVE-M':
            dsa._query_array(array_kind)

        if numant == 0 or array_kind == 'TWELVE-M':
            numant = None

        self.data.update_status() #to be put on thread

        if timestring != '':
            dsa.set_time(timestring)  # YYYY-MM-DD HH:mm:SS
        else:
            dsa.set_time_now()

        dsa.write_ephem_coords()
        dsa.static_param()
        dsa.selector(array_kind=array_kind, minha=minha, maxha=maxha,
                     conf=conf, array_id=array_id,
                     pwv=pwv, horizon=horizon, numant=numant,
                     bands=bands)

        scorer = dsa.master_dsa_df.apply(
            lambda x: DsaScore.calc_all_scores(
                pwv, x['maxPWVC'], x['Exec. Frac'], x['sbName'], x['array'], x['ARcor'],
                x['DEC'], x['array_ar_cond'], x['minAR'], x['maxAR'], x['Observed'],
                x['EXECOUNT'], x['PRJ_SCIENTIFIC_RANK'], x['DC_LETTER_GRADE'],
                x['CYCLE'], x['HA']), axis=1)

        fin = pd.merge(
                pd.merge(
                    dsa.master_dsa_df[
                        dsa.selection_df.ix[:, 1:11].sum(axis=1) == 10],
                    dsa.selection_df, on='SB_UID'),
                scorer.reset_index(), on='SB_UID').set_index(
            'SB_UID', drop=False).sort('Score', ascending=0)

        return fin.to_json(orient='index')
Ejemplo n.º 5
0
dsa.write_ephem_coords()
dsa.static_param()
pwv = pd.read_sql('pwv_data', engine).pwv.values[0]
dsa.selector(
    minha=-4., maxha=4., letterg=['A', 'B', 'C'],
    array_id='last', pwv=pwv)
dsa.selection_df['PWV now'] = pwv
dsa.selection_df['PWV now date'] = (
    pd.read_sql('pwv_data', engine).date.values[0] + ' ' +
    pd.read_sql('pwv_data', engine).time.values[0])
dsa.selection_df['date'] = str(dsa._ALMA_ephem.date)
dsa.selection_df['arrayname'] = dsa.arrays.iloc[0, 3]
scorer = dsa.master_dsa_df.apply(
    lambda x: WtoScor.calc_all_scores(
        pwv, x['maxPWVC'], x['Exec. Frac'], x['sbName'], x['array'], x['ARcor'],
        x['DEC'], x['array_ar_cond'], x['minAR'], x['maxAR'], x['Observed'],
        x['EXECOUNT'], x['PRJ_SCIENTIFIC_RANK'], x['DC_LETTER_GRADE'],
        x['CYCLE'], x['HA']), axis=1)

dsa.master_dsa_df['allconfs'] = dsa.obs_param.apply(
    lambda x: ','.join(
        [str(x['C36_1']), str(x['C36_2']), str(x['C36_3']), str(x['C36_4']),
         str(x['C36_5']), str(x['C36_7']), str(x['C36_8'])]), axis=1)

scorer.to_sql('scorer_wto_test', engine, index_label='SBUID',
              if_exists='replace')
print('scorer written')
dsa.inputs.to_sql('inputs_wto_text', engine, index_label='Cycle',
                  if_exists='replace')
print('inputs written')
dsa.selection_df.to_sql('selection_wto_test', engine, index_label='SBUID',