TangoData.cxx

Go to the documentation of this file.

#include "TangoData.h"
 
#include "TColor.h"
#include "TROOT.h"
#include "TRandom.h"
#include "TangoConnection.h"
#include "UniRun.h"
 
#include <TAxis.h>
#include <TCanvas.h>
#include <TGraph.h>
#include <TGraph2D.h>
#include <TH2D.h>
#include <TLegend.h>
#include <TMultiGraph.h>
#include <TSQLServer.h>
#include <TSQLStatement.h>
#include <TStyle.h>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <fstream>
#include <iostream>
using namespace std;
 
// Tango Database connection based on MySQL before 2020-03-24
const char* const TANGO_DB_USERNAME_b2020 = "tango";
const char* const TANGO_DB_PASSWORD_b2020 = "tangompd";
const char* const TANGO_DB_HOST_b2020 = "10.18.11.66";
const char* const TANGO_DB_NAME_b2020 = "hdbpp";
 
TangoTimeParameter::TangoTimeParameter() {}
 
TangoTimeParameter::TangoTimeParameter(TDatime par_time, Tango_Parameter_Type par_type)
{
    parameter_time = par_time;
    parameter_type = par_type;
}
 
// Copy constructor
TangoTimeParameter::TangoTimeParameter(const TangoTimeParameter& ttp)
    : TObject(ttp)
    , parameter_time(ttp.parameter_time)
    , parameter_type(ttp.parameter_type)
{
    bool_parameter_value = ttp.bool_parameter_value;
    double_parameter_value = ttp.double_parameter_value;
}
 
TangoTimeParameter::~TangoTimeParameter() {}
 
TangoTimeInterval::TangoTimeInterval() {}
 
TangoTimeInterval::TangoTimeInterval(TDatime start_time_interval, TDatime end_time_interval)
{
    start_time = start_time_interval;
    end_time = end_time_interval;
}
 
TangoTimeInterval::~TangoTimeInterval() {}
 
/**
 *  TangoData CLASS IMPLEMENTATION
 **/
 
/** Single Constructor: fill Tango data array according to the given parameters
 *  Tango database connection is defined in the 'tango_db_settings.h' file
 *  Parameters:
 *  start_date - time from which to start reading the parameter, format: "YYYY-MM-DD HH:MM:SS"
 *               (e.g. "2015-03-13 23:00:00")
 *  end_date - end time of reading the parameter, the same format (e.g. "2015-03-13 24:00:00")
 *  system_name - name of the system, i.e. Tango domain (e.g. "magnet", "fhcal" or "gem")
 *  parameter_name - name of hardware parameter stored in Tango, i.e. Tango attribute
 *                   (e.g. "vch_2_1" for FHCal or "vmon_0" for GEM)
 *  member_name - name of the Tango member, i.e. device (e.g. "hv_1" for FHCal or "mod_0" for GEM),
 *                it can be given with the Tango family as "family/member" if the member name is not unique
 *                in the domain (e.g. "caen_232/mod_2" for CSC or "plane1_top/adcsc_7_temp" for FSD),
 *                empty string - the member is not used
 **/
TangoData::TangoData(const char* start_date,
                     const char* end_date,
                     const char* system_name,
                     const char* parameter_name,
                     const char* member_name,
                     int verbose)
    : strSystemName(system_name)
    , strParameterName(parameter_name)
    , strMemberName(member_name)
    , strUserName("")
    , strStartDate(start_date)
    , strEndDate(end_date)
    , iVerbose(verbose)
{
    InitTangoData();
}
 
/** Run Range Constructor: fill Tango data array for the time interval from the start time of the first run
 *  to the end time of the last run of the given range (the gaps between runs are included)
 *  The run times are taken from the Unified Condition Database (UniRun)
 *  Parameters:
 *  period_number - period (session) number of the runs (e.g. 8)
 *  start_run - number of the first run of the range (e.g. 6000)
 *  end_run - number of the last run of the range (set equal to start_run to read a single run)
 *  system_name, parameter_name, member_name, verbose - the same as in the time interval constructor
 *  Use GetRunAverageTangoData() to average the parameter only over the time of the runs
 **/
TangoData::TangoData(int period_number,
                     int start_run,
                     int end_run,
                     const char* system_name,
                     const char* parameter_name,
                     const char* member_name,
                     int verbose)
    : strSystemName(system_name)
    , strParameterName(parameter_name)
    , strMemberName(member_name)
    , strUserName("")
    , iVerbose(verbose)
    , iPeriodNumber(period_number)
    , iStartRun(start_run)
    , iEndRun(end_run)
{
    if (SetRunRangeDates(period_number, start_run, end_run) == 0)
        InitTangoData();
}
 
TangoData::~TangoData()
{
    if (arrTangoData != nullptr) {
        arrTangoData->Delete();
        delete arrTangoData;
    }
}
 
TString TangoData::GetFullName()
{
    TString strFullName = strSystemName + ":" + strParameterName;
    if (strMemberName != "")
        strFullName += " (" + strMemberName + ")";
 
    return strFullName;
}
 
// non-user function SetRunRangeDates sets strStartDate and strEndDate to the start time of the first run
// and the end time of the last run existing in the given run range of the period,
// and fills vecRunIntervals with the time intervals of the runs (runs without end time are skipped)
// Returns: 0 - in case of the success, < 0 - if an error occured
// the last successfully read run range is cached to avoid repeated requests to the Unified Database,
// e.g. when many Tango parameters are read for the same runs
static int cached_period = -1, cached_start_run = -1, cached_end_run = -1;
static TString cached_start_date, cached_end_date;
static vector<TangoTimeInterval> cached_run_intervals;
 
