A DDLogicalPart aggregates information concerning material, solid and sensitveness ... More...

#include <DDLogicalPart.h>

Inheritance diagram for DDLogicalPart:

Public Member Functions
void	addSpecifics (const std::pair< DDPartSelection , DDsvalues_type > &)
	don't use, internal only /todo make it private
const std::vector< std::pair < DDPartSelection , DDsvalues_type > > &	attachedSpecifics (void) const
DDEnums::Category	category (void) const
	Returns the categorization of the DDLogicalPart (sensitive detector element, cable, ...)
	DDLogicalPart (const DDName &name)
	Creates a reference object referring to the appropriate XML specification.
	DDLogicalPart (void)
	The default constructor provides an uninitialzed reference object.
	DDLogicalPart (const DDName &name, const DDMaterial &material, const DDSolid &solid, DDEnums::Category cat=DDEnums::unspecified)
	Registers (creates) a reference object representing a LogicalPart.
bool	hasDDValue (const DDValue &) const
const DDMaterial &	material (void) const
	Returns a reference object of the material this LogicalPart is made of.
DDsvalues_type	mergedSpecifics (void) const
	returns the merged-specifics, i.e. the last specified specifics of this logical-part
void	removeSpecifics (const std::pair< DDPartSelection , DDsvalues_type > &)
const DDSolid &	solid (void) const
	Returns a reference object of the solid being the shape of this LogicalPart.
std::vector< const DDsvalues_type * >	specifics (void) const
	returns the specific-data attached to the LogicalPart only (not to a DDExpandedNode)
double &	weight (void)
	Weight of the LogicalPart viewed as a component, if cached, else -1.
Friends
std::ostream &	operator<< (std::ostream &, const DDLogicalPart &)

Detailed Description

A DDLogicalPart aggregates information concerning material, solid and sensitveness ...

... of a unpositioned volume. DDLogicalPart provides thus an interface to its XML representation <LogicalPart ... </LogicalPart>.

An object of this class is a reference-object and thus lightweighted. It can be copied by value without having a large overhead. Assigning to the reference-object invalidates the object which was referred to before. Assigning also effects all other instances of this class which were created using the same value of DDName. In fact, the value of DDName identifies a LogicalPart uniquely.

Current Restriction: Only the name part of DDName identifies the LogicalPart.

General properties of reference objects:

Three kind of reference objects can be distinguished:

Uninitialized reference objects (related to default constructor)
Initialized reference objects (related to the constructor taken DDName as argument)
Defined reference objects

An unititialized reference object is somehow comparable to an anonymous structure. The default constructor (no arguments) is used to create it. No DDName was specified. It's not very useful unless you assign an initialized or defined reference object.

An initialized reference object is a reference object which was created first using only the constructor taking a single DDName as an argument. It's comparable to a variable declaration with default initialization (like std::vector < int > v). The default object is registered using the DDName as index in some from the user hidden registry. After an initialized reference object has been created it can be used (copied, assigned to, beeing assigned to, ..) like a built in type like int. As soon as an defined reference object with the same DDName is create, all already existing initialized reference object become defined reference object immidiately (some kind of one-definition-rule).

A defined reference object is a reference object which was created using a constructor taking DDName and additional arguments or using appropriate factory functions (e.g. DDbox) returning a defined reference object. As soon as one defined reference object A1 is created with a unique DDName N1, every reference object A2 created by the constructor which only take DDName N2 as an argument and N2 == N1, is also a defined reference object referring to the same object than A1. Hence A1 == A2 is true. Further any previously created initialized reference objects having the same DDName also become references to the newly created defined reference object A1.

To find out whether an instance of a reference object is defined or not, operator bool can be used, i.e.

    DDLogicalPart(DDName("CMS","cms.xml")) cms;
    if (cms) {
      // cms is a defined reference object
    }
    else {
      // cms is a (default) initialized reference object
    }

Definition at line 88 of file DDLogicalPart.h.

Constructor & Destructor Documentation

DDLogicalPart::DDLogicalPart ( void ) [inline]

The default constructor provides an uninitialzed reference object.

Definition at line 94 of file DDLogicalPart.h.

: DDBase<DDName,DDI::LogicalPart*>(){ }

DDLogicalPart::DDLogicalPart ( const DDName & name )

Creates a reference object referring to the appropriate XML specification.

In order to use an uninitialized reference object one has to assign to it an initialized object of the same class.

Example:

      DDLogicalPart world;  // uninitialized (anonymous) reference object
      world = DDLogicalPart(DDName("CMS","cms.xml"));  
      // now world refers to an initialized object, which in turn is not
      // necessarily defined yet.

