prerun_create.C

Go to the documentation of this file.

// convert a datetime string in the SQL format ("yyyy-mm-dd hh:mm:ss") to TDatime
bool parse_datetime(TString datetime_string, TDatime& datetime)
{
    TPRegexp re_datetime("^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$");
    datetime_string = datetime_string.Strip(TString::kBoth);
    if (!re_datetime.MatchB(datetime_string)) {
        cout << "ERROR: wrong datetime format (\"yyyy-mm-dd hh:mm:ss\" is expected): " << datetime_string << endl;
        return false;
    }
    datetime.Set(datetime_string.Data());
    return true;
}
 
// creating new period/session with the given time interval
// if the period already exists (isPeriodExists) then its start and end times are changed to the given ones
int create_run_period(int period_number, TDatime start_datetime, TDatime end_datetime, bool isPeriodExists)
{
    if (!isPeriodExists) {
        UniRunPeriod* pPeriod = UniRunPeriod::CreateRunPeriod(period_number, start_datetime, &end_datetime);
        if (pPeriod == nullptr) {
            cout << "ERROR: creating the run period " << period_number << " failed" << endl;
            return -1;
        }
        cout << "The run period " << period_number << " was created: " << start_datetime.AsSQLString() << " - "
             << end_datetime.AsSQLString() << endl;
        delete pPeriod;
        return 0;
    }
 
    cout << "WARNING: the run period " << period_number
         << " already exists, its start and end times will be set to the given ones" << endl;
    UniRunPeriod* pPeriod = UniRunPeriod::GetRunPeriod(period_number);
    if (pPeriod == nullptr) {
        cout << "ERROR: getting the run period " << period_number << " failed" << endl;
        return -2;
    }
    if ((pPeriod->SetStartDatetime(start_datetime) != 0) || (pPeriod->SetEndDatetime(&end_datetime) != 0)) {
        cout << "ERROR: updating start and end times of the run period " << period_number << " failed" << endl;
        delete pPeriod;
        return -3;
    }
    delete pPeriod;
 
    return 0;
}
 
// creating fictitious run (without beam, target and events) if absent for parameter validity range
int create_fictitious_run(int period_number, int run_number, TDatime start_datetime, TDatime end_datetime)
{
    int run_exists = UniRun::CheckRunExists(period_number, run_number);
    if (run_exists < 0) {
        cout << "ERROR: checking existence of the run " << period_number << ":" << run_number << " failed" << endl;
        return -1;
    }
    if (run_exists > 0) {
        cout << "WARNING: the run " << period_number << ":" << run_number << " already exists, it is skipped" << endl;
        return 0;
    }
 
    // run type 0 is the same as for the runs automatically created on writing raw file metadata
    UniRun* pRun = UniRun::CreateRun(period_number, run_number, 0, start_datetime, &end_datetime, "", "", "", nullptr,
                                     nullptr, nullptr, 1);
    if (pRun == nullptr) {
        cout << "ERROR: creating the fictitious run " << period_number << ":" << run_number << " failed" << endl;
        return -2;
    }
    cout << "The fictitious run " << period_number << ":" << run_number << " has been created" << endl;
    delete pRun;
 
    return 0;
}
 
