// @(#)root/geom:$Id$
// Author: Andrei Gheata   24/10/01
// TGeoTrd1::Contains() and DistFromInside() implemented by Mihaela Gheata

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//_____________________________________________________________________________
// TGeoTrd1 - a trapezoid with only x length varying with z. It has 4
//   parameters, the half length in x at the low z surface, that at the
//   high z surface, the half length in y, and in z
//
//_____________________________________________________________________________
//Begin_Html
/*
<img src="gif/t_trd1.gif">
*/
//End_Html

//Begin_Html
/*
<img src="gif/t_trd1divY.gif">
*/
//End_Html

//Begin_Html
/*
<img src="gif/t_trd1divZ.gif">
*/
//End_Html

//Begin_Html
/*
<img src="gif/t_trd1divstepZ.gif">
*/
//End_Html

#include "Riostream.h"

#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TGeoVolume.h"
#include "TGeoTrd1.h"
#include "TMath.h"

ClassImp(TGeoTrd1)

//_____________________________________________________________________________
TGeoTrd1::TGeoTrd1()
{
   // dummy ctor
   fDz = fDx1 = fDx2 = fDy = 0;
   SetShapeBit(kGeoTrd1);
}

//_____________________________________________________________________________
TGeoTrd1::TGeoTrd1(Double_t dx1, Double_t dx2, Double_t dy, Double_t dz)
         :TGeoBBox(0,0,0)
{
// constructor.
   SetShapeBit(kGeoTrd1);
   fDx1 = dx1;
   fDx2 = dx2;
   fDy = dy;
   fDz = dz;
   if ((dx1<0) || (dx2<0) || (dy<0) || (dz<0)) {
      SetShapeBit(kGeoRunTimeShape);
      printf("trd1 : dx1=%f, dx2=%f, dy=%f, dz=%f\n",
              dx1,dx2,dy,dz);
   }
   else ComputeBBox();
}

//_____________________________________________________________________________
TGeoTrd1::TGeoTrd1(const char *name, Double_t dx1, Double_t dx2, Double_t dy, Double_t dz)
         :TGeoBBox(name, 0,0,0)
{
// constructor.
   SetShapeBit(kGeoTrd1);
   fDx1 = dx1;
   fDx2 = dx2;
   fDy = dy;
   fDz = dz;
   if ((dx1<0) || (dx2<0) || (dy<0) || (dz<0)) {
      SetShapeBit(kGeoRunTimeShape);
      printf("trd1 : dx1=%f, dx2=%f, dy=%f, dz=%f\n",
              dx1,dx2,dy,dz);
   }
   else ComputeBBox();
}

//_____________________________________________________________________________
TGeoTrd1::TGeoTrd1(Double_t *param)
         :TGeoBBox(0,0,0)
{
   // ctor with an array of parameters
   // param[0] = dx1
   // param[1] = dx2
   // param[2] = dy
   // param[3] = dz
   SetShapeBit(kGeoTrd1);
   SetDimensions(param);
   if ((fDx1<0) || (fDx2<0) || (fDy<=0) || (fDz<=0)) SetShapeBit(kGeoRunTimeShape);
   else ComputeBBox();
}

//_____________________________________________________________________________
TGeoTrd1::~TGeoTrd1()
{
// destructor
}

//_____________________________________________________________________________
Double_t TGeoTrd1::Capacity() const
{
// Computes capacity of the shape in [length^3]
   Double_t capacity = 4.*(fDx1+fDx2)*fDy*fDz;
   return capacity;
}

//_____________________________________________________________________________
void TGeoTrd1::ComputeBBox()
{
// compute bounding box for a trd1
   fDX = TMath::Max(fDx1, fDx2);
   fDY = fDy;
   fDZ = fDz;
   memset(fOrigin, 0, 3*sizeof(Double_t));
}

//_____________________________________________________________________________
void TGeoTrd1::ComputeNormal(const Double_t *point, const Double_t *dir, Double_t *norm)
{
// Compute normal to closest surface from POINT.
   Double_t safe, safemin;
   //--- Compute safety first
   Double_t fx = 0.5*(fDx1-fDx2)/fDz;
   Double_t calf = 1./TMath::Sqrt(1.0+fx*fx);
   // check Z facettes
   safe = safemin = TMath::Abs(fDz-TMath::Abs(point[2]));
   norm[0] = norm[1] = 0;
   norm[2] = (dir[2]>=0)?1:-1;
   if (safe<1E-6) return;
   // check X facettes
   Double_t distx = 0.5*(fDx1+fDx2)-fx*point[2];
   if (distx>=0) {
      safe=TMath::Abs(distx-TMath::Abs(point[0]))*calf;
      if (safe<safemin) {
         safemin = safe;
         norm[0] = (point[0]>0)?calf:(-calf);
         norm[1] = 0;
         norm[2] = calf*fx;
         Double_t dot = norm[0]*dir[0]+norm[1]*dir[1]+norm[2]*dir[2];
         if (dot<0) {
            norm[0] = -norm[0];
            norm[2] = -norm[2];
         }
         if (safe<1E-6) return;
      }
   }
   // check Y facettes
   safe = TMath::Abs(fDy-TMath::Abs(point[1]));
   if (safe<safemin) {
      norm[0] = norm[2] = 0;
      norm[1] = (dir[1]>=0)?1:-1;
   }
}

//_____________________________________________________________________________
Bool_t TGeoTrd1::Contains(const Double_t *point) const
{
// test if point is inside this shape
   // check Z range
   if (TMath::Abs(point[2]) > fDz) return kFALSE;
   // then y
   if (TMath::Abs(point[1]) > fDy) return kFALSE;
   // then x
   Double_t dx = 0.5*(fDx2*(point[2]+fDz)+fDx1*(fDz-point[2]))/fDz;
   if (TMath::Abs(point[0]) > dx) return kFALSE;
   return kTRUE;
}

//_____________________________________________________________________________
Double_t TGeoTrd1::DistFromInside(const Double_t *point, const Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
// Compute distance from inside point to surface of the trd1
// Boundary safe algorithm.
   Double_t snxt = TGeoShape::Big();
   if (iact<3 && safe) {
   // compute safe distance
      *safe = Safety(point, kTRUE);
      if (iact==0) return TGeoShape::Big();
      if (iact==1 && step<*safe) return TGeoShape::Big();
   }

   //--- Compute safety first
   Double_t fx = 0.5*(fDx1-fDx2)/fDz;
   Double_t cn;
   Double_t distx = 0.5*(fDx1+fDx2)-fx*point[2];
   //--- Compute distance to this shape
   // first check if Z facettes are crossed
   Double_t dist[3];
   for (Int_t i=0; i<3; i++) dist[i]=TGeoShape::Big();
   if (dir[2]<0) {
      dist[0]=-(point[2]+fDz)/dir[2];
   } else if (dir[2]>0) {
      dist[0]=(fDz-point[2])/dir[2];
   }
   if (dist[0]<=0) return 0.0;
   // now check X facettes
   cn = -dir[0]+fx*dir[2];
   if (cn>0) {
      dist[1] = point[0]+distx;
      if (dist[1]<=0) return 0.0;
      dist[1] /= cn;
   }
   cn = dir[0]+fx*dir[2];
   if (cn>0) {
      Double_t s = distx-point[0];
      if (s<=0) return 0.0;
      s /= cn;
      if (s<dist[1]) dist[1] = s;
   }
   // now check Y facettes
   if (dir[1]<0) {
      dist[2]=-(point[1]+fDy)/dir[1];
   } else if (dir[1]>0) {
      dist[2]=(fDy-point[1])/dir[1];
   }
   if (dist[2]<=0) return 0.0;
   snxt = dist[TMath::LocMin(3,dist)];
   return snxt;
}

