MINFLST.cxx

Go to the documentation of this file.

// $Id: MINFLST.cxx,v 1.4 2003/03/24 20:41:53 rhatcher Exp $
//
// MINFLST.cxx
//
// Begin_Html<img src="../../pedestrians.gif" align=center>
// <a href="../source_warning.html">Warning for beginners</a>.<br>
//
// The single MINLST object describes all aspects of the scintillator
// detector.  It inherits from (i.e. has an embedded) generic
// MINFDetector, and, whereas that detector deals in generic MINFHits,
// it deals in specific MINFLSTHits:-
//
//o    Its fHits TClonesArray contains MINLSTHits that come from the
//     current REROOT_Event's REROOT_LSTHits.
//
//o    Its fTrkHits are TObjArrays of TObjArrays of MINLSTHits.
//
//o    When asked information about specific hits it interrogates the
//     current REROOT_Event's REROOT_LSTHits. 
//
// Author:  G. Irwin 7/98
//
// Also see <a href="../../root_crib/index.html">The ROOT Crib</a> and 
// <a href="../MINF_Classes.html"> MINF_Classes</a> (part of
// <a href="../index.html">The MINOS Class User Guide</a>)End_Html

#include <iostream>

#include "TMath.h"

#include "MINF_Classes/MINFast.h"
#include "MINF_Classes/MINFLST.h"

#include "REROOT_Classes/REROOT_CellPos.h"
#include "REROOT_Classes/REROOT_DigitPln.h"
#include "REROOT_Classes/REROOT_Event.h"
#include "REROOT_Classes/REROOT_Geom.h"
#include "REROOT_Classes/REROOT_LSTHit.h"
#include "REROOT_Classes/REROOT_LSTWire.h"

ClassImp(MINFLST)

//______________________________________________________________________
MINFLST::MINFLST()
{
   fNV       = 0;
   fNH       = 0;
   fIshunt   = 0;
}

//______________________________________________________________________
MINFLST::MINFLST(const char *name, const char *title) :
   MINFDetector(name,title)
{

//Begin_Html
/*
<img src="gif/MINFlst.gif">
*/
//End_Html

   fHits = new TClonesArray("MINFLSTHit", 405);

   fNV         =  1;
   fNH         =  3;
   fIshunt     =  0;
}

//______________________________________________________________________
MINFLST::~MINFLST()
{
}

//______________________________________________________________________
void MINFLST::BookHits(REROOT_Event *revt)
{
   
// Get pointer to current REROOT_Geom object.
   REROOT_Geom *rgeo = REROOT_Geom::curgeom();

// Set detector type index from MINFast enum of detector types.
   Int_t det = (MINFast::DETTYPE) MINFast::LST;

// Set up fTrkHits = TObjArray by track of TObjArrays by hit.
   Int_t ntracks = gMINFast->GetNtrack();
   fTrkHits = new TObjArray(ntracks);

//gmi printf("MINFLST::BookHits: create fTrkHits for ntracks = %d\n",
//gmi                                                          ntracks);
//gmi printf("MINFLST::BookHits: Tracks in fTrkHits = %d\n",
//gmi                                       fTrkHits->GetEntriesFast());

   for (Int_t itrk=0; itrk<ntracks; itrk++) {
     fTrkHits->Add(new TObjArray(50));

//gmi printf("MINFLST::BookHits: addhitarray to fTrkHits for trk %d\n",
//gmi                                                             itrk);
//gmi printf("MINFLST::BookHits: Tracks in fTrkHits = %d\n",
//gmi                                       fTrkHits->GetEntriesFast());
   }

   TClonesArray &lhits = *fHits;
   const TClonesArray *lsthits = revt->lsthits();
   REROOT_LSTHit *lsthit;

   for (Int_t ihit=0; ihit<revt->n_lsthits(); ihit++) {
     lsthit = (REROOT_LSTHit *) lsthits->At(ihit);
     Int_t track = TMath::Abs(lsthit->ITrack()); // Should flag neg trks

//gmi printf("MINFLST::BookHits: processing hit %d\n",ihit);
//gmi printf("MINFLST::BookHits: Hit comes from track %d\n",
//gmi                                                 lsthit->ITrack());

// Kludge until lsthits gets meaningful track number.
     if (track >= ntracks)
      printf("MINFLST::BookHits: Track no. %d >= number of tracks %d\n",
                                                        track, ntracks);
     track = TMath::Min(track, ntracks-1); 

//gmi printf("MINFLST::BookHits: Track no. converted to %d\n",track);
//gmi printf("MINFLST::BookHits: Hits so far this track = %d\n",
//gmi                 ((TObjArray *) fTrkHits->At(track))->GetLast()+1);
//gmi printf("MINFLST::BookHits: Hits so far this track = %d\n",
//gmi                   ((TObjArray *) GetTrkHits(track))->GetLast()+1);

// Calculate XYZGlobal first.
     const TClonesArray *cellposs   = rgeo->cellposs();
     const TClonesArray *planeposs  = rgeo->planeposs();
     const TClonesArray *planespecs = rgeo->planespecs();
     const TClonesArray *rotms      = rgeo->rotms();

// These lines are here for debug.  gmi
     if (!cellposs)   {cout << "cellposs = 0" << endl;  return;}
     if (!planeposs)  {cout << "planeposs = 0" << endl;  return;}
     if (!planespecs) {cout << "planespecs = 0" << endl;  return;}
     if (!rotms)      {cout << "rotms = 0" << endl;  return;}

// Get pointer to REROOT_PlanePos from its TClonesArray.
     REROOT_PlanePos *planepos =
                      (REROOT_PlanePos *) planeposs->At(lsthit->IPln());

// Get pointer to REROOT_PlaneSpec from its TClonesArray.
     REROOT_PlaneSpec *planespec =
              (REROOT_PlaneSpec *) planespecs->At(planepos->ActvSpec());

// Get pointer to REROOT_Rotm from its TClonesArray.
     REROOT_Rotm *rotm = (REROOT_Rotm *) rotms->At(planepos->RotmID());

// Get pointer to REROOT_CellPos from its TClonesArray.
     REROOT_CellPos *cellpos =
                     (REROOT_CellPos *) cellposs->At(lsthit->CellPos());

// Calculate XYZGlobal[3] vector for hit.
     Float_t xyz_center[3];
     xyz_center[0] = planepos->XYActv()[0];
     xyz_center[1] = planepos->XYActv()[1];
     xyz_center[2] = planepos->ZFrntActv() + 0.5*planespec->Thickness();

     Float_t xyz_inplane[3];
     xyz_inplane[0] = 0.5 * (lsthit->XEnd()+lsthit->XBegin()) +
                            (cellpos->XYZCenter()[0]);
     xyz_inplane[1] = 0.5 * (lsthit->YEnd()+lsthit->YBegin()) +
                            (cellpos->XYZCenter()[1]);
     xyz_inplane[2] = 0.5 * (lsthit->ZEnd()+lsthit->ZBegin()) +
                            (cellpos->XYZCenter()[2]);

     Float_t XYZGlobal[3];
     XYZGlobal[0] = xyz_inplane[0]*rotm->r11() +
                    xyz_inplane[1]*rotm->r21() +
                    xyz_inplane[2]*rotm->r31() + xyz_center[0];
     XYZGlobal[1] = xyz_inplane[0]*rotm->r12() +
                    xyz_inplane[1]*rotm->r22() +
                    xyz_inplane[2]*rotm->r32() + xyz_center[1];
     XYZGlobal[2] = xyz_inplane[0]*rotm->r13() +
                    xyz_inplane[1]*rotm->r23() +
                    xyz_inplane[2]*rotm->r33() + xyz_center[2];

     Int_t *vol = 0;
     new(lhits[ihit]) MINFLSTHit(fIshunt,det,ihit,track,vol,XYZGlobal);
     fNhits++;

//gmi printf("MINFLST::BookHits: addhitarray to lhits for hit %d\n",
//gmi                                                             ihit);
//gmi printf("MINFLST::BookHits: hits in lhits = %d\n",
//gmi                                           lhits.GetEntriesFast());
//gmi printf("MINFLST::BookHits: fNhits = %d\n",fNhits);

// Put pointer to this MINFLSTHit object into fTrkHits[track][itrkhit].
     ((TObjArray *) GetTrkHits(track))->Add(lhits[fNhits-1]);

   }
}