int TangoData::SetRunRangeDates(int period_number, int start_run, int end_run)
{
    vecRunIntervals.clear();
    if (start_run > end_run) {
        cout << "ERROR: start run (" << start_run << ") cannot be greater than end run (" << end_run << ")" << endl;
        return -1;
    }
 
    if ((period_number == cached_period) && (start_run == cached_start_run) && (end_run == cached_end_run)) {
        strStartDate = cached_start_date;
        strEndDate = cached_end_date;
        vecRunIntervals = cached_run_intervals;
        if (iVerbose)
            cout << "Run range " << period_number << ":" << start_run << "-" << end_run
                 << " (from the cache) corresponds"
                 << " to the time " << strStartDate << " - " << strEndDate << endl;
        return 0;
    }
 
    // get runs existing in the database for the given range (run numbers can have gaps)
    UniqueRunNumber* run_numbers = nullptr;
    int run_count = UniRun::GetRunNumbers(run_numbers, period_number, start_run, period_number, end_run);
    if (run_count < 0) {
        cout << "ERROR: getting run numbers from the Unified Database has been failed" << endl;
        return -2;
    }
    if (run_count == 0) {
        delete[] run_numbers;
        cout << "ERROR: there are no runs in the range " << period_number << ":" << start_run << "-" << end_run
             << " in the Unified Database" << endl;
        return -3;
    }
    int first_run = run_numbers[0].run_number, last_run = run_numbers[run_count - 1].run_number;
 
    // get start and end times of every run in the range
    TString start_date, end_date;
    for (int i = 0; i < run_count; i++) {
        int run_number = run_numbers[i].run_number;
        UniRun* pRun = UniRun::GetRun(period_number, run_number);
        if (pRun == nullptr) {
            cout << "ERROR: run " << period_number << ":" << run_number << " was not found in the Unified Database"
                 << endl;
            delete[] run_numbers;
            vecRunIntervals.clear();
            return -4;
        }
        TDatime run_start = pRun->GetStartDatetime();
        TDatime* run_end = pRun->GetEndDatetime();
        delete pRun;
        if (i == 0)
            start_date = run_start.AsSQLString();
 
        if (run_end == nullptr) {
            // the end time of the last run defines the end of the whole time interval
            if (i == run_count - 1) {
                cout << "ERROR: there is no end time for the last run " << period_number << ":" << run_number
                     << " in the Unified Database" << endl;
                delete[] run_numbers;
                vecRunIntervals.clear();
                return -5;
            }
            cout << "WARNING: there is no end time for the run " << period_number << ":" << run_number
                 << " in the Unified Database, it is excluded from the run time intervals" << endl;
            continue;
        }
        if (i == run_count - 1)
            end_date = run_end->AsSQLString();
 
        vecRunIntervals.push_back(TangoTimeInterval(run_start, *run_end));
        delete run_end;
    }
    delete[] run_numbers;
 
    strStartDate = start_date;
    strEndDate = end_date;
    if (iVerbose)
        cout << "Run range " << period_number << ":" << first_run << "-" << last_run << " (" << run_count
             << " runs) corresponds to the time " << strStartDate << " - " << strEndDate << endl;
 
    cached_period = period_number, cached_start_run = start_run, cached_end_run = end_run;
    cached_start_date = strStartDate, cached_end_date = strEndDate;
    cached_run_intervals = vecRunIntervals;
 
    return 0;
}
 
// non-user function InitTangoData selects the Tango database (MySQL before 2020-03-25, PgSQL after)
// by the start date and fills the Tango data array
void TangoData::InitTangoData()
{
    if (strcmp(strStartDate.Data(), "2020-03-25") < 0) {
        IsOldMySQL = true;
        if (iVerbose)
            cout << "Old MySQL Database is used to get Tango data" << endl;
    } else if (iVerbose)
        cout << "PostgreSQL Database is used to get Tango data" << endl;
 
    GetTangoParameter();
}
 
