CDCStateFilterFactory Class Reference

Factory that can create appropriate cluster filters from associated names. More...

#include <CDCStateFilterFactory.h>

Inheritance diagram for CDCStateFilterFactory:

Public Types
using	CreatedFilter = BaseCDCStateFilter
	Type of the filter that this factory creates.

Public Member Functions
	CDCStateFilterFactory (const std::string &defaultFilterName="all")
	Constructor forwarding the default filter name.
	~CDCStateFilterFactory ()
	Default destructor.
std::string	getIdentifier () const override
	Getter for a short identifier for the factory.
std::string	getFilterPurpose () const override
	Getter for a descriptive purpose of the constructed filters.
std::map< std::string, std::string >	getValidFilterNamesAndDescriptions () const override
	Getter for valid filter names and a description for each.
std::unique_ptr< BaseCDCStateFilter >	create (const std::string &filterName) const override
	Create a filter with the given name.
virtual std::string	createFiltersNameDescription () const
	Create a string with a description mentioning the names of the chooseable filter.
virtual std::string	createFiltersParametersDescription () const
	Create a string with a description mentioning the parameters of the chooseable filter.
const std::string &	getDefaultFilterName () const
	Legacy - Return the default filter suggested by the factory.

Private Types
using	Super = TrackFindingCDC::FilterFactory< BaseCDCStateFilter >
	Type of the base class.

Private Attributes
std::string	m_defaultFilterName
	Legacy - Default filter name suggested by this factory.

Detailed Description

Factory that can create appropriate cluster filters from associated names.

Definition at line 19 of file CDCStateFilterFactory.h.

Member Typedef Documentation

CreatedFilter

using CreatedFilter = BaseCDCStateFilter

inherited

Type of the filter that this factory creates.

Definition at line 29 of file FilterFactory.dcl.h.

Super

using Super = TrackFindingCDC::FilterFactory<BaseCDCStateFilter>

private

Type of the base class.

Definition at line 23 of file CDCStateFilterFactory.h.

Constructor & Destructor Documentation

CDCStateFilterFactory()

CDCStateFilterFactory ( const std::string &  defaultFilterName = "all" )

explicit

Constructor forwarding the default filter name.

Definition at line 42 of file CDCStateFilterFactory.cc.

  : Super(defaultFilterName)
{
}

Member Function Documentation

create()

std::unique_ptr< BaseCDCStateFilter > create ( const std::string &  filterName ) const

overridevirtual

Create a filter with the given name.

Reimplemented from FilterFactory< BaseCDCStateFilter >.

Definition at line 80 of file CDCStateFilterFactory.cc.

{
  if (filterName == "none") {
    return std::make_unique<TrackFindingCDC::NoneFilter<BaseCDCStateFilter>>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "all") {
    return std::make_unique<TrackFindingCDC::AllFilter<BaseCDCStateFilter>>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "rough") {
    return std::make_unique<RoughCDCStateFilter>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "rough_eclSeed") {
    return std::make_unique<RoughCDCfromEclStateFilter>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "mc_truth") {
    return std::make_unique<MCTruthCDCStateFilter>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "mc_truth_eclSeed") {
    return std::make_unique<MCTruthEclSeedFilter>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "extrapolate_and_update") {
    return std::make_unique<ExtrapolateAndUpdateCDCStateFilter>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "distance") {
    return std::make_unique<DistanceCDCStateFilter>();
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "recording") {
    return std::make_unique<RecordingCDCStateFilter>("CDCStateFilter.root");
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "rough_and_recording") {
    return std::make_unique<AndCDCStateFilter>(
             std::make_unique<RecordingCDCStateFilter>("CDCStateFilter.root"),
             std::make_unique<RoughCDCStateFilter>()
           );
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "recording_eclSeed") {
    return std::make_unique<RecordingCDCfromEclStateFilter>("CDCfromECLStateFilter.root");
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "rough_and_recording_eclSeed") {
    return std::make_unique<AndCDCStateFilter>(
             std::make_unique<RecordingCDCfromEclStateFilter>("CDCfromECLStateFilter.root"),
             std::make_unique<RoughCDCfromEclStateFilter>()
           );
    // cppcheck-suppress knownConditionTrueFalse
  } else if (filterName == "distance_and_recording_eclSeed") {
    return std::make_unique<AndCDCStateFilter>(
             std::make_unique<RecordingCDCfromEclStateFilter>("CDCfromECLStateFilter.root"),
             std::make_unique<DistanceCDCStateFilter>()
           );
  } else {
    return Super::create(filterName);
  }
}

createFiltersNameDescription()

std::string createFiltersNameDescription

virtualinherited

Create a string with a description mentioning the names of the chooseable filter.

