LArSamples::FilterParams Class Reference

#include <FilterParams.h>

Collaboration diagram for LArSamples::FilterParams:

Public Member Functions
	FilterParams ()
	FilterParams (const FilterParams &other)
bool	set (const char *selection)
void	addRunRange (unsigned int run1, unsigned int run2)
void	addEventRange (unsigned int event1, unsigned int event2)
void	addLBRange (unsigned int lb1, unsigned int lb2)
void	addHashIdRange (unsigned int hashId1, unsigned int hashId2)
void	addRun (unsigned int run)
void	addEvent (unsigned int event)
void	addLB (unsigned int lb)
void	addHashId (unsigned int hashId)
void	addLayer (unsigned int layer)
void	addGain (CaloGain::CaloGain gain)
void	addRunEventFromData (const Data &data)
void	addChannel (CaloId calo, int feedthrough, int slot, int channel)
void	addChannels (const char *fileName)
void	setChannelVeto (short veto=-1)
void	addCalo (CaloId calo)
void	addPartition (PartitionId part)
void	setStatus (unsigned int status)
void	setRequireConvergence (bool conv=true)
void	setRequireSaturation (bool flag=true)
void	setRequireNoSaturation (bool flag=true)
void	setIndexParity (short parity)
bool	pass (unsigned int hashId, const History &history, unsigned int k) const
bool	passHash (unsigned int hashId) const
bool	passCell (const CellInfo &info) const
bool	passEvent (const Data &data) const
TString	processToken (const TString &var, const TString &op, const TString &arg, const TString &oring="")

Static Public Member Functions
static bool	splitToken (const TString &token, TString &var, TString &op, TString &arg)

Static Public Attributes
static const short	m_saturation = 3800

Private Attributes
std::vector< UIntRange >	m_runs
std::vector< UIntRange >	m_events
std::vector< UIntRange >	m_hashIds
std::vector< UIntRange >	m_lbs
std::vector< CaloId >	m_calos
std::vector< PartitionId >	m_partitions
std::vector< ChannelSpec >	m_channels
std::vector< int >	m_layers
std::vector< CaloGain::CaloGain >	m_gains
unsigned int	m_status
unsigned int	m_requireSat
std::map< TString, FuncCut >	m_cuts
bool	m_requireConvergence
int	m_channelSel
short	m_indexParity

Detailed Description

Definition at line 50 of file FilterParams.h.

Constructor & Destructor Documentation

FilterParams() [1/2]

LArSamples::FilterParams::FilterParams ( )

inline

Definition at line 54 of file FilterParams.h.

                   : 
      m_status(0xffffffff), m_requireSat(0),
      m_requireConvergence(false), m_channelSel(0), m_indexParity(0) { }

FilterParams() [2/2]

FilterParams::FilterParams

(

const FilterParams &

other

)

Definition at line 43 of file FilterParams.cxx.

                                                    : 
      m_runs(other.m_runs), m_events(other.m_events), m_hashIds(other.m_hashIds), m_lbs(other.m_lbs), 
      m_calos(other.m_calos), m_partitions(other.m_partitions), m_channels(other.m_channels), m_layers(other.m_layers),
      m_gains(other.m_gains), m_status(other.m_status), m_requireSat(other.m_requireSat),
      m_cuts(other.m_cuts), m_requireConvergence(other.m_requireConvergence), 
      m_channelSel(other.m_channelSel), m_indexParity(other.m_indexParity) 
{ }

Member Function Documentation

addCalo()

void LArSamples::FilterParams::addCalo ( CaloId  calo )

inline

Definition at line 80 of file FilterParams.h.

{ m_calos.push_back(calo); }

addChannel()

void FilterParams::addChannel	(	CaloId	calo,
		int	feedthrough,
		int	slot,
		int	channel
	)

Definition at line 373 of file FilterParams.cxx.

{
  m_channels.emplace_back(calo, feedThrough, slot, channel);
}

addChannels()

void FilterParams::addChannels

(

const char *

fileName

)

Definition at line 379 of file FilterParams.cxx.

