RerootExodus.cxx

Go to the documentation of this file.

// $Id: RerootExodus.cxx,v 1.62 2008/05/16 15:50:29 rhatcher Exp $
//
// RerootExodus
//
// RerootExodus is static-only class for dealing with the REROOT data
//
// Author:  R. Hatcher 2000.05.19
//

#include "RerootExodus/RerootExodus.h"

// needed for "rgeo" and "revt"
#include "MINF_Classes/MINFast.h"

#include "TArrayI.h"
#include "TMath.h"
#include "TSystem.h"

#include "MessageService/MsgService.h"
CVSID("$Id: RerootExodus.cxx,v 1.62 2008/05/16 15:50:29 rhatcher Exp $");

#include <cassert>


static Int_t        LastSteelMapGeometry  = -999;
static TArrayI     *SteelMap              = 0;
static Bool_t       FirstPasvAir          = false;  // set with steel map
static VldTimeStamp NullVldTimeStamp      = VldTimeStamp((time_t)0,0);

VldTimeStamp RerootExodus::fInitialVldTimeStamp = NullVldTimeStamp;
VldTimeStamp RerootExodus::fLastVldTimeStamp    = NullVldTimeStamp;
VldTimeStamp RerootExodus::fSpillTimeInterval   = 
           VldTimeStamp((time_t)1,900000000);
//                              s mmmuuunnn
UInt_t       RerootExodus::fNSpills = 0;
UInt_t       RerootExodus::fSnarlNum = 0;

static SimFlag::SimFlag_t DefaultSimFlag  = SimFlag::kReroot;
static Detector::Detector_t ForceDetector = Detector::kUnknown;

const Int_t  kSubRunMagic = 100000;

ClassImp(RerootExodus)

//_____________________________________________________________________________
RerootExodus::RerootExodus()
{
   // Default constructor -- called by self only
}

//_____________________________________________________________________________
RerootExodus::RerootExodus(const RerootExodus &plp)
  : TObject(plp)
{
   // copy constuctor should never get called
   MSG("Exodus",Msg::kFatal) << 
               "RerootExodus copy constructor called" << endl;
   assert(0);
}

//_____________________________________________________________________________
RerootExodus::~RerootExodus()
{
   // delete all the owned sub-objects
}

//_____________________________________________________________________________
Detector::Detector_t RerootExodus::GetDetector()
{
   // interpret GeomMisc_NearFar to get detector type
   // unless ForceDetector is set to something other than kUnknown
   // in which case use that.

  if ( ForceDetector != Detector::kUnknown ) return ForceDetector;

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "GetDetector lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      return Detector::kUnknown;
   }

   REROOT_GeomMisc *geommisc = GetGeomMisc();
   Int_t nearfar = geommisc->NearFar();

   if ( nearfar < 0 ) {
      return Detector::kNear;
   } else if ( nearfar > 0 ) {
      return Detector::kFar;
   } else if ( nearfar == 0 ) {
      return Detector::kCalDet;
   } else {
      return Detector::kUnknown;  // pass back a bad value
   }

}

//_____________________________________________________________________________
void RerootExodus::SetVldSimFlag(SimFlag::SimFlag_t flag)
{
  // Set the default SimFlag
  DefaultSimFlag = flag;
}

SimFlag::SimFlag_t RerootExodus::GetVldSimFlag()
{
  // get the default SimFlag
  return DefaultSimFlag;
}

void RerootExodus::SetForceDetector(Detector::Detector_t det)
{
  // Set the ForceDetector -- if anything but kUnknown then
  // the GetDetector() and BuildVldContext() will use this to
  // override what it would otherwise choose.
  ForceDetector = det;

  if ( det != Detector::kUnknown ) {
    MSG("Exodus",Msg::kWarning)
      << endl
      << "#################################################################" 
      << endl
      << "Whoa!  You are forcing VldContext to use k"
      << Detector::AsString(det) << " as the detector," << endl
      << "which overrides what might be found in the reroot file." 
      << "  I sure " << endl
      << "hope you know what you're doing!  Don't say I didn't warn you." 
      << endl
      << "#################################################################" 
      << endl;
  }

}

Detector::Detector_t RerootExodus::GetForceDetector()
{
  // get the ForceDetector setting
  return ForceDetector;
}
//_____________________________________________________________________________
VldContext RerootExodus::BuildVldContext(void)
{   // Build a VldContext object from the REROOT
   // geometry and event currently available

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "BuildVldContext lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      VldTimeStamp now;
      return VldContext(Detector::kUnknown,DefaultSimFlag,now);
   }

   // Determine detector type
   Detector::Detector_t detector = GetDetector();

   // By definition these should be flagged as Reroot derived
   SimFlag::SimFlag_t simflag = DefaultSimFlag;

   // determine run and event numbers
   // Int_t run = GetRunNo(); 
   Int_t evt = GetEventNo();
   static Int_t evt_last = 0;

   // Set inital timestamp if not yet set
   if (fInitialVldTimeStamp == NullVldTimeStamp) {

     fInitialVldTimeStamp = GetLastEventHistoryTimeStamp(true); // no hr,min,sec

     MSG("Exodus",Msg::kInfo)
       << "RerootExodus::BuildVldContext initial timestamp "
       << fInitialVldTimeStamp
       << " spill interval " 
       << fSpillTimeInterval.AsString("2")
       << endl;
   }

   // if it's a new event move things along
   if ( evt_last != evt ) {
     evt_last = evt;
     fNSpills++;
     // make time stamping independent of where we start in the file
     fLastVldTimeStamp = fInitialVldTimeStamp;
     fLastVldTimeStamp.Add(fSpillTimeInterval*GetEventRecord());
   }

   // Construct and return a VldContext
   return VldContext(detector,simflag,fLastVldTimeStamp);
}

//_____________________________________________________________________________
Int_t RerootExodus::GetTimeFrame(VldContext& /* vldc */)
{
  // return the TimeFrame that corresponds to this VldContext
  return Int_t( fSpillTimeInterval*(GetSnarlNum()%kSubRunMagic) );
}

//_____________________________________________________________________________
Short_t RerootExodus::GetSubRunNum()
{
  // return the SubRun #
  // it's embedded into the GEANT event #
  return GetEventNo()/kSubRunMagic;
}

//_____________________________________________________________________________
Int_t RerootExodus::GetSnarlNum()
{
  // assign a SnarlNum()  tie to tree entry, but different for subruns
  return kSubRunMagic*GetSubRunNum() + GetEventRecord();
}

//_____________________________________________________________________________
VldRange RerootExodus::BuildVldRange(void)
{
   VldContext vldc = BuildVldContext();

   VldTimeStamp start = vldc.GetTimeStamp();
   Int_t maxdt        = 4*24*60*60;  // max sec of reroot *file* generation
   VldTimeStamp end   = VldTimeStamp(start.GetSec()+maxdt,999999999);

   return VldRange(vldc.GetDetector(),
                   vldc.GetSimFlag(),
                   start,end,"RerootExodus");
}