Definition at line 56 of file FilterFactory.icc.h.

    {
      // Compose description for the filter names
      std::ostringstream oss;
      oss << this->getFilterPurpose();
      oss << "Allowed values are: ";
      std::vector<std::string> filterNameAndDescriptions;
      for (const auto& filterNameAndDescription : this->getValidFilterNamesAndDescriptions()) {
        const std::string& filterName = filterNameAndDescription.first;
        const std::string& filterDescription = filterNameAndDescription.second;
        filterNameAndDescriptions.push_back(quoted(filterName) + " " + bracketed(filterDescription));
      }
      oss << join(", ", filterNameAndDescriptions);
      return oss.str();
    }

createFiltersParametersDescription()

std::string createFiltersParametersDescription

virtualinherited

Create a string with a description mentioning the parameters of the chooseable filter.

Definition at line 59 of file FilterFactory.icc.h.

    {
      // Compose description for the filter parameters
      std::ostringstream oss;
      oss << "Key -- value pairs depending on the filter." << std::endl;
      for (const auto& filterNameAndDescription : this->getValidFilterNamesAndDescriptions()) {
 
        const std::string& filterName = filterNameAndDescription.first;
        // const std::string& filterDescription = filterNameAndDescription.second;
 
        std::unique_ptr<AFilter> filter = this->create(filterName);
        if (not filter) {
          B2WARNING("Could not create a filter for name " << filterName);
          continue;
        }
 
        ModuleParamList moduleParamList;
        const std::string prefix = "";
        filter->exposeParameters(&moduleParamList, prefix);
 
        std::map<std::string, std::string> filterParameters;
        for (auto && name : moduleParamList.getParameterNames()) {
          filterParameters[name] = moduleParamList.getParameterDescription(name);
        }
 
        oss << quoted(filterName) << " :\n";
        if (filterParameters.empty()) {
          oss << "(no parameters)";
        } else {
          std::vector<std::string> parameterDescriptions;
          for (const auto& parameterNameAndDescription : filterParameters) {
            const std::string& parameterName = parameterNameAndDescription.first;
            const std::string& parameterDescription = parameterNameAndDescription.second;
            parameterDescriptions.push_back(parameterName + " -- " + parameterDescription);
          }
          oss << join(",\n", parameterDescriptions);
        }
        oss << ";\n";
      }
      return oss.str();
    }

getDefaultFilterName()

const std::string & getDefaultFilterName

inherited

Legacy - Return the default filter suggested by the factory.

Definition at line 63 of file FilterFactory.icc.h.

    {
      return m_defaultFilterName;
    }

getFilterPurpose()

std::string getFilterPurpose ( ) const

overridevirtual

Getter for a descriptive purpose of the constructed filters.

Implements FilterFactory< BaseCDCStateFilter >.

Definition at line 54 of file CDCStateFilterFactory.cc.

{
  return "Reject CDC CKF states. ";
}

getIdentifier()

std::string getIdentifier ( ) const

overridevirtual

Getter for a short identifier for the factory.

Implements FilterFactory< BaseCDCStateFilter >.

Definition at line 49 of file CDCStateFilterFactory.cc.

{
  return "CDCState";
}

getValidFilterNamesAndDescriptions()

std::map< std::string, std::string > getValidFilterNamesAndDescriptions ( ) const

overridevirtual

Getter for valid filter names and a description for each.

Implements FilterFactory< BaseCDCStateFilter >.

Definition at line 59 of file CDCStateFilterFactory.cc.

{
  return {
    {"none", "no track combination is valid"},
    {"all", "set all track combinations as good"},
    {"mc_truth", "filtering based on the mc truth information"},
    {"mc_truth_eclSeed", "filtering based on the mc truth information"},
    {"rough", "very rough filtering"},
    {"rough_eclSeed", "very rough filtering, seed created from ECL shower"},
    {"extrapolate_and_update", "Extrapolation and update"},
    {"distance", "Give a weight based on the distance"},
    {"recording", "record variables to a TTree"},
    {"recording_eclSeed", "record variables to a TTree"},
    {"rough_and_recording", "very rough filtering, seed created from SVD track"},
    {"rough_and_recording_eclSeed", "very rough filtering, seed created from ECL shower"},
    {"distance_and_recording_eclSeed", "Give a weight based on the distance"},
 
  };
}

Member Data Documentation

m_defaultFilterName

std::string m_defaultFilterName

privateinherited

Legacy - Default filter name suggested by this factory.

Definition at line 67 of file FilterFactory.dcl.h.

---

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

• tracking/ckf/cdc/filters/states/include/CDCStateFilterFactory.h
• tracking/ckf/cdc/filters/states/src/CDCStateFilterFactory.cc