InDetDD::VolumeSplitter Class Reference

#include <VolumeSplitter.h>

Collaboration diagram for InDetDD::VolumeSplitter:

Public Member Functions
	VolumeSplitter ()
	~VolumeSplitter ()
const std::vector< const ServiceVolume * > &	splitAll (const Zone &zone, const std::vector< const ServiceVolume * > &)
void	split (const Zone &zone, const ServiceVolume &origVolume)
const std::vector< const ServiceVolume * > &	getVolumes () const
void	takeOwnership ()

Private Member Functions
Ray	makeRay (const ServiceVolume &origVolume)
void	makeVolumes (const Zone *zone, const ServiceVolume &origVolume)
void	splitVolume (const Zone *zone, const ServiceVolume &vol)
void	adjustR (const ServiceVolume &param, ServiceVolume *paramNew)

Private Attributes
bool	m_ownVolumes
double	m_epsilon
std::vector< const ServiceVolume * >	m_volumes

Detailed Description

Definition at line 16 of file VolumeSplitter.h.

Constructor & Destructor Documentation

VolumeSplitter()

InDetDD::VolumeSplitter::VolumeSplitter

(

)

Definition at line 14 of file VolumeSplitter.cxx.

    : m_ownVolumes(true),
    m_epsilon(0.0001 * Gaudi::Units::mm)
  {}

~VolumeSplitter()

InDetDD::VolumeSplitter::~VolumeSplitter

(

)

Definition at line 19 of file VolumeSplitter.cxx.

                                  {
    if (m_ownVolumes) {
      for (std::vector<const ServiceVolume*>::iterator iter = m_volumes.begin(); iter != m_volumes.end(); ++iter) {
        delete *iter;
      }
    }
  }

Member Function Documentation

adjustR()

void InDetDD::VolumeSplitter::adjustR ( const ServiceVolume &  param, ServiceVolume *  paramNew  )

private

Definition at line 155 of file VolumeSplitter.cxx.

                                                                             {
    double z1 = param.zmin();
    double z2 = param.zmax();
    double z1New = paramNew->zmin();
    double z2New = paramNew->zmax();
    double rmin1 = param.rmin();
    double rmin2 = param.rmin2();
    double rmax1 = param.rmax();
    double rmax2 = param.rmax2();
 
    // Make sure z1 < z2
    // as r1, r2 order assumes this
    if (z1 > z2) std::swap(z1, z2);
    if (z1New > z2New) std::swap(z1New, z2New);
 
    // Avoid divide by zero.
    if (z1 == z2) return;
 
    if (z1 != z1New || z2 != z2New) {
      if (rmin2 > 0 && rmax2 > 0 && (rmin1 != rmin2 || rmax1 != rmax2)) {
        double slopeMin = (rmin2 - rmin1) / (z2 - z1);
        double slopeMax = (rmax2 - rmax1) / (z2 - z1);
 
        double rmin1New = (z1New - z1) * slopeMin + rmin1;
        double rmin2New = (z2New - z1) * slopeMin + rmin1;
 
        double rmax1New = (z1New - z1) * slopeMax + rmax1;
        double rmax2New = (z2New - z1) * slopeMax + rmax1;
 
        paramNew->setRmin(rmin1New);
        paramNew->setRmax(rmax1New);
        paramNew->setRmin2(rmin2New);
        paramNew->setRmax2(rmax2New);
      }
    }
  }

getVolumes()

const std::vector<const ServiceVolume *>& InDetDD::VolumeSplitter::getVolumes ( ) const

inline

Definition at line 23 of file VolumeSplitter.h.

{return m_volumes;}

makeRay()

Ray InDetDD::VolumeSplitter::makeRay ( const ServiceVolume &  origVolume )

private

Definition at line 41 of file VolumeSplitter.cxx.

                                                         {
    double zmin = origVolume.zmin();
    double zmax = origVolume.zmax();
    double rmin = origVolume.rmin();
    double rmax = origVolume.rmax();
 
    if (zmax < zmin) std::swap(zmin, zmax);
    if (rmax < rmin) std::swap(rmin, rmax);
 
    bool horizontal = (std::abs(zmax - zmin) > std::abs(rmax - rmin));
    if (horizontal) {
      double rmid = 0.5 * (rmin + rmax);
      return Ray(Point(zmin, rmid), Point(zmax, rmid));
    } else {
      double zmid = 0.5 * (zmin + zmax);
      return Ray(Point(zmid, rmin), Point(zmid, rmax));
    }
  }

makeVolumes()

void InDetDD::VolumeSplitter::makeVolumes ( const Zone *  zone, const ServiceVolume &  origVolume  )

private