// non-user function GetTangoParameter gets hardware data from the Tango database and write to the arrTangoData
// First, name of the target table with required parameter is extracted from the Tango Base Table,
// then required data are selected from the target table corresponding the given time interval.
// Returns: 0 - in case of the success, < 0 - if an error occured
int TangoData::GetTangoParameter()
{
    if (iVerbose)
        cout << "Input Start Date = " << strStartDate.Data() << endl;
    if (iVerbose)
        cout << "Input End Date = " << strEndDate.Data() << endl;
    if ((strStartDate == "") || (strEndDate == "")) {
        cout << "ERROR: start datetime and end datetime should not be empty!" << endl;
        return -1;
    }
    if (strStartDate < "2000-01-01") {
        cout << "ERROR: start date cannot be less than 2000 year" << endl;
        return -2;
    }
 
    // new start and end datetime with time zone if PgSQL
    TString start_date_new(strStartDate), end_date_new(strEndDate);
    if (!IsOldMySQL)
        start_date_new += " Europe/Moscow", end_date_new += " Europe/Moscow";
 
    // TANGO database connection (MySQL before 2020-03-24 and PgSQL after)
    TangoConnection* connDb = nullptr;
    if (IsOldMySQL)
        connDb = TangoConnection::Open(TangoConnection::MySQL, TANGO_DB_HOST_b2020, TANGO_DB_NAME_b2020,
                                       TANGO_DB_USERNAME_b2020, TANGO_DB_PASSWORD_b2020);
    else
        connDb = TangoConnection::Open();
    if (connDb == nullptr)
        return -3;
    TSQLServer* db_server = connDb->GetSQLServer();
    if (db_server == nullptr)
        return -4;
 
    if (db_server->GetTables(db_server->GetDB()) == nullptr)
        return -5;
 
    // searching for a table name with corresponding parametter type, where the parameter with given system and
    // parameter names is stored Statement returns parameter ID and parameter table
    TString strStatement;
    if (IsOldMySQL)
        strStatement = TString::Format(
            "SELECT att_conf_id, data_type "
            "FROM att_conf ac join att_conf_data_type acdt on ac.att_conf_data_type_id = acdt.att_conf_data_type_id "
            "WHERE family='%s' and name='%s' ",
            strSystemName.Data(), strParameterName.Data());
    else {
        strStatement = TString::Format("SELECT att_conf_id, table_name "
                                       "FROM att_conf "
                                       "WHERE domain='%s' and name='%s' ",
                                       strSystemName.Data(), strParameterName.Data());
        // the member name can be given with the family as "family/member" if the member name is not unique
        // in the domain (e.g. "caen_232/mod_2" and "caen_240/mod_2" for CSC)
        TString family_name(""), member_name(strMemberName);
        Ssiz_t slash_pos = strMemberName.First('/');
        if (slash_pos != kNPOS) {
            family_name = strMemberName(0, slash_pos);
            member_name = strMemberName(slash_pos + 1, strMemberName.Length() - slash_pos - 1);
        }
        if (family_name != "")
            strStatement += TString::Format("and family = '%s' ", family_name.Data());
        if (member_name != "")
            strStatement += TString::Format("and member = '%s' ", member_name.Data());
        strStatement += "ORDER BY att_conf_id";
    }
 
    if (iVerbose)
        cout << "Processing the following SQL request to get info on the Tango parameter:" << endl
             << strStatement << endl;
    TSQLStatement* stmt_select = db_server->Statement(strStatement);
    if (!stmt_select->Process()) {
        cout << "ERROR: getting info on parameter from Tango has been failed: " << GetFullName() << endl;
        delete stmt_select;
        return -6;
    }
 
    stmt_select->StoreResult();
    if (!stmt_select->NextResultRow()) {
        cout << "ERROR: There is no Tango parameter '" << GetFullName() << endl;
        delete stmt_select;
        return -7;
    }
    // Tango team duplicated (old MySQL solution) parameters for every Nuclotron session
    if ((IsOldMySQL) && (stmt_select->GetNumAffectedRows() > 1) && (strcmp(strEndDate.Data(), "2018-01-01") > 0)) {
        if (!stmt_select->NextResultRow()) {
            cout << "ERROR: There is no second row for parameter '" << strParameterName << "' for " << strSystemName
                 << " detector" << endl;
            delete stmt_select;
            return -8;
        }
    }
 
    int parameter_id = stmt_select->GetInt(0);
    TString table_name(stmt_select->GetString(1));
    // several Tango parameters can correspond to the given names, e.g. the same member name in different families
    if ((!IsOldMySQL) && (stmt_select->NextResultRow()))
        cout << "WARNING: several Tango parameters correspond to '" << GetFullName()
             << "', the first one is used. Specify the family in the member name as \"family/member\"" << endl;
    if (IsOldMySQL)
        table_name = TString::Format("att_%s", table_name.Data());
    if (iVerbose)
        cout << "Found Data Table name = " << table_name << ". Parameter ID = " << parameter_id << endl;
    delete stmt_select;
 
    // parse parameter type. current support for att_array_devdouble, att_array_devboolean, att_scalar_devdouble,
    // att_scalar_devboolean and integer types read as numeric values: att_scalar_devshort, att_scalar_devlong,
    // att_scalar_devlong64 and att_scalar_devstate
    Tango_Parameter_Type par_type;
    if (table_name.Contains("array_devdouble"))
        par_type = Tango_Double_Array;
    else if (table_name.Contains("array_devboolean"))
        par_type = Tango_Bool_Array;
    else if (table_name.Contains("scalar_devdouble") || table_name.Contains("scalar_devshort")
             || table_name.Contains("scalar_devlong") || table_name.Contains("scalar_devstate"))
        par_type = Tango_Double;
    else if (table_name.Contains("scalar_devboolean"))
        par_type = Tango_Bool;
    else {
        cout << "ERROR: This Tango type is not supported: '" << table_name << "'" << endl;
        return -9;
    }
 
    // getting data from the table found by the attribute type
    TString query_data;
    if (IsOldMySQL)
        query_data = "SELECT date_format(data_time, '%Y-%m-%d %H:%i:%S'), value_r ";
    else
        query_data = "SELECT to_char(data_time, 'YYYY-MM-DD HH24:MI:SS.MS'), value_r ";
 
    if (par_type > 10)   // if the parameter is stored as array of values
        query_data += ", dim_x_r, dim_x_w, idx ";
 
    // add a new point with the previous value (<=date_start)
    query_data += TString::Format("FROM %s "
                                  "WHERE att_conf_id='%d' and ((data_time > '%s' and data_time <= '%s') "
                                  "or (data_time = (SELECT max(data_time) FROM %s WHERE att_conf_id='%d' and data_time "
                                  "<= '%s' and value_r is not null))) "
                                  "and value_r is not null ",
                                  table_name.Data(), parameter_id, start_date_new.Data(), end_date_new.Data(),
                                  table_name.Data(), parameter_id, start_date_new.Data());
 
    if (par_type > 10)   // if the parameter is stored as array of values
        query_data += "ORDER BY data_time,idx";
    else
        query_data += "ORDER BY data_time";
 
    if (iVerbose)
        cout << "Query data with the following SQL request:" << endl << query_data << endl;
    stmt_select = db_server->Statement(query_data);
    if (!stmt_select->Process()) {
        cout << "ERROR: getting parameter values from Tango has been failed" << endl;
        delete stmt_select;
        return -10;
    }
 
    stmt_select->StoreResult();
 
    Int_t cur_num = 0;
    TangoTimeParameter* par = nullptr;
    // create Tango data array and write data to it
    arrTangoData = new TObjArray();
    arrTangoData->SetName(
        TString::Format("'%s' parameter for %s detector", strParameterName.Data(), strSystemName.Data()));
    arrTangoData->SetOwner(kTRUE);
    while (stmt_select->NextResultRow()) {
        const char* pc_datetime = stmt_select->GetString(0);
        TDatime datetime(pc_datetime);
        // shift the previous time va;ue to the date_start position
        if ((cur_num == 0) && (strcmp(pc_datetime, strStartDate) < 0))
            datetime.Set(strStartDate);
 
        int i_par_len = 1;
        if (par_type > 10)
            i_par_len = stmt_select->GetInt(2);
        if (i_par_len == 0) {
            cout << "ERROR: Parameter length cannot be equal 0" << endl;
            delete stmt_select;
            DeleteTangoParameter();
            return -11;
        }
 
        int i_real_par_len = 1;
        if (par_type > 10)
            i_real_par_len = stmt_select->GetInt(3);
        if (i_real_par_len == 0) {
            cout << "ERROR: Real parameter length cannot be equal 0" << endl;
            delete stmt_select;
            DeleteTangoParameter();
            return -12;
        }
 
        par = new TangoTimeParameter(datetime, par_type);
        // cout<<par.parameter_time.AsString()<<endl;
        for (int ind = 0; ind < i_par_len; ind++) {
            if (ind > 0)
                stmt_select->NextResultRow();
 
            int i_idx = 0;
            if (par_type > 10)
                i_idx = stmt_select->GetInt(4);
            // cout<<"idx:ind - "<<idx<<":"<<ind<<endl;
            if (i_idx != ind) {
                cout << "ERROR: idx should be equal index of the parameter array" << endl;
                delete stmt_select;
                DeleteTangoParameter();
                return -13;
            }
 
            if (ind >= i_real_par_len)
                continue;
 
            if ((par_type == Tango_Bool_Array) || (par_type == Tango_Bool)) {
                // boolean value is returned as a number by MySQL and as "t" or "f" by PgSQL
                TString str_val = stmt_select->GetString(1);
                bool b_val = (str_val == "t") || (str_val == "true") || (str_val.Atoi() != 0);
                par->bool_parameter_value.push_back(b_val);
                par->double_parameter_value.push_back(b_val);
                // cout<<par.bool_parameter_value[par.bool_parameter_value.size()-1]<<endl;
            } else {
                double d_val = stmt_select->GetDouble(1);
                par->double_parameter_value.push_back(d_val);
                // cout<<par.double_parameter_value[par.double_parameter_value.size()-1]<<endl;
            }
        }
        if (iVerbose)
            cout << "Boolean parameter value size = " << par->bool_parameter_value.size() << endl;
        if (iVerbose)
            cout << "Double parameter value size = " << par->double_parameter_value.size() << endl;
 
        arrTangoData->Add(par);
        cur_num++;
    }
    delete stmt_select;
 
    // add date_end point (if not exists) equal to the the previous value
    // (the last archived value is extended even if the archiving was stopped before date_end)
    if ((par != nullptr) && (strcmp(par->parameter_time.AsSQLString(), strEndDate.Data()) < 0)) {
        TangoTimeParameter* par_last = new TangoTimeParameter(*par);
        par_last->parameter_time.Set(strEndDate);
        arrTangoData->Add(par_last);
    }
 
    return 0;
}
 
// Function displays hardware data obtained from Tango, e.g. FHCal voltage in time interval, in console
void TangoData::PrintTangoDataConsole()
{
    if (arrTangoData == nullptr) {
        cout << "ERROR: Tango parameter has not been obtained" << endl;
        return;
    }
 
    int def_precision = cout.precision();
    cout.precision(17);
 
    int par_length = 0;
    for (int i = 0; i < arrTangoData->GetEntriesFast(); i++) {
        TangoTimeParameter* pParameter = (TangoTimeParameter*)arrTangoData->At(i);
        cout << pParameter->parameter_time.AsSQLString() << endl;
 
        // cout<<TD->dataArray[i].parameter_length<<endl;
        par_length = pParameter->double_parameter_value.size();
        for (int j = 0; j < par_length; j++)
            cout << pParameter->double_parameter_value[j] << "  ";
        cout << "" << endl << endl;
    }
 
    cout.precision(def_precision);
    return;
}
 
// Function displays a set of "simple" parameters obtained from Tango, e.g. GEMs high voltages voltage, in console
void TangoData::PrintTangoArrayConsole(vector<TangoData*> vecTangoData)
{
    for (const auto& tango_data : vecTangoData) {
        cout << "The current parameter: " << tango_data->GetFullName() << endl;
        tango_data->PrintTangoDataConsole();
    }
}
 