One has to distinguish two cases:

The object which should be referred to has already been defined ...

... using the constructor:

 DDLogicalPart(const DDName &, const DDMaterial, 
       const DDSolid, bool sens)

This will be the case for example after XML has been parsed. The XML parser calls the constructor described below and thus registers a new object using DDName to identify it uniquely. The using this constructor one fetches the reference object. Assigning to this reference object invalidates the object being refered before (and redirects all reference objects using the same value of their DDName already in use to the newly assigned reference object).

The object which should be referred to has not yet been defined: In this case this constructor registeres a valid object. But this object is not yet defined (i.e. no material nor a solid has been attached to it). Nevertheless the reference object can be used (copied ...) everywhere. If, at a later stage, a defined reference object with the same DDName is created, all already existing reference objects become references to this newly created reference object (one definition rule).

Example:

       ... // code for DDMaterial (material) definition and DDSolid (solid) defintion goes here
       DDName detName("Detector","logparts"); // define a unique  name
       DDLogicalPart detDeclaration(detName); // detName-corresponding object not defined yet!
       std::vector<DDLogicalPart> vec; 
       vec.push_back(det);  // use reference object in a std::vector
       // now define ad detName-corresponding object (it will be internally registered) 
       DDLogicalPart detDefinition(detName, material, solid, false); 
       // now also vec[0] automatically becomes a reference to detDefinition!
       // both got

Definition at line 99 of file DDLogicalPart.cc.

References DD_NC(), DDI::Singleton< I >::instance(), and DDBase< DDName, DDI::LogicalPart * >::prep_.

  : DDBase<DDName, DDI::LogicalPart*>()
{ 
  prep_ = StoreT::instance().create( name );
  DD_NC( name );
}

DDLogicalPart::DDLogicalPart	(	const DDName &	ddname,
		const DDMaterial &	material,
		const DDSolid &	solid,
		DDEnums::Category	cat = `DDEnums::unspecified`
	)

Registers (creates) a reference object representing a LogicalPart.

An object representing a logicalpart uniquely identified by its DDName name will be created. If reference objects of the same name already exist, they will refere to the newly created object. DDMaterial material and DDSolid solid are themselves reference objects to a material and solid specification. The need not be defined yet as long as they were constructed using unique DDName-objects.

This constructor is intended to be called by the XML parsing software, not by the DDD user. It decouples the input technologies (i.e. XML) and forms the transition to the runtime DDD representation. However, it could also be used for 'programming' a detector description.

Definition at line 118 of file DDLogicalPart.cc.

References DCOUT, DD_NC(), DDI::Singleton< I >::instance(), DDBase< N, C >::name(), and DDBase< DDName, DDI::LogicalPart * >::prep_.

 : DDBase<DDName,DDI::LogicalPart*>() 
{ 
   DCOUT('C', "create LogicalPart ddname=" << ddname << " mat=" << material.name() << " sol=" << solid.name());
   prep_ = StoreT::instance().create(ddname, new DDI::LogicalPart(material,solid,cat));
   DD_NC(ddname);
}

Member Function Documentation

void DDLogicalPart::addSpecifics ( const std::pair< DDPartSelection *, DDsvalues_type * > & s )

don't use, internal only /todo make it private

Definition at line 241 of file DDLogicalPart.cc.

References DCOUT, DDBase< DDName, DDI::LogicalPart * >::name(), and DDBase< DDName, DDI::LogicalPart * >::rep().

{
   DCOUT('S', "lp=" << name());
   rep().addSpecifics(s);
}

const std::vector< std::pair< DDPartSelection *, DDsvalues_type * > > & DDLogicalPart::attachedSpecifics ( void ) const

Definition at line 407 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep().

Referenced by OutputDDToDDL::addToSpecStore(), GeometryInfoDump::dumpInfo(), DDExpandedView::mergedSpecificsV(), and DDExpandedView::specificsV().

{
  return rep().attachedSpecifics();
}

DDEnums::Category DDLogicalPart::category ( void ) const

Returns the categorization of the DDLogicalPart (sensitive detector element, cable, ...)

Definition at line 137 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep().

Referenced by PhysicalPartsTree::beginRun(), and DDStreamer::parts_write().

{ 
  return rep().category(); 
}

bool DDLogicalPart::hasDDValue ( const DDValue & v ) const

Definition at line 250 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep().

Referenced by DDSpecificsFilter::accept_impl().

{
  return rep().hasDDValue(v);
}

const DDMaterial & DDLogicalPart::material ( void ) const

Returns a reference object of the material this LogicalPart is made of.

