infid_finder.cxx

Go to the documentation of this file.

#include "DataUtil/infid_finder.h"

#include <iostream>
#include <iomanip>

#include "TMath.h"

#include "Plex/PlexPlaneId.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliPlnHandle.h"

// Older versions of Util don't have GetMsgLevel, but because of
// ties of UtilIstHEP to newer versions of ROOT we can't use an new
// version of the Util package (which has the functions) here and 
// still use this under R1.24.3/v5-12-00f.  Thus the duplicate 
// implementations of these MsgLevel() and GetMsgLevel()

#include <MessageService/Msg.h>
#include <MessageService/MsgService.h>

namespace FidVol {
bool MsgLevel(const char* stream, const char* level);
const char* GetMsgLevel(const char* stream);
}

bool FidVol::MsgLevel(const char* stream, const char* level)
{
    MsgStream *s = MsgService::Instance()->GetStream(stream);
    if (!s) return false;
    Msg::LogLevel_t lvl = Msg::GetLevelCode(level);
    if ( lvl < 0 ) return false;
    s->SetLogLevel(lvl);
    return true;
}

const char* FidVol::GetMsgLevel(const char* stream)
{
    MsgStream *s = MsgService::Instance()->GetStream(stream);
    if (!s) return Msg::LevelAsString(Msg::kInfo); // default
    Msg::LogLevel_t lvl = s->GetLogLevel();
    if ( lvl < 0 ) return Msg::LevelAsString(Msg::kInfo); // default
    return Msg::LevelAsString(lvl);
}


// utility functions
UgliPlnHandle fidvol_find_ugliplnhandle(PlexPlaneId plnid, 
                                        std::vector<UgliPlnHandle>& plnv)
{
  for (unsigned int i = 0; i < plnv.size(); ++i) {
    const UgliPlnHandle& uph = plnv[i];
    if (uph.GetPlexPlaneId() == plnid) return uph;
  }
  // fell through
  return UgliPlnHandle();
}
                                        
void fidvol_toggle_msglvl()
{
  static const char* msglvl_dbi  = "Fatal";
  static const char* msglvl_ugli = "Fatal";
  static const char* msglvl_geo  = "Fatal";

  const char* curr_dbi  = FidVol::GetMsgLevel("Dbi");
  const char* curr_ugli = FidVol::GetMsgLevel("Ugli");
  const char* curr_geo  = FidVol::GetMsgLevel("Geo");
  FidVol::MsgLevel("Dbi",msglvl_dbi);
  FidVol::MsgLevel("Ugli",msglvl_ugli);
  FidVol::MsgLevel("Geo",msglvl_geo);
  msglvl_dbi  = curr_dbi;
  msglvl_ugli = curr_ugli;
  msglvl_geo  = curr_geo;
}

const char* FidVol::AirRegionAsString(FidVol::EAirRegion region)
{
  switch (region) {
  case kBetweenScintAndSteel:  return "BetweenScintAndSteel";
  case kDownstreamOfSteel:     return "DownstreamOfSteel";
  default:                     return "UnknownAirRegion";
  }
}

const char* FidVol::PositionAsString(FidVol::EPosition pos)
{
  switch (pos) {
  case kUpstream:   return "upstream";
  case kMiddle:     return "middle";
  case kDownstream: return "downstream";
  default:          return "UnknownPosition";
  }
}

double FidVol::infid_z_finder(VldContext vldc, int planenum, 
                            EAirRegion region, EPosition pos, double eps)
{

  fidvol_toggle_msglvl(); // quiet things down
  //std::cout << "FidVol::infid_z_finder for " << vldc.AsString() << std::endl;

  UgliGeomHandle ugh(vldc);
  PlexPlaneId plnid_steel(vldc.GetDetector(),planenum,true);
  // kBetweenScintAndSteel means scint/steel are same pair and scint is upstream
  // kDownstreamOfSteel means scint
  int dir = -1;
  if ( kDownstreamOfSteel == region ) dir = +1;
  PlexPlaneId plnid_adjoin = plnid_steel.GetAdjoin(dir);
  if ( ! plnid_steel.IsValid() || ! plnid_adjoin.IsValid() ) {
    std::cout << "HEY! invalid plane " << planenum
              << " steel " << plnid_steel << " adjoin " << plnid_adjoin
              << std::endl;
    fidvol_toggle_msglvl(); // restore message levels
    return -9999;
  }
  
  std::vector<UgliPlnHandle> uphv = ugh.GetPlnHandleVector();
  UgliPlnHandle uph_steel  = fidvol_find_ugliplnhandle(plnid_steel,uphv);
  UgliPlnHandle uph_adjoin = fidvol_find_ugliplnhandle(plnid_adjoin,uphv);
  if ( ! uph_steel.IsValid()  || ! uph_adjoin.IsValid() ) {
    std::cout << "HEY! invalid UgliPlnHandle: steel "
              << (uph_steel.IsValid()?"okay":"invalid")
              << " adjoin "
              << (uph_adjoin.IsValid()?"okay":"invalid")
              << std::endl;
    fidvol_toggle_msglvl(); // restore message levels
    return -9999;
  }

  double zup, zdn;
  if ( kDownstreamOfSteel == region ) {
    zup = uph_steel.GetZ0()  + uph_steel.GetHalfThickness();
    zdn = uph_adjoin.GetZ0() - uph_adjoin.GetHalfThickness();
  } else {
    zup = uph_adjoin.GetZ0() + uph_adjoin.GetHalfThickness();
    zdn = uph_steel.GetZ0()  - uph_steel.GetHalfThickness();
  }

  double z;
  switch ( pos ) {
  case kUpstream:    z = zup + eps;     break;
  case kMiddle:      z = 0.5*(zup+zdn); break;
  case kDownstream:  z = zup - eps;     break;
  default:
    std::cout << "HEY: pos arg isn't legal " << (int)pos << std::endl;
    z = -9999;
  }

  //std::cout << " planeum " << planenum << " blah, blah  chooose z = " << z << std::endl;

  fidvol_toggle_msglvl(); // restore message levels
  return z;

}