// non-user function GetSourceName returns "domain_member" of the Tango parameter or "domain" if the member is not set
static TString GetSourceName(TangoData* pTangoData)
{
    TString source_name = pTangoData->GetSystemName();
    if (pTangoData->GetMemberName() != "")
        source_name += "_" + pTangoData->GetMemberName();
    return source_name;
}
 
// non-user function GetRangeSuffix returns the range of the Tango parameter:
// for the Run Range Constructor - the period and run range "_p<period>_r<start>_<end>"
// (e.g. "_p9_r9696_9730", or "_p9_r9696" for a single run),
// for the time interval - the start and end dates "_t<YYYYMMDD>_<HHMM>_<YYYYMMDD>_<HHMM>"
// (e.g. "_t20250301_1000_20250301_1600")
static TString GetRangeSuffix(TangoData* pTangoData)
{
    if (pTangoData->GetPeriodNumber() >= 0) {
        TString run_suffix = TString::Format("_p%d_r%d", pTangoData->GetPeriodNumber(), pTangoData->GetStartRun());
        if (pTangoData->GetEndRun() != pTangoData->GetStartRun())
            run_suffix += TString::Format("_%d", pTangoData->GetEndRun());
        return run_suffix;
    }
 
    if ((pTangoData->GetStartDate() == "") || (pTangoData->GetEndDate() == ""))
        return "";
    TDatime start_date(pTangoData->GetStartDate()), end_date(pTangoData->GetEndDate());
    return TString::Format("_t%d_%04d_%d_%04d", start_date.GetDate(), start_date.GetTime() / 100, end_date.GetDate(),
                           end_date.GetTime() / 100);
}
 
// non-user function GetDataName returns the name of the Tango parameter used in the canvas names:
// "domain_member_attribute" with the run range or time interval (e.g. "fhcal_hv_1_vch_2_1_p9_r9696_9730")
static TString GetDataName(TangoData* pTangoData)
{
    return GetSourceName(pTangoData) + "_" + pTangoData->GetParameterName() + GetRangeSuffix(pTangoData);
}
 
// non-user function GetArrayDataName returns the name of the set of Tango parameters used in the canvas names:
// the name of the first parameter + "_to_" + the name of the last one; if domain, member and ranges of the parameters
// are the same, only the attribute of the last one is added, e.g. "fhcal_hv_1_vch_2_1_to_vch_2_10_p9_r9696_9730"
static TString GetArrayDataName(vector<TangoData*>& vecTangoData)
{
    TangoData *pFirst = vecTangoData.front(), *pLast = vecTangoData.back();
    if (vecTangoData.size() == 1)
        return GetDataName(pFirst);
 
    if ((GetSourceName(pFirst) == GetSourceName(pLast)) && (GetRangeSuffix(pFirst) == GetRangeSuffix(pLast)))
        return GetSourceName(pFirst) + "_" + pFirst->GetParameterName() + "_to_" + pLast->GetParameterName()
               + GetRangeSuffix(pFirst);
 
    return GetDataName(pFirst) + "_to_" + GetDataName(pLast);
}
 
// non-user function GetArrayTitle returns the title of the set of Tango parameters for the graphs:
// the full names of the first and last parameters and the number of the parameters,
// e.g. "fhcal:vch_2_1 - vch_2_10 (hv_1), 10 channels" if the system and member are the same,
// or "gem:vmon_0 (mod_0) - gem:vmon_11 (mod_2), 24 channels"
static TString GetArrayTitle(vector<TangoData*>& vecTangoData)
{
    TangoData *pFirst = vecTangoData.front(), *pLast = vecTangoData.back();
    if (vecTangoData.size() == 1)
        return pFirst->GetFullName();
 
    TString title;
    if ((pFirst->GetSystemName() == pLast->GetSystemName()) && (pFirst->GetMemberName() == pLast->GetMemberName())) {
        title = pFirst->GetSystemName() + ":" + pFirst->GetParameterName() + " - " + pLast->GetParameterName();
        if (pFirst->GetMemberName() != "")
            title += " (" + pFirst->GetMemberName() + ")";
    } else
        title = pFirst->GetFullName() + " - " + pLast->GetFullName();
 
    return title + TString::Format(", %zu channels", vecTangoData.size());
}
 
// non-user function CreateTangoCanvas creates a canvas named by the displayed data and the kind of visualization,
// e.g. "fhcal_hv_1_vch_2_1_multigraph3d"; a canvas with the same name (the same data and view) is replaced
static TCanvas* CreateTangoCanvas(TString data_name, TString view_name)
{
    TString canvas_name = data_name + "_" + view_name;
    // only letters, digits and underscores to use the canvas name in the ROOT interpreter
    for (Ssiz_t i = 0; i < canvas_name.Length(); i++)
        if (!isalnum(canvas_name[i]))
            canvas_name[i] = '_';
 
    return new TCanvas(canvas_name, canvas_name, 800, 600);
}
 
// Function displays hardware vector data obtained from Tango, e.g. FHCal voltage in time interval, graphically as 2D
// Surface Graph Parameter: y_axis - label of Y axis
void TangoData::PrintTangoDataSurface(const char* y_axis)
{
    if (arrTangoData == nullptr) {
        cout << "ERROR: Tango parameter has not been obtained" << endl;
        return;
    }
 
    TCanvas* c1 = CreateTangoCanvas(GetDataName(this), "surface");
    TGraph2D* tango_graph = new TGraph2D();
    tango_graph->SetTitle(arrTangoData->GetName());
 
    int par_length = 0;
    for (int i = 0; i < arrTangoData->GetEntriesFast(); i++) {
        TangoTimeParameter* pParameter = (TangoTimeParameter*)arrTangoData->At(i);
 
        par_length = pParameter->double_parameter_value.size();
        // cout<<"Parameter length = "<<par_length<<endl;
        for (int j = 0; j < par_length; j++) {
            int cur_time = pParameter->parameter_time.Convert();
            double value = pParameter->double_parameter_value[j];
            // cout<<x<<" "<<y<<" "<<z<<endl;
            tango_graph->SetPoint(i * par_length + j, cur_time, j + 1, value);
        }
    }
 
    tango_graph->Draw("SURF1");
    gPad->Update();
 
    tango_graph->GetXaxis()->SetTitle("time");
    tango_graph->GetXaxis()->CenterTitle();
    tango_graph->GetXaxis()->SetTitleOffset(1.9);
    tango_graph->GetXaxis()->SetLabelSize(0.025);
    tango_graph->GetXaxis()->SetLabelOffset(0.009);
    tango_graph->GetXaxis()->SetNdivisions(-503);
 
    tango_graph->GetYaxis()->SetTitle(y_axis);
    tango_graph->GetYaxis()->CenterTitle();
    tango_graph->GetYaxis()->SetTitleOffset(1.9);
    tango_graph->GetYaxis()->SetLabelSize(0.025);
    tango_graph->GetYaxis()->SetLabelOffset(0.001);
    tango_graph->GetYaxis()->CenterLabels();
    tango_graph->GetYaxis()->SetNdivisions(par_length + 1, 0, 0);
 
    tango_graph->GetZaxis()->SetLabelSize(0.025);
 
    // form X-axis with time ticks
    tango_graph->GetXaxis()->SetTimeDisplay(1);
    tango_graph->GetXaxis()->SetTimeFormat("%Y.%m.%d %H:%M");
    tango_graph->GetXaxis()->SetTimeOffset(0, "local");
 
    c1->Modified();
 
    return;
}
 
