// ============================================================================
StatusCode GaudiPython::TupleDecorator::farray
( const Tuples::Tuple& tuple ,
const std::string& name ,
const std::vector<double>& data ,
const std::string& length ,
const size_t maxv )
{
if ( !tuple.valid() ) { return StatusCode::FAILURE ; }
return tuple->farray( name , data.begin() , data.end() , length , maxv ) ;
}
// ============================================================================
StatusCode GaudiPython::TupleDecorator::farray
( const Tuples::Tuple& tuple ,
const std::string& name ,
const CLHEP::HepVector& data ,
const std::string& length ,
const size_t maxv )
{
if ( !tuple.valid() ) { return StatusCode::FAILURE ; }
// use the trick!
const double* begin = &(data[0]);
const double* end = begin + data.num_row() ;
return tuple->farray ( name , begin , end , length , maxv ) ;
}
StatusCode TupleToolTagging::fill( const Particle* mother
, const Particle* P
, const std::string& head
, Tuples::Tuple& tuple )
{
const std::string prefix=fullName(head);
Assert( P && mother && m_dva && m_tagging,
"Should not happen, you are inside TupleToolTagging.cpp" );
std::string loc = objectLocation( P->parent() );
// nothing to tag on something which is not a B
if( !P->particleID().hasBottom() ) return StatusCode::SUCCESS;
if( msgLevel( MSG::DEBUG ) ){
debug() << " Going to Save Tagging information for B candidate "
<< endreq;
}
FlavourTag theTag;
FlavourTags* tags = NULL;
bool check = false;
StatusCode sc=StatusCode::SUCCESS;
boost::replace_all( loc, "/Particles", "/FlavourTags" );
if( m_useFTonDST ) {
if( exist < LHCb::FlavourTags > (loc,IgnoreRootInTES))
tags = get< LHCb::FlavourTags > (loc,IgnoreRootInTES );
}
if (tags) {
for(FlavourTags::const_iterator it = tags->begin(); it != tags->end(); ++it) {
if( P != (**it).taggedB()) continue;
theTag = **it;
check = true;
}
if (!check) sc = StatusCode::FAILURE;
} else {
const VertexBase* v = m_dva->bestVertex( mother );
const RecVertex* vtx = dynamic_cast<const RecVertex*>(v);
if( !vtx ){
sc = m_tagging->tag( theTag, P );
} else {
sc = m_tagging->tag( theTag, P, vtx );
}
}
// try to find unphysical defaults
int dec = 0;
double omega = 0.5;
int decOS = 0;
double omegaOS = 0.5;
if( sc ){
dec = theTag.decision();
omega = theTag.omega(); // predicted wrong tag fraction.
decOS = theTag.decisionOS();
omegaOS = theTag.omegaOS(); // predicted wrong tag fraction.
} else {
Warning("The tagging algorithm failed");
}
bool test = true;
test &= tuple->column( prefix+"_TAGDECISION" , dec );
test &= tuple->column( prefix+"_TAGOMEGA" , omega );
test &= tuple->column( prefix+"_TAGDECISION_OS" , decOS );
test &= tuple->column( prefix+"_TAGOMEGA_OS" , omegaOS );
int taggers_code = 0;
// intialize tagger by tagger W :
std::vector<Tagger> taggers = theTag.taggers();
for(size_t i=0; i<taggers.size(); ++i) {
int tdec = taggers[i].decision();
if(tdec) switch ( taggers[i].type() ) {
case Tagger::OS_Charm : taggers_code +=1000000000 *(tdec+2); break;
case Tagger::SS_Proton : taggers_code += 100000000 *(tdec+2); break;
case Tagger::OS_nnetKaon : taggers_code += 10000000 *(tdec+2); break;
case Tagger::SS_nnetKaon : taggers_code += 1000000 *(tdec+2); break;
case Tagger::OS_Muon : taggers_code += 100000 *(tdec+2); break;
case Tagger::OS_Electron : taggers_code += 10000 *(tdec+2); break;
case Tagger::OS_Kaon : taggers_code += 1000 *(tdec+2); break;
case Tagger::SS_Kaon : taggers_code += 100 *(tdec+2); break;
case Tagger::SS_Pion : taggers_code += 10 *(tdec+2); break;
case Tagger::VtxCharge : taggers_code += 1 *(tdec+2); break;
}
}
test &= tuple->column( prefix+"_TAGGER" , taggers_code);
if(isVerbose())
{
// Initialize all columns to default values
for(size_t i=0; i<m_activeTaggers.size(); i++) {
std::string active = m_activeTaggers[i];
test &= tuple->column( prefix+"_"+active+"_DEC", (short int)0 );
test &= tuple->column( prefix+"_"+active+"_PROB", (float)0.5 );
if(m_extendedTagging){
if( true ) {
std::vector<double> id, p, px, py, pz, pt, theta, phi;
std::vector<double> pid_e, pid_mu, pid_k, pid_p;
std::vector<double> ip, chi2, bip, bchi2, bp_chi2;
const std::string num_name = prefix+"_"+active+"_PARTICLES_NUM";
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_ID", id.begin(), id.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_P", p.begin(), p.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PX", px.begin(), px.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PY", py.begin(), py.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PZ", pz.begin(), pz.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PT", pt.begin(), pt.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_THETA", theta.begin(), theta.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PHI", phi.begin(), phi.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PIDe", pid_e.begin(), pid_e.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PIDmu", pid_mu.begin(), pid_mu.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PIDk", pid_k.begin(), pid_k.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_PIDp", pid_p.begin(), pid_p.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_IP_OWNPV", ip.begin(), ip.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_IPCHI2_OWNPV", chi2.begin(), chi2.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_IP_BVertex", bip.begin(), bip.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_IPCHI2_BVertex", bchi2.begin(), bchi2.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+active+"_PARTICLES_CHI2_BpVertex", bp_chi2.begin(), bp_chi2.end(), num_name, 20 );
}
}
}
for(size_t i=0; i<taggers.size(); i++) {
std::string name = m_tagger_map[(int)taggers[i].type()];
//loop over active taggers only
if(std::find(m_activeTaggers.begin(), m_activeTaggers.end(), name) != m_activeTaggers.end()) {
Tagger tagger = taggers[i];
test &= tuple->column( prefix+"_"+name+"_DEC", tagger.decision() );
test &= tuple->column( prefix+"_"+name+"_PROB", tagger.omega() );
if(m_extendedTagging){
// Save interesting tagging data
std::vector<double> id, p, px, py, pz, pt, theta, phi;
std::vector<double> pid_e, pid_mu, pid_k, pid_p;
std::vector<double> ip, chi2, bip, bchi2, bp_chi2;
SmartRefVector<LHCb::Particle> parts = tagger.taggerParts();
for(SmartRefVector<LHCb::Particle>::const_iterator it=parts.begin();
it != parts.end(); it++) {
VerboseData data = getVerboseData(*it, P);
id.push_back(data.id);
p.push_back(data.p);
px.push_back(data.px);
py.push_back(data.py);
pz.push_back(data.pz);
pt.push_back(data.pt);
theta.push_back(data.theta);
phi.push_back(data.phi);
pid_e.push_back(data.pid_e);
pid_mu.push_back(data.pid_mu);
pid_k.push_back(data.pid_k);
pid_p.push_back(data.pid_p);
ip.push_back(data.ip);
chi2.push_back(data.chi2);
bip.push_back(data.bip);
bchi2.push_back(data.bchi2);
bp_chi2.push_back(data.bp_chi2);
}
const std::string num_name = prefix+"_"+name+"_PARTICLES_NUM";
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_ID", id.begin(), id.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_P", p.begin(), p.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PX", px.begin(), px.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PY", py.begin(), py.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PZ", pz.begin(), pz.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PT", pt.begin(), pt.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_THETA", theta.begin(), theta.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PHI", phi.begin(), phi.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PIDe", pid_e.begin(), pid_e.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PIDmu", pid_mu.begin(), pid_mu.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PIDk", pid_k.begin(), pid_k.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_PIDp", pid_p.begin(), pid_p.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_IP_OWNPV", ip.begin(), ip.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_IPCHI2_OWNPV", chi2.begin(), chi2.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_IP_BVertex", bip.begin(), bip.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_IPCHI2_BVertex", bchi2.begin(), bchi2.end(), num_name, 20 );
test &= tuple->farray( prefix+"_"+name+"_PARTICLES_CHI2_BpVertex", bp_chi2.begin(), bp_chi2.end(), num_name, 20 );
}
}
}
}
if( msgLevel( MSG::DEBUG ) ){
debug() << "Tagging summary: decision: " << dec
<< ", omega=" << omega << endreq;
}
return StatusCode(test);
}
//=========================================================================
// Fill PV for all PV
//=========================================================================
StatusCode TupleToolGeometry::fillMinIP( const Particle* P,
const std::string& prefix,
Tuples::Tuple& tuple ) const
{
bool test = true ;
// minimum IP
double ipmin = -1;
double minchi2 = -1 ;
double ipminnextbest = -1;
double minchi2nextbest = -1;
if(msgLevel(MSG::VERBOSE)) verbose() << "Looking for Min IP" << endmsg ;
const RecVertex::Range PV = m_dva->primaryVertices();
if(msgLevel(MSG::VERBOSE)) verbose() << "PV size: " << PV.size() << endmsg ;
std::vector<double> ips, ipchi2s, diras;
if ( !PV.empty() )
{
if(msgLevel(MSG::VERBOSE)) verbose() << "Filling IP " << prefix + "_MINIP : "
<< P << " PVs:" << PV.size() << endmsg ;
for ( RecVertex::Range::const_iterator pv = PV.begin() ; pv!=PV.end() ; ++pv)
{
RecVertex newPV(**pv);
if (m_refitPVs)
{
StatusCode scfit = m_pvReFitter->remove(P, &newPV);
if(!scfit) { Warning("ReFitter fails!",StatusCode::SUCCESS,10).ignore(); continue; }
}
double ip, chi2;
//StatusCode test2 = m_dist->distance ( P, *pv, ip, chi2 );
LHCb::VertexBase* newPVPtr = (LHCb::VertexBase*)&newPV;
StatusCode test2 = m_dist->distance ( P, newPVPtr, ip, chi2 );
ips.push_back(ip);
ipchi2s.push_back(chi2);
if (P->endVertex()) diras.push_back(dira(newPVPtr,P));
if( test2 && isVerbose() )
{
if ((ip<ipmin) || (ipmin<0.))
{
ipminnextbest = ipmin;
ipmin = ip ;
}
else
{
if((ip < ipminnextbest) || (ipminnextbest < 0))
{
ipminnextbest = ip;
}
}
if ((chi2<minchi2) || (minchi2<0.))
{
minchi2nextbest = minchi2;
minchi2 = chi2 ;
}
else
{
if((chi2 < minchi2nextbest) || (minchi2nextbest < 0))
{
minchi2nextbest = chi2;
}
}
}
}
}
if (isVerbose()){
if ( msgLevel(MSG::VERBOSE) )
{
verbose() << "Filling IP " << prefix + "_MINIP " << ipmin << " at " << minchi2 << endmsg ;
verbose() << "Filling IP next best " << prefix + "_MINIP " << ipminnextbest << " at "
<< minchi2nextbest << endmsg ;
}
test &= tuple->column( prefix + "_MINIP", ipmin );
test &= tuple->column( prefix + "_MINIPCHI2", minchi2 );
test &= tuple->column( prefix + "_MINIPNEXTBEST", ipminnextbest );
test &= tuple->column( prefix + "_MINIPCHI2NEXTBEST", minchi2nextbest );
}
if (m_fillMultiPV){
test &= tuple->farray( prefix + "_AllIP", ips, "nPV", m_maxPV );
test &= tuple->farray( prefix + "_AllIPchi2", ipchi2s, "nPV", m_maxPV );
if (!diras.empty()) test &= tuple->farray( prefix + "_AllDIRA", diras, "nPV", m_maxPV );
// --------------------------------------------------
}
if(msgLevel(MSG::VERBOSE))
verbose() << "Return from fillMinIP: " << prefix << " " << test << endmsg;
if (!test) Warning("Error in fillMinIP",1,StatusCode::FAILURE);
return StatusCode(test) ;
}