{
  // bad channels list in usual format: 1 per line, | barrel_ec | pos_neg | ft | slot | channel | pb | 
 
  ifstream f(fileName);
  int barrel_ec, pos_neg, ft, slot, channel, status;
  std::string pb;
  
  while (!f.eof()) {
    f >> barrel_ec >> pos_neg >> ft >> slot >> channel >> status >> pb;
    //cout << barrel_ec << " " << pos_neg << " " << ft << " " <<  slot << " " << channel << " " << pb << endl;
    CaloId calo = UNKNOWN_CALO;
    if (barrel_ec == 0 && pos_neg == 0) calo = EMB_C;
    if (barrel_ec == 0 && pos_neg == 1) calo = EMB_A;
    if (barrel_ec == 1 && pos_neg == 0) calo = EMEC_C;
    if (barrel_ec == 1 && pos_neg == 1) calo = EMEC_A;
    if (calo != UNKNOWN_CALO) addChannel(calo, ft, slot, channel);
  }
  
/*  for (unsigned int k = 0; k < m_channels.size(); k++)
    cout << k << " " << Id::str(m_channels[k].calo) << " " <<  m_channels[k].feedThrough << " " << m_channels[k].slot << " " << m_channels[k].channel << endl;*/
}

addEvent()

void LArSamples::FilterParams::addEvent ( unsigned int  event )

inline

Definition at line 68 of file FilterParams.h.

{ m_events.push_back(UIntRange(event, event + 1)); }

addEventRange()

void LArSamples::FilterParams::addEventRange ( unsigned int  event1, unsigned int  event2  )

inline

Definition at line 63 of file FilterParams.h.

{ m_events.push_back(UIntRange(event1, event2)); }

addGain()

void LArSamples::FilterParams::addGain ( CaloGain::CaloGain  gain )

inline

Definition at line 72 of file FilterParams.h.

{ m_gains.push_back(gain); }

addHashId()

void LArSamples::FilterParams::addHashId ( unsigned int  hashId )

inline

Definition at line 70 of file FilterParams.h.

{ m_hashIds.push_back(UIntRange(hashId, hashId + 1)); }

addHashIdRange()

void LArSamples::FilterParams::addHashIdRange ( unsigned int  hashId1, unsigned int  hashId2  )

inline

Definition at line 65 of file FilterParams.h.

{ m_hashIds.push_back(UIntRange(hashId1, hashId2)); }

addLayer()

void LArSamples::FilterParams::addLayer ( unsigned int  layer )

inline

Definition at line 71 of file FilterParams.h.

{ m_layers.push_back(layer); }

addLB()

void LArSamples::FilterParams::addLB ( unsigned int  lb )

inline

Definition at line 69 of file FilterParams.h.

{ m_lbs.push_back(UIntRange(lb, lb + 1)); }

addLBRange()

void LArSamples::FilterParams::addLBRange ( unsigned int  lb1, unsigned int  lb2  )

inline

Definition at line 64 of file FilterParams.h.

{ m_lbs.push_back(UIntRange(lb1, lb2)); }

addPartition()

void LArSamples::FilterParams::addPartition ( PartitionId  part )

inline

Definition at line 81 of file FilterParams.h.

{ m_partitions.push_back(part); }

addRun()

void LArSamples::FilterParams::addRun ( unsigned int  run )

inline

Definition at line 67 of file FilterParams.h.

{ m_runs.push_back(UIntRange(run, run + 1)); }

addRunEventFromData()

void FilterParams::addRunEventFromData

(

const Data &

data

)

Definition at line 366 of file FilterParams.cxx.

{
  addRun(data.run());
  addEvent(data.event());
}

addRunRange()

void LArSamples::FilterParams::addRunRange ( unsigned int  run1, unsigned int  run2  )

inline

Definition at line 62 of file FilterParams.h.

{ m_runs.push_back(UIntRange(run1, run2)); }

pass()

bool FilterParams::pass	(	unsigned int	hashId,
		const History &	history,
		unsigned int	k
	)		const

Definition at line 403 of file FilterParams.cxx.

{
  if (!passHash(hashId)) return false;
  if (!passCell(*history.cellInfo())) return false;
  if (!passEvent(*history.data(k))) return false;
  return true;
}

passCell()

bool FilterParams::passCell

(

const CellInfo &

info

)

const

Definition at line 482 of file FilterParams.cxx.

