flyopunta/src/src_dev/devcrn.cpp

/***************************************************************************
                          devcrn.cpp  -  description
                             -------------------
    begin                : Sat May 26 2001
    copyright            : (C) 2001 by Giuseppe Pierazzini
    email                : peppe@unipi.it
  ***************************************************************************
  *                                                                         *
  *   NA48  simulation program.                                             *
  *                                                                         *
  ***************************************************************************/
#include "parm.h"
#include "devcrn.h"

// using namespace std;

DevCrn::~DevCrn()
{
}
//==================  Corona=======erede di Cilindro
DevCrn::DevCrn()
{
  devtype=TypDevCrn;
  devclass="Corona";
  rin =Lin.y=Lin.x;
  Lin.Norma();
  rinq=rin*rin;
}

//----------------- --------
void DevCrn::Prgeom()
{
  Gout<<"==================  R i v e l a t o r e =================";
  Gout<<"\n --> < "<<nome <<" >  [ "<<fun
  <<" ]  Corona con rout "<<rout<<"  e rin "<<rin;
  Device::Prgeom();

}

//======================================================
//----------------- -----P o s i z i o n e ---
int DevCrn::Posizione()
{
  if ( DevCln::Posizione() >0 ) return 1;  //  il punto e' esterno
  P_Cin=X_dev-Centrin;
  Dind.z=P_Cin.z-Lin.z;
  Dins.z=- ( Lin.z+P_Cin.z );
// se sono interno al rivelatore verifico se siamo nel buco
  if ( Dins.z>0.0 || Dind.z>0.0 ||
       ( drinq=P_Cin.x*P_Cin.x+P_Cin.y*P_Cin.y ) >rinq ) return 0;               //e' fouri buco
  return -1; // se nel buco
}
//----------------------C a m E s t e r --------------------
// usa quella di Cilindro  per eredita'
//===========================================================
//----------------------C a m I n t e r --------------------

double DevCrn::CamInter()
{
//uso quella di Cilindro per calcolare il cammino
// interno senza il buco...
  double ctratto=DevCln::CamInter();
//poi verifico se colpisce le pareti del buco .....
  double b,c,dltq,t,nv,z;
// calcolo il cammino positivo verso le  superfici del cilind
// e scelgo il cammino maggiore
//  calcolo i coefficienti della equazione intersezione di un
  camm=-1.;
// controllo se colpisce la base
  if ( ( nv=V_dev.z ) >0.0 && Dins.z>0.0 )  // piani z
    {
      t=Dins.z/nv;
      if ( t>camm ) camm=t;
    }
  else if ( nv<0.0 && Dind.z>0.0 )
    {
      t=-Dind.z/nv;
      if ( t>camm ) camm=t;
    }


//
  if ( vxyq>0.0 )
    {
      b=V_dev.x*P_Cin.x+V_dev.y*P_Cin.y;
      if ( b<0. )   // revised 31.07.01 gmp
        {
          c=drinq-rinq;
          if ( ( dltq=b*b-vxyq*c ) >=0.0 )
            {
              t= - ( b + sqrt ( dltq ) ) /vxyq; // Scelgo la soluzione minore
              if ( t>=0.0 )
                {// check limiti in zeta
                  z=P_Cin.z+nv*t;

                  if ( -Lin.z<=z&&z<=Lin.z ) camm=t;
                }
            }
        }
    }

  // quindi confronto camm con tratto e accetto il cammino piu' piccolo
  if ( camm<0.0 )
    {
      camm=ctratto;
      return camm;
    }
  if ( camm>0.0 && ctratto<camm ) camm=ctratto;
  return camm;
}
//===========================================================
//--------------- C a m B u c o -----------------------------
double DevCrn::CamBuco()
{
  double b,c,dltq,t,nv;
  camm=1.0e+10;
// calcolo il cammino verso le  superfici
// quella cilindrica e dalle basi del cilindro.
// scelgo il cammino positivo minore...
// calcolo il cammino positivo verso la superfice del cilindr
// le soluzioni sono sempre di segno opposto.

  if ( vxyq>0.0 )
    {
      b=V_dev.x*P_Cin.x+V_dev.y*P_Cin.y;
      c=drinq-rinq;           // nota sempre negativo internament
      if ( ( dltq=b*b-vxyq*c ) >=0.0 )
        {
          t= ( -b + sqrt ( dltq ) ) /vxyq; // Scelgo la soluzione positiva
          if ( t>=0.0 ) camm=t;
        }
    }
// controllo anche la zeta....
  if ( ( nv=V_dev.z ) >0.0 )  // piani z
    {
      t=-Dind.z/nv;
      if ( t<camm ) camm=t;
    }
  else if ( nv<0.0 )
    {
      t=Dins.z/nv;
      if ( t<camm ) camm=t;
    }
  return camm;
}