int main(int argc, char **argv)
{
get_ngram().read(argc == 2 ? argv[1] : "ngram");
dic_init();
warch.load("wordlist");
int count = 0;
while (!cin.eof()) {
if (++count % 200 == 0) cerr << count << endl;
Lattice l;
cin >> l;
WordDAG dag(&l);
Path p;
PFS pfs;
pfs.search(dag,p);
Segmentation seg;
if (p.empty() || p.size() <= 2)
continue;
seg.resize(p.size()-2);
copy(p.begin()+1,p.end()-1,seg.begin());
seg.we = l.we;
cout << seg << endl;
}
return 0;
}
KeyDetectionResult KeyFinder::keyOfChromagram(
Workspace& workspace,
const Parameters& params
) const {
KeyDetectionResult result;
// working copy of chromagram
Chromagram* ch = new Chromagram(*workspace.chroma);
ch->reduceToOneOctave();
// get harmonic change signal and segment
Segmentation segmenter;
std::vector<unsigned int> segmentBoundaries = segmenter.getSegmentationBoundaries(ch, params);
segmentBoundaries.push_back(ch->getHops()); // sentinel
// get key estimates for each segment
KeyClassifier classifier(
params.getSimilarityMeasure(),
params.getToneProfile(),
params.getOffsetToC(),
params.getCustomToneProfile()
);
std::vector<float> keyWeights(24); // TODO: not ideal using int cast of key_t enum. Hash?
for (int s = 0; s < (signed) segmentBoundaries.size() - 1; s++) {
KeyDetectionResultSegment segment;
segment.firstHop = segmentBoundaries[s];
segment.lastHop = segmentBoundaries[s+1] - 1;
// collapse segment's time dimension
std::vector<float> segmentChroma(ch->getBands(), 0.0);
for (unsigned int hop = segment.firstHop; hop <= segment.lastHop; hop++) {
for (unsigned int band = 0; band < ch->getBands(); band++) {
float value = ch->getMagnitude(hop, band);
segmentChroma[band] += value;
segment.energy += value;
}
}
segment.chromaVector = segmentChroma;
segment.key = classifier.classify(segmentChroma);
if (segment.key != SILENCE)
keyWeights[segment.key] += segment.energy;
result.segments.push_back(segment);
}
delete ch;
// get global key
result.globalKeyEstimate = SILENCE;
float mostCommonKeyWeight = 0.0;
for (int k = 0; k < (signed)keyWeights.size(); k++) {
if (keyWeights[k] > mostCommonKeyWeight) {
mostCommonKeyWeight = keyWeights[k];
result.globalKeyEstimate = (key_t)k;
}
}
return result;
}
bool ModelValidator::isValid(const Segmentation& segmentation, bool allowDefaults/* = false*/)
{
RETURN_IF_UID_NOT_VALID(segmentation.GetSopInstanceUID(), "SOP Instance UID");
RETURN_IF_UID_NOT_VALID(segmentation.GetSopClassUID(), "SOP Class UID");
RETURN_IF_UID_NOT_VALID(segmentation.GetReferencedSopInstanceUID(), "Referenced SOP Instance UID");
if (segmentation.GetImagingObservation() != NULL)
RETURN_IF_NOT_VALID1(*segmentation.GetImagingObservation(), allowDefaults, "Segmentation's Imaging Observation is invalid");
return true;
}
void Tools::segmentation()
{
ImageViewer* iv = getViewer();
if (!SupportedImageFormat(iv, QList<QImage::Format>() << QImage::Format_Indexed8
<< QImage::Format_RGB32))
return;
Segmentation* s = new Segmentation(iv->getImage(), iv);
s->start();
}
void WFST::generate_misspelled_words(const vector<uint> &pos,int len,Segmentation &final_seg)
{
const Lattice &words = *p_words;
Lattice w;
w.based_on(words);
// 2. Compute the score, jump to 1. if score is too low (pruning 1)
// create new (more compact) Lattice structure
int i,n = words.get_word_count();
for (i = 0;i < len;i ++) {
const WordEntryRefs &fmap = words.get_fuzzy_map(pos[i]);
int ii,nn = fmap.size();
for (ii = 0;ii < nn;++ii)
w.add(*fmap[ii]);
}
//cerr << w << endl;
// 4. Create sections
Sections sects;
sects.construct(words);
// 5. Call create_base_segmentation
//Segmentation base_seg(words.we);
//create_base_segmentation(words,sects,base_seg);
// 6. Get the best segmentation of each section,
// then merge to one big segment.
n = sects.size();
uint ii,nn;
i = ii = 0;
nn = words.get_word_count();
final_seg.clear();
while (ii < nn)
if (i < n && sects[i].start == ii) {
Segmentation seg;
sects[i].segment_best(words,seg);
copy(seg.begin(),
seg.end(),
back_insert_iterator< Segmentation >(final_seg));
ii += sects[i].len;
i ++;
} else {
// only word(i,*,0) exists
final_seg.push_back(words.get_we(ii)[0]->id);
ii += words.get_we(ii)[0]->len;
}
}
int
main (int argc, char **argv)
{
bool use_device = false;
bool use_file = false;
if (argc >= 2)
use_device = true;
if (argc >= 3)
use_file = true;
Segmentation s;
s.run (use_device, use_file);
return 0;
}
int
main (int argc, char **argv)
{
ros::init (argc, argv, "realtime_segmentation");
ros::NodeHandle nh ("~");
bool gui = false;
if (command_line_param (argc, argv, "--gui"))
gui = true;
Segmentation s (nh, gui);
s.run ();
return 0;
}
long long Geant4SensitiveDetector::getCellID(G4Step* s) {
StepHandler h(s);
Geant4VolumeManager volMgr = Geant4Mapping::instance().volumeManager();
VolumeID volID = volMgr.volumeID(h.preTouchable());
Segmentation seg = m_readout.segmentation();
if ( seg.isValid() ) {
G4ThreeVector global = 0.5 * ( h.prePosG4()+h.postPosG4());
G4ThreeVector local = h.preTouchable()->GetHistory()->GetTopTransform().TransformPoint(global);
Position loc(local.x()*MM_2_CM, local.y()*MM_2_CM, local.z()*MM_2_CM);
Position glob(global.x()*MM_2_CM, global.y()*MM_2_CM, global.z()*MM_2_CM);
VolumeID cID = seg.cellID(loc,glob,volID);
return cID;
}
return volID;
}
ReturnType Recognizer::getHypseg(Segmentation& seg) {
if ((decoder == NULL) || (is_recording)) return BAD_STATE;
seg.clear();
int32 scoreh=0, sfh=0, efh=0;
std::string hseg;
ps_seg_t *itor = ps_seg_iter(decoder, &scoreh);
while (itor) {
SegItem segItem;
segItem.word = ps_seg_word(itor);
ps_seg_frames(itor, &sfh, &efh);
segItem.start = sfh;
segItem.end = efh;
seg.push_back(segItem);
itor = ps_seg_next(itor);
}
return SUCCESS;
}
int main(int argc, char** argv)
{
const std::string sourcePath = "IMG_0267.jpg";
const std::string destPath = "test.bmp";
// Basic procedure to use the library
ColorimetricYCbCrAlgorithm1<NumType> algo = ColorimetricYCbCrAlgorithm1<NumType>();
// Algorithm configuration
algo.ApplyMedian(true);
algo.MedianSize(3);
algo.ApplyGrow(true);
algo.GrowCount(20);
algo.GrowSize(3);
algo.ApplyShrink(true);
algo.ShrinkCount(22);
algo.ShrinkSize(3);
algo.ApplyFixedGrowShrink(false);
algo.FixedGrowShrinkCount(10);
algo.FixedGrowShrinkSize(5);
algo.ApplyRegionClearing(true);
Segmentation<NumType> segm = Segmentation<NumType>(&algo);
CImg<bool> *mask = segm.retrieveMask_asBinaryChannel(sourcePath);
CImg<int> *distMap = segm.retrieveDistanceMapOfMask(*mask);
CImg<unsigned char> *resImg = distanceMapToRGB(distMap);
//CImg<int> *resImg = changeBinaryMaskToRGBImage(*mask);
/*std::vector<BinarySeed> *skinSeeds = segm.retrieveSkinSeedsOfMask(*testImg, true, true, 30, 5);
std::vector<BinarySeed> *nonSkinSeeds = segm.retrieveNonSkinSeedsOfMask(*testImg, true, true, 30, 5);
addSeedsToRGBImage(resImg,skinSeeds,nonSkinSeeds);*/
resImg->save(destPath.c_str());
delete mask;
delete resImg;
delete distMap;
return 0;
}
void TonalAnalyser::finalise(TrackInfoObject* tio) {
if(!m_bCanRun)
return;
CLAM::DiscontinuousSegmentation segmentation = m_ce.segmentation();
Segmentation<QString> segs;
for (unsigned i=0; i<segmentation.onsets().size(); i++)
{
unsigned chordIndex = m_ce.chordIndexes()[i];
std::string chordName = m_ce.root(chordIndex) + " " + m_ce.mode(chordIndex);
//segmentation.setLabel(i,chordName);
segs.addSeg(segmentation.onsets()[i], segmentation.offsets()[i], chordName.c_str());
//qDebug() << "Got chord " << chordName.c_str() << " at " << segmentation.onsets()[i] << " until " << segmentation.offsets()[i];
}
m_ce.clear();
tio->setChordData(segs);
}
/*******************************************************************
* Function Name: GetSegments
* Return Type : int
* Created On : Jan 1, 2013
* Created By : hrushi
* Comments : Gets the Segments of objects
*******************************************************************/
ContourMap Detect::GetSegments( const ColorImg ProbeImg, const GrayImg BkImg, bool bSaveOutput, const Args& args )
{
fs::path iPath = ProbeImg.GetImagePath();
fs::path OutputPath;
OutputPath = GiveSegImgPath(iPath, "_seg");
ContourMap Cnturs;
for( int K = SLIC_K; K >= 1; K-- )
{
try
{
Segmentation Segm;
Cnturs = Segm.GetSegments(ProbeImg, BkImg, OutputPath.string(), bSaveOutput, K, SLIC_M, args );
}
catch(int iERR)
{
if( iERR == ERR_SLIC )
{
cerr << "Calling Slick with K: " << (K - 1) << endl;
continue;
}
}
break;
}
if(bSaveOutput)
{
ColorImg Overlay = ProbeImg.Overlay(Cnturs, 1, cv::Scalar(0, 0, 255), args);
string OverlayWrite = GiveSegImgPath(iPath, "_Merge").string();
Overlay.Write( OverlayWrite );
}
return Cnturs;
}
void FireflyOptimizator::computeFirefly(Segmentation ffI, int idx_ffI, int verbose = 3)
{
if(verbose >=1 ) {
cout << "------------------------------" << endl;
cout << "Starting " << idx_ffI << endl;
}
double rank1 = ranks[idx_ffI];
int j = 0,idx_ffJ =0 ;
vector<Segmentation>::iterator ffJ;
for( ffJ = population.begin(),idx_ffJ=0; ffJ != population.end();idx_ffJ++,ffJ++) {
if (idx_ffI == idx_ffJ) {
j++;
continue;
}
double rank2 = ranks[idx_ffJ];
if(verbose >=2 )
cout << "\tComparing " << idx_ffI << " with " << j << " (" << rank1 << " x " << rank2 << " ) ";
if (rank2 > rank1) {
double distance = getDistance(ffI, *ffJ);
double amount = beta * exp(-gamma * distance * distance);
if(verbose >= 3)
cout << " - Dis: " << distance << " It: " << amount;
ffI.matrixAdj = ffI.interpolateMatrix(*ffJ, amount);
j++;
}
else
{ if(verbose >=3 )
cout<<" - "<<idx_ffI << " greater, no update.";
}
//cout<<endl;
}
}
double FireflyOptimizator::getDistance(Segmentation pr, Segmentation gt)
{
double dis = 0.0;
for(int i=0;i<pr.size;i++) {
int top = (i-pr.width)<0?-1:i-pr.width;
int down = (i+pr.width) >= pr.width* pr.height ? -1 : i+pr.width;
int left = (i-1)<0?-1:i-1;
int right = (i+1)>= pr.height*pr.width?-1:i+1;
if (top!=-1)
{
dis += abs(pr.findWeight(i, top) - gt.findWeight(i, top));
}
if (down!=-1)
{
dis += abs(pr.findWeight(i, down) - gt.findWeight(i, down));
}
if (right!=-1)
{
dis += abs(pr.findWeight(i, right) - gt.findWeight(i, right));
}
if (left!=-1) {
dis += abs(pr.findWeight(i, left) - gt.findWeight(i, left));
}
}
return dis;
}
void print_area_center(Segmentation& seg, const std::string& name, int label, Image& output) {
int area; Coordinate center;
seg.GetCenterAndArea(label, center, area);
std::cout << name << " is located at " << center.GetX() << ", " << center.GetY() << " with area " << area << std::endl;
Coordinate point(seg.GetLabelTopLeft(label));
std::vector<int> freeman_code;
seg.GetFreemanCode(label, point, freeman_code);
seg.DrawContourFreeman(point, freeman_code, Color::red(), output);
const float circumference = seg.GetCircumference(freeman_code);
const float roundness = seg.GetRoundness(area, circumference);
std::cout << " Object has roundness of " << roundness << std::endl;
if (rint(roundness) >= 45) {
std::cout << " Object is a tree" << std::endl;
} else if (rint(roundness) >= 16) {
std::cout << " Object is a rectangle" << std::endl;
} else {
std::cout << " Object is a circle" << std::endl;
}
}
static long createGearForILD(Detector& description, int /*argc*/, char** /*argv*/) {
std::cout << " **** running plugin createGearForILD ! " << std::endl ;
// ===========================================================================================
// global parameters:
double crossing_angle(0.) ;
try{ crossing_angle = description.constant<double>("ILC_Main_Crossing_Angle") ; } catch(std::runtime_error&e) {std::cerr << " >>>> " << e.what() << std::endl ;}
//========= TPC ==============================================================================
try{
DetElement tpcDE = description.detector("TPC") ;
FixedPadSizeTPCData* tpc = tpcDE.extension<FixedPadSizeTPCData>() ;
gear::TPCParametersImpl* gearTPC = new gear::TPCParametersImpl( tpc->driftLength /dd4hep::mm , gear::PadRowLayout2D::POLAR ) ;
gearTPC->setPadLayout( new gear::FixedPadSizeDiskLayout( tpc->rMinReadout/dd4hep::mm , tpc->rMaxReadout/dd4hep::mm, tpc->padHeight/dd4hep::mm,
tpc->padWidth/dd4hep::mm , tpc->maxRow, tpc->padGap /dd4hep::mm ) ) ;
gearTPC->setDoubleVal("tpcInnerRadius", tpc->rMin/dd4hep::mm ) ; // inner r of support tube
gearTPC->setDoubleVal("tpcOuterRadius", tpc->rMax/dd4hep::mm ) ; // outer radius of TPC
gearTPC->setDoubleVal("tpcInnerWallThickness", tpc->innerWallThickness/dd4hep::mm ) ; // thickness of inner shell
gearTPC->setDoubleVal("tpcOuterWallThickness", tpc->outerWallThickness/dd4hep::mm ) ; // thickness of outer shell
tpcDE.addExtension< GearHandle >( new GearHandle( gearTPC, "TPCParameters" ) ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
//========= VXD ==============================================================================
try{
DetElement vxdDE = description.detector("VXD") ;
ZPlanarData* vxd = vxdDE.extension<ZPlanarData>() ;
// ZPlanarParametersImpl (int type, double shellInnerRadius, double shellOuterRadius, double shellHalfLength, double shellGap, double shellRadLength)
int vxdType = gear::ZPlanarParameters::CMOS ;
gear::ZPlanarParametersImpl* gearVXD = new gear::ZPlanarParametersImpl( vxdType, vxd->rInnerShell/dd4hep::mm, vxd->rOuterShell/dd4hep::mm,
vxd->zHalfShell/dd4hep::mm , vxd->gapShell/dd4hep::mm , 0. ) ;
for(unsigned i=0,n=vxd->layers.size() ; i<n; ++i){
const rec::ZPlanarData::LayerLayout& l = vxd->layers[i] ;
// FIXME set rad lengths to 0 -> need to get from dd4hep ....
gearVXD->addLayer( l.ladderNumber, l.phi0,
l.distanceSupport/dd4hep::mm, l.offsetSupport/dd4hep::mm, l.thicknessSupport/dd4hep::mm, l.zHalfSupport/dd4hep::mm, l.widthSupport/dd4hep::mm, 0. ,
l.distanceSensitive/dd4hep::mm, l.offsetSensitive/dd4hep::mm, l.thicknessSensitive/dd4hep::mm, l.zHalfSensitive/dd4hep::mm, l.widthSensitive/dd4hep::mm, 0. ) ;
}
GearHandle* handle = new GearHandle( gearVXD, "VXDParameters" ) ;
// quick hack for now: add the one material that is needed by KalDet :
// handle->addMaterial( "VXDSupportMaterial", 2.075865162e+01, 1.039383117e+01, 2.765900000e+02, 1.014262421e+03, 3.341388059e+03) ;
// -------- better: get right averaged material from first ladder: ------------------
MaterialManager matMgr( Detector::getInstance().world().volume() ) ;
const rec::ZPlanarData::LayerLayout& l = vxd->layers[0] ;
Vector3D a( l.distanceSupport , l.phi0 , 0. , Vector3D::cylindrical ) ;
Vector3D b( l.distanceSupport + l.thicknessSupport , l.phi0 , 0. , Vector3D::cylindrical ) ;
const MaterialVec& materials = matMgr.materialsBetween( a , b ) ;
MaterialData mat = ( materials.size() > 1 ? matMgr.createAveragedMaterial( materials ) : materials[0].first ) ;
// std::cout << " ####### found materials between points : " << a << " and " << b << " : " ;
// for( unsigned i=0,n=materials.size();i<n;++i){
// std::cout << materials[i].first.name() << "[" << materials[i].second << "], " ;
// }
// std::cout << std::endl ;
// std::cout << " averaged material : " << mat << std::endl ;
handle->addMaterial( "VXDSupportMaterial", mat.A(), mat.Z() , mat.density()/(dd4hep::kg/(dd4hep::g*dd4hep::m3)) , mat.radiationLength()/dd4hep::mm , mat.interactionLength()/dd4hep::mm ) ;
vxdDE.addExtension< GearHandle >( handle ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
//========= SIT ==============================================================================
try{
DetElement sitDE = description.detector("SIT") ;
ZPlanarData* sit = sitDE.extension<ZPlanarData>() ;
// ZPlanarParametersImpl (int type, double shellInnerRadius, double shellOuterRadius, double shellHalfLength, double shellGap, double shellRadLength)
int sitType = gear::ZPlanarParameters::CCD ;
gear::ZPlanarParametersImpl* gearSIT = new gear::ZPlanarParametersImpl( sitType, sit->rInnerShell/dd4hep::mm, sit->rOuterShell/dd4hep::mm,
sit->zHalfShell/dd4hep::mm , sit->gapShell/dd4hep::mm , 0. ) ;
std::vector<int> n_sensors_per_ladder ;
for(unsigned i=0,n=sit->layers.size() ; i<n; ++i){
const rec::ZPlanarData::LayerLayout& l = sit->layers[i] ;
// FIXME set rad lengths to 0 -> need to get from dd4hep ....
gearSIT->addLayer( l.ladderNumber, l.phi0,
l.distanceSupport/dd4hep::mm, l.offsetSupport/dd4hep::mm, l. thicknessSupport/dd4hep::mm, l.zHalfSupport/dd4hep::mm, l.widthSupport/dd4hep::mm, 0. ,
l.distanceSensitive/dd4hep::mm, l.offsetSensitive/dd4hep::mm, l. thicknessSensitive/dd4hep::mm, l.zHalfSensitive/dd4hep::mm, l.widthSensitive/dd4hep::mm, 0. ) ;
n_sensors_per_ladder.push_back( l.sensorsPerLadder);
}
gearSIT->setDoubleVal("strip_width_mm" , sit->widthStrip / dd4hep::mm ) ;
gearSIT->setDoubleVal("strip_length_mm" , sit->lengthStrip/ dd4hep::mm ) ;
gearSIT->setDoubleVal("strip_pitch_mm" , sit->pitchStrip / dd4hep::mm ) ;
gearSIT->setDoubleVal("strip_angle_deg" , sit->angleStrip / dd4hep::deg ) ;
gearSIT->setIntVals("n_sensors_per_ladder",n_sensors_per_ladder);
sitDE.addExtension< GearHandle >( new GearHandle( gearSIT, "SITParameters" ) ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
//============================================================================================
try {
DetElement setDE = description.detector("SET") ;
ZPlanarData* set = setDE.extension<ZPlanarData>() ;
// ZPlanarParametersImpl (int type, double shellInnerRadius, double shellOuterRadius, double shellHalfLength, double shellGap, double shellRadLength)
int setType = gear::ZPlanarParameters::CCD ;
gear::ZPlanarParametersImpl* gearSET = new gear::ZPlanarParametersImpl( setType, set->rInnerShell/dd4hep::mm, set->rOuterShell/dd4hep::mm,
set->zHalfShell/dd4hep::mm , set->gapShell/dd4hep::mm , 0. ) ;
std::vector<int> n_sensors_per_ladder ;
//n_sensors_per_ladder.clear() ;
for(unsigned i=0,n=set->layers.size() ; i<n; ++i){
const rec::ZPlanarData::LayerLayout& l = set->layers[i] ;
// FIXME set rad lengths to 0 -> need to get from dd4hep ....
gearSET->addLayer( l.ladderNumber, l.phi0,
l.distanceSupport/dd4hep::mm, l.offsetSupport/dd4hep::mm, l. thicknessSupport/dd4hep::mm, l.zHalfSupport/dd4hep::mm, l.widthSupport/dd4hep::mm, 0. ,
l.distanceSensitive/dd4hep::mm, l.offsetSensitive/dd4hep::mm, l. thicknessSensitive/dd4hep::mm, l.zHalfSensitive/dd4hep::mm, l.widthSensitive/dd4hep::mm, 0. ) ;
n_sensors_per_ladder.push_back( l.sensorsPerLadder);
}
gearSET->setDoubleVal("strip_width_mm" , set->widthStrip / dd4hep::mm ) ;
gearSET->setDoubleVal("strip_length_mm" , set->lengthStrip/ dd4hep::mm ) ;
gearSET->setDoubleVal("strip_pitch_mm" , set->pitchStrip / dd4hep::mm ) ;
gearSET->setDoubleVal("strip_angle_deg" , set->angleStrip / dd4hep::deg ) ;
gearSET->setIntVals("n_sensors_per_ladder",n_sensors_per_ladder);
setDE.addExtension< GearHandle >( new GearHandle( gearSET, "SETParameters" ) ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
//============================================================================================
try {
DetElement ftdDE = description.detector("FTD") ;
ZDiskPetalsData* ftd = ftdDE.extension<ZDiskPetalsData>() ;
gear::FTDParametersImpl* gearFTD = new gear::FTDParametersImpl();
for(unsigned i=0,n=ftd->layers.size() ; i<n; ++i){
const rec::ZDiskPetalsData::LayerLayout& l = ftd->layers[i] ;
bool isDoubleSided = l.typeFlags[ rec::ZDiskPetalsStruct::SensorType::DoubleSided ] ;
// avoid 'undefined reference' at link time ( if built w/o optimization ):
static const int PIXEL = gear::FTDParameters::PIXEL ;
static const int STRIP = gear::FTDParameters::STRIP ;
int sensorType = ( l.typeFlags[ rec::ZDiskPetalsStruct::SensorType::Pixel ] ? PIXEL : STRIP ) ;
// gear::FTDParameters::PIXEL : gear::FTDParameters::STRIP ) ;
double zoffset = fabs( l.zOffsetSupport ) ;
double signoffset = l.zOffsetSupport > 0 ? 1. : -1 ;
gearFTD->addLayer( l.petalNumber, l.sensorsPerPetal,
isDoubleSided, sensorType,
l.petalHalfAngle, l.phi0, l.alphaPetal,
l.zPosition/dd4hep::mm, zoffset/dd4hep::mm, signoffset,
l.distanceSupport/dd4hep::mm, l.thicknessSupport/dd4hep::mm,
l.widthInnerSupport/dd4hep::mm, l.widthOuterSupport/dd4hep::mm,
l.lengthSupport/dd4hep::mm,
0.,
l.distanceSensitive/dd4hep::mm, l.thicknessSensitive/dd4hep::mm,
l.widthInnerSensitive/dd4hep::mm, l.widthOuterSensitive/dd4hep::mm,
l.lengthSensitive/dd4hep::mm,
0. ) ;
// FIXME set rad lengths to 0 -> need to get from dd4hep ....
}
gearFTD->setDoubleVal("strip_width_mm" , ftd->widthStrip / dd4hep::mm ) ;
gearFTD->setDoubleVal("strip_length_mm" , ftd->lengthStrip/ dd4hep::mm ) ;
gearFTD->setDoubleVal("strip_pitch_mm" , ftd->pitchStrip / dd4hep::mm ) ;
gearFTD->setDoubleVal("strip_angle_deg" , ftd->angleStrip / dd4hep::deg ) ;
ftdDE.addExtension< GearHandle >( new GearHandle( gearFTD, "FTDParameters" ) ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
//============================================================================================
try {
DetElement coilDE = description.detector("Coil") ;
gear::GearParametersImpl* gearCOIL = new gear::GearParametersImpl();
Tube coilTube = Tube( coilDE.volume().solid() ) ;
gearCOIL->setDoubleVal("Coil_cryostat_inner_radius" , coilTube->GetRmin()/ dd4hep::mm ) ;
gearCOIL->setDoubleVal("Coil_cryostat_outer_radius" , coilTube->GetRmax()/ dd4hep::mm ) ;
gearCOIL->setDoubleVal("Coil_cryostat_half_z" , coilTube->GetDZ()/ dd4hep::mm ) ;
coilDE.addExtension< GearHandle >( new GearHandle( gearCOIL, "CoilParameters" ) ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
//============================================================================================
try {
DetElement tubeDE = description.detector("Tube") ;
ConicalSupportData* tube = tubeDE.extension<ConicalSupportData>() ;
gear::GearParametersImpl* gearTUBE = new gear::GearParametersImpl();
tube->isSymmetricInZ = true ;
unsigned n = tube->sections.size() ;
std::vector<double> rInner(n) ;
std::vector<double> rOuter(n) ;
std::vector<double> zStart(n) ;
for(unsigned i=0 ; i<n ; ++i){
const ConicalSupportData::Section& s = tube->sections[i] ;
rInner[i] = s.rInner/ dd4hep::mm ;
rOuter[i] = s.rOuter/ dd4hep::mm ;
zStart[i] = s.zPos / dd4hep::mm ;
// FIXME set rad lengths to 0 -> need to get from dd4hep ....
}
gearTUBE->setDoubleVals("RInner" , rInner ) ;
gearTUBE->setDoubleVals("ROuter" , rOuter ) ;
gearTUBE->setDoubleVals("Z" , zStart ) ;
tubeDE.addExtension< GearHandle >( new GearHandle( gearTUBE, "BeamPipe" ) ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
//========= CALO ==============================================================================
//**********************************************************
//* gear interface w/ LayeredCalorimeterData extension
//**********************************************************
std::map< std::string, std::string > caloMap ;
caloMap["HcalBarrel"] = "HcalBarrelParameters" ;
caloMap["EcalBarrel"] = "EcalBarrelParameters" ;
caloMap["EcalEndcap"] = "EcalEndcapParameters" ;
caloMap["EcalPlug"] = "EcalPlugParameters" ;
caloMap["YokeBarrel"] = "YokeBarrelParameters" ;
caloMap["YokeEndcap"] = "YokeEndcapParameters" ;
caloMap["YokePlug"] = "YokePlugParameters" ;
caloMap["HcalBarrel"] = "HcalBarrelParameters" ;
caloMap["HcalEndcap"] = "HcalEndcapParameters" ;
caloMap["HcalRing"] = "HcalRingParameters" ;
caloMap["Lcal"] = "LcalParameters" ;
caloMap["LHcal"] = "LHcalParameters" ;
caloMap["BeamCal"] = "BeamCalParameters" ;
for( std::map< std::string, std::string >::const_iterator it = caloMap.begin() ; it != caloMap.end() ; ++it ){
try {
DetElement caloDE = description.detector( it->first ) ;
LayeredCalorimeterData* calo = caloDE.extension<LayeredCalorimeterData>() ;
gear::CalorimeterParametersImpl* gearCalo =
( calo->layoutType == LayeredCalorimeterData::BarrelLayout ?
new gear::CalorimeterParametersImpl( calo->extent[0]/dd4hep::mm, calo->extent[3]/dd4hep::mm, calo->inner_symmetry, calo->phi0 ) :
//CalorimeterParametersImpl (double rMin, double zMax, int symOrder=8, double phi0=0.0) - C'tor for a cylindrical (octagonal) BARREL calorimeter.
new gear::CalorimeterParametersImpl( calo->extent[0]/dd4hep::mm, calo->extent[1]/dd4hep::mm, calo->extent[2]/dd4hep::mm, calo->outer_symmetry, calo->phi0 ) ) ;
//CalorimeterParametersImpl (double rMin, double rMax, double zMin, int symOrder=2, double phi0=0.0) - C'tor for a cylindrical (octagonal) ENDCAP calorimeter.
for( unsigned i=0, nL = calo->layers.size() ; i <nL ; ++i ){
LayeredCalorimeterData::Layer& l = calo->layers[i] ;
//Do some arithmetic to get thicknesses and (approximate) absorber thickneses from "new" rec structures
//The positioning should come out right, but the absorber thickness should be overestimated due to the presence of
//other less dense material
if( i == 0 ) {
gearCalo->layerLayout().positionLayer( l.distance/dd4hep::mm,
(l.inner_thickness+l.sensitive_thickness/2.)/dd4hep::mm ,
l.cellSize0/dd4hep::mm, l.cellSize1/dd4hep::mm,
(l.inner_thickness-l.sensitive_thickness/2.)/dd4hep::mm ) ;
}else{
gearCalo->layerLayout().addLayer( (l.inner_thickness+l.sensitive_thickness/2.+calo->layers[i-1].outer_thickness-calo->layers[i-1].sensitive_thickness/2. ) / dd4hep::mm ,
l.cellSize0/dd4hep::mm, l.cellSize1/dd4hep::mm, (l.inner_thickness-l.sensitive_thickness/2.+calo->layers[i-1].outer_thickness-calo->layers[i-1].sensitive_thickness/2.)/dd4hep::mm) ;
}
// if( i == 0 ) {
// gearCalo->layerLayout().positionLayer( l.distance/dd4hep::mm, l.thickness/dd4hep::mm ,
// l.cellSize0/dd4hep::mm, l.cellSize1/dd4hep::mm, l.absorberThickness/dd4hep::mm ) ;
// }else{
// gearCalo->layerLayout().addLayer( l.thickness/dd4hep::mm ,
// l.cellSize0/dd4hep::mm, l.cellSize1/dd4hep::mm, l.absorberThickness/dd4hep::mm ) ;
// }
}
if( it->first == "HcalBarrel" ){
// additional parameters needed by MarlinPandora
gearCalo->setIntVal("Hcal_outer_polygon_order" , calo->outer_symmetry ) ;
gearCalo->setDoubleVal("Hcal_outer_polygon_phi0" , calo->phi0 ) ;
}
if( it->first == "BeamCal" ){
try{
// additional parameters needed by BCalReco
SensitiveDetector sD = description.sensitiveDetector( it->first ) ;
Readout readOut = sD.readout() ;
Segmentation seg = readOut.segmentation() ;
// DDSegmentation::DoubleVecParameter rPar = dynamic_cast<DDSegmentation::DoubleVecParameter>( seg.parameter("grid_r_values"));
DDSegmentation::DoubleVecParameter pPar = dynamic_cast<DDSegmentation::DoubleVecParameter>( seg.parameter("grid_phi_values"));
DDSegmentation::DoubleParameter oPPar= dynamic_cast<DDSegmentation::DoubleParameter>( seg.parameter("offset_phi"));
//offset_phi="-180*degree+(360*degree-BCal_SpanningPhi)*0.5"
double offsetPhi = oPPar->typedValue() ;
double spanningPhi = 360.*dd4hep::deg - 2.*( offsetPhi + 180.*dd4hep::deg ) ;
gearCalo->setDoubleVals( "phi_segmentation" , pPar->typedValue() );
gearCalo->setDoubleVal( "cylinder_starting_phi", offsetPhi );
gearCalo->setDoubleVal( "cylinder_spanning_phi", spanningPhi );
gearCalo->setDoubleVal( "beam_crossing_angle" , crossing_angle );
//fixme: don't know how to get these parameters at this stage ...
// probably need a named parameter object at every DetElement ....
gearCalo->setDoubleVal( "dead_area_outer_r" , 0 );
gearCalo->setDoubleVal( "pairsMonitorZ" , 0. );
gearCalo->setDoubleVal( "FIXME_dead_area_outer_r" , -1. );
gearCalo->setDoubleVal( "FIXME_pairsMonitorZ" , -1. );
} catch( std::runtime_error& e ){
std::cerr << " >>>> BeamCal: " << e.what() << std::endl ;
}
}
if( it->first == "Lcal" || it->first == "LHcal" ){
gearCalo->setDoubleVal( "beam_crossing_angle" , crossing_angle );
}
caloDE.addExtension< GearHandle >( new GearHandle( gearCalo, it->second ) ) ;
} catch( std::runtime_error& e ){
std::cerr << " >>>> " << e.what() << std::endl ;
}
} // calo loop
//**********************************************************
//* test gear interface w/ LayeredExtensionImpl extension
//**********************************************************
// DetElement calo2DE = description.detector("EcalBarrel") ;
// Calorimeter calo2( calo2DE ) ;
// gear::CalorimeterParametersImpl* gearCalo2 =
// ( calo2.isBarrel() ?
// new gear::CalorimeterParametersImpl( calo2.getRMin()/dd4hep::mm, calo2.getZMax()/dd4hep::mm, calo2.getNSides(), 0. ) : // fixme: phi 0 is not defined ??
// new gear::CalorimeterParametersImpl( calo2.getRMin()/dd4hep::mm, calo2.getRMax()/dd4hep::mm, calo2.getZMin()/dd4hep::mm, calo2.getNSides(), 0. )
// ) ;
// for( unsigned i=0, nL = calo2.numberOfLayers() ; i <nL ; ++i ){
// if( i == 0 ) {
// gearCalo2->layerLayout().positionLayer( calo2.getRMin()/dd4hep::mm, calo2.thickness(i)/dd4hep::mm , 0. /dd4hep::mm, 0. /dd4hep::mm, calo2.absorberThickness(i)/dd4hep::mm ) ;
// }else{ // fixme: cell sizes not in API !?
// gearCalo2->layerLayout().addLayer( calo2.thickness(i)/dd4hep::mm , 0. /dd4hep::mm, 0. /dd4hep::mm, calo2.absorberThickness(i)/dd4hep::mm ) ;
// }
// }
// calo2DE.addExtension< GearHandle >( new GearHandle( gearCalo2, "EcalBarrelParameters" ) ) ;
//============================================================================================
// --- Detector::apply() expects return code 1 if all went well ! ----
return 1;
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @return
*/
Image *execute(Image *imgIn, Image *imgOut)
{
if(imgIn == NULL) {
return NULL;
}
if(!imgIn->isValid()) {
return NULL;
}
if(imgOut == NULL) {
imgOut = new Image(1, imgIn->width, imgIn->height, imgIn->channels);
}
//compute segmentation map
seg_map = seg.Process(imgIn, seg_map);
/* 0 ---> Drago et al. 2003
1 ---> Reinhard et al. 2002
LumZone = [-2, -1, 0, 1, 2, 3, 4];
TMOForZone = [ 0, 0, 1, 0, 1, 0, 0]; */
int count[2];
count[0] = 0;
count[1] = 0;
for(int i = 0; i < seg_map->size(); i++) {
int indx = int(seg_map->data[i]);
if((indx == 2) || (indx == 4)) {
seg_map->data[i] = 1.0f;
count[1]++;
} else {
seg_map->data[i] = 0.0f;
count[0]++;
}
}
#ifdef PIC_DEBUG
seg_map->Write("weight_map.pfm");
#endif
//check if we have different zones
int value = 10;
if(count[0] > 0 && count[1] > 0) {
value = 10;
}
if(count[0] > 0 && count[1] == 0) {
value = 0;
}
if(count[0] == 0 && count[1] > 0) {
value = 1;
}
switch(value) {
case 0: {
fltDragoTMO.Process(Single(imgIn), imgOut);
}
break;
case 1: {
fltReinhardTMO.Process(Single(imgIn), imgOut);
}
break;
case 10: {
//Drago TMO
imgDrago = fltDragoTMO.Process(Single(imgIn), imgDrago);
if(pyrA == NULL) {
pyrA = new Pyramid(imgDrago, true);
} else {
pyrA->update(imgDrago);
}
//Reinhard TMO
imgReinhard = fltReinhardTMO.Process(Single(imgIn), imgReinhard);
if(pyrB == NULL) {
pyrB = new Pyramid(imgReinhard, true);
} else {
pyrB->update(imgReinhard);
}
//compute blending weight
if(pyrWeight == NULL) {
pyrWeight = new Pyramid(seg_map, false);
} else {
pyrWeight->update(seg_map);
}
//blend
pyrA->blend(pyrB, pyrWeight);
pyrA->reconstruct(imgOut);
}
break;
}
return imgOut;
}
int main(int argc, char** argv)
{
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBA>);
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloudFiltered (new pcl::PointCloud<pcl::PointXYZRGBA>);
int k=atoi(argv[1]);
double min_mah_dist=atof(argv[2]);
int max_gauss=atoi(argv[3]);
std::vector <Gauss> gaussians_learned;
pcl::PCDReader reader;
reader.read (argv[4], *cloud);
pcl::console::TicToc timer;
timer.tic();
// Filtering
Filtering filtering;
cloudFiltered=filtering.filter(cloud);
// Segmentation
Segmentation segmentation;
std::vector <Surface> surfaces=segmentation.segment (cloudFiltered);
// Colour extraction from point cloud
ExtractColour extractcolour;
cv::Mat samples=extractcolour.pcd2colourRGB(surfaces[0].segmented_cloud);
// Point cloud analysis
ColourAnalysis colouranalysis;
std::vector <Gauss> gaussians = colouranalysis.analyzeColourCluster(k, surfaces[0].segmented_cloud, surfaces[0].b, surfaces[0].d, samples);
// Learning
Learning learning;
gaussians_learned=learning.learnGaussians(gaussians, gaussians_learned, max_gauss);
// ROI
ROI roi;
std::vector<Line> lines=roi.roi(surfaces);
std::vector<int> index=roi.extractIndex(lines);
// Colour extraction from image
std::vector<Matrix_double> colours=extractcolour.indexPCD2VectorRGB(*cloud, index);
// Image analysis
std::vector <int> pixels_labeled=colouranalysis.labelIndex(colours, k, gaussians_learned, min_mah_dist);
// Map reconstruction
Map map;
std::vector<Matrix_double> distancesLabeled=map.mapDistances(index, surfaces[0].a ,surfaces[0].b, surfaces[0].c, surfaces[0].d);
std::cout << "Part 1 finished" << std::endl;
timer.toc_print();
timer.tic();
// Generate image
cv::Mat environment=extractcolour.pcd2image(*cloud);
// Calcule begin and end points for a line
std::vector <LinePoint> linePoints=roi.calculeLinePoints(lines);
// Draw lines
Visualize visualize;
environment=visualize.drawLines (environment, linePoints, "green");
// Print floor
std::vector<int> pixels=colouranalysis.labelPixel(pixels_labeled, index, colours);
environment=visualize.drawFloor (pixels, environment, "cyan");
std::vector <int> kinectIndex=roi.extractFloorIdx(surfaces[0].a, surfaces[0].b, surfaces[0].c, surfaces[0].d, cloud);
environment=visualize.drawFloor (kinectIndex, environment, "blue");
// Reconstruct kinect floor
std::vector <int> kinect (kinectIndex.size(), 1);
std::vector<Matrix_double> distancesKinect=map.mapDistances(kinectIndex, surfaces[0].a ,surfaces[0].b, surfaces[0].c, surfaces[0].d);
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloudEnhanced=map.mapEnhance(distancesLabeled, index, cloud, pixels_labeled, surfaces[0].a ,surfaces[0].b, surfaces[0].c, surfaces[0].d);
// Generate map reconstruction image
cv::Mat map_reconstruction(cv::Size(400,650),CV_8UC3);
map_reconstruction=cv::Scalar(0,0,0);
map_reconstruction=visualize.mapGeneration(map_reconstruction, pixels_labeled, distancesLabeled, "blue", "white");
map_reconstruction=visualize.mapGeneration(map_reconstruction, kinect, distancesKinect, "red", "yellow");
// Show images on a window
std::string name_window="Floor window";
visualize.visualizeImage (environment, name_window);
name_window="Map window";
visualize.visualizeImage (map_reconstruction, name_window);
visualize.visualizeCloud(cloudEnhanced, "Cloud");
// Save images
Save save;
char name[50]="map.png";
save.saveImage(map_reconstruction, name);
char name2[50]="environment.png";
save.saveImage(environment, name2);
// Save cloud
std::string names= "cloud.pcd";
save.saveCloud(surfaces[0].segmented_cloud, names);
std::cout << "Part 2 finished" << std::endl;
timer.toc_print();
cv::waitKey();
return 0;
}
void defaultExecution(SysEnv &sysEnv, std::string &metricType, RegionTemplateCollection *rtCollection,
std::string tuningPolicy,
float *perf, float *totaldiffs, float *metricPerIteration,
float *diceNotCoolPerIteration,
uint64_t *totalexecutiontimes) {
int versionNorm = 0, versionSeg = 0;
int segCount = 0;
std::vector<int> segComponentIds[rtCollection->getNumRTs()];
std::vector<int> metricComponentIds[rtCollection->getNumRTs()];
std::vector<int> diceNotCoolComponentIds[rtCollection->getNumRTs()];
// Build application dependency graph
// Instantiate application dependency graph
for (int i = 0; i < rtCollection->getNumRTs(); i++) {
int previousSegCompId = 0;
// CREATE NORMALIZATION STEP
ParameterSet parSetNormalization;
std::vector<ArgumentBase *> targetMeanOptions;
ArgumentFloatArray *targetMeanAux = new ArgumentFloatArray(ArgumentFloat(-0.632356));
targetMeanAux->addArgValue(ArgumentFloat(-0.0516004));
targetMeanAux->addArgValue(ArgumentFloat(0.0376543));
targetMeanOptions.push_back(targetMeanAux);
parSetNormalization.addArguments(targetMeanOptions);
parSetNormalization.resetIterator();
std::vector<ArgumentBase *> argSetInstanceNorm = parSetNormalization.getNextArgumentSetInstance();
NormalizationComp *norm = new NormalizationComp();
// normalization parameters
norm->addArgument(new ArgumentInt(versionNorm));
norm->addArgument(argSetInstanceNorm[0]);
norm->addRegionTemplateInstance(rtCollection->getRT(i), rtCollection->getRT(i)->getName());
sysEnv.executeComponent(norm);
std::cout << "BEGIN: Default Execution: ";
std::cout << std::endl;
// Creating segmentation component
Segmentation *seg = new Segmentation();
// version of the data region red. Each parameter instance in norm creates a output w/ different version
seg->addArgument(new ArgumentInt(versionNorm));
// version of the data region generated by the segmentation stage
seg->addArgument(new ArgumentInt(versionSeg));
int blue = 220;
int green = 220;
int red = 220;
float T1 = 5.0;
float T2 = 4.0;
int G1 = 80;
int minSize = 11;
int maxSize = 1000;
int G2 = 45;
int minSizePl = 30;
int minSizeSeg = 21;
int maxSizeSeg = 1000;
int fillHolesConnectivity = 4;
int reconConnectivity = 8;
int watershedConnectivity = 8;
// add remaining (application specific) parameters from the argSegInstance
seg->addArgument(new ArgumentInt(
(int) round(blue)));
seg->addArgument(new ArgumentInt(
(int) round(green)));
seg->addArgument(new ArgumentInt(
(int) round(red)));
seg->addArgument(
new ArgumentFloat((float) (T1)));
seg->addArgument(
new ArgumentFloat((float) (T2)));
seg->addArgument(new ArgumentInt(
(int) round(G1)));
seg->addArgument(new ArgumentInt(
(int) round(G2)));
seg->addArgument(new ArgumentInt(
(int) round(minSize)));
seg->addArgument(new ArgumentInt(
(int) round(maxSize)));
seg->addArgument(new ArgumentInt(
(int) round(minSizePl)));
seg->addArgument(new ArgumentInt(
(int) round(minSizeSeg)));
seg->addArgument(new ArgumentInt(
(int) round(maxSizeSeg)));
seg->addArgument(new ArgumentInt(
(int) round(fillHolesConnectivity)));
seg->addArgument(new ArgumentInt(
(int) round(reconConnectivity)));
seg->addArgument(new ArgumentInt(
(int) round(watershedConnectivity)));
// and region template instance that it is suppose to process
seg->addRegionTemplateInstance(rtCollection->getRT(i), rtCollection->getRT(i)->getName());
seg->addDependency(norm->getId());
std::cout << "Creating DiffMask" << std::endl;
RTPipelineComponentBase *metricComp;
DiceNotCoolMaskComp *diceNotCoolComp;
if (metricType.find("jaccard") != std::string::npos) metricComp = new JaccardMaskComp();
else metricComp = new DiceMaskComp();
if (metricType.find("dicenc") != std::string::npos) diceNotCoolComp = new DiceNotCoolMaskComp();
// version of the data region that will be read. It is created during the segmentation.
// region template name
metricComp->addArgument(new ArgumentInt(versionSeg));
metricComp->addRegionTemplateInstance(rtCollection->getRT(i), rtCollection->getRT(i)->getName());
metricComp->addDependency(seg->getId());
// add to the list of diff component ids.
segComponentIds[i].push_back(seg->getId());
metricComponentIds[i].push_back(metricComp->getId());
sysEnv.executeComponent(seg);
sysEnv.executeComponent(metricComp);
if (metricType.find("dicenc") != std::string::npos) {
diceNotCoolComp->addArgument(new ArgumentInt(versionSeg));
diceNotCoolComp->addRegionTemplateInstance(rtCollection->getRT(i),
rtCollection->getRT(i)->getName());
diceNotCoolComp->addDependency(metricComp->getId());
diceNotCoolComponentIds[i].push_back(diceNotCoolComp->getId());
sysEnv.executeComponent(diceNotCoolComp);
}
std::cout << "Manager CompId: " << metricComp->getId() << " fileName: " <<
rtCollection->getRT(i)->getDataRegion(0)->getInputFileName() << std::endl;
segCount++;
versionSeg++;
versionNorm++;
}
// End Creating Dependency Graph
sysEnv.startupExecution();
std::cout << std::endl << std::endl;
//==============================================================================================
//Fetch results from execution workflow
//==============================================================================================
for (int j = 0; j < rtCollection->getNumRTs(); j++) {
float metric = 0;
float secondaryMetric = 0;
float diceNotCoolValue = 0;
std::ostringstream oss;
oss << " Default PARAMS";
for (int i = 0; i < metricComponentIds[j].size(); i++) {
char *metricResultData = sysEnv.getComponentResultData(metricComponentIds[j][i]);
std::cout << "RT name: " << rtCollection->getRT(j)->getDataRegion("RAW")->getInputFileName() <<
" - Diff Id: " << metricComponentIds[j][i];
if (metricResultData != NULL) {
//std::cout << "size: " << ((int *) metricResultData)[0] << " \thadoopgis-metric: " <<
//((float *) metricResultData)[1] <<
//" \tsecondary: " << ((float *) metricResultData)[2] << endl;
metric += ((float *) metricResultData)[1];
secondaryMetric += ((float *) metricResultData)[2];
if (metricType.find("dicenc") != std::string::npos) {
char *diceNotCoolResultData = sysEnv.getComponentResultData(diceNotCoolComponentIds[j][i]);
// std::cout << " \tdiceNotCool: " <<
// ((float *) diceNotCoolResultData)[1] << std::endl;
diceNotCoolValue += ((float *) diceNotCoolResultData)[1];
}
} else {
std::cout << "NULL" << std::endl;
}
char *segExecutionTime = sysEnv.getComponentResultData(segComponentIds[j][i]);
if (segExecutionTime != NULL) {
totalexecutiontimes[j] = ((int *) segExecutionTime)[1];
// cout << "Segmentation execution time:" <<
// totalexecutiontimes[j] << endl;
}
if (metricType.find("dicenc") != std::string::npos)
sysEnv.eraseResultData(diceNotCoolComponentIds[j][i]);
sysEnv.eraseResultData(metricComponentIds[j][i]);
sysEnv.eraseResultData(segComponentIds[j][i]);
}
metricComponentIds[j].clear();
segComponentIds[j].clear();
if (metricType.find("dicenc") != std::string::npos) diceNotCoolComponentIds[j].clear();
float diff;
if (metricType.find("dicenc") != std::string::npos) diff = (metric + diceNotCoolValue) / 2;
else diff = metric;
if (diff <= 0) diff = FLT_EPSILON;
cout << "\tDiff (average of metric and dnc): " << diff << "\tMetric:" << metric << "\tDNC:" <<
diceNotCoolValue << " Segmentation Time: " <<
totalexecutiontimes[j] << endl;
totaldiffs[j] = diff;
metricPerIteration[j] = metric;
diceNotCoolPerIteration[j] = diceNotCoolValue;
}
std::cout << std::endl << std::endl;
}
void test_crosschannelregistration(UnitTest &ut) {
ut.begin_test_set("CrossChannelRegistration");
Segmentation<uint16> segmenter;
EuclideanDistanceMap<uint16> edm;
Watershed<uint16> wat;
Invert<uint16> inv;
NWThreshold<uint16> nwt(5,0.5,60000,NWThreshold<uint16>::mask_type_square);//0.75 beautiful
SwiftImage<uint16> c1a_i1("./Images/smallfake2/c1_a.tif");
cout << "Load complete" << endl;
SwiftImage<uint16> c1a_i2 = nwt.process(c1a_i1);
cout << "Thresholding complete" << endl;
SwiftImage<uint16> c1a_i3 = edm.process(c1a_i2);
cout << "EDM complete" << endl;
SwiftImage<uint16> c1a_i4 = inv.process(c1a_i3);
cout << "INV complete" << endl;
SwiftImage<uint16> c1a_i5 = wat.process(c1a_i4);
cout << "Wat complete" << endl;
SwiftImage<uint16> c1a_i6 = c1a_i2 && c1a_i5;
vector<SwiftImageObject<> > c1a_objs1 = segmenter.process(c1a_i6);
SwiftImage<uint16> c2a_i1("./Images/smallfake2/c2_a.tif");
cout << "Load complete" << endl;
SwiftImage<uint16> c2a_i2 = nwt.process(c2a_i1);
cout << "Thresholding complete" << endl;
SwiftImage<uint16> c2a_i3 = edm.process(c2a_i2);
cout << "EDM complete" << endl;
SwiftImage<uint16> c2a_i4 = inv.process(c2a_i3);
cout << "INV complete" << endl;
SwiftImage<uint16> c2a_i5 = wat.process(c2a_i4);
cout << "Wat complete" << endl;
SwiftImage<uint16> c2a_i6 = c2a_i2 && c2a_i5;
vector<SwiftImageObject<> > c2a_objs1 = segmenter.process(c2a_i6);
SwiftImage<uint16> c1t_i1("./Images/smallfake2/c1_t.tif");
cout << "Load complete" << endl;
SwiftImage<uint16> c1t_i2 = nwt.process(c1t_i1);
cout << "Thresholding complete" << endl;
SwiftImage<uint16> c1t_i3 = edm.process(c1t_i2);
cout << "EDM complete" << endl;
SwiftImage<uint16> c1t_i4 = inv.process(c1t_i3);
cout << "INV complete" << endl;
SwiftImage<uint16> c1t_i5 = wat.process(c1t_i4);
cout << "Wat complete" << endl;
SwiftImage<uint16> c1t_i6 = c1t_i2 && c1t_i5;
vector<SwiftImageObject<> > c1t_objs1 = segmenter.process(c1t_i6);
SwiftImage<uint16> c2t_i1("./Images/smallfake2/c2_t.tif");
cout << "Load complete" << endl;
SwiftImage<uint16> c2t_i2 = nwt.process(c2t_i1);
cout << "Thresholding complete" << endl;
SwiftImage<uint16> c2t_i3 = edm.process(c2t_i2);
cout << "EDM complete" << endl;
SwiftImage<uint16> c2t_i4 = inv.process(c2t_i3);
cout << "INV complete" << endl;
SwiftImage<uint16> c2t_i5 = wat.process(c2t_i4);
cout << "Wat complete" << endl;
SwiftImage<uint16> c2t_i6 = c2t_i2 && c2t_i5;
vector<SwiftImageObject<> > c2t_objs1 = segmenter.process(c2t_i6);
// Now have c1_objs1 and c2_objs1 for registration
vector<vector<SwiftImageObject<> > > a_cycles;
a_cycles.push_back(c1a_objs1);
a_cycles.push_back(c2a_objs1);
vector<vector<SwiftImageObject<> > > t_cycles;
t_cycles.push_back(c1t_objs1);
t_cycles.push_back(c2t_objs1);
ChannelRegistration<> chanreg(c2a_i6.image_width(),c2a_i6.image_height());
vector<vector<SwiftImageCluster<> > > a_clusters = chanreg.process_channel_registration(a_cycles,SwiftImageCluster<>::base_a);
vector<vector<SwiftImageCluster<> > > c_clusters = chanreg.process_channel_registration(t_cycles,SwiftImageCluster<>::base_c);
vector<vector<SwiftImageCluster<> > > g_clusters = chanreg.process_channel_registration(a_cycles,SwiftImageCluster<>::base_g);
vector<vector<SwiftImageCluster<> > > t_clusters = chanreg.process_channel_registration(t_cycles,SwiftImageCluster<>::base_t);
CrossChannelRegistration<> crosschanreg(c2a_i6.image_width(),c2a_i6.image_height(),true,3);
vector<vector<SwiftImageCluster<> > > all_clusters = crosschanreg.process_crosschannel_registration(a_clusters,
c_clusters,
g_clusters,
t_clusters);
for(int n=0;n<all_clusters.size();n++) {
ut.test(static_cast<int>(all_clusters[n].size()),2);
}
ut.test(static_cast<int>(all_clusters.size()),5);
// Cluster 1, Cycle 1
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 1, Cycle 2
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 2, Cycle 1
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_a].size()),2);
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_g].size()),2);
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 2, Cycle 2
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,6);
// Cluster 3, Cycle 1
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 3, Cycle 2
ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 4, Cycle 1
ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 4, Cycle 2
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
all_clusters = crosschanreg.process_crosschannel_registration_inv(a_clusters,
c_clusters,
g_clusters,
t_clusters);
for(int n=0;n<all_clusters.size();n++) {
ut.test(static_cast<int>(all_clusters[n].size()),2);
}
ut.test(static_cast<int>(all_clusters.size()),5);
// Cluster 1, Cycle 1
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 1, Cycle 2
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 2, Cycle 1
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_a].size()),2);
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_g].size()),2);
ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 2, Cycle 2
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,6);
// Cluster 3, Cycle 1
ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 3, Cycle 2
ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 4, Cycle 1
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_a].size()),1);
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_t].size()),1);
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_g].size()),1);
ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_c].size()),1);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
// Cluster 4, Cycle 2
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
ut.end_test_set();
}
static Ref_t create_detector(Detector& theDetector, xml_h element, SensitiveDetector sens) {
xml_det_t x_det = element;
Layering layering(x_det);
xml_dim_t dim = x_det.dimensions();
string det_name = x_det.nameStr();
//unused: string det_type = x_det.typeStr();
Material air = theDetector.air();
Material stavesMaterial = theDetector.material(x_det.materialStr());
int numSides = dim.numsides();
int det_id = x_det.id();
DetElement sdet(det_name,det_id);
PlacedVolume pVol;
// --- create an envelope volume and position it into the world ---------------------
Volume envelope = dd4hep::xml::createPlacedEnvelope( theDetector, element , sdet ) ;
sdet.setTypeFlag( DetType::CALORIMETER | DetType::ENDCAP | DetType::HADRONIC ) ;
if( theDetector.buildType() == BUILD_ENVELOPE ) return sdet ;
//-----------------------------------------------------------------------------------
sens.setType("calorimeter");
DetElement stave_det("module0stave0",det_id);
// The way to reaad constant from XML/Detector file.
double Hcal_radiator_thickness = theDetector.constant<double>("Hcal_radiator_thickness");
double Hcal_endcap_lateral_structure_thickness = theDetector.constant<double>("Hcal_endcap_lateral_structure_thickness");
double Hcal_endcap_layer_air_gap = theDetector.constant<double>("Hcal_endcap_layer_air_gap");
//double Hcal_cells_size = theDetector.constant<double>("Hcal_cells_size");
double HcalEndcap_inner_radius = theDetector.constant<double>("HcalEndcap_inner_radius");
double HcalEndcap_outer_radius = theDetector.constant<double>("HcalEndcap_outer_radius");
double HcalEndcap_min_z = theDetector.constant<double>("HcalEndcap_min_z");
double HcalEndcap_max_z = theDetector.constant<double>("HcalEndcap_max_z");
double Hcal_steel_cassette_thickness = theDetector.constant<double>("Hcal_steel_cassette_thickness");
double HcalServices_outer_FR4_thickness = theDetector.constant<double>("HcalServices_outer_FR4_thickness");
double HcalServices_outer_Cu_thickness = theDetector.constant<double>("HcalServices_outer_Cu_thickness");
double Hcal_endcap_services_module_width = theDetector.constant<double>("Hcal_endcap_services_module_width");
Material stainless_steel = theDetector.material("stainless_steel");
Material PCB = theDetector.material("PCB");
Material copper = theDetector.material("Cu");
std::cout <<"\n HcalEndcap_inner_radius = "
<<HcalEndcap_inner_radius/dd4hep::mm <<" mm"
<<"\n HcalEndcap_outer_radius = "
<<HcalEndcap_outer_radius/dd4hep::mm <<" mm"
<<"\n HcalEndcap_min_z = "
<<HcalEndcap_min_z/dd4hep::mm <<" mm"
<<"\n HcalEndcap_max_z = "
<<HcalEndcap_max_z/dd4hep::mm <<" mm"
<<std::endl;
Readout readout = sens.readout();
Segmentation seg = readout.segmentation();
std::vector<double> cellSizeVector = seg.segmentation()->cellDimensions(0); //Assume uniform cell sizes, provide dummy cellID
double cell_sizeX = cellSizeVector[0];
double cell_sizeY = cellSizeVector[1];
//========== fill data for reconstruction ============================
LayeredCalorimeterData* caloData = new LayeredCalorimeterData ;
caloData->layoutType = LayeredCalorimeterData::EndcapLayout ;
caloData->inner_symmetry = 4 ; // hard code cernter box hole
caloData->outer_symmetry = 0 ; // outer tube, or 8 for Octagun
caloData->phi0 = 0 ;
/// extent of the calorimeter in the r-z-plane [ rmin, rmax, zmin, zmax ] in mm.
caloData->extent[0] = HcalEndcap_inner_radius ;
caloData->extent[1] = HcalEndcap_outer_radius ;
caloData->extent[2] = HcalEndcap_min_z ;
caloData->extent[3] = HcalEndcap_max_z ;
int endcapID = 0;
for(xml_coll_t c(x_det.child(_U(dimensions)),_U(dimensions)); c; ++c)
{
xml_comp_t l(c);
double dim_x = l.attr<double>(_Unicode(dim_x));
double dim_y = l.attr<double>(_Unicode(dim_y));
double dim_z = l.attr<double>(_Unicode(dim_z));
double pos_y = l.attr<double>(_Unicode(y_offset));
// Hcal Endcap module shape
double box_half_x= dim_x/2.0; // module width, all are same
double box_half_y= dim_y/2.0; // total thickness, all are same
double box_half_z= dim_z/2.0; // module length, changed,
double x_offset = box_half_x*numSides-box_half_x*endcapID*2.0-box_half_x;
double y_offset = pos_y;
Box EndcapModule(box_half_x,box_half_y,box_half_z);
// define the name of each endcap Module
string envelopeVol_name = det_name+_toString(endcapID,"_EndcapModule%d");
Volume envelopeVol(envelopeVol_name,EndcapModule,stavesMaterial);
// Set envelope volume attributes.
envelopeVol.setAttributes(theDetector,x_det.regionStr(),x_det.limitsStr(),x_det.visStr());
double FEE_half_x = box_half_x-Hcal_endcap_services_module_width/2.0;
double FEE_half_y = box_half_y;
double FEE_half_Z = Hcal_endcap_services_module_width/2.0;
Box FEEBox(FEE_half_x,FEE_half_y,FEE_half_Z);
Volume FEEModule("Hcal_endcap_FEE",FEEBox,air);
double FEELayer_thickness = Hcal_steel_cassette_thickness + HcalServices_outer_FR4_thickness + HcalServices_outer_Cu_thickness;
Box FEELayerBox(FEE_half_x,FEELayer_thickness/2.0,FEE_half_Z);
Volume FEELayer("FEELayer",FEELayerBox,air);
Box FEELayerSteelBox(FEE_half_x,Hcal_steel_cassette_thickness/2.0,FEE_half_Z);
Volume FEELayerSteel("FEELayerSteel",FEELayerSteelBox,stainless_steel);
pVol = FEELayer.placeVolume(FEELayerSteel,
Position(0,
(-FEELayer_thickness/2.0
+Hcal_steel_cassette_thickness/2.0),
0));
Box FEELayerFR4Box(FEE_half_x,HcalServices_outer_FR4_thickness/2.0,FEE_half_Z);
Volume FEELayerFR4("FEELayerFR4",FEELayerFR4Box,PCB);
pVol = FEELayer.placeVolume(FEELayerFR4,
Position(0,
(-FEELayer_thickness/2.0+Hcal_steel_cassette_thickness
+HcalServices_outer_FR4_thickness/2.0),
0));
Box FEELayerCuBox(FEE_half_x,HcalServices_outer_Cu_thickness/2.0,FEE_half_Z);
Volume FEELayerCu("FEELayerCu",FEELayerCuBox,copper);
pVol = FEELayer.placeVolume(FEELayerCu,
Position(0,
(-FEELayer_thickness/2.0+Hcal_steel_cassette_thickness+HcalServices_outer_FR4_thickness
+HcalServices_outer_Cu_thickness/2.0),
0));
// ========= Create Hcal Chamber (i.e. Layers) ==============================
// It will be the sub volume for placing the slices.
// Itself will be placed into the Hcal Endcap modules envelope.
// ==========================================================================
// create Layer (air) and place the slices (Polystyrene,Cu,FR4,air) into it.
// place the Layer into the Hcal Endcap Modules envelope (stavesMaterial).
// First Hcal Chamber position, start after first radiator
double layer_pos_y = - box_half_y + Hcal_radiator_thickness;
// Create Hcal Endcap Chamber without radiator
// Place into the Hcal Encap module envelope, after each radiator
int layer_num = 1;
for(xml_coll_t m(x_det,_U(layer)); m; ++m) {
xml_comp_t x_layer = m;
int repeat = x_layer.repeat(); // Get number of layers.
double layer_thickness = layering.layer(layer_num)->thickness();
string layer_name = envelopeVol_name+"_layer";
DetElement layer(stave_det,layer_name,det_id);
// Active Layer box & volume
double active_layer_dim_x = box_half_x - Hcal_endcap_lateral_structure_thickness - Hcal_endcap_layer_air_gap;
double active_layer_dim_y = layer_thickness/2.0;
double active_layer_dim_z = box_half_z;
// Build chamber including air gap
// The Layer will be filled with slices,
Volume layer_vol(layer_name, Box((active_layer_dim_x + Hcal_endcap_layer_air_gap),
active_layer_dim_y,active_layer_dim_z), air);
LayeredCalorimeterData::Layer caloLayer ;
caloLayer.cellSize0 = cell_sizeX;
caloLayer.cellSize1 = cell_sizeY;
// ========= Create sublayer slices =========================================
// Create and place the slices into Layer
// ==========================================================================
// Create the slices (sublayers) within the Hcal Chamber.
double slice_pos_y = -(layer_thickness / 2.0);
int slice_number = 0;
double nRadiationLengths=0.;
double nInteractionLengths=0.;
double thickness_sum=0;
nRadiationLengths = Hcal_radiator_thickness/(stavesMaterial.radLength());
nInteractionLengths = Hcal_radiator_thickness/(stavesMaterial.intLength());
thickness_sum = Hcal_radiator_thickness;
for(xml_coll_t k(x_layer,_U(slice)); k; ++k) {
xml_comp_t x_slice = k;
string slice_name = layer_name + _toString(slice_number,"_slice%d");
double slice_thickness = x_slice.thickness();
Material slice_material = theDetector.material(x_slice.materialStr());
DetElement slice(layer,_toString(slice_number,"slice%d"),det_id);
slice_pos_y += slice_thickness / 2.0;
// Slice volume & box
Volume slice_vol(slice_name,Box(active_layer_dim_x,slice_thickness/2.0,active_layer_dim_z),slice_material);
nRadiationLengths += slice_thickness/(2.*slice_material.radLength());
nInteractionLengths += slice_thickness/(2.*slice_material.intLength());
thickness_sum += slice_thickness/2;
if ( x_slice.isSensitive() ) {
sens.setType("calorimeter");
slice_vol.setSensitiveDetector(sens);
#if DD4HEP_VERSION_GE( 0, 15 )
//Store "inner" quantities
caloLayer.inner_nRadiationLengths = nRadiationLengths;
caloLayer.inner_nInteractionLengths = nInteractionLengths;
caloLayer.inner_thickness = thickness_sum;
//Store scintillator thickness
caloLayer.sensitive_thickness = slice_thickness;
#endif
//Reset counters to measure "outside" quantitites
nRadiationLengths=0.;
nInteractionLengths=0.;
thickness_sum = 0.;
}
nRadiationLengths += slice_thickness/(2.*slice_material.radLength());
nInteractionLengths += slice_thickness/(2.*slice_material.intLength());
thickness_sum += slice_thickness/2;
// Set region, limitset, and vis.
slice_vol.setAttributes(theDetector,x_slice.regionStr(),x_slice.limitsStr(),x_slice.visStr());
// slice PlacedVolume
PlacedVolume slice_phv = layer_vol.placeVolume(slice_vol,Position(0,slice_pos_y,0));
//slice_phv.addPhysVolID("slice",slice_number);
slice.setPlacement(slice_phv);
// Increment Z position for next slice.
slice_pos_y += slice_thickness / 2.0;
// Increment slice number.
++slice_number;
}
// Set region, limitset, and vis.
layer_vol.setAttributes(theDetector,x_layer.regionStr(),x_layer.limitsStr(),x_layer.visStr());
#if DD4HEP_VERSION_GE( 0, 15 )
//Store "outer" quantities
caloLayer.outer_nRadiationLengths = nRadiationLengths;
caloLayer.outer_nInteractionLengths = nInteractionLengths;
caloLayer.outer_thickness = thickness_sum;
#endif
// ========= Place the Layer (i.e. Chamber) =================================
// Place the Layer into the Hcal Endcap module envelope.
// with the right position and rotation.
// Registry the IDs (layer, stave, module).
// Place the same layer 48 times into Endcap module
// ==========================================================================
for (int j = 0; j < repeat; j++) {
// Layer position in y within the Endcap Modules.
layer_pos_y += layer_thickness / 2.0;
PlacedVolume layer_phv = envelopeVol.placeVolume(layer_vol,
Position(0,layer_pos_y,0));
// registry the ID of Layer, stave and module
layer_phv.addPhysVolID("layer",layer_num);
// then setPlacement for it.
layer.setPlacement(layer_phv);
pVol = FEEModule.placeVolume(FEELayer,
Position(0,layer_pos_y,0));
//-----------------------------------------------------------------------------------------
if ( caloData->layers.size() < (unsigned int)repeat ) {
caloLayer.distance = HcalEndcap_min_z + box_half_y + layer_pos_y
- caloLayer.inner_thickness ; // Will be added later at "DDMarlinPandora/DDGeometryCreator.cc:226" to get center of sensitive element
caloLayer.absorberThickness = Hcal_radiator_thickness ;
caloData->layers.push_back( caloLayer ) ;
}
//-----------------------------------------------------------------------------------------
// ===== Prepare for next layer (i.e. next Chamber) =========================
// Prepare the chamber placement position and the chamber dimension
// ==========================================================================
// Increment the layer_pos_y
// Place Hcal Chamber after each radiator
layer_pos_y += layer_thickness / 2.0;
layer_pos_y += Hcal_radiator_thickness;
++layer_num;
}
}
// =========== Place Hcal Endcap envelope ===================================
// Finally place the Hcal Endcap envelope into the world volume.
// Registry the stave(up/down), module(left/right) and endcapID.
// ==========================================================================
// Acording to the number of staves and modules,
// Place the same Hcal Endcap module volume into the world volume
// with the right position and rotation.
for(int stave_num=0;stave_num<2;stave_num++){
double EndcapModule_pos_x = 0;
double EndcapModule_pos_y = 0;
double EndcapModule_pos_z = 0;
double rot_EM = 0;
double EndcapModule_center_pos_z = HcalEndcap_min_z + box_half_y;
double FEEModule_pos_x = 0;
double FEEModule_pos_y = 0;
double FEEModule_pos_z = 0;
double FEEModule_center_pos_z = HcalEndcap_min_z + box_half_y;
switch (stave_num)
{
case 0 :
EndcapModule_pos_x = x_offset;
EndcapModule_pos_y = y_offset;
FEEModule_pos_x = x_offset;
FEEModule_pos_y = y_offset + box_half_z + Hcal_endcap_services_module_width/2.0;
break;
case 1 :
EndcapModule_pos_x = -x_offset;
EndcapModule_pos_y = -y_offset;
FEEModule_pos_x = -x_offset;
FEEModule_pos_y = -y_offset - box_half_z - Hcal_endcap_services_module_width/2.0;
break;
}
for(int module_num=0;module_num<2;module_num++) {
int module_id = (module_num==0)? 0:6;
rot_EM = (module_id==0)?(-M_PI/2.0):(M_PI/2.0);
EndcapModule_pos_z = (module_id==0)? -EndcapModule_center_pos_z:EndcapModule_center_pos_z;
PlacedVolume env_phv = envelope.placeVolume(envelopeVol,
Transform3D(RotationX(rot_EM),
Translation3D(EndcapModule_pos_x,
EndcapModule_pos_y,
EndcapModule_pos_z)));
env_phv.addPhysVolID("tower",endcapID);
env_phv.addPhysVolID("stave",stave_num); // y: up /down
env_phv.addPhysVolID("module",module_id); // z: -/+ 0/6
env_phv.addPhysVolID("system",det_id);
FEEModule_pos_z = (module_id==0)? -FEEModule_center_pos_z:FEEModule_center_pos_z;
if (!(endcapID==0))
env_phv = envelope.placeVolume(FEEModule,
Transform3D(RotationX(rot_EM),
Translation3D(FEEModule_pos_x,
FEEModule_pos_y,
FEEModule_pos_z)));
DetElement sd = (module_num==0&&stave_num==0) ? stave_det : stave_det.clone(_toString(module_id,"module%d")+_toString(stave_num,"stave%d"));
sd.setPlacement(env_phv);
}
}
endcapID++;
}
sdet.addExtension< LayeredCalorimeterData >( caloData ) ;
return sdet;
}
static Ref_t create_detector(Detector& theDetector, xml_h element, SensitiveDetector sens) {
static double tolerance = 0e0;
xml_det_t x_det = element;
string det_name = x_det.nameStr();
Layering layering (element);
Material air = theDetector.air();
//unused: Material vacuum = theDetector.vacuum();
int det_id = x_det.id();
xml_comp_t x_staves = x_det.staves();
DetElement sdet (det_name,det_id);
xml_comp_t x_dim = x_det.dimensions();
int nsides = x_dim.numsides();
double dphi = (2*M_PI/nsides);
double hphi = dphi/2;
// --- create an envelope volume and position it into the world ---------------------
Volume envelope = dd4hep::xml::createPlacedEnvelope( theDetector, element , sdet ) ;
dd4hep::xml::setDetectorTypeFlag( element, sdet ) ;
if( theDetector.buildType() == BUILD_ENVELOPE ) return sdet ;
//-----------------------------------------------------------------------------------
sens.setType("calorimeter");
Material stave_material = theDetector.material(x_staves.materialStr());
DetElement stave_det("module0stave0",det_id);
Readout readout = sens.readout();
Segmentation seg = readout.segmentation();
// check if we have a WaferGridXY segmentation :
WaferGridXY* waferSeg =
dynamic_cast< WaferGridXY*>( seg.segmentation() ) ;
std::vector<double> cellSizeVector = seg.segmentation()->cellDimensions(0); //Assume uniform cell sizes, provide dummy cellID
double cell_sizeX = cellSizeVector[0];
double cell_sizeY = cellSizeVector[1];
//====================================================================
//
// Read all the constant from ILD_o1_v05.xml
// Use them to build HcalBarrel
//
//====================================================================
int N_FIBERS_W_STRUCTURE = 2;
int N_FIBERS_ALVOULUS = 3;
// read parametere from compact.xml file
double Ecal_Alveolus_Air_Gap = theDetector.constant<double>("Ecal_Alveolus_Air_Gap");
double Ecal_Slab_shielding = theDetector.constant<double>("Ecal_Slab_shielding");
double Ecal_Slab_copper_thickness = theDetector.constant<double>("Ecal_Slab_copper_thickness");
double Ecal_Slab_PCB_thickness = theDetector.constant<double>("Ecal_Slab_PCB_thickness");
double Ecal_Slab_glue_gap = theDetector.constant<double>("Ecal_Slab_glue_gap");
double Ecal_Slab_ground_thickness = theDetector.constant<double>("Ecal_Slab_ground_thickness");
double Ecal_fiber_thickness = theDetector.constant<double>("Ecal_fiber_thickness");
double Ecal_Si_thickness = theDetector.constant<double>("Ecal_Si_thickness");
double Ecal_inner_radius = theDetector.constant<double>("TPC_outer_radius") +theDetector.constant<double>("Ecal_Tpc_gap");
double Ecal_radiator_thickness1 = theDetector.constant<double>("Ecal_radiator_layers_set1_thickness");
double Ecal_radiator_thickness2 = theDetector.constant<double>("Ecal_radiator_layers_set2_thickness");
double Ecal_radiator_thickness3 = theDetector.constant<double>("Ecal_radiator_layers_set3_thickness");
double Ecal_Barrel_halfZ = theDetector.constant<double>("Ecal_Barrel_halfZ");
double Ecal_support_thickness = theDetector.constant<double>("Ecal_support_thickness");
double Ecal_front_face_thickness = theDetector.constant<double>("Ecal_front_face_thickness");
double Ecal_lateral_face_thickness = theDetector.constant<double>("Ecal_lateral_face_thickness");
double Ecal_Slab_H_fiber_thickness = theDetector.constant<double>("Ecal_Slab_H_fiber_thickness");
double Ecal_Slab_Sc_PCB_thickness = theDetector.constant<double>("Ecal_Slab_Sc_PCB_thickness");
double Ecal_Sc_thickness = theDetector.constant<double>("Ecal_Sc_thickness");
double Ecal_Sc_reflector_thickness = theDetector.constant<double>("Ecal_Sc_reflector_thickness");
int Ecal_nlayers1 = theDetector.constant<int>("Ecal_nlayers1");
int Ecal_nlayers2 = theDetector.constant<int>("Ecal_nlayers2");
int Ecal_nlayers3 = theDetector.constant<int>("Ecal_nlayers3");
int Ecal_barrel_number_of_towers = theDetector.constant<int>("Ecal_barrel_number_of_towers");
//double Ecal_cells_size = theDetector.constant<double>("Ecal_cells_size");
double Ecal_guard_ring_size = theDetector.constant<double>("Ecal_guard_ring_size");
//====================================================================
//
// general calculated parameters
//
//====================================================================
double Ecal_total_SiSlab_thickness =
Ecal_Slab_shielding +
Ecal_Slab_copper_thickness +
Ecal_Slab_PCB_thickness +
Ecal_Slab_glue_gap +
Ecal_Si_thickness +
Ecal_Slab_ground_thickness +
Ecal_Alveolus_Air_Gap / 2;
#ifdef VERBOSE
std::cout << " Ecal_total_SiSlab_thickness = " << Ecal_total_SiSlab_thickness << std::endl;
#endif
double Ecal_total_ScSlab_thickness =
Ecal_Slab_shielding +
Ecal_Slab_copper_thickness +
Ecal_Slab_Sc_PCB_thickness +
Ecal_Sc_thickness +
Ecal_Sc_reflector_thickness * 2 +
Ecal_Alveolus_Air_Gap / 2;
#ifdef VERBOSE
std::cout << " Ecal_total_ScSlab_thickness = " << Ecal_total_ScSlab_thickness << std::endl;
#endif
int Number_of_Si_Layers_in_Barrel = 0;
int Number_of_Sc_Layers_in_Barrel = 0;
#ifdef VERBOSE
std::cout << " Ecal total number of Silicon layers = " << Number_of_Si_Layers_in_Barrel << std::endl;
std::cout << " Ecal total number of Scintillator layers = " << Number_of_Sc_Layers_in_Barrel << std::endl;
#endif
// In this release the number of modules is fixed to 5
double Ecal_Barrel_module_dim_z = 2 * Ecal_Barrel_halfZ / 5. ;
#ifdef VERBOSE
std::cout << "Ecal_Barrel_module_dim_z = " << Ecal_Barrel_module_dim_z << std::endl;
#endif
// The alveolus size takes in account the module Z size
// but also 4 fiber layers for the alveoulus wall, the all
// divided by the number of towers
double alveolus_dim_z =
(Ecal_Barrel_module_dim_z - 2. * Ecal_lateral_face_thickness) /
Ecal_barrel_number_of_towers -
2 * N_FIBERS_ALVOULUS * Ecal_fiber_thickness -
2 * Ecal_Slab_H_fiber_thickness -
2 * Ecal_Slab_shielding;
#ifdef VERBOSE
std::cout << "alveolus_dim_z = " << alveolus_dim_z << std::endl;
#endif
int n_total_layers = Ecal_nlayers1 + Ecal_nlayers2 + Ecal_nlayers3;
Number_of_Si_Layers_in_Barrel = n_total_layers+1;
double module_thickness =
Ecal_nlayers1 * Ecal_radiator_thickness1 +
Ecal_nlayers2 * Ecal_radiator_thickness2 +
Ecal_nlayers3 * Ecal_radiator_thickness3 +
int(n_total_layers/2) * // fiber around W struct layers
(N_FIBERS_W_STRUCTURE * 2 * Ecal_fiber_thickness) +
Number_of_Si_Layers_in_Barrel * // Silicon slabs plus fiber around and inside
(Ecal_total_SiSlab_thickness +
(N_FIBERS_ALVOULUS + 1 ) * Ecal_fiber_thickness) +
Number_of_Sc_Layers_in_Barrel * // Scintillator slabs plus fiber around and inside
(Ecal_total_ScSlab_thickness +
(N_FIBERS_ALVOULUS + 1 ) * Ecal_fiber_thickness) +
Ecal_support_thickness + Ecal_front_face_thickness;
#ifdef VERBOSE
std::cout << "For information : module_thickness = " << module_thickness << std::endl;
#endif
// module barrel key parameters
double bottom_dim_x = 2. * tan(M_PI/8.) * Ecal_inner_radius +
module_thickness/sin(M_PI/4.);
double top_dim_x = bottom_dim_x - 2 * module_thickness;
//------------------------------------------------------------------------------------
LayeredCalorimeterData::Layer caloLayer ;
caloLayer.cellSize0 = cell_sizeX;
caloLayer.cellSize1 = cell_sizeY;
//== For Wafer ===
double cell_dim_x = caloLayer.cellSize0;
double total_Si_dim_z = alveolus_dim_z;
double util_SI_wafer_dim_z =
total_Si_dim_z/2 - 2 * Ecal_guard_ring_size;
double cell_dim_z = util_SI_wafer_dim_z/
floor(util_SI_wafer_dim_z/
cell_dim_x);
int N_cells_in_Z = int(util_SI_wafer_dim_z/cell_dim_z);
int N_cells_in_X = N_cells_in_Z;
cell_dim_x = cell_dim_z;
#ifdef VERBOSE
std::cout << " bottom_dim_x = " << bottom_dim_x << std::endl;
std::cout << " top_dim_x = " << top_dim_x << std::endl;
std::cout << " Ecal total number of Silicon layers = " << Number_of_Si_Layers_in_Barrel << std::endl;
std::cout << " Ecal total number of Scintillator layers = " << Number_of_Sc_Layers_in_Barrel << std::endl;
#endif
// ========= Create Ecal Barrel stave ====================================
// It will be the volume for palcing the Ecal Barrel alveolus(i.e. Layers).
// And the structure W plate.
// Itself will be placed into the world volume.
// ==========================================================================
// The TOP_X and BOTTOM_X is different in Mokka and DD4hep
Trapezoid trd(top_dim_x / 2,
bottom_dim_x / 2,
Ecal_Barrel_module_dim_z / 2,
Ecal_Barrel_module_dim_z / 2,
module_thickness/2);
// Volume mod_vol(det_name+"_module",trd,theDetector.material("g10"));
Volume mod_vol(det_name+"_module",trd,theDetector.material("CarbonFiber")); // DJeans 5-sep-2016
// We count the layers starting from IP and from 1,
// so odd layers should be inside slabs and
// even ones on the structure.
// The structure W layers are here big plans, as the
// gap between each W plate is too small to create problems
// The even W layers are part of H structure placed inside
// the alveolus.
// ############################
// Dimension of radiator wLog
// slice provide the thickness
// ############################
double y_floor =
Ecal_front_face_thickness +
N_FIBERS_ALVOULUS * Ecal_fiber_thickness;
// ############################
// Dimension of alveolus
// slice provide the thickness
// ############################
// ===== build Si Slab and put into the Layer volume =====
// ===== place the layer into the module 5 time for one full layer into the trd module ====
// ===== build and place barrel structure into trd module ====
// Parameters for computing the layer X dimension:
double stave_z =(Ecal_Barrel_module_dim_z - 2. * Ecal_lateral_face_thickness) / Ecal_barrel_number_of_towers/2.;
double l_dim_x = bottom_dim_x/2.; // Starting X dimension for the layer.
double l_pos_z = module_thickness/2;
l_dim_x -= y_floor;
l_pos_z -= y_floor;
// ------------- create extension objects for reconstruction -----------------
//========== fill data for reconstruction ============================
LayeredCalorimeterData* caloData = new LayeredCalorimeterData ;
caloData->layoutType = LayeredCalorimeterData::BarrelLayout ;
caloData->inner_symmetry = nsides ;
//added by Thorben Quast
caloData->outer_symmetry = nsides ;
caloData->phi0 = 0 ; // hardcoded
/// extent of the calorimeter in the r-z-plane [ rmin, rmax, zmin, zmax ] in mm.
caloData->extent[0] = Ecal_inner_radius ;
//line fixed by Thorben Quast since actual conversion is made during the drawing
caloData->extent[1] = ( Ecal_inner_radius + module_thickness );
//caloData->extent[1] = ( Ecal_inner_radius + module_thickness ) / cos( M_PI/8. ) ;
caloData->extent[2] = 0. ;
caloData->extent[3] = Ecal_Barrel_halfZ ;
// // base vectors for surfaces:
// dd4hep::rec::Vector3D u(1,0,0) ;
// dd4hep::rec::Vector3D v(0,1,0) ;
// dd4hep::rec::Vector3D n(0,0,1) ;
//-------------------- start loop over ECAL layers ----------------------
// Loop over the sets of layer elements in the detector.
double nRadiationLengths = 0. ;
double nInteractionLengths = 0. ;
double thickness_sum = 0. ;
nRadiationLengths = Ecal_radiator_thickness1/(stave_material.radLength())
+ y_floor/air.radLength();
nInteractionLengths = Ecal_radiator_thickness1/(stave_material.intLength())
+ y_floor/air.intLength();
thickness_sum = Ecal_radiator_thickness1 + y_floor;
int l_num = 1;
bool isFirstSens = true;
int myLayerNum = 0 ;
for(xml_coll_t li(x_det,_U(layer)); li; ++li) {
xml_comp_t x_layer = li;
int repeat = x_layer.repeat();
// Loop over number of repeats for this layer.
for (int j=0; j<repeat; j++) {
string l_name = _toString(l_num,"layer%d");
double l_thickness = layering.layer(l_num-1)->thickness(); // Layer's thickness.
double xcut = (l_thickness); // X dimension for this layer.
l_dim_x -= xcut;
Box l_box(l_dim_x-tolerance,stave_z-tolerance,l_thickness/2.0-tolerance);
Volume l_vol(det_name+"_"+l_name,l_box,air);
l_vol.setVisAttributes(theDetector.visAttributes(x_layer.visStr()));
//fg: need vector of DetElements for towers !
// DetElement layer(stave_det, l_name, det_id);
std::vector< DetElement > layers( Ecal_barrel_number_of_towers ) ;
// place layer 5 times in module. at same layer position (towers !)
double l_pos_y = Ecal_Barrel_module_dim_z / 2.
- ( Ecal_lateral_face_thickness +
Ecal_fiber_thickness * N_FIBERS_ALVOULUS +
Ecal_Slab_shielding +
Ecal_Slab_H_fiber_thickness +
alveolus_dim_z /2.);
for (int i=0; i<Ecal_barrel_number_of_towers; i++){ // need four clone
layers[i] = DetElement( stave_det, l_name+_toString(i,"tower%02d") , det_id ) ;
Position l_pos(0,l_pos_y,l_pos_z-l_thickness/2.); // Position of the layer.
PlacedVolume layer_phv = mod_vol.placeVolume(l_vol,l_pos);
// layer_phv.addPhysVolID("layer", l_num);
layer_phv.addPhysVolID("tower", i);
layers[i].setPlacement(layer_phv);
l_pos_y -= (alveolus_dim_z +
2. * Ecal_fiber_thickness * N_FIBERS_ALVOULUS +
2. * Ecal_Slab_H_fiber_thickness +
2. * Ecal_Slab_shielding);
}
// Loop over the sublayers or slices for this layer.
int s_num = 1;
double s_pos_z = l_thickness / 2.;
//--------------------------------------------------------------------------------
// BuildBarrelAlveolus: BuildSiliconSlab:
//--------------------------------------------------------------------------------
double radiator_dim_y = Ecal_radiator_thickness1; //to be updated with slice radiator thickness
for(xml_coll_t si(x_layer,_U(slice)); si; ++si) {
xml_comp_t x_slice = si;
string s_name = _toString(s_num,"slice%d");
double s_thick = x_slice.thickness();
Material slice_material = theDetector.material(x_slice.materialStr());
#ifdef VERBOSE
std::cout<<"Ecal_barrel_number_of_towers: "<< Ecal_barrel_number_of_towers <<std::endl;
#endif
double slab_dim_x = l_dim_x-tolerance;
double slab_dim_y = s_thick/2.;
double slab_dim_z = stave_z-tolerance;
Box s_box(slab_dim_x,slab_dim_z,slab_dim_y);
Volume s_vol(det_name+"_"+l_name+"_"+s_name,s_box,slice_material);
//fg: not needed DetElement slice(layer,s_name,det_id);
s_vol.setVisAttributes(theDetector.visAttributes(x_slice.visStr()));
#ifdef VERBOSE
std::cout<<"x_slice.materialStr(): "<< x_slice.materialStr() <<std::endl;
#endif
if (x_slice.materialStr().compare(x_staves.materialStr()) == 0){
radiator_dim_y = s_thick;
// W StructureLayer has the same thickness as W radiator layer in the Alveolus layer
#if DD4HEP_VERSION_GE( 0, 15 )
caloLayer.outer_nRadiationLengths = nRadiationLengths;
caloLayer.outer_nInteractionLengths = nInteractionLengths;
caloLayer.outer_thickness = thickness_sum;
if (!isFirstSens){ caloData->layers.push_back( caloLayer ) ;
#ifdef VERBOSE
std::cout<<" caloLayer.distance: "<< caloLayer.distance <<std::endl;
std::cout<<" caloLayer.inner_nRadiationLengths: "<< caloLayer.inner_nRadiationLengths <<std::endl;
std::cout<<" caloLayer.inner_nInteractionLengths: "<< caloLayer.inner_nInteractionLengths <<std::endl;
std::cout<<" caloLayer.inner_thickness: "<< caloLayer.inner_thickness <<std::endl;
std::cout<<" caloLayer.sensitive_thickness: "<< caloLayer.sensitive_thickness <<std::endl;
std::cout<<" caloLayer.outer_nRadiationLengths: "<< caloLayer.outer_nRadiationLengths <<std::endl;
std::cout<<" caloLayer.outer_nInteractionLengths: "<< caloLayer.outer_nInteractionLengths <<std::endl;
std::cout<<" caloLayer.outer_thickness: "<< caloLayer.outer_thickness <<std::endl;
std::cout<<" EcalBarrel[1]==>caloLayer.inner_thickness + caloLayer.outer_thickness: "
<< caloLayer.inner_thickness + caloLayer.outer_thickness <<std::endl;
#endif
}
#endif
// Init for inner
nRadiationLengths = 0. ;
nInteractionLengths = 0. ;
thickness_sum = 0. ;
isFirstSens = false;
}
nRadiationLengths += s_thick/(2.*slice_material.radLength());
nInteractionLengths += s_thick/(2.*slice_material.intLength());
thickness_sum += s_thick/2.;
if ( x_slice.isSensitive() ) {
//s_vol.setSensitiveDetector(sens);
// Normal squared wafers
double wafer_dim_x =
N_cells_in_X * cell_dim_x;
double wafer_dim_z =
N_cells_in_Z * cell_dim_z;
Box WaferSiSolid( wafer_dim_x/2,wafer_dim_z/2,slab_dim_y);
//Volume WaferSiLog(det_name+"_"+l_name+"_"+s_name+"Wafer",WaferSiSolid,slice_material);
//WaferSiLog.setSensitiveDetector(sens);
double real_wafer_size_x =
wafer_dim_x + 2 * Ecal_guard_ring_size;
int n_wafers_x =
int(floor(slab_dim_x*2 / real_wafer_size_x));
double wafer_pos_x =
-slab_dim_x +
Ecal_guard_ring_size +
wafer_dim_x /2 ;
int n_wafer_x;
int wafer_num = 0;
for (n_wafer_x = 1;
n_wafer_x < n_wafers_x + 1;
n_wafer_x++)
{
double wafer_pos_z =
-alveolus_dim_z/2.0 +
Ecal_guard_ring_size +
wafer_dim_z /2;
for (int n_wafer_z = 1;
n_wafer_z < 3;
n_wafer_z++)
{
wafer_num++;
string Wafer_name = _toString(wafer_num,"wafer%d");
Volume WaferSiLog(det_name+"_"+l_name+"_"+s_name+"_"+Wafer_name,WaferSiSolid,slice_material);
WaferSiLog.setSensitiveDetector(sens);
//WaferSiLog.setVisAttributes(theDetector.visAttributes(x_slice.visStr()));
PlacedVolume wafer_phv = s_vol.placeVolume(WaferSiLog,Position(wafer_pos_x,
wafer_pos_z,
0));
wafer_phv.addPhysVolID("wafer", wafer_num);
// Normal squared wafers, this waferOffsetX is 0.0
waferSeg->setWaferOffsetX(myLayerNum, wafer_num, 0.0);
wafer_pos_z +=
wafer_dim_z +
2 * Ecal_guard_ring_size;
}
wafer_pos_x +=
wafer_dim_x +
2 * Ecal_guard_ring_size;
}
// Magic wafers to complete the slab...
// (wafers with variable number of cells just
// to complete the slab. in reality we think that
// we'll have just a few models of special wafers
// for that.
double resting_dim_x =
slab_dim_x*2 -
(wafer_dim_x + 2 * Ecal_guard_ring_size) *
n_wafers_x;
if(resting_dim_x >
(cell_dim_x + 2 * Ecal_guard_ring_size))
{
int N_cells_x_remaining =
int(floor((resting_dim_x -
2 * Ecal_guard_ring_size)
/cell_dim_x));
wafer_dim_x =
N_cells_x_remaining *
cell_dim_x;
Box MagicWaferSiSolid( wafer_dim_x/2,wafer_dim_z/2,slab_dim_y);
//Volume MagicWaferSiLog(det_name+"_"+l_name+"_"+s_name+"MagicWafer",MagicWaferSiSolid,slice_material);
// Magic wafers, this waferOffsetX has to be taken care, 0.0 or half cell size in X.
double thisWaferOffsetX = 0.0;
if ( N_cells_x_remaining%2 ) thisWaferOffsetX = cell_dim_x/2.0;
wafer_pos_x =
-slab_dim_x +
n_wafers_x * real_wafer_size_x +
(wafer_dim_x + 2 * Ecal_guard_ring_size)/2;
real_wafer_size_x =
wafer_dim_x + 2 * Ecal_guard_ring_size;
double wafer_pos_z =
-alveolus_dim_z/2.0 +
Ecal_guard_ring_size +
wafer_dim_z /2;
//int MagicWafer_num = 0;
for (int n_wafer_z = 1;
n_wafer_z < 3;
n_wafer_z++)
{
wafer_num++;
string MagicWafer_name = _toString(wafer_num,"MagicWafer%d");
Volume MagicWaferSiLog(det_name+"_"+l_name+"_"+s_name+"_"+MagicWafer_name,MagicWaferSiSolid,slice_material);
MagicWaferSiLog.setSensitiveDetector(sens);
//MagicWaferSiLog.setVisAttributes(theDetector.visAttributes(x_slice.visStr()));
PlacedVolume wafer_phv = s_vol.placeVolume(MagicWaferSiLog,Position(wafer_pos_x,
wafer_pos_z,
0));
wafer_phv.addPhysVolID("wafer", wafer_num);
// Magic wafers, set the waferOffsetX for this layer this wafer.
waferSeg->setWaferOffsetX(myLayerNum, wafer_num, thisWaferOffsetX);
wafer_pos_z +=
wafer_dim_z +
2 * Ecal_guard_ring_size;
}
}
#if DD4HEP_VERSION_GE( 0, 15 )
//Store "inner" quantities
caloLayer.inner_nRadiationLengths = nRadiationLengths ;
caloLayer.inner_nInteractionLengths = nInteractionLengths ;
caloLayer.inner_thickness = thickness_sum ;
//Store sensitive slice thickness
caloLayer.sensitive_thickness = s_thick ;
#ifdef VERBOSE
std::cout<<" l_num: "<<l_num <<std::endl;
std::cout<<" s_num: "<<s_num <<std::endl;
std::cout<<" Ecal_inner_radius: "<< Ecal_inner_radius <<std::endl;
std::cout<<" module_thickness: "<< module_thickness <<std::endl;
std::cout<<" l_pos_z: "<< l_pos_z <<std::endl;
std::cout<<" l_thickness: "<< l_thickness <<std::endl;
std::cout<<" s_pos_z: "<< s_pos_z <<std::endl;
std::cout<<" s_thick: "<< s_thick <<std::endl;
std::cout<<" radiator_dim_y: "<< radiator_dim_y <<std::endl;
#endif
//-----------------------------------------------------------------------------------------
caloLayer.distance = Ecal_inner_radius + module_thickness/2.0 - l_pos_z + l_thickness/2. + (s_pos_z+s_thick/2.)
- caloLayer.inner_thickness;
caloLayer.absorberThickness = radiator_dim_y ;
//-----------------------------------------------------------------------------------------
#endif
// Init for outer
nRadiationLengths = 0. ;
nInteractionLengths = 0. ;
thickness_sum = 0. ;
}
nRadiationLengths += s_thick/(2.*slice_material.radLength());
nInteractionLengths += s_thick/(2.*slice_material.intLength());
thickness_sum += s_thick/2;
// Slice placement.
PlacedVolume slice_phv = l_vol.placeVolume(s_vol,Position(0,0,s_pos_z-s_thick/2));
if ( x_slice.isSensitive() ) {
slice_phv.addPhysVolID("layer", myLayerNum++ );
// slice_phv.addPhysVolID("slice",s_num);
}
//fg: not needed slice.setPlacement(slice_phv);
// Increment Z position of slice.
s_pos_z -= s_thick;
// Increment slice number.
++s_num;
}
#if DD4HEP_VERSION_GE( 0, 15 )
caloLayer.outer_nRadiationLengths = nRadiationLengths
+ (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE))/air.radLength();
caloLayer.outer_nInteractionLengths = nInteractionLengths
+ (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE))/air.intLength();
caloLayer.outer_thickness = thickness_sum
+ (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE));
if (!isFirstSens) caloData->layers.push_back( caloLayer ) ;
#ifdef VERBOSE
std::cout<<" caloLayer.distance: "<< caloLayer.distance <<std::endl;
std::cout<<" caloLayer.inner_nRadiationLengths: "<< caloLayer.inner_nRadiationLengths <<std::endl;
std::cout<<" caloLayer.inner_nInteractionLengths: "<< caloLayer.inner_nInteractionLengths <<std::endl;
std::cout<<" caloLayer.inner_thickness: "<< caloLayer.inner_thickness <<std::endl;
std::cout<<" caloLayer.sensitive_thickness: "<< caloLayer.sensitive_thickness <<std::endl;
std::cout<<" caloLayer.outer_nRadiationLengths: "<< caloLayer.outer_nRadiationLengths <<std::endl;
std::cout<<" caloLayer.outer_nInteractionLengths: "<< caloLayer.outer_nInteractionLengths <<std::endl;
std::cout<<" caloLayer.outer_thickness: "<< caloLayer.outer_thickness <<std::endl;
std::cout<<" EcalBarrel[2]==>caloLayer.inner_thickness + caloLayer.outer_thickness: "
<< caloLayer.inner_thickness + caloLayer.outer_thickness <<std::endl;
#endif
#endif
// Init for next double layer
nRadiationLengths = radiator_dim_y/(stave_material.radLength())
+ (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE))/air.radLength();
nInteractionLengths = radiator_dim_y/(stave_material.intLength())
+ (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE))/air.intLength();
thickness_sum = radiator_dim_y
+ (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE));
if(radiator_dim_y <= 0) {
stringstream err;
err << " \n ERROR: The subdetector " << x_det.nameStr() << " geometry parameter -- radiator_dim_y = " << radiator_dim_y ;
err << " \n Please check the radiator material name in the subdetector xml file";
throw runtime_error(err.str());
}
// #########################
// BuildBarrelStructureLayer
// #########################
l_dim_x -= (radiator_dim_y + Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE));
double radiator_dim_x = l_dim_x*2.;
#ifdef VERBOSE
std::cout << "radiator_dim_x = " << radiator_dim_x << std::endl;
#endif
double radiator_dim_z =
Ecal_Barrel_module_dim_z -
2 * Ecal_lateral_face_thickness -
2 * N_FIBERS_W_STRUCTURE * Ecal_fiber_thickness;
string bs_name="bs";
Box barrelStructureLayer_box(radiator_dim_x/2.,radiator_dim_z/2.,radiator_dim_y/2.);
Volume barrelStructureLayer_vol(det_name+"_"+l_name+"_"+bs_name,barrelStructureLayer_box,stave_material);
barrelStructureLayer_vol.setVisAttributes(theDetector.visAttributes(x_layer.visStr()));
// Increment to next layer Z position.
l_pos_z -= l_thickness;
// Without last W StructureLayer, the last part is Si SD even layer.
// the last number of Ecal_nlayers1, Ecal_nlayers2 and Ecal_nlayers3 is odd.
int even_layer = l_num*2;
if(even_layer > Ecal_nlayers1 + Ecal_nlayers2 + Ecal_nlayers3) continue;
//if ( Number_of_Si_Layers_in_Barrel > n_total_layers ) continue;
double bsl_pos_z = l_pos_z - (radiator_dim_y/2. + Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE));
l_pos_z -= (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE));
Position bsl_pos(0,0,bsl_pos_z); // Position of the layer.
// PlacedVolume barrelStructureLayer_phv =
mod_vol.placeVolume(barrelStructureLayer_vol,bsl_pos);
l_dim_x -= (Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE));
l_pos_z -= (radiator_dim_y + Ecal_fiber_thickness * (N_FIBERS_ALVOULUS + N_FIBERS_W_STRUCTURE));
++l_num;
}
}
// Set stave visualization.
if (x_staves) {
mod_vol.setVisAttributes(theDetector.visAttributes(x_staves.visStr()));
}
//====================================================================
// Place ECAL Barrel stave module into the envelope volume
//====================================================================
double X,Y;
X = module_thickness * sin(M_PI/4.);
Y = Ecal_inner_radius + module_thickness / 2.;
for (int stave_id = 1; stave_id <= nsides ; stave_id++)
for (int module_id = 1; module_id < 6; module_id++)
{
double phirot = (stave_id-1) * dphi - hphi*3.0;
double module_z_offset = (2 * module_id-6) * Ecal_Barrel_module_dim_z/2.;
// And the rotation in Mokka is right hand rule, and the rotation in DD4hep is clockwise rule
// So there is a negitive sign when port Mokka into DD4hep
Transform3D tr(RotationZYX(0,phirot,M_PI*0.5),Translation3D(X*cos(phirot)-Y*sin(phirot),
X*sin(phirot)+Y*cos(phirot),
module_z_offset));
PlacedVolume pv = envelope.placeVolume(mod_vol,tr);
pv.addPhysVolID("module",module_id);
pv.addPhysVolID("stave",stave_id);
DetElement sd = (module_id==0&&stave_id==0) ? stave_det : stave_det.clone(_toString(module_id,"module%d")+_toString(stave_id,"stave%d"));
sd.setPlacement(pv);
sdet.add(sd);
}
// Set envelope volume attributes.
envelope.setAttributes(theDetector,x_det.regionStr(),x_det.limitsStr(),x_det.visStr());
sdet.addExtension< LayeredCalorimeterData >( caloData ) ;
return sdet;
}
int main(int argc, char *argv[]) {
//std::cout << "Running mrisegmentation.cpp..." << std::endl;
if (argc != 12) {
cerr << "#arguments = " << argc << endl;
cerr <<
"Usage: dist mrivolume.bin seeds.bin #rows #columns #layers #bands samplingdensity [a|c|f|g|m] [m|p|*] neighborhoodSize segmentation.bin" <<
endl;
exit(1);
}
// read input parameters
char *volumeFilename, *seedsFilename, *segmentationFilename;
char distanceMeasureType, normType;
int nRows, nColumns, nLayers, nBands, neighborhoodSize;
double inputDensity, outputDensity;
volumeFilename = argv[1];
seedsFilename = argv[2];
nRows = atoi(argv[3]);
nColumns = atoi(argv[4]);
nLayers = atoi(argv[5]);
nBands = atoi(argv[6]);
inputDensity = atof(argv[7]);
distanceMeasureType = *argv[8];
normType = *argv[9];
neighborhoodSize = atoi(argv[10]);
segmentationFilename = argv[11];
int nElements = nRows * nColumns * nLayers;
// create input image
double *volumeData;
volumeData = readVolume(volumeFilename, nElements * nBands);
CCLattice lattice(nRows, nColumns, nLayers, inputDensity);
Image<double> inputImage(volumeData, lattice, nBands);
// extract seed points
int nLabels = 5;
double *seedData;
seedData = readVolume(seedsFilename, nElements * nLabels);
Image<double> seedImage(seedData, lattice, nLabels);
//int nPotentialSeeds = 0;
//for (int elementIndex = 0; elementIndex < nElements; elementIndex++) {
// if (fabs(seedData[elementIndex]) > EPSILONT) {
// nPotentialSeeds++;
// }
//}
//cout << "#Potential seedpoints: " << nPotentialSeeds << endl;
vector<vector<Seed> > seedPoints;
vector<Seed> tmp;
for (int label = 0; label < nLabels; label++) {
tmp.clear();
for (int elementIndex = 0; elementIndex < nElements; elementIndex++) {
if (fabs(seedImage(elementIndex, label) - 1) < EPSILONT) {
tmp.push_back(Seed(Seed(elementIndex, label)));
}
}
seedPoints.push_back(tmp);
}
//std::cout << "Extracted seedpoints:" << std::endl;
//std::cout << "\tlabel 1: " << seedPoints[0].size() << std::endl;
//std::cout << "\tlabel 2: " << seedPoints[1].size() << std::endl;
//std::cout << "\tlabel 3: " << seedPoints[2].size() << std::endl;
//std::cout << "\tlabel 4: " << seedPoints[3].size() << std::endl;
//std::cout << "\tlabel 5: " << seedPoints[4].size() << std::endl;
// distance measure
Norm<double> *norm;
switch (normType) {
case 'm':
norm = new MaximumNorm<double>;
break;
case 'p':
norm = new PNorm<double>(2);
break;
case '*':
norm = new ProductNorm<double>;
break;
default:
exit(1);
}
SeededDistanceMeasure<double> *distanceMeasure;
switch (distanceMeasureType) {
case 'a':
distanceMeasure = new ApproximateMinimumBarrierDistance<double>(*norm);
break;
case 'c':
distanceMeasure = new FuzzyConnectedness<double>(*norm);
break;
case 'f':
distanceMeasure = new FuzzyDistance<double>(*norm);
break;
case 'g':
distanceMeasure = new GeodesicDistance<double>;
break;
case 'm':
distanceMeasure = new MinimumBarrierDistance<double>;
break;
default:
exit(1);
}
// distance transform
double *distanceTransformData = new double[nElements];
Image<double> distanceImage(distanceTransformData, lattice, 1);
int *rootData = new int[nElements];
Image<int> rootImage(rootData, lattice, 1);
SeededDistanceTransform seededDistanceTransform;
seededDistanceTransform.applySingleLayer(inputImage, seedPoints, *distanceMeasure, neighborhoodSize, distanceImage, rootImage);
writeVolume("distancetransform.bin", distanceTransformData, nElements);
// segmentation
Segmentation segmentation;
double *fuzzySegmentationData = new double[nElements * nLabels];
//double *fuzzySegmentationData = readVolume(segmentationFilename, nElements * nLabels);
Image<double> fuzzySegmentationImage(fuzzySegmentationData, *lattice, nLabels);
IntensityWorkset<double> fuzzySegmentation(fuzzySegmentationImage, 0, 1);
// save segmentation
segmentation.fuzzy(distanceImage, neighborhoodSize, fuzzySegmentation);
writeVolume(segmentationFilename, fuzzySegmentationData, nElements * nLabels);
ObjectSurfaceAreaFromVoronoiCellIntersection<double> surfaceAreaComputer;
double area;
area = surfaceAreaComputer.compute(fuzzySegmentation, 4);
cout << "small tomato surface area: " << area << endl;
area = surfaceAreaComputer.compute(fuzzySegmentation, 3);
cout << "large tomato surface area: " << area << endl;
area = surfaceAreaComputer.compute(fuzzySegmentation, 2);
cout << "avocado surface area: " << area << endl;
area = surfaceAreaComputer.compute(fuzzySegmentation, 1);
cout << "margarine surface area: " << area << endl;
ObjectVolumeFromCoverage<double> volumeComputer;
double volume;
volume = volumeComputer.compute(fuzzySegmentation, 4);
cout << "small tomato volume: " << volume << endl;
volume = volumeComputer.compute(fuzzySegmentation, 3);
cout << "large tomato volume: " << volume << endl;
volume = volumeComputer.compute(fuzzySegmentation, 2);
cout << "avocado volume: " << volume << endl;
volume = volumeComputer.compute(fuzzySegmentation, 1);
cout << "margarine volume: " << volume << endl;
delete seedData;
delete volumeData;
delete rootData;
delete distanceTransformData;
delete fuzzySegmentationData;
delete norm;
delete distanceMeasure;
return 0;
}
KeyDetectionResult KeyFinder::findKey(const AudioData& originalAudio, const Parameters& params){
KeyDetectionResult result;
AudioData* workingAudio = new AudioData(originalAudio);
workingAudio->reduceToMono();
// TODO: there is presumably some good maths to determine filter frequencies
float lpfCutoff = params.getLastFrequency() * 1.05;
float dsCutoff = params.getLastFrequency() * 1.10;
unsigned int downsampleFactor = (int)floor( workingAudio->getFrameRate() / 2 / dsCutoff );
// get filter
LowPassFilter* lpf = lpfFactory.getLowPassFilter(160, workingAudio->getFrameRate(), lpfCutoff, 2048);
// feeding in the downsampleFactor for a shortcut
lpf->filter(workingAudio, downsampleFactor);
// note we don't delete the LPF; it's stored in the factory for reuse
Downsampler ds;
ds.downsample(workingAudio, downsampleFactor);
SpectrumAnalyser* sa = new SpectrumAnalyser(workingAudio->getFrameRate(), params, &ctFactory);
// run spectral analysis
Chromagram* ch = sa->chromagram(workingAudio);
delete workingAudio;
delete sa;
// reduce chromagram
ch->reduceTuningBins(params);
result.fullChromagram = Chromagram(*ch);
ch->reduceToOneOctave(params);
result.oneOctaveChromagram = Chromagram(*ch);
// get harmonic change signal
Segmentation* segmenter = Segmentation::getSegmentation(params);
result.harmonicChangeSignal = segmenter->getRateOfChange(*ch, params);
// get track segmentation
std::vector<unsigned int> segmentBoundaries = segmenter->getSegments(result.harmonicChangeSignal, params);
segmentBoundaries.push_back(ch->getHops()); // sentinel
delete segmenter;
// get key estimates for each segment
KeyClassifier hc(params);
std::vector<float> keyWeights(24); // TODO: not ideal using int cast of key_t enum. Hash?
for (int s = 0; s < (signed)segmentBoundaries.size()-1; s++){
KeyDetectionSegment segment;
segment.firstHop = segmentBoundaries[s];
segment.lastHop = segmentBoundaries[s+1] - 1;
// collapse segment's time dimension
std::vector<float> segmentChroma(ch->getBins());
for (unsigned int hop = segment.firstHop; hop <= segment.lastHop; hop++) {
for (unsigned int bin = 0; bin < ch->getBins(); bin++) {
float value = ch->getMagnitude(hop, bin);
segmentChroma[bin] += value;
segment.energy += value;
}
}
segment.key = hc.classify(segmentChroma);
if(segment.key != SILENCE){
keyWeights[segment.key] += segment.energy;
}
result.segments.push_back(segment);
}
delete ch;
// get global key
result.globalKeyEstimate = SILENCE;
float mostCommonKeyWeight = 0.0;
for (int k = 0; k < (signed)keyWeights.size(); k++){
if(keyWeights[k] > mostCommonKeyWeight){
mostCommonKeyWeight = keyWeights[k];
result.globalKeyEstimate = (key_t)k;
}
}
return result;
}
static Ref_t create_detector(Detector& theDetector, xml_h e, SensitiveDetector sens) {
xml_det_t x_det = e;
int det_id = x_det.id();
string det_name = x_det.nameStr();
DetElement sdet (det_name,det_id);
// --- create an envelope volume and position it into the world ---------------------
Volume envelope = dd4hep::xml::createPlacedEnvelope( theDetector, e , sdet ) ;
dd4hep::xml::setDetectorTypeFlag( e, sdet ) ;
if( theDetector.buildType() == BUILD_ENVELOPE ) return sdet ;
//-----------------------------------------------------------------------------------
xml_dim_t dim = x_det.dimensions();
Material air = theDetector.air();
int nsides_inner = dim.nsides_inner();
int nsides_outer = dim.nsides_outer();
double rmin = dim.rmin();
double rmax = dim.rmax(); /// FIXME: IS THIS RIGHT?
double zmin = dim.zmin();
double rcutout = dim.hasAttr(_U(rmin2)) ? dim.rmin2() : 0.;
double zcutout = dim.hasAttr(_U(z2)) ? dim.z2() : 0.;
Layering layering(x_det);
double totalThickness = layering.totalThickness();
Readout readout = sens.readout();
Segmentation seg = readout.segmentation();
std::vector<double> cellSizeVector = seg.segmentation()->cellDimensions(0); //Assume uniform cell sizes, provide dummy cellID
double cell_sizeX = cellSizeVector[0];
double cell_sizeY = cellSizeVector[1];
PolyhedraRegular polyVolume(nsides_outer,rmin,rmax,totalThickness);
Volume endcapVol("endcap",polyVolume,air);
if(zcutout >0. || rcutout > 0.){
PolyhedraRegular cutoutPolyVolume(nsides_inner,0,rmin+rcutout,zcutout);
Position cutoutPos(0,0,(zcutout-totalThickness)/2.0);
std::cout<<"Cutout z width will be "<<zcutout<<std::endl;
endcapVol=Volume("endcap",SubtractionSolid(polyVolume,cutoutPolyVolume,cutoutPos),air);
}
DetElement endcapA(sdet,"endcap",det_id);
Ref_t(endcapA)->SetName((det_name+"_A").c_str());
int layer_num = 0;
int layerType = 0;
double layerZ = -totalThickness/2;
//Create caloData object to extend driver with data required for reconstruction
LayeredCalorimeterData* caloData = new LayeredCalorimeterData ;
caloData->layoutType = LayeredCalorimeterData::EndcapLayout ;
caloData->inner_symmetry = nsides_inner;
caloData->outer_symmetry = nsides_outer;
/** NOTE: phi0=0 means lower face flat parallel to experimental floor
* This is achieved by rotating the modules with respect to the envelope
* which is assumed to be a Polyhedron and has its axes rotated with respect
* to the world by 180/nsides. In any other case (e.g. if you want to have
* a tip of the calorimeter touching the ground) this value needs to be computed
*/
caloData->inner_phi0 = 0.;
caloData->outer_phi0 = 0.;
caloData->gap0 = 0.; //FIXME
caloData->gap1 = 0.; //FIXME
caloData->gap2 = 0.; //FIXME
/// extent of the calorimeter in the r-z-plane [ rmin, rmax, zmin, zmax ] in mm.
caloData->extent[0] = rmin ;
caloData->extent[1] = rmax ; ///FIXME: CHECK WHAT IS NEEDED (EXSCRIBED?)
caloData->extent[2] = zmin ;
caloData->extent[3] = zmin + totalThickness;
endcapVol.setAttributes(theDetector,x_det.regionStr(),x_det.limitsStr(),x_det.visStr());
for(xml_coll_t c(x_det,_U(layer)); c; ++c) {
xml_comp_t x_layer = c;
double layer_thick = layering.layer(layer_num)->thickness();
string layer_type_name = _toString(layerType,"layerType%d");
int layer_repeat = x_layer.repeat();
double layer_rcutout = x_layer.hasAttr(_U(gap)) ? x_layer.gap() : 0;
std::cout<<"Number of layers in group "<<layerType<<" : "<<layer_repeat<<std::endl;
Volume layer_vol(layer_type_name,PolyhedraRegular(nsides_outer,rmin+layer_rcutout,rmax,layer_thick),air);
int slice_num = 0;
double sliceZ = -layer_thick/2;
//Create a caloLayer struct for thiss layer type to store copies of in the parent struct
LayeredCalorimeterData::Layer caloLayer ;
caloLayer.cellSize0 = cell_sizeX;
caloLayer.cellSize1 = cell_sizeY;
double nRadiationLengths=0.;
double nInteractionLengths=0.;
double thickness_sum=0;
for(xml_coll_t s(x_layer,_U(slice)); s; ++s) {
xml_comp_t x_slice = s;
string slice_name = _toString(slice_num,"slice%d");
double slice_thickness = x_slice.thickness();
Material slice_material = theDetector.material(x_slice.materialStr());
Volume slice_vol(slice_name,PolyhedraRegular(nsides_outer,rmin+layer_rcutout,rmax,slice_thickness),slice_material);
slice_vol.setVisAttributes(theDetector.visAttributes(x_slice.visStr()));
sliceZ += slice_thickness/2;
layer_vol.placeVolume(slice_vol,Position(0,0,sliceZ));
nRadiationLengths += slice_thickness/(2.*slice_material.radLength());
nInteractionLengths += slice_thickness/(2.*slice_material.intLength());
thickness_sum += slice_thickness/2;
if ( x_slice.isSensitive() ) {
sens.setType("calorimeter");
slice_vol.setSensitiveDetector(sens);
#if DD4HEP_VERSION_GE( 0, 15 )
//Store "inner" quantities
caloLayer.inner_nRadiationLengths = nRadiationLengths;
caloLayer.inner_nInteractionLengths = nInteractionLengths;
caloLayer.inner_thickness = thickness_sum;
//Store scintillator thickness
caloLayer.sensitive_thickness = slice_thickness;
#endif
//Reset counters to measure "outside" quantitites
nRadiationLengths=0.;
nInteractionLengths=0.;
thickness_sum = 0.;
}
nRadiationLengths += slice_thickness/(2.*slice_material.radLength());
nInteractionLengths += slice_thickness/(2.*slice_material.intLength());
thickness_sum += slice_thickness/2;
sliceZ += slice_thickness/2;
slice_num++;
}
#if DD4HEP_VERSION_GE( 0, 15 )
//Store "outer" quantities
caloLayer.outer_nRadiationLengths = nRadiationLengths;
caloLayer.outer_nInteractionLengths = nInteractionLengths;
caloLayer.outer_thickness = thickness_sum;
#endif
layer_vol.setVisAttributes(theDetector.visAttributes(x_layer.visStr()));
if ( layer_repeat <= 0 ) throw std::runtime_error(x_det.nameStr()+"> Invalid repeat value");
for(int j=0; j<layer_repeat; ++j) {
string phys_lay = _toString(layer_num,"layer%d");
//The rest of the data is constant; only the distance needs to be updated
//Store the position up to the inner face of the layer
caloLayer.distance = zmin + totalThickness/2 + layerZ;
//Push back a copy to the caloData structure
caloData->layers.push_back( caloLayer );
layerZ += layer_thick/2;
DetElement layer_elt(endcapA, phys_lay, layer_num);
PlacedVolume pv = endcapVol.placeVolume(layer_vol,Position(0,0,layerZ));
pv.addPhysVolID("layer", layer_num);
layer_elt.setPlacement(pv);
layerZ += layer_thick/2;
++layer_num;
}
++layerType;
}
double z_pos = zmin+totalThickness/2;
PlacedVolume pv;
// Reflect it.
DetElement endcapB = endcapA.clone(det_name+"_B",x_det.id());
//Removed rotations to align with envelope
//NOTE: If the envelope is not a polyhedron (eg. if you use a tube)
//you may need to rotate so the axes match
pv = envelope.placeVolume(endcapVol,Transform3D(RotationZYX(0,0,0),
Position(0,0,z_pos)));
pv.addPhysVolID("side", 1);
endcapA.setPlacement(pv);
//Removed rotations
pv = envelope.placeVolume(endcapVol,Transform3D(RotationZYX(0,M_PI,0),
Position(0,0,-z_pos)));
pv.addPhysVolID("side", 2);
endcapB.setPlacement(pv);
sdet.add(endcapB);
sdet.addExtension< LayeredCalorimeterData >( caloData ) ;
return sdet;
}
void KeyFinderWorkerThread::run(){
if(!haveParams){
emit failed("No parameters.");
return;
}
// initialise stream and decode file into it
AudioStream* astrm = NULL;
AudioFileDecoder* dec = AudioFileDecoder::getDecoder(filePath.toUtf8().data());
try{
astrm = dec->decodeFile(filePath.toUtf8().data());
}catch(Exception){
delete astrm;
delete dec;
emit failed("Could not decode file.");
return;
}
delete dec;
emit decoded();
// make audio stream monaural
astrm->reduceToMono();
emit madeMono();
// downsample if necessary
if(prefs.getDFactor() > 1){
Downsampler* ds = Downsampler::getDownsampler(prefs.getDFactor(),astrm->getFrameRate(),prefs.getLastFreq());
try{
astrm = ds->downsample(astrm,prefs.getDFactor());
}catch(Exception){
delete astrm;
delete ds;
emit failed("Downsampler failed.");
return;
}
delete ds;
emit downsampled();
}
// start spectrum analysis
SpectrumAnalyser* sa = NULL;
Chromagram* ch = NULL;
sa = SpectrumAnalyserFactory::getInstance()->getSpectrumAnalyser(astrm->getFrameRate(),prefs);
ch = sa->chromagram(astrm);
delete astrm; // note we don't delete the spectrum analyser; it stays in the centralised factory for reuse.
ch->reduceTuningBins(prefs);
emit producedFullChromagram(*ch);
// reduce chromagram
ch->reduceToOneOctave(prefs);
emit producedOneOctaveChromagram(*ch);
// get energy level across track to weight segments
std::vector<float> loudness(ch->getHops());
for(int h=0; h<ch->getHops(); h++)
for(int b=0; b<ch->getBins(); b++)
loudness[h] += ch->getMagnitude(h,b);
// get harmonic change signal
Segmentation* hcdf = Segmentation::getSegmentation(prefs);
std::vector<double> harmonicChangeSignal = hcdf->getRateOfChange(ch,prefs);
emit producedHarmonicChangeSignal(harmonicChangeSignal);
// get track segmentation
std::vector<int> changes = hcdf->getSegments(harmonicChangeSignal,prefs);
changes.push_back(ch->getHops()); // It used to be getHops()-1. But this doesn't crash. So we like it.
// batch output of keychange locations for Beatles experiment
//for(int i=1; i<changes.size(); i++) // don't want the leading zero
// std::cout << filePath.substr(53) << "\t" << std::fixed << std::setprecision(2) << changes[i]*(prefs.getHopSize()/(44100.0/prefs.getDFactor())) << std::endl;
// end experiment output
// get key estimates for segments
KeyClassifier hc(prefs);
std::vector<int> keys(0);
std::vector<float> keyWeights(24);
for(int i=0; i<(signed)changes.size()-1; i++){
std::vector<double> chroma(ch->getBins());
for(int j=changes[i]; j<changes[i+1]; j++)
for(int k=0; k<ch->getBins(); k++)
chroma[k] += ch->getMagnitude(j,k);
int key = hc.classify(chroma);
for(int j=changes[i]; j<changes[i+1]; j++){
keys.push_back(key);
if(key < 24) // ignore parts that were classified as silent
keyWeights[key] += loudness[j];
}
}
keys.push_back(keys[keys.size()-1]); // put last key on again to match length of track
delete ch;
emit producedKeyEstimates(keys);
// get global key
int mostCommonKey = 24;
float mostCommonKeyWeight = 0.0;
for(int i=0; i<(signed)keyWeights.size(); i++){
if(keyWeights[i] > mostCommonKeyWeight){
mostCommonKeyWeight = keyWeights[i];
mostCommonKey = i;
}
}
emit producedGlobalKeyEstimate(mostCommonKey);
return;
}
KeyDetectionResult KeyFinder::findKey(const AudioData& originalAudio, const Parameters& params){
KeyDetectionResult result;
AudioData* workingAudio = new AudioData(originalAudio);
workingAudio->reduceToMono();
Downsampler ds;
ds.downsample(workingAudio, params.getLastFreq(), &lpfFactory);
SpectrumAnalyser* sa = new SpectrumAnalyser(workingAudio->getFrameRate(), params, &ctFactory);
// run spectral analysis
Chromagram* ch = sa->chromagram(workingAudio);
delete workingAudio;
delete sa;
// reduce chromagram
ch->reduceTuningBins(params);
result.fullChromagram = Chromagram(*ch);
ch->reduceToOneOctave(params);
result.oneOctaveChromagram = Chromagram(*ch);
// get harmonic change signal
Segmentation* segmenter = Segmentation::getSegmentation(params);
result.harmonicChangeSignal = segmenter->getRateOfChange(*ch, params);
// get track segmentation
std::vector<unsigned int> segmentBoundaries = segmenter->getSegments(result.harmonicChangeSignal, params);
segmentBoundaries.push_back(ch->getHops()); // sentinel
delete segmenter;
// get key estimates for each segment
KeyClassifier hc(params);
std::vector<float> keyWeights(24); // TODO: not ideal using int cast of key_t enum. Hash?
for (int s = 0; s < (signed)segmentBoundaries.size()-1; s++){
KeyDetectionSegment segment;
segment.firstWindow = segmentBoundaries[s];
segment.lastWindow = segmentBoundaries[s+1] - 1;
// collapse segment's time dimension, for a single chroma vector and a single energy value
std::vector<float> segmentChroma(ch->getBins());
// for each relevant hop of the chromagram
for (unsigned int hop = segment.firstWindow; hop <= segment.lastWindow; hop++) {
// for each bin
for (unsigned int bin = 0; bin < ch->getBins(); bin++) {
float value = ch->getMagnitude(hop, bin);
segmentChroma[bin] += value;
segment.energy += value;
}
}
segment.key = hc.classify(segmentChroma);
if(segment.key != SILENCE){
keyWeights[segment.key] += segment.energy;
}
result.segments.push_back(segment);
}
delete ch;
// get global key
result.globalKeyEstimate = SILENCE;
float mostCommonKeyWeight = 0.0;
for (int k = 0; k < (signed)keyWeights.size(); k++){
if(keyWeights[k] > mostCommonKeyWeight){
mostCommonKeyWeight = keyWeights[k];
result.globalKeyEstimate = (key_t)k;
}
}
return result;
}
TuningInterface *multiObjectiveTuning(int argc, char **argv, SysEnv &sysEnv, int max_number_of_tests,
std::string &metricType,
double metricWeight,
double timeWeight,
double &tSlowest, double &tFastest, RegionTemplateCollection *rtCollection,
std::string tuningPolicy,
float *perf, float *totaldiffs, float *metricPerIteration,
float *diceNotCoolPerIteration,
uint64_t *totalexecutiontimes) {
TuningInterface *tuningClient;
int numClients;
//USING AH
if (tuningPolicy.find("nm") != std::string::npos || tuningPolicy.find("NM") != std::string::npos ||
tuningPolicy.find("pro") != std::string::npos || tuningPolicy.find("PRO") != std::string::npos ||
tuningPolicy.find("random") != std::string::npos || tuningPolicy.find("RANDOM") != std::string::npos) {
numClients = 1;
tuningClient = new ActiveHarmonyTuning(tuningPolicy, max_number_of_tests, numClients);
} else {
//USING GA
int max_number_of_generations = (int) floor(sqrt(max_number_of_tests));
int mutationchance = 30;
int crossoverrate = 50;
int popsize = (int) ceil(sqrt(max_number_of_tests));
if (popsize > 1 && ((popsize % 2) == 1)) {
--popsize;
max_number_of_generations++;
} //Pop size must be an even number for GA.
if (popsize <= 1) popsize++; //pop size must be at least 2.
if (popsize * max_number_of_generations > max_number_of_tests) {
max_number_of_generations--;
}
//int propagationamount = 2;
int propagationamount = (int) ceil(popsize * 0.25); //around 25% of popsize
if ((2 * propagationamount) >= popsize)
propagationamount--; //Elite size(propagation amount) must be less than half the popsize.
numClients = popsize; //popsize
tuningClient = new GeneticAlgorithm(max_number_of_generations, popsize, mutationchance,
crossoverrate,
propagationamount,
1);
}
double *totalExecutionTimesNormalized = (double *) malloc(sizeof(double) * max_number_of_tests);
std::vector<int> segComponentIds[numClients];
std::vector<int> metricComponentIds[numClients];
std::vector<int> diceNotCoolComponentIds[numClients];
std::map<std::string, double> perfDataBase; //Checks if a param has been tested already
int versionNorm = 0, versionSeg = 0;
resetPerf(perf, max_number_of_tests);
bool executedAlready[numClients];
int repeatCounter = 0;
if (tuningClient->initialize(argc, argv) != 0) {
fprintf(stderr, "Failed to initialize tuning session.\n");
return NULL;
};
if (tuningClient->declareParam("blue", 210, 240, 10) != 0 ||
tuningClient->declareParam("green", 210, 240, 10) != 0 ||
tuningClient->declareParam("red", 210, 240, 10) != 0 ||
tuningClient->declareParam("T1", 2.5, 7.5, 0.5) != 0 ||
tuningClient->declareParam("T2", 2.5, 7.5, 0.5) != 0 ||
tuningClient->declareParam("G1", 5, 80, 5) != 0 ||
tuningClient->declareParam("minSize", 2, 40, 2) != 0 ||
tuningClient->declareParam("maxSize", 900, 1500, 50) != 0 ||
tuningClient->declareParam("G2", 2, 40, 2) != 0 ||
tuningClient->declareParam("minSizePl", 5, 80, 5) != 0 ||
tuningClient->declareParam("minSizeSeg", 2, 40, 2) != 0 ||
tuningClient->declareParam("maxSizeSeg", 900, 1500, 50) != 0 ||
tuningClient->declareParam("fillHoles", 4, 8, 4) != 0 ||
tuningClient->declareParam("recon", 4, 8, 4) != 0 ||
tuningClient->declareParam("watershed", 4, 8, 4) != 0) {
fprintf(stderr, "Failed to define tuning session\n");
return NULL;
}
if (tuningClient->configure() != 0) {
fprintf(stderr, "Failed to initialize tuning session.\n");
return NULL;
};
for (; !tuningClient->hasConverged();) {
cout << "ITERATION: " << tuningClient->getIteration() << endl;
//Get new param suggestions from the tuning client
tuningClient->fetchParams();
//Apply fitness function for each individual
for (int i = 0; i < numClients; i++) {
std::ostringstream oss;
oss << "PARAMS";
typedef std::map<std::string, double *>::iterator it_type;
for (it_type iterator = tuningClient->getParamSet(i)->paramSet.begin();
iterator != tuningClient->getParamSet(i)->paramSet.end(); iterator++) {
//iterator.first key
//iterator.second value
oss << " - " << iterator->first << ": " << *(iterator->second);
}
// / if not found in performance database
if (perfDataBase.find(oss.str()) != perfDataBase.end()) {
perf[tuningClient->getIteration() * numClients +
(i)] = perfDataBase.find(oss.str())->second;
std::cout << "Parameters already tested: " << oss.str() << " perf: " << perf << std::endl;
executedAlready[i] = true;
} else {
executedAlready[i] = false;
}
}
int segCount = 0;
// Build application dependency graph
// Instantiate application dependency graph
for (int i = 0; i < rtCollection->getNumRTs(); i++) {
int previousSegCompId = 0;
// CREATE NORMALIZATION STEP
ParameterSet parSetNormalization;
std::vector<ArgumentBase *> targetMeanOptions;
ArgumentFloatArray *targetMeanAux = new ArgumentFloatArray(ArgumentFloat(-0.632356));
targetMeanAux->addArgValue(ArgumentFloat(-0.0516004));
targetMeanAux->addArgValue(ArgumentFloat(0.0376543));
targetMeanOptions.push_back(targetMeanAux);
parSetNormalization.addArguments(targetMeanOptions);
parSetNormalization.resetIterator();
std::vector<ArgumentBase *> argSetInstanceNorm = parSetNormalization.getNextArgumentSetInstance();
NormalizationComp *norm = new NormalizationComp();
// normalization parameters
norm->addArgument(new ArgumentInt(versionNorm));
norm->addArgument(argSetInstanceNorm[0]);
norm->addRegionTemplateInstance(rtCollection->getRT(i), rtCollection->getRT(i)->getName());
sysEnv.executeComponent(norm);
for (int j = 0; j < numClients; j++) {
if (executedAlready[j] == false) {
std::cout << "BEGIN: LoopIdx: " << tuningClient->getIteration() * numClients + (j);
typedef std::map<std::string, double *>::iterator it_type;
for (it_type iterator = tuningClient->getParamSet(j)->paramSet.begin();
iterator != tuningClient->getParamSet(j)->paramSet.end(); iterator++) {
std::cout << " - " << iterator->first << ": " << *(iterator->second);
}
std::cout << std::endl;
// Creating segmentation component
Segmentation *seg = new Segmentation();
// version of the data region red. Each parameter instance in norm creates a output w/ different version
seg->addArgument(new ArgumentInt(versionNorm));
// version of the data region generated by the segmentation stage
seg->addArgument(new ArgumentInt(versionSeg));
// add remaining (application specific) parameters from the argSegInstance
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("blue", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("green", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("red", j))));
seg->addArgument(
new ArgumentFloat((float) (tuningClient->getParamValue("T1", j))));
seg->addArgument(
new ArgumentFloat((float) (tuningClient->getParamValue("T2", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("G1", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("G2", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("minSize", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("maxSize", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("minSizePl", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("minSizeSeg", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("maxSizeSeg", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("fillHoles", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("recon", j))));
seg->addArgument(new ArgumentInt(
(int) round(tuningClient->getParamValue("watershed", j))));
// and region template instance that it is suppose to process
seg->addRegionTemplateInstance(rtCollection->getRT(i), rtCollection->getRT(i)->getName());
seg->addDependency(norm->getId());
std::cout << "Creating DiffMask" << std::endl;
RTPipelineComponentBase *metricComp;
DiceNotCoolMaskComp *diceNotCoolComp;
if (metricType.find("jaccard") != std::string::npos) metricComp = new JaccardMaskComp();
else metricComp = new DiceMaskComp();
if (metricType.find("dicenc") != std::string::npos) diceNotCoolComp = new DiceNotCoolMaskComp();
// version of the data region that will be read. It is created during the segmentation.
// region template name
metricComp->addArgument(new ArgumentInt(versionSeg));
metricComp->addRegionTemplateInstance(rtCollection->getRT(i), rtCollection->getRT(i)->getName());
metricComp->addDependency(seg->getId());
// add to the list of diff component ids.
segComponentIds[j].push_back(seg->getId());
metricComponentIds[j].push_back(metricComp->getId());
sysEnv.executeComponent(seg);
sysEnv.executeComponent(metricComp);
if (metricType.find("dicenc") != std::string::npos) {
diceNotCoolComp->addArgument(new ArgumentInt(versionSeg));
diceNotCoolComp->addRegionTemplateInstance(rtCollection->getRT(i),
rtCollection->getRT(i)->getName());
diceNotCoolComp->addDependency(metricComp->getId());
diceNotCoolComponentIds[j].push_back(diceNotCoolComp->getId());
sysEnv.executeComponent(diceNotCoolComp);
}
std::cout << "Manager CompId: " << metricComp->getId() << " fileName: " <<
rtCollection->getRT(i)->getDataRegion(0)->getInputFileName() << std::endl;
segCount++;
versionSeg++;
}
}
versionNorm++;
}
// End Creating Dependency Graph
sysEnv.startupExecution();
//==============================================================================================
//Fetch results from execution workflow
//==============================================================================================
for (int j = 0; j < numClients; j++) {
float metric = 0;
float secondaryMetric = 0;
float diceNotCoolValue = 0;
std::ostringstream oss;
oss << "PARAMS";
typedef std::map<std::string, double *>::iterator it_type;
for (it_type iterator = tuningClient->getParamSet(j)->paramSet.begin();
iterator != tuningClient->getParamSet(j)->paramSet.end(); iterator++) {
oss << " - " << iterator->first << ": " << *(iterator->second);
}
if (executedAlready[j] == false) {
for (int i = 0; i < metricComponentIds[j].size(); i++) {
char *metricResultData = sysEnv.getComponentResultData(metricComponentIds[j][i]);
std::cout << "Diff Id: " << metricComponentIds[j][i] << " \tmetricResultData: ";
if (metricResultData != NULL) {
std::cout << "size: " << ((int *) metricResultData)[0] << " \thadoopgis-metric: " <<
((float *) metricResultData)[1] <<
" \tsecondary: " << ((float *) metricResultData)[2] << endl;
metric += ((float *) metricResultData)[1];
secondaryMetric += ((float *) metricResultData)[2];
if (metricType.find("dicenc") != std::string::npos) {
char *diceNotCoolResultData = sysEnv.getComponentResultData(diceNotCoolComponentIds[j][i]);
std::cout << " \tdiceNotCool: " <<
((float *) diceNotCoolResultData)[1] << std::endl;
diceNotCoolValue += ((float *) diceNotCoolResultData)[1];
}
} else {
std::cout << "NULL" << std::endl;
}
char *segExecutionTime = sysEnv.getComponentResultData(segComponentIds[j][i]);
if (segExecutionTime != NULL) {
totalexecutiontimes[tuningClient->getIteration() * numClients +
(j)] = ((int *) segExecutionTime)[1];
cout << "Segmentation execution time:" <<
totalexecutiontimes[tuningClient->getIteration() * numClients + (j)] << endl;
}
if (metricType.find("dicenc") != std::string::npos)
sysEnv.eraseResultData(diceNotCoolComponentIds[j][i]);
sysEnv.eraseResultData(metricComponentIds[j][i]);
sysEnv.eraseResultData(segComponentIds[j][i]);
}
metricComponentIds[j].clear();
segComponentIds[j].clear();
if (metricType.find("dicenc") != std::string::npos) diceNotCoolComponentIds[j].clear();
//########################################################################################
//Multi Objective Tuning
//########################################################################################
float diff;
if (metricType.find("dicenc") != std::string::npos) diff = (metric + diceNotCoolValue) / 2;
else diff = metric;
if (diff <= 0) diff = FLT_EPSILON;
double timeNormalized;
if (timeWeight > 0) {
timeNormalized =
(tSlowest - (double) totalexecutiontimes[tuningClient->getIteration() * numClients + (j)]) /
(tSlowest - tFastest);
// double timeNormalized = (tSlowest)/
// ((double) totalexecutiontimes[tuningClient->getIteration() * numClients + (j)]) ;
}
double weightedSumOfMetricAndTime = (double) (metricWeight * diff + timeWeight * timeNormalized);
if ((weightedSumOfMetricAndTime > 0) && (diff > FLT_EPSILON)) {
perf[tuningClient->getIteration() * numClients + (j)] = (double) 1 /
weightedSumOfMetricAndTime; //Multi Objective Tuning
} else {
perf[tuningClient->getIteration() * numClients + (j)] = std::numeric_limits<double>::infinity();
}
totalExecutionTimesNormalized[tuningClient->getIteration() * numClients + (j)] = timeNormalized;
if (perf[tuningClient->getIteration() * numClients + (j)] < 0)
perf[tuningClient->getIteration() * numClients + (j)] = -perf[
tuningClient->getIteration() * numClients + (j)];
std::cout << "END: LoopIdx: " << tuningClient->getIteration() * numClients + (j);
typedef std::map<std::string, double *>::iterator it_type;
for (it_type iterator = tuningClient->getParamSet(j)->paramSet.begin();
iterator != tuningClient->getParamSet(j)->paramSet.end(); iterator++) {
//iterator.first key
//iterator.second value
std::cout << " - " << iterator->first << ": " << *(iterator->second);
}
cout << endl << endl << "\tDiff: " << diff << " Secondary Metric: " << secondaryMetric <<
" Time Normalized: " << timeNormalized << " Segmentation Time: " <<
totalexecutiontimes[tuningClient->getIteration() * numClients + (j)] << " Perf: " <<
perf[tuningClient->getIteration() * numClients + (j)] << endl;
totaldiffs[tuningClient->getIteration() * numClients + (j)] = diff;
metricPerIteration[tuningClient->getIteration() * numClients + (j)] = metric;
diceNotCoolPerIteration[tuningClient->getIteration() * numClients + (j)] = diceNotCoolValue;
perfDataBase[oss.str()] = perf[tuningClient->getIteration() * numClients + (j)];
} else {
perf[tuningClient->getIteration() * numClients + (j)] = perfDataBase[oss.str()];
std::cout << "ATTENTION! Param set executed already:" << std::endl;
std::cout << "END: LoopIdx: " << tuningClient->getIteration() * numClients + (j);
std::cout << oss.str() << endl;
std::cout << " perf: " << perf[tuningClient->getIteration() * numClients + (j)] << std::endl;
}
// Report the performance we've just measured.
tuningClient->reportScore(perf[tuningClient->getIteration() * numClients + (j)], j);
}
//Checks if at least one test in this iteration succeeded.
bool shouldIterate = false;
for (int k = 0; k < numClients; ++k) {
shouldIterate |= !executedAlready[k];
}
//Iterates the tuning algorithm
if (shouldIterate == true || (repeatCounter >= MAX_ITERATION_REPEAT)) {
tuningClient->nextIteration();
repeatCounter = 0;
} else {
repeatCounter++;
}
//tuningClient->nextIteration(); //Always iterate - to be fair, all 3 algorithms may repeat values.
}
return tuningClient;
}