{
  if (!m_calos.empty()) {
    bool pass = false;
    for (unsigned int k = 0; k < m_calos.size(); k++)
      if (Id::matchCalo(info.calo(), m_calos[k])) {
        pass = true;
        break;
      }
    if (!pass) return false;
  }
 
  if (!m_partitions.empty()) {
    bool pass = false;
    for (unsigned int k = 0; k < m_partitions.size(); k++)
      if (info.partition() == m_partitions[k]) {
        pass = true;
        break;
      }
    if (!pass) return false;
  }
  
  if (!m_layers.empty()) {
    bool found = false;
    for (unsigned int k = 0; k < m_layers.size(); k++)
      if (m_layers[k] == info.layer()) {
        found = true;
        break;
      }
    if (!found) return false; 
  }
  
  if (!m_channels.empty()) {
    bool found = false;
    for (unsigned int k = 0; k < m_channels.size(); k++)
      if (m_channels[k].match(info)) {
        found = true;
        break;
      }
    //cout << found << " " << m_channelSel << endl;
    if (!found && m_channelSel == +1) return false;
    if ( found && m_channelSel == -1) return false;
  }
  
  return true;
}

passEvent()

bool FilterParams::passEvent

(

const Data &

data

)

const

Definition at line 427 of file FilterParams.cxx.

{
  for (const auto& p : m_cuts) {
    if (!p.second.pass(data)) return false;
  }
  
  if (m_requireConvergence && data.adcMax() < 0) return false;
  if (!(m_status & data.status()) && data.status()) return false;
  if ((m_requireSat & 1) && data.maxSample() < m_saturation) return false;
  if ((m_requireSat & 2) && data.maxSample() > m_saturation) return false;
  if (m_indexParity > 0 && (data.index() % 2) != (m_indexParity % 2)) return false;
  if (!m_runs.empty()) {
    bool pass = false;
    for (unsigned int k = 0; k < m_runs.size(); k++)
      if (m_runs[k].first <= data.run() && data.run() < m_runs[k].second) {
        pass = true;
        break;
      }
    if (!pass) return false;
  }
  
  if (!m_events.empty()) {
    bool pass = false;
    for (unsigned int k = 0; k < m_events.size(); k++)
      if (m_events[k].first <= data.event() && data.event() < m_events[k].second) {
        pass = true;
        break;
      }
    if (!pass) return false;
  }
 
  if (!m_lbs.empty()) {
    bool pass = false;
    for (unsigned int k = 0; k < m_lbs.size(); k++)
      if (m_lbs[k].first <= data.lumiBlock() && data.lumiBlock() < m_lbs[k].second) {
        pass = true;
        break;
      }
    if (!pass) return false;
  }
 
  if (!m_gains.empty()) {
    bool pass = false;
    for (unsigned int k = 0; k < m_gains.size(); k++)
      if (m_gains[k] == data.gain()) {
        pass = true;
        break;
      }
    if (!pass) return false;
  }
  
  return true;
}

passHash()

bool FilterParams::passHash

(

unsigned int

hashId

)

const

Definition at line 412 of file FilterParams.cxx.

{
  if (!m_hashIds.empty()) {
    bool pass = false;
    for (unsigned int k = 0; k < m_hashIds.size(); k++)
      if (m_hashIds[k].first <= (int)hashId && (int)hashId < m_hashIds[k].second) {
        pass = true;
        break;
      }
    if (!pass) return false;
  }
  return true;
}

processToken()

TString FilterParams::processToken	(	const TString &	var,
		const TString &	op,
		const TString &	arg,
		const TString &	oring = ""
	)

Definition at line 163 of file FilterParams.cxx.