// non-user function AddStepPoint adds a new point to the graph drawn as steps: Tango time points are transitions
// to new values, so the previous value is held (horizontal line) up to the time point of the new value
static void AddStepPoint(TGraph& graph, double x, double y)
{
    int n = graph.GetN();
    if ((n > 0) && (graph.GetY()[n - 1] != y)) {
        double previous_y = graph.GetY()[n - 1];
        graph.SetPoint(n, x, previous_y);
        n++;
    }
    graph.SetPoint(n, x, y);
}
 
// Function PrintTangoDataMulti3D display hardware vector data obtained from Tango, e.g. FHCal voltage in time interval,
// graphically as a set of Line Graphs Parameter: tango_data - TObjArray with TangoTimeParameter objects obtained from
// 'GetTangoParameter' function
int TangoData::PrintTangoDataMultiGraph(const char* y_axis, bool is3D)
{
    if (arrTangoData == nullptr) {
        cout << "ERROR: Tango parameter has not been obtained" << endl;
        return -1;
    }
 
    if (arrTangoData->GetEntries() < 1) {
        cout << "WARNING: There are no elements in the Tango array" << endl;
        return -2;
    }
 
    TCanvas* c1 = CreateTangoCanvas(GetDataName(this), is3D ? "multigraph3d" : "multigraph");
 
    // cout<<"Tango data array size = "<<arrTangoData->GetEntries()<<endl;
    int par_length = ((TangoTimeParameter*)arrTangoData->At(0))->double_parameter_value.size();
    // cout<<"par_length = "<<par_length<<endl;
    TGraph* tango_graphs = new TGraph[par_length]();
    gRandom->SetSeed();
    for (int j = 0; j < par_length; j++) {
        Int_t color = gRandom->Integer(50);
        if ((color == 0) || (color == 10) || ((color > 16) && (color < 20)))
            color += 20;
        tango_graphs[j].SetLineColor(color);
    }
 
    // the 3D view does not support time display, so time is shown in hours from the start date
    UInt_t start_time = TDatime(strStartDate).Convert();
    for (int i = 0; i < arrTangoData->GetEntriesFast(); i++) {
        TangoTimeParameter* pParameter = (TangoTimeParameter*)arrTangoData->At(i);
        par_length = pParameter->double_parameter_value.size();
        for (int j = 0; j < par_length; j++) {
            UInt_t cur_time = pParameter->parameter_time.Convert();
            double x = is3D ? ((double)cur_time - start_time) / 3600 : cur_time;
            double value = pParameter->double_parameter_value[j];
            AddStepPoint(tango_graphs[j], x, value);
        }
    }
 
    TMultiGraph* tango_multi = new TMultiGraph();
    tango_multi->SetTitle(arrTangoData->GetName());
    for (int j = 0; j < par_length; j++) {
        tango_multi->Add(&tango_graphs[j]);
        tango_graphs[j].SetTitle(TString::Format("%d", j));
        tango_graphs[j].SetLineWidth(3);
    }
 
    TString draw_par = "AL";
    if (is3D)
        draw_par += "3D";
    tango_multi->Draw(draw_par.Data());
    gPad->Update();
 
    if (!is3D) {
        tango_multi->GetXaxis()->SetTitle("time");
        tango_multi->GetXaxis()->CenterTitle();
        tango_multi->GetXaxis()->SetTitleOffset(1.3);
        tango_multi->GetXaxis()->SetLabelSize(0.025);
        tango_multi->GetXaxis()->SetLabelOffset(0.009);
        tango_multi->GetXaxis()->SetNdivisions(-503);
        // form X-axis with time ticks
        tango_multi->GetXaxis()->SetTimeDisplay(1);
        tango_multi->GetXaxis()->SetTimeFormat("%Y.%m.%d %H:%M");
        tango_multi->GetXaxis()->SetTimeOffset(0, "local");
 
        tango_multi->GetYaxis()->SetTitle(y_axis);
        tango_multi->GetYaxis()->CenterTitle();
        tango_multi->GetYaxis()->SetTitleOffset(1.3);
        tango_multi->GetYaxis()->SetLabelSize(0.025);
        tango_multi->GetYaxis()->SetLabelOffset(0.001);
        tango_multi->GetYaxis()->CenterLabels();
        // gr->GetYaxis()->SetNdivisions(10, 0, 0);
    }
    // the titles are passed to the 3D frame: X axis title - to the time axis, Y axis title - to the value axis
    else
    {
        tango_multi->GetXaxis()->SetTitle(TString::Format("time, hours from %s", strStartDate.Data()));
        tango_multi->GetYaxis()->SetTitle(y_axis);
    }
 
    TLegend* pLegend = c1->BuildLegend(0.92, 0.77, 0.99, 0.98, "");
    pLegend->SetMargin(0.80);
 
    c1->Modified();
    return 0;
}
 