//_____________________________________________________________________________
Int_t RerootExodus::NumberOfPlanes(const Bool_t isactv, const Int_t supermodule)
{
   // count the number of FLS or B planes in the geometry

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "NumberOfPlanes lacked gMINFast" 
         << endl;
      return 0;
   }
   
   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();
//   REROOT_GeomMisc *geommisc = GetGeomMisc();

   const TClonesArray *planeposs    = rgeo->planeposs();
   REROOT_PlanePos    *planepos     = 0;

   Int_t nplns = 0;

   for (Int_t rpln=0; rpln<planeposs->GetLast()+1; rpln++) {
      planepos = (REROOT_PlanePos*) planeposs->At(rpln);
      if (planepos->ISuper() == supermodule || supermodule == -1) {
         if (isactv) {
            // count only FLS planes
            if (planepos->ActvName()[0] == 'F') nplns++;
         } else {
            // count only Steel planes
            if (planepos->PasvName()[0] == 'B') nplns++;
         }
      }
   }

   return nplns;

}
//_____________________________________________________________________________
Int_t RerootExodus::RerootToSteelPlane(const Int_t rpln,
                                       const Bool_t isactv)
{
   // Convert from REROOT plane # to Steel Plane #

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "RerootToSteelPlane lacked gMINFast" 
         << endl;
      return 0;
   }
   
   TArrayI *steel = CreateSteelMap();

   Int_t spln;

   if (rpln < 0 || rpln > steel->GetSize()-1 ) {
      static Int_t msg = 2;
      if (msg>0) {
         const Char_t *active = (isactv) ? "active" : "steel";
         MSG("Exodus",Msg::kDebug) << endl
            << " RerootToSteelPlane  reroot " << active << " plane " << rpln 
            << " out of bounds " << endl;
         msg--;
      }
      spln = -1;
   } else {
      spln = (*steel)[rpln];
   }

   // if asking about "active" plane then make adjustment for
   // the fact the GMINOS mounts actives on the back of the
   // steel while construction will have them on the front
   // the lead "blank" steel make this all work out ok
   //         B  A B  A B  A B  A   B=steel, A=active
   // f77     1  1 2  2 3  3 4  4  
   // reroot  0  0 1  1 2  2 3  3
   // steel   0  1 1  2 2  3 3  4
   //
   // For Caldet, construction has active mounted on the front
   // of steel. In GMINOS this is hacked as plane 1 being active
   // mounted on the back of air (passive), planes 2-60 being
   // active on the back of steel, and plane 61 being the "blank"
   // steel (air mounted on the back of steel). With the above
   // numbering scheme, this works out to steel planes numbering
   // from 1-60 rather than 0-59 as desired. To fix, need to
   // subtract 1 from the above "steel" number to get the correct
   // "caldet" number.
   //            A B  A B  A B  A B
   // f77        1 2  2 3  3 4  4 5
   // reroot     0 1  1 2  2 3  3 4
   // steel      1 1  2 2  3 3  4 4
   // caldet     0 0  1 1  2 2  3 3

   if (isactv) spln++;
   if (FirstPasvAir) spln--;

   return spln;
}

//_____________________________________________________________________________
Int_t RerootExodus::SteelToRerootPlane(const Int_t spln,
                                       const Bool_t isactv)
{
   // Convert from Steel Plane # to REROOT plane #

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "SteelToRerootPlane lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      return 0;
   }
   
   TArrayI *steel = CreateSteelMap();

   // if asking about "active" plane then make adjustment for
   // the fact the GMINOS mounts actives on the back of the
   // steel while construction will have them on the front
   // the lead "blank" steel make this all work out ok
   //         B  A B  A B  A B  A   B=steel, A=active
   // f77     1  1 2  2 3  3 4  4  
   // reroot  0  0 1  1 2  2 3  3
   // steel   0  1 1  2 2  3 3  4
   //
   // For Caldet, construction has active mounted on the front
   // of steel. In GMINOS this is hacked as plane 1 being active
   // mounted on the back of air (passive), planes 2-60 being
   // active on the back of steel, and plane 61 being the "blank"
   // steel (air mounted on the back of steel). With the above
   // numbering scheme, this works out to steel planes numbering
   // from 1-60 rather than 0-59 as desired. To fix, need to
   // subtract 1 from the above "steel" number to get the correct
   // "caldet" number.
   //            A B  A B  A B  A B
   // f77        1 2  2 3  3 4  4 5
   // reroot     0 1  1 2  2 3  3 4
   // steel      1 1  2 2  3 3  4 4
   // caldet     0 0  1 1  2 2  3 3


   Int_t lookfor = (isactv) ? spln-1 : spln;
   if (FirstPasvAir) lookfor++;

   Int_t indx = TMath::BinarySearch(steel->GetSize(),steel->GetArray(),lookfor);

   if (indx < 0 || indx > steel->GetSize()-1 || lookfor != (*steel)[indx] ) {
      // last test is an artifact of TMath:BinarySearch

      static Int_t msg = 2;
      if (msg>0) {
         const Char_t *active = (isactv) ? "active" : "steel";
         Char_t result[8] = "illegal";
         if (indx>0 && indx < steel->GetSize()) 
            sprintf(result,"%d",(*steel)[indx]);
         MSG("Exodus",Msg::kDebug) 
            << "SteelToRerootPlane " << active 
            << " plane (spln) " << spln << endl
            << " not found in map "
            << "    lookfor " << lookfor << " indx " << indx 
            << " (*steel)[indx] " 
            << result << endl;
         msg--;
      }
      indx = -1;
      // don't return here without deleting the map
   }

   return indx;
}

