UgliGeomHandle.cxx

Go to the documentation of this file.

// $Id: UgliGeomHandle.cxx,v 1.21 2007/06/14 14:49:06 rhatcher Exp $
//
// UgliGeomHandle
//
// UgliGeomHandle is single geometry
//
// Author:  R. Hatcher 2000.04.25
//

#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliLoanPool.h"
#include "UgliGeometry/UgliGeometry.h"

#include "Validity/VldContext.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliGeomHandle.cxx,v 1.21 2007/06/14 14:49:06 rhatcher Exp $");

#include <cassert>

ClassImp(UgliGeomHandle)

//_____________________________________________________________________________
UgliGeomHandle::UgliGeomHandle()
  : fUgliGeometry(0),fGeoGeometry(0)
{
   // Default constructor

   MSG("Ugli",Msg::kWarning) 
      << endl
      << "UgliGeomHandle created by default ctor" 
      << endl;

//   assert(0);

   VldContext vldc(Detector::kUnknown,SimFlag::kUnknown,
                   VldTimeStamp((time_t)0,0));

   if ( !UgliLoanPool::Instance()->UseGeo() ) {
     fUgliGeometry 
       = UgliLoanPool::Instance()->GetUgliGeometry(vldc,true);
     fUgliGeometry->IncrementRef();
   }
   else {
     fGeoGeometry
       = UgliLoanPool::Instance()->GetGeoGeometry(vldc,true,Geo::kRecons);
     fGeoGeometry->IncrementRef();
   }
   

}

//_____________________________________________________________________________
UgliGeomHandle::UgliGeomHandle(const VldContext& vldc, 
                               Ugli::EModifyMode mmode,
                               Geo::EAppType apptype) : fUgliGeometry(0),
                                                        fGeoGeometry(0)
{
   // Normal constructor

   Bool_t use_frozen = true;
   switch (mmode) {
   case (Ugli::kModifiable): use_frozen = false; break;
   case (Ugli::kFrozen):     use_frozen = true;  break;
   case (Ugli::kUseGlobal): 
      use_frozen = true;
      if (Ugli::kModifiable == 
          Ugli::GetDefaultModifyMode()) use_frozen = false;
      break;
   }

   if ( !UgliLoanPool::Instance()->UseGeo() ) {
     fUgliGeometry 
       = UgliLoanPool::Instance()->GetUgliGeometry(vldc,use_frozen);
     fUgliGeometry->IncrementRef();
   }
   else {
     fGeoGeometry
       = UgliLoanPool::Instance()->GetGeoGeometry(vldc,use_frozen,apptype);
     fGeoGeometry->IncrementRef();
   }
   
}

//_____________________________________________________________________________
UgliGeomHandle::UgliGeomHandle(const UgliGeomHandle &that)
  : UgliGeomABC()
{
   // copy constructor keeps reference count up-to-date

   // patterned after other ROOT objects

   ((UgliGeomHandle&)that).Copy(*this);
   if ( !IsGeo() ) fUgliGeometry->IncrementRef();
   else fGeoGeometry->IncrementRef();
   
}

//_____________________________________________________________________________
UgliGeomHandle::~UgliGeomHandle()
{
   // handle deletion updates reference count
   if ( !IsGeo() ) fUgliGeometry->DecrementRef();
   else            fGeoGeometry->DecrementRef();
  
} 

//_____________________________________________________________________________
UgliGeomHandle&  UgliGeomHandle::operator=(const UgliGeomHandle& ugh)
{
   // assignment keeps reference counts up-to-date

   if ( !IsGeo() ) fUgliGeometry->DecrementRef();
   else            fGeoGeometry->DecrementRef();   

   ((UgliGeomHandle&)ugh).Copy(*this);

   if ( !IsGeo() ) fUgliGeometry->IncrementRef();
   else            fGeoGeometry->IncrementRef();

   return *this;
}

//_____________________________________________________________________________
void UgliGeomHandle::ResetVldContext(const VldContext& vldc)
{
  Bool_t use_frozen = IsFrozen();
  if ( !IsGeo() ) {
    fUgliGeometry->DecrementRef();
    fUgliGeometry 
       = UgliLoanPool::Instance()->GetUgliGeometry(vldc,use_frozen);
    fUgliGeometry->IncrementRef();
  }
  else {
    Geo::EAppType apptype = fGeoGeometry->GetAppType();
    fGeoGeometry->DecrementRef();
    fGeoGeometry
       = UgliLoanPool::Instance()->GetGeoGeometry(vldc,use_frozen,apptype);
    fGeoGeometry->IncrementRef();
  }

}