//_____________________________________________________________________________
void TGeoTrd1::GetVisibleCorner(const Double_t *point, Double_t *vertex, Double_t *normals) const
{
// get the most visible corner from outside point and the normals
   Double_t fx = 0.5*(fDx1-fDx2)/fDz;
   Double_t calf = 1./TMath::Sqrt(1.0+fx*fx);
   Double_t salf = calf*fx;
   // check visibility of X faces
   Double_t distx = 0.5*(fDx1+fDx2)-fx*point[2];
   memset(normals, 0, 9*sizeof(Double_t));
   TGeoTrd1 *trd1 = (TGeoTrd1*)this;
   if (point[0]>distx) {
   // hi x face visible
      trd1->SetShapeBit(kGeoVisX);
      normals[0]=calf;
      normals[2]=salf;
   } else {
      trd1->SetShapeBit(kGeoVisX, kFALSE);
      normals[0]=-calf;
      normals[2]=salf;
   }
   if (point[1]>fDy) {
   // hi y face visible
      trd1->SetShapeBit(kGeoVisY);
      normals[4]=1;
   } else {
      trd1->SetShapeBit(kGeoVisY, kFALSE);
      normals[4]=-1;
   }
   if (point[2]>fDz) {
   // hi z face visible
      trd1->SetShapeBit(kGeoVisZ);
      normals[8]=1;
   } else {
      trd1->SetShapeBit(kGeoVisZ, kFALSE);
      normals[8]=-1;
   }
   SetVertex(vertex);
}

//_____________________________________________________________________________
void TGeoTrd1::GetOppositeCorner(const Double_t * /*point*/, Int_t inorm, Double_t *vertex, Double_t *normals) const
{
// get the opposite corner of the intersected face
   TGeoTrd1 *trd1 = (TGeoTrd1*)this;
   if (inorm != 0) {
   // change x face
      trd1->SetShapeBit(kGeoVisX, !TestShapeBit(kGeoVisX));
      normals[0]=-normals[0];
   }
   if (inorm != 1) {
   // change y face
      trd1->SetShapeBit(kGeoVisY, !TestShapeBit(kGeoVisY));
      normals[4]=-normals[4];
   }
   if (inorm != 2) {
   // hi z face visible
      trd1->SetShapeBit(kGeoVisZ, !TestShapeBit(kGeoVisZ));
      normals[8]=-normals[8];
   }
   SetVertex(vertex);
}

//_____________________________________________________________________________
Double_t TGeoTrd1::DistFromOutside(const Double_t *point, const Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
// Compute distance from outside point to surface of the trd1
// Boundary safe algorithm
   Double_t snxt = TGeoShape::Big();
   if (iact<3 && safe) {
   // compute safe distance
      *safe = Safety(point, kFALSE);
      if (iact==0) return TGeoShape::Big();
      if (iact==1 && step<*safe) return TGeoShape::Big();
   }
   // find a visible face
   Double_t xnew,ynew,znew;
   Double_t fx = 0.5*(fDx1-fDx2)/fDz;
   Double_t cn;
   Double_t distx = 0.5*(fDx1+fDx2)-fx*point[2];
   Bool_t in = kTRUE;
   Double_t safx = distx-TMath::Abs(point[0]);
   Double_t safy = fDy-TMath::Abs(point[1]);
   Double_t safz = fDz-TMath::Abs(point[2]);

   //--- Compute distance to this shape
   // first check if Z facettes are crossed
   if (point[2]<=-fDz) {
      if (dir[2]<=0) return TGeoShape::Big();
      in = kFALSE;
      snxt = -(fDz+point[2])/dir[2];
      // find extrapolated X and Y
      xnew = point[0]+snxt*dir[0];
      if (TMath::Abs(xnew) <= fDx1) {
         ynew = point[1]+snxt*dir[1];
         if (TMath::Abs(ynew) <= fDy) return snxt;
      }
   } else if (point[2]>=fDz) {
      if (dir[2]>=0) return TGeoShape::Big();
      in = kFALSE;
      snxt = (fDz-point[2])/dir[2];
      // find extrapolated X and Y
      xnew = point[0]+snxt*dir[0];
      if (TMath::Abs(xnew) <= fDx2) {
         ynew = point[1]+snxt*dir[1];
         if (TMath::Abs(ynew) <= fDy) return snxt;
      }
   }
   // check if X facettes are crossed
   if (point[0]<=-distx) {
      cn = -dir[0]+fx*dir[2];
      if (cn>=0) return TGeoShape::Big();
      in = kFALSE;
      snxt = (point[0]+distx)/cn;
      // find extrapolated Y and Z
      ynew = point[1]+snxt*dir[1];
      if (TMath::Abs(ynew) <= fDy) {
         znew = point[2]+snxt*dir[2];
         if (TMath::Abs(znew) <= fDz) return snxt;
      }
   }
   if (point[0]>=distx) {
      cn = dir[0]+fx*dir[2];
      if (cn>=0) return TGeoShape::Big();
      in = kFALSE;
      snxt = (distx-point[0])/cn;
      // find extrapolated Y and Z
      ynew = point[1]+snxt*dir[1];
      if (TMath::Abs(ynew) < fDy) {
         znew = point[2]+snxt*dir[2];
         if (TMath::Abs(znew) < fDz) return snxt;
      }
   }
   // finally check Y facettes
   if (point[1]<=-fDy) {
      cn = -dir[1];
      if (cn>=0) return TGeoShape::Big();
      in = kFALSE;
      snxt = (point[1]+fDy)/cn;
      // find extrapolated X and Z
      znew = point[2]+snxt*dir[2];
      if (TMath::Abs(znew) < fDz) {
         xnew = point[0]+snxt*dir[0];
         Double_t dx = 0.5*(fDx1+fDx2)-fx*znew;
         if (TMath::Abs(xnew) < dx) return snxt;
      }
   } else if (point[1]>=fDy) {
      cn = dir[1];
      if (cn>=0) return TGeoShape::Big();
      in = kFALSE;
      snxt = (fDy-point[1])/cn;
      // find extrapolated X and Z
      znew = point[2]+snxt*dir[2];
      if (TMath::Abs(znew) < fDz) {
         xnew = point[0]+snxt*dir[0];
         Double_t dx = 0.5*(fDx1+fDx2)-fx*znew;
         if (TMath::Abs(xnew) < dx) return snxt;
      }
   }
   if (!in) return TGeoShape::Big();
   // Point actually inside
   if (safz<safx && safz<safy) {
      if (point[2]*dir[2]>=0) return TGeoShape::Big();
      return 0.0;
   }
   if (safy<safx) {
      if (point[1]*dir[1]>=0) return TGeoShape::Big();
      return 0.0;
   }
   cn = TMath::Sign(1.0,point[0])*dir[0]+fx*dir[2];
   if (cn>=0) return TGeoShape::Big();
   return 0.0;
}