//_____________________________________________________________________________
TArrayI *RerootExodus::CreateSteelMap(void)
{
   // Build a map from REROOT Plane # to Steel Plane #
   // For near detector it is just a shift of 1
   //   (due to the 0-th steel no having any attached scintillator)
   // For the far detector there is the shift of 1 plus
   //   the extra steel that is missing in the model of the
   //   supermodule gaps -- if it used the 2 supermodule setup.
   //   If it used the 6 supermodule setup then this is accounted
   //   for and we only need the shift by 1
   //   6 supermodules = (10BF) (220BF) (10BF+1BT) (10BF) (220BF) (10BF+1BT)

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "CreateSteelMap lacked gMINFast" 
         << endl;
      return 0;
   }
   
   REROOT_Geom  *rgeo = gREROOT_Geom;
   
   if (rgeo->GetNumberRead() == LastSteelMapGeometry) return SteelMap;

   // delete whatever exists
   delete SteelMap;

   // REROOT_GeomMisc *geommisc = GetGeomMisc();

   Detector::Detector_t detector = GetDetector();

   //Int_t nsupmdl = geommisc->NSupmdl();
   Int_t nsupdiv = 1;

   // all Far file *now* assume 3 "supermodules" per physical supermodule
   // structure (gone are the cases of 1:1 and 2:1)
   if (Detector::kFar == detector) nsupdiv = 3;

   const TClonesArray *planeposs    = rgeo->planeposs();

   Int_t nplns = planeposs->GetLast()+1;

   Int_t *array = new Int_t [nplns];

   // work with base array -- we don't need bounds checking here

   for (Int_t rpln = 0; rpln < nplns; rpln++) array[rpln] = rpln;

   // check whether we're leading with a intial "AIR" passive
   Char_t ptype = ((REROOT_PlanePos*)planeposs->At(0))->PasvName()[0];
   FirstPasvAir = (ptype == 'K');

   // hack for non-standard far detector geometries
   if (detector == Detector::kFar) {

      if (RerootPlaneToView(0) == 'U') {
        MSG("Exodus",Msg::kWarning) 
          << "CreateSteelMap() no longer supports setting "
          << "PlexPlaneId::fgFarIsUV=true"
          << endl
          << "No longer accept FarDet geomtries that start with U plane"
          << endl;
        assert(0);
      }

      const TClonesArray *supermodules = rgeo->supermodules();
      Int_t iSM, iSMpart, nplnsInSM = 0;
      REROOT_SuperModule *supermodule  = 0;
      for (int gsup=0; gsup < supermodules->GetLast()+1; gsup++) {
         // assume!! 3 GMINOS supermodules per physical supermodule
         iSM     = gsup/3;
         iSMpart = gsup%3;
         if (iSMpart == 0) nplnsInSM = 0;
         supermodule = (REROOT_SuperModule*) supermodules->At(gsup);
         nplnsInSM += supermodule->NActvPln();
         if (iSM>2) {
            MSG("Exodus",Msg::kError)
               << "CreateSteelMap saw "
               << supermodules->GetLast()+1 
               << " GMINOS supermodules " << endl
               << "   more than the allowed 2 physical SM (of 3 GMINOS  SM each)" << endl;
            break;
         }
         else {
            if (iSMpart == 2) {
               MSG("Exodus",Msg::kInfo)
                  << "RerootExodus::CreateSteelMap setting # planes in SM "
                  << iSM << " to " << nplnsInSM << endl;
               //PlexPlaneId::fgNumPlnsInFarSM[iSM] = nplnsInSM;
            }
         }
      }       // loop over GMINOS supermodules
   }          // Far
   else if (detector == Detector::kCalDet) {
      PlexPlaneId::fgCalDetCosmicsAView = (RerootPlaneToView(61) == 'A');
   }

   SteelMap = new TArrayI();
   SteelMap->Adopt(nplns,array);
   LastSteelMapGeometry = rgeo->GetNumberRead();
   MSG("Exodus",Msg::kDebug) << "created new SteelMap for " 
                             << LastSteelMapGeometry << endl;
   return SteelMap;
}

//_____________________________________________________________________________
Char_t RerootExodus::RerootPlaneToView(const Int_t rpln)
{

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "RerootPlaneToView lacked gMINFast" 
         << endl;
      return 0;
   }
   
   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();
   REROOT_PlanePos    *planepos    = (REROOT_PlanePos*) planeposs->At(rpln);

   return planepos->Rotm()[0];
}

//_____________________________________________________________________________
PlexPlaneId RerootExodus::RerootPln2PlnId(const Int_t rpln, const Bool_t isactv)
{
   // Convert from REROOT numbering to PlexPlaneId object

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "RerotoPln2PlnId lacked gMINFast" 
         << endl;
      return PlexPlaneId();
   }
   
   // the correct plane # for this type of plane
   Int_t plnid_spln = RerootToSteelPlane(rpln,isactv);
   Int_t rpln_back  = SteelToRerootPlane(plnid_spln,isactv);

   PlaneView::PlaneView_t plnid_view  = PlaneView::kUnknown;
   PlaneCoverage::PlaneCoverage_t plnid_cover = PlaneCoverage::kUnknown;
   
   PlexPlaneId noactive(GetDetector(),plnid_spln,!isactv,plnid_view,plnid_cover);
   if (GetDetector() == Detector::kCalDet && plnid_spln == 0) {
      // PlexPlaneId takes unknown as request for hardcoded default
      // which in this case assumes the CalDet 0 plane *is* instrumented
      // ??? noactive.SetPlaneView(PlaneView::kUnknown);
      // ??? noactive.SetPlaneCoverage(PlaneCoverage::kUninstrumented);
   }

   bool debug_noactive = false;
   // if it doesn't map back to itself then it isn't there
   if (rpln_back != rpln) {
      if (debug_noactive) cout << "  ******** failed to map back *" << endl;
      return noactive;
   }

   // view & coverage depend on the *active* 
   // (so if asked about a steel plane return attached active's view&coverage)
   Int_t rpln_active = SteelToRerootPlane(plnid_spln,kTRUE);

   // deal with case of the active plane attached isn't a FLS plane
   // or doesn't exist at all
   if (rpln_active<0) {
      if (debug_noactive) cout << "  ******** rpln_active < 0 *" << endl;
      return noactive;
   }
   if (ActvPlaneName(rpln_active)[0] != 'F') {
      if (debug_noactive) cout << "  ******** upstream wasn't active *" << endl;
      return noactive;
   }

   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();
   REROOT_PlanePos    *planepos    = (REROOT_PlanePos*) planeposs->At(rpln_active);
   Int_t ispec = planepos->ActvSpec();
   const TClonesArray *planespecs  = rgeo->planespecs();
   REROOT_PlaneSpec   *planespec   = (REROOT_PlaneSpec*) planespecs->At(ispec);

   char rotm = planepos->Rotm()[0];
   switch (rotm) {
   case 'u':
   case 'U':
      plnid_view = PlaneView::kU;
      break;
   case 'v':
   case 'V':
      plnid_view = PlaneView::kV;
      break;
   case 'x':
   case 'X':
// GMINOS "X" view corresponds to PlaneView::kY (strip # increase w/ "y")
      plnid_view = PlaneView::kY;
// for CalDet map kY->kV
      if (GetDetector() == Detector::kCalDet) plnid_view = PlaneView::kV;
      break;
   case 'y':
   case 'Y':
// GMINOS "Y" view corresponds to PlaneView::kX (strip # increase w/ "x")
      plnid_view = PlaneView::kX;
// for CalDet map kX->kU
      if (GetDetector() == Detector::kCalDet) plnid_view = PlaneView::kU;
      break;
   case 'a':
   case 'A':
      plnid_view = PlaneView::kA;
      break;
   case 'b':
   case 'B':
      plnid_view = PlaneView::kB;
      break;
   default:
      MSG("Exodus",Msg::kWarning) << " Rotm '" << rotm 
                                  << "' not one of {U,V,X,Y,A,B} " << endl;
   }

   // plane names take form:
   // F6PL - far detector complete coverage
   // FUPL,FVPL - near detector "full" coverage
   // FRPL,FVPL - near detector "partial" coverage
   // test on *second* character

   switch (planespec->PlnName()[1]) {
   case '1':  // std far detector plane
   case '2':  // std far detector plane
   case '6':  // std far detector plane
      plnid_cover = PlaneCoverage::kComplete;
      break;
   case 'U':
   case 'V':
      plnid_cover = PlaneCoverage::kNearFull;
      break;
   case 'R':
   case 'S':
      plnid_cover = PlaneCoverage::kNearPartial;
      break;
   case '8':  // CalDet plane
   case 'X':  // CalDet plane  X orientation (for .fiberinfo)
   case 'Y':  // CalDet plane  Y orientation (for .fiberinfo)
   case 'A':  // CalDet plane
   case 'B':  // CalDet plane
   case 'C':  // CalDet plane  Cosmic counter on floor
      plnid_cover = PlaneCoverage::kComplete;
      break;
   default:
      MSG("Exodus",Msg::kWarning) 
         << " PlnName Key '" << planespec->PlnName()[1]
         << "' not one of {1,2,6,U,V,R,S,8,X,Y,A,B,C} " << endl;
   }

   return PlexPlaneId(GetDetector(),plnid_spln,!isactv,plnid_view,plnid_cover);

}

