DelphesSimulation::DelphesSimulation(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc) ,
m_DelphesCard(),
m_Delphes(nullptr),
m_hepMCConverter(nullptr),
m_eventCounter(0),
m_outRootFile(nullptr),
m_outRootFileName(""),
m_treeWriter(nullptr),
m_branchEvent(nullptr),
m_confReader(nullptr),
m_allParticles(nullptr),
m_stableParticles(nullptr),
m_partons(nullptr)
{
//declareProperty("filename", m_filename="" , "Name of the HepMC file to read");
declareProperty("DelphesCard" , m_DelphesCard , "Name of Delphes tcl config file with detector and simulation parameters");
declareProperty("ROOTOutputFile" , m_outRootFileName , "Name of Delphes Root output file, if defined, the Delphes standard tree write out (in addition to FCC-EDM based output to transient data store)");
declareInput("hepmc", m_hepmcHandle);
declareProperty("outputs", m_saveToolNames);
declareOutput("genParticles" , m_handleGenParticles, "genParticles");
declareOutput("genVertices" , m_handleGenVertices, "genVertices");
}
G4SaveSmearedParticles::G4SaveSmearedParticles(const std::string& aType, const std::string& aName, const IInterface* aParent) :
AlgTool(aType, aName, aParent) {
declareInterface<IG4SaveOutputTool>(this);
declareOutput("particles", m_particles,"particles/smearedParticles");
declareOutput("particlesMCparticles", m_particlesMCparticles,"particles/smearedParticles");
// needed for AlgTool wit output/input until it appears in Gaudi AlgTool constructor
declareProperty("DataInputs", inputDataObjects());
declareProperty("DataOutputs", outputDataObjects());
}
G4SaveCalHits::G4SaveCalHits(const std::string& aType, const std::string& aName, const IInterface* aParent) :
GaudiTool(aType, aName, aParent) {
declareInterface<IG4SaveOutputTool>(this);
declareProperty("caloType", m_calType);
declareOutput("caloClusters", m_caloClusters,"hits/caloClusters");
declareOutput("caloHits", m_caloHits,"hits/caloHits");
// needed for AlgTool wit output/input until it appears in Gaudi AlgTool constructor
declareProperty("DataInputs", inputDataObjects());
declareProperty("DataOutputs", outputDataObjects());
}
DelphesSaveGenJets::DelphesSaveGenJets(const std::string& aType, const std::string& aName, const IInterface* aParent) :
GaudiTool(aType, aName, aParent) {
declareInterface<IDelphesSaveOutputTool>(this);
declareOutput("genJets", m_genJets);
declareOutput("genJetsFlavorTagged", m_taggedGenJets);
declareProperty("delphesArrayName", m_delphesArrayName);
// needed for AlgTool wit output/input until it appears in Gaudi AlgTool constructor
declareProperty("DataInputs", inputDataObjects());
declareProperty("DataOutputs", outputDataObjects());
}
Key::Key() : AlgorithmComposite() {
_keyAlgo = standard::AlgorithmFactory::create("Key");
_poolStorage = new PoolStorage<std::vector<Real> >(&_pool, "internal.hpcp");
declareInput(_poolStorage->input("data"), 1, "pcp", "the input pitch class profile");
declareOutput(_key, 0, "key", "the estimated key, from A to G");
declareOutput(_scale, 0, "scale", "the scale of the key (major or minor)");
declareOutput(_strength, 0, "strength", "the strength of the estimated key");
}
SimG4SaveTrackerHits::SimG4SaveTrackerHits(const std::string& aType, const std::string& aName, const IInterface* aParent) :
GaudiTool(aType, aName, aParent) {
declareInterface<ISimG4SaveOutputTool>(this);
declareProperty("readoutNames", m_readoutNames);
declareOutput("trackClusters", m_trackClusters,"hits/trackerClusters");
declareOutput("trackHits", m_trackHits,"hits/trackerHits");
declareOutput("trackHitsClusters", m_trackHitsClusters,"hits/trackerAssociations");
// needed for AlgTool wit output/input until it appears in Gaudi AlgTool constructor
declareProperty("DataInputs", inputDataObjects());
declareProperty("DataOutputs", outputDataObjects());
}
CreateCaloCells::CreateCaloCells(const std::string& name, ISvcLocator* svcLoc)
: GaudiAlgorithm(name, svcLoc)
{
declareInput("hits", m_hits,"hits");
declareOutput("cells", m_cells,"cells");
declareProperty("mergeTool",m_mergeTool);
declarePrivateTool(m_mergeTool,"MergeCaloHitsTool");
declareProperty("calibTool",m_calibTool);
declarePrivateTool(m_calibTool,"CalibrateCaloHitsTool");
declareProperty("noiseTool",m_noiseTool);
declarePrivateTool(m_noiseTool,"NoiseCaloCellsTool");
declareProperty("doCellCalibration",m_doCellCalibration=true);
declareProperty("addCellNoise",m_addCellNoise=true);
declareProperty("filterCellNoise",m_filterCellNoise=false);
//PhiEta segmentation required
declareProperty("readoutName", m_readoutName="ECalHitsPhiEta");
declareProperty("activeVolumeName", m_activeVolumeName="LAr");
//number of volumes with active material which are not readout
declareProperty("numVolumesRemove",m_numVolumesRemove=0);
declareProperty("activeFieldName", m_activeFieldName="active_layer");
declareProperty("fieldNames", m_fieldNames);
declareProperty("fieldValues", m_fieldValues);
}
GenParticleFilter::GenParticleFilter(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc)
{
declareProperty("accept", m_accept, {1});
declareInput("genparticles", m_iGenpHandle);
declareOutput("genparticles", m_oGenpHandle);
}
AudioOnsetsMarker::AudioOnsetsMarker() : Algorithm(), _beep(false) {
_preferredSize = 4096;
_onsetIdx = 0;
_processedSamples = 0;
_burstIdx = 0;
declareInput(_input, _preferredSize, "signal", "the input signal");
declareOutput(_output, _preferredSize, "signal", "the input signal mixed with bursts at onset locations");
}
CreatePositionedHit::CreatePositionedHit(const std::string& name, ISvcLocator* svcLoc)
: GaudiAlgorithm(name, svcLoc) {
declareInput("caloCells", m_caloCells,"caloCells");
declareOutput("caloPositionedHits", m_caloPositionedHits,"caloPositionedHits");
declareProperty("readoutName", m_readoutName="ECalHitsNew");
declareProperty("activeFieldName", m_activeFieldName="active_layer");
declareProperty("activeVolumeName", m_activeVolumeName="LAr_sensitive");
}
MergeCells::MergeCells(const std::string& aName, ISvcLocator* aSvcLoc):
GaudiAlgorithm(aName, aSvcLoc){
declareInput("inhits", m_inHits,"hits/caloInHits");
declareOutput("outhits", m_outHits,"hits/caloOutHits");
declareProperty("readout", m_readoutName);
declareProperty("identifier", m_idToMerge);
declareProperty("merge", m_numToMerge = 0);
declareProperty("debugPrint", m_debugPrint = 10);
}
void Algorithm::declareOutput(SourceBase& source,
int acquireSize,
int releaseSize,
const std::string& name,
const std::string& desc) {
source.setAcquireSize(acquireSize);
source.setReleaseSize(releaseSize);
declareOutput(source, name, desc);
}
ChordsDetection::ChordsDetection() : AlgorithmComposite() {
declareInput(_pcp, "pcp", "the pitch class profile from which to detect the chord");
declareOutput(_chords, 1, "chords", "the resulting chords, from A to G");
declareOutput(_strength, 1, "strength", "the strength of the chord");
_chordsAlgo = standard::AlgorithmFactory::create("Key");
_chordsAlgo->configure("profileType", "tonictriad", "usePolyphony", false);
_poolStorage = new PoolStorage<vector<Real> >(&_pool, "internal.hpcp");
// FIXME: this is just a temporary hack...
// the correct way to do this is to have the algorithm output the chords
// continuously while processing, which requires a FrameCutter for vectors
// Need to set the buffer type to multiple frames as all the chords
// are output all at once
_chords.setBufferType(BufferUsage::forMultipleFrames);
_strength.setBufferType(BufferUsage::forMultipleFrames);
attach(_pcp, _poolStorage->input("data"));
}
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
ParticleGunAlg::ParticleGunAlg( const std::string& name,
ISvcLocator* pSvcLocator)
: GaudiAlgorithm ( name , pSvcLocator ) ,
m_particleGunTool ( nullptr ),
m_vertexSmearTool ( nullptr )
{
// Generation Method
declareProperty ( "ParticleGunTool" ,
m_particleGunToolName = "GenericGun" ) ;
declareProperty ( "VertexSmearingTool" ,
m_vertexSmearingToolName = "" ) ;
declareOutput("hepmc", m_hepmchandle);
}
void SilenceRate::configure() {
_thresholds = parameter("thresholds").toVectorReal();
clearOutputs();
for (int i=0; i<int(_thresholds.size()); ++i) {
_outputs.push_back(new Source<Real>());
ostringstream outputName;
outputName << "threshold_" << i;
ostringstream thresholdIndex;
thresholdIndex << i;
declareOutput(*_outputs.back(), 1, outputName.str(),
"the silence rate for threshold #" + thresholdIndex.str());
}
}
ChordsDetection::ChordsDetection() : AlgorithmComposite() {
declareInput(_pcp, "pcp", "the pitch class profile from which to detect the chord");
declareOutput(_chords, 1, "chords", "the resulting chords, from A to G");
declareOutput(_strength, 1, "strength", "the strength of the chord");
_chordsAlgo = standard::AlgorithmFactory::create("Key");
_chordsAlgo->configure("profileType", "tonictriad", "usePolyphony", false);
_poolStorage = new PoolStorage<vector<Real> >(&_pool, "internal.hpcp");
// FIXME: this is just a temporary hack...
// the correct way to do this is to have the algorithm output the chords
// continuously while processing, which requires a FrameCutter for vectors
_chords.setBufferType(BufferUsage::forLargeAudioStream);
_strength.setBufferType(BufferUsage::forLargeAudioStream);
// Some old buffer settings that were not enough for long audio
//BufferInfo binfo;
//binfo.size = 16384;
//binfo.maxContiguousElements = 0;
//_chords.setBufferInfo(binfo);
//_strength.setBufferInfo(binfo);
attach(_pcp, _poolStorage->input("data"));
}
AlbersWrite::AlbersWrite(const std::string& name, ISvcLocator* svcLoc) :
GaudiAlgorithm(name, svcLoc)
{
declareOutput("albersJets", m_jethandle);
}
DummySimulation::DummySimulation(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc) {
declareInput("genparticles", m_genphandle);
declareOutput("particles", m_recphandle);
}
void Algorithm::declareOutput(SourceBase& source, int n, const std::string& name, const std::string& desc) {
declareOutput(source, n, n, name, desc);
}
PythiaInterface::PythiaInterface(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc), m_pythia( nullptr ), m_parfile()
{
declareProperty("Filename", m_parfile="", "Name of the Pythia parameter file to read");
declareOutput("hepmc", m_hepmchandle);
}