// Function displays a set of "simple" parameters obtained from Tango, e.g. GEMs high voltages voltage, graphically as a
// set of Line Graphs
int TangoData::PrintTangoArrayMultiGraph(vector<TangoData*> vecTangoData, const char* y_axis, bool is3D)
{
    if (vecTangoData.size() < 1) {
        cout << "WARNING: There are no parameters in the specified array" << endl;
        return -1;
    }
 
    // check all the parameters before drawing
    for (const auto& current_parameter : vecTangoData) {
        if ((current_parameter->GetTangoData() == nullptr) || (current_parameter->GetTangoData()->IsEmpty())) {
            cout << "ERROR: There are no elements in the parameter (" << current_parameter->GetFullName() << ")"
                 << endl;
            return -2;
        }
 
        if ((((TangoTimeParameter*)current_parameter->GetTangoData()->At(0))->double_parameter_value.size()) != 1) {
            cout << "ERROR: the parameter " << current_parameter->GetFullName() << " must have single value" << endl;
            return -3;
        }
    }
 
    // cout<<"Tango data array size = "<<vecTangoData.size()<<endl;
    int par_length = vecTangoData.size();
    // cout<<"par_length = "<<par_length<<endl;
 
    TCanvas* c1 = CreateTangoCanvas(GetArrayDataName(vecTangoData), is3D ? "multigraph3d" : "multigraph");
    TGraph* tango_graphs = new TGraph[par_length]();
    gRandom->SetSeed();
    int j;
    for (j = 0; j < par_length; j++) {
        Int_t color = gRandom->Integer(50);
        if ((color == 0) || (color == 10) || ((color > 16) && (color < 20)))
            color += 20;
        tango_graphs[j].SetLineColor(color);
    }
 
    // the 3D view does not support time display, so time is shown in hours from the start date of the first parameter
    TString start_date = vecTangoData[0]->GetStartDate();
    UInt_t start_time = TDatime(start_date).Convert();
    j = 0;
    for (const auto& current_parameter : vecTangoData) {
        TObjArray* arrTangoData = current_parameter->GetTangoData();
        for (int i = 0; i < arrTangoData->GetEntriesFast(); i++) {
            UInt_t cur_time = ((TangoTimeParameter*)arrTangoData->At(i))->parameter_time.Convert();
            double x = is3D ? ((double)cur_time - start_time) / 3600 : cur_time;
            double value = ((TangoTimeParameter*)arrTangoData->At(i))->double_parameter_value[0];
            AddStepPoint(tango_graphs[j], x, value);
        }
        j++;
    }
 
    TMultiGraph* tango_multi = new TMultiGraph();
    tango_multi->SetTitle(GetArrayTitle(vecTangoData));
    for (j = 0; j < par_length; j++) {
        tango_multi->Add(&tango_graphs[j]);
        tango_graphs[j].SetTitle(TString::Format("%d", j));
        tango_graphs[j].SetLineWidth(3);
    }
 
    TString draw_par = "AL";
    if (is3D)
        draw_par += "3D";
    tango_multi->Draw(draw_par.Data());
    gPad->Update();
 
    if (!is3D) {
        tango_multi->GetXaxis()->SetTitle("time");
        tango_multi->GetXaxis()->CenterTitle();
        tango_multi->GetXaxis()->SetTitleOffset(1.3);
        tango_multi->GetXaxis()->SetLabelSize(0.025);
        tango_multi->GetXaxis()->SetLabelOffset(0.009);
        tango_multi->GetXaxis()->SetNdivisions(-503);
        // form X-axis with time ticks
        tango_multi->GetXaxis()->SetTimeDisplay(1);
        tango_multi->GetXaxis()->SetTimeFormat("%Y.%m.%d %H:%M");
        tango_multi->GetXaxis()->SetTimeOffset(0, "local");
 
        tango_multi->GetYaxis()->SetTitle(y_axis);
        tango_multi->GetYaxis()->CenterTitle();
        tango_multi->GetYaxis()->SetTitleOffset(1.3);
        tango_multi->GetYaxis()->SetLabelSize(0.025);
        tango_multi->GetYaxis()->SetLabelOffset(0.001);
        tango_multi->GetYaxis()->CenterLabels();
        // gr->GetYaxis()->SetNdivisions(10, 0, 0);
    }
    // the titles are passed to the 3D frame: X axis title - to the time axis, Y axis title - to the value axis
    else
    {
        tango_multi->GetXaxis()->SetTitle(TString::Format("time, hours from %s", start_date.Data()));
        tango_multi->GetYaxis()->SetTitle(y_axis);
    }
 
    TLegend* pLegend = c1->BuildLegend(0.92, 0.77, 0.99, 0.98, "");
    pLegend->SetMargin(0.80);
 
    c1->Modified();
    return 0;
}
 
/** Function displays a set of "simple" parameters obtained from Tango, e.g. FHCal or GEM high voltages, graphically
 *  as 2D Surface (X - time, Y - channel, i.e. index of the parameter in the array, Z - value of the parameter)
 *  The time interval of the first parameter is divided into equal time bins, and every bin is filled with
 *  the time-weighted average value of the channel in the bin (every value is valid up to the next time point)
 *  Parameters:
 *  z_axis - label of Z axis (parameter values), y_axis - label of Y axis (channels)
 *  draw_option - draw option of the 2D histogram: "SURF1" - surface (default), "LEGO2" - columns,
 *                "COLZ" - 2D color map, etc.
 *  time_bins - number of the time bins
 *  Returns: 0 - in case of the success, < 0 - if an error occured
 **/
int TangoData::PrintTangoArraySurface(vector<TangoData*> vecTangoData,
                                      const char* z_axis,
                                      const char* y_axis,
                                      const char* draw_option,
                                      int time_bins)
{
    if (vecTangoData.size() < 1) {
        cout << "WARNING: There are no parameters in the specified array" << endl;
        return -1;
    }
    if (time_bins < 1) {
        cout << "ERROR: the number of time bins should be greater than 0" << endl;
        return -2;
    }
 
    // check all the parameters before drawing
    for (const auto& current_parameter : vecTangoData) {
        if ((current_parameter->GetTangoData() == nullptr) || (current_parameter->GetTangoData()->IsEmpty())) {
            cout << "ERROR: There are no elements in the parameter (" << current_parameter->GetFullName() << ")"
                 << endl;
            return -3;
        }
 
        if ((((TangoTimeParameter*)current_parameter->GetTangoData()->At(0))->double_parameter_value.size()) != 1) {
            cout << "ERROR: the parameter " << current_parameter->GetFullName() << " must have single value" << endl;
            return -4;
        }
    }
 
    // the time interval is taken from the first parameter
    UInt_t start_time = TDatime(vecTangoData[0]->GetStartDate()).Convert();
    UInt_t end_time = TDatime(vecTangoData[0]->GetEndDate()).Convert();
    if (end_time <= start_time) {
        cout << "ERROR: the end time should be greater than the start time of the parameters" << endl;
        return -5;
    }
    int channel_count = vecTangoData.size();
    double bin_width = (double)(end_time - start_time) / time_bins;
 
    // the histogram is not added to the current directory to avoid replacing of the previous one
    bool add_directory = TH1::AddDirectoryStatus();
    TH1::AddDirectory(kFALSE);
    TH2D* tango_hist = new TH2D("tango_surface", GetArrayTitle(vecTangoData), time_bins, start_time, end_time,
                                channel_count, -0.5, channel_count - 0.5);
    TH1::AddDirectory(add_directory);
 
    vector<double> bin_sum(time_bins), bin_sec(time_bins);
    for (int j = 0; j < channel_count; j++) {
        TangoData* current_parameter = vecTangoData[j];
        TObjArray* arrParameterData = current_parameter->GetTangoData();
        UInt_t data_start = TDatime(current_parameter->GetStartDate()).Convert();
        UInt_t data_end = TDatime(current_parameter->GetEndDate()).Convert();
        fill(bin_sum.begin(), bin_sum.end(), 0);
        fill(bin_sec.begin(), bin_sec.end(), 0);
        for (int i = 0; i < arrParameterData->GetEntriesFast(); i++) {
            UInt_t value_start, value_end;
            current_parameter->GetValuePeriod(i, data_start, data_end, value_start, value_end);
            double value = ((TangoTimeParameter*)arrParameterData->At(i))->double_parameter_value[0];
 
            // add the value weighted by its time overlapped with every time bin
            int first_bin = max(0, (int)floor(((double)value_start - start_time) / bin_width));
            int last_bin = min(time_bins - 1, (int)floor(((double)value_end - start_time) / bin_width));
            for (int b = first_bin; b <= last_bin; b++) {
                double bin_start = start_time + b * bin_width, bin_end = bin_start + bin_width;
                double overlap = min((double)value_end, bin_end) - max((double)value_start, bin_start);
                if (overlap <= 0)
                    continue;
                bin_sum[b] += value * overlap;
                bin_sec[b] += overlap;
            }
        }
 
        for (int b = 0; b < time_bins; b++)
            if (bin_sec[b] > 0)
                tango_hist->SetBinContent(b + 1, j + 1, bin_sum[b] / bin_sec[b]);
    }
 
    // the view name is the draw option, e.g. "surf1" or "lego2"
    TString view_name(draw_option);
    view_name.ToLower();
    TCanvas* c1 = CreateTangoCanvas(GetArrayDataName(vecTangoData), view_name);
    tango_hist->SetStats(kFALSE);
    if (tango_hist->GetMinimum() > 0)
        tango_hist->SetMinimum(0);
 
    // 3D view ("SURF", "LEGO") or 2D view (e.g. "COLZ" color map), where the right margin is used for the palette
    bool is3D = view_name.Contains("surf") || view_name.Contains("lego");
    if (!is3D)
        c1->SetRightMargin(0.15);
 
    tango_hist->GetXaxis()->SetTitle("time");
    tango_hist->GetXaxis()->CenterTitle();
    tango_hist->GetXaxis()->SetTitleOffset(is3D ? 1.9 : 1.2);
    tango_hist->GetXaxis()->SetLabelSize(0.025);
    tango_hist->GetXaxis()->SetNdivisions(-503);
    // form X-axis with time ticks
    tango_hist->GetXaxis()->SetTimeDisplay(1);
    tango_hist->GetXaxis()->SetTimeFormat("%Y.%m.%d %H:%M");
    tango_hist->GetXaxis()->SetTimeOffset(0, "local");
 
    tango_hist->GetYaxis()->SetTitle(y_axis);
    tango_hist->GetYaxis()->CenterTitle();
    tango_hist->GetYaxis()->SetTitleOffset(is3D ? 1.9 : 1.0);
    tango_hist->GetYaxis()->SetLabelSize(0.025);
 
    tango_hist->GetZaxis()->SetTitle(z_axis);
    tango_hist->GetZaxis()->CenterTitle();
    tango_hist->GetZaxis()->SetTitleOffset(is3D ? 1.5 : 1.2);
    tango_hist->GetZaxis()->SetLabelSize(0.025);
 
    tango_hist->Draw(draw_option);
    c1->Modified();
    return 0;
}
 
