//=============================================================================
// GetClusters
//=============================================================================
StatusCode HTBlob::GetViewClustersAboveThreshold( SmartRefVector<Minerva::IDCluster> &idClusterVec,
SmartRefVector<Minerva::IDCluster> &idClusterView,
Minerva::IDCluster::View view, double pecut ) const
{
if( !idClusterVec.size() ) {
debug() << " ALERT: Input Vector of Clusters to the Get_Clusters tool is empty " << endmsg;
return StatusCode::FAILURE;
}
SmartRefVector<Minerva::IDCluster> ClusTemp = idClusterVec;
SmartRefVector<Minerva::IDCluster>::iterator itClus = ClusTemp.begin();
idClusterVec.clear();
for ( ; itClus != ClusTemp.end(); itClus++ ){
if ( (*itClus)->view()==view && (*itClus)->pe()/(*itClus)->iddigs()>3 && (*itClus)->pe()>pecut ) {
idClusterView.push_back(*itClus);
}
else idClusterVec.push_back(*itClus);
}
return StatusCode::SUCCESS;
}
//=============================================================================
// Create2dHTBlob
//=============================================================================
StatusCode HTBlob::Create2dHTSeed( SmartRefVector<Minerva::IDCluster> &idClusterView,
SmartRefVector<Minerva::IDCluster> &HT2dClusters,
double r, double theta, Gaudi::XYZPoint ref, double &spX, double &spZ ) const
{
debug() << " HTtool::Create2dHTSeed " << endmsg;
double rmin, rmax, x, z, zmin = 10000, Total_e = 0;
SmartRefVector<Minerva::IDCluster> ClusTemp = idClusterView;
SmartRefVector<Minerva::IDCluster>::iterator itClus = ClusTemp.begin();
idClusterView.clear();
debug() << " Will study " << ClusTemp.size() << " clusters " << endmsg;
debug() << " Seed with, r: " << r << ", theta = " << theta << ";contains these clusters: " << endmsg;
for ( ; itClus != ClusTemp.end(); itClus++ ){
z = (*itClus)->z() - ref.z();
x = (*itClus)->tpos1() - ref.x();
rmin = x*sin(theta*CLHEP::pi/180) + z*cos(theta*CLHEP::pi/180);
x = (*itClus)->tpos2() - ref.x();
rmax = x*sin(theta*CLHEP::pi/180) + z*cos(theta*CLHEP::pi/180);
if ( fabs ( 2*r - rmin - rmax ) <= 90 ){
if ( (*itClus)->z()< zmin ) {
zmin = (*itClus)->z();
spZ = (*itClus)->z();
spX = (*itClus)->position();
}
debug() << " pe = " << (*itClus)->pe() << "; z = " << (*itClus)->z() << "; pos = " << (*itClus)->position()
<< endmsg;
HT2dClusters.push_back(*itClus);
Total_e += (*itClus)->energy();
continue;
}
idClusterView.push_back(*itClus);
}
debug() << " Total energy comming from seed = " << Total_e << "; this energy must be bigger than 19"
<< endmsg << endmsg;
if ( Total_e < 19 ) {
idClusterView.insert(idClusterView.end(),HT2dClusters.begin(),HT2dClusters.end());
return StatusCode::FAILURE;
}
return StatusCode::SUCCESS;
}
void AngleScan_V::coneView(SmartRefVector<Minerva::IDCluster>& unusedViewClusters,
SmartRefVector<Minerva::IDCluster>& showerCand,
double vtxT,
double min_angle, double max_angle,
double zmin, double zmax)
{
SmartRefVector<Minerva::IDCluster> tmpClusters;
tmpClusters.swap(unusedViewClusters);
for (SmartRefVector<Minerva::IDCluster>::iterator c = tmpClusters.begin();
c != tmpClusters.end(); ++c) {
const double dZ = (*c)->z() - fZ;
const double dV = (*c)->position() - vtxT;
const double theta = std::atan2(dV,dZ)*TMath::RadToDeg();
const double z_c = (*c)->z();
if ((min_angle <= theta && theta <= max_angle) &&
(zmin < z_c && z_c < zmax)) {
showerCand.push_back(*c);
} else {
unusedViewClusters.push_back(*c);
}
}
}
//======================================================================
// PseudoCone
//=======================================================================
StatusCode HTBlob::PseudoCone(SmartRefVector<Minerva::IDCluster> &Seed, SmartRefVector<Minerva::IDCluster> &ClusVectorX,
Gaudi::XYZVector direction, Gaudi::XYZPoint vert ) const
{
debug() << " HTBlob::PseudoCone, clusters with Angles < 0.06 will be include in the seed " << endmsg;
SmartRefVector<Minerva::IDCluster> ClusTemp = ClusVectorX; ClusVectorX.clear();
SmartRefVector<Minerva::IDCluster>::iterator itClusX;
double angle;
for ( itClusX = ClusTemp.begin(); itClusX != ClusTemp.end(); itClusX++ ){
if ( Angle( *itClusX, direction, vert, angle ) ) {
if ( angle < 0.06 && (*itClusX)->z() > vert.z() ) Seed.push_back(*itClusX); // must be carefull with backward showers
else ClusVectorX.push_back(*itClusX);
} else ClusVectorX.push_back(*itClusX);
}
debug() << endmsg;
return StatusCode::SUCCESS;
}
void AngleScan_V::completeView(SmartRefVector<Minerva::IDCluster>& unusedViewClusters,
SmartRefVector<Minerva::IDCluster>& showerCand,
double vtxT)
{
if (unusedViewClusters.empty()) return;
double z_min = 10000;
double z_max = -10000;
double angle_min = 180;
double angle_max = -180;
SmartRefVector<Minerva::IDCluster> viewShowerCand;
SmartRefVector<Minerva::IDCluster>::iterator it_view = unusedViewClusters.begin();
for (SmartRefVector<Minerva::IDCluster>::iterator c = showerCand.begin();
c != showerCand.end(); ++c){
if ( (*c)->view() == (*it_view)->view() ) viewShowerCand.push_back(*c);
if ( (*c)->view() == Minerva::IDCluster::U && (*c)->z() < z_min ) z_min = (*c)->z();
if ( (*c)->view() == Minerva::IDCluster::U && (*c)->z() > z_max ) z_max = (*c)->z();
}
if (viewShowerCand.empty()) {
std::cout << "\tAngleScan_V::completeView: no view cluster" << std::endl;
return;
}
for ( it_view = viewShowerCand.begin(); it_view != viewShowerCand.end(); ++it_view){
const double z = (*it_view)->z() - fZ;
const double u = (*it_view)->position() - vtxT;
const double ang = std::atan2(u,z)*TMath::RadToDeg();
if ( ang >= angle_max ) angle_max = ang;
if ( ang <= angle_min ) angle_min = ang;
}
z_min = z_min - 100;
z_max = z_max + 100;
angle_max = angle_max + 10.0;
angle_min = angle_min - 10.0;
/* Move clusters between (angle_min,angle_max) and (z_min,z_max) from
'unusedClusters' to blob */
std::cout << "\tAngleScan_V::completeView:oldsize: " << showerCand.size() << std::endl;
coneView(unusedViewClusters, showerCand, vtxT, angle_min, angle_max, z_min, z_max );
std::cout << "\tAngleScan_V::completeView:newsize: " << showerCand.size() << std::endl;
}
void AngleScan_V::addClustersToBlob(SmartRefVector<Minerva::IDCluster>& xshowerCand,
SmartRefVector<Minerva::IDCluster>& uclusters,
SmartRefVector<Minerva::IDCluster>& vclusters,
SmartRefVector<Minerva::IDCluster>& showerCand,
double epsilon)
{
for (SmartRefVector<Minerva::IDCluster>::iterator c = xshowerCand.begin();
c != xshowerCand.end(); ++c) {
Minerva::IDCluster* cluster_x = *c;
double min = 1e3;
SmartRefVector<Minerva::IDCluster>::iterator ucluster = uclusters.end();
SmartRefVector<Minerva::IDCluster>::iterator vcluster = vclusters.end();
for (SmartRefVector<Minerva::IDCluster>::iterator itU = uclusters.begin();
itU != uclusters.end(); ++itU) {
if (std::abs( cluster_x->z() - (*itU)->z() ) > 50.0 ) continue;
for (SmartRefVector<Minerva::IDCluster>::iterator itV = vclusters.begin();
itV != vclusters.end(); ++itV) {
if ( std::abs( cluster_x->z() - (*itV)->z() ) > 50.0 ) continue;
double delta = std::abs((*itU)->tpos1()+(*itU)->tpos2()+ /* |u+v-x| */
(*itV)->tpos1()+(*itV)->tpos2()-
cluster_x->tpos1()-cluster_x->tpos2());
if ( delta < min ) {
min = delta;
ucluster = itU;
vcluster = itV;
}
}
}
if (min <= epsilon && (ucluster != uclusters.end() && vcluster != vclusters.end())) {
showerCand.push_back(*ucluster);
showerCand.push_back(*vcluster);
uclusters.erase(ucluster);
vclusters.erase(vcluster);
}
}
}
void AngleScan_V::FormXUVShowerCand()
{
std::vector<SmartRefVector<Minerva::IDCluster> > nogrowShowerCandidates;
std::cout << "AngleScan_V::total V candidates: " << fVShowerCandidates.size() << std::endl;
for (std::vector<SmartRefVector<Minerva::IDCluster> >::iterator s
= fVShowerCandidates.begin();
s != fVShowerCandidates.end(); ++s) {
std::cout << "\tAngleScan_V::V cand: " << s->size() << std::endl;
SmartRefVector<Minerva::IDCluster>& vshowerCand = *s;
SmartRefVector<Minerva::IDCluster> showerCand = vshowerCand;
double zmin = +1e6;
double zmax = -1e6;
double ztot = 0.0;
for (SmartRefVector<Minerva::IDCluster>::iterator c = vshowerCand.begin();
c != vshowerCand.end(); ++c) {
zmin = std::min(zmin,(*c)->z());
zmax = std::max(zmax,(*c)->z());
ztot += (*c)->z();
}
if (zmax-zmin < 50.0) {
const double zcenter = ztot/vshowerCand.size();
std::cout << "\t AngleScan_V::Candidate with small z extend at: " << zcenter << std::endl;
SmartRefVector<Minerva::IDCluster> xclusters_tmp;
SmartRefVector<Minerva::IDCluster> uclusters_tmp;
fRemainingXClusters.swap(xclusters_tmp);
fRemainingUClusters.swap(uclusters_tmp);
for (SmartRefVector<Minerva::IDCluster>::iterator c = xclusters_tmp.begin();
c != xclusters_tmp.end(); ++c) {
if (std::abs((*c)->z()-zcenter) < 50.0) {
std::cout << "\t\t AngleScan_V::adding a X cluster " << (*c)->z() << " " << (*c)->pe()
<< std::endl;
showerCand.push_back(*c);
}
else fRemainingXClusters.push_back(*c);
}
for (SmartRefVector<Minerva::IDCluster>::iterator c = uclusters_tmp.begin();
c != uclusters_tmp.end(); ++c) {
if (std::abs((*c)->z()-zcenter) < 50.0) {
std::cout << "\t\t AngleScan_V::adding a U cluster " << (*c)->z() << " " << (*c)->pe()
<< std::endl;
showerCand.push_back(*c);
}
else fRemainingUClusters.push_back(*c);
}
fShowerCandidates.push_back(showerCand);
} else {
std::cout << "\t AngleScan_V::Candidate with large z extent " << std::endl;
addClustersToBlob(vshowerCand,fRemainingXClusters,fRemainingUClusters,showerCand,
fUVMatchTolerance);
if (showerCand.size() > vshowerCand.size()) fShowerCandidates.push_back(showerCand);
else if (vshowerCand.size() >= 3) nogrowShowerCandidates.push_back(vshowerCand);
else {
std::cout << "\t AngleScan_V::Throw away V shower candidate" << std::endl;
}
}
}
std::cout << "AngleScan_V::Shower candidates: " << fShowerCandidates.size() << std::endl;
std::cout << "AngleScan_V::Nogrow candidates: " << nogrowShowerCandidates.size() << std::endl;
if (fAllowUVMatchWithMoreTolerance) {
for (std::vector<SmartRefVector<Minerva::IDCluster> >::iterator s
= nogrowShowerCandidates.begin();
s != nogrowShowerCandidates.end(); ++s) {
SmartRefVector<Minerva::IDCluster>& vshowerCand = *s;
SmartRefVector<Minerva::IDCluster> showerCand = vshowerCand;
addClustersToBlob(vshowerCand,fRemainingXClusters,fRemainingUClusters,showerCand,
fUVMatchMoreTolerance);
fShowerCandidates.push_back(showerCand);
}
}
std::cout << "AngleScan_V::Shower candidates(10x): " << fShowerCandidates.size() << std::endl;
for (std::vector<SmartRefVector<Minerva::IDCluster> >::iterator s = fShowerCandidates.begin();
s != fShowerCandidates.end(); ++s) {
std::cout << "\tAngleScan_V:: cand: " << std::distance(fShowerCandidates.begin(),s) << " "
<< fRemainingXClusters.size() << " " << fRemainingUClusters.size()
<< std::endl;
completeView(fRemainingXClusters, *s, fX);
completeView(fRemainingUClusters, *s, fU);
}
std::cout << "AngleScan_V::Final showers: " << fShowerCandidates.size() << std::endl;
std::sort(fShowerCandidates.begin(), fShowerCandidates.end(), greaterShower());
std::copy(fRemainingVClusters.begin(),fRemainingVClusters.end(), std::back_inserter(fRemainingClusters));
std::copy(fRemainingXClusters.begin(),fRemainingXClusters.end(), std::back_inserter(fRemainingClusters));
std::copy(fRemainingUClusters.begin(),fRemainingUClusters.end(), std::back_inserter(fRemainingClusters));
}
//======================================================================
// XUVMatch overload
//=======================================================================
StatusCode HTBlob::XUVMatch( SmartRef<Minerva::IDCluster> Cluster, SmartRefVector<Minerva::IDCluster> &Seed,
SmartRefVector<Minerva::IDCluster> &ClusVectorU,
SmartRefVector<Minerva::IDCluster> &ClusVectorV,
double zmin, double zmax, double match) const
{
debug() << " HTBlob::XUVMatch - Overload with match = " << match <<endmsg;
SmartRefVector<Minerva::IDCluster>::iterator itClusU, itClusV;
SmartRef<Minerva::IDCluster> U, V;
double dmin = 1000, distance;
debug() << " MATCH, X cluster, pe " << Cluster->pe() << "; z " << Cluster->z() << "; position " << Cluster->position()
<< "; sum pos " << Cluster->position()+Cluster->tpos1()+Cluster->tpos2() << endmsg;
for ( itClusU = ClusVectorU.begin(); itClusU != ClusVectorU.end(); itClusU++ ){
if ( fabs( Cluster->z() - (*itClusU)->z() ) > 50 ) continue;
for ( itClusV = ClusVectorV.begin(); itClusV != ClusVectorV.end(); itClusV++ ) {
if ( fabs( Cluster->z() - (*itClusV)->z() ) > 50 ) continue;
distance = Cluster->position()+Cluster->tpos1()+Cluster->tpos2();
distance -= ((*itClusU)->position()+(*itClusU)->tpos1()+(*itClusU)->tpos2());
distance -= ((*itClusV)->position()+(*itClusV)->tpos1()+(*itClusV)->tpos2());
distance = fabs(distance);
if ( distance < dmin) {
debug() << " MATCH Cand. " << " U, pe " << (*itClusU)->pe() << "; z " << (*itClusU)->z()
<< "; position " << (*itClusU)->position()
<< "; sum pos " << (*itClusU)->position()+(*itClusU)->tpos1()+(*itClusU)->tpos2() << endmsg;
debug() << " V, pe " << (*itClusV)->pe() << "; z " << (*itClusV)->z()
<< "; position " << (*itClusV)->position()
<< "; sum pos " << (*itClusV)->position()+(*itClusV)->tpos1()+(*itClusV)->tpos2()
<< endmsg;
dmin = distance;
U = *itClusU;
V = *itClusV;
}
}
}
double efmatch = fabs(zmax-zmin) < 190 ? match*2 : match; // High angles or shorts?
if ( dmin <= efmatch && Cluster->z() >= zmin && Cluster->z() <= zmax ) {
debug() << " FOUND MATCH " << U << " " << V << " Match " << efmatch << endmsg;
SmartRefVector<Minerva::IDCluster>::iterator itU, itV;
itU = remove(ClusVectorU.begin(),ClusVectorU.end(),U); // move elements to the end to can erase
itV = remove(ClusVectorV.begin(),ClusVectorV.end(),V);
ClusVectorU.erase(itU,ClusVectorU.end()); // found it in doxygen
ClusVectorV.erase(itV,ClusVectorV.end()); // found it in doxygen
Seed.push_back(U);
Seed.push_back(V);
}
return StatusCode::SUCCESS;
}