Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Running code-format for simulation #26791

Merged
merged 1 commit into from May 16, 2019
Merged

Running code-format for simulation #26791

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
121 changes: 61 additions & 60 deletions Mixing/Base/interface/BMixingModule.h
View file
Open in desktop
Expand Up @@ -35,81 +35,82 @@ namespace edm {
std::vector<std::string> sourceNames_;
std::vector<std::shared_ptr<PileUpConfig>> inputConfigs_;
};
}
} // namespace MixingCache

class BMixingModule : public stream::EDProducer<GlobalCache<MixingCache::Config>> {
public:
/** standard constructor*/
explicit BMixingModule(const edm::ParameterSet& ps, MixingCache::Config const* globalConf);
public:
/** standard constructor*/
explicit BMixingModule(const edm::ParameterSet& ps, MixingCache::Config const* globalConf);

/**Default destructor*/
~BMixingModule() override;
/**Default destructor*/
~BMixingModule() override;

/**Cumulates the pileup events onto this event*/
void produce(edm::Event& e1, const edm::EventSetup& c) override;
/**Cumulates the pileup events onto this event*/
void produce(edm::Event& e1, const edm::EventSetup& c) override;

virtual void initializeEvent(const edm::Event& event, const edm::EventSetup& setup) {}
virtual void initializeEvent(const edm::Event& event, const edm::EventSetup& setup) {}

// edm::Event is non-const because digitizers put their products into the Event.
virtual void finalizeEvent(edm::Event& event, const edm::EventSetup& setup) {}
// edm::Event is non-const because digitizers put their products into the Event.
virtual void finalizeEvent(edm::Event& event, const edm::EventSetup& setup) {}

void beginRun(const edm::Run& r, const edm::EventSetup& setup) override;
void beginLuminosityBlock(const edm::LuminosityBlock& l, const edm::EventSetup& setup) override;
void beginRun(const edm::Run& r, const edm::EventSetup& setup) override;
void beginLuminosityBlock(const edm::LuminosityBlock& l, const edm::EventSetup& setup) override;

void endRun(const edm::Run& r, const edm::EventSetup& setup) override;
void endLuminosityBlock(const edm::LuminosityBlock& l, const edm::EventSetup& setup) override;
void endRun(const edm::Run& r, const edm::EventSetup& setup) override;
void endLuminosityBlock(const edm::LuminosityBlock& l, const edm::EventSetup& setup) override;

static std::unique_ptr<MixingCache::Config> initializeGlobalCache(edm::ParameterSet const&);
static void globalEndJob(MixingCache::Config*) {}
static std::unique_ptr<MixingCache::Config> initializeGlobalCache(edm::ParameterSet const&);
static void globalEndJob(MixingCache::Config*) {}

// to be overloaded by dependent class
virtual void reload(const edm::EventSetup & setup){};
// to be overloaded by dependent class
virtual void reload(const edm::EventSetup& setup){};

// Should 'averageNumber' return 0 or 1 if there is no mixing? It is the average number of
// *crossings*, including the hard scatter, or the average number of overlapping events?
// We have guessed 'overlapping events'.
double averageNumber() const {return inputSources_[0] ? inputSources_[0]->averageNumber() : 0.0; }
// Should 'poisson' return 0 or 1 if there is no mixing? See also averageNumber above.
bool poisson() const {return inputSources_[0] ? inputSources_[0]->poisson() : 0.0 ;}
// Should 'averageNumber' return 0 or 1 if there is no mixing? It is the average number of
// *crossings*, including the hard scatter, or the average number of overlapping events?
// We have guessed 'overlapping events'.
double averageNumber() const { return inputSources_[0] ? inputSources_[0]->averageNumber() : 0.0; }
// Should 'poisson' return 0 or 1 if there is no mixing? See also averageNumber above.
bool poisson() const { return inputSources_[0] ? inputSources_[0]->poisson() : 0.0; }

virtual void createnewEDProduct();
virtual void checkSignal(const edm::Event &e);
virtual void addSignals(const edm::Event &e,const edm::EventSetup& c) {}
virtual void addPileups(const int bcr, EventPrincipal *ep, unsigned int eventId,unsigned int worker, const edm::EventSetup& c) {}
virtual void setBcrOffset ();
virtual void setSourceOffset (const unsigned int s);
virtual void put(edm::Event &e,const edm::EventSetup& c) {}
virtual void doPileUp(edm::Event &e, const edm::EventSetup& c);
virtual void createnewEDProduct();
virtual void checkSignal(const edm::Event& e);
virtual void addSignals(const edm::Event& e, const edm::EventSetup& c) {}
virtual void addPileups(
const int bcr, EventPrincipal* ep, unsigned int eventId, unsigned int worker, const edm::EventSetup& c) {}
virtual void setBcrOffset();
virtual void setSourceOffset(const unsigned int s);
virtual void put(edm::Event& e, const edm::EventSetup& c) {}
virtual void doPileUp(edm::Event& e, const edm::EventSetup& c);

protected:
void setupPileUpEvent(const edm::EventSetup& setup);
void dropUnwantedBranches(std::vector<std::string> const& wantedBranches);
void beginStream(edm::StreamID) override;
void endStream() override;
// std::string type_;
int bunchSpace_;
int vertexOffset_;
bool checktof_;
int minBunch_;
int maxBunch_;
bool const mixProdStep1_;
bool const mixProdStep2_;
bool readDB_;
bool playback_;
const static unsigned int maxNbSources_;
bool doit_[4];//FIXME
std::vector< float > TrueNumInteractions_;

unsigned int eventId_;

// input, cosmics, beamhalo_plus, beamhalo_minus
std::vector<std::shared_ptr<PileUp>> inputSources_;

void update(edm::EventSetup const&);
edm::ESWatcher<MixingRcd> parameterWatcher_;
void setupPileUpEvent(const edm::EventSetup& setup);
void dropUnwantedBranches(std::vector<std::string> const& wantedBranches);
void beginStream(edm::StreamID) override;
void endStream() override;
// std::string type_;
int bunchSpace_;
int vertexOffset_;
bool checktof_;
int minBunch_;
int maxBunch_;
bool const mixProdStep1_;
bool const mixProdStep2_;

bool readDB_;
bool playback_;
const static unsigned int maxNbSources_;
bool doit_[4]; //FIXME
std::vector<float> TrueNumInteractions_;

unsigned int eventId_;

// input, cosmics, beamhalo_plus, beamhalo_minus
std::vector<std::shared_ptr<PileUp>> inputSources_;

void update(edm::EventSetup const&);
edm::ESWatcher<MixingRcd> parameterWatcher_;
};

}//edm
} // namespace edm