//_____________________________________________________________________________
PlexStripEndId RerootExodus::PECAB2SEId(const Int_t rpln, const Int_t extru, const Int_t cell, const Int_t iab)
{
   // Convert from GMINOS (Plane,Extrusion,Cell) numbering
   // to PlexStripEndId object
   // iab:  0=A, 1=B

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "PECAB2SEId lacked gMINFast" 
         << endl;
      return PlexStripEndId();
   }
   

   PlexPlaneId plnid = RerootPln2PlnId(rpln,kTRUE);

   // if bad plane number return before we do any damage
   if (PlaneCoverage::kUninstrumented == plnid.GetPlaneCoverage()) 
      return PlexStripEndId(plnid,0x255);

   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();
   REROOT_PlanePos    *planepos    = (REROOT_PlanePos*) planeposs->At(rpln);

   // convert Extrusion+Cell into strip #
   // but don't count missing strips

   Int_t ispec = planepos->ActvSpec();

   const TClonesArray *planespecs  = rgeo->planespecs();
   REROOT_PlaneSpec   *planespec   = (REROOT_PlaneSpec*) planespecs->At(ispec);

   //   MSG("Exodus",Msg::kInfo) <<
   //      " PECAB2SEId pec " << plane << " " << extru << " " << cell <<
   //      " in " << planepos->ActvName() << " " << planespec->PlnName() << 
   //      endl;

   // determine end as kEast or kWest rather than A or B
   StripEnd::StripEnd_t   seid_end     = StripEnd::kUnknown;

   switch (plnid.GetPlaneView()) {
   case PlaneView::kU:
//               0=A,1=B  true=B            false=A
      if (Detector::kCalDet != plnid.GetDetector()) 
         seid_end  = (iab) ? StripEnd::kWest : StripEnd::kEast;
      else  // caldet ...
         seid_end  = (iab) ? StripEnd::kDown : StripEnd::kUp;
      break;
   case PlaneView::kV:
//               0=A,1=B  true=B            false=A
      if (Detector::kCalDet != plnid.GetDetector())
        // 'M' planes using 'W' rotation don't differ from kU mapping
        // but 'F' planes using 'V' rotation of funky 
       if ( planepos->Rotm()[0] == 'V' ) 
           seid_end  = (iab) ? StripEnd::kEast : StripEnd::kWest;
        else
           seid_end  = (iab) ? StripEnd::kWest : StripEnd::kEast;
      else // caldet ...
         seid_end  = (iab) ? StripEnd::kWest : StripEnd::kEast;
      break;
   case PlaneView::kY:
//               0=A,1=B  true=B            false=A
      seid_end  = (iab) ? StripEnd::kWest : StripEnd::kEast;
      break;
   case PlaneView::kX:
//               0=A,1=B  true=B            false=A
      seid_end  = (iab) ? StripEnd::kDown : StripEnd::kUp;
      break;
   case PlaneView::kA:
//               0=A,1=B  true=B            false=A
      seid_end  = (iab) ? StripEnd::kWest : StripEnd::kEast;
      break;
   case PlaneView::kB:
//               0=A,1=B  true=B            false=A
      seid_end  = (iab) ? StripEnd::kDown : StripEnd::kUp;
      break;
   default:
      MSG("Exodus",Msg::kWarning) 
         << " bad PlaneView '" << plnid.AsString() << endl;
   }

   StripEnd::StripEnd_t   seid_subpart = StripEnd::kWhole;

   // loop over the CellPos entries for this plane type
   // to determine the SEId strip #
   // skip strips that have no length (near detector)
   // count from top in the case of V planes so that increasing Y 
   // increases strip #
   const TClonesArray *cellposs   = rgeo->cellposs();
   REROOT_CellPos     *cellpos    = 0;
   
   Int_t seid_strip = 0;

   Int_t indx_beg, indx_end, indx_inc;
   if ( plnid.GetPlaneView() != PlaneView::kV || 
        plnid.GetDetector()  == Detector::kCalDet ) {
      indx_inc = 1;
      indx_beg = planespec->FirstStrip();
      indx_end = planespec->LastStrip() + indx_inc;
   } else {
      if ( planepos->Rotm()[0] == 'V' ) {
         // special case: V view flips counting side
         indx_inc = -1;
         indx_beg = planespec->LastStrip();
         indx_end = planespec->FirstStrip() + indx_inc;
      }
      else {
         // 'M' planes with 'W' rotation are regular
         indx_inc = 1;
         indx_beg = planespec->FirstStrip();
         indx_end = planespec->LastStrip() + indx_inc;
      }
   }

   //   MSG("Exodus",Msg::kInfo) << " cellpos range " << 
   //      indx_beg << " to " << indx_end << endl;

   for (Int_t i = indx_beg; i != indx_end; i += indx_inc) {
      cellpos = (REROOT_CellPos*) cellposs->At(i);
      Float_t length = cellpos->XYZReadout()[0] - 
                       cellpos->XYZFarend()[0];
      length = TMath::Abs(length);
      //      MSG("Exodus",Msg::kInfo) << 
      //         " look at " << i << " (" << seid_strip << ") " <<
      //         " EC " << cellpos->IExtr() << " " << cellpos->ICell() << 
      //         " length " << length << endl;
      if ( length > 0.0 ) {
         if ( cellpos->IExtr() == extru && cellpos->ICell() == cell ) break;
         // only increment if current one had non-zero length
         seid_strip++;
      }
      // not this one, move on to next in list
   }
   
   return PlexStripEndId(plnid,seid_strip,seid_end,seid_subpart);
                         
}

