ARICHDatabaseImporter.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#ifndef ARICHDATABASEIMPORTER_H
#define ARICHDATABASEIMPORTER_H
 
#include <TGraph.h>
#include <TH1.h>
#include <TH2F.h>
#include <TH3F.h>
#include <TTimeStamp.h>
#include <map>
#include <tuple>
#include <vector>
#include <iostream>
#include <string>
#include <framework/database/IntervalOfValidity.h>
#include <arich/dbobjects/tessellatedSolidStr.h>
 
namespace Belle2 {
 
  class ARICHDatabaseImporter {
 
  public:
    ARICHDatabaseImporter(): m_inputFilesHapdQA(), m_inputFilesAsicRoot(), m_inputFilesAsicTxt(), m_inputFilesHapdQE(),
      m_inputFilesFebTest(), m_iov(0, 0, -1, -1) {};
 
    ARICHDatabaseImporter(const std::vector<std::string>& inputFilesHapdQA, const std::vector<std::string>& inputFilesAsicRoot,
                          const std::vector<std::string>& inputFilesAsicTxt, const std::vector<std::string>& inputFilesHapdQE,
                          const std::vector<std::string>& inputFilesFebTest);
 
 
    ARICHDatabaseImporter(int experiment, int run);
 
 
    virtual ~ARICHDatabaseImporter() {};
 
    void SetIOV(int experimentLow, int runLow, int experimentHigh, int runHigh);
 
    void setExperimentAndRun(int experiment, int run);
 
    // classes used in simulation/reconstruction software
 
    void importSimulationParams();
 
    void importReconstructionParams();
 
 
    void printSimulationPar();
 
    void importModulesInfo();
 
    void printModulesInfo();
 
    void setHAPDQE(unsigned modID, double qe = 0.27, bool import = false);
 
    void importGlobalAlignment();
 
    void importMirrorAlignment();
 
    void importAeroTilesAlignment();
 
    void importMergerCoolingGeo();
 
    tessellatedSolidStr readTessellatedSolidVerticesFromDATfile(const std::string& inDATfile);
 
    void importChannelMask();
 
    void importChannelMask(TH1* h);
 
 
    void printChannelMask(bool makeHist = false);
 
    void importChannelMapping();
 
    void printChannelMapping();
 
    void importFEMappings();
 
    void printMergerMapping();
 
    void printCopperMapping();
 
    void printReconstructionPar();
 
    void printGeometryConfig();
 
    void dumpQEMap(bool simple = false);
 
    void dumpHvMappings();
 
    void printFEMappings();
 
    void dumpMergerMapping(bool sn = true);
 
    void dumpModuleNumbering();
 
    void dumpAerogelOpticalProperties(std::string outRootFileName = "ARICH_AerogelOpticalProperties.root");
 
    void importCosmicTestGeometry();
 
    void importGeometryConfig();
 
    void importAeroTilesInfo();
 
    void importAeroRayleighScatteringFit(std::string commentSingleWord = "");
 
    int getAeroTileRing(int slot);
 
    int getAeroTileColumn(int slot);
 
    void printAeroTileInfo();
 
    void printGlobalAlignment();
 
    void printMirrorAlignment();
 
    void printAeroTilesAlignment();
 
    // DAQ classes
 
    void importBiasMappings();
 
    void importHvMappings();
 
    void importNominalBiasVoltages();
 
    void printBiasMappings();
 
    void printHvMappings();
 
    void printNominalBiasVoltages();
 
    void printNominalBiasVoltageForChannel(std::vector<int> channel);
 
    void printHapdPositionFromCrateSlot(int crate, int slot, int channelID);
 
    int getFebDaqSlot(unsigned febSlot);
 
 
    // classes used in conditions DB
 
    void importAerogelInfo(TString coreNameSuffix = "");
 
    void exportAerogelInfo(int verboseLevel = 0);
 
    void importAerogelMap();
 
    void exportAerogelMap();
 
    void importAerogelInfoEventDep();
 
    void exportAerogelInfoEventDep();
 
    void importHapdQA();
 
    void exportHapdQA();
 
    void importAsicInfo();
 
    void importAsicInfoRoot();
 
    void exportAsicInfo();
 
    TTimeStamp timedate(std::string enddate);
 
    TTimeStamp getAsicDate(const std::string& asicSerial, const std::string& type);
 
    std::vector<int> channelsList(std::string badCH);
 
    void importFebTest();
 
    void importFebTestRoot();
 
    std::tuple<std::string, float, float, float> getFebLVtestData(int serial, int lvRun);
 
    std::tuple<std::string, float> getFebHVtestData(int serial, int hvRun);
 
    std::vector<int> getDeadChFEB(const std::string& dna);
 
    TTimeStamp timedate2(std::string time);
 
    std::pair<std::vector<float>, std::vector<float>> getSlopes(int serialNum, const std::string& runSCAN);
 
    std::vector<std::pair<float, float>> getFwhm(int serialNum, const std::string& runSCAN);
 
    std::vector<TH3F*> getFebTestHistograms(const std::string& dna, const std::string& run, int febposition);
 
    TH2F* getFebTestPulse(const std::string& dna, const std::string& run, int febposition);
 
    void exportFebTest();
 
    void importHapdChipInfo();
 
    void exportHapdChipInfo();
 
    void importHapdInfo();
 
    std::vector<int> channelsListHapd(std::string chlist, std::string chipDelay);
 
    int getChannelPosition(const std::string& XY, const std::string& chip_2d, int chipnum);
 
    TGraph* getGraphGainCurrent(const std::string& bomb_aval, const std::string& g_i, const std::string& chip_label, int i, float* HV,
                                float* gain_current);
 
    TH2F* getBiasGraph(const std::string& chip_2d, const std::string& voltage_current, int* chipnum, float* bias_v_i);
 
    void exportHapdInfo();
 
    void importHapdQE();
 
    void exportHapdQE();
 
    void printBiasVoltagesForHapdChip(const std::string& serialNumber);
 
    void printMyParams(const std::string& aeroSerialNumber);
 
    std::map<std::string, float> getAerogelParams(const std::string& aeroSerialNumber);
 
    void importFEBoardInfo();
 
    void exportFEBoardInfo();
 
    void importModuleTest(const std::string& mypath, const std::string& HVtest);
 
    void exportModuleTest(const std::string& HVtest);
 
    void importSensorModuleInfo();
 
    void importSensorModuleMap();
 
    void exportSensorModuleMap();
    void exportSensorModuleMapInfo(int number);
 
    void importMagnetTest();
 
    void exportMagnetTest();
 
    void exportAll();
 
 
  private:
 
    std::vector<std::string> m_inputFilesHapdQA;        
    std::vector<std::string> m_inputFilesAsicRoot;      
    std::vector<std::string> m_inputFilesAsicTxt;       
    std::vector<std::string> m_inputFilesHapdQE;        
    std::vector<std::string> m_inputFilesFebTest;       
    IntervalOfValidity m_iov;
 
    template <typename Container_t>
    inline auto printContainer(const Container_t& rContainer, std::ostream& rStream = std::cout) noexcept -> void
    {
      if (rContainer.empty())
        return void();
 
      rStream << rContainer.front();
      for (auto i = 1ul; i < rContainer.size(); ++i)
        rStream << " - " << rContainer[i];
      rStream << '\n';
    }
 
  };
 
} // Belle2 namespace
#endif