---

global_simpleAngular_0 Class Reference

(. More...

#include <DetectorDescription/Algorithm/src/global_simpleAngular.h>

Inheritance diagram for global_simpleAngular_0:

List of all members.

Public Member Functions
bool	checkParameters ()
	subclass must check the supplied parameters ParE_, ParS_
void	checkTermination ()
	for algorithms with incr_==0 the algorithm must check whether to terminate
	global_simpleAngular_0 (AlgoPos *, std::string label)
DDRotationMatrix	rotation ()
	subclass must calculate a rotation matrix
void	stream (std::ostream &) const
DDTranslation	translation ()
	subclass must calculate a translation std::vector
	~global_simpleAngular_0 ()

---

Detailed Description

(.

..THIS COULD BE DOXYGEN CONFORMANT ...) Angular positioning according to the formula:

offset ... an angle offset from which to start the positioning

radius ... an offset distance in the radial direction.

delta ... angular delta between each position.

number ... number of times to position within the range rotate ... boolean text, T or F, True or False, 1 or zero. Use this to indicate if the self logical part should be rotated. Since the DDD uses double or std::string, I'm using std::string. default = "T" orientation ... std::string: rotation matrix name to be used to orient the part within the mother. This is a DDLrRotation.

The algorithm has (at least) two implementations.

The first is selected if delta is specified and number is NOT specified. In this algorithm, the positioning is relatively straight-forward.

The second is selected if number is specified and delta is NOT specified. This should use the first one by specifying a delta based on dividing up 360 degrees by the number of positionings desired. For this one, CheckTermination is used to determine when to stop making them.

Some methods are only specific to this algorithm (I HOPE)

Definition at line 57 of file global_simpleAngular.h.

---

Constructor & Destructor Documentation

global_simpleAngular_0::global_simpleAngular_0	(	AlgoPos *	a,
		std::string	label
	)

Definition at line 21 of file global_simpleAngular.cc.

 : AlgoImpl(a,label)
{ }

global_simpleAngular_0::~global_simpleAngular_0

(

)

Definition at line 25 of file global_simpleAngular.cc.

{ }

---

Member Function Documentation

bool global_simpleAngular_0::checkParameters

(

)

[virtual]

subclass must check the supplied parameters ParE_, ParS_

whether they are correct and should select this paricular algorithm.

If the parameters are correct by should not select this particular algorithm, checkParamters must return false otherwise true.

The std::string err_ is to be used to be extended with error information in case any errors have been detected. Error information must be attached to err_ because of the possibility of already contained error information.

In case of errors: If an DDException is thrown by the algorithm implementation, further processing of any other implementations of the algorithm will be stopped. If no exception is thrown, checkParamters must return false. It's preferable not to throw an exception in case of errors. The algorithm implementation will throw if all checkParamters() of all registered algorithm implementations have returned false.

Implements AlgoImpl.

Definition at line 28 of file global_simpleAngular.cc.

References AlgoImpl::err_, AlgoImpl::ParE_, HLT_VtxMuL3::result, and size.

{
/* besides the automatic generated checking for the input params, 
     we have to decide, whether the params are correct and should
     select this implementation 
  */
                  
  bool result = true;   
                  
  // check for presence of delta
  if (ParE_["delta"].size() == 0) {
    result = false; // don't select this implementation, because delta is missing
  }
  else {
    // check for valid delta-value
    if (ParE_["delta"][0] == 0.) {
      err_ += "\tdelta can not be zero\n";
      result = false;
    }
  }

  // check for presence of number
  if (ParE_["number"].size() != 0) {
//    err_ += "\tcan not specify a delta and a number\n";
    result = false;
  }  
  return result;  
}

void global_simpleAngular_0::checkTermination

(

)

[virtual]

for algorithms with incr_==0 the algorithm must check whether to terminate

Overload this function in case the algorithm is a 'incr_==0' type. In this case provide some code which checks using perhaps the value of count_ and/or supplied algorithm parameters to check whether terminate() has to be called or not. If terminate() is called, the current iteration of the algorithm is not taken into account!

The default implementation will immidiately terminate the algorithm in case incr_==0.

In case of incr_!=0: checkTermination() is not called at all; the algorithm will terminate automatically when the specified range [start_, end_, incr_] has been covered or terminate() has been called from within translation() or rotation().

Reimplemented from AlgoImpl.

Definition at line 149 of file global_simpleAngular.cc.

References AlgoImpl::count_, AlgoImpl::ParE_, and AlgoImpl::terminate().

{
  // initially I thought of ending our rotation algorithm at the vertical
  // (+x), but decided it should always go full circle.
  //  if ((ParE_["offset"][0] + ParE_["delta"][0] * count_ / deg) > 360.)
  if (ParE_["delta"][0] * count_ / deg > 360.)
    terminate();

}

DDRotationMatrix global_simpleAngular_0::rotation

(

)

[virtual]

subclass must calculate a rotation matrix

depending on the current position curr_ in the range [start_,end_,incr_] and the user supplied parameters ParE_, ParS_

Implements AlgoImpl.

Definition at line 72 of file global_simpleAngular.cc.

References angle(), AlgoImpl::count_, GenMuonPlsPt100GeV_cfg::cout, lat::endl(), i, j, name, AlgoImpl::ParE_, AlgoImpl::ParS_, DDRotation::rotation(), and size.

{
  std::cout << "ParS_[\"rotate\"][0] = " << ParS_["rotate"][0] << std::endl; 
  if (ParS_["rotate"][0] == "T" || ParS_["rotate"][0] == "1"
      || ParS_["rotate"][0] == "True")
    {
      double angle = -(ParE_["offset"][0]/rad + (ParE_["delta"][0]/rad) * (count_ - 1));
      DDRotationMatrix rm1;
      if (ParS_["orientation"].size() != 0)
        {
          std::string name=ParS_["orientation"][0];
          size_t foundColon = 0;
          std::string rn = "";
          std::string ns = "";
          while (foundColon < name.size() && name[foundColon] != ':')
            ++foundColon;
          if (foundColon != name.size())
            {
              for (size_t j = foundColon + 1; j < name.size(); ++j)
                rn = rn + name[j];
              for (size_t i = 0; i < foundColon; ++i)
                ns = ns + name[i];
            }
          if (rn != "" && ns != "")
            {
              DDRotation myDDRotation(DDName(rn, ns));
              rm1 = *(myDDRotation.rotation());
            }
          else
            std::cout << "MAJOR PROBLEM: expected a fully qualified DDName but got :" 
                 << name << std::endl;
        }
      ROOT::Math::RotationZ rm(angle);
      rm1.Invert(); 
      rm.Invert();
      return rm * rm1;
    }
  else if (ParS_["orientation"].size() != 0)
    {
      // return the orientation matrix
      std::string name=ParS_["orientation"][0];
      size_t foundColon = 0;
      std::string rn = "";
      std::string ns = "";
      while (foundColon < name.size() && name[foundColon] != ':')
        ++foundColon;
      if (foundColon != name.size())
        {
          for (size_t j = foundColon + 1; j < name.size(); ++j)
            rn = rn + name[j];
          for (size_t i = 0; i < foundColon; ++i)
            ns = ns + name[i];
        }
      if (rn != "" && ns != "")
        {
          
          DDRotation myDDRotation(DDName(rn, ns));
          std::cout << "about to return *(myDDRotation.rotation())" << std::endl;
          std::cout << *myDDRotation.rotation() << std::endl;
          return *(myDDRotation.rotation());
        }
      else
        std::cout << "MAJOR PROBLEM: expected a fully qualified DDName but got " 
             << name << " therefore could not look up the rotation." << std::endl;
      return DDRotationMatrix();
    }
  else
    {
      return DDRotationMatrix(); // return identity matrix.
    }
}   

void global_simpleAngular_0::stream

(

std::ostream &

os

)

const

Definition at line 160 of file global_simpleAngular.cc.

{
  os << "global_simplesimpleAngular_0::stream(): not implemented.";
}

DDTranslation global_simpleAngular_0::translation

(

)

[virtual]

subclass must calculate a translation std::vector

depending on the current position curr_ in the range [start_,end_,incr_] and the user supplied parameters ParE_, ParS_

Implements AlgoImpl.

Definition at line 58 of file global_simpleAngular.cc.

References funct::cos(), AlgoImpl::count_, offset, AlgoImpl::ParE_, radius(), and funct::sin().

{
  double offset  = ParE_["offset"][0]/rad;
  double delta   = ParE_["delta"][0]/rad;
  double radius  = ParE_["radius"][0];
//  std::cout << "x = " << radius * cos(offset + delta * (count_ - 1)) << "  y = " << radius * sin(offset + delta * (count_ - 1)) << std::endl;
  DDTranslation trans(radius * cos(offset + delta * (count_ - 1)),
                      radius * sin(offset + delta * (count_ - 1)),
                      0. );
                 
  return trans;
}

---

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

• DetectorDescription/Algorithm/src/global_simpleAngular.h
• DetectorDescription/Algorithm/src/global_simpleAngular.cc

---