// Adpated from gminos/hits/PEC_pack.F.  bv@bnl.gov.  NOTE: this
// assumes that plane, extru and cell are zero origin (ie, C index) as
// returned by, eg, REROOT_FLSDigit::ID(). !!!
int RerootExodus::PEC_pack(int plane, int extru, int cell)
{
    plane += 1;                 // put them 
    extru += 1;                 // back in to 
    cell  += 1;                 // fortran order

    REROOT_Event *revt = gMINFast->GetREROOTEvent();
    const TClonesArray *gafkeys = revt->gafkeys();
    REROOT_GAFKey      *gafkey  = (REROOT_GAFKey*) gafkeys->At(0);
    int ver = gafkey->Version();
    if (ver >= 500) {
        return (plane<<16) | (extru<<8) | cell;
    }
    else {
        return cell + 1000*(extru + 1000*plane);
    }
    
}
void RerootExodus::PEC_unpack(int pec, int& plane, int& extru, int& cell)
{
    plane = (pec&0xffff0000)>>16;
    extru = (pec&0xff00)>>8;
    cell = (pec&0xff);

    plane -= 1;                 // convert from
    extru -= 1;                 // fortran to
    cell -= 1;                  // C ordering
}

//_____________________________________________________________________________
Int_t RerootExodus::NStripsNonZero(const Int_t rpln)
{
   // Count the number of strips in a given plane
   // Exclude phantom strips that have zero length due to squashing

   if (rpln<0) return 0;

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "NStripSNonZero lacked gMINFast" 
         << endl;
      return 0;
   }
   
   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();
   REROOT_PlanePos    *planepos    = (REROOT_PlanePos*) planeposs->At(rpln);

   Int_t ispec = planepos->ActvSpec();

   const TClonesArray *planespecs  = rgeo->planespecs();
   REROOT_PlaneSpec   *planespec   = (REROOT_PlaneSpec*) planespecs->At(ispec);

   Int_t indx_beg = planespec->FirstStrip();
   Int_t indx_end = planespec->LastStrip() + 1;

   const TClonesArray *cellposs   = rgeo->cellposs();
   REROOT_CellPos     *cellpos    = 0;
   
   Int_t nonzero = 0;

   for (Int_t i = indx_beg; i != indx_end; i++ ) {
      cellpos = (REROOT_CellPos*) cellposs->At(i);
      Float_t length = cellpos->XYZReadout()[0] - 
                       cellpos->XYZFarend()[0];
      length = TMath::Abs(length);
      if ( length > 0.0 ) nonzero++;
   }

   return nonzero;
}

//_____________________________________________________________________________
REROOT_CellPos * RerootExodus::GetCellPos(const PlexStripEndId seid)
{
   // get the CellPos entry corresponding to this PlexStripEndId

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetCellPos lacked gMINFast" 
         << endl;
      return 0;
   }

   int itry = 0;
   PlexStripEndId seid_try = seid;
 caldet_restart:
   
   REROOT_Geom   *rgeo = gMINFast->GetREROOTGeom();

   REROOT_PlanePos  *planepos  = GetPlanePos(seid_try);
   REROOT_PlaneSpec *planespec = GetPlaneSpec(seid_try);

   bool noinfo = (!planepos || !planespec);
   bool caldet0 =  (noinfo &&  seid.GetPlane() == 0 &&
                    seid.GetDetector() == Detector::kCalDet );
   // special case for CalDet ... PlexPlaneId expects a plane 0 active
   // it might not be there in REROOT
   if (caldet0 && itry==0) {
      // change the id for a second try
      seid_try.SetPlane(2);
      MSG("Ugli",Msg::kDebug) 
         << " fake CalDet plane 0 CellPos for strip " 
         << seid.GetStrip() << endl;
      itry++;
      goto caldet_restart;
   }

   if (noinfo) return 0;

   char rotm = planepos->Rotm()[0];
   Bool_t isV = (rotm == 'v') || (rotm == 'V');

   // loop over the CellPos entries for this plane type
   // to determine the SEId strip #
   // skip strips that have no length (near detector)
   // count from top in the case of V planes so that increasing Y 
   // increases strip #
   const TClonesArray *cellposs   = rgeo->cellposs();
   REROOT_CellPos     *cellpos    = 0;
   
   Int_t seid_strip    = 0;
   Int_t lookfor_strip = seid.GetStrip();

   Int_t indx_beg, indx_end, indx_inc;
   if ( ! isV ) {
      indx_inc = 1;
      indx_beg = planespec->FirstStrip();
      indx_end = planespec->LastStrip() + indx_inc;
   } else {
      indx_inc = -1;
      indx_beg = planespec->LastStrip();
      indx_end = planespec->FirstStrip() + indx_inc;
   }

   for (Int_t i = indx_beg; i != indx_end; i += indx_inc) {
      cellpos = (REROOT_CellPos*) cellposs->At(i);
      Float_t length = cellpos->XYZReadout()[0] - 
                       cellpos->XYZFarend()[0];
      length = TMath::Abs(length);
      //      MSG("Exodus",Msg::kInfo) << 
      //         " look at " << i << " (" << seid_strip << ") " <<
      //         " EC " << cellpos->IExtr() << " " << cellpos->ICell() << 
      //         " length " << length << endl;
      if ( length > 0.0 ) {
         if ( seid_strip == lookfor_strip) {
            return cellpos;
         }
         // only increment if current one had non-zero length
         seid_strip++;
      }
      // not this one, move on to next in list
   }

   MSG("Exodus",Msg::kDebug) <<
      "GetCellPos failed to find the strip " << seid.AsString() << endl;
   return 0;

}

//_____________________________________________________________________________
REROOT_PlanePos * RerootExodus::GetPlanePos(const PlexPlaneId plnid)
{
   // get the PlanePos entry corresponding to this PlexPlaneId

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetPlanePos lacked gMINFast" 
         << endl;
      return 0;
   }
   
   REROOT_Geom   *rgeo = gMINFast->GetREROOTGeom();
   
   Int_t rpln = SteelToRerootPlane(plnid.GetPlane(),!plnid.IsSteel());
   if (rpln<0) {
      MSG("Exodus",Msg::kDebug) 
         << "RerootExodus::GetPlanePos bad plnid " << plnid.AsString()
         << " ( rpln = " << rpln << " )" << endl;
      return 0;
   }

   const TClonesArray *planeposs  = rgeo->planeposs();
   REROOT_PlanePos    *planepos   = (REROOT_PlanePos*) planeposs->At(rpln);

   return planepos;
}

//_____________________________________________________________________________
REROOT_PlaneSpec * RerootExodus::GetPlaneSpec(const PlexPlaneId plnid)
{
   // get the PlaneSpec entry corresponding to this PlexPlaneId

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetPlaneSpec lacked gMINFast" 
         << endl;
      return 0;
   }
   
   REROOT_Geom     *rgeo     = gMINFast->GetREROOTGeom();

   REROOT_PlanePos *planepos = GetPlanePos(plnid);
   if (!planepos) return 0;
 
   Bool_t isactv = !plnid.IsSteel();
   Int_t ispec = (isactv) ? planepos->ActvSpec() : planepos->PasvSpec() ;
   const TClonesArray *planespecs  = rgeo->planespecs();
   REROOT_PlaneSpec   *planespec   = (REROOT_PlaneSpec*) planespecs->At(ispec);

   return planespec;
}