#endif
121 changes: 67 additions & 54 deletions Mixing/Base/interface/PileUp.h
View file
Open in desktop
Expand Up @@ -21,7 +21,7 @@ namespace CLHEP {
class RandPoissonQ;
class RandPoisson;
class HepRandomEngine;
}
} // namespace CLHEP

namespace edm {
class SecondaryEventProvider;
Expand All @@ -30,7 +30,7 @@ namespace edm {

struct PileUpConfig {
PileUpConfig(std::string sourcename, double averageNumber, std::unique_ptr<TH1F>& histo, const bool playback)
: sourcename_(sourcename), averageNumber_(averageNumber), histo_(histo.release()), playback_(playback) {}
: sourcename_(sourcename), averageNumber_(averageNumber), histo_(histo.release()), playback_(playback) {}
std::string sourcename_;
double averageNumber_;
std::shared_ptr<TH1F> histo_;
Expand All @@ -42,23 +42,32 @@ namespace edm {
explicit PileUp(ParameterSet const& pset, const std::shared_ptr<PileUpConfig>& config);
~PileUp();

template<typename T>
void readPileUp(edm::EventID const& signal, std::vector<edm::SecondaryEventIDAndFileInfo>& ids, T eventOperator, int const NumPU, StreamID const&);

template<typename T>
void playPileUp(std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator begin, std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator end, std::vector<edm::SecondaryEventIDAndFileInfo>& ids, T eventOperator);

template<typename T>
void playOldFormatPileUp(std::vector<edm::EventID>::const_iterator begin, std::vector<edm::EventID>::const_iterator end, std::vector<edm::SecondaryEventIDAndFileInfo>& ids, T eventOperator);

double averageNumber() const {return averageNumber_;}
bool poisson() const {return poisson_;}
bool doPileUp( int BX ) {
if(Source_type_ != "cosmics") {
return none_ ? false : averageNumber_>0.;
}
else {
return ( BX >= minBunch_cosmics_ && BX <= maxBunch_cosmics_);
template <typename T>
void readPileUp(edm::EventID const& signal,
std::vector<edm::SecondaryEventIDAndFileInfo>& ids,
T eventOperator,
int const NumPU,
StreamID const&);

template <typename T>
void playPileUp(std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator begin,
std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator end,
std::vector<edm::SecondaryEventIDAndFileInfo>& ids,
T eventOperator);

template <typename T>
void playOldFormatPileUp(std::vector<edm::EventID>::const_iterator begin,
std::vector<edm::EventID>::const_iterator end,
std::vector<edm::SecondaryEventIDAndFileInfo>& ids,
T eventOperator);

double averageNumber() const { return averageNumber_; }
bool poisson() const { return poisson_; }
bool doPileUp(int BX) {
if (Source_type_ != "cosmics") {
return none_ ? false : averageNumber_ > 0.;
} else {
return (BX >= minBunch_cosmics_ && BX <= maxBunch_cosmics_);
}
}
void dropUnwantedBranches(std::vector<std::string> const& wantedBranches) {
Expand All @@ -75,24 +84,27 @@ namespace edm {

void setupPileUpEvent(const edm::EventSetup& setup);

void reload(const edm::EventSetup & setup);
void reload(const edm::EventSetup& setup);

void CalculatePileup(int MinBunch, int MaxBunch, std::vector<int>& PileupSelection, std::vector<float>& TrueNumInteractions, StreamID const&);
void CalculatePileup(int MinBunch,
int MaxBunch,
std::vector<int>& PileupSelection,
std::vector<float>& TrueNumInteractions,
StreamID const&);

//template<typename T>
// void recordEventForPlayback(EventPrincipal const& eventPrincipal,
// std::vector<edm::SecondaryEventIDAndFileInfo> &ids, T& eventOperator);
// std::vector<edm::SecondaryEventIDAndFileInfo> &ids, T& eventOperator);

const unsigned int & input()const{return inputType_;}
void input(unsigned int s){inputType_=s;}
const unsigned int& input() const { return inputType_; }
void input(unsigned int s) { inputType_ = s; }

private:

std::unique_ptr<CLHEP::RandPoissonQ> const& poissonDistribution(StreamID const& streamID);
std::unique_ptr<CLHEP::RandPoisson> const& poissonDistr_OOT(StreamID const& streamID);
CLHEP::HepRandomEngine* randomEngine(StreamID const& streamID);

unsigned int inputType_;
unsigned int inputType_;
std::string type_;
std::string Source_type_;
double averageNumber_;
Expand All @@ -110,9 +122,8 @@ namespace edm {
bool PU_Study_;
std::string Study_type_;


int intFixed_OOT_;
int intFixed_ITPU_;
int intFixed_OOT_;
int intFixed_ITPU_;

int minBunch_cosmics_;
int maxBunch_cosmics_;
Expand All @@ -134,30 +145,27 @@ namespace edm {
//TH1F *h1f;
//TH1F *hprobFunction;
//TFile *probFileHisto;

//playback info
bool playback_;

// sequential reading
bool sequential_;
};



template<typename T>
class RecordEventID
{
template <typename T>
class RecordEventID {
private:
std::vector<edm::SecondaryEventIDAndFileInfo>& ids_;
T& eventOperator_;
int eventCount ;
int eventCount;

public:
RecordEventID(std::vector<edm::SecondaryEventIDAndFileInfo>& ids, T& eventOperator)
: ids_(ids), eventOperator_(eventOperator), eventCount(1) {
}
: ids_(ids), eventOperator_(eventOperator), eventCount(1) {}
bool operator()(EventPrincipal const& eventPrincipal, size_t fileNameHash) {
bool used = eventOperator_(eventPrincipal, eventCount);
if(used) {
if (used) {
++eventCount;
ids_.emplace_back(eventPrincipal.id(), fileNameHash);
}
Expand All @@ -175,39 +183,44 @@ namespace edm {
* The "signal" event is optionally used to restrict
* the secondary events used for pileup and mixing.
*/
template<typename T>
void
PileUp::readPileUp(edm::EventID const& signal, std::vector<edm::SecondaryEventIDAndFileInfo>& ids, T eventOperator,
int const pileEventCnt, StreamID const& streamID) {

template <typename T>
void PileUp::readPileUp(edm::EventID const& signal,
std::vector<edm::SecondaryEventIDAndFileInfo>& ids,
T eventOperator,
int const pileEventCnt,
StreamID const& streamID) {
// One reason PileUp is responsible for recording event IDs is
// that it is the one that knows how many events will be read.
ids.reserve(pileEventCnt);
RecordEventID<T> recorder(ids,eventOperator);
RecordEventID<T> recorder(ids, eventOperator);
int read = 0;
CLHEP::HepRandomEngine* engine = (sequential_ ? nullptr : randomEngine(streamID));
read = input_->loopOverEvents(*eventPrincipal_, fileNameHash_, pileEventCnt, recorder, engine, &signal);
if (read != pileEventCnt)
edm::LogWarning("PileUp") << "Could not read enough pileup events: only " << read << " out of " << pileEventCnt << " requested.";
edm::LogWarning("PileUp") << "Could not read enough pileup events: only " << read << " out of " << pileEventCnt
<< " requested.";
}

template<typename T>
void
PileUp::playPileUp(std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator begin, std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator end, std::vector<edm::SecondaryEventIDAndFileInfo>& ids, T eventOperator) {
template <typename T>
void PileUp::playPileUp(std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator begin,
std::vector<edm::SecondaryEventIDAndFileInfo>::const_iterator end,
std::vector<edm::SecondaryEventIDAndFileInfo>& ids,
T eventOperator) {
//TrueNumInteractions.push_back( end - begin ) ;
RecordEventID<T> recorder(ids, eventOperator);
input_->loopSpecified(*eventPrincipal_, fileNameHash_, begin, end, recorder);
}

template<typename T>
void
PileUp::playOldFormatPileUp(std::vector<edm::EventID>::const_iterator begin, std::vector<edm::EventID>::const_iterator end, std::vector<edm::SecondaryEventIDAndFileInfo>& ids, T eventOperator) {
template <typename T>
void PileUp::playOldFormatPileUp(std::vector<edm::EventID>::const_iterator begin,
std::vector<edm::EventID>::const_iterator end,
std::vector<edm::SecondaryEventIDAndFileInfo>& ids,
T eventOperator) {
//TrueNumInteractions.push_back( end - begin ) ;
RecordEventID<T> recorder(ids, eventOperator);
input_->loopSpecified(*eventPrincipal_, fileNameHash_, begin, end, recorder);
}

}

} // namespace edm

#endif