MasterGeVPerMip.cxx

Go to the documentation of this file.

#include "DataUtil/MasterGeVPerMip.h"

#include <cassert>
#include <iostream>
#include <iomanip>
using namespace std;

#include "TString.h"  // for ToLower() function

// nasty bit:  make "RT" synonym for "ReleaseType"
namespace RT = ReleaseType;

// one-and-only instance
MasterGeVPerMip* MasterGeVPerMip::fMyInstance = 0;

// syntactic sugar-coated interfaces
double get_gevpermip(Detector::Detector_t det)
{ return MasterGeVPerMip::Instance().Get(det); }

void choose_gevpermip_release(std::string setname)
{ MasterGeVPerMip::Instance().SelectSet(setname); }

void choose_gevpermip_release(ReleaseType::Release_t rt)
{ MasterGeVPerMip::Instance().SelectSet(rt); }

void new_gevpermip_release(std::string setname,
                           double nearval, double farval, double caldetval)
{ MasterGeVPerMip::Instance().AddSet(setname,nearval,farval,caldetval); }

void new_gevpermip_release(ReleaseType::Release_t rt,
                           double nearval, double farval, double caldetval)
{ MasterGeVPerMip::Instance().AddSet(rt,nearval,farval,caldetval); }

void print_gevpermip(Option_t* opt)
{ MasterGeVPerMip::Instance().Print(opt); }

bool   gevpermip_release_exists(std::string setname)
{ return MasterGeVPerMip::Instance().SetExists(setname); }

bool   gevpermip_release_exists(ReleaseType::Release_t rt)
{ return MasterGeVPerMip::Instance().SetExists(rt); }

//_____________________________________________________________________________

MasterGeVPerMip::MasterGeVPerMip()
{ 
  // ctor

  fQuiet  = false;  // by default don't be quiet about set selection misses
  fAssert = true;   // by default assert when miss set selection
  cout << "MasterGeVPerMip creation:" << endl;

  string setname;
  // Initial set of sets ...
  //           name                           NearDet   FarDet    CalDet
  // "default" is only to be used by those you don't care about the real GeVPerMip
  // In principle the "default" value represents the most recent version
  // The CalDet GevPerMip number is currenlty incorrect and set to zero
  AddSet("default"                         , 0.001775, 0.001790, 0.000000);
  // NOTICE: the following depends on "namespace RT = ReleaseType;" above!


  //Dogwood7 GevPerMip number based on Daikon MC
  AddSet(RT::kDogwood7 +RT::kDaikon+RT::k04, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood7 +RT::kDaikon+RT::k07, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood7 +RT::kDaikon+RT::k08, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood7 +RT::kDaikon+RT::k09, 0.001777, 0.001793, 0.000000);


  //Dogwood6 GevPerMip number based on Daikon MC - do we ever need dogwood6 for MC??? - this is an overkill, I know.
  AddSet(RT::kDogwood6 +RT::kDaikon+RT::k04, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood6 +RT::kDaikon+RT::k07, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood6 +RT::kDaikon+RT::k08, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood6 +RT::kDaikon+RT::k09, 0.001777, 0.001793, 0.000000);

  //Dogwood5 GevPerMip number based on Daikon MC
  AddSet(RT::kDogwood5 +RT::kDaikon+RT::k04, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood5 +RT::kDaikon+RT::k07, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood5 +RT::kDaikon+RT::k08, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood5 +RT::kDaikon+RT::k09, 0.001777, 0.001793, 0.000000);

  //Dogwood4 GevPerMip number based on Daikon MC
  AddSet(RT::kDogwood4 +RT::kDaikon+RT::k04, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood4 +RT::kDaikon+RT::k07, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood4 +RT::kDaikon+RT::k08, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood4 +RT::kDaikon+RT::k09, 0.001777, 0.001793, 0.000000);

  //Dogwood3 GevPerMip number based on Daikon MC
  AddSet(RT::kDogwood3 +RT::kDaikon+RT::k04, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood3 +RT::kDaikon+RT::k07, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood3 +RT::kDaikon+RT::k08, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood3 +RT::kDaikon+RT::k09, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood3 +RT::kGarlic+RT::k00, 0.001777, 0.001793, 0.000000);

  //Dogwood2 GevPerMip number based on Daikon MC
  AddSet(RT::kDogwood2 +RT::kDaikon+RT::k04, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood2 +RT::kDaikon+RT::k07, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood2 +RT::kGarlic+RT::k00, 0.001777, 0.001793, 0.000000);

  //Dogwood1 GevPerMip number based on Daikon MC
  AddSet(RT::kDogwood1 +RT::kDaikon+RT::k04, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood1 +RT::kDaikon+RT::k07, 0.001777, 0.001793, 0.000000);
  AddSet(RT::kDogwood1 +RT::kGarlic+RT::k00, 0.001777, 0.001793, 0.000000);
  
  // Best Guess of Dogwood GeVPerMip number based on Cedar_Phy Daikon03
  AddSet("predogwood"                      , 0.001789, 0.001790, 0.000000);
  AddSet("dogwood"                         , 0.001775, 0.001790, 0.000000);
  AddSet(RT::kDogwood  +RT::kDaikon+RT::k04, 0.001775, 0.001790, 0.000000);
  AddSet(RT::kDogwood  +RT::kGarlic+RT::k00, 0.001775, 0.001790, 0.000000);

  // All versions of cedar_phy have the same GeVPerMip number
  AddSet("cedar_phy"                       , 0.001792, 0.001786, 0.000000);
  AddSet(RT::kCedar_Phy+RT::kDaikon+RT::k00, 0.001792, 0.001786, 0.000000);
  AddSet(RT::kCedar_Phy+RT::kDaikon+RT::k01, 0.001792, 0.001786, 0.000000);
  AddSet(RT::kCedar_Phy+RT::kDaikon+RT::k02, 0.001792, 0.001786, 0.000000);
  AddSet(RT::kCedar_Phy+RT::kDaikon+RT::k03, 0.001792, 0.001786, 0.000000);
  AddSet(RT::kCedar_Phy+RT::kDaikon+RT::k04, 0.001792, 0.001786, 0.000000);
  //calB
  AddSet("r1_24_calb"                      , 0.001759, 0.001747, 0.000000);
  //cedar
  AddSet("cedar"                           , 0.001759, 0.001737, 0.000000);

  // pick initial default set
  SelectSet();
}