Definition at line 143 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep().

{
  return rep().material();
}

DDsvalues_type DDLogicalPart::mergedSpecifics ( void ) const

returns the merged-specifics, i.e. the last specified specifics of this logical-part

Definition at line 233 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep(), and query::result.

{
  DDsvalues_type  result;
  rep().mergedSpecificsV(result);
  return result;
}

void DDLogicalPart::removeSpecifics ( const std::pair< DDPartSelection *, DDsvalues_type * > & s )

Definition at line 246 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep().

{
   rep().removeSpecifics(s);
}

const DDSolid & DDLogicalPart::solid ( void ) const

Returns a reference object of the solid being the shape of this LogicalPart.

Definition at line 149 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep().

{
  return rep().solid();
}

std::vector< const DDsvalues_type * > DDLogicalPart::specifics ( void ) const

returns the specific-data attached to the LogicalPart only (not to a DDExpandedNode)

The method will only return specific data attached to a DDLogicalPart. If DDL-XML is used to define specific data, the path-attribute of <PartSelector> addressing only LogicalParts only consists of a "//" and the name of the LogicalPart (or a regexp for the name):

   <SpecPar name="Color">
    <PartSelector path="//BarrelDetector"/>
    <PartSelector path="//ForwardSector1.*Cable."/>
    <Parameter name="rgb" value="0.5"/>
    <Parameter name="rgb" value="0.1+0.2"/>
    <Parameter name="rgb" value="[colors:blue1]/>
    <Parameter name="visible" value="true"/>
   </SpecPar>

The above XML assigns specific data to a DDLogicalPart with name "BarrelDetector" and to all DDLogicalParts whose names match the regexp "ForwardSector1.*Cable.", e.g. "ForwardSector123abCable7" Two parameters are attached as specific data: "rgb" - a std::vector of three values, and "visible" - a std::vector of one value.

The method DDLogicalPart::specifics() now returns a std::vector<const DDsvalues_type *> V which correspond to these two values. Every entry in V comes from a different <SpecPar> tag. In our example above, V would have size 1, e.g. V.size() == 1.

A <Paramter> is std::mapped to DDValue. 'value' of <Parameter> is kept as a std::string and as a double. If the std::string does not evaluate correctly to double, 0 is the assigned.

Here's the code to retrieve the 'rgb' Parameter:

   void someFunc(DDLogicalPart aLp) {

     // want to know, whether the specific parameter 'Color' is attached to aLp

     // each <SpecPar> for this LogicalPart will create one entry in the result_type std::vector
     // each entry in the result_type std::vector contains all Paramters defined in one SpecPar-tag
     // We assume now, that we have only one SpecPar ...
     typedef std::vector<const DDsvalues_type *> result_type;
     result_type result = aLp.specifics();
     if (result.size()==1) {
       DDValue val("Color");
       bool foundIt=false;
       foundIt = DDfetch(result[0],val) // DDfetch is a utility function to retrieve values from a DDsvalues_type*
      if (foundIt) { // val contains the result
        const std::vector<std::string> & strVec = val.std::string();
       // strVec[0] == "0.5"
       // strVec[1] == "0.1+0.2"
       const std::vector<double> & dblVec = val.doubles(); 
       // dblVec[0] == double value of Constant 'red' 0.5
... 
      // do something here ...
     }
   }

Definition at line 225 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep(), and query::result.

Referenced by DDG4Builder::getDouble(), DDG4Builder::getInt(), MuonDDDNumbering::getInt(), and DDG4SensitiveConverter::getString().

{
  std::vector<const DDsvalues_type*> result;
  rep().specificsV(result);
  return result;
}

double & DDLogicalPart::weight ( void )

Weight of the LogicalPart viewed as a component, if cached, else -1.

Definition at line 166 of file DDLogicalPart.cc.

References DDBase< DDName, DDI::LogicalPart * >::rep().

Referenced by DDCompactViewImpl::weight().

{
  return rep().weight();
}

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const DDLogicalPart &	part
	)		`[friend]`

Definition at line 29 of file DDLogicalPart.cc.

{
  DDBase<DDName,DDI::LogicalPart*>::def_type defined( part.isDefined());
  if( defined.first )
  {
    os << *(defined.first) << " ";
    if( defined.second )
    {
      part.rep().stream( os ); 
    }
    else
    {
      os << "* logicalpart not defined * ";  
    }
  }  
  else
  {
    os << "* logicalpart not declared * ";  
  }  
  return os;
}

DDLogicalPart Class Reference

Public Member Functions

Friends

Detailed Description

General properties of reference objects:

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation