Alignments.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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/objects/AlignmentsInterna.h"
#include "DD4hep/objects/ConditionsInterna.h"

// C/C++ include files
#include <sstream>

using namespace std;
using namespace DD4hep::Alignments;

namespace DD4hep {
  
  namespace Alignments {

#if defined(__APPLE__) || defined(__clang__)
    Alignment::Alignment(const string& nam)
    { assign(new Interna::AlignmentNamedObject(nam, "alignment"), nam, "alignment");    }

    AlignmentCondition::AlignmentCondition(const string& nam)
    { assign(new AlignmentCondition::Object(nam, "alignment"), nam, "alignment");       }
#else
    template <> Alignment::Alignment<AlignmentData>(const string& nam)
    { assign(new AlignmentData(), nam, "alignment");                                    }

    template <> Alignment::Alignment<Interna::AlignmentNamedObject>(const string& nam)
    { assign(new Interna::AlignmentNamedObject(nam, "alignment"), nam, "alignment");    }

    template <> AlignmentCondition::AlignmentCondition<Interna::AlignmentConditionObject>(const string& nam)
    { assign(new Object(nam, "alignment"), nam, "alignment");                           }
#endif
  } /* End namespace Aligments                    */
}   /* End namespace DD4hep                       */


Alignment::Processor::Processor() {
}

const TGeoHMatrix& Alignment::worldTransformation()  const  {
  return data().worldTransformation();
}

const TGeoHMatrix& Alignment::detectorTransformation() const   {
  return data().detectorTransformation();
}

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;
}

AlignmentCondition::Data& AlignmentCondition::data()              {
  Object* o = access();
  if ( o->alignment_data )
    return *(o->alignment_data);
  Conditions::Condition c(*this);
  o->alignment_data = c.is_bound() ? &c.get<Data>() : &c.bind<Data>();
  o->alignment_data->condition = c;
  return *(o->alignment_data);
}

const AlignmentCondition::Data& AlignmentCondition::data() const  {
  Object* o = access();
  if ( o->alignment_data )
    return *(o->alignment_data);
  Conditions::Condition c(*this);
  o->alignment_data = c.is_bound() ? &c.get<Data>() : &c.bind<Data>();
  o->alignment_data->condition = c;
  return *(o->alignment_data);
}

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();
}

Container::Processor::Processor() {
}

size_t Container::numKeys() const   {
  return access()->keys.size();
}

const Container::Keys& Container::keys()  const   {
  Object* o = ptr();
  if ( !o )   {
    invalidHandleError<Container>();
  }
  return o->keys;
}

Alignment Container::get(const string& alignment_key, const iov_type& iov)  {
  Object* o = ptr();
  if ( o )  {
    Alignment c = o->get(alignment_key, iov);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Alignment>();
  }
  invalidHandleError<Container>();
  return Alignment();
}

Alignment Container::get(key_type alignment_key, const iov_type& iov)  {
  Object* o = ptr();
  if ( o )  {
    Alignment c = o->get(alignment_key, iov);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Alignment>();
  }
  invalidHandleError<Container>();
  return Alignment();
}

Alignment Container::get(const string& alignment_key, const UserPool& pool)  {
  Object* o = ptr();
  if ( o )  {
    Alignment c = o->get(alignment_key, pool);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Alignment>();
  }
  invalidHandleError<Container>();
  return Alignment();
}

Alignment Container::get(key_type alignment_key, const UserPool& pool)  {
  Object* o = ptr();
  if ( o )  {
    Alignment c = o->get(alignment_key, pool);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Alignment>();
  }
  invalidHandleError<Container>();
  return Alignment();
}