MyTracking: Reconstruccion de trazas en FTD en MarlinReco

Descripcion del Codigo


Este software funciona con la version V01-04 del software del ILC. Estoy trabajando en la v01-06 ahora. Ya os hare un update cuando este listo.

Esencialmente, añado un procesador Marlin que se llama MyTracking? (localizado en /mnt/data2/ilcsoft/ilcinstall_prueba/ilcinstall/my_v01-04/MarlinReco/v00-10-04/Tracking/SiliconTracking/src ). Este reconstruye trazas en el FTD usando todos los utensilios que encontraras en un paquete nuevo: TrackingTools?. Si miras mas detenidamente el codigo reconoceras el codigo del filtro de Kalman de CMS...

La reconstruccion estandar tiene como input un fichero LCIO con colecciones de SimTrackerHits? etc, y produce un fichero LCIO con colecciones de trazas reconstruidas etc. La reconstruccion mia produce una ntupla ROOT. Asi me ahorro un paso para convertir el LCIO en ROOT.

root [0] TFile f1("ntuple.root")
root [1] f1.ls()
TFile**         ntuple.root
 TFile*         ntuple.root
  KEY: TNtuple  confucius;1     confucius
  KEY: TNtuple  eff;1   eff
  KEY: TNtuple  hit;1   hit
  KEY: TNtuple  track;1 track

Las tuplas que creas en el fichero root contienen la siguiente información:

  • "eff": diversa información cinemática de las partículas MC + información de la trayectoria reconstruida que han generado.
  • "hit": diversa información de los hits
  • "confucius": cinematica de particula MC y traza asociada (semillas de hits consecutivos??)
  • "track": numero de hits y cinemática de las trazas y semillas encontradas
NOTA: Olvidaros de las ntuplas "confucius" y "track" (que sirvieron para hacer un plot muy enrevesado hace bastante tiempo)

Variables de las ntuples

NTUPLE "eff"

  • 0 :evt
  • 1 :pdg :
  • 2 : p :
  • 3 :pt :
  • 4 :theta :
  • 5 :phi :
  • 6 :vtxx :
  • 7 :vtxy :
  • 8 :vtxz :
  • 9 :evtxx :
  • 10 :evtxy :
  • 11 :evtxz :
  • 12 :t1nh :
  • 13 :t1p :
  • 14 :t1pt :
  • 15 :t1theta :
  • 16 :t1phi :
  • 17 :t1d0 :
  • 18 :t1z0 :
  • 19 :t2nh :
  • 20 :t2p :
  • 21 :t2pt :
  • 22 :t2theta :
  • 23 :t2phi :
  • 24 :t2d0 :
  • 25 :t2z0 :

NTUPLE "hit"

  • 0 :evt :
  • 1 :side :
  • 2 :layer :
  • 3 :x :
  • 4 :y :
  • 5 :z :
  • 6 :r :
  • 7 :theta :

root [2] eff->Scan()
************************************************************************************************************
*    Row   *       evt *       pdg *         p *        pt *     theta *       phi *      vtxx *      vtxy *
************************************************************************************************************
*        0 *         0 *        13 * 2.0000014 * 1.8400890 * 1.9734002 * 2.8171234 *         0 *         0 *
*        1 *         0 *        13 * 2.0000014 *  1.928532 * 1.3026561 * 0.9479593 *         0 *         0 *
*        2 *         0 *        13 * 2.0000014 * 0.9553816 * 0.4980239 * 1.3556954 *         0 *         0 *
*        3 *         0 *        13 * 2.0000016 * 1.7393161 * 2.0870847 * 2.2315609 *         0 *         0 *
*        4 *         0 *       -13 * 2.0000014 * 0.7537208 * 0.3864041 * -1.209654 *         0 *         0 *
*        5 *         0 *        13 * 2.0000014 * 1.0498882 * 2.5889437 * 2.3403301 *         0 *         0 *
*        6 *         0 *       -13 * 2.0000014 * 1.9183646 * 1.8574986 * -1.404702 *         0 *         0 *
*        7 *         0 *       -13 * 2.0000014 * 1.9324486 * 1.3101500 * -1.996732 *         0 *         0 *
*        8 *         0 *       -13 * 2.0000014 * 1.9608719 * 1.3726607 * 0.0610460 *         0 *         0 *
*        9 *         0 *       -13 * 2.0000014 * 0.8833087 * 0.4574414 * 1.2320897 *         0 *         0 *
*       10 *         0 *        13 * 2.0000014 * 1.2723186 * 0.6895095 * -1.434904 *         0 *         0 *
root [3] hit->Scan()
************************************************************************************************************
*    Row   *       evt *      side *     layer *         x *         y *         z *         r *     theta *
************************************************************************************************************
*        0 *         0 *         0 *         0 * 1.7663962 * 11.832013 *        22 * 11.963138 * 0.4980544 *
*        1 *         0 *         0 *         0 * 2.6196887 * -8.563647 *        22 * 8.9553794 * 0.3865800 *
*        2 *         0 *         0 *         1 * 3.7982239 * -14.62814 * 37.130939 * 15.113214 * 0.3865475 *
*        3 *         0 *         0 *         2 * 4.5869855 * -25.76406 * 64.490577 * 26.169204 * 0.3854820 *
*        4 *         0 *         0 *         0 * 2.0843827 * -6.676621 *        22 * 6.9944214 * 0.3078224 *
*        5 *         0 *         0 *         1 * 2.1919360 * -6.675683 * 37.130939 * 7.0263309 * 0.1870197 *
*        6 *         0 *         0 *         2 * 2.2845237 * -6.662490 * 64.490577 * 7.0432825 * 0.1087829 *
*        7 *         0 *         1 *         0 * -10.08300 * 9.0754499 *       -22 * 13.565794 * 2.5890369 *
*        8 *         0 *         0 *         0 * 1.4301350 * -11.20565 * 21.998750 * 11.296547 * 0.4743959 *
*        9 *         0 *         0 *         0 * 4.2492046 * 9.9453067 *        22 * 10.815030 * 0.4568988 *
*       10 *         0 *         0 *         0 * 3.1762721 * 7.7407164 *        22 * 8.3670425 * 0.3634267 *