//_____________________________________________________________________________
bool UgliGeomHandle::DoesValidGeomExist(const VldContext& vldc, 
                                        Ugli::EModifyMode mmode)
{
   // static method for testing if ctor will construct a new geometry
   // turns around and asks UgliLoanPool
   return UgliLoanPool::Instance()->DoesValidGeomExist(vldc,mmode);
}

//_____________________________________________________________________________
void UgliGeomHandle::Copy(TObject &that) const
{
   // actual copying

   TObject::Copy(that);
   ((UgliGeomHandle&)that).fUgliGeometry = fUgliGeometry;
   ((UgliGeomHandle&)that).fGeoGeometry  = fGeoGeometry;

}

//_____________________________________________________________________________
// inlining these causes a circular dependency

//inline 
UgliScintPlnHandle UgliGeomHandle::GetScintPlnHandle(PlexPlaneId planeid)
{ if ( !IsGeo() ) 
    return UgliScintPlnHandle(fUgliGeometry->GetScintPlnNode(planeid)); 
  else 
    return UgliScintPlnHandle(fGeoGeometry->GetScintPlnNode(planeid)); }

//inline 
UgliStripHandle UgliGeomHandle::GetStripHandle(PlexStripEndId seid)
{ if ( !IsGeo() ) 
    return UgliStripHandle(fUgliGeometry->GetStripNode(seid)); 
  else
    return UgliStripHandle(fGeoGeometry->GetStripNode(seid)); }

//inline 
vector<UgliScintPlnHandle> UgliGeomHandle::GetScintPlnHandleVector()
{
//{ return fUgliGeometry->GetScintPlnHandleVector(); }
  vector<UgliScintPlnHandle> scintPlnHandles;
  if ( !IsGeo() ) {
    vector<UgliScintPlnNode*>  scintPlnNodes =
      fUgliGeometry->GetScintPlnNodePtrVector();
    for (unsigned int i=0; i<scintPlnNodes.size(); ++i)
      scintPlnHandles.push_back(UgliScintPlnHandle(scintPlnNodes[i]));
  }
  else {
    vector<GeoScintPlnNode*>  scintPlnNodes =
      fGeoGeometry->GetScintPlnNodePtrVector();
    for (unsigned int i=0; i<scintPlnNodes.size(); ++i)
      scintPlnHandles.push_back(UgliScintPlnHandle(scintPlnNodes[i]));
  }
  
  return scintPlnHandles;
}

//inline 
vector<UgliSteelPlnHandle> UgliGeomHandle::GetSteelPlnHandleVector()
{
//{ return fUgliGeometry->GetSteelPlnHandleVector(); }
  vector<UgliSteelPlnHandle> steelPlnHandles;
  if ( !IsGeo() ) {
    vector<UgliSteelPlnNode*>  steelPlnNodes =
      fUgliGeometry->GetSteelPlnNodePtrVector();
    for (unsigned int i=0; i<steelPlnNodes.size(); ++i)
      steelPlnHandles.push_back(UgliSteelPlnHandle(steelPlnNodes[i]));
  }
  else {
    vector<GeoSteelPlnNode*>  steelPlnNodes =
      fGeoGeometry->GetSteelPlnNodePtrVector();
    for (unsigned int i=0; i<steelPlnNodes.size(); ++i)
      steelPlnHandles.push_back(UgliSteelPlnHandle(steelPlnNodes[i]));
  }
  
  return steelPlnHandles;
}

//inline 
vector<UgliPlnHandle> UgliGeomHandle::GetPlnHandleVector()
{
//{ return fUgliGeometry->GetPlnHandleVector(); }
  vector<UgliPlnHandle> plnHandles;
  if ( !IsGeo() ) {
    vector<UgliPlnNode*>  plnNodes =
      fUgliGeometry->GetPlnNodePtrVector();
    for (unsigned int i=0; i<plnNodes.size(); ++i)
      plnHandles.push_back(UgliPlnHandle(plnNodes[i]));
  }
  else {
    vector<GeoPlnNode*>  plnNodes =
      fGeoGeometry->GetPlnNodePtrVector();
    for (unsigned int i=0; i<plnNodes.size(); ++i)
      plnHandles.push_back(UgliPlnHandle(plnNodes[i]));
  }
  
  return plnHandles;
}

void UgliGeomHandle::SwitchMedia(bool toswim) {
  // Switch to swimmer media.  Only useful within PTSimApplication 
  // context, so perhaps should be protected with friend access? 
  // For now is public method.

  if ( !IsGeo() ) MSG("Ugli",Msg::kWarning) 
    << "SwitchMedia with UgliGeometry is not applicable." << endl;
  else fGeoGeometry -> SwitchMedia(toswim);

}
  
//_____________________________________________________________________________

---