CocoaDBMgr Class Reference

#include <CocoaDBMgr.h>

Public Member Functions
bool	DumpCocoaResults ()
	~CocoaDBMgr ()

Static Public Member Functions
static CocoaDBMgr *	getInstance ()

Private Member Functions
std::pair< Alignments *, AlignmentErrorsExtended * >	BuildAlignments (bool bDT)
OpticalAlignments *	BuildOpticalAlignments ()
	CocoaDBMgr ()
AlignTransformErrorExtended *	GetAlignInfoErrorFromOptO (OpticalObject *opto)
AlignTransform *	GetAlignInfoFromOptO (OpticalObject *opto)
double	GetEntryError (const Entry *entry)
double	GetEntryError (const Entry *entry1, const Entry *entry2)
OpticalAlignInfo	GetOptAlignInfoFromOptO (OpticalObject *opto)

Static Private Attributes
static CocoaDBMgr *	instance = nullptr

Detailed Description

Definition at line 35 of file CocoaDBMgr.h.

Constructor & Destructor Documentation

CocoaDBMgr()

CocoaDBMgr::CocoaDBMgr ( )

private

Definition at line 48 of file CocoaDBMgr.cc.

{}

~CocoaDBMgr()

CocoaDBMgr::~CocoaDBMgr ( )

inline

Definition at line 42 of file CocoaDBMgr.h.

{}

Member Function Documentation

BuildAlignments()

std::pair< Alignments *, AlignmentErrorsExtended * > CocoaDBMgr::BuildAlignments ( bool  bDT )

private

Definition at line 303 of file CocoaDBMgr.cc.

                                                                                   {
  Alignments* alignments = new Alignments;
  AlignmentErrorsExtended* alignmentErrors = new AlignmentErrorsExtended;
 
  //read
  static std::vector<OpticalObject*> optolist = Model::OptOList();
  static std::vector<OpticalObject*>::const_iterator ite;
  for (ite = optolist.begin(); ite != optolist.end(); ++ite) {
    if ((*ite)->type() == "system")
      continue;
    std::cout << "CocoaDBMgr::BuildAlignments getCmsswID " << (*ite) << std::endl;
    std::cout << "CocoaDBMgr::BuildAlignments getCmsswID " << (*ite)->getCmsswID() << std::endl;
    //check CMSSW ID
    if ((*ite)->getCmsswID() > 0) {  //put the numbers of DT or CSC objects
      std::cout << " cal fill alignments " << std::endl;
      alignments->m_align.push_back(*(GetAlignInfoFromOptO(*ite)));
      std::cout << " fill alignments " << std::endl;
      //      AlignTransformErrorExtended* err =
      //GetAlignInfoErrorFromOptO( *ite );
      alignmentErrors->m_alignError.push_back(*(GetAlignInfoErrorFromOptO(*ite)));
      std::cout << "CocoaDBMgr::BuildAlignments add alignmentError " << alignmentErrors->m_alignError.size()
                << std::endl;
    }
  }
 
  if (ALIUtils::debug >= 4)
    std::cout << "CocoaDBMgr::BuildAlignments end with n alignment " << alignments->m_align.size()
              << " n alignmentError " << alignmentErrors->m_alignError.size() << std::endl;
  return std::pair<Alignments*, AlignmentErrorsExtended*>(alignments, alignmentErrors);
}

References gather_cfg::cout, ALIUtils::debug, Alignments::m_align, AlignmentErrorsExtended::m_alignError, and Model::OptOList().

BuildOpticalAlignments()

OpticalAlignments * CocoaDBMgr::BuildOpticalAlignments ( )

private

Definition at line 285 of file CocoaDBMgr.cc.

                                                      {
  OpticalAlignments* optalign = new OpticalAlignments;
 
  static std::vector<OpticalObject*> optolist = Model::OptOList();
  static std::vector<OpticalObject*>::const_iterator ite;
  for (ite = optolist.begin(); ite != optolist.end(); ++ite) {
    if ((*ite)->type() == "system")
      continue;
    OpticalAlignInfo data = GetOptAlignInfoFromOptO(*ite);
    optalign->opticalAlignments_.push_back(data);
    if (ALIUtils::debug >= 5) {
      std::cout << "@@@@ OPTALIGNINFO TO BE WRITTEN TO DB " << data << std::endl;
    }
  }
  return optalign;
}

References gather_cfg::cout, data, ALIUtils::debug, OpticalAlignments::opticalAlignments_, and Model::OptOList().

DumpCocoaResults()

bool CocoaDBMgr::DumpCocoaResults

(

)

Definition at line 51 of file CocoaDBMgr.cc.

                                  {
  edm::Service<cond::service::PoolDBOutputService> myDbService;
 
  GlobalOptionMgr* gomgr = GlobalOptionMgr::getInstance();
  int nrcd;
 
  cond::Time_t appendTime = Fit::nEvent + 1;
  if (gomgr->GlobalOptions()["writeDBOptAlign"] > 0) {
    //----- Build OpticalAlignments
    OpticalAlignments* optalign = BuildOpticalAlignments();
 
    //--- Dump OpticalAlignments
    nrcd = optalign->opticalAlignments_.size();
    if (!myDbService.isAvailable()) {
      throw cms::Exception("CocoaDBMgr::DumpCocoaResults DB not available");
    }
    //    try{
    if (myDbService->isNewTagRequest("OpticalAlignmentsRcd")) {
      std::cout << " new OA to DB "
                << "begin " << myDbService->beginOfTime() << " current " << myDbService->currentTime() << " end "
                << myDbService->endOfTime() << std::endl;
      myDbService->createNewIOV<OpticalAlignments>(
          optalign,
          myDbService->beginOfTime(),
          myDbService->endOfTime(),
          //                           myDbService->endOfTime(),
          "OpticalAlignmentsRcd");
    } else {
      std::cout << " old OA to DB "
                << " current " << myDbService->currentTime() << " end " << myDbService->endOfTime() << std::endl;
      myDbService->appendSinceTime<OpticalAlignments>(
          optalign,
          //              myDbService->endOfTime(),
          appendTime,
          //                               myDbService->currentTime(),
          "OpticalAlignmentsRcd");
    }
 
    /*    }catch(const cond::Exception& er) {
      std::cout<<er.what()<<std::endl;
      }catch(const std::exception& er){
      std::cout<<"caught std::exception "<<er.what()<<std::endl;
      }catch(...){
      std::cout<<"Funny error"<<std::endl;
      } */
 
    if (ALIUtils::debug >= 2)
      std::cout << "OpticalAlignmentsRcd WRITTEN TO DB : " << nrcd << std::endl;
  }
 
  if (gomgr->GlobalOptions()["writeDBAlign"] > 0) {
    // Build DT alignments and errors
    std::pair<Alignments*, AlignmentErrorsExtended*> dtali = BuildAlignments(true);
    Alignments* dt_Alignments = dtali.first;
    AlignmentErrorsExtended* dt_AlignmentErrors = dtali.second;
 
    // Dump DT alignments and errors
    nrcd = dt_Alignments->m_align.size();
    if (myDbService->isNewTagRequest("DTAlignmentRcd")) {
      myDbService->createNewIOV<Alignments>(
          &(*dt_Alignments), myDbService->beginOfTime(), myDbService->endOfTime(), "DTAlignmentRcd");
    } else {
      myDbService->appendSinceTime<Alignments>(&(*dt_Alignments),
                                               appendTime,
                                               //                          myDbService->currentTime(),
                                               "DTAlignmentRcd");
    }
    if (ALIUtils::debug >= 2)
      std::cout << "DTAlignmentRcd WRITTEN TO DB : " << nrcd << std::endl;
 
    nrcd = dt_AlignmentErrors->m_alignError.size();
    if (myDbService->isNewTagRequest("DTAlignmentErrorExtendedRcd")) {
      myDbService->createNewIOV<AlignmentErrorsExtended>(
          &(*dt_AlignmentErrors), myDbService->beginOfTime(), myDbService->endOfTime(), "DTAlignmentErrorExtendedRcd");
    } else {
      myDbService->appendSinceTime<AlignmentErrorsExtended>(
          &(*dt_AlignmentErrors), appendTime, "DTAlignmentErrorExtendedRcd");
    }
    if (ALIUtils::debug >= 2)
      std::cout << "DTAlignmentErrorExtendedRcd WRITTEN TO DB : " << nrcd << std::endl;
 
    // Build CSC alignments and errors
    std::pair<Alignments*, AlignmentErrorsExtended*> cscali = BuildAlignments(false);
    Alignments* csc_Alignments = cscali.first;
    AlignmentErrorsExtended* csc_AlignmentErrors = cscali.second;
 
    // Dump CSC alignments and errors
    nrcd = csc_Alignments->m_align.size();
    if (myDbService->isNewTagRequest("CSCAlignmentRcd")) {
      myDbService->createNewIOV<Alignments>(
          &(*csc_Alignments), myDbService->beginOfTime(), myDbService->endOfTime(), "CSCAlignmentRcd");
    } else {
      myDbService->appendSinceTime<Alignments>(&(*csc_Alignments), appendTime, "CSCAlignmentRcd");
    }
    if (ALIUtils::debug >= 2)
      std::cout << "CSCAlignmentRcd WRITTEN TO DB : " << nrcd << std::endl;
 
    nrcd = csc_AlignmentErrors->m_alignError.size();
    if (myDbService->isNewTagRequest("CSCAlignmentErrorExtendedRcd")) {
      myDbService->createNewIOV<AlignmentErrorsExtended>(&(*csc_AlignmentErrors),
                                                         myDbService->beginOfTime(),
                                                         myDbService->endOfTime(),
                                                         "CSCAlignmentErrorExtendedRcd");
    } else {
      myDbService->appendSinceTime<AlignmentErrorsExtended>(
          &(*csc_AlignmentErrors), appendTime, "CSCAlignmentErrorExtendedRcd");
    }
    if (ALIUtils::debug >= 2)
      std::cout << "CSCAlignmentErrorExtendedRcd WRITTEN TO DB : " << nrcd << std::endl;
 
    //? gives unreadable error???  std::cout << "@@@@ OPTICALALIGNMENTS WRITTEN TO DB " << *optalign << std::endl;
 
    return TRUE;
  }
 
  return TRUE;
}

References cond::service::PoolDBOutputService::appendSinceTime(), cond::service::PoolDBOutputService::beginOfTime(), gather_cfg::cout, cond::service::PoolDBOutputService::createNewIOV(), cond::service::PoolDBOutputService::currentTime(), ALIUtils::debug, cond::service::PoolDBOutputService::endOfTime(), Exception, GlobalOptionMgr::getInstance(), GlobalOptionMgr::GlobalOptions(), edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), Alignments::m_align, AlignmentErrorsExtended::m_alignError, Fit::nEvent, OpticalAlignments::opticalAlignments_, and TRUE.

Referenced by Fit::startFit().

GetAlignInfoErrorFromOptO()

AlignTransformErrorExtended * CocoaDBMgr::GetAlignInfoErrorFromOptO ( OpticalObject *  opto )

private

Definition at line 353 of file CocoaDBMgr.cc.

                                                                                      {
  if (ALIUtils::debug >= 3)
    std::cout << "@@@ CocoaDBMgr::GetAlignInfoErrorFromOptO " << opto->name() << std::endl;
 
  align::ID cmsswID = opto->getCmsswID();
 
  GlobalError gerr(1., 0., 1., 0., 0., 1.);
  //double(dx*dx),  0., double(dy*dy),     0., 0., double(dz*dz) ) ;
  CLHEP::HepSymMatrix errms = asHepMatrix(gerr.matrix());
  AlignTransformErrorExtended* alignError = new AlignTransformErrorExtended(errms, cmsswID);
  return alignError;
 
  CLHEP::HepMatrix errm(3, 3);
  const std::vector<Entry*>& theCoordinateEntryVector = opto->CoordinateEntryList();
  std::cout << "@@@ CocoaDBMgr::GetAlignInfoFromOptOfill errm " << opto->name() << std::endl;
  errm(0, 0) = GetEntryError(theCoordinateEntryVector[0]) * 1._m;                               // m in COCOA, cm in DB
  errm(1, 1) = GetEntryError(theCoordinateEntryVector[1]) * 1._m;                               // m in COCOA, cm in DB
  errm(2, 2) = GetEntryError(theCoordinateEntryVector[2]) * 1._m;                               // m in COCOA, cm in DB
  errm(0, 1) = GetEntryError(theCoordinateEntryVector[0], theCoordinateEntryVector[1]) * 1._m;  // m in COCOA, cm in DB
  errm(0, 2) = GetEntryError(theCoordinateEntryVector[0], theCoordinateEntryVector[2]) * 1._m;  // m in COCOA, cm in DB
  errm(1, 2) = GetEntryError(theCoordinateEntryVector[1], theCoordinateEntryVector[2]) * 1._m;  // m in COCOA, cm in DB
  //   errm(1,0) = errm(0,1);
  // errm(2,0) = errm(0,2);
  // errm(2,1) = errm(1,2);
 
  std::cout << "@@@ CocoaDBMgr::GetAlignInfoFromOptO errm filled" << opto->name() << std::endl;
  //  CLHEP::HepSymMatrix errms(3);
  //  errms.assign(errm);
 
  std::cout << "@@@ CocoaDBMgr::GetAlignInfoFromOptO errms filled " << opto->name() << std::endl;
  //  AlignTransformErrorExtended* alignError = new AlignTransformErrorExtended( errms, cmsswID );
  //  AlignTransformErrorExtended* alignError = 0;
 
  std::cout << alignError << "@@@ CocoaDBMgr::GetAlignInfoFromOptO error built " << opto->name() << std::endl;
  //t  return alignError;
  return (AlignTransformErrorExtended*)nullptr;
}