//_____________________________________________________________________________

MasterGeVPerMip::~MasterGeVPerMip() 
{
  // dtor prints final status
  cout << "MasterGeVPerMip final state:" << endl;
  Print();
  cout << endl;
}

//_____________________________________________________________________________

MasterGeVPerMip& MasterGeVPerMip::Instance()
{
  static Cleaner cleaner;  // cleaner dtor calls MasterGevPerMip dtor
  if ( ! fMyInstance ) {
    fMyInstance = new MasterGeVPerMip;
    cleaner.UseMe();
  }
  return *fMyInstance;
}

//_____________________________________________________________________________

void MasterGeVPerMip::AddSet(ReleaseType::Release_t rt, double nearval, 
                                  double farval, double caldetval)
{ AddSet(ReleaseType::AsString(rt),nearval,farval,caldetval); }

void MasterGeVPerMip::AddSet(string setname, double nearval, 
                                  double farval, double caldetval)
{
  // add a new set of values
  // does NOT change current set

  // do everything lower case, no leading/trailing blanks
  string usrreq = TrimOption(setname);
  if (usrreq == "") usrreq = "default";

  string current = fSetName;
  
  map<string,int>::iterator itr = fSetIndexMap.find(usrreq);
  if ( itr != fSetIndexMap.end() ) {
    // already exists
    fSetName  = itr->first;
    fSetIndex = itr->second;
    // if it's not tagged as "-modified" don't allow it
    if ( fSetName.find("-modified") == string::npos) {
      cout << "FATAL: MasterGevPerMip::AddSet already had a \""
           << fSetName << "\", assert(0)." << endl;
      assert(0);
    }
  } else {
    fSetName  = usrreq;
    fSetIndex = fSetIndexMap.size(); // currently nothing -> index=0, 1 -> 2
    fSetIndexMap[usrreq] = fSetIndex;
    fBestValueNear.resize(fSetIndex+1);
    fBestValueFar.resize(fSetIndex+1);
    fBestValueCalDet.resize(fSetIndex+1);
  }
  fBestValueNear[fSetIndex]   = nearval;
  fBestValueFar[fSetIndex]    = farval;
  fBestValueCalDet[fSetIndex] = caldetval;

  // restore initial state
  fQuiet = true;
  SelectSet(current);
  fQuiet = false;
}

//_____________________________________________________________________________

bool MasterGeVPerMip::SetExists(ReleaseType::Release_t rt) const
{ return SetExists(ReleaseType::AsString(rt)); }
bool MasterGeVPerMip::SetExists(std::string setname) const
{
  // do everything lower case, no leading/trailing blanks
  string usrreq = TrimOption(setname);
  if (usrreq == "") usrreq = "default";

  map<string,int>::const_iterator itr = fSetIndexMap.find(usrreq);
  if ( itr != fSetIndexMap.end() ) {
    // already exists
    return true;
  }
  return false;
}

//_____________________________________________________________________________