void FidVol::find_z_cuts(int pup_near, int pdn_near,
                         int pup1_far, int pdn1_far,
                         int pup2_far, int pdn2_far,
                         EAirRegion region, EPosition pos, double eps)
{
  VldTimeStamp now;
  VldContext vldc_near_data(Detector::kNear,SimFlag::kData,now);
  VldContext vldc_near_mc(Detector::kNear,SimFlag::kMC,now);
  VldContext vldc_far_data(Detector::kFar,SimFlag::kData,now);
  VldContext vldc_far_mc(Detector::kFar,SimFlag::kMC,now);
  std::cout << "FidVol::find_z_cuts() called" << std::endl;
  double nearZData[2], nearZMC[2];
  double farZData[4],  farZMC[4];

  nearZData[0] = FidVol::infid_z_finder(vldc_near_data,pup_near,region,pos,eps);
  nearZData[1] = FidVol::infid_z_finder(vldc_near_data,pdn_near,region,pos,eps);

  nearZMC[0]   = FidVol::infid_z_finder(vldc_near_mc,pup_near,region,pos,eps);
  nearZMC[1]   = FidVol::infid_z_finder(vldc_near_mc,pdn_near,region,pos,eps);

  farZData[0]  = FidVol::infid_z_finder(vldc_far_data,pup1_far,region,pos,eps);
  farZData[1]  = FidVol::infid_z_finder(vldc_far_data,pdn1_far,region,pos,eps);
  farZData[2]  = FidVol::infid_z_finder(vldc_far_data,pup2_far,region,pos,eps);
  farZData[3]  = FidVol::infid_z_finder(vldc_far_data,pdn2_far,region,pos,eps);

  farZMC[0]    = FidVol::infid_z_finder(vldc_far_mc,pup1_far,region,pos,eps);
  farZMC[1]    = FidVol::infid_z_finder(vldc_far_mc,pdn1_far,region,pos,eps);
  farZMC[2]    = FidVol::infid_z_finder(vldc_far_mc,pup2_far,region,pos,eps);
  farZMC[3]    = FidVol::infid_z_finder(vldc_far_mc,pdn2_far,region,pos,eps);

  // now format it for cut-and-paste purposes
  std::cout << "   // Chosen z is " << FidVol::PositionAsString(pos)
            << " of air gap " << FidVol::AirRegionAsString(region);
  if ( pos != kMiddle && eps != 0)
    std::cout << " eps = " << eps;
  std::cout << std::endl;
  
  std::cout << "   // Near:  relative to steel planes "
            << " [" << pup_near << "," << pdn_near << "]" 
            << std::endl;
  std::cout << "   setNearZData(0," << Form("%8.5f",nearZData[0]) << ");"
            << "   setNearZData(1," << Form("%8.5f",nearZData[1]) << ");"
            << std::endl;
  std::cout << "   setNearZMC(  0," << Form("%8.5f",nearZMC[0]) << ");"
            << "   setNearZMC(  1," << Form("%8.5f",nearZMC[1]) << ");"
            << std::endl;


  std::cout << "   // Far:  relative to steel planes "
            << " [" << pup1_far << "," << pdn1_far << "]" 
            << " [" << pup2_far << "," << pdn2_far << "]" 
            << std::endl;
  std::cout << "   setFarZData(0," << Form("%8.5f",farZData[0]) << "); "
            << "   setFarZData(1," << Form("%8.5f",farZData[1]) << ");"
            << std::endl
            << "   setFarZData(2," << Form("%8.5f",farZData[2]) << "); "
            << "   setFarZData(3," << Form("%8.5f",farZData[3]) << ");"
            << std::endl;
  std::cout << "   setFarZMC(  0," << Form("%8.5f",farZMC[0]) << "); "
            << "   setFarZMC(  1," << Form("%8.5f",farZMC[1]) << ");"
            << std::endl
            << "   setFarZMC(  2," << Form("%8.5f",farZMC[2]) << "); "
            << "   setFarZMC(  3," << Form("%8.5f",farZMC[3]) << ");"
            << std::endl;
}

---