VData.cxx

Go to the documentation of this file.

/**
 * @file VData.cxx
 * @author zhangzeheng (zhangzeheng@ihep.ac.cn)
 * @brief provides definitions of functions to handle our cached hv info.
 * @version 0.1
 * @date 2022-01-19
 *
 * @copyright Copyright (c) 2022
 *
 */
 
#include "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(msgSvc(), name());
    // log << MSG::INFO << "MdcHvDropSvc::initialize()" << endmsg;
    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;
}