Descricion del codigo

MyTracking hace una reconstruccion de trazas en el FTD "standalone", i.e. sin usar la información de los demas detectores. Empieza en hits simulados de GEANT4 (pasamos de los modulos de digitizacion estandares de MarlinReco?). El algoritmo usa los utensilios de "TrackingTools": un "kit" completo de filtro Kalman para ajustar la trayectoria de las particulas cargadas:

  • propagadores: permiten extrapolar una trayectoria a un plano. en primer orden el modelo seria de un helice, pero se tienen en cuenta tambien efectos de material. devuelve una posicion + errores en el plano.
  • estimadores: calculan los residuos entre un hit en un plano y la posicion extrapolada de la trayectoria.
  • el filtro Kalman procede a actualizar los parametros de la trayectoria y sus errores en base a la informacion del hit Reconstruimos las trazas partiendo de semillas creadas a partir de combinaciones de hits en el primer y segundo disco. Propagamos cada semilla al tercer disco, buscamos un hit compatible (dentro de 5 sigma, combinando los errores de la trayectoria y del hit), actualizamos la trayectoria con la informacion del hit, propagamos al cuarto disco, y asi hasta llegar al final del detector. Si hay dos hits compatibles duplicamos la trayectoria, actualizamos una copia con cada hit y seguimos con las dos.

En el constructor (antes de empezar el bucle de sucesos) leemos unos parametros del algoritmo que se pueden modificar en el "steering file". Los parametros incluyen los limites de los parametros de las trazas que vamos a reconstruir (el parametro de impacto maximo, el pT minimo), algunos parametros que describen el detector (resolucion de hits en Rphi y R de los discos, material en cada disco). En MyTracking?::init() se lee el fichero "GEAR" que contiene informacion sobre la geometria del detector (posiciones de los discos, campo magnetico, etc). Finalmente se crean algunos de los utensilios que vamos a usar: los propagadores y estimadores del filtro Kalman, y el ajustador de trazas.

Para cada suceso ejecutamos: processEvent( LCEvent * evt ) { fillTransientHitCollectionFTD( evt ); // este metodo abre la coleccion de hits simulados (objetos de tipo SimTrackerHit? que contienen la posicion del deposito de energia de GEANT4). Para cada hit:

  • hace un "smearing" con la resolucion declarada en el steering file
  • crea un plano que cuelga de la geometria del detector (usaremos estos planos como destino para el propagador) (theGeometry->addFTDModule(tp,radLen,xi, localerrx, localerrz);),
  • llena la ntupla "hits", y
  • crea un TransientTrackingRecHit? que vuelca en un vector _transientHitsFTD[layer].push_back(smearedTRecHit);

para comparar la traza reconstruida con lo que simulamos vamos a buscar la particula MC. Nos limitamos a buscar un muon (en estas muestras basta con eso)., MCParticle *mcp = getTracksFromMC( evt ); nos interesan su momento (realMom.mag(), perp(), theta(), phi() que seran p, pt, theta y phi en la ntupla "eff") su vertice de origen (vtxx, vtxy, vtxz en "eff"; en este caso es siempre (0,0,0)) y el punto final de la trayectoria (evtxx,evtxy,evtxz).

Y ya procedemos a la reconstruccion de trazas trackingInFTD(); createSeedsFTD(); crea las semillas para iniciar la busqueda de trazas. Para cada combinacion de hits en disco 1 y 2 crea un SeedFromConsecutiveHits? que vuelca en seedsFTD_finalTrajectories.clear();

createTrajectoriesFTD(); lleva cada semilla a los discos siguientes.

En cada paso intenta añadir un hit a la(s) trayectoria(s): extendTrajectoriesFTD(iSeed, trajectories,iS,iL);

En este paso la trayectoria puede:

  • crecer si se encuentra un hit compatible
  • dar por acabada si no hay ningun hit cercano
  • duplicarse en varias trayectorias si hay multiples hits

Las trayectorias que ya no encuentran hits se salvan en finalTrajectories. Las demas siguen a la siguiente ronda. Cuando hayamos terminado el bucle sobre todos los discos volvemos a "processEvent". Para las 0, 1 o 2 trayectorias en finalTrajectories hacemos un ajuste final con el FitterSmoother? y llenamos la ntupla "eff" con el momento de la traza.

-- Main.iglesias - 02 Feb 2009

Revision: r1.5 - 22 Jan 2010 - 09:49 - Main.iglesias
ILC > DescripcionDelCodigo
Copyright © 1999-2019 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding this material Send feedback