Definition at line 61 of file VolumeSplitter.cxx.

                                                                               {
    // See if its a symmetric volume
    if (origVolume.zsymm()) {
      ServiceVolume param1(origVolume);
      ServiceVolume param2(origVolume);
      param1.addLabel("A");
      param1.setNeedsRotation(false);
      param2.addLabel("C");
      param2.setZmin(-origVolume.zmax());
      param2.setZmax(-origVolume.zmin());
      param2.setNeedsRotation(origVolume.needsRotation());
      splitVolume(zone, param1);
      splitVolume(zone, param2);
    } else {
      ServiceVolume param1(origVolume);
      param1.setNeedsRotation(false);
      splitVolume(zone, param1);
    }
  }

split()

void InDetDD::VolumeSplitter::split	(	const Zone &	zone,
		const ServiceVolume &	origVolume
	)

Definition at line 36 of file VolumeSplitter.cxx.

                                                                         {
    makeVolumes(&zone, origVolume);
  }

splitAll()

const std::vector< const ServiceVolume * > & InDetDD::VolumeSplitter::splitAll	(	const Zone &	zone,
		const std::vector< const ServiceVolume * > &	origVolumeList
	)

Definition at line 28 of file VolumeSplitter.cxx.

                                                                                                  {
    for (unsigned int i = 0; i < origVolumeList.size(); ++i) {
      split(zone, *(origVolumeList[i]));
    }
    return m_volumes;
  }

splitVolume()

void InDetDD::VolumeSplitter::splitVolume ( const Zone *  zone, const ServiceVolume &  vol  )

private

Definition at line 82 of file VolumeSplitter.cxx.

                                                                          {
    Ray ray = makeRay(param);
    SegmentSplitter splitter;
    const SegmentList& segments = splitter.split(zone, ray);
 
    //std::cout << "Segments: " << std::endl;
    //segments.print();
 
    double volumeTotal = 0;
 
    std::vector<ServiceVolume* > tmpServiceVec;
    tmpServiceVec.reserve(segments.size());
    for (unsigned int i = 0; i < segments.size(); ++i) {
      const Segment& seg = segments.getSegment(i);
      ServiceVolume* paramNew = new ServiceVolume(param);
 
      if (segments.horizontal()) {
        if (param.splittableInZ()) {
          paramNew->setZmin(seg.zmin());
          paramNew->setZmax(seg.zmax());
          // If z changed adjust r in cone like volumes
          adjustR(param, paramNew);
        } else if (i == 1) {
          std::cout << "Volume " << param.fullLabel() << " cannot be split in Z" << std::endl;
        }
      } else {
        // vertical
        if (param.splittableInR()) {
          paramNew->setRmin(seg.rmin());
          paramNew->setRmax(seg.rmax());
        } else if (i == 1) {
          std::cout << "Volume " << param.fullLabel() << " cannot be split in R" << std::endl;
        }
      }
 
      if (seg.rotated()) {
        // Often the -ve endcap region is created as the +ve endcap and then rotated. Therefore we have to reflect the z
        // coords.
        // Also have to turn off the needsRotation flag in case it was set.
        //std::cout << "Segment " << i << " rotated " << paramNew->zmin() << " " << paramNew->zmax() <<std::endl;
        double zminTmp = paramNew->zmin();
        paramNew->setZmin(-paramNew->zmax());
        paramNew->setZmax(-zminTmp);
        paramNew->setNeedsRotation(false);
        //std::cout << "After adjusted " << paramNew->zmin() << " " << paramNew->zmax() <<std::endl;
      }
 
      if (param.splittableInZ()) {
        paramNew->reduceSize(m_epsilon); // safety gap between volumes
      }
 
      paramNew->setRegion(seg.label());
      tmpServiceVec.push_back(paramNew);
 
      paramNew->getShape();
      volumeTotal += paramNew->volume();
      //std::cout << i << ": volume: " <<  paramNew->volume() << std::endl;
    }
    //std::cout << "Total volume: " << volumeTotal << std::endl;
    for (unsigned int i = 0; i < segments.size(); ++i) {
      ServiceVolume* paramNew = tmpServiceVec[i];
      if (segments.size() > 1) {
        std::ostringstream ostr;
        ostr << "_" << i + 1;
        paramNew->addLabel(ostr.str());
      }
      paramNew->setOrigVolume(volumeTotal);
      m_volumes.push_back(paramNew);
    }
  }

takeOwnership()

void InDetDD::VolumeSplitter::takeOwnership ( )

inline

Definition at line 25 of file VolumeSplitter.h.

{m_ownVolumes = false;}

Member Data Documentation

m_epsilon

double InDetDD::VolumeSplitter::m_epsilon

private

Definition at line 33 of file VolumeSplitter.h.

m_ownVolumes

bool InDetDD::VolumeSplitter::m_ownVolumes

private

Definition at line 32 of file VolumeSplitter.h.

m_volumes

std::vector<const ServiceVolume *> InDetDD::VolumeSplitter::m_volumes

private

Definition at line 34 of file VolumeSplitter.h.

---

The documentation for this class was generated from the following files:

• VolumeSplitter.h
• VolumeSplitter.cxx