{
  //cout << var << " " << op << " " << arg << " " << oring << endl;  
  if (var == "status" && op == "==") {
    if (m_status != 0xffffffff) return "Variable " + var + " already set";
    setStatus(arg.Atoi());
    return "";
  }
  if (var == "saturate" && op == "==") {
    if (m_requireSat != 0) return "Variable " + var + " already set";
    if (arg == "yes") { setRequireSaturation(); cout << "---> setRequireSaturation" << endl; return ""; }
    if (arg == "no") { setRequireNoSaturation(); cout << "---> setRequireNoSaturation" << endl;  return ""; }
    return "Invalid argument " + arg;
  }
  if (var == "cell") {
    if (oring != "cell" && !m_channels.empty()) return "Variable " + var + " already set";
    if (op == "==") {
      if (m_channelSel == -1) return "Cannot have positive channel selections and vetos in the same command";
      cout << "---> set channel sel == 1" << endl;
      m_channelSel = 1;
    }
    if (op == "!=") {
      if (m_channelSel == +1) return "Cannot have positive channel selections and vetos in the same command";
      cout << "---> set channel sel == -1" << endl;
      m_channelSel = -1;
    }    
    TObjArray* chTokens = nullptr;
    if (TString(arg[0]) == "[" || TString(arg[arg.Length() - 1]) == "]")
      chTokens = TString(arg(1, arg.Length() - 2)).Tokenize(",");
    else 
      chTokens = arg.Tokenize("/");
    if (chTokens->GetEntries() != 4) { delete chTokens; return "Invalid argument " + arg; }
    TString calo = ((TObjString*)chTokens->At(0))->String();
    TString ft   = ((TObjString*)chTokens->At(1))->String();
    TString slot = ((TObjString*)chTokens->At(2))->String();
    TString channel = ((TObjString*)chTokens->At(3))->String();
    delete chTokens;
    CaloId caloId = Id::caloId(calo);
    if (caloId == UNKNOWN_CALO) return "Invalid argument " + arg;
    int ftNum = -99, slotNum = -99, channelNum = -99;
    if (ft.IsDigit()) 
      ftNum = ft.Atoi();
    else if (ft == "?" || ft == "x" || ft == "-1") 
      ftNum = -1;    
    if (ftNum == -99) return "Invalid FT argument " + ft;
    if (slot.IsDigit()) 
     slotNum = slot.Atoi();
    else if (slot == "?" || slot == "x" || slot == "-1") 
      slotNum = -1;    
    if (slotNum == -99) return "Invalid slot argument " + slot;
    if (channel.IsDigit()) 
      channelNum = channel.Atoi();
    else if (channel == "?" || channel == "x" || channel == "-1") 
      channelNum = -1;    
    if (channelNum == -99) return "Invalid channel argument " + channel;
    addChannel(caloId, ftNum, slotNum, channelNum);
    cout << "---> addChannel " << Id::str(caloId) << " " << ftNum << " " << slotNum << " " << channelNum << endl;
    return "";
  }
  if (var == "calo" && op == "==") {
    if (oring != "calo" && !m_calos.empty()) return "Variable " + var + " already set";
    CaloId caloId = Id::caloId(arg);
    if (caloId == UNKNOWN_CALO) return "Invalid argument " + arg;
    addCalo(caloId);
    cout << "---> addCalo " << Id::str(caloId) << endl;
    return "";
  }
  if (var == "partition" && op == "==") {
    if (oring != "partition" && !m_calos.empty()) return "Variable " + var + " already set";
    PartitionId partId = Id::partitionId(arg);
    if (partId == UNKNOWN_PARTITION) return "Invalid argument " + arg;
    addPartition(partId);
    cout << "---> addPartition " << Id::str(partId) << endl;
    return "";
  }
  if (var == "layer" && op == "==") {
    if (oring != "layer" && !m_layers.empty()) return "Variable " + var + " already set";
    if (!arg.IsDigit()) return "Invalid argument " + arg;
    addLayer(arg.Atoi());
    cout << "---> addLayer " << arg.Atoi() << endl;
    return "";
  }
  if (var == "gain" && op == "==") {
    if (oring != "gain" && !m_gains.empty()) return "Variable " + var + " already set";
    CaloGain::CaloGain gain = CaloGain::UNKNOWNGAIN;
    if (arg == "HIGH")   gain = CaloGain::LARHIGHGAIN;
    if (arg == "MEDIUM") gain = CaloGain::LARMEDIUMGAIN;
    if (arg == "LOW")    gain = CaloGain::LARLOWGAIN;
    if (gain == CaloGain::UNKNOWNGAIN) return "Invalid gain argument " + arg + ", expecting HIGH/MEDIUM/LOW";
    addGain(gain);
    cout << "---> addGain " << Data::gainStr(gain) << endl;
    return "";
  }
  if (var == "runNum" && op == "==") {
    if (oring != "runNum" && !m_runs.empty()) return "Variable " + var + " already set";
    if (!arg.IsDigit()) return "Invalid argument " + arg;
    addRun(arg.Atoi());
    cout << "---> addRun " << arg.Atoi() << endl;
    return "";
  }
  if (var == "eventNum" && op == "==") {
    if (oring != "eventNum" && !m_events.empty()) return "Variable " + var + " already set";
    if (!arg.IsDigit()) return "Invalid argument " + arg;
    addEvent(arg.Atoi());
    cout << "---> addEvent " << arg.Atoi() << endl;
    return "";
  }
  if (var == "eventSpec" && op == "==") {
    if (oring != "eventSpec" && !m_events.empty()) return "Variable " + var + " already set";
    TObjArray* evTokens = arg.Tokenize("/");
    if (evTokens->GetEntries() != 2) { delete evTokens; return "Invalid argument " + arg; }
    TString evt = ((TObjString*)evTokens->At(0))->String();
    TString run = ((TObjString*)evTokens->At(1))->String();
    delete evTokens;
    if (!run.IsDigit()) return "Invalid run argument in " + arg;
    if (!evt.IsDigit()) return "Invalid event argument in " + arg;
    addRun(run.Atoi());
    addEvent(evt.Atoi());
    cout << "---> addRun/addEvent " << run.Atoi() << "/" << evt.Atoi() << endl;
    return "";
  }
  if (var == "eventFile" && op == "==") {
    if (oring != "eventFile" && !m_events.empty()) return "Variable " + var + " already set";
    ifstream fs(arg);
    if (!fs.is_open() || fs.eof()) return "File " + arg + " does not contain a valid event list";
    while (!fs.eof()) {
      char line[200];
      fs.getline(line, 200);
      //line = line.Substr(0, line.Length() - 1); // remove trailing linefeed
      TObjArray* evTokens = arg.Tokenize("/");
      if (evTokens->GetEntries() != 2) { delete evTokens; return "Invalid argument " + arg; }
      TString evt = ((TObjString*)evTokens->At(0))->String();
      TString run = ((TObjString*)evTokens->At(1))->String();
      delete evTokens;
      if (!run.IsDigit()) return "Invalid run argument in " + arg;
      if (!evt.IsDigit()) return "Invalid event argument in " + arg;
      addRun(run.Atoi());
      addEvent(evt.Atoi());
      cout << "---> addRun/addEvent " << run.Atoi() << "/" << evt.Atoi() << endl;
    }
    fs.close();
  }
  if (var == "lb" && op == "==") {
    if (oring != "lb" && !m_lbs.empty()) return "Variable " + var + " already set";
    if (!arg.IsDigit()) return "Invalid argument " + arg;
    addLB(arg.Atoi());
    cout << "---> addLB " << arg.Atoi() << endl;
    return "";
  }
  if (var == "hashId" && op == "==") {
    if (oring != "hashId" && !m_hashIds.empty()) return "Variable " + var + " already set";
    if (!arg.IsDigit()) return "Invalid argument " + arg;
    addHashId(arg.Atoi());
    cout << "---> addHashId " << arg.Atoi() << endl;
    return "";
  }
  if (var == "hashId" && op == "<") {
    if (oring != "hashId" && !m_hashIds.empty()) return "Variable " + var + " already set";
    if (!arg.IsDigit()) return "Invalid argument " + arg;
    addHashIdRange(0, arg.Atoi());
    cout << "---> addHashIdRange 0 " << arg.Atoi() << endl;
    return "";
  }
  if (var == "indexParity" && op == "==") {
    if (oring != "") return "Variable " + var + " cannot be or'ed";
    if (!arg.IsDigit()) return "Invalid argument " + arg;
    setIndexParity(arg.Atoi());
    cout << "---> indexParity " << arg.Atoi() << endl;
    return "";
  }
 
  std::vector<TString> vars;
  std::vector<DataFuncSet> funcs;
  std::vector<DataFuncArgs> args;
  bool status = MonitorBase::parseVariables(var, vars, funcs, args);
  if (status && vars.size() == 1) {
    std::map<TString, FuncCut>::iterator cut = m_cuts.find(var);
    if (cut == m_cuts.end()) {
      m_cuts[var] = FuncCut(funcs[0], args[0]);
      cut = m_cuts.find(var);
    }
    if (op == ">") {
      if (cut->second.gotMin()) return "Min value for variable " + var + " was already set"; 
      cut->second.min = arg.Atof();
      cout << "---> set " << var << " >= " << arg.Atof() << endl;
    }
    if (op == "<") {
      if (cut->second.gotMax()) return "Max value for variable " + var + " was already set"; 
      cut->second.max = arg.Atof();
      cout << "---> set " << var << " < " << arg.Atof() << endl;
    }
    if (op == "==") {
      if (cut->second.gotMin() || cut->second.gotMax()) return "A cut for variable " + var + " was already set"; 
      cut->second.setEqual(arg.Atof());
      cout << "---> set " << var << " == " << arg.Atof() << endl;
    }
    return "";
  }
 
  return "Invalid variable or operator";
}

