Alignments.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
 
// Framework include files
#include <DD4hep/AlignmentData.h>
#include <DD4hep/detail/AlignmentsInterna.h>
#include <DD4hep/detail/ConditionsInterna.h>
 
// C/C++ include files
#include <sstream>
 
using namespace dd4hep;
 
const std::string dd4hep::align::Keys::deltaName("alignment_delta");
const dd4hep::Condition::itemkey_type  dd4hep::align::Keys::deltaKey =
  dd4hep::ConditionKey::itemCode("alignment_delta");
 
const std::string dd4hep::align::Keys::alignmentName("alignment");
const dd4hep::Condition::itemkey_type dd4hep::align::Keys::alignmentKey =
  dd4hep::ConditionKey::itemCode("alignment");
 
Alignment::Processor::Processor() {
}
 
Alignment::Alignment(const std::string& nam)  {
  char*   p = (char*)::operator new(sizeof(Object)+sizeof(AlignmentData));
  Object* o = new(p) Object(nam, "alignment", p+sizeof(Object), sizeof(AlignmentData));
  assign(o, nam, "alignment");
  o->hash   = 0;
}
 
AlignmentCondition::AlignmentCondition(const std::string& nam)   {
  char*   p = (char*)::operator new(sizeof(Object)+sizeof(AlignmentData));
  Object* o = new(p) Object(nam, "alignment", p+sizeof(Object), sizeof(AlignmentData));
  assign(o, nam, "alignment");
  o->hash   = 0;
}
 
AlignmentData& Alignment::data()              {
  return access()->values();
}
 
const AlignmentData& Alignment::data() const  {
  return access()->values();
}
 
const Delta& Alignment::delta() const   {
  return access()->values().delta;
}
 
const TGeoHMatrix& Alignment::worldTransformation()  const  {
  return access()->values().worldTransformation();
}
 
const TGeoHMatrix& Alignment::detectorTransformation() const   {
  return access()->values().detectorTransformation();
}
 
const std::vector<PlacedVolume>& Alignment::nodes() const   {
  return access()->values().nodes;
}
 
void Alignment::localToWorld(const Position& local, Position& global) const  {
  return access()->values().localToWorld(local,global);
}
 
void Alignment::localToWorld(const Double_t local[3], Double_t global[3]) const  {
  return access()->values().localToWorld(local,global);
}
Position Alignment::localToWorld(const Position& local) const  {
  return access()->values().localToWorld(local);
}
 
void Alignment::worldToLocal(const Position& global, Position& local) const  {
  return access()->values().worldToLocal(global,local);
}
 
void Alignment::worldToLocal(const Double_t global[3], Double_t local[3]) const  {
  return access()->values().worldToLocal(global,local);
}
 
Position Alignment::worldToLocal(const Position& global) const  {
  return access()->values().worldToLocal(global);
}
 
void Alignment::localToDetector(const Position& local, Position& detector) const  {
  return access()->values().localToDetector(local,detector);
}
 
void Alignment::localToDetector(const Double_t local[3], Double_t detector[3]) const  {
  return access()->values().localToDetector(local,detector);
}
 
Position Alignment::localToDetector(const Position& local) const  {
  return access()->values().localToDetector(local);
}
 
void Alignment::detectorToLocal(const Position& detector, Position& local) const  {
  return access()->values().detectorToLocal(detector,local);
}
 
void Alignment::detectorToLocal(const Double_t detector[3], Double_t local[3]) const  {
  return access()->values().detectorToLocal(detector,local);
}
 
Position Alignment::detectorToLocal(const Position& detector) const  {
  return access()->values().detectorToLocal(detector);
}
 
const dd4hep::IOVType& AlignmentCondition::iovType() const   {
  return *(access()->iovType());
}
 
const dd4hep::IOV& AlignmentCondition::iov() const   {
  return *(access()->iovData());
}
 
AlignmentCondition::key_type AlignmentCondition::key() const   {
  return access()->hash;
}
 
AlignmentData& AlignmentCondition::data()              {
  return *(access()->alignment_data);
}
 
const AlignmentData& AlignmentCondition::data() const  {
  return *(access()->alignment_data);
}
 
const Delta& AlignmentCondition::delta() const   {
  return access()->alignment_data->delta;
}
 
bool AlignmentCondition::is_bound()  const  {
  return isValid() ? ptr()->data.is_bound() : false;
}
 
const TGeoHMatrix& AlignmentCondition::worldTransformation()  const  {
  return data().worldTransformation();
}
 
const TGeoHMatrix& AlignmentCondition::detectorTransformation() const   {
  return data().detectorTransformation();
}