flyopunta/src/src_dev/devxtax.cpp

/***************************************************************************
                          devxtax  -  description
                             -------------------
    begin                : Sat Aug 14 2004
    copyright            : (C) 2004 by gmp
    email                : peppe@newpeppe
  ***************************************************************************
  *                                                                         *
  *   NA48  simulation program.                                             *
  *                                                                         *
  ***************************************************************************/
#include "parm.h"
#include "devxtax.h"
#include "evento.h"

DevXTax::DevXTax()
 : DevRt()
{
  devtype=TypDevXTax;
  devclass="X_Tax";
//Plane versor  of the hole y-walls
  gvet P1,P2; 
//  
  Ptxup.setvn(Lin[0],Lin[1],-Lin[2]);         // dx,dy,-dz
  Ptxdw.setvn(Lin[0],-Lin[1],-Lin[2]);        // dx,-dy,-dz
  P1=Ptxup; P1[0]=-P1[0];                      //-dx,dy,-dz
  P2.setvn( Fortax[0],Fortax[1],Fortax[2]);    // dx,dy',dz    
  
  Vtxup=(Ptxup-P1)&(Ptxup-P2);   
  Vtxup=Vtxup.NVerso(); // prodotto vettoriale normalizzato
// per simmetria 
  Vtxdw=Vtxup;Vtxdw[1]=-Vtxdw[1];
  
  /*
  Fortax.print("Fortax");
  Ptxup.print("Ptxup");
  Ptxdw.print("Ptxdw");
  P1.print("P1");
  P2.print("P2");
  Vtxup.print("Vtxup");
  Vtxdw.print("Vtxdw");
  */
  
 
}


DevXTax::~DevXTax()
{
}

//======================================================
//----------------- -----P o s i z i o n e ---
int DevXTax::Posizione()
{
  if( DevRt::Posizione()>0) return 1; //  il punto e' esterno
// il dev ha un buco centrale rettangolare che diminuisce (o cresce) in y in funzione di z   
// devo scalare le dimensioni y del buco secondo la z tel punto.

  P_Cin=X_dev-Centrin;   // mi riferisco al centro del buco interno 
  ForSize=Lin;
  ForSize[1]=Lin[1] + 0.5*(Fortax[1]-Lin[1])*(Lin[2]+P_Cin[2])/Lin[2];
  Dind=P_Cin-ForSize;
  Dins=-(ForSize+P_Cin);
    
  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;
// ritorno -1 se il punto e' nel buco altrimento ritorno 0
   
   return -1;
}
//----------------- --------
void DevXTax::Prgeom()
 {

  Gout<<"==================  R i v e l a t o r e =================";
  Gout<<"\n --> < "<<nome <<" >  [ "<<fun
  <<" ]  X_tax  con foro rettang variabile in y  lungo z ."<<std::endl;
  Device::Prgeom();
  Gout<<std::endl;
}

//----------------------C a m I n t e r --------------------

double DevXTax::CamInter()
{
//uso quella di DevRt per calcolare il cammino
// interno 
   tratto=DevRt::CamInter();
//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_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;}
      
// attenzione: piano inclinato  superiore     
  nv=V_dev%Vtxup; dtxd=(Ptxup-P_Cin)%Vtxup; 
  if(nv<0.0 && dtxd<0.0)              
      {t=dtxd/nv;  if(t>camm)camm=t;}
// piano inferiore... 
  nv=V_dev%Vtxdw; dtxd=(Ptxdw-P_Cin)%Vtxdw; 
  if(nv<0.0 && dtxd<0.0)
      {t=dtxd/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;}

  // 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 DevXTax::CamBuco()
{
//  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  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; }
// piani inclinati y: superiore  Vtxup,Vtxdw sono i versori
// dei piani                       
  if( (nv=V_dev%Vtxup) >0.0)  
      {dtxd=(Ptxup-P_Cin)%Vtxup;
       t=dtxd/nv; if(t<camm)camm=t; }
// piani inclinati: inferiore                    
  if( (nv=V_dev%Vtxdw) >0.0)  
      {dtxd=(Ptxdw-P_Cin)%Vtxdw;
       t=dtxd/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; }
return camm;
}