ReleaseType.cxx

Go to the documentation of this file.

// $Id: ReleaseType.cxx,v 1.28 2009/12/18 06:41:43 asousa Exp $
 
// C/C++
#include <cassert>
#include <iomanip>
#include <iostream>
#include <string>
#include <sstream>

#include <TString.h>

#include "MessageService/MsgService.h"
#include "Conventions/ReleaseType.h"

CVSID("$Id: ReleaseType.cxx,v 1.28 2009/12/18 06:41:43 asousa Exp $");

using std::string;


bool ReleaseType::IsData(int type)   { 
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kData);
}

bool ReleaseType::IsMC(int type)     { 
  return  ((type & ReleaseType::DataMCMask) > 0);
}

bool ReleaseType::IsTest(int type)     {
  return  ((type & ReleaseType::RecoTestMask) > 0);
}

//Start of MC Release Identification 

bool ReleaseType::IsAvocado(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kAvocado);
}

bool ReleaseType::IsBeet(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kBeet);
}

bool ReleaseType::IsCarrot(int type) { 
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kCarrot);
}

bool ReleaseType::IsDaikon(int type) { 
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kDaikon);
}

bool ReleaseType::IsEggplant(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kEggplant);
}

bool ReleaseType::IsFava(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kFava);
}

bool ReleaseType::IsGarlic(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kGarlic);
}

bool ReleaseType::IsHops(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kHops);
}

bool ReleaseType::IsIceberg(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kIceberg);
}

bool ReleaseType::IsJicama(int type) {
  return ((type & ReleaseType::DataMCMask) == ReleaseType::kJicama);
}

// End of MC release information

// Start of Reconstruction release type information

bool ReleaseType::IsAsh(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kAsh);
}

bool ReleaseType::IsBirch(int type)  { 
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kBirch);
}

bool ReleaseType::IsCedar(int type)  { 
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kCedar);
}

bool ReleaseType::IsDogwood(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kDogwood);
}

bool ReleaseType::IsElm(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kElm);
}

bool ReleaseType::IsFir(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kFir);
}

bool ReleaseType::IsGinkgo(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kGinkgo);
}

bool ReleaseType::IsHickory(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kHickory);
}

bool ReleaseType::IsIvy(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kIvy);
}

bool ReleaseType::IsJuniper(int type)  {
  return  ((type & ReleaseType::RecoMask) == ReleaseType::kJuniper);
}

// Get Combined Information

ReleaseType::Release_t  ReleaseType::GetRecoInfo(int type){
  return (type & (ReleaseType::RecoMask + ReleaseType::SubRecoMask));
}

ReleaseType::Release_t  ReleaseType::GetMCInfo(int type){
  return (type & (ReleaseType::DataMCMask + ReleaseType::SubMCMask));
}


// Start Of Section dealing with SubSections

int ReleaseType::GetMCSubVersion(int type)
{
   int temp = type & SubMCMask;
   return temp/(SubMCMask/0xF);
}
                                                                                
int ReleaseType::GetRecoSubVersion(int type)
{
   int temp = type & SubRecoMask;
   return temp/(SubRecoMask/0xF);
}

// Provide a string to id things