//_____________________________________________________________________________
TGeoVolume *TGeoTrd1::Divide(TGeoVolume *voldiv, const char *divname, Int_t iaxis, Int_t ndiv,
                             Double_t start, Double_t step)
{
//--- Divide this trd1 shape belonging to volume "voldiv" into ndiv volumes
// called divname, from start position with the given step. Returns pointer
// to created division cell volume in case of Y divisions. For Z divisions just
// return the pointer to the volume to be divided. In case a wrong
// division axis is supplied, returns pointer to volume that was divided.
   TGeoShape *shape;           //--- shape to be created
   TGeoVolume *vol;            //--- division volume to be created
   TGeoVolumeMulti *vmulti;    //--- generic divided volume
   TGeoPatternFinder *finder;  //--- finder to be attached
   TString opt = "";           //--- option to be attached
   Double_t zmin, zmax, dx1n, dx2n;
   Int_t id;
   Double_t end = start+ndiv*step;
   switch (iaxis) {
      case 1:
         Warning("Divide", "dividing a Trd1 on X not implemented");
         return 0;
      case 2:
         finder = new TGeoPatternY(voldiv, ndiv, start, end);
         voldiv->SetFinder(finder);
         finder->SetDivIndex(voldiv->GetNdaughters());
         shape = new TGeoTrd1(fDx1, fDx2, step/2, fDz);
         vol = new TGeoVolume(divname, shape, voldiv->GetMedium());
         vmulti = gGeoManager->MakeVolumeMulti(divname, voldiv->GetMedium());
         vmulti->AddVolume(vol);
         opt = "Y";
         for (id=0; id<ndiv; id++) {
            voldiv->AddNodeOffset(vol, id, start+step/2+id*step, opt.Data());
            ((TGeoNodeOffset*)voldiv->GetNodes()->At(voldiv->GetNdaughters()-1))->SetFinder(finder);
         }
         return vmulti;
      case 3:
         finder = new TGeoPatternZ(voldiv, ndiv, start, end);
         voldiv->SetFinder(finder);
         finder->SetDivIndex(voldiv->GetNdaughters());
         vmulti = gGeoManager->MakeVolumeMulti(divname, voldiv->GetMedium());
         for (id=0; id<ndiv; id++) {
            zmin = start+id*step;
            zmax = start+(id+1)*step;
            dx1n = 0.5*(fDx1*(fDz-zmin)+fDx2*(fDz+zmin))/fDz;
            dx2n = 0.5*(fDx1*(fDz-zmax)+fDx2*(fDz+zmax))/fDz;
            shape = new TGeoTrd1(dx1n, dx2n, fDy, step/2.);
            vol = new TGeoVolume(divname, shape, voldiv->GetMedium());
            vmulti->AddVolume(vol);
            opt = "Z";
            voldiv->AddNodeOffset(vol, id, start+step/2+id*step, opt.Data());
            ((TGeoNodeOffset*)voldiv->GetNodes()->At(voldiv->GetNdaughters()-1))->SetFinder(finder);
         }
         return vmulti;
      default:
         Error("Divide", "Wrong axis type for division");
         return 0;
   }
}

//_____________________________________________________________________________
Double_t TGeoTrd1::GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const
{
// Get range of shape for a given axis.
   xlo = 0;
   xhi = 0;
   Double_t dx = 0;
   switch (iaxis) {
      case 2:
         xlo = -fDy;
         xhi = fDy;
         dx = xhi-xlo;
         return dx;
      case 3:
         xlo = -fDz;
         xhi = fDz;
         dx = xhi-xlo;
         return dx;
   }
   return dx;
}

//_____________________________________________________________________________
void TGeoTrd1::GetBoundingCylinder(Double_t *param) const
{
//--- Fill vector param[4] with the bounding cylinder parameters. The order
// is the following : Rmin, Rmax, Phi1, Phi2
   TGeoBBox::GetBoundingCylinder(param);
}

//_____________________________________________________________________________
Int_t TGeoTrd1::GetFittingBox(const TGeoBBox *parambox, TGeoMatrix *mat, Double_t &dx, Double_t &dy, Double_t &dz) const
{
// Fills real parameters of a positioned box inside this. Returns 0 if successfull.
   dx=dy=dz=0;
   if (mat->IsRotation()) {
      Error("GetFittingBox", "cannot handle parametrized rotated volumes");
      return 1; // ### rotation not accepted ###
   }
   //--> translate the origin of the parametrized box to the frame of this box.
   Double_t origin[3];
   mat->LocalToMaster(parambox->GetOrigin(), origin);
   if (!Contains(origin)) {
      Error("GetFittingBox", "wrong matrix - parametrized box is outside this");
      return 1; // ### wrong matrix ###
   }
   //--> now we have to get the valid range for all parametrized axis
   Double_t dd[3];
   dd[0] = parambox->GetDX();
   dd[1] = parambox->GetDY();
   dd[2] = parambox->GetDZ();
   //-> check if Z range is fixed
   if (dd[2]<0) {
      dd[2] = TMath::Min(origin[2]+fDz, fDz-origin[2]);
      if (dd[2]<0) {
         Error("GetFittingBox", "wrong matrix");
         return 1;
      }
   }
   //-> check if Y range is fixed
   if (dd[1]<0) {
      dd[1] = TMath::Min(origin[1]+fDy, fDy-origin[1]);
      if (dd[1]<0) {
         Error("GetFittingBox", "wrong matrix");
         return 1;
      }
   }
   if (dd[0]>=0) {
      dx = dd[0];
      dy = dd[1];
      dz = dd[2];
      return 0;
   }
   //-> check now range at Z = origin[2] +/- dd[2]
   Double_t fx = 0.5*(fDx1-fDx2)/fDz;
   Double_t dx0 = 0.5*(fDx1+fDx2);
   Double_t z=origin[2]-dd[2];
   dd[0] = dx0-fx*z-origin[0];
   z=origin[2]+dd[2];
   dd[0] = TMath::Min(dd[0], dx0-fx*z-origin[0]);
   if (dd[0]<0) {
      Error("GetFittingBox", "wrong matrix");
      return 1;
   }
   dx = dd[0];
   dy = dd[1];
   dz = dd[2];
   return 0;
}

//_____________________________________________________________________________
TGeoShape *TGeoTrd1::GetMakeRuntimeShape(TGeoShape *mother, TGeoMatrix * /*mat*/) const
{
// in case shape has some negative parameters, these has to be computed
// in order to fit the mother
   if (!TestShapeBit(kGeoRunTimeShape)) return 0;
   if (!mother->TestShapeBit(kGeoTrd1)) {
      Error("GetMakeRuntimeShape", "invalid mother");
      return 0;
   }
   Double_t dx1, dx2, dy, dz;
   if (fDx1<0) dx1=((TGeoTrd1*)mother)->GetDx1();
   else dx1=fDx1;
   if (fDx2<0) dx2=((TGeoTrd1*)mother)->GetDx2();
   else dx2=fDx2;
   if (fDy<0) dy=((TGeoTrd1*)mother)->GetDy();
   else dy=fDy;
   if (fDz<0) dz=((TGeoTrd1*)mother)->GetDz();
   else dz=fDz;

   return (new TGeoTrd1(dx1, dx2, dy, dz));
}

//_____________________________________________________________________________
void TGeoTrd1::InspectShape() const
{
// print shape parameters
   printf("*** Shape %s: TGeoTrd1 ***\n", GetName());
   printf("    dx1 = %11.5f\n", fDx1);
   printf("    dx2 = %11.5f\n", fDx2);
   printf("    dy  = %11.5f\n", fDy);
   printf("    dz  = %11.5f\n", fDz);
   printf(" Bounding box:\n");
   TGeoBBox::InspectShape();
}