//_____________________________________________________________________________
REROOT_Rotm * RerootExodus::GetRotm(const PlexPlaneId plnid)
{
   // get the Rotm entry corresponding to this PlexPlaneId

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetRotm lacked gMINFast" 
         << endl;
      return 0;
   }
   
   REROOT_Geom     *rgeo     = gMINFast->GetREROOTGeom();

   REROOT_PlanePos *planepos = GetPlanePos(plnid);
   if (!planepos) return 0;

   Int_t irotm = planepos->RotmID();
   const TClonesArray *rotms  = rgeo->rotms();
   REROOT_Rotm        *rotm   = (REROOT_Rotm*) rotms->At(irotm);

   // only recorded Rotm is for *active* detector plane
   if (plnid.IsSteel()) {
      // search for X rotation matrix
      for (irotm=0; irotm<rotms->GetEntriesFast(); irotm++) {
         rotm   = (REROOT_Rotm*) rotms->At(irotm);
         if (!rotm) continue;
         if (rotm->Name()[0] == 'X') return rotm;
      }
      rotm = 0;  // not found?
   }

   return rotm;
}

//_____________________________________________________________________________
TString RerootExodus::PlaneName(PlexPlaneId plnid)
{
  // get the string name of the given plane 

   REROOT_PlanePos *planepos = GetPlanePos(plnid);
   if (!planepos) return "?Illegal";
   
   if (plnid.IsSteel()) return planepos->PasvName();
   else                 return planepos->ActvName();

}

//_____________________________________________________________________________
Float_t RerootExodus::SEIdToTPos(const PlexStripEndId seid)
{
   // convert from PlexStripEndId to a new-TPos position
   // "new" in the sense that V planes now have TPos going the other way

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "SEIdToTPos lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      return 0;
   }
   
   REROOT_CellPos *cellpos = GetCellPos(seid);
   if (cellpos) {
      Float_t tpos = cellpos->XYZReadout()[1]; // tpos = unrotated "y"
      // V planes flip old version of tpos
      // except CalDet where kX->kU and kY->kV
      if (seid.GetDetector() == Detector::kCalDet || 
          cellpos->PlnName()[0] != 'F' ) {   // 'M' planes are regular
         return tpos;
      } else {
         return (seid.GetPlaneView() == PlaneView::kV) ? -tpos : tpos;
      }
   } else
      return -9999;

}

//_____________________________________________________________________________
Float_t RerootExodus::SEIdToLPos(const PlexStripEndId seid)
{
   // convert from PlexStripEndId to a new-LPos position
   // "new" in the sense that V planes now have TPos going the other way

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "SEIdToTPos lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      return 0;
   }
   
   REROOT_CellPos *cellpos = GetCellPos(seid);
   if (cellpos) {
      Float_t lpos = 0.5 * (cellpos->XYZFarend()[0] + cellpos->XYZReadout()[0]);
      // V planes flip old version of tpos
      // except CalDet where kX->kU and kY->kV
      if (seid.GetDetector() == Detector::kCalDet ||
          cellpos->PlnName()[0] != 'F' ) {   // 'M' planes are regular
         return lpos;
      } else {
         return (seid.GetPlaneView() == PlaneView::kV) ? -lpos : lpos;
      }
   } else
      return -9999;

}

//_____________________________________________________________________________
Float_t RerootExodus::SEIdHalfLength(const PlexStripEndId seid)
{
   // convert from PlexStripEndId to a half length of strip

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "SEIdHalfLength lacked gMINFast" 
         << endl;
      return -1;
   }
   
   REROOT_CellPos *cellpos = GetCellPos(seid);
   if (cellpos) {
      Float_t length = cellpos->XYZReadout()[0] - 
                       cellpos->XYZFarend()[0];
      length = TMath::Abs(length);
      return length/2.0;
   } else
      return 0;

}

//_____________________________________________________________________________
Float_t RerootExodus::SEIdHalfThickness(const PlexStripEndId seid)
{
   // convert from PlexStripEndId to a half thickness of strip

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "SEIdHalfThickness lacked gMINFast" 
         << endl;
      return -1;
   }
      
   REROOT_PlaneSpec   *planespec   = GetPlaneSpec(seid);
   return 0.5*planespec->CellThick();

}

//_____________________________________________________________________________
Float_t RerootExodus::SEIdHalfWidth(const PlexStripEndId seid)
{
   // convert from PlexStripEndId to a half width of strip

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "SEIdHalfWidth lacked gMINFast" 
         << endl;
      return -1;
   }
   
   REROOT_PlaneSpec   *planespec   = GetPlaneSpec(seid);
   return 0.5*planespec->CellWidth();

}

//_____________________________________________________________________________
TVector3 RerootExodus::SEIdLocalToGlobal(const PlexStripEndId seid,
                                         const TVector3& local_in)
{

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "SEIdLocalToGlobal lacked gMINFast" 
         << endl;
      return TVector3(0.,0.,0.);
   }

   REROOT_CellPos   *cellpos   = GetCellPos(seid);
   REROOT_PlanePos  *planepos  = GetPlanePos(seid);
   REROOT_PlaneSpec *planespec = GetPlaneSpec(seid);
   REROOT_Rotm      *rotm      = GetRotm(seid);

   if ( !cellpos || !planepos || !planespec || !rotm ) {
      MSG("Exodus",Msg::kWarning)
         << "SEIdLocalToGlobal missing info: "
         << endl << seid.AsString()
         << " CellPos " << cellpos
         << " PlanePos " << planepos
         << " PlaneSpec " << planespec
         << " Rotm " << rotm
         << endl;
      return TVector3(0.,0.,0.);
   }

   // Transform local x from strip centered to plane centered
   // this is important for the chopped up near detector strips
   TVector3 local = local_in;
   Float_t xoff = 0.5*(cellpos->XYZFarend()[0]+cellpos->XYZReadout()[0]);
   local += TVector3(xoff,0.,0.);

   // "borrowed" from MINFFLS.cxx
   // code translated from xyz_cell2mars.F

   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] = local.X() + (cellpos->XYZCenter()[0]);
   xyz_inplane[1] = local.Y() + (cellpos->XYZCenter()[1]);
   xyz_inplane[2] = local.Z() + (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];

   return TVector3(XYZGlobal);
}

//_____________________________________________________________________________
TVector3 RerootExodus::SEIdGlobalToLocal(const PlexStripEndId seid,
                                         const TVector3& global)
{

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "SEIdGlobalToLocal lacked gMINFast" 
         << endl;
      return TVector3(0.,0.,0.);
   }

   REROOT_CellPos   *cellpos   = GetCellPos(seid);
   REROOT_PlanePos  *planepos  = GetPlanePos(seid);
   REROOT_PlaneSpec *planespec = GetPlaneSpec(seid);
   REROOT_Rotm      *rotm      = GetRotm(seid);


   // inverse of SEIdLocalToGlobal
   // code translated from xyz_mars2cell.F

   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_rotpln[3];
   xyz_rotpln[0] = global.X() - xyz_center[0];
   xyz_rotpln[1] = global.Y() - xyz_center[1];
   xyz_rotpln[2] = global.Z() - xyz_center[2];

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

   Float_t XYZLocal[3];
   XYZLocal[0] = xyz_inpln[0] - (cellpos->XYZCenter()[0]);
   XYZLocal[1] = xyz_inpln[1] - (cellpos->XYZCenter()[1]);
   XYZLocal[2] = xyz_inpln[2] - (cellpos->XYZCenter()[2]);

   return TVector3(XYZLocal);
}

