flyopunta/src/src_dev/devclot.cpp

/***************************************************************************
                          devclot.cpp  -  description
                             -------------------
    begin                : Mon Dec 8 2003
    copyright            : (C) 2003 by gmp
    email                : peppe@newpeppe
  ***************************************************************************
  *                                                                         *
  *   NA48  simulation program.                                             *
  *                                                                         *
  ***************************************************************************/
#include "parm.h"
#include "devclot.h"
DevClOt::~DevClOt()
{}
DevClOt::DevClOt()
{
  devtype=TypDevClOt;
  devclass="Cili_Ottg";
  Firot=.707107;
}


void DevClOt::Prgeom()
{

  Gout<<"==================  R i v e l a t o r e =================";
  Gout<<"\n --> < "<<nome <<" >  [ "<<fun
  <<" ]  Cilindro con buco ottagonale "<<std::endl;
  Device::Prgeom();
}
//----------------- -----P o s i z i o n e ---
int DevClOt::Posizione()
{
  //     Posizione della particella rispetto questo dev
  // Le distanze di un punto interno dai piani del
  // rivelatore sono tutte negative o nulle data
  // la definizione delle normali ai piani ( verso l'esterno)
  // Le distanze di un punto esterno sono sia positive che negative:
  // ma almeno  una distanza e' positiva.
  // X_dev   e' la posizione  della particella rispeto al sistema del dev
  // Ruoto di -45 gradi il punto e lo paragono con i lati inclinati....
  // ripeto la stessa procedura di prima per simmetria (Lout non cambia);
  // double Firot=0.707107= 1/sqrt(2.);
  // X_rot   e' la posizione rotata di 45 gradi


  if( (pos=DevClRt::Posizione())>0)
    return 1;
  // pos e' 0, indica che il punto e' probabilmente interno   ..
  // ruoto di -45 gradi il punto e lo paragono poi anche con i lati inclinati interni....
  X_rot.setvn(Firot*(X_dev[0]+X_dev[1]),Firot*(X_dev[1]-X_dev[0]), X_dev[2]);
  Dinrd=X_rot-Lin;
  Dinrs=-(Lin+X_rot);

  //Test now
  if(pos==0)
    return 0;
  if(Dinrs[0]>0.0 ||
      Dinrd[0]>0.0 || Dinrs[1]>0.0 || Dinrd[1]>0.0   )
    return 0;
  return -1;     // 0 se interno, 1 se esterno.

}
//----------------------C a m E s t e r --------------------
// calcola il cammino esterno per raggiungere il rivelatore...
// eridata da DevCl::CamEster()

//----------------------C a m I n t e r --------------------
// calcola il cammino interno per uscire dal rivelatore...
// vedi la routine nella classe base rettangolo.
// V_dev e' il versore della traiettoria nel dev
// V_rot e' il versore ruotato di 45 gradi per i lati inclinati
//
double DevClOt::CamInter()
{
  // calcolo il cammino verso le  superfici del cilindro
  // e  quattro dei lati dell'ottagono
  // le distanze sono per definizione negative...
  // e scelgo il cammino positivo  maggiore
  // camm in uscita e' sempre definito
  // prima la classe base....
  tratto=DevClRt::CamInter();

  // roto di 45 gradi per controllare il moto rispetto ai piani inclinati...
  V_rot.setvn(Firot*(V_dev[0]+V_dev[1]),Firot*(V_dev[1]-V_dev[0]), V_dev[2]);

  //poi verifico se colpisce le pareti del buco .....
  double nv,t;
  camm=-1.;
  // calcolo il cammino positivo verso le sei superfici del buco. Per dist>0
  // scelgo il cammino maggiore

  if((nv=V_rot[0])>0.0 && Dinrs[0]>0.0)  // piani x
    {t=Dinrs[0]/nv;
      if(t>camm)
        camm=t;
    }
  else if(nv<0.0 && Dinrd[0]>0.0)
    {
      t=-Dinrd[0]/nv;
      if(t>camm)
        camm=t;
    }

  if((nv=V_rot[1])>0.0 && Dinrs[1]>0.0)  // piani y
    {t=Dinrs[1]/nv;
      if(t>camm)
        camm=t;
    }
  else if(nv<0.0 && Dinrd[1]>0.0)
    {
      t=-Dinrd[1]/nv;
      if(t>camm)
        camm=t;
    }

  if((nv=V_rot[2])>0.0 && Dinrs[2]>0.0)  // piani z
    {t=Dinrs[2]/nv;
      if(t>camm)
        camm=t;
    }
  else if(nv<0.0 && Dinrd[2]>0.0)
    {
      t=-Dinrd[2]/nv;
      if(t>camm)
        camm=t;
    }

  // quindi confronto camm con tratto e accetto il cammino piu' breve......
  if(camm<0.0)
    {
      camm=tratto;
      return camm;
    }
  if(camm>0.0 && tratto<camm)
    camm=tratto;
  return camm;
}
//=========================================
//===============================================================
//--------------- C a m B u c o ---------------------------------
double DevClOt::CamBuco()
{

  // simile a (copia di)   DevOtOt::CamBuco();

  double nv,t;
  camm=1.0e+10;
  // calcolo il cammino verso le otto+2  superfici
  // le distanze sono per definizione negative...
  // e scelgo il cammino positivo  minore


  if((nv=V_dev[0])>0.0)  // piani x
    {t=-Dind[0]/nv;
      if(t<camm)
        camm=t;
    }
  else if(nv<0.0)
    {
      t=Dins[0]/nv;
      if(t<camm)
        camm=t;
    }

  if((nv=V_dev[1])>0.0)  // piani y
    {t=-Dind[1]/nv;
      if(t<camm)
        camm=t;
    }
  else if(nv<0.0)
    {
      t=Dins[1]/nv;
      if(t<camm)
        camm=t;
    }

  if((nv=V_dev[2])>0.0)  // piani z
    {t=-Dind[2]/nv;
      if(t<camm)
        camm=t;
    }
  else if(nv<0.0)
    {
      t=Dins[2]/nv;
      if(t<camm)
        camm=t;
    }

  // roto di 45 gradi per controllare il moto rispetto ai piani inclinati...
  V_rot.setvn(Firot*(V_dev[0]+V_dev[1]),Firot*(V_dev[1]-V_dev[0]), V_dev[2]);

  if((nv=V_rot[0])>0.0)  // piani x
    {t=-Dinrd[0]/nv;
      if(t<camm)
        camm=t;
    }
  else if(nv<0.0)
    {
      t=Dinrs[0]/nv;
      if(t<camm)
        camm=t;
    }

  if((nv=V_rot[1])>0.0)  // piani y
    {t=-Dinrd[1]/nv;
      if(t<camm)
        camm=t;
    }
  else if(nv<0.0)
    {
      t=Dinrs[1]/nv;
      if(t<camm)
        camm=t;
    }

  return camm;
}