//_____________________________________________________________________________
Double_t TGeoTrd1::Safety(const Double_t *point, Bool_t in) const
{
// computes the closest distance from given point to this shape, according
// to option. The matching point on the shape is stored in spoint.
   Double_t saf[3];
   //--- Compute safety first
   // check Z facettes
   saf[0] = fDz-TMath::Abs(point[2]);
   Double_t fx = 0.5*(fDx1-fDx2)/fDz;
   Double_t calf = 1./TMath::Sqrt(1.0+fx*fx);
   // check X facettes
   Double_t distx = 0.5*(fDx1+fDx2)-fx*point[2];
   if (distx<0) saf[1]=TGeoShape::Big();
   else         saf[1]=(distx-TMath::Abs(point[0]))*calf;
   // check Y facettes
   saf[2] = fDy-TMath::Abs(point[1]);
   if (in) return saf[TMath::LocMin(3,saf)];
   for (Int_t i=0; i<3; i++) saf[i]=-saf[i];
   return saf[TMath::LocMax(3,saf)];
}

//_____________________________________________________________________________
void TGeoTrd1::SavePrimitive(std::ostream &out, Option_t * /*option*/ /*= ""*/)
{
// Save a primitive as a C++ statement(s) on output stream "out".
   if (TObject::TestBit(kGeoSavePrimitive)) return;
   out << "   // Shape: " << GetName() << " type: " << ClassName() << std::endl;
   out << "   dx1 = " << fDx1 << ";" << std::endl;
   out << "   dx2 = " << fDx2 << ";" << std::endl;
   out << "   dy  = " << fDy  << ";" << std::endl;
   out << "   dz  = " << fDZ  << ";" << std::endl;
   out << "   TGeoShape *" << GetPointerName() << " = new TGeoTrd1(\"" << GetName() << "\", dx1,dx2,dy,dz);" << std::endl;
   TObject::SetBit(TGeoShape::kGeoSavePrimitive);
}

//_____________________________________________________________________________
void TGeoTrd1::SetDimensions(Double_t *param)
{
// set trd1 params in one step :
   fDx1 = param[0];
   fDx2 = param[1];
   fDy  = param[2];
   fDz  = param[3];
   ComputeBBox();
}

//_____________________________________________________________________________
void TGeoTrd1::SetVertex(Double_t *vertex) const
{
// set vertex of a corner according to visibility flags
   if (TestShapeBit(kGeoVisX)) {
      if (TestShapeBit(kGeoVisZ)) {
         vertex[0] = fDx2;
         vertex[2] = fDz;
         vertex[1] = (TestShapeBit(kGeoVisY))?fDy:-fDy;
      } else {
         vertex[0] = fDx1;
         vertex[2] = -fDz;
         vertex[1] = (TestShapeBit(kGeoVisY))?fDy:-fDy;
      }
   } else {
      if (TestShapeBit(kGeoVisZ)) {
         vertex[0] = -fDx2;
         vertex[2] = fDz;
         vertex[1] = (TestShapeBit(kGeoVisY))?fDy:-fDy;
      } else {
         vertex[0] = -fDx1;
         vertex[2] = -fDz;
         vertex[1] = (TestShapeBit(kGeoVisY))?fDy:-fDy;
      }
   }
}

//_____________________________________________________________________________
void TGeoTrd1::SetPoints(Double_t *points) const
{
// create arb8 mesh points
   if (!points) return;
   points[ 0] = -fDx1; points[ 1] = -fDy; points[ 2] = -fDz;
   points[ 3] = -fDx1; points[ 4] =  fDy; points[ 5] = -fDz;
   points[ 6] =  fDx1; points[ 7] =  fDy; points[ 8] = -fDz;
   points[ 9] =  fDx1; points[10] = -fDy; points[11] = -fDz;
   points[12] = -fDx2; points[13] = -fDy; points[14] =  fDz;
   points[15] = -fDx2; points[16] =  fDy; points[17] =  fDz;
   points[18] =  fDx2; points[19] =  fDy; points[20] =  fDz;
   points[21] =  fDx2; points[22] = -fDy; points[23] =  fDz;
}

//_____________________________________________________________________________
void TGeoTrd1::SetPoints(Float_t *points) const
{
// create arb8 mesh points
   if (!points) return;
   points[ 0] = -fDx1; points[ 1] = -fDy; points[ 2] = -fDz;
   points[ 3] = -fDx1; points[ 4] =  fDy; points[ 5] = -fDz;
   points[ 6] =  fDx1; points[ 7] =  fDy; points[ 8] = -fDz;
   points[ 9] =  fDx1; points[10] = -fDy; points[11] = -fDz;
   points[12] = -fDx2; points[13] = -fDy; points[14] =  fDz;
   points[15] = -fDx2; points[16] =  fDy; points[17] =  fDz;
   points[18] =  fDx2; points[19] =  fDy; points[20] =  fDz;
   points[21] =  fDx2; points[22] = -fDy; points[23] =  fDz;
}

//_____________________________________________________________________________
void TGeoTrd1::Sizeof3D() const
{
// fill size of this 3-D object
   TGeoBBox::Sizeof3D();
}

//_____________________________________________________________________________
void TGeoTrd1::Contains_v(const Double_t *points, Bool_t *inside, Int_t vecsize) const
{
// Check the inside status for each of the points in the array.
// Input: Array of point coordinates + vector size
// Output: Array of Booleans for the inside of each point
   for (Int_t i=0; i<vecsize; i++) inside[i] = Contains(&points[3*i]);
}

//_____________________________________________________________________________
void TGeoTrd1::ComputeNormal_v(const Double_t *points, const Double_t *dirs, Double_t *norms, Int_t vecsize)
{
// Compute the normal for an array o points so that norm.dot.dir is positive
// Input: Arrays of point coordinates and directions + vector size
// Output: Array of normal directions
   for (Int_t i=0; i<vecsize; i++) ComputeNormal(&points[3*i], &dirs[3*i], &norms[3*i]);
}

//_____________________________________________________________________________
void TGeoTrd1::DistFromInside_v(const Double_t *points, const Double_t *dirs, Double_t *dists, Int_t vecsize, Double_t* step) const
{
// Compute distance from array of input points having directions specisied by dirs. Store output in dists
   for (Int_t i=0; i<vecsize; i++) dists[i] = DistFromInside(&points[3*i], &dirs[3*i], 3, step[i]);
}

//_____________________________________________________________________________
void TGeoTrd1::DistFromOutside_v(const Double_t *points, const Double_t *dirs, Double_t *dists, Int_t vecsize, Double_t* step) const
{
// Compute distance from array of input points having directions specisied by dirs. Store output in dists
   for (Int_t i=0; i<vecsize; i++) dists[i] = DistFromOutside(&points[3*i], &dirs[3*i], 3, step[i]);
}