//_____________________________________________________________________________
Int_t RerootExodus::GetRunNo()
{
   // return the current run #

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "GetRunNo lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      return -1;
   }

   return gMINFast->GetHeader()->GetRun();

   //rwh: REROOT_Event *revt = gMINFast->GetREROOTEvent();
   //rwh: const TClonesArray *gafkeys = revt->gafkeys();
   //rwh: REROOT_GAFKey      *gafkey  = (REROOT_GAFKey*) gafkeys->At(0);
   //rwh: return gafkey->RunNo();
}

//_____________________________________________________________________________
Int_t RerootExodus::GetEventNo()
{
   // return the current event #

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "GetEventNo lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      return -1;
   }

   return gMINFast->GetHeader()->GetEvent();

   //rwh: REROOT_Event *revt = gMINFast->GetREROOTEvent();
   //rwh: const TClonesArray *gafkeys = revt->gafkeys();
   //rwh: REROOT_GAFKey      *gafkey  = (REROOT_GAFKey*) gafkeys->At(0);
   //rwh: return gafkey->EventNo();
}


//_____________________________________________________________________________
Int_t RerootExodus::GetEventRecord()
{
   // return the current event record #

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetEventRecord lacked gMINFast" 
         << endl;
      return -1;
   }

   return gMINFast->GetHeader()->GetEventRecord();

}

//_____________________________________________________________________________
const char * RerootExodus::GetRerootFileName()
{
   // return the current reroot filename

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetRerootFileName lacked gMINFast" 
         << endl;
      return "no REROOT file";
   }

   const char* urlFile = 
     gMINFast->GetMINFile()->gettf()->GetEndpointUrl()->GetFile();
   return urlFile;
   //return gSystem->BaseName(urlFile);

}