// copying all detector parameter values valid for the previous run (prev_period:prev_run)
// to the new validity range: period_number::start_run -> period_number::end_run
// values having an active record overlapped with the new range (e.g. already copied before) are skipped
// if isCopySingleRunValues is false then values valid only for one run (start = end, e.g. T0_SlewingCorr) are skipped,
// because they are usually written run by run and a session-wide copy would block writing them for the new session
int copy_detector_parameters(int period_number,
                             int start_run,
                             int end_run,
                             int prev_period,
                             int prev_run,
                             bool isCopySingleRunValues = false)
{
    UniConnection* connDb = UniConnection::Open();
    if (connDb == nullptr) {
        cout << "ERROR: connection to the UniConDa database failed" << endl;
        return -1;
    }
 
    TSQLServer* db_server = connDb->GetSQLServer();
    TString sql_source =
        TString::Format("from detector_parameter dp join parameter_ p on dp.parameter_id = p.parameter_id "
                        "where dp.expiry_date is null "
                        // the value is valid for the previous run
                        "and ((dp.start_period < %d) or ((dp.start_period = %d) and (dp.start_run <= %d))) "
                        "and ((dp.end_period > %d) or ((dp.end_period = %d) and (dp.end_run >= %d))) "
                        // no active value of the same parameter overlaps the new validity range
                        "and not exists (select 1 from detector_parameter np "
                        "where np.detector_name = dp.detector_name and np.parameter_id = dp.parameter_id "
                        "and np.value_key = dp.value_key and np.expiry_date is null "
                        "and not (((np.end_period < %d) or ((np.end_period = %d) and (np.end_run < %d))) or "
                        "((np.start_period > %d) or ((np.start_period = %d) and (np.start_run > %d))))) ",
                        prev_period, prev_period, prev_run, prev_period, prev_period, prev_run, period_number,
                        period_number, start_run, period_number, period_number, end_run);
    if (!isCopySingleRunValues)
        sql_source += "and not ((dp.start_period = dp.end_period) and (dp.start_run = dp.end_run)) ";
 
    // print detector parameter values to be copied
    TString sql = "select dp.detector_name, p.parameter_name, dp.value_key, dp.start_period, dp.start_run, "
                  "dp.end_period, dp.end_run, length(dp.parameter_value) "
                  + sql_source + "order by dp.detector_name, p.parameter_name, dp.value_key";
    TSQLStatement* stmt = db_server->Statement(sql);
 
    if (!stmt->Process()) {
        cout << "ERROR: getting detector parameters valid for the previous run failed" << endl;
        delete stmt;
        delete connDb;
        return -2;
    }
    stmt->StoreResult();
 
    int value_count = 0;
    while (stmt->NextResultRow()) {
        if (value_count == 0)
            cout << "Detector parameter values to be copied to " << period_number << ":" << start_run << " - "
                 << period_number << ":" << end_run << endl;
        cout << "    " << stmt->GetString(0) << " : " << stmt->GetString(1) << " (key " << stmt->GetInt(2) << ", "
             << stmt->GetInt(3) << ":" << stmt->GetInt(4) << " - " << stmt->GetInt(5) << ":" << stmt->GetInt(6) << ", "
             << stmt->GetLong64(7) << " bytes)" << endl;
        value_count++;
    }
    delete stmt;
 
    if (value_count == 0) {
        cout << "WARNING: there are no detector parameter values to be copied from the run " << prev_period << ":"
             << prev_run << endl;
        delete connDb;
        return 0;
    }
 
    // copy the parameter values on the database side to avoid transferring large binary values
    sql = TString::Format(
              "insert into detector_parameter "
              "(detector_name, parameter_id, start_period, start_run, end_period, end_run, value_key, parameter_value) "
              "select dp.detector_name, dp.parameter_id, %d, %d, %d, %d, dp.value_key, dp.parameter_value ",
              period_number, start_run, period_number, end_run)
          + sql_source;
    stmt = db_server->Statement(sql);
 
    // write new parameter values to the database
    if (!stmt->Process()) {
        cout << "ERROR: copying detector parameters to the new period failed" << endl;
        delete stmt;
        delete connDb;
        return -3;
    }
    cout << "Detector parameter values copied: " << stmt->GetNumAffectedRows() << endl;
 
    delete stmt;
    delete connDb;
 
    return 0;
}
 
/**
 *  Main pre-run procedure to prepare metadata parameters for a new Run:
 *  1. create the new period with the given time interval ("yyyy-mm-dd hh:mm:ss")
 *  2. create fictitious runs with start_run and end_run numbers for the period
 *  3. copy all detector parameter values valid for the last run before the period to
 *     period_number:start_run - period_number:end_run
 *  The fictitious run range is corrected to the real first and last runs after the session by postrun_update.C
 *
 *  If the period already exists then nothing is changed and the macro exits (returns 1),
 *  unless isUpdateExistingPeriod is true: then the period times are set to the given ones,
 *  absent fictitious runs are created and absent parameter values are copied
 *
 *  example:
 *  root -b -q 'prerun_create.C(10, "2026-10-01 00:00:00", "2027-04-01 00:00:00", 1, 100000)'
 **/
int prerun_create(int period_number,
                  TString start_datetime,
                  TString end_datetime,
                  int start_run = 1,
                  int end_run = 100000,
                  bool isCopySingleRunValues = false,
                  bool isUpdateExistingPeriod = false)
{
    TDatime period_start, period_end;
    if (!parse_datetime(start_datetime, period_start) || !parse_datetime(end_datetime, period_end))
        return -1;
    if (period_start.Convert() >= period_end.Convert()) {
        cout << "ERROR: start time of the period must be less than its end time" << endl;
        return -1;
    }
    if (start_run >= end_run) {
        cout << "ERROR: start run number must be less than the end run number" << endl;
        return -1;
    }
 
    // exit without any changes if the period already exists, unless it is allowed to update the existing period
    int period_exists = UniRunPeriod::CheckRunPeriodExists(period_number);
    if (period_exists < 0) {
        cout << "ERROR: checking existence of the run period " << period_number << " failed" << endl;
        return -2;
    }
    if ((period_exists > 0) && !isUpdateExistingPeriod) {
        cout << "WARNING: the run period " << period_number << " already exists, nothing is changed. "
             << "Set isUpdateExistingPeriod to true to update the existing period" << endl;
        return 1;
    }
 
    // find the previous run whose parameter values are copied to the new period (before creating fictitious runs)
    int prev_period = period_number, prev_run = start_run;
    if (UniRun::FindPreviousRun(prev_period, prev_run) != 0) {
        cout << "ERROR: no previous run was found to copy parameters for the period " << period_number << endl;
        return -3;
    }
    cout << "Detector parameters valid for the run " << prev_period << ":" << prev_run << " will be copied" << endl;
 
    if (create_run_period(period_number, period_start, period_end, period_exists > 0) != 0)
        return -4;
 
    if (create_fictitious_run(period_number, start_run, period_start, period_start) != 0)
        return -5;
    if (create_fictitious_run(period_number, end_run, period_end, period_end) != 0)
        return -5;
 
    if (copy_detector_parameters(period_number, start_run, end_run, prev_period, prev_run, isCopySingleRunValues) != 0)
        return -6;
 
    return 0;
}