//______________________________________________________________________
Int_t MINFLST::DistancetoPrimitive(Int_t , Int_t )
{
   return 9999;
}

//______________________________________________________________________
void MINFLST::DumpHit(Int_t ihit)
{

// Dump REROOT object for selected hit.
   printf("MINFLST::DumpHit number %d\n", ihit);
   const TClonesArray *lsthits = gMINFast->GetREROOTEvent()->lsthits();
   REROOT_LSTHit *lsthit = (REROOT_LSTHit *) lsthits->UncheckedAt(ihit);
   if (lsthit) {
     lsthit->printEvent(cout);
     lsthit->Dump();
   }
}

//______________________________________________________________________
Float_t MINFLST::GetHitELOSS(Int_t ihit)
{

// Returns ELOSS for selected hit.
   const TClonesArray *lsthits = gMINFast->GetREROOTEvent()->lsthits();
   REROOT_LSTHit *lsthit = (REROOT_LSTHit *) lsthits->UncheckedAt(ihit);
   if (!lsthit) return 0.;
   return (lsthit->ELoss());
}

//______________________________________________________________________
Float_t MINFLST::GetHitPartMom(Int_t ihit)
{

// Returns momentum of particle causing selected hit.
   const TClonesArray *lsthits = gMINFast->GetREROOTEvent()->lsthits();
   REROOT_LSTHit *lsthit = (REROOT_LSTHit *) lsthits->UncheckedAt(ihit);
   if (!lsthit) return 0.;
   return (lsthit->Ptot());
}

//______________________________________________________________________
Int_t MINFLST::GetIPDG(Int_t ihit)
{

// Get REROOT object for selected hit.
   const TClonesArray *lsthits = gMINFast->GetREROOTEvent()->lsthits();
   REROOT_LSTHit *lsthit = (REROOT_LSTHit *) lsthits->UncheckedAt(ihit);
   if (lsthit) return (lsthit->IPDG());
   return 0;
}

//______________________________________________________________________
void MINFLST::InspectHit(Int_t ihit)
{

// Inspect REROOT object for selected hit.
   const TClonesArray *lsthits = gMINFast->GetREROOTEvent()->lsthits();
   REROOT_LSTHit *lsthit = (REROOT_LSTHit *) lsthits->UncheckedAt(ihit);
   if (lsthit) lsthit->Inspect();
}

//______________________________________________________________________
void MINFLST::Paint(Option_t *)
{
}

ClassImp(MINFLSTHit)

//______________________________________________________________________
MINFLSTHit::MINFLSTHit(Int_t shunt, Int_t det,  Int_t idlsthit,
                       Int_t track, Int_t * /* vol */, Float_t *hits) :
MINFHit(shunt, det, track)
{
   fIDREROOTHit = idlsthit;
//gmi   for (Int_t i=0;i<2;i++) fVolume[i] = vol[i];
   fX=hits[0];
   fY=hits[1];
   fZ=hits[2];
}

//______________________________________________________________________
MINFLSTHit::MINFLSTHit()
{
}

//______________________________________________________________________
MINFLSTHit::~MINFLSTHit()
{
}

---