// Function calculates and returns average value for Tango data array (result vector with size > 1 is used in case of
// many channels)
vector<double> TangoData::GetAverageTangoData()
{
    vector<double> result;
    if (arrTangoData == nullptr) {
        cout << "ERROR: Tango parameter has not been obtained" << endl;
        return result;
    }
 
    if (iVerbose)
        cout << "strStartDateAvg = " << strStartDate.Data() << endl;
    if (iVerbose)
        cout << "strEndDateAvg = " << strEndDate.Data() << endl;
    int time_count = arrTangoData->GetEntriesFast();
    TDatime start_date(strStartDate), end_date(strEndDate);
 
    // get arithmetic average value
    if ((IsOldMySQL) || (time_count < 2)) {
        for (int i = 0; i < time_count; i++) {
            TangoTimeParameter* pParameter = (TangoTimeParameter*)arrTangoData->At(i);
            // cycle for Tango parameter array (from 1 to array size)
            for (size_t j = 0; j < pParameter->double_parameter_value.size(); j++) {
                if (i == 0)
                    result.push_back(pParameter->double_parameter_value[j]);
                else
                    result[j] += pParameter->double_parameter_value[j];
            }
        }
 
        for (size_t j = 0; j < result.size(); j++)
            result[j] /= time_count;
    }
    // get time-weighted average value over the whole time interval (for the new architecture of the Tango database)
    else
        result = GetTimeWeightedAverage(vector<TangoTimeInterval>{TangoTimeInterval(start_date, end_date)});
 
    return result;
}
 
// Function calculates and returns time-weighted average value for Tango data array only over the time of the runs,
// i.e. the gaps between runs are excluded (result vector with size > 1 is used in case of many channels)
// Every Tango value is considered valid from its time point to the next one
// It is available only if the object was created by the Run Range Constructor
vector<double> TangoData::GetRunAverageTangoData()
{
    if (arrTangoData == nullptr) {
        cout << "ERROR: Tango parameter has not been obtained" << endl;
        return vector<double>();
    }
    if (vecRunIntervals.empty()) {
        cout << "ERROR: there are no run time intervals, the object should be created by the Run Range Constructor"
             << endl;
        return vector<double>();
    }
 
    return GetTimeWeightedAverage(vecRunIntervals);
}
 
// non-user function GetTimeWeightedAverage calculates average value for Tango data array over the given time
// intervals, where every value is weighted by the length of its validity period inside the intervals
// Every Tango time point is a transition to a new value: the value is valid from its time point to the next one,
// the first value is also used from the start date, the last one - up to the end date
// Returns empty vector in case of errors
vector<double> TangoData::GetTimeWeightedAverage(const vector<TangoTimeInterval>& time_intervals)
{
    vector<double> result;
    int time_count = arrTangoData->GetEntriesFast();
    if (time_count == 0) {
        cout << "ERROR: there are no elements in the Tango array" << endl;
        return result;
    }
 
    size_t channel_count = ((TangoTimeParameter*)arrTangoData->At(0))->double_parameter_value.size();
    result.assign(channel_count, 0);
    UInt_t data_start = TDatime(strStartDate).Convert(), data_end = TDatime(strEndDate).Convert();
    double total_sec = 0;
    for (int i = 0; i < time_count; i++) {
        TangoTimeParameter* pParameter = (TangoTimeParameter*)arrTangoData->At(i);
        if (pParameter->double_parameter_value.size() != channel_count) {
            cout << "ERROR: channel count of the Tango parameter is not constant during the time interval" << endl;
            result.clear();
            return result;
        }
 
        UInt_t value_start, value_end;
        GetValuePeriod(i, data_start, data_end, value_start, value_end);
 
        // add the value weighted by its time overlapped with every interval
        for (const auto& time_interval : time_intervals) {
            UInt_t overlap_start = max(value_start, time_interval.start_time.Convert());
            UInt_t overlap_end = min(value_end, time_interval.end_time.Convert());
            if (overlap_end <= overlap_start)
                continue;
 
            UInt_t sec = overlap_end - overlap_start;
            for (size_t j = 0; j < channel_count; j++)
                result[j] += pParameter->double_parameter_value[j] * sec;
            total_sec += sec;
        }
    }
 
    if (total_sec == 0) {
        cout << "ERROR: the total time of the intervals for the average value is equal 0" << endl;
        result.clear();
        return result;
    }
    if (iVerbose)
        cout << "Total time of " << time_intervals.size() << " interval(s) used for the average value = " << total_sec
             << " s" << endl;
 
    for (size_t j = 0; j < channel_count; j++)
        result[j] /= total_sec;
 
    return result;
}
 
// non-user function GetValuePeriod gets the time period where the value of the i-th Tango time point is valid:
// from its time point to the next one, the first value is also used from the start date (data_start),
// the last one - up to the end date (data_end)
void TangoData::GetValuePeriod(int i, UInt_t data_start, UInt_t data_end, UInt_t& value_start, UInt_t& value_end)
{
    value_start = ((TangoTimeParameter*)arrTangoData->At(i))->parameter_time.Convert();
    value_end = data_end;
    if ((i == 0) && (data_start < value_start))
        value_start = data_start;
    if (i < arrTangoData->GetEntriesFast() - 1)
        value_end = ((TangoTimeParameter*)arrTangoData->At(i + 1))->parameter_time.Convert();
}
 