//_____________________________________________________________________________
REROOT_GeomMisc* RerootExodus::GetGeomMisc()
{

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetGeomMisc lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();
   //rwh:   REROOT_Event *revt = gMINFast->GetREROOTEvent();

   // we know that there is only one useful entry so return it not the list
   const TClonesArray *geommiscs    = rgeo->geommiscs();
   return (REROOT_GeomMisc*) geommiscs->At(0);

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetFLSDigitList()
{

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "GetFLSDigitList lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }         
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->flsdigits();

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetFLSHitList()
{

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetFLSHitList lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->flshits();

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetStdHepList()
{
   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetStdHepList lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->stdheps();

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetStdHepHeadList()
{
   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetStdHepHeadList lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->stdhepheads();

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetNeuKinList()
{

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetNeuKinList lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->neukins();

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetNeuVtxList()
{
   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetNeuVtxList lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->neuvtxs();

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetFluxInfoList()
{
   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetFluxInfoList lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->fluxinfos();

}

//_____________________________________________________________________________
const TClonesArray* RerootExodus::GetFluxWgtList()
{
   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetFluxWgtList lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Event *revt = gMINFast->GetREROOTEvent();
   return revt->fluxwgts();

}

//_____________________________________________________________________________
TString RerootExodus::ActvPlaneName(const Int_t rpln)
{
   if (rpln<0) return TString("#nosuchplane");

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetActvPlaneName lacked gMINFast" 
         << endl;
      return TString("#nosuchplane");
   }

   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();
   REROOT_PlanePos    *planepos    = (REROOT_PlanePos*) planeposs->At(rpln);

   return TString(planepos->ActvName());

}

//_____________________________________________________________________________
TString RerootExodus::PasvPlaneName(const Int_t rpln)
{
   if (rpln<0) return TString("#nosuchplane");

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetPasvPlaneName lacked gMINFast" 
         << endl;
      return TString("#nosuchplane");
   }

   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();
   REROOT_PlanePos    *planepos    = (REROOT_PlanePos*) planeposs->At(rpln);

   return TString(planepos->PasvName());

}

//_____________________________________________________________________________
Float_t RerootExodus::RerootPlaneZ0(PlexPlaneId plnid)
{
   // return "z" of *center* of plane

   Float_t xyz[3];
   RerootPlaneXYZ0(plnid,xyz);
   return xyz[2];
}

//_____________________________________________________________________________
void RerootExodus::RerootPlaneXYZ0(PlexPlaneId plnid, Float_t* xyz)
{
   // return "xyz" of *center* of plane

   Bool_t isactv = ! plnid.IsSteel();
   Int_t rpln = SteelToRerootPlane(plnid.GetPlane(),isactv);
   RerootPlaneXYZ0(rpln,isactv,xyz);
}

//_____________________________________________________________________________
void RerootExodus::RerootPlaneXYZ0(const Int_t rpln, const Bool_t isactv,
                                   Float_t* xyz)
{
   // return "xyz" of *center* of plane

   if (rpln<0) {xyz[0]=xyz[1]=xyz[2]=0; return;}

   if (!gMINFast) {
      static int nmsg = 10;
      if (nmsg) {
         MSG("Exodus",Msg::kFatal) 
            << "GetRerootPlaneXYZ0 lacked gMINFast" 
            << endl;
         nmsg--;
         if (!nmsg) MSG("Exodus",Msg::kFatal) 
            << " ... last such message" << endl;
      }
      xyz[0]=xyz[1]=xyz[2]=0;
      return;
   }

   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();
   REROOT_PlanePos    *planepos    = (REROOT_PlanePos*) planeposs->At(rpln);

   Int_t indx_spec = 0;
   const TClonesArray *planespecs  = rgeo->planespecs();
   REROOT_PlaneSpec   *planespec   = 0;

   if (isactv) {
      indx_spec = planepos->ActvSpec();
      planespec = (REROOT_PlaneSpec*) planespecs->At(indx_spec);
      xyz[0] = planepos->XYActv()[0];
      xyz[1] = planepos->XYActv()[1];
      xyz[2] = planepos->ZFrntActv() + 0.5*planespec->Thickness();
   } else {
      indx_spec = planepos->PasvSpec();
      planespec = (REROOT_PlaneSpec*) planespecs->At(indx_spec);
      xyz[0] = planepos->XYPasv()[0];
      xyz[1] = planepos->XYPasv()[1];
      xyz[2] = planepos->ZFrntPasv() + 0.5*planespec->Thickness();
   }

}

//_____________________________________________________________________________
Int_t RerootExodus::RerootPlaneNo(const Float_t z)
{

   // return Plane No. given a Z value
   // This is rather brute force
   // Returns the plane pair most downstream with zmin<z
   // (except in case of supermodule gaps)

   if (!gMINFast) {
      MSG("Exodus",Msg::kFatal) 
         << "GetRerootPlaneNo lacked gMINFast" 
         << endl;
      return 0;
   }

   REROOT_Geom  *rgeo = gMINFast->GetREROOTGeom();

   const TClonesArray *planeposs   = rgeo->planeposs();

   Int_t num_plns = rgeo->n_planeposs();

   //Int_t ipln = num_plns;

//rwh:   for (Int_t i=0; i < num_plns; i++) {
   for (Int_t i=num_plns-1; i >= 0; i--) {

        REROOT_PlanePos *planepos = (REROOT_PlanePos*) planeposs->At(i);

// ignore floor planes for CalDet (ROTM = A or B)
        if (planepos->Rotm()[0] == 'A' ||
            planepos->Rotm()[0] == 'B'    ) continue;

        Float_t zmin = planepos->PairZmin();
        Float_t zmax = planepos->PairZmax();
//        Float_t zpasv = planepos->ZFrntPasv();
//        Float_t zactv = planepos->ZFrntActv();

//rwh: returns 9999 for supermodule gaps:
//      if(z >= zmin && z < zmax ) ipln = i;

//      assume list in ascending order in orginal array
//      first one with z>=zmin

        // deal with supermodule gaps
        if (z >  zmax && i<num_plns-1) return i+1; 

        // normal pair
        if (z >= zmin) return i;
   }

//rwh:   return ipln
   return 0;
}

//_____________________________________________________________________________
VldTimeStamp RerootExodus::GetLastEventHistoryTimeStamp(bool dateonly)
{

    // Determine when the event was created/modified
    // While this was a good idea it turns out that GMINOS used the
    // fortran "datime" routine and it appears my attempt to turn
    // it into a string munged with a Y2K problem
    // returning strings like "20  . 1.06  3:17" instead of "1999.11.08 13:42"
    // This is further compounded by REROOT_EventHistory's misguided
    // attempt to truncate the string by looking for the _first_ blank
    // (rather than noting the last non-blank place).
    
    // use run # to encode the "time" as a fake way of doing the
    // reverse of what one would usually do ( time --> run # )
    // stick it in the nanoseconds part
    
    Char_t  lastdate[17];
    const Char_t* origdate = "1970.01.01 00:00";
    Int_t   i;
    for (i=0; i<16; i++) lastdate[i] = ' '; lastdate[16] = '\0';
    
    REROOT_Event *revt = gMINFast->GetREROOTEvent();
    const TClonesArray  *eventhistorys  = revt->eventhistorys();
    REROOT_EventHistory *eh;
    TIter hiter(eventhistorys);
    while ( (eh = (REROOT_EventHistory*) hiter.Next() ) ) {
        //      strncpy(lastdate,eh->DateFilled(),16);
        origdate = eh->DateFilled();
        for (i=0; i<16; i++) {
            if (eh->DateFilled()[i] == '\0') break;
            lastdate[i] = eh->DateFilled()[i];
        }
    }
    
    // hack for mucked up date/time in REROOT_EventHistory
    if (lastdate[0]  == ' ') lastdate[0]  = '2';
    if (lastdate[1]  == ' ') lastdate[1]  = '0';
    if (lastdate[2]  == ' ') lastdate[2]  = '0';
    if (lastdate[3]  == ' ') lastdate[3]  = '0';
    if (lastdate[5]  == ' ') lastdate[4]  = '.';
    if (lastdate[5]  == ' ') lastdate[5]  = '0';
    if (lastdate[6]  == ' ') lastdate[6]  = '1';
    if (lastdate[7]  == ' ') lastdate[7]  = '.';
    if (lastdate[8]  == ' ') lastdate[8]  = '0';
    if (lastdate[9]  == ' ') lastdate[9]  = '1';
    if (lastdate[10] != ' ') lastdate[10] = ' ';
    if (lastdate[11] == ' ') lastdate[11] = '0';
    if (lastdate[12] == ' ') lastdate[12] = '0';
    if (lastdate[13] == ' ') lastdate[13] = ':';
    if (lastdate[14] == ' ') lastdate[14] = '0';
    if (lastdate[15] == ' ') lastdate[15] = '1';
    
    // attempt to interpret what's there ...
    Int_t year, month, day, hour, min, sec=0;
    sscanf(lastdate,"%4d.%2d.%2d %2d:%2d",&year,&month,&day,&hour,&min);
    
    // tests for mucked up date/time in REROOT_EventHistory
    Bool_t sensible = kTRUE;
    if ( month>12 || month<1 ) sensible = kFALSE;
    if (   day>31 ||   day<1 ) sensible = kFALSE;
    if (  hour>24 ||  hour<0 ) sensible = kFALSE;
    if (   min>60 ||   min<0 ) sensible = kFALSE;
    if (!sensible) {
        printf(" Report the following 3 lines to rhatcher@fnal.gov\n");
        printf(" eh->DateFilled() = \"%s\"\n",origdate);
        printf(" lastdate         = \"%s\"\n",lastdate);
        printf(" year %4d month %2d day %2d hour %2d min %2d sec %2d\n",
               year,month,day,hour,min,sec);
        if ( month>12 || month<1 ) month = 1;
        if (   day>31 ||   day<1 )   day = 1;
        if (  hour>24 ||  hour<0 )  hour = 0;
        if (   min>60 ||   min<0 )   min = 0;
    }
    
    if (dateonly) { hour = min = sec = 0; }
    
    return VldTimeStamp(year,month,day,hour,min,sec,0);
}

//_____________________________________________________________________________

TString RerootExodus::GetGminosCodeName()
{
    // The EventHistory table *might* have an entry signifying what
    // codename was given to a tagged version of GMINOS.

    TString codename("<<no-codename>>");
    
    REROOT_Event *revt = gMINFast->GetREROOTEvent();
    const TClonesArray  *eventhistorys  = revt->eventhistorys();
    REROOT_EventHistory *eh;
    TIter hiter(eventhistorys);
    while ( (eh = (REROOT_EventHistory*) hiter.Next() ) ) {
        TString keyname(eh->VersionString());
        if (keyname == "codename") {
          TString value(eh->Routine());
          codename = value;
          break;
        }
    }

    return codename;

}

//_____________________________________________________________________________

TString RerootExodus::GetGminosHostName()
{
    // The EventHistory table *might* have an entry signifying what
    // machine name (host) GMINOS was run on.

    TString hostname("<<no-hostname>>");
    
    REROOT_Event *revt = gMINFast->GetREROOTEvent();
    const TClonesArray  *eventhistorys  = revt->eventhistorys();
    REROOT_EventHistory *eh;
    TIter hiter(eventhistorys);
    while ( (eh = (REROOT_EventHistory*) hiter.Next() ) ) {
        TString keyname(eh->VersionString());
        if (keyname == "hostname") {
          TString value(eh->Routine());
          hostname = value;
          break;
        }
    }

    return hostname;

}

//_____________________________________________________________________________

---