double MasterGeVPerMip::Get(Detector::Detector_t det) const
{ 
  // assume fSetIndex in a fine state ...
  switch (det) {
  case Detector::kNear:    return fBestValueNear[fSetIndex];
  case Detector::kFar:     return fBestValueFar[fSetIndex];
  case Detector::kCalDet:  return fBestValueCalDet[fSetIndex];
  default:
    return 0;
  }
}

//_____________________________________________________________________________

void MasterGeVPerMip::Print(string option) const
{
  string opt = TrimOption(option);
  if ( opt == "compact" ) {
    // default is current set
    cout << "MasterGeVPerMip: (\"" << setiosflags(ios::left)
      //<< setw(24) 
         << fSetName 
         << resetiosflags(ios::adjustfield) << "\")";
    cout << " Near " << Get(Detector::kNear) << ",";
    cout << " Far " << Get(Detector::kFar) << ",";
    cout << " CalDet " << Get(Detector::kCalDet) << endl;
    return;
  }

  ios_base::fmtflags orig_fmt = cout.flags();
  map<string,int>::const_iterator itr = fSetIndexMap.begin();
  cout << "MasterGeVPerMip: name          index"
       << "   Near      "
       << "   Far       "
       << "   CalDet    "
       << endl;
  while ( itr != fSetIndexMap.end() ) {
    bool iscurrent = ( itr->first == fSetName );
    if ( iscurrent || opt == "all" ) {
      int indx = itr->second;
      if ( iscurrent ) cout << " -> " ;
      else             cout << "    " ;
      cout<< "\"" << setiosflags(ios::left)
           << setw(24) << itr->first 
           << resetiosflags(ios::adjustfield) << "\" ";
      cout << "(" << setw(3) << indx << ")";
      cout << setprecision(8) << fixed;
      cout << " " << setw(12) << fBestValueNear[indx]
           << " " << setw(12) << fBestValueFar[indx]
           << " " << setw(12) << fBestValueCalDet[indx]
           << endl;
      cout.flags(orig_fmt);
    }
    itr++;  // move along
  }
}

//_____________________________________________________________________________

void MasterGeVPerMip::SelectSet(ReleaseType::Release_t rt)
{ SelectSet(ReleaseType::AsString(rt)); }

void MasterGeVPerMip::SelectSet(string setname)
{  
  // do everything lower case, no leading/trailing blanks
  string usrreq = TrimOption(setname);
  if (usrreq == "") usrreq = "default";
  
  map<string,int>::iterator itr = fSetIndexMap.find(usrreq);
  if ( itr != fSetIndexMap.end() ) {
    fSetName  = itr->first;
    fSetIndex = itr->second;
  } else {
    if ( ! fQuiet ) {
      cout 
        << "WARNING: MasterGeVPerMip::SelectSet could not find " 
        << "\"" << usrreq << "\"";
      if ( fAssert ) {
        cout << ", assert(0)!" << endl;
        assert(0);
      } else {
        cout << ", continue using:" << endl;
      }
    } // ! fQuiet
  }
  if ( ! fQuiet ) Print();
}

//_____________________________________________________________________________

void MasterGeVPerMip::SetValue(Detector::Detector_t det, double value)
{ 
  string modsetname = fSetName;
  if ( modsetname.find("-modified") == string::npos) modsetname += "-modified";

  cout << "MasterGeVPerMip: "
            << "SetValue(" << Detector::AsString(det) << "," << value << ")" 
            << " on \"" << modsetname << "\"" << endl;

  fQuiet = true;  // don't complain if not found
  SelectSet(modsetname); // if not found leaves thing unchanged

  if ( fSetName != modsetname ) {
    // make a modified entry, so one can restore/revert to unmodified set
    double nearval   = Get(Detector::kNear);
    double farval    = Get(Detector::kFar);
    double caldetval = Get(Detector::kCalDet);
    AddSet(modsetname,nearval,farval,caldetval);
    SelectSet(modsetname);
  }

  switch (det) {
  case Detector::kNear:   fBestValueNear[fSetIndex]   = value; break;
  case Detector::kFar:    fBestValueFar[fSetIndex]    = value; break;
  case Detector::kCalDet: fBestValueCalDet[fSetIndex] = value; break;
  default:
    cout << "MasterGeVPerMip doesn't handle Detector::k"
              << Detector::AsString(det) << " (" << int(det) 
              << ")" << endl;
    break;
  }
  fQuiet = false; // restore complaints about unknown sets 
  Print();
}

//_____________________________________________________________________________

string MasterGeVPerMip::TrimOption(string opt)
{ 
  // convert to lowercase, strip leading/trailing spaces
  TString ts = ToLower(opt).Strip(TString::kBoth);
  // change change multiple spaces to single space
  while ( ts.Index("  ") != Ssiz_t(-1) )
    ts = ts.ReplaceAll("  "," ");
  // convert to STL string
  string s = ts.Data();
  return s;
}

//_____________________________________________________________________________

---