flyopunta/src/src_dev/devrt.cpp

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

//using namespace std;


DevRt::~DevRt()
{
}
void DevRt::Prgeom()
{
  Gout<<"==================  R i v e l a t o r e =================";
  Gout<<"\n --> < "<<nome <<" >  [ "<<fun
  <<" ]  rettangolare senza buco ";
  Device::Prgeom();

}
//----------------- -----P o s i z i o n e ---
int DevRt::Posizione()
{
// Distanze dai piani pari in Doutd.
// dist dal piano x=Nx%(P-Lout) etcc...
// 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.

  Doutd=X_dev-Lout;     Doutd.Norma();
  Douts=- ( Lout+X_dev );  Douts.Norma();

  int posto=0;

  if ( X_dev.normaq>Rqsize ) posto=1;

  else if ( Douts[2]>0.0 || Doutd[2]>0.0 || Douts[0]>0.0 ||
            Doutd[0]>0.0 || Douts[1]>0.0 || Doutd[1]>0.0 ) posto =1;
  // 0 se interno, 1 se esterno.

  return posto;

}
//----------------------------------------------------------
//----------------------C a m E s t e r --------------------
// calcola il cammino esterno per raggiungere il rivelatore...
// Pp punto di partenza in dev frame
// Vv versore del moto
// da chiamrsi sempre dopo Posizione....

double DevRt::CamEster()
{
  double nv,t=0.;
  camm=-1.;
  // calcolo il cammino verso le sei superfici. Per dist>0
  // scelgo il cammino maggiore.
  // camm resta negativo se il dev non puo' essere colpito.

  /*****************  standar version ****/

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

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

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

/*
// test if hit inside the side surface
// dannazione a questo... se il device è spostato dal centro crea danni..
 if(camm>0.)
{
  gvet Xpos= X_dev+V_dev*t;
  if ( fabs ( Xpos.x ) >Lout.x ) camm=-1;
  if ( fabs ( Xpos.y ) >Lout.y ) camm=-1;
}
 */
//if(pr_dev->Get_Idm()==14 && idev==49)
//  {X_dev.print("XdR");V_dev.print("vdR");Gout<<"\n cammino Ret "<<camm;}

  return camm;
}

//----------------------C a m I n t e r --------------------
// calcola il cammino interno per uscire dal rivelatore...
// Pp punto di partenza in dev frame
// Vv versore del moto
// da chiamrsi sempre dopo Posizione....

double DevRt::CamInter()
{
  double nv,t;
  camm=1.0e+10;
  // calcolo il cammino verso le sei superfici
  // le distanze sono per definizione negative...
  // e scelgo il cammino positivo  maggiore
  // camm in uscita e' sempre definito

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

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

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