//_____________________________________________________________________________
void TGeoTrd1::Safety_v(const Double_t *points, const Bool_t *inside, Double_t *safe, Int_t vecsize) const
{
// Compute safe distance from each of the points in the input array.
// Input: Array of point coordinates, array of statuses for these points, size of the arrays
// Output: Safety values
   for (Int_t i=0; i<vecsize; i++) safe[i] = Safety(&points[3*i], inside[i]);
}
 TGeoTrd1.cxx:1
 TGeoTrd1.cxx:2
 TGeoTrd1.cxx:3
 TGeoTrd1.cxx:4
 TGeoTrd1.cxx:5
 TGeoTrd1.cxx:6
 TGeoTrd1.cxx:7
 TGeoTrd1.cxx:8
 TGeoTrd1.cxx:9
 TGeoTrd1.cxx:10
 TGeoTrd1.cxx:11
 TGeoTrd1.cxx:12
 TGeoTrd1.cxx:13
 TGeoTrd1.cxx:14
 TGeoTrd1.cxx:15
 TGeoTrd1.cxx:16
 TGeoTrd1.cxx:17
 TGeoTrd1.cxx:18
 TGeoTrd1.cxx:19
 TGeoTrd1.cxx:20
 TGeoTrd1.cxx:21
 TGeoTrd1.cxx:22
 TGeoTrd1.cxx:23
 TGeoTrd1.cxx:24
 TGeoTrd1.cxx:25
 TGeoTrd1.cxx:26
 TGeoTrd1.cxx:27
 TGeoTrd1.cxx:28
 TGeoTrd1.cxx:29
 TGeoTrd1.cxx:30
 TGeoTrd1.cxx:31
 TGeoTrd1.cxx:32
 TGeoTrd1.cxx:33
 TGeoTrd1.cxx:34
 TGeoTrd1.cxx:35
 TGeoTrd1.cxx:36
 TGeoTrd1.cxx:37
 TGeoTrd1.cxx:38
 TGeoTrd1.cxx:39
 TGeoTrd1.cxx:40
 TGeoTrd1.cxx:41
 TGeoTrd1.cxx:42
 TGeoTrd1.cxx:43
 TGeoTrd1.cxx:44
 TGeoTrd1.cxx:45
 TGeoTrd1.cxx:46
 TGeoTrd1.cxx:47
 TGeoTrd1.cxx:48
 TGeoTrd1.cxx:49
 TGeoTrd1.cxx:50
 TGeoTrd1.cxx:51
 TGeoTrd1.cxx:52
 TGeoTrd1.cxx:53
 TGeoTrd1.cxx:54
 TGeoTrd1.cxx:55
 TGeoTrd1.cxx:56
 TGeoTrd1.cxx:57
 TGeoTrd1.cxx:58
 TGeoTrd1.cxx:59
 TGeoTrd1.cxx:60
 TGeoTrd1.cxx:61
 TGeoTrd1.cxx:62
 TGeoTrd1.cxx:63
 TGeoTrd1.cxx:64
 TGeoTrd1.cxx:65
 TGeoTrd1.cxx:66
 TGeoTrd1.cxx:67
 TGeoTrd1.cxx:68
 TGeoTrd1.cxx:69
 TGeoTrd1.cxx:70
 TGeoTrd1.cxx:71
 TGeoTrd1.cxx:72
 TGeoTrd1.cxx:73
 TGeoTrd1.cxx:74
 TGeoTrd1.cxx:75
 TGeoTrd1.cxx:76
 TGeoTrd1.cxx:77
 TGeoTrd1.cxx:78
 TGeoTrd1.cxx:79
 TGeoTrd1.cxx:80
 TGeoTrd1.cxx:81
 TGeoTrd1.cxx:82
 TGeoTrd1.cxx:83
 TGeoTrd1.cxx:84
 TGeoTrd1.cxx:85
 TGeoTrd1.cxx:86
 TGeoTrd1.cxx:87
 TGeoTrd1.cxx:88
 TGeoTrd1.cxx:89
 TGeoTrd1.cxx:90
 TGeoTrd1.cxx:91
 TGeoTrd1.cxx:92
 TGeoTrd1.cxx:93
 TGeoTrd1.cxx:94
 TGeoTrd1.cxx:95
 TGeoTrd1.cxx:96
 TGeoTrd1.cxx:97
 TGeoTrd1.cxx:98
 TGeoTrd1.cxx:99
 TGeoTrd1.cxx:100
 TGeoTrd1.cxx:101
 TGeoTrd1.cxx:102
 TGeoTrd1.cxx:103
 TGeoTrd1.cxx:104
 TGeoTrd1.cxx:105
 TGeoTrd1.cxx:106
 TGeoTrd1.cxx:107
 TGeoTrd1.cxx:108
 TGeoTrd1.cxx:109
 TGeoTrd1.cxx:110
 TGeoTrd1.cxx:111
 TGeoTrd1.cxx:112
 TGeoTrd1.cxx:113
 TGeoTrd1.cxx:114
 TGeoTrd1.cxx:115
 TGeoTrd1.cxx:116
 TGeoTrd1.cxx:117
 TGeoTrd1.cxx:118
 TGeoTrd1.cxx:119
 TGeoTrd1.cxx:120
 TGeoTrd1.cxx:121
 TGeoTrd1.cxx:122
 TGeoTrd1.cxx:123
 TGeoTrd1.cxx:124
 TGeoTrd1.cxx:125
 TGeoTrd1.cxx:126
 TGeoTrd1.cxx:127
 TGeoTrd1.cxx:128
 TGeoTrd1.cxx:129
 TGeoTrd1.cxx:130
 TGeoTrd1.cxx:131
 TGeoTrd1.cxx:132
 TGeoTrd1.cxx:133
 TGeoTrd1.cxx:134
 TGeoTrd1.cxx:135
 TGeoTrd1.cxx:136
 TGeoTrd1.cxx:137
 TGeoTrd1.cxx:138
 TGeoTrd1.cxx:139
 TGeoTrd1.cxx:140
 TGeoTrd1.cxx:141
 TGeoTrd1.cxx:142
 TGeoTrd1.cxx:143
 TGeoTrd1.cxx:144
 TGeoTrd1.cxx:145
 TGeoTrd1.cxx:146
 TGeoTrd1.cxx:147
 TGeoTrd1.cxx:148
 TGeoTrd1.cxx:149
 TGeoTrd1.cxx:150
 TGeoTrd1.cxx:151
 TGeoTrd1.cxx:152
 TGeoTrd1.cxx:153
 TGeoTrd1.cxx:154
 TGeoTrd1.cxx:155
 TGeoTrd1.cxx:156
 TGeoTrd1.cxx:157
 TGeoTrd1.cxx:158
 TGeoTrd1.cxx:159
 TGeoTrd1.cxx:160
 TGeoTrd1.cxx:161
 TGeoTrd1.cxx:162
 TGeoTrd1.cxx:163
 TGeoTrd1.cxx:164
 TGeoTrd1.cxx:165
 TGeoTrd1.cxx:166
 TGeoTrd1.cxx:167
 TGeoTrd1.cxx:168
 TGeoTrd1.cxx:169
 TGeoTrd1.cxx:170
 TGeoTrd1.cxx:171
 TGeoTrd1.cxx:172
 TGeoTrd1.cxx:173
 TGeoTrd1.cxx:174
 TGeoTrd1.cxx:175
 TGeoTrd1.cxx:176
 TGeoTrd1.cxx:177
 TGeoTrd1.cxx:178
 TGeoTrd1.cxx:179
 TGeoTrd1.cxx:180
 TGeoTrd1.cxx:181
 TGeoTrd1.cxx:182
 TGeoTrd1.cxx:183
 TGeoTrd1.cxx:184
 TGeoTrd1.cxx:185
 TGeoTrd1.cxx:186
 TGeoTrd1.cxx:187
 TGeoTrd1.cxx:188
 TGeoTrd1.cxx:189
 TGeoTrd1.cxx:190
 TGeoTrd1.cxx:191
 TGeoTrd1.cxx:192
 TGeoTrd1.cxx:193
 TGeoTrd1.cxx:194
 TGeoTrd1.cxx:195
 TGeoTrd1.cxx:196
 TGeoTrd1.cxx:197
 TGeoTrd1.cxx:198
 TGeoTrd1.cxx:199
 TGeoTrd1.cxx:200
 TGeoTrd1.cxx:201
 TGeoTrd1.cxx:202
 TGeoTrd1.cxx:203
 TGeoTrd1.cxx:204
 TGeoTrd1.cxx:205
 TGeoTrd1.cxx:206
 TGeoTrd1.cxx:207
 TGeoTrd1.cxx:208
 TGeoTrd1.cxx:209
 TGeoTrd1.cxx:210
 TGeoTrd1.cxx:211
 TGeoTrd1.cxx:212
 TGeoTrd1.cxx:213
 TGeoTrd1.cxx:214
 TGeoTrd1.cxx:215
 TGeoTrd1.cxx:216
 TGeoTrd1.cxx:217
 TGeoTrd1.cxx:218
 TGeoTrd1.cxx:219
 TGeoTrd1.cxx:220
 TGeoTrd1.cxx:221
 TGeoTrd1.cxx:222
 TGeoTrd1.cxx:223
 TGeoTrd1.cxx:224
 TGeoTrd1.cxx:225
 TGeoTrd1.cxx:226
 TGeoTrd1.cxx:227
 TGeoTrd1.cxx:228
 TGeoTrd1.cxx:229
 TGeoTrd1.cxx:230
 TGeoTrd1.cxx:231
 TGeoTrd1.cxx:232
 TGeoTrd1.cxx:233
 TGeoTrd1.cxx:234
 TGeoTrd1.cxx:235
 TGeoTrd1.cxx:236
 TGeoTrd1.cxx:237
 TGeoTrd1.cxx:238
 TGeoTrd1.cxx:239
 TGeoTrd1.cxx:240
 TGeoTrd1.cxx:241
 TGeoTrd1.cxx:242
 TGeoTrd1.cxx:243
 TGeoTrd1.cxx:244
 TGeoTrd1.cxx:245
 TGeoTrd1.cxx:246
 TGeoTrd1.cxx:247
 TGeoTrd1.cxx:248
 TGeoTrd1.cxx:249
 TGeoTrd1.cxx:250
 TGeoTrd1.cxx:251
 TGeoTrd1.cxx:252
 TGeoTrd1.cxx:253
 TGeoTrd1.cxx:254
 TGeoTrd1.cxx:255
 TGeoTrd1.cxx:256
 TGeoTrd1.cxx:257
 TGeoTrd1.cxx:258
 TGeoTrd1.cxx:259
 TGeoTrd1.cxx:260
 TGeoTrd1.cxx:261
 TGeoTrd1.cxx:262
 TGeoTrd1.cxx:263
 TGeoTrd1.cxx:264
 TGeoTrd1.cxx:265
 TGeoTrd1.cxx:266
 TGeoTrd1.cxx:267
 TGeoTrd1.cxx:268
 TGeoTrd1.cxx:269
 TGeoTrd1.cxx:270
 TGeoTrd1.cxx:271
 TGeoTrd1.cxx:272
 TGeoTrd1.cxx:273
 TGeoTrd1.cxx:274
 TGeoTrd1.cxx:275
 TGeoTrd1.cxx:276
 TGeoTrd1.cxx:277
 TGeoTrd1.cxx:278
 TGeoTrd1.cxx:279
 TGeoTrd1.cxx:280
 TGeoTrd1.cxx:281
 TGeoTrd1.cxx:282
 TGeoTrd1.cxx:283
 TGeoTrd1.cxx:284
 TGeoTrd1.cxx:285
 TGeoTrd1.cxx:286
 TGeoTrd1.cxx:287
 TGeoTrd1.cxx:288
 TGeoTrd1.cxx:289
 TGeoTrd1.cxx:290
 TGeoTrd1.cxx:291
 TGeoTrd1.cxx:292
 TGeoTrd1.cxx:293
 TGeoTrd1.cxx:294
 TGeoTrd1.cxx:295
 TGeoTrd1.cxx:296
 TGeoTrd1.cxx:297
 TGeoTrd1.cxx:298
 TGeoTrd1.cxx:299
 TGeoTrd1.cxx:300
 TGeoTrd1.cxx:301
 TGeoTrd1.cxx:302
 TGeoTrd1.cxx:303
 TGeoTrd1.cxx:304
 TGeoTrd1.cxx:305
 TGeoTrd1.cxx:306
 TGeoTrd1.cxx:307
 TGeoTrd1.cxx:308
 TGeoTrd1.cxx:309
 TGeoTrd1.cxx:310
 TGeoTrd1.cxx:311
 TGeoTrd1.cxx:312
 TGeoTrd1.cxx:313
 TGeoTrd1.cxx:314
 TGeoTrd1.cxx:315
 TGeoTrd1.cxx:316
 TGeoTrd1.cxx:317
 TGeoTrd1.cxx:318
 TGeoTrd1.cxx:319
 TGeoTrd1.cxx:320
 TGeoTrd1.cxx:321
 TGeoTrd1.cxx:322
 TGeoTrd1.cxx:323
 TGeoTrd1.cxx:324
 TGeoTrd1.cxx:325
 TGeoTrd1.cxx:326
 TGeoTrd1.cxx:327
 TGeoTrd1.cxx:328
 TGeoTrd1.cxx:329
 TGeoTrd1.cxx:330
 TGeoTrd1.cxx:331
 TGeoTrd1.cxx:332
 TGeoTrd1.cxx:333
 TGeoTrd1.cxx:334
 TGeoTrd1.cxx:335
 TGeoTrd1.cxx:336
 TGeoTrd1.cxx:337
 TGeoTrd1.cxx:338
 TGeoTrd1.cxx:339
 TGeoTrd1.cxx:340
 TGeoTrd1.cxx:341
 TGeoTrd1.cxx:342
 TGeoTrd1.cxx:343
 TGeoTrd1.cxx:344
 TGeoTrd1.cxx:345
 TGeoTrd1.cxx:346
 TGeoTrd1.cxx:347
 TGeoTrd1.cxx:348
 TGeoTrd1.cxx:349
 TGeoTrd1.cxx:350
 TGeoTrd1.cxx:351
 TGeoTrd1.cxx:352
 TGeoTrd1.cxx:353
 TGeoTrd1.cxx:354
 TGeoTrd1.cxx:355
 TGeoTrd1.cxx:356
 TGeoTrd1.cxx:357
 TGeoTrd1.cxx:358
 TGeoTrd1.cxx:359
 TGeoTrd1.cxx:360
 TGeoTrd1.cxx:361
 TGeoTrd1.cxx:362
 TGeoTrd1.cxx:363
 TGeoTrd1.cxx:364
 TGeoTrd1.cxx:365
 TGeoTrd1.cxx:366
 TGeoTrd1.cxx:367
 TGeoTrd1.cxx:368
 TGeoTrd1.cxx:369
 TGeoTrd1.cxx:370
 TGeoTrd1.cxx:371
 TGeoTrd1.cxx:372
 TGeoTrd1.cxx:373
 TGeoTrd1.cxx:374
 TGeoTrd1.cxx:375
 TGeoTrd1.cxx:376
 TGeoTrd1.cxx:377
 TGeoTrd1.cxx:378
 TGeoTrd1.cxx:379
 TGeoTrd1.cxx:380
 TGeoTrd1.cxx:381
 TGeoTrd1.cxx:382
 TGeoTrd1.cxx:383
 TGeoTrd1.cxx:384
 TGeoTrd1.cxx:385
 TGeoTrd1.cxx:386
 TGeoTrd1.cxx:387
 TGeoTrd1.cxx:388
 TGeoTrd1.cxx:389
 TGeoTrd1.cxx:390
 TGeoTrd1.cxx:391
 TGeoTrd1.cxx:392
 TGeoTrd1.cxx:393
 TGeoTrd1.cxx:394
 TGeoTrd1.cxx:395
 TGeoTrd1.cxx:396
 TGeoTrd1.cxx:397
 TGeoTrd1.cxx:398
 TGeoTrd1.cxx:399
 TGeoTrd1.cxx:400
 TGeoTrd1.cxx:401
 TGeoTrd1.cxx:402
 TGeoTrd1.cxx:403
 TGeoTrd1.cxx:404
 TGeoTrd1.cxx:405
 TGeoTrd1.cxx:406
 TGeoTrd1.cxx:407
 TGeoTrd1.cxx:408
 TGeoTrd1.cxx:409
 TGeoTrd1.cxx:410
 TGeoTrd1.cxx:411
 TGeoTrd1.cxx:412
 TGeoTrd1.cxx:413
 TGeoTrd1.cxx:414
 TGeoTrd1.cxx:415
 TGeoTrd1.cxx:416
 TGeoTrd1.cxx:417
 TGeoTrd1.cxx:418
 TGeoTrd1.cxx:419
 TGeoTrd1.cxx:420
 TGeoTrd1.cxx:421
 TGeoTrd1.cxx:422
 TGeoTrd1.cxx:423
 TGeoTrd1.cxx:424
 TGeoTrd1.cxx:425
 TGeoTrd1.cxx:426
 TGeoTrd1.cxx:427
 TGeoTrd1.cxx:428
 TGeoTrd1.cxx:429
 TGeoTrd1.cxx:430
 TGeoTrd1.cxx:431
 TGeoTrd1.cxx:432
 TGeoTrd1.cxx:433
 TGeoTrd1.cxx:434
 TGeoTrd1.cxx:435
 TGeoTrd1.cxx:436
 TGeoTrd1.cxx:437
 TGeoTrd1.cxx:438
 TGeoTrd1.cxx:439
 TGeoTrd1.cxx:440
 TGeoTrd1.cxx:441
 TGeoTrd1.cxx:442
 TGeoTrd1.cxx:443
 TGeoTrd1.cxx:444
 TGeoTrd1.cxx:445
 TGeoTrd1.cxx:446
 TGeoTrd1.cxx:447
 TGeoTrd1.cxx:448
 TGeoTrd1.cxx:449
 TGeoTrd1.cxx:450
 TGeoTrd1.cxx:451
 TGeoTrd1.cxx:452
 TGeoTrd1.cxx:453
 TGeoTrd1.cxx:454
 TGeoTrd1.cxx:455
 TGeoTrd1.cxx:456
 TGeoTrd1.cxx:457
 TGeoTrd1.cxx:458
 TGeoTrd1.cxx:459
 TGeoTrd1.cxx:460
 TGeoTrd1.cxx:461
 TGeoTrd1.cxx:462
 TGeoTrd1.cxx:463
 TGeoTrd1.cxx:464
 TGeoTrd1.cxx:465
 TGeoTrd1.cxx:466
 TGeoTrd1.cxx:467
 TGeoTrd1.cxx:468
 TGeoTrd1.cxx:469
 TGeoTrd1.cxx:470
 TGeoTrd1.cxx:471
 TGeoTrd1.cxx:472
 TGeoTrd1.cxx:473
 TGeoTrd1.cxx:474
 TGeoTrd1.cxx:475
 TGeoTrd1.cxx:476
 TGeoTrd1.cxx:477
 TGeoTrd1.cxx:478
 TGeoTrd1.cxx:479
 TGeoTrd1.cxx:480
 TGeoTrd1.cxx:481
 TGeoTrd1.cxx:482
 TGeoTrd1.cxx:483
 TGeoTrd1.cxx:484
 TGeoTrd1.cxx:485
 TGeoTrd1.cxx:486
 TGeoTrd1.cxx:487
 TGeoTrd1.cxx:488
 TGeoTrd1.cxx:489
 TGeoTrd1.cxx:490
 TGeoTrd1.cxx:491
 TGeoTrd1.cxx:492
 TGeoTrd1.cxx:493
 TGeoTrd1.cxx:494
 TGeoTrd1.cxx:495
 TGeoTrd1.cxx:496
 TGeoTrd1.cxx:497
 TGeoTrd1.cxx:498
 TGeoTrd1.cxx:499
 TGeoTrd1.cxx:500
 TGeoTrd1.cxx:501
 TGeoTrd1.cxx:502
 TGeoTrd1.cxx:503
 TGeoTrd1.cxx:504
 TGeoTrd1.cxx:505
 TGeoTrd1.cxx:506
 TGeoTrd1.cxx:507
 TGeoTrd1.cxx:508
 TGeoTrd1.cxx:509
 TGeoTrd1.cxx:510
 TGeoTrd1.cxx:511
 TGeoTrd1.cxx:512
 TGeoTrd1.cxx:513
 TGeoTrd1.cxx:514
 TGeoTrd1.cxx:515
 TGeoTrd1.cxx:516
 TGeoTrd1.cxx:517
 TGeoTrd1.cxx:518
 TGeoTrd1.cxx:519
 TGeoTrd1.cxx:520
 TGeoTrd1.cxx:521
 TGeoTrd1.cxx:522
 TGeoTrd1.cxx:523
 TGeoTrd1.cxx:524
 TGeoTrd1.cxx:525
 TGeoTrd1.cxx:526
 TGeoTrd1.cxx:527
 TGeoTrd1.cxx:528
 TGeoTrd1.cxx:529
 TGeoTrd1.cxx:530
 TGeoTrd1.cxx:531
 TGeoTrd1.cxx:532
 TGeoTrd1.cxx:533
 TGeoTrd1.cxx:534
 TGeoTrd1.cxx:535
 TGeoTrd1.cxx:536
 TGeoTrd1.cxx:537
 TGeoTrd1.cxx:538
 TGeoTrd1.cxx:539
 TGeoTrd1.cxx:540
 TGeoTrd1.cxx:541
 TGeoTrd1.cxx:542
 TGeoTrd1.cxx:543
 TGeoTrd1.cxx:544
 TGeoTrd1.cxx:545
 TGeoTrd1.cxx:546
 TGeoTrd1.cxx:547
 TGeoTrd1.cxx:548
 TGeoTrd1.cxx:549
 TGeoTrd1.cxx:550
 TGeoTrd1.cxx:551
 TGeoTrd1.cxx:552
 TGeoTrd1.cxx:553
 TGeoTrd1.cxx:554
 TGeoTrd1.cxx:555
 TGeoTrd1.cxx:556
 TGeoTrd1.cxx:557
 TGeoTrd1.cxx:558
 TGeoTrd1.cxx:559
 TGeoTrd1.cxx:560
 TGeoTrd1.cxx:561
 TGeoTrd1.cxx:562
 TGeoTrd1.cxx:563
 TGeoTrd1.cxx:564
 TGeoTrd1.cxx:565
 TGeoTrd1.cxx:566
 TGeoTrd1.cxx:567
 TGeoTrd1.cxx:568
 TGeoTrd1.cxx:569
 TGeoTrd1.cxx:570
 TGeoTrd1.cxx:571
 TGeoTrd1.cxx:572
 TGeoTrd1.cxx:573
 TGeoTrd1.cxx:574
 TGeoTrd1.cxx:575
 TGeoTrd1.cxx:576
 TGeoTrd1.cxx:577
 TGeoTrd1.cxx:578
 TGeoTrd1.cxx:579
 TGeoTrd1.cxx:580
 TGeoTrd1.cxx:581
 TGeoTrd1.cxx:582
 TGeoTrd1.cxx:583
 TGeoTrd1.cxx:584
 TGeoTrd1.cxx:585
 TGeoTrd1.cxx:586
 TGeoTrd1.cxx:587
 TGeoTrd1.cxx:588
 TGeoTrd1.cxx:589
 TGeoTrd1.cxx:590
 TGeoTrd1.cxx:591
 TGeoTrd1.cxx:592
 TGeoTrd1.cxx:593
 TGeoTrd1.cxx:594
 TGeoTrd1.cxx:595
 TGeoTrd1.cxx:596
 TGeoTrd1.cxx:597
 TGeoTrd1.cxx:598
 TGeoTrd1.cxx:599
 TGeoTrd1.cxx:600
 TGeoTrd1.cxx:601
 TGeoTrd1.cxx:602
 TGeoTrd1.cxx:603
 TGeoTrd1.cxx:604
 TGeoTrd1.cxx:605
 TGeoTrd1.cxx:606
 TGeoTrd1.cxx:607
 TGeoTrd1.cxx:608
 TGeoTrd1.cxx:609
 TGeoTrd1.cxx:610
 TGeoTrd1.cxx:611
 TGeoTrd1.cxx:612
 TGeoTrd1.cxx:613
 TGeoTrd1.cxx:614
 TGeoTrd1.cxx:615
 TGeoTrd1.cxx:616
 TGeoTrd1.cxx:617
 TGeoTrd1.cxx:618
 TGeoTrd1.cxx:619
 TGeoTrd1.cxx:620
 TGeoTrd1.cxx:621
 TGeoTrd1.cxx:622
 TGeoTrd1.cxx:623
 TGeoTrd1.cxx:624
 TGeoTrd1.cxx:625
 TGeoTrd1.cxx:626
 TGeoTrd1.cxx:627
 TGeoTrd1.cxx:628
 TGeoTrd1.cxx:629
 TGeoTrd1.cxx:630
 TGeoTrd1.cxx:631
 TGeoTrd1.cxx:632
 TGeoTrd1.cxx:633
 TGeoTrd1.cxx:634
 TGeoTrd1.cxx:635
 TGeoTrd1.cxx:636
 TGeoTrd1.cxx:637
 TGeoTrd1.cxx:638
 TGeoTrd1.cxx:639
 TGeoTrd1.cxx:640
 TGeoTrd1.cxx:641
 TGeoTrd1.cxx:642
 TGeoTrd1.cxx:643
 TGeoTrd1.cxx:644
 TGeoTrd1.cxx:645
 TGeoTrd1.cxx:646
 TGeoTrd1.cxx:647
 TGeoTrd1.cxx:648
 TGeoTrd1.cxx:649
 TGeoTrd1.cxx:650
 TGeoTrd1.cxx:651
 TGeoTrd1.cxx:652
 TGeoTrd1.cxx:653
 TGeoTrd1.cxx:654
 TGeoTrd1.cxx:655
 TGeoTrd1.cxx:656
 TGeoTrd1.cxx:657
 TGeoTrd1.cxx:658
 TGeoTrd1.cxx:659
 TGeoTrd1.cxx:660
 TGeoTrd1.cxx:661
 TGeoTrd1.cxx:662
 TGeoTrd1.cxx:663
 TGeoTrd1.cxx:664
 TGeoTrd1.cxx:665
 TGeoTrd1.cxx:666
 TGeoTrd1.cxx:667
 TGeoTrd1.cxx:668
 TGeoTrd1.cxx:669
 TGeoTrd1.cxx:670
 TGeoTrd1.cxx:671
 TGeoTrd1.cxx:672
 TGeoTrd1.cxx:673
 TGeoTrd1.cxx:674
 TGeoTrd1.cxx:675
 TGeoTrd1.cxx:676
 TGeoTrd1.cxx:677
 TGeoTrd1.cxx:678
 TGeoTrd1.cxx:679
 TGeoTrd1.cxx:680
 TGeoTrd1.cxx:681
 TGeoTrd1.cxx:682
 TGeoTrd1.cxx:683
 TGeoTrd1.cxx:684
 TGeoTrd1.cxx:685
 TGeoTrd1.cxx:686
 TGeoTrd1.cxx:687
 TGeoTrd1.cxx:688
 TGeoTrd1.cxx:689
 TGeoTrd1.cxx:690
 TGeoTrd1.cxx:691
 TGeoTrd1.cxx:692
 TGeoTrd1.cxx:693
 TGeoTrd1.cxx:694
 TGeoTrd1.cxx:695
 TGeoTrd1.cxx:696
 TGeoTrd1.cxx:697
 TGeoTrd1.cxx:698
 TGeoTrd1.cxx:699
 TGeoTrd1.cxx:700
 TGeoTrd1.cxx:701
 TGeoTrd1.cxx:702
 TGeoTrd1.cxx:703
 TGeoTrd1.cxx:704
 TGeoTrd1.cxx:705
 TGeoTrd1.cxx:706
 TGeoTrd1.cxx:707
 TGeoTrd1.cxx:708
 TGeoTrd1.cxx:709
 TGeoTrd1.cxx:710
 TGeoTrd1.cxx:711
 TGeoTrd1.cxx:712
 TGeoTrd1.cxx:713
 TGeoTrd1.cxx:714
 TGeoTrd1.cxx:715
 TGeoTrd1.cxx:716
 TGeoTrd1.cxx:717
 TGeoTrd1.cxx:718
 TGeoTrd1.cxx:719
 TGeoTrd1.cxx:720
 TGeoTrd1.cxx:721
 TGeoTrd1.cxx:722
 TGeoTrd1.cxx:723
 TGeoTrd1.cxx:724
 TGeoTrd1.cxx:725
 TGeoTrd1.cxx:726
 TGeoTrd1.cxx:727
 TGeoTrd1.cxx:728
 TGeoTrd1.cxx:729
 TGeoTrd1.cxx:730
 TGeoTrd1.cxx:731
 TGeoTrd1.cxx:732
 TGeoTrd1.cxx:733
 TGeoTrd1.cxx:734
 TGeoTrd1.cxx:735
 TGeoTrd1.cxx:736
 TGeoTrd1.cxx:737
 TGeoTrd1.cxx:738
 TGeoTrd1.cxx:739
 TGeoTrd1.cxx:740
 TGeoTrd1.cxx:741
 TGeoTrd1.cxx:742
 TGeoTrd1.cxx:743
 TGeoTrd1.cxx:744
 TGeoTrd1.cxx:745
 TGeoTrd1.cxx:746
 TGeoTrd1.cxx:747
 TGeoTrd1.cxx:748
 TGeoTrd1.cxx:749