eclWriteLocalDB.cc

/**************************************************************************
 * 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.                  *
 **************************************************************************/
 
#include <framework/database/DBImportObjPtr.h>
#include <framework/database/DBObjPtr.h>
#include <framework/database/DBStore.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/datastore/DataStore.h>
#include <framework/dataobjects/EventMetaData.h>
#include <framework/logging/LogSystem.h>
#include <ecl/dbobjects/ECLCrystalCalib.h>
#include <iostream>
 
using namespace Belle2;
 
namespace {
  void setupDatabase(int exp, int run, int eventNr = 1)
  {
    StoreObjPtr<EventMetaData> evtPtr;
    // simulate the initialize() phase where we can register objects in the DataStore
    DataStore::Instance().setInitializeActive(true);
    evtPtr.registerInDataStore();
    DataStore::Instance().setInitializeActive(false);
    // now construct the event metadata
    evtPtr.construct(eventNr, run, exp);
    // and update the database contents
    DBStore& dbstore = DBStore::Instance();
    dbstore.update();
    // this is only needed it the payload might be intra-run dependent,
    // that is if it might change during one run as well
    dbstore.updateEvent();
  }
}
 
 
int main()
{
 
  std::vector<float> tempCalib;
  std::vector<float> tempCalibUnc;
 
  /*
   float calib = 0.;
   float calibUnc = 0.;
   for (int cellID = 1; cellID <= 8736; cellID++) {
   tempCalib.push_back(calib);
   tempCalibUnc.push_back(calibUnc);
   } */
 
  /* std::ifstream calibFile("refref1.txt");
   float cellIDf, amplitude, toff;
   for(int cellID=1; cellID<=8736; cellID++) {
   calibFile >> cellIDf >> amplitude >> toff;
   if(cellID<=1152) {
   calib = 1.;
   } else {
   calib = 17800./amplitude;
   }
   calibUnc = 0.;
   tempCalib.push_back(calib);
   tempCalibUnc.push_back(calibUnc);
   if(cellID%100==0) {std::cout << cellID << " ampl = " << amplitude << " calib = " << calib << " " << calibUnc << std::endl;}
   } */
 
  /* TFile f("eclCosmicEAlgorithm.root");
   TH1F *CalibvsCrys = (TH1F*)f.Get("CalibvsCrys");
   for(int cellID=1; cellID<=8736; cellID++) {
   if(cellID<1153) {
   calib = 4.06902e-05;
   calibUnc = 0.;
   } else {
   calib = CalibvsCrys->GetBinContent(cellID);
   calibUnc = CalibvsCrys->GetBinError(cellID);
   }
   tempCalib.push_back(calib);
   tempCalibUnc.push_back(calibUnc);
   if(cellID%100==0) {std::cout << "cellID = " << cellID << " calib = " << calib << " +/- " << calibUnc << std::endl; }
   } */
 
  LogConfig* logging = LogSystem::Instance().getLogConfig();
  logging->setLogLevel(LogConfig::c_Debug);
  logging->setDebugLevel(10);
 
  DBObjPtr<Belle2::ECLCrystalCalib> InputCalib("ECLCrystalEnergy");
 
  int experiment = 1002;
  int run = 1;
  setupDatabase(experiment, run);
 
  InputCalib->Dump();
 
  std::vector<float> calibIn;
  std::vector<float> calibInUnc;
  calibIn = InputCalib->getCalibVector();
  calibInUnc = InputCalib->getCalibUncVector();
 
  tempCalib = calibIn;
  tempCalibUnc = calibInUnc;
 
  for (int ic = 0; ic < 9000; ic += 1000) {
    std::cout << "crysID " << ic << " calib = " << tempCalib[ic] << " +/- " << tempCalibUnc[ic] << std::endl;
  }
 
  //..Write out to localdb
  std::cout << "Creating importer" << std::endl;
  Belle2::DBImportObjPtr<Belle2::ECLCrystalCalib> importer("ECLCrystalEnergyGammaGamma");
  importer.construct();
  importer->setCalibVector(tempCalib, tempCalibUnc);
  importer.import(Belle2::IntervalOfValidity(0, 0, -1, -1));
  std::cout << "Successfully wrote payload ECLCrystalEnergyGammaGamma" << std::endl;
}