/** Function SearchTangoIntervals gets time intervals for defined condition on the parameter values
 *  NOTE: it works only if channel count is constant during given time period
 *  Parameters:
 *  condition - condition of time interval sampling, default: conditionEqual (the possible list is presented above in
 *              'enumConditions', except conditionLike, conditionNull and conditionNotNull)
 *  value - numeric value for the condition with which the comparison is performed, default: 1 (true);
 *          boolean values of the parameter are compared as 0 (false) and 1 (true)
 *  mapChannel - vector of integer values (map) to change the order of result TObjArray-s in the common result array,
 *               if, for example, channels go in a different sequence; nullptr - if not used
 *  Returns common TObjArray with TObjArray objects containing TangoTimeInterval for every channel
 *  (i.e. conditionally TObjArray<TObjArray<TangoTimeInterval*>>). If there are no intervals found, it returns
 *  an empty TObjArray with zero elements. In case of errors it returns nullptr
 **/
TObjArray* TangoData::SearchTangoIntervals(enumConditions condition, double value, vector<int>* mapChannel)
{
    if (arrTangoData == nullptr) {
        cout << "ERROR: Tango parameter has not been obtained" << endl;
        return nullptr;
    }
    if ((condition == conditionLike) || (condition == conditionNull) || (condition == conditionNotNull)) {
        cout << "ERROR: comparison operator in the searching of intervals is not supported" << endl;
        return nullptr;
    }
 
    TObjArray* pTimeIntervals = new TObjArray();
    pTimeIntervals->SetOwner(kTRUE);
 
    // if there is no points in the Tango period then return empty common TObjArray (without any elements)
    int time_count = arrTangoData->GetEntriesFast();
    if (time_count == 0)
        return pTimeIntervals;
 
    // TObjArray with the found time intervals for every channel
    size_t channel_count = ((TangoTimeParameter*)arrTangoData->At(0))->double_parameter_value.size();
    for (size_t j = 0; j < channel_count; j++) {
        TObjArray* pChannel = new TObjArray();
        pChannel->SetOwner(kTRUE);
        pTimeIntervals->Add(pChannel);
    }
 
    // add the found time interval of the channel to the result array considering the channel map
    auto AddInterval = [&](size_t j, TDatime start_interval, TDatime end_interval) {
        int real_channel = j;
        if (mapChannel != nullptr) {
            if (mapChannel->size() > j) {
                real_channel = mapChannel->at(j);
                if (pTimeIntervals->GetEntriesFast() <= real_channel) {
                    cout << "CRITICAL WARNING: Tango array size is less than the corrected channel: " << real_channel
                         << endl;
                    return;
                }
            } else
                cout << "CRITICAL WARNING: map channel size is less than the current channel: " << j << endl;
        }
        ((TObjArray*)pTimeIntervals->At(real_channel))->Add(new TangoTimeInterval(start_interval, end_interval));
    };
    // start time of the interval beginning at the given time point (the middle between the points for old MySQL)
    auto GetStartTime = [&](int start_i) {
        TDatime start_interval = ((TangoTimeParameter*)arrTangoData->At(start_i))->parameter_time;
        if ((start_i > 0) && (IsOldMySQL)) {
            TDatime previous_time = ((TangoTimeParameter*)arrTangoData->At(start_i - 1))->parameter_time;
            start_interval.Set((start_interval.Convert() + previous_time.Convert()) / 2);
        }
        return start_interval;
    };
 
    // start indices of the current intervals satisfying the condition for every channel (-1 - no interval)
    vector<int> vecStart(channel_count, -1);
    for (int i = 0; i < time_count; i++) {
        TangoTimeParameter* pParameter = (TangoTimeParameter*)arrTangoData->At(i);
        if (pParameter->double_parameter_value.size() != channel_count) {
            cout << "ERROR: channel count of the Tango parameter is not constant during the time interval" << endl;
            delete pTimeIntervals;
            return nullptr;
        }
 
        // cycle for array parameter data (if the parameter is an array) and checking the given condition
        for (size_t j = 0; j < channel_count; j++) {
            double cur_value = pParameter->double_parameter_value[j];
            bool isCondition = false;
            switch (condition) {
                case conditionLess:
                    isCondition = cur_value < value;
                    break;
                case conditionLessOrEqual:
                    isCondition = cur_value <= value;
                    break;
                case conditionEqual:
                    isCondition = cur_value == value;
                    break;
                case conditionNotEqual:
                    isCondition = cur_value != value;
                    break;
                case conditionGreater:
                    isCondition = cur_value > value;
                    break;
                case conditionGreaterOrEqual:
                    isCondition = cur_value >= value;
                    break;
                default:
                    break;
            }
 
            // save the start index of a new interval satisfying the condition
            if (isCondition) {
                if (vecStart[j] < 0)
                    vecStart[j] = i;
            }
            // the interval has ended: write it (the end is just before the current time point)
            else if (vecStart[j] >= 0)
            {
                UInt_t uiEndTime = pParameter->parameter_time.Convert();
                TDatime end_interval(uiEndTime - 1);
                if (IsOldMySQL)
                    end_interval.Set(
                        (uiEndTime + ((TangoTimeParameter*)arrTangoData->At(i - 1))->parameter_time.Convert()) / 2);
                AddInterval(j, GetStartTime(vecStart[j]), end_interval);
                vecStart[j] = -1;
            }
        }   // for (size_t j = 0; j < channel_count; j++)
    }   // for (int i = 0; i < time_count; i++)
 
    // write the intervals lasting up to the end of the time period
    TDatime end_time = ((TangoTimeParameter*)arrTangoData->At(time_count - 1))->parameter_time;
    for (size_t j = 0; j < channel_count; j++)
        if (vecStart[j] >= 0)
            AddInterval(j, GetStartTime(vecStart[j]), end_time);
 
    return pTimeIntervals;
}
 
/** Function displays (in console) time intervals obtained from Tango for a defined condition
 *  Parameters:
 *  tango_intervals - TObjArray with TObjArray objects containing TangoTimeInterval objects obtained from
 *'SearchTangoIntervals' function channel_name - name of the dimension to display on the screen, default: Channel
 *  isShowOnlyExists - if true, print only intervals which satisfy the condition (skip empty intervals)
 **/
void TangoData::PrintTangoIntervalConsole(TObjArray* tango_intervals, TString channel_name, bool isShowOnlyExists)
{
    for (int i = 0; i < tango_intervals->GetEntriesFast(); i++) {
        TObjArray* pChannel = (TObjArray*)tango_intervals->At(i);
        if (pChannel->GetEntriesFast() == 0) {
            if (!isShowOnlyExists)
                cout << channel_name.Data() << " " << i << ":" << endl
                     << "   No intervals correspond to the specified conditions" << endl;
            continue;
        } else
            cout << channel_name.Data() << " " << i << ":" << endl;
        for (int j = 0; j < pChannel->GetEntriesFast(); j++) {
            TangoTimeInterval* pInterval = (TangoTimeInterval*)pChannel->At(j);
            cout << "   " << pInterval->start_time.AsSQLString();
            cout << " - ";
            cout << pInterval->end_time.AsSQLString();
        }
        cout << endl;
    }
 
    return;
}
 
// delete Tango parameter
void TangoData::DeleteTangoParameter()
{
    IsOldMySQL = false;
    strSystemName = "", strParameterName = "", strStartDate = "", strEndDate = "";
    iPeriodNumber = -1, iStartRun = -1, iEndRun = -1;
    vecRunIntervals.clear();
    if (arrTangoData != nullptr) {
        arrTangoData->Delete();
        delete arrTangoData;
        arrTangoData = nullptr;
    }
}