Structs.cxx

Go to the documentation of this file.

//
//  Structs.cxx
//  novasoft-mrb
//
//  Created by Brian Rebel on 5/21/16.
//  Copyright © 2016 Brian Rebel. All rights reserved.
//

#include "CovarianceMatrixFit/dataProducts/Structs.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

namespace cmf{

  //----------------------------------------------------------------------------
  long StringToKey(std::string const& str)
  {
    long key = 0;
    
    // check for the detector
    if     (str.find("MINOSNear") != std::string::npos) key += cmf::DetectorTypeKey(cmf::kMINOSNEAR);
    else if(str.find("MINOSFar" ) != std::string::npos) key += cmf::DetectorTypeKey(cmf::kMINOSFAR );
    else if(str.find("Near")      != std::string::npos) key += cmf::DetectorTypeKey(cmf::kNEARDET  );
    else if(str.find("Far" )      != std::string::npos) key += cmf::DetectorTypeKey(cmf::kFARDET   );
    
    // check the period
    if(str.find("Period") != std::string::npos)
      key += cmf::PeriodKey(std::stol(str.substr(str.find("Period") + 6, std::string::npos)));
    else if(str.find("P") != std::string::npos)
      key += cmf::PeriodKey(std::stol(str.substr(str.find("P") + 1, std::string::npos)));

    // check the file type
    if     (str.find("Beam"        )  != std::string::npos) key += cmf::FileTypeKey(cmf::kBeam        );
    else if(str.find("TauSwap"     )  != std::string::npos) key += cmf::FileTypeKey(cmf::kTauSwap     );
    else if(str.find("FluxSwap"    )  != std::string::npos) key += cmf::FileTypeKey(cmf::kSwap        );
    else if(str.find("RockFluxSwap")  != std::string::npos) key += cmf::FileTypeKey(cmf::kRockFluxSwap);
    else if(str.find("RockNonSwap" )  != std::string::npos) key += cmf::FileTypeKey(cmf::kRockNonSwap );
    else if(str.find("Data"        )  != std::string::npos) key += cmf::FileTypeKey(cmf::kDataFile    );
    
    // check for a selection
    if     (str.find("NuMuSelQ1"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ1       );
    else if(str.find("NuMuSelQ2"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ2       );
    else if(str.find("NuMuSelQ3"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ3       );
    else if(str.find("NuMuSelQ4"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ4       );
    else if(str.find("NuMuSel"          ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelection         );
    else if(str.find("NuESel_AllPID"    ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelection          );
    else if(str.find("NuESel_LowPID"    ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionLowPID    );
    else if(str.find("NuESel_MidPID"    ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionMidPID    );
    else if(str.find("NuESel_HighPID"   ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionHighPID   );
    else if(str.find("NuESel_Peripheral") != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionPeripheral);
    
    // check for an interaction type
    if     (str.find("NuMuCC"    ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuMuCC    );
    else if(str.find("NuMuBarCC" ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuMuBarCC );
    else if(str.find("NuECC"     ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuECC     );
    else if(str.find("NuEBarCC"  ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuEBarCC  );
    else if(str.find("NuTauCC"   ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuTauCC   );
    else if(str.find("NuTauBarCC") != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuTauBarCC);
    else if(str.find("NC"        ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNC        );
    else if(str.find("CosmicMuon") != std::string::npos) key += cmf::InteractionTypeKey(cmf::kCosmicMuon);

    // check if this is data or MC, multiply by +/- 1 depending on the answer
    if     (str.find("MC")   != std::string::npos)   key *=  1;
    else if(str.find("Data") != std::string::npos)   key *= -1;

    return key;
  }

  //---------------------------------------------------------------------------
  long PeriodStringToInt(std::string const& epochStr){
    size_t first = epochStr.find_first_of("abcdefghijklmnopqrstuvwxyz");
    if(first != std::string::npos){
      LOG_WARNING("MetaData")
          << "use of subperiods is deprecated, only full periods are used";

      //auto alpha = epochStr.substr(first, first + 1);
      //return (std::stol(epochStr.substr(0, first).c_str(), nullptr, 0) * 1000 + static_cast<int>(*(alpha.c_str())));
    }

    LOG_DEBUG("MetaData")
    << epochStr
    << " "
    << std::stol(epochStr.substr(0, epochStr.length()).c_str(), nullptr, 0);

    return std::stol(epochStr.substr(0, epochStr.length()).c_str(), nullptr, 0);
  }

  //----------------------------------------------------------------------------
  MetaData::MetaData()
  : isMC           (false)
  , detector       (cmf::kUnknownDet)
  , fileType       (kUnknownFileType)
  , selectionType  (kUnknownSelection)
  , interactionType(kUnknownInteraction)
  , period         (0)
  {}
  
  //----------------------------------------------------------------------------
  MetaData::MetaData(bool                   const& mc,
                     cmf::DetType_t         const& det,
                     cmf::FileType_t        const& ft,
                     cmf::SelectionType_t   const& st,
                     cmf::InteractionType_t const& it,
                     std::string            const& ep)
  : isMC           (mc)
  , detector       (det)
  , fileType       (ft)
  , selectionType  (st)
  , interactionType(it)
  {
    period = cmf::PeriodStringToInt(ep);
  }

  //----------------------------------------------------------------------------
  MetaData::MetaData(bool                   const& mc,
                     cmf::DetType_t         const& det,
                     cmf::FileType_t        const& ft,
                     cmf::SelectionType_t   const& st,
                     cmf::InteractionType_t const& it,
                     int                    const& ep)
  : isMC           (mc)
  , detector       (det)
  , fileType       (ft)
  , selectionType  (st)
  , interactionType(it)
  , period         (ep)
  {}

  //----------------------------------------------------------------------------
  cmf::MetaDataLite MetaData::LiteMD() const
  {
    return MetaDataLite(this->detector, this->selectionType, this->Period());
  }
  
  //----------------------------------------------------------------------------
  std::string MetaData::ToString() const
  {
    std::string outType = (this->DetectorString() +
                           this->PeriodString()   +
                           cmf::cBeamType_Strings[this->BeamType()]);
    
    if(this->isMC){
      outType.insert(0, "MC");
      outType += cmf::cFileTypeStrings[fileType];
    }
    else
      outType.insert(0, "Data");
    
    outType += cmf::cSelectionType_Strings[selectionType];

    // this is not grouped with the other MC test to have the interaction type
    // be the last thing in the string
    if(this->isMC)
      outType += cmf::cInteractionType_Strings[interactionType];

    return outType;
  }

  //----------------------------------------------------------------------------
  std::string MetaData::ToStringLatex() const
  {
    std::string outType("Data");
    if(this->isMC){
      outType  = "MC";
      outType += " " + cmf::cFileTypeStrings_Latex[fileType];
      outType += " " + cmf::cSelectionType_LatexStrings[selectionType];
      outType += " " + cmf::cInteractionType_LatexStrings[interactionType];
    }
    
    if(detector == cmf::kFARDET    || 
       detector == cmf::kNEARDET   ||
       detector == cmf::kMINOSNEAR || 
       detector == cmf::kMINOSFAR   ) outType += " " + cmf::cDetType_Strings[detector];
    else                              outType += " " + cmf::cDetType_Strings[cmf::kUnknownDet];
    
    outType += this->PeriodString();

    outType += " " + cmf::cBeamType_LatexStrings[this->BeamType()];

    return outType;
  }


  //----------------------------------------------------------------------------
  cmf::BeamType_t MetaData::BeamType() const
  {

    // NOvA Period and Epoch naming scheme from:
    // https://cdcvs.fnal.gov/redmine/projects/novaart/wiki/Period_and_Epoch_Naming
                cmf::BeamType_t beam = cmf::PeriodToBeamType(this->PeriodString());

    LOG_DEBUG("UnknownBeamType")
      << "period : "
      <<  period
      << " Cannot identify beam type";

    return beam;
  }  

  //----------------------------------------------------------------------------
  long MetaData::DetectorBeamSelectionKey() const
  {
    return cmf::DetectorBeamSelectionTypesToKey(detector, this->BeamType(), selectionType);
  }

  //----------------------------------------------------------------------------
  long MetaData::Key() const
  {
    return ( this->MCKey()          *
            (this->DetectorKey()    +
             this->FileKey()        +
             this->SelectionKey()   +
             this->InteractionKey() +
             this->PeriodKey()
            )
           );
  }

  //----------------------------------------------------------------------------
  bool MetaData::IsNuMuQuantiles() const
  {
    return cmf::IsNuMuQuantiles(this->selectionType);
  }

  //----------------------------------------------------------------------------
  bool MetaData::IsNuMuSelected() const
  {
    return cmf::IsNuMuSelected(this->selectionType);
  }

  //----------------------------------------------------------------------------
  bool MetaData::IsNuESelected() const
  {
    return cmf::IsNuESelected(this->selectionType);
  }

  //----------------------------------------------------------------------------
  bool MetaData::IsNCSelected() const
  {
    return (this->selectionType == cmf::kNCSelection);
  }

  //----------------------------------------------------------------------------
  bool MetaData::operator==(const MetaData& other) const
  {
    return (other.isMC            == this->isMC            &&
            other.detector        == this->detector        &&
            other.fileType        == this->fileType        &&
            other.selectionType   == this->selectionType   &&
            other.interactionType == this->interactionType &&
            other.period          == this->period);
  }

  //----------------------------------------------------------------------------
  bool MetaData::operator<(const MetaData& other) const
  {
    return this->Key() < other.Key();
  }
  
  //----------------------------------------------------------------------------
  MetaDataLite::MetaDataLite()
  : detector(cmf::kUnknownDet)
  , selectionType(kUnknownSelection)
  , period(0)
  {}
  
  //----------------------------------------------------------------------------
  MetaDataLite::MetaDataLite(cmf::DetType_t  const& det,
                             cmf::SelectionType_t const& st,
                             std::string          const& ep)
  : detector       (det)
  , selectionType  (st)
  {
    period = cmf::PeriodStringToInt(ep);
  }
  
  //----------------------------------------------------------------------------
  std::string MetaDataLite::PeriodString() const
  {
    return ("Period" + std::to_string(period));
  }
  
  //----------------------------------------------------------------------------
  std::string MetaDataLite::ToString() const
  {
    std::string outType;
    
    if(detector == cmf::kFARDET    || 
       detector == cmf::kNEARDET   ||
       detector == cmf::kMINOSNEAR || 
       detector == cmf::kMINOSFAR   ) outType += cmf::cDetType_Strings[detector];
    else                              outType += cmf::cDetType_Strings[cmf::kUnknownDet];
    
    outType += cmf::cSelectionType_Strings[selectionType];
    outType += this->PeriodString();
    
    return outType;
  }
  
  //----------------------------------------------------------------------------
  bool MetaDataLite::operator==(const MetaDataLite& other) const
  {
    return (other.detector      == this->detector        &&
            other.selectionType == this->selectionType   &&
            other.period        == this->period);
  }
  
  //----------------------------------------------------------------------------
  bool MetaDataLite::operator<(const MetaDataLite& other) const
  {
    long thisNum = (this->detector        * 10000000 +
                    this->selectionType   * 100000   +
                    this->period);
    long otherNum = (other.detector       * 10000000 +
                     other.selectionType  * 100000   +
                     other.period);
    
    return thisNum < otherNum;
  }

  //----------------------------------------------------------------------------
  SpillSummary::SpillSummary()
  : totalPOT      (0.)
  , goodPOT       (0.)
  , liveTime      (0.)
  , totalNumSpills(0)
  , numGoodSpills (0)
  {}
  
  //----------------------------------------------------------------------------
  SpillSummary::SpillSummary(double            const& totPOT,
                             double            const& gPOT,
                             double            const& lt,
                             unsigned long int const& totSpill,
                             unsigned long int const& goodSpill)
  : totalPOT      (totPOT   )
  , goodPOT       (gPOT     )
  , liveTime      (lt       )
  , totalNumSpills(totSpill )
  , numGoodSpills (goodSpill)
  {}

  //----------------------------------------------------------------------------
  void SpillSummary::clear()
  {
    totalPOT       = 0.;
    goodPOT        = 0.;
    liveTime       = 0.;
    totalNumSpills = 0;
    numGoodSpills  = 0;
  }
  
  //----------------------------------------------------------------------------
  void SpillSummary::operator+=(SpillSummary const& o)
  {
    totalPOT       += o.totalPOT;
    goodPOT        += o.goodPOT;
    liveTime       += o.liveTime;
    totalNumSpills += o.totalNumSpills;
    numGoodSpills  += o.numGoodSpills;
  }

  //----------------------------------------------------------------------------
  void SpillSummary::operator*=(float f)
  {
    totalPOT       *= f;
    goodPOT        *= f;
    liveTime       *= f;
    totalNumSpills *= f;
    numGoodSpills  *= f;
  }

} // end namespace