string ReleaseType::AsString(int type)
{
  string dmc = "unknown";
  string reco = "unknownRel";

  if(ReleaseType::IsMC(type)){
    if(ReleaseType::IsAvocado(type)) dmc = "Avocado";
    else if(ReleaseType::IsBeet(type)) dmc = "Beet";
    else if(ReleaseType::IsCarrot(type)) dmc = "Carrot";
    else if(ReleaseType::IsDaikon(type)) dmc = "Daikon";
    else if(ReleaseType::IsEggplant(type)) dmc = "Eggplant";
    else if(ReleaseType::IsFava(type)) dmc = "Fava";  
    else if(ReleaseType::IsGarlic(type)) dmc = "Garlic";
    else if(ReleaseType::IsHops(type)) dmc = "Hops";
    else if(ReleaseType::IsIceberg(type)) dmc = "Iceberg";
    else if(ReleaseType::IsJicama(type)) dmc = "Jicama";
    else dmc = "unknown MC";
   
    dmc += GetVersionString(ReleaseType::GetMCSubVersion(type));
  }else{
    dmc = "Data";
  }

  if(ReleaseType::IsAsh(type)) reco = "Ash";
  if(ReleaseType::IsBirch(type)) reco = "Birch";
  if(ReleaseType::IsCedar(type)){
     if(ReleaseType::GetRecoInfo(type) == ReleaseType::kCedarPhy ||
         ReleaseType::GetRecoInfo(type) == ReleaseType::kR1_24_3 )
        reco = "CedarPhy";
     else  reco = "Cedar";
  }
  if(ReleaseType::IsDogwood(type)) {
    if(ReleaseType::GetRecoInfo(type) == ReleaseType::kDogwood1 ||
       ReleaseType::GetRecoInfo(type) == ReleaseType::kR2_0_1 )
      reco = "Dogwood";
    else if(ReleaseType::GetRecoInfo(type) == ReleaseType::kDogwood2 ||
            ReleaseType::GetRecoInfo(type) == ReleaseType::kR2_0_2 )
      reco = "Dogwood";
    else if(ReleaseType::GetRecoInfo(type) == ReleaseType::kDogwood3 ||
            ReleaseType::GetRecoInfo(type) == ReleaseType::kR2_0_3 )
      reco = "Dogwood";
    else reco = "Dogwood";    
  }
  if(ReleaseType::IsElm(type)) reco = "Elm";
  if(ReleaseType::IsFir(type)) reco = "Fir";
  if(ReleaseType::IsGinkgo(type)) reco = "Ginkgo";
  if(ReleaseType::IsHickory(type)) reco = "Hickory";
  if(ReleaseType::IsIvy(type)) reco = "Ivy";
  if(ReleaseType::IsJuniper(type)) reco = "Juniper";

  if(ReleaseType::IsTest(type)) reco += "Test";
  reco += GetVersionString(ReleaseType::GetRecoSubVersion(type));

  string name = reco + " " + dmc;

  return name;
}                             

std::string ReleaseType::GetVersionString(int val)
{
   char dum[4];
   sprintf(dum, "V%02d", val);
   std::string temp = dum;
   return temp;
}

//Convert strings back to a Release_t
ReleaseType::Release_t ReleaseType::StringToType(const char* nameChar){
  string name(nameChar);
  Release_t type = 0x00;

  string dmc = name.substr(1+name.find(" "));
  if(dmc.find("Data") != string::npos) type += kData;

  // Now could just check the first letter if speed is an issue.
  else if(dmc.find("Avocado") != string::npos ) type += kAvocado;
  else if(dmc.find("Beet") != string::npos) type += kBeet;
  else if(dmc.find("Carrot") != string::npos) type += kCarrot;
  else if(dmc.find("Daikon") != string::npos) type += kDaikon;
  else if(dmc.find("Eggplant") != string::npos) type += kEggplant;
  else if(dmc.find("Fava") != string::npos) type += kFava;
  else if(dmc.find("Garlic") != string::npos) type += kGarlic;
  else if(dmc.find("Hops") != string::npos) type += kHops;
  else if(dmc.find("Iceberg") != string::npos) type += kIceberg;
  else if(dmc.find("Jicama") != string::npos) type += kJicama;
  // No good way to treat "unknown MC"; leave it as "kUnknown"
  else type = kUnknown;

  string dmcver = dmc.substr(1 + dmc.find_last_of("V"));
  if(dmcver.find("00") != string::npos) type += k00;  
  else if(dmcver.find("01") != string::npos) type += k01;
  else if(dmcver.find("02") != string::npos) type += k02;
  else if(dmcver.find("03") != string::npos) type += k03;
  else if(dmcver.find("04") != string::npos) type += k04; 
  else if(dmcver.find("05") != string::npos) type += k05;
  else if(dmcver.find("06") != string::npos) type += k06;
  else if(dmcver.find("07") != string::npos) type += k07;
  else if(dmcver.find("08") != string::npos) type += k08;
  else if(dmcver.find("09") != string::npos) type += k09;
  else if(dmcver.find("10") != string::npos) type += k10;
  else type += k00;

  string reco = name.substr(0, name.find(" "));
  if( type != kUnknown ){
    if (reco.find("Ash") != string::npos) type += kAsh;
    else if (reco.find("Birch") != string::npos) type += kBirch;
    else if (reco.find("Cedar") != string::npos){
      if(reco.find("CedarPhy") != string::npos) type += kCedar;
      else if(reco.find("Cedar_Phy") != string::npos) type += kCedar;
      else type += kCedar;
    }else if (reco.find("Dogwood") != string::npos){ 
      if(reco.find("Dogwood0") != string::npos) type += kDogwood;
      else if(reco.find("Dogwood1") != string::npos) type += kDogwood;
      else if(reco.find("Dogwood2") != string::npos) type += kDogwood;
      else if(reco.find("Dogwood3") != string::npos) type += kDogwood;
      type += kDogwood;
    }else if (reco.find("Elm") != string::npos) type += kElm;
    else if (reco.find("Fir") != string::npos) type += kFir;
    else if (reco.find("Ginkgo") != string::npos) type += kGinkgo;
    else if (reco.find("Hickory") != string::npos) type += kHickory;
    else if (reco.find("Ivy") != string::npos) type += kIvy;
    else if (reco.find("Juniper") != string::npos) type += kJuniper;

    if(name.find("Test")  != string::npos) type += kTest;

    // Unknown reconstruction is possible; just leave that bit 0.

    string rver = reco.substr(1 + reco.find_last_of("V"));
    if(rver.find("00") != string::npos) type += kR00;
    else if(rver.find("01") != string::npos) type += kR01;
    else if(rver.find("02") != string::npos) type += kR02;
    else if(rver.find("03") != string::npos) type += kR03;
    else if(rver.find("04") != string::npos) type += kR04;
    else if(rver.find("05") != string::npos) type += kR05;
    else if(rver.find("06") != string::npos) type += kR06;
    else if(rver.find("07") != string::npos) type += kR07;
    else if(rver.find("08") != string::npos) type += kR08;
    else if(rver.find("09") != string::npos) type += kR09;
    else if(rver.find("10") != string::npos) type += kR10;
    else type += kR00;
  }  // if (a known dmc type)
  
  return type;
}

ReleaseType::Release_t ReleaseType::MakeReleaseType(std::string fTitle, std::string mcinfo)
//Warning: Deprecated from R1.28 on, meaning should not be used for
//Dogwood and more modern releases.

//  string relName = NtpStRecord->GetTitle();
//  string mcinfo =  NtpStRecord->mchdr.geninfo.codename;
/*
    Suggested Usage with NtpStRecord str;

    string relName = str->GetTitle();
    string mcinfo = "";
    if(vc.GetSimFlag() == SimFlag::kMC){
       mcinfo = "Carrot";
       string temp = str->mchdr.geninfo.codename;
       if(temp.size() != 0){   mcinfo = temp;  }
    }
    release = ReleaseType::MakeReleaseType(relName, mcinfo);
*/
{
   string relName = fTitle;
   string reco = relName.substr(0,relName.find_first_of("("));
   ReleaseType::Release_t release = ReleaseType::kUnknown;

   //Setting for dealing with Cedar and Cedar Variants
   if(strstr(reco.c_str(), "CEDAR") != 0 || 
       strstr(reco.c_str(), "CHERRY") != 0 ){

      if(reco == "CEDAR"){
         release = ReleaseType::kCedar;   //Fine for Data or Carrot
         string temp = relName.substr(22,1);
         if(temp == "1") release = ReleaseType::kR1_24_1;
      }

      if(reco == "CEDAR_PHY"){
         release = ReleaseType::kCedarPhy;
         if(strstr(fTitle.c_str(), "Daikon") != 0)   release = ReleaseType::kR1_24_2;

         std::string software = relName.substr(relName.find_first_of(":")+1,
               relName.find_first_of(",") - relName.find_first_of(":") - 1);

         if(software == "R1.24.2") release = ReleaseType::kR1_24_2;
         if(software == "R1.24.3") release = ReleaseType::kR1_24_3;

      }

      if(reco == "CHERRY") release = ReleaseType::kR1_24_Cal;
   }
   else release = ReleaseType::kBirch;


   //Setting Data/MC version
   if(mcinfo.size() > 0){
     if(strstr(mcinfo.c_str(), "daikon") != 0)
        release += ReleaseType::kDaikon;
     else
        release += ReleaseType::kCarrot;
                                                                                
     if(strstr(mcinfo.c_str(), "00") != 0) release += ReleaseType::k00;
     if(strstr(mcinfo.c_str(), "01") != 0) release += ReleaseType::k01;
     if(strstr(mcinfo.c_str(), "02") != 0) release += ReleaseType::k02;
     if(strstr(mcinfo.c_str(), "03") != 0) release += ReleaseType::k03;
     if(strstr(mcinfo.c_str(), "04") != 0) release += ReleaseType::k04;
     if(strstr(mcinfo.c_str(), "05") != 0) release += ReleaseType::k05;
     if(strstr(mcinfo.c_str(), "06") != 0) release += ReleaseType::k06;
     if(strstr(mcinfo.c_str(), "07") != 0) release += ReleaseType::k07;
     if(strstr(mcinfo.c_str(), "08") != 0) release += ReleaseType::k08;
     if(strstr(mcinfo.c_str(), "09") != 0) release += ReleaseType::k09;
   }
   else
     release += ReleaseType::kData;
 
  return release;
}

//-------------------------------------------------------------------------------------------
const std::pair<std::string, std::string> ReleaseType::AsBatchString(const int type)
{
   //
   // Return pair of strings: 
   //    1st element is reconstruction release name as used for pnfs file storage
   //    2nd element is Monte-Carlo release name as used for pnfs file storage
   //

  string dmc = "unknown_mc";
  string reco = "unknown_reco";

  if(ReleaseType::IsMC(type))
  {
     if(ReleaseType::IsAvocado(type))       dmc = "avocado";
     else if(ReleaseType::IsBeet(type))     dmc = "beet";
     else if(ReleaseType::IsCarrot(type))   dmc = "carrot";
     else if(ReleaseType::IsDaikon(type))   dmc = "daikon";
     else if(ReleaseType::IsEggplant(type)) dmc = "eggplant";
     else if(ReleaseType::IsFava(type))     dmc = "fava";  
     else if(ReleaseType::IsGarlic(type))   dmc = "garlic";
     else if(ReleaseType::IsHops(type))     dmc = "hops";
     else if(ReleaseType::IsIceberg(type))  dmc = "iceberg";
     else if(ReleaseType::IsJicama(type))   dmc = "jicama";

     if(ReleaseType::GetMCSubVersion(type) < 0 || ReleaseType::GetMCSubVersion(type) > 99)
     {
        std::cerr << "ReleaseType::AsBatchString - bad Monte-Carlo version: " 
                  << ReleaseType::GetMCSubVersion(type) << std::endl;
     }
     else
     {
        std::stringstream mver;
        mver << std::setw(2) << std::setfill('0') << ReleaseType::GetMCSubVersion(type);
        dmc = dmc + "_" + mver.str();
     }     
  }
  else
  {
     dmc = "data";
  }
  
  if(ReleaseType::IsAsh(type)) reco = "ash";
  if(ReleaseType::IsBirch(type)) reco = "birch";
  if(ReleaseType::IsCedar(type))
  {
     if(ReleaseType::GetRecoSubVersion(type) == 0)
     {
        reco = "cedar";
     }
     else if(ReleaseType::GetRecoSubVersion(type) == 1)
     {
        reco = "cedar";
     }
     else if(ReleaseType::GetRecoSubVersion(type) == 2)
     {
        reco = "cedar_phy";
     }
     else if(ReleaseType::GetRecoSubVersion(type) == 3)
     {
        reco = "cedar_phy_bhcurv";
     }
     else
     {
        std::cerr << "ReleaseType::AsBatchString - bad cedar reconstuction version: "
                  << ReleaseType::GetRecoSubVersion(type) << std::endl; 
     }
  }
  if(ReleaseType::IsDogwood(type))
  {
    if(ReleaseType::GetRecoSubVersion(type) == 0)
      {
        reco = "dogwood0";
      }
    else if(ReleaseType::GetRecoSubVersion(type) == 1)
      {
        reco = "dogwood1";
      }
    else if(ReleaseType::GetRecoSubVersion(type) == 2)
      {
        reco = "dogwood2";
      }
    else if(ReleaseType::GetRecoSubVersion(type) == 3)
      {
        reco = "dogwood3";
      }
    else
      {
        std::cerr << "ReleaseType::AsBatchString - bad dogwood reconstuction version: "
                  << ReleaseType::GetRecoSubVersion(type) << std::endl; 
      }
  }
  if(ReleaseType::IsElm(type)) reco = "elm";
  if(ReleaseType::IsFir(type)) reco = "fir";
  if(ReleaseType::IsGinkgo(type)) reco = "ginkgo";
  if(ReleaseType::IsHickory(type)) reco = "hickory";
  if(ReleaseType::IsIvy(type)) reco = "ivy";
  if(ReleaseType::IsJuniper(type)) reco = "juniper";
 
  if(ReleaseType::IsTest(type)) reco += "test";

  return std::pair<std::string, std::string>(dmc, reco);
}

//_____________________________________________________________________________
ReleaseType::Release_t ReleaseType::GetRecoRelease(
                                          const char* recoreleasename) {
  // Purpose: Convert text string recoreleasename to an ERecoRelease.
  // Returns kUnknown if unknown.
  ReleaseType::Release_t result = kUnknown;

  TString tmpstr(recoreleasename);
  tmpstr.ToLower();
  if ( strstr(tmpstr.Data(),"ash") != 0 )  result = kAsh;
  else if ( strstr(tmpstr.Data(),"birch") != 0 ) result = kBirch;
  else if ( strstr(tmpstr.Data(),"cedar") != 0 ) result = kCedar;
  else if ( strstr(tmpstr.Data(),"dogwood") != 0 ) result = kDogwood;
  else if ( strstr(tmpstr.Data(),"elm") != 0 ) result = kElm;
  else if ( strstr(tmpstr.Data(),"fir") != 0 ) result = kFir;
  else if ( strstr(tmpstr.Data(),"ginkgo") != 0 ) result = kGinkgo;
  else if ( strstr(tmpstr.Data(),"hickory") != 0 ) result = kHickory;
  else if ( strstr(tmpstr.Data(),"ivy") != 0 ) result = kIvy;
  else if ( strstr(tmpstr.Data(),"juniper") != 0 ) result = kJuniper;

  if(result == kUnknown) return result;
  
  if(strstr(tmpstr.Data(),"test") != 0) result |= kTest;

  return result;
}

//_____________________________________________________________________________
const char* ReleaseType::AsString(ReleaseType::ERecoRelease recorelease){
  // Purpose: Convert enumerated recorelease to string
  
  switch ( recorelease ) {

  case kAsh:      return "Ash";
  case kBirch:    return "Birch";
  case kCedar:    return "Cedar";
  case kDogwood:  return "Dogwood";
  case kElm:      return "Elm";
  case kFir:      return "Fir";
  case kGinkgo:   return "Ginkgo";
  case kHickory:  return "Hickory";
  case kIvy:      return "Ivy";
  case kJuniper:  return "Juniper";
  default:
    MSG("Conv",Msg::kError) << "ReleaseType::AsString for unknown "
                            << "ERecoRelease " << recorelease 
                            << ". Fix method. Abort." << endl;
    abort();
  }
  
}

//_____________________________________________________________________________
ReleaseType::Release_t ReleaseType::GetSubRecoRelease(
                                        const char* subrecoreleasename) {
  // Purpose: Search for substring in subrecoreleasename corresponding to
  //          an ESubRecoRelease code.  Returns kUnknown if no match.

  TString tmpstr(subrecoreleasename);
  tmpstr.ToLower();
  if ( strstr(tmpstr.Data(),"00") != 0 ) return kR00;
  else if ( strstr(tmpstr.Data(),"01") != 0 ) return kR01;
  else if ( strstr(tmpstr.Data(),"02") != 0 ) return kR02;
  else if ( strstr(tmpstr.Data(),"03") != 0 ) return kR03;
  else if ( strstr(tmpstr.Data(),"04") != 0 ) return kR04;
  else if ( strstr(tmpstr.Data(),"05") != 0 ) return kR05;
  else if ( strstr(tmpstr.Data(),"06") != 0 ) return kR06;
  else if ( strstr(tmpstr.Data(),"07") != 0 ) return kR07;
  else if ( strstr(tmpstr.Data(),"08") != 0 ) return kR08;
  else if ( strstr(tmpstr.Data(),"09") != 0 ) return kR09;
  else if ( strstr(tmpstr.Data(),"10") != 0 ) return kR10;
  return kUnknown;
  
}

//_____________________________________________________________________________
const char* ReleaseType::AsString(ReleaseType::ESubRecoRelease subrecorelease){
  // Purpose: Convert enumerated subrecorelease to string
  
  switch ( subrecorelease ) {

  case kR00:    return "00";
  case kR01:    return "01";
  case kR02:    return "02";
  case kR03:    return "03";
  case kR04:    return "04";
  case kR05:    return "05";
  case kR06:    return "06";
  case kR07:    return "07";
  case kR08:    return "08";
  case kR09:    return "09";
  case kR10:    return "10";
  default:
    MSG("Conv",Msg::kError) << "ReleaseType::AsString for unknown "
                            << "ESubRecoRelease " << subrecorelease 
                            << ". Fix method. Abort." << endl;
    abort();
  }
  
}

//_____________________________________________________________________________
ReleaseType::Release_t ReleaseType::GetDataMCRelease(
                                           const char* datamcreleasename) {
  // Purpose: Search for substring in datamcreleasename corresponding to
  //          an EDataMCRelease.  Returns EDataMCRelease if found, else
  //          kUnknown.

  TString tmpstr(datamcreleasename);
  tmpstr.ToLower();
  if ( strstr(tmpstr.Data(),"data") != 0 ) return kData;
  else if ( strstr(tmpstr.Data(),"avocado") != 0 ) return kAvocado;
  else if ( strstr(tmpstr.Data(),"beet") != 0 ) return kBeet;
  else if ( strstr(tmpstr.Data(),"carrot") != 0 ) return kCarrot;
  else if ( strstr(tmpstr.Data(),"daikon") != 0 ) return kDaikon;
  else if ( strstr(tmpstr.Data(),"eggplant") != 0 ) return kEggplant;
  else if ( strstr(tmpstr.Data(),"fava") != 0 ) return kFava;
  else if ( strstr(tmpstr.Data(),"garlic") != 0 ) return kGarlic;
  else if ( strstr(tmpstr.Data(),"hops") != 0 ) return kHops;
  else if ( strstr(tmpstr.Data(),"iceberg") != 0 ) return kIceberg;
  else if ( strstr(tmpstr.Data(),"jicama") != 0 ) return kJicama;
  return kUnknown;
  
}


//_____________________________________________________________________________
const char* ReleaseType::AsString(ReleaseType::EDataMCRelease datamcrelease) {
  // Purpose: Convert enumerated datamcrelease to string
  
  switch ( datamcrelease ) {

  case kData:       return "Data";
  case kAvocado:    return "Avocado";
  case kBeet:       return "Beet";
  case kCarrot:     return "Carrot";
  case kDaikon:     return "Daikon";
  case kEggplant:   return "Eggplant";
  case kFava:       return "Fava";
  case kGarlic:     return "Garlic";
  case kHops:       return "Hops";
  case kIceberg:    return "Iceberg";
  case kJicama:     return "Jicama";
  default:
    MSG("Conv",Msg::kError) << "ReleaseType::AsString for unknown "
                            << "EDataMCRelease " << datamcrelease 
                            << ". Fix method. Abort." << endl;
    abort();
  }
  
}

//_____________________________________________________________________________
ReleaseType::Release_t ReleaseType::GetSubMCRelease(
                                          const char* submcreleasename) {
  // Purpose: Search for substring in submcreleasename corresponding to
  //          an ESubMCRelease.  Returns matching ESubMCRelease if found,
  //          else kUnknown if no match.

  TString tmpstr(submcreleasename);
  tmpstr.ToLower();
  if ( strstr(tmpstr.Data(),"00") != 0 ) return k00;
  else if ( strstr(tmpstr.Data(),"01") != 0 ) return k01;
  else if ( strstr(tmpstr.Data(),"02") != 0 ) return k02;
  else if ( strstr(tmpstr.Data(),"03") != 0 ) return k03;
  else if ( strstr(tmpstr.Data(),"04") != 0 ) return k04;
  else if ( strstr(tmpstr.Data(),"05") != 0 ) return k05;
  else if ( strstr(tmpstr.Data(),"06") != 0 ) return k06;
  else if ( strstr(tmpstr.Data(),"07") != 0 ) return k07;
  else if ( strstr(tmpstr.Data(),"08") != 0 ) return k08;
  else if ( strstr(tmpstr.Data(),"09") != 0 ) return k09;
  else if ( strstr(tmpstr.Data(),"10") != 0 ) return k10;
  return kUnknown;
  
}

//_____________________________________________________________________________
const char* ReleaseType::AsString(ReleaseType::ESubMCRelease submcrelease) {
  // Purpose: Convert enumerated submcrelease to string
  
  switch ( submcrelease ) {

  case k00:    return "00";
  case k01:    return "01";
  case k02:    return "02";
  case k03:    return "03";
  case k04:    return "04";
  case k05:    return "05";
  case k06:    return "06";
  case k07:    return "07";
  case k08:    return "08";
  case k09:    return "09";
  case k10:    return "10";
  default:
    MSG("Conv",Msg::kError) << "ReleaseType::AsString for unknown "
                            << "ESubMCRelease " << submcrelease 
                            << ". Fix method. Abort." << endl;
    abort();
  }
  
}

//_____________________________________________________________________________
ReleaseType::Release_t ReleaseType::GetTestFlag(const char* testflagname)
{
  // Purpose: Search for substring in testflagname corresponding to
  //          an ETestFlag.  Returns matching ETestFlag if found, else
  //          ETestFlag::kStandard.

  TString tmpstr(testflagname);
  tmpstr.ToLower();
  if ( strstr(tmpstr.Data(),"test") != 0 ) return kTest;
  return kStandard; // default

}

//_____________________________________________________________________________
const char* ReleaseType::AsString(ReleaseType::ETestFlag testflag)
{
  switch ( testflag) {
  case kStandard:    return "";
  case kTest:        return "test";
  default:
    MSG("Conv",Msg::kError) << "ReleaseType::AsString for unknown "
                            << "ETestFlag " << testflag
                            << ". Fix method. Abort." << endl;
    abort();
  }
}

//_____________________________________________________________________________
ReleaseType::Release_t ReleaseType::GetProductionRelease(
                                          const char* prodreleasename) {
  // Purpose: Convert text string prodreleasename to release type.
  // Returns kUnknown if unknown.
  // If prodreleasename is from reco batch production, 
  // e.g. "dogwood2" or "dogwoodtest0", returns ReleaseType as combination of 
  // ERecoRelease, ESubReco, and ETestFlag.
  // If prodreleasename is from MC production, e.g. Daikon_00, returns
  // ReleaseType as combination of EDataMCRelease and ESubMCRelease.

  ReleaseType::Release_t result = kUnknown;
                                                            
  result = ReleaseType::GetRecoRelease(prodreleasename);
  
  if ( result != kUnknown ) {
    // Batch production. Add test flag.
    result |= ReleaseType::GetTestFlag(prodreleasename);
    // Add version
    std::string tmpstr = std::string(prodreleasename);
    //  char version = tmpstr[tmpstr.size()-1];
    char ver[2];  sprintf(ver, "0%c", tmpstr[tmpstr.size()-1]);
    ReleaseType::Release_t subver = ReleaseType::GetSubRecoRelease(ver);
    if ( subver != kUnknown ) result |= subver;
  }
  else {
    result = ReleaseType::GetDataMCRelease(prodreleasename);
    if ( result != kUnknown ) {
      // MC production.  Add version.
      ReleaseType::Release_t subver 
                              = ReleaseType::GetSubMCRelease(prodreleasename);
      if ( subver != kUnknown ) result |= subver;
    }
  }
  
  return result;
}

---