VData.cxx

Go to the documentation of this file.

/**
 * @file VData.cxx
 * @author zhangzeheng ([email protected])
 * @brief provides definitions of functions to handle our cached hv info.
 * @version 0.1
 * @date 2022-01-19
 * 
 * @copyright Copyright (c) 2022
 * 
 */
 
#include <MdcHvDropSvc/VData.h>
#include <algorithm>
#include <iostream>
//#include "GaudiKernel/MsgStream.h"
 
bool VData::isValid(Time_t time) const{
    time+=time_offset; 
    if (time > Boundary_time_High || time < Boundary_time_Low) {
        return false;
    }
    std::vector<Time_t>::const_iterator iter = std::upper_bound(timeVector.begin(), timeVector.end(), time);
    int index2                         = iter - timeVector.begin();
    Time_t time2 = timeVector[index2], time1 = timeVector[index2 - 1];
    if (abs(time - time2) > 10 && abs(time - time1) > 10){
        return false;
    }
    return true;
}
 
VDataItem VData::getVoltage(Time_t time) {
    VDataItem voltage;
    time+=time_offset; 
    if (time > Boundary_time_High || time < Boundary_time_Low) {
        //MsgStream log(messageService(), name());
        //log << MSG::INFO << "MdcHvDropSvc::initialize()" << endreq;
        std::cerr << "Error! time exceeds boundary. up:down"<<getUpperBoundaryEventTime()<<":"<<getLowerBoundaryEventTime()<<std::endl;
        std::cerr<< "this should not happen. check your code that matters with VData"<<std::endl;
        //if (Boundary_time_High==Boundary_time_Low && Boundary_time_Low==0){
        //    std::cerr << "you need to call updateBoundary() after inserting items.";
        //}
        //std::cerr << std::endl;
        return voltage;
    }
    std::vector<Time_t>::iterator iter = std::upper_bound(timeVector.begin(), timeVector.end(), time);
    int index2                         = iter - timeVector.begin();
    Time_t time2 = timeVector[index2], time1 = timeVector[index2 - 1];
    
    VDataItem &voltage2 = VdataVector[index2], &voltage1 = VdataVector[index2 - 1];
    for (size_t i = 0; i < voltage.size(); i++) {
        voltage[i] = voltage1[i] + ((double)(time - time1)) / (time2 - time1) * (voltage2[i] - voltage1[i]);
    }
    return voltage;
}
VData::VData(){
    double a[]={
    1871.65,    1988.291667,    2016.875,   2017.791667,    2044.25,    2029.25,    2016.75,    1986.5,     2111,       2199,   
    2187.5,     2226,           2214.75,    2233,           2216,       2222.75,    2199.5,     2217.75,    2189.25,    2142.75,    
    2119.5,     2192.25,        2209.5,     2218,           2201,       2211.25,    2227,       2226,       2186.25,    2201.5, 
    2217,       2211.5,         2177,       2191.25,        2192.25,    2135.75,    2133.25,    2200.75,    2218.75,    2204.25,    
    2137.5,     2139.75,        2059.5, 
    };
    voltagesStd=VDataItem::fromArray(a);
    time_offset=6;
    Boundary_time_High=0;
    Boundary_time_Low=0;
}
 
/**
 * @brief throw all cached data. next time you might have to prepare cache again..
 * 
 */
void VData::clear(){
    Boundary_time_High=0;
    Boundary_time_Low=0;
    timeVector.clear();
    VdataVector.clear();
}
 
 
VDataItem VData::getDrop(Time_t time){
    VDataItem voltTripPerc;
    VDataItem voltage=getVoltage(time);
    for (size_t i=0; i<voltage.size(); i++){ 
        voltTripPerc[i]=(voltagesStd[i]-voltage[i])/voltagesStd[i];
    }
    return voltTripPerc;
}
double VData::getAvgDrop(Time_t time){
    VDataItem voltTripPerc=getDrop(time);
    double totalDropPerc=0;
    for (size_t i=0; i<voltTripPerc.size(); i++) totalDropPerc+=voltTripPerc[i];
    return totalDropPerc/voltTripPerc.size();
}
double VData::getAvgDropButVeryDrop(Time_t time){
    VDataItem voltTripPerc=getDrop(time);
    double totalDropPerc=0;
    for (size_t i=0; i<20; i++)                     totalDropPerc+=voltTripPerc[i];
    for (size_t i=25-1; i<voltTripPerc.size(); i++) totalDropPerc+=voltTripPerc[i];
    
    return totalDropPerc/(voltTripPerc.size()-4);
}
/**
 * @brief add a entry to our cache. the entry has to be pushed back in ascending order, 
 * with no gap. inserting a item that is within timeboundary will fail and do nothing.
 * 
 * @param time_HV_SLOWCTRL a time in database time; not event time
 * @param data 
 */
void VData::push_back_sorted(Time_t time_HV_SLOWCTRL, const VDataItem &data) {
    if (time_HV_SLOWCTRL <= Boundary_time_High){ // first check if time is in boundary
    //    std::vector<Time_t>::iterator iter = std::upper_bound(timeVector.begin(), timeVector.end(), time_HV_SLOWCTRL);
    //    if (! (iter == timeVector.end())) {return;} //if found time in vector
        return;
    }
    timeVector.push_back(time_HV_SLOWCTRL);
    VdataVector.push_back(data);
    updateBoundary();
}
 
VDataItem VDataItem::fromArray(const double* item){
    VDataItem out;
    for (size_t i=0; i<VDataItem::size(); i++){
        out[i]=item[i];
    }
    return out;
}