flyopunta/src/src_dev/devotot.cpp

/***************************************************************************
                          devotot.cpp  -  description
                             -------------------
    begin                : Sun Dec 7 2003
    copyright            : (C) 2003 by gmp
    email                : peppe@newpeppe
  ***************************************************************************
  *                                                                         *
  *   NA48  simulation program.                                             *
  *                                                                         *
  ***************************************************************************/
#include "parm.h"
#include "devotot.h"

DevOtOt::~DevOtOt(){
}


//================== DevOtOt ======Erede di DevOt
DevOtOt::DevOtOt()
 {
   devtype=TypDevOtOt;
   devclass="Ottg_Ottg";
 }

 //----------------- --------
 void DevOtOt::Prgeom()
 {

  Gout<<"==================  R i v e l a t o r e =================";
  Gout<<"\n --> < "<<nome <<" >  [ "<<fun
      <<" ]  Ottagonale con buco ottagonale  "<<std::endl;
  Device::Prgeom();
 }

//======================================================
//----------------- -----P o s i z i o n e ---
int DevOtOt::Posizione()
{

  if( DevOt::Posizione()>0) return 1; //  il punto e' esterno

  // se sono interno al rivelatore verifico se siamo nel buco

  P_Cin=X_dev-Centrin;   // mi riferisco al centro del buco interno
  Dind=P_Cin-Lin;
  Dins=-(Lin+P_Cin);

// 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.);
   
   P_Crot.setvn(Firot*(P_Cin[0]+P_Cin[1]),Firot*(P_Cin[1]-P_Cin[0]), P_Cin[2]);
  Dinrd=P_Crot-Lin;
  Dinrs=-(Lin+P_Crot);   // l'operatore unario "-" funge....

// Test now  

  if(Dins[2]>0.0  || Dind[2]>0.0  || Dins[0]>0.0 ||
     Dind[0]>0.0  || Dins[1]>0.0  || Dind[1]>0.0    ) return 0;
     
  if(Dinrs[0]>0.0 ||
     Dinrd[0]>0.0 || Dinrs[1]>0.0 || Dinrd[1]>0.0   ) return 0;
// ritorno -1  perche' nel buco
  return -1;
}
//----------------------C a m E s t e r --------------------
// usa quella di DevOt  per eredita'
//===========================================================
//----------------------C a m I n t e r --------------------

double DevOtOt::CamInter()
{
//uso quella di DevRt per calcolare il cammino
// interno senza il buco...
  double tratto=DevOt::CamInter();
  double nv,t;
  camm=-1.;
// calcolo il cammino positivo verso le otto+2  superfici del buco. Per dist>0
// scelgo il cammino maggiore

  if((nv=V_dev[0])>0.0 && Dins[0]>0.0)  // piani x
      {t=Dins[0]/nv;  if(t>camm)camm=t;}
  else if(nv<0.0 && Dind[0]>0.0)
      {t=-Dind[0]/nv; if(t>camm)camm=t;}
  if((nv=V_dev[1])>0.0 && Dins[1]>0.0)  // piani y
      {t=Dins[1]/nv;  if(t>camm)camm=t;}
  else if(nv<0.0 && Dind[1]>0.0)
      {t=-Dind[1]/nv; if(t>camm)camm=t;}   
  if((nv=V_dev[2])>0.0 && Dins[2]>0.0)  // piani z
      {t=Dins[2]/nv;  if(t>camm)camm=t;}
  else if(nv<0.0 && Dind[2]>0.0)
      {t=-Dind[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 && 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 && Dind[1]>0.0)
      {t=-Dinrd[1]/nv; if(t>camm)camm=t;}
// test su zeta non serve
 
// 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 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; }

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


      
     
return camm;
}