References asHepMatrix(), OpticalObject::CoordinateEntryList(), gather_cfg::cout, ALIUtils::debug, OpticalObject::getCmsswID(), GlobalErrorBase< T, ErrorWeightType >::matrix(), and OpticalObject::name().

GetAlignInfoFromOptO()

AlignTransform * CocoaDBMgr::GetAlignInfoFromOptO ( OpticalObject *  opto )

private

Definition at line 335 of file CocoaDBMgr.cc.

                                                                    {
  if (ALIUtils::debug >= 3)
    std::cout << "@@@ CocoaDBMgr::GetAlignInfoFromOptO " << opto->name() << std::endl;
 
  const AlignTransform::Translation& trans = opto->centreGlob();
  const AlignTransform::Rotation& rot = opto->rmGlob();
  align::ID cmsswID = opto->getCmsswID();
 
  std::cout << "@@@ CocoaDBMgr::GetAlignInfoFromOptO buildalign" << opto->name() << std::endl;
  AlignTransform* align = new AlignTransform(trans, rot, cmsswID);
 
  std::cout << "@@@ CocoaDBMgr::GetAlignInfoFromOptO alig built " << opto->name() << std::endl;
 
  return align;
  //  return dd;
}

References OpticalObject::centreGlob(), gather_cfg::cout, ALIUtils::debug, OpticalObject::getCmsswID(), OpticalObject::name(), OpticalObject::rmGlob(), and makeMuonMisalignmentScenario::rot.

GetEntryError() [1/2]

double CocoaDBMgr::GetEntryError ( const Entry *  entry )

private

GetEntryError() [2/2]

double CocoaDBMgr::GetEntryError ( const Entry *  entry1, const Entry *  entry2  )

private

getInstance()

CocoaDBMgr * CocoaDBMgr::getInstance ( )

static

Definition at line 40 of file CocoaDBMgr.cc.

                                    {
  if (!instance) {
    instance = new CocoaDBMgr;
  }
  return instance;
}

References instance.

Referenced by Fit::startFit().

GetOptAlignInfoFromOptO()

OpticalAlignInfo CocoaDBMgr::GetOptAlignInfoFromOptO ( OpticalObject *  opto )

private

Definition at line 170 of file CocoaDBMgr.cc.

                                                                        {
  LogDebug("Alignment") << " CocoaDBMgr::GetOptAlignInfoFromOptO " << opto->name();
  OpticalAlignInfo data;
  data.ID_ = opto->getCmsswID();
  data.type_ = opto->type();
  data.name_ = opto->name();
 
  //----- Centre in local coordinates
  CLHEP::Hep3Vector centreLocal = opto->centreGlob() - opto->parent()->centreGlob();
  CLHEP::HepRotation parentRmGlobInv = inverseOf(opto->parent()->rmGlob());
  centreLocal = parentRmGlobInv * centreLocal;
 
  const std::vector<Entry*>& theCoordinateEntryVector = opto->CoordinateEntryList();
  LogDebug("Alignment") << " CocoaDBMgr::GetOptAlignInfoFromOptO starting coord ";
  if (theCoordinateEntryVector.size() == 6) {
    const Entry* const translationX = theCoordinateEntryVector.at(0);
    OpticalAlignParam translationXDataForDB;
    translationXDataForDB.name_ = translationX->name();
    translationXDataForDB.dim_type_ = translationX->type();
    translationXDataForDB.value_ = centreLocal.x() * 1._m;              // m in COCOA, cm in DB
    translationXDataForDB.error_ = GetEntryError(translationX) * 1._m;  // m in COCOA, cm in DB
    translationXDataForDB.quality_ = translationX->quality();
    data.x_ = translationXDataForDB;
 
    const Entry* const translationY = theCoordinateEntryVector.at(1);
    OpticalAlignParam translationYDataForDB;
    translationYDataForDB.name_ = translationY->name();
    translationYDataForDB.dim_type_ = translationY->type();
    translationYDataForDB.value_ = centreLocal.y() * 1._m;              // m in COCOA, cm in DB
    translationYDataForDB.error_ = GetEntryError(translationY) * 1._m;  // m in COCOA, cm in DB
    translationYDataForDB.quality_ = translationY->quality();
    data.y_ = translationYDataForDB;
 
    const Entry* const translationZ = theCoordinateEntryVector.at(2);
    OpticalAlignParam translationZDataForDB;
    translationZDataForDB.name_ = translationZ->name();
    translationZDataForDB.dim_type_ = translationZ->type();
    translationZDataForDB.value_ = centreLocal.z() * 1._m;              // m in COCOA, cm in DB
    translationZDataForDB.error_ = GetEntryError(translationZ) * 1._m;  // m in COCOA, cm in DB
    translationZDataForDB.quality_ = translationZ->quality();
    data.z_ = translationZDataForDB;
 
    //----- angles in local coordinates
    std::vector<double> anglocal = opto->getLocalRotationAngles(theCoordinateEntryVector);
    if (anglocal.size() == 3) {
      const Entry* const rotationX = theCoordinateEntryVector.at(3);
      OpticalAlignParam rotationXDataForDB;
      rotationXDataForDB.name_ = rotationX->name();
      rotationXDataForDB.dim_type_ = rotationX->type();
      rotationXDataForDB.value_ = anglocal.at(0);
      rotationXDataForDB.error_ = GetEntryError(rotationX);
      rotationXDataForDB.quality_ = rotationX->quality();
      data.angx_ = rotationXDataForDB;
 
      const Entry* const rotationY = theCoordinateEntryVector.at(4);
      OpticalAlignParam rotationYDataForDB;
      rotationYDataForDB.name_ = rotationY->name();
      rotationYDataForDB.dim_type_ = rotationY->type();
      rotationYDataForDB.value_ = anglocal.at(1);
      rotationYDataForDB.error_ = GetEntryError(rotationY);
      rotationYDataForDB.quality_ = rotationY->quality();
      data.angy_ = rotationYDataForDB;
 
      const Entry* const rotationZ = theCoordinateEntryVector.at(5);
      OpticalAlignParam rotationZDataForDB;
      rotationZDataForDB.name_ = rotationZ->name();
      rotationZDataForDB.dim_type_ = rotationZ->type();
      rotationZDataForDB.value_ = anglocal.at(2);
      rotationZDataForDB.error_ = GetEntryError(rotationZ);
      rotationZDataForDB.quality_ = rotationZ->quality();
      data.angz_ = rotationZDataForDB;
    }
  }
 
  std::cout << " CocoaDBMgr::GetOptAlignInfoFromOptO starting entry " << std::endl;
  for (const auto& myDBExtraEntry : opto->ExtraEntryList()) {
    OpticalAlignParam extraEntry;
    extraEntry.name_ = myDBExtraEntry->name();
    extraEntry.dim_type_ = myDBExtraEntry->type();
    extraEntry.value_ = myDBExtraEntry->value();
    extraEntry.error_ = myDBExtraEntry->sigma();
    if (extraEntry.dim_type_ == "centre" || extraEntry.dim_type_ == "length") {
      extraEntry.value_ *= 1._m;  // m in COCOA, cm in DB
      extraEntry.error_ *= 1._m;  // m in COCOA, cm in DB
    }
    extraEntry.quality_ = myDBExtraEntry->quality();
    data.extraEntries_.emplace_back(extraEntry);
    std::cout << " CocoaDBMgr::GetOptAlignInfoFromOptO done extra entry " << extraEntry.name_ << std::endl;
  }
 
  return data;
}

References OpticalObject::centreGlob(), OpticalObject::CoordinateEntryList(), gather_cfg::cout, data, OpticalAlignParam::dim_type_, OpticalAlignParam::error_, OpticalObject::ExtraEntryList(), OpticalObject::getCmsswID(), OpticalObject::getLocalRotationAngles(), LogDebug, OpticalObject::name(), OpticalAlignParam::name_, OpticalObject::parent(), OpticalAlignParam::quality_, OpticalObject::rmGlob(), OpticalObject::type(), and OpticalAlignParam::value_.

Member Data Documentation

instance

CocoaDBMgr * CocoaDBMgr::instance = nullptr

staticprivate

Definition at line 59 of file CocoaDBMgr.h.

Referenced by production_tasks.Task::getname().