set()

bool FilterParams::set

(

const char *

selection

)

Definition at line 52 of file FilterParams.cxx.

{
  TString error = "Allowed syntax is \" condition1 && condition2 && ... && conditionN\n";
  error += "where conditionX is of the form status==XXX, saturate==yes|no, energy>XX, eta>XX, eta<XX, adcMax>XX, sampleMax>XX\n";
  error += "chi2<XX, time>XX, time<XX, converged=true, calo==XX, cell==[FT,slot,channel], run==XX, event=XX\n";
  error += "or an or list (item1 || item2 ||...  itemN) of such statements.";
  
  TString sel = selection, var = "", arg = "", op = "";
  
  sel.ReplaceAll(" ", "");
  TObjArray* tokens = sel.Tokenize("&&");
  for (int i = 0; i < tokens->GetEntries(); i++) {
    TString& token = ((TObjString*)tokens->At(i))->String();    
    if (TString(token[0]) == "(" && TString(token[token.Length() - 1]) == ")") {
      TObjArray* orTokens = TString(token(1, token.Length() - 2)).Tokenize("||");
      TString oring = "";
      for (int j = 0; j < orTokens->GetEntries(); j++) {
        TString& orToken = ((TObjString*)orTokens->At(j))->String();    
    if (!splitToken(orToken, var, op, arg)) {
      cout << "could not process token " << orToken << endl << error << endl;
      delete tokens;
          delete orTokens;
      return false;
    }
        if (oring != "" && oring != var) {
          cout << "inconsistent or-list " << token << endl << error << endl;
          delete orTokens;
          delete tokens;          
          return false;
        }
    TString result = processToken(var, op, arg, oring);
    if (result != "") {
      cout << "Error while processing token " << orToken << " : " << result << endl << error << endl;
      delete tokens;
          delete orTokens;
      return false;
    }
        if (oring == "")
          oring = var;
      }
      delete orTokens;
      continue;
    }
    if (!splitToken(token, var, op, arg)) {
      cout << "could not process token " << token << endl << error << endl;
      delete tokens;
      return false;
    }
    TString result = processToken(var, op, arg);
    if (result != "") {
      cout << "Error while processing token " << token << " : " << result << endl << error << endl;
      delete tokens;
      return false;
    }
  }
  delete tokens;
  return true;
}

setChannelVeto()

void LArSamples::FilterParams::setChannelVeto ( short  veto = -1 )

inline

Definition at line 78 of file FilterParams.h.

{ m_channelSel = veto; }  // apply channelList as Veto (true) or positive filter (false)

setIndexParity()

void LArSamples::FilterParams::setIndexParity ( short  parity )

inline

Definition at line 87 of file FilterParams.h.

{ m_indexParity = parity; }

setRequireConvergence()

void LArSamples::FilterParams::setRequireConvergence ( bool  conv = true )

inline

Definition at line 84 of file FilterParams.h.

{ m_requireConvergence = conv; }

setRequireNoSaturation()

void LArSamples::FilterParams::setRequireNoSaturation ( bool  flag = true )

inline

Definition at line 86 of file FilterParams.h.

{ m_requireSat = m_requireSat | (flag ? 12 : 0); }

setRequireSaturation()

void LArSamples::FilterParams::setRequireSaturation ( bool  flag = true )

inline

Definition at line 85 of file FilterParams.h.

{ m_requireSat = m_requireSat | (flag ? 1 : 0); }

setStatus()

void LArSamples::FilterParams::setStatus ( unsigned int  status )

inline

Definition at line 82 of file FilterParams.h.

{ m_status = status; }

splitToken()

bool FilterParams::splitToken ( const TString &  token, TString &  var, TString &  op, TString &  arg  )

static

Definition at line 112 of file FilterParams.cxx.

{
  //cout << token << endl;
  if (token.Index("!=") >= 0) {
    TObjArray* neTokens = token.Tokenize("!=");
    if (neTokens->GetEntries() == 2) {
      var = ((TObjString*)neTokens->At(0))->String();
      arg = ((TObjString*)neTokens->At(1))->String();
      op = "!=";
      delete neTokens;
      return true;    
    }
    delete neTokens;
  }
  if (token.Index("==") >= 0) {
    TObjArray* eqTokens = token.Tokenize("==");
    if (eqTokens->GetEntries() == 2) {
      var = ((TObjString*)eqTokens->At(0))->String();
      arg = ((TObjString*)eqTokens->At(1))->String();
      op = "==";
      delete eqTokens;
      return true;    
    }
    delete eqTokens;
  }
  if (token.Index(">") >= 0) {
    TObjArray* gtTokens = token.Tokenize(">");
    if (gtTokens->GetEntries() == 2) {
      var = ((TObjString*)gtTokens->At(0))->String();
      arg = ((TObjString*)gtTokens->At(1))->String();
      op = ">";
      delete gtTokens;
      return true;    
    }
    delete gtTokens;
  }
  if (token.Index("<") >= 0) {
    TObjArray* ltTokens = token.Tokenize("<");
    if (ltTokens->GetEntries() == 2) {
      var = ((TObjString*)ltTokens->At(0))->String();
      arg = ((TObjString*)ltTokens->At(1))->String();
      op = "<";
      delete ltTokens;
      return true;    
    }
    delete ltTokens;
  }
  return false;
}

Member Data Documentation

m_calos

std::vector<CaloId> LArSamples::FilterParams::m_calos

private

Definition at line 108 of file FilterParams.h.

m_channels

std::vector<ChannelSpec> LArSamples::FilterParams::m_channels

private

Definition at line 110 of file FilterParams.h.

m_channelSel

int LArSamples::FilterParams::m_channelSel

private

Definition at line 120 of file FilterParams.h.

m_cuts

std::map<TString, FuncCut> LArSamples::FilterParams::m_cuts

private

Definition at line 116 of file FilterParams.h.

m_events

std::vector<UIntRange> LArSamples::FilterParams::m_events

private

Definition at line 107 of file FilterParams.h.

m_gains

std::vector<CaloGain::CaloGain> LArSamples::FilterParams::m_gains

private

Definition at line 112 of file FilterParams.h.

m_hashIds

std::vector<UIntRange> LArSamples::FilterParams::m_hashIds

private

Definition at line 107 of file FilterParams.h.

m_indexParity

short LArSamples::FilterParams::m_indexParity

private

Definition at line 121 of file FilterParams.h.

m_layers

std::vector<int> LArSamples::FilterParams::m_layers

private

Definition at line 111 of file FilterParams.h.

m_lbs

std::vector<UIntRange> LArSamples::FilterParams::m_lbs

private

Definition at line 107 of file FilterParams.h.

m_partitions

std::vector<PartitionId> LArSamples::FilterParams::m_partitions

private

Definition at line 109 of file FilterParams.h.

m_requireConvergence

bool LArSamples::FilterParams::m_requireConvergence

private

Definition at line 119 of file FilterParams.h.

m_requireSat

unsigned int LArSamples::FilterParams::m_requireSat

private

Definition at line 113 of file FilterParams.h.

m_runs

std::vector<UIntRange> LArSamples::FilterParams::m_runs

private

Definition at line 107 of file FilterParams.h.

m_saturation

const short LArSamples::FilterParams::m_saturation = 3800

static

Definition at line 100 of file FilterParams.h.

m_status

unsigned int LArSamples::FilterParams::m_status

private

Definition at line 113 of file FilterParams.h.

---

The documentation for this class was generated from the following files:

• FilterParams.h
• FilterParams.cxx