UChar_t KVSpectroDetector::GetPosition( Double_t *XYZf, Int_t idx ){
// Returns in the array 'XYZf', the coordinates (in cm) of a point randomly drawn in the
// active volume with index 'idx'. We assume that the shape of this
// volume is a TGeoBBox. These coordinates are given in the focal-plane
// of reference.
// The function returns a binary code where:
// - bit 0 = 1 if X is OK (001);
// - bit 1 = 1 if Y is OK (010);
// - bit 2 = 1 if Z is OK (100);
//
// If no coordinates are OK, the returned value is null (000) and if
// X, Y and Z are OK then the returned value is equal 7 (111).
TGeoVolume *vol = GetActiveVolume(idx);
if( !vol || !PositionIsOK() ) return 0;
const TGeoBBox *box = (TGeoBBox *)vol->GetShape();
Double_t dx = box->GetDX();
Double_t dy = box->GetDY();
Double_t dz = box->GetDZ();
Double_t ox = (box->GetOrigin())[0];
Double_t oy = (box->GetOrigin())[1];
Double_t oz = (box->GetOrigin())[2];
Double_t xyz[3];
xyz[0] = ox+( TestBit(kRdmPos) ? dx*(2*gRandom->Rndm()-1) : 0.);
xyz[1] = oy+( TestBit(kRdmPos) ? dy*(2*gRandom->Rndm()-1) : 0.);
xyz[2] = oz+( TestBit(kRdmPos) ? dz*(2*gRandom->Rndm()-1) : 0.);
if( ActiveVolumeToFocal( xyz , XYZf, idx ) ) return 7;
return 0;
}
long dump(TGeoNode* ideal, TGeoNode* aligned,int level, VIDs volids) const {
char fmt[128];
string opt_info;
PlacedVolume pv(ideal);
bool sensitive = false;
if ( m_printPositions || m_printVolIDs ) {
stringstream log;
if ( m_printPositions ) {
const double* trans = ideal->GetMatrix()->GetTranslation();
::snprintf(fmt, sizeof(fmt), "Pos: (%f,%f,%f) ",trans[0],trans[1],trans[2]);
log << fmt;
}
// Top level volume! have no volume ids
if ( m_printVolIDs && ideal && ideal->GetMotherVolume() ) {
VIDs vid = pv.volIDs();
if ( !vid.empty() ) {
sensitive = true;
log << " VolID: ";
volids.std::vector<VID>::insert(volids.end(),vid.begin(),vid.end());
for(VIDs::const_iterator i=volids.begin(); i!=volids.end(); ++i) {
::snprintf(fmt, sizeof(fmt), "%s:%2d ",(*i).first.c_str(), (*i).second);
log << fmt;
}
}
}
opt_info = log.str();
}
TGeoVolume* volume = ideal->GetVolume();
if ( !m_printSensitivesOnly || (m_printSensitivesOnly && sensitive) ) {
char sens = pv.volume().isSensitive() ? 'S' : ' ';
if ( ideal == aligned ) {
::snprintf(fmt,sizeof(fmt),"%03d %%-%ds %%s (%%s: %%s) \t[%p] %c %%s",
level+1,2*level+1,(void*)ideal, sens);
}
else {
::snprintf(fmt,sizeof(fmt),"%03d %%-%ds %%s (%%s: %%s) Ideal:%p Aligned:%p %c %%s",
level+1,2*level+1,(void*)ideal,(void*)aligned, sens);
}
printout(INFO,"+++",fmt,"",
aligned->GetName(),
volume->GetTitle(),
volume->GetShape()->IsA()->GetName(),
opt_info.c_str());
}
for (Int_t idau = 0, ndau = aligned->GetNdaughters(); idau < ndau; ++idau) {
TGeoNode* ideal_daughter = ideal->GetDaughter(idau);
const char* daughter_name = ideal_daughter->GetName();
TGeoNode* aligned_daughter = volume->GetNode(daughter_name);
dump(ideal_daughter, aligned_daughter, level+1, volids);
}
return 1;
}
void KVSpectroDetector::GetDeltaXYZf(Double_t *DXYZf, Int_t idx){
// Returns in the DXYZf array the errors of each coordinate of the position returned by
// GetPosition(...) in the focal-plane frame of reference.
//
// In this mother class, the surface of the detector is assumed to be perpendicular to the
// Z-axis. To be modified in the child classes.
DXYZf[0] = DXYZf[1] = DXYZf[2] = -1;
TGeoVolume *vol = GetActiveVolume(idx);
if( !vol || !PositionIsOK() ) return;
const TGeoBBox *box = (TGeoBBox *)vol->GetShape();
DXYZf[0] = box->GetDX();
DXYZf[1] = box->GetDY();
DXYZf[2] = box->GetDZ();
}
//______________________________________________________________________________
void AddText(TPaveText *pave, TObject *pf, Int_t iaxis)
{
char line[128];
TGeoPatternFinder *finder = (TGeoPatternFinder*)pf;
if (!pave || !pf) return;
for (Int_t i=0; i<128; i++) line[i] = ' ';
TGeoVolume *volume = finder->GetVolume();
TGeoShape *sh = volume->GetShape();
sprintf(line, "Division of %s on axis %d (%s)", volume->GetName(), iaxis,sh->GetAxisName(iaxis));
TText *text = pave->AddText(line);
text->SetTextColor(3);
text->SetTextAlign(12);
AddText(pave, "fNdiv",finder->GetNdiv(),"number of divisions");
AddText(pave, "fStart",finder->GetStart(),"start divisioning position");
AddText(pave, "fStep",finder->GetStep(),"division step");
}
GeoHandler& GeoHandler::collect(DetElement element, GeometryInfo& info) {
m_data->clear();
i_collect(element.placement().ptr(), 0, Region(), LimitSet());
for (Data::const_reverse_iterator i = m_data->rbegin(); i != m_data->rend(); ++i) {
const Data::mapped_type& mapped = (*i).second;
for (Data::mapped_type::const_iterator j = mapped.begin(); j != mapped.end(); ++j) {
const TGeoNode* n = *j;
TGeoVolume* v = n->GetVolume();
if (v) {
Material m(v->GetMedium());
Volume vol = Ref_t(v);
// Note : assemblies and the world do not have a real volume nor a material
if (info.volumeSet.find(vol) == info.volumeSet.end()) {
info.volumeSet.insert(vol);
info.volumes.push_back(vol);
}
if (m.isValid())
info.materials.insert(m);
if (dynamic_cast<Volume::Object*>(v)) {
VisAttr vis = vol.visAttributes();
//Region reg = vol.region();
//LimitSet lim = vol.limitSet();
//SensitiveDetector det = vol.sensitiveDetector();
if (vis.isValid())
info.vis.insert(vis);
//if ( lim.isValid() ) info.limits[lim.ptr()].insert(v);
//if ( reg.isValid() ) info.regions[reg.ptr()].insert(v);
//if ( det.isValid() ) info.sensitives[det.ptr()].insert(v);
}
collectSolid(info, v->GetName(), n->GetName(), v->GetShape(), n->GetMatrix());
}
}
}
return *this;
}
int main()
{
Vectors3DSOA points, dirs, intermediatepoints, intermediatedirs;
StructOfCoord rpoints, rintermediatepoints, rdirs, rintermediatedirs;
int np=1024;
points.alloc(np);
dirs.alloc(np);
intermediatepoints.alloc(np);
intermediatedirs.alloc(np);
rpoints.alloc(np);
rdirs.alloc(np);
rintermediatepoints.alloc(np);
rintermediatedirs.alloc(np);
double *distances = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
double *distances2 = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
double *steps = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
for(auto i=0;i<np;++i) steps[i]=1E30;
std::vector<Vector3D> conventionalpoints(np);
std::vector<Vector3D> conventionaldirs(np);
Vector3D * conventionalpoints2 = (Vector3D *) new Vector3D[np];
Vector3D * conventionaldirs2 = (Vector3D *) new Vector3D[np];
StopWatch timer;
// generate benchmark cases
for( int r=0; r< EulerAngles.size(); ++r ) // rotation cases
for( int t=0; t<TransCases.size(); ++t ) // translation cases
{
TransformationMatrix const * identity = new TransformationMatrix(0,0,0,0,0,0);
PhysicalVolume * world = GeoManager::MakePlacedBox( new BoxParameters(100,100,100), identity );
TransformationMatrix * tm = new TransformationMatrix(TransCases[t][0], TransCases[t][1], TransCases[t][2],
EulerAngles[r][0], EulerAngles[r][1], EulerAngles[r][2]);
// these dispatch to specialized matrices
TransformationMatrix const * sm = TransformationMatrix::createSpecializedMatrix( TransCases[t][0], TransCases[t][1], TransCases[t][2],
EulerAngles[r][0], EulerAngles[r][1], EulerAngles[r][2] );
PhysicalVolume * daughter = GeoManager::MakePlacedBox( new BoxParameters(10,15,20), tm );
world->AddDaughter(daughter);
world->fillWithRandomPoints(points,np);
world->fillWithBiasedDirections(points, dirs, np, 1./10);
points.toStructureOfVector3D( conventionalpoints );
dirs.toStructureOfVector3D( conventionaldirs );
points.toStructureOfVector3D( conventionalpoints2 );
dirs.toStructureOfVector3D( conventionaldirs2 );
// time performance for this placement ( we should probably include some random physical steps )
timer.Start();
for(int reps=0;reps<1000;reps++)
{
daughter->DistanceToIn(points,dirs,steps,distances);
}
timer.Stop();
double t0 = timer.getDeltaSecs();
// std::cerr << tm->GetTranslationIdType() << " " << tm->getNumberOfZeroEntries() << " " << timer.getDeltaSecs() << std::endl;
timer.Start();
for(int reps=0;reps<1000;reps++)
{
daughter->DistanceToInIL(points,dirs,steps,distances);
}
timer.Stop();
double til = timer.getDeltaSecs();
timer.Start();
for(int reps=0;reps<1000;reps++)
{
daughter->DistanceToInIL( conventionalpoints2, conventionaldirs2, steps, distances, np );
}
timer.Stop();
double til2 = timer.getDeltaSecs();
// compare with case that uses external unspecialized transformation
PhysicalVolume * unplaceddaughter = GeoManager::MakePlacedBox(new BoxParameters(10,15,20), identity);
timer.Start();
for(int reps=0;reps<1000;reps++)
{
if(! tm->isIdentity() )
{
tm->MasterToLocal(points, intermediatepoints );
tm->MasterToLocalVec( dirs, intermediatedirs );
unplaceddaughter->DistanceToIn( intermediatepoints, intermediatedirs, steps, distances2);
}
else
{
unplaceddaughter->DistanceToIn( points, dirs, steps, distances2);
}
}
timer.Stop();
double t1 = timer.getDeltaSecs();
// compare with external specialized transformation ( sm )
sm->print();
timer.Start();
for(int reps=0;reps<1000;reps++)
{
sm->MasterToLocal(points, intermediatepoints );
sm->MasterToLocalVec( dirs, intermediatedirs );
unplaceddaughter->DistanceToIn( intermediatepoints, intermediatedirs, steps, distances2);
}
timer.Stop();
double t2 = timer.getDeltaSecs();
std::cerr << "VECTOR " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t0 << " " << t1 << " " << t2 << " " << til << " " << til2 << std::endl;
cmpresults( distances, distances2, np );
// now we do the scalar interface: first of all placed version
timer.Start();
for(int reps=0;reps<1000;reps++)
{
for(auto j=0;j<np;++j)
{
distances[j]=daughter->DistanceToIn( conventionalpoints[j], conventionaldirs[j], steps[j]);
}
}
timer.Stop();
double t3 = timer.getDeltaSecs();
// now unplaced version
timer.Start();
for(int reps=0;reps<1000;reps++)
{
for(auto j=0;j<np;++j)
{
Vector3D localp, localdir;
tm->MasterToLocal(conventionalpoints[j], localp);
tm->MasterToLocalVec(conventionaldirs[j], localdir);
distances2[j]=unplaceddaughter->DistanceToIn( localp, localdir, steps[j]);
}
}
timer.Stop();
double t4 = timer.getDeltaSecs();
// now unplaced version
timer.Start();
for(int reps=0;reps<1000;reps++)
{
for(auto j=0;j<np;++j)
{
Vector3D localp, localdir;
sm->MasterToLocal(conventionalpoints[j], localp);
sm->MasterToLocalVec(conventionaldirs[j], localdir);
distances2[j]=unplaceddaughter->DistanceToIn( localp, localdir, steps[j]);
}
}
timer.Stop();
double t5 = timer.getDeltaSecs();
// now unplaced version but inlined matrices
timer.Start();
for(int reps=0;reps<1000;reps++)
{
for(auto j=0;j<np;++j)
{
Vector3D localp, localdir;
// this inlines I think
tm->MasterToLocal<-1,-1>(conventionalpoints[j], localp);
tm->MasterToLocalVec<-1>(conventionaldirs[j], localdir);
distances2[j]=unplaceddaughter->DistanceToIn( localp, localdir, 1E30);
}
}
timer.Stop();
double t6 = timer.getDeltaSecs();
std::cerr << "SCALAR " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t3 << " " << t4 << " " << t5 << " " << t6 << std::endl;
TGeoMatrix * rootmatrix= new TGeoCombiTrans(TransCases[t][0], TransCases[t][1], TransCases[t][2],
new TGeoRotation("rot1",EulerAngles[r][0], EulerAngles[r][1], EulerAngles[r][2]));
TGeoManager *geom = new TGeoManager("","");
TGeoVolume * vol = geom->MakeBox("abox",0,10,15,20);
TGeoShape * rootbox=vol->GetShape();
// now the scalar version from ROOTGeantV
timer.Start();
for(int reps=0;reps<1000;reps++)
{
for(auto j=0;j<np;++j)
{
Vector3D localp, localdir;
// this inlines I think
rootmatrix->MasterToLocal( &conventionalpoints[j].x, &localp.x );
rootmatrix->MasterToLocalVect( &conventionaldirs[j].x, &localdir.x );
distances[j]=rootbox->DistFromOutside( &localp.x, &localdir.x, 3,1e30, 0);
}
}
timer.Stop();
double t7 = timer.getDeltaSecs();
// now the VECTOR version from ROOT
// now the scalar version from ROOTGeantV
timer.Start();
for(int reps=0;reps<1000;reps++)
{
rootmatrix->MasterToLocalCombined_v( reinterpret_cast<StructOfCoord const &>(points), reinterpret_cast<StructOfCoord &>(intermediatepoints),
reinterpret_cast<StructOfCoord const &>(dirs), reinterpret_cast<StructOfCoord &>(intermediatedirs), np );
rootbox->DistFromOutsideSOA_v( reinterpret_cast<StructOfCoord const &>(intermediatepoints),
reinterpret_cast<StructOfCoord const &>(intermediatedirs), 3, steps, 0, distances2, np);
}
timer.Stop();
double t8 = timer.getDeltaSecs();
std::cerr << "RSCAL " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t7 << std::endl;
std::cerr << "RVEC " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t8 << std::endl;
cmpresults( distances, distances2, np );
delete tm;
delete sm;
}
_mm_free(distances);
return 1;
}
//////////////////////////////////
// main function
int main(int argc, char * argv[])
{
int axis= 0;
double axis1_start= 0.;
double axis1_end= 0.;
double axis2_start= 0.;
double axis2_end= 0.;
double pixel_width= 0;
double pixel_axis= 1.;
if( argc < 5 )
{
std::cerr<< std::endl;
std::cerr<< "Need to give rootfile, volumename, axis and number of axis"<< std::endl;
std::cerr<< "USAGE : ./XRayBenchmarkFromROOTFile [rootfile] [VolumeName] [ViewDirection(Axis)]"
<< "[PixelWidth(OutputImageSize)] [--usolids|--vecgeom(Default:usolids)] [--novoxel(Default:voxel)]"
<< std::endl;
std::cerr<< " ex) ./XRayBenchmarkFromROOTFile cms2015.root BSCTrap y 95"<< std::endl;
std::cerr<< " ./XRayBenchmarkFromROOTFile cms2015.root PLT z 500 --vecgeom --novoxel"<< std::endl<< std::endl;
return 1;
}
TGeoManager::Import( argv[1] );
std::string testvolume( argv[2] );
if( strcmp(argv[3], "x")==0 )
axis= 1;
else if( strcmp(argv[3], "y")==0 )
axis= 2;
else if( strcmp(argv[3], "z")==0 )
axis= 3;
else
{
std::cerr<< "Incorrect axis"<< std::endl<< std::endl;
return 1;
}
pixel_width= atof(argv[4]);
for(auto i= 5; i< argc; i++)
{
if( ! strcmp(argv[i], "--usolids") )
usolids= true;
if( ! strcmp(argv[i], "--vecgeom") )
usolids= false;
if( ! strcmp(argv[i], "--novoxel") )
voxelize = false;
}
int found = 0;
TGeoVolume * foundvolume = NULL;
// now try to find shape with logical volume name given on the command line
TObjArray *vlist = gGeoManager->GetListOfVolumes( );
for( auto i = 0; i < vlist->GetEntries(); ++i )
{
TGeoVolume * vol = reinterpret_cast<TGeoVolume*>(vlist->At( i ));
std::string fullname(vol->GetName());
std::size_t founds = fullname.compare(testvolume);
if ( founds==0 ){
found++;
foundvolume = vol;
std::cerr << "("<< i<< ")found matching volume " << foundvolume->GetName()
<< " of type " << foundvolume->GetShape()->ClassName() << "\n";
}
}
std::cerr << "volume found " << found << " times \n\n";
// if volume not found take world
if( ! foundvolume ) {
std::cerr << "specified volume not found; xraying complete detector\n";
foundvolume = gGeoManager->GetTopVolume();
}
if( foundvolume ) {
foundvolume->GetShape()->InspectShape();
std::cerr << "volume capacity "
<< foundvolume->GetShape()->Capacity() << "\n";
// get bounding box to generate x-ray start positions
double dx = ((TGeoBBox*)foundvolume->GetShape())->GetDX()*1.05;
double dy = ((TGeoBBox*)foundvolume->GetShape())->GetDY()*1.05;
double dz = ((TGeoBBox*)foundvolume->GetShape())->GetDZ()*1.05;
double origin[3]= {0., };
origin[0]= ((TGeoBBox*)foundvolume->GetShape())->GetOrigin()[0];
origin[1]= ((TGeoBBox*)foundvolume->GetShape())->GetOrigin()[1];
origin[2]= ((TGeoBBox*)foundvolume->GetShape())->GetOrigin()[2];
TGeoMaterial * matVacuum = new TGeoMaterial("Vacuum",0,0,0);
TGeoMedium * vac = new TGeoMedium("Vacuum",1,matVacuum);
TGeoVolume* boundingbox= gGeoManager->MakeBox("BoundingBox", vac,
std::abs(origin[0]) + dx,
std::abs(origin[1]) + dy,
std::abs(origin[2]) + dz );
// TGeoManager * geom = boundingbox->GetGeoManager();
std::cout << gGeoManager->CountNodes() << "\n";
if(! voxelize ) DeleteROOTVoxels();
gGeoManager = 0;
TGeoManager * mgr2 = new TGeoManager();
// delete gGeoManager;
// gGeoManager = new TGeoManager();
boundingbox->AddNode( foundvolume, 1);
mgr2->SetTopVolume( boundingbox );
mgr2->CloseGeometry();
gGeoManager = mgr2;
gGeoManager->Export("DebugGeom.root");
mgr2->GetTopNode()->GetMatrix()->Print();
std::cout << gGeoManager->CountNodes() << "\n";
//delete world->GetVoxels();
//world->SetVoxelFinder(0);
std::cout<< std::endl;
std::cout<< "BoundingBoxDX: "<< dx<< std::endl;
std::cout<< "BoundingBoxDY: "<< dy<< std::endl;
std::cout<< "BoundingBoxDZ: "<< dz<< std::endl;
std::cout<< std::endl;
std::cout<< "BoundingBoxOriginX: "<< origin[0]<< std::endl;
std::cout<< "BoundingBoxOriginY: "<< origin[1]<< std::endl;
std::cout<< "BoundingBoxOriginZ: "<< origin[2]<< std::endl<< std::endl;
Vector3D<Precision> p;
Vector3D<Precision> dir;
if(axis== 1)
{
dir.Set(1., 0., 0.);
//Transformation3D trans( 0, 0, 0, 5, 5, 5);
//trans.Print();
// dir = trans.TransformDirection( Vector3D<Precision> (1,0,0));
axis1_start= origin[1]- dy;
axis1_end= origin[1]+ dy;
axis2_start= origin[2]- dz;
axis2_end= origin[2]+ dz;
pixel_axis= (dy*2)/pixel_width;
}
else if(axis== 2)
{
dir.Set(0., 1., 0.);
//vecgeom::Transformation3D trans( 0, 0, 0, 5, 5, 5);
//dir = trans.TransformDirection(dir);
axis1_start= origin[0]- dx;
axis1_end= origin[0]+ dx;
axis2_start= origin[2]- dz;
axis2_end= origin[2]+ dz;
pixel_axis= (dx*2)/pixel_width;
}
else if(axis== 3)
{
dir.Set(0., 0., 1.);
//vecgeom::Transformation3D trans( 0, 0, 0, 5, 5, 5);
//dir = trans.TransformDirection(dir);
axis1_start= origin[0]- dx;
axis1_end= origin[0]+ dx;
axis2_start= origin[1]- dy;
axis2_end= origin[1]+ dy;
pixel_axis= (dx*2)/pixel_width;
}
// init data for image
int data_size_x= (axis1_end-axis1_start)/pixel_axis;
int data_size_y= (axis2_end-axis2_start)/pixel_axis;
int *volume_result= (int*) new int[data_size_y * data_size_x*3];
#ifdef VECGEOM_GEANT4
int *volume_result_Geant4= (int*) new int[data_size_y * data_size_x*3];
#endif
int *volume_result_VecGeom= (int*) new int[data_size_y * data_size_x*3];
int *volume_result_VecGeomABB= (int*) new int[data_size_y * data_size_x*3];
Stopwatch timer;
timer.Start();
#ifdef CALLGRIND
CALLGRIND_START_INSTRUMENTATION;
#endif
XRayWithROOT( axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result );
#ifdef CALLGRIND
CALLGRIND_STOP_INSTRUMENTATION;
CALLGRIND_DUMP_STATS;
#endif
timer.Stop();
std::cout << std::endl;
std::cout << " ROOT Elapsed time : "<< timer.Elapsed() << std::endl;
// Make bitmap file; generate filename
std::stringstream imagenamebase;
imagenamebase << "volumeImage_" << testvolume;
if(axis==1) imagenamebase << "x";
if(axis==2) imagenamebase << "y";
if(axis==3) imagenamebase << "z";
if(voxelize) imagenamebase << "_VOXELIZED_";
std::stringstream ROOTimage;
ROOTimage << imagenamebase.str();
ROOTimage << "_ROOT.bmp";
make_bmp(volume_result, ROOTimage.str().c_str(), data_size_x, data_size_y);
make_bmp(volume_result, "foo.bmp", data_size_x, data_size_y, false);
#ifdef VECGEOM_GEANT4
G4VPhysicalVolume * world = SetupGeant4Geometry( testvolume, Vector3D<Precision>( std::abs(origin[0]) + dx,
std::abs(origin[1]) + dy,
std::abs(origin[2]) + dz ) );
G4GeoManager::Instance().LoadG4Geometry( world );
timer.Start();
XRayWithGeant4( world, axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result_Geant4 );
timer.Stop();
std::stringstream G4image;
G4image << imagenamebase.str();
G4image << "_Geant4.bmp";
make_bmp(volume_result_Geant4, G4image.str().c_str(), data_size_x, data_size_y);
std::cout << std::endl;
std::cout << " Geant4 Elapsed time : "<< timer.Elapsed() << std::endl;
make_diff_bmp(volume_result, volume_result_Geant4, "diffROOTGeant4.bmp", data_size_x, data_size_y);
#endif
// convert current gGeoManager to a VecGeom geometry
RootGeoManager::Instance().LoadRootGeometry();
std::cout << "Detector loaded " << "\n";
ABBoxManager::Instance().InitABBoxesForCompleteGeometry();
std::cout << "voxelized " << "\n";
timer.Start();
#ifdef CALLGRIND
CALLGRIND_START_INSTRUMENTATION;
#endif
XRayWithVecGeom<SimpleNavigator>( axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result_VecGeom );
#ifdef CALLGRIND
CALLGRIND_START_INSTRUMENTATION;
CALLGRIND_DUMP_STATS;
#endif
timer.Stop();
std::stringstream VecGeomimage;
VecGeomimage << imagenamebase.str();
VecGeomimage << "_VecGeom.bmp";
make_bmp(volume_result_VecGeom, VecGeomimage.str().c_str(), data_size_x, data_size_y);
make_diff_bmp(volume_result, volume_result_VecGeom, "diffROOTVecGeom.bmp", data_size_x, data_size_y);
std::cout << std::endl;
std::cout << " VecGeom Elapsed time : "<< timer.Elapsed() << std::endl;
timer.Start();
#ifdef CALLGRIND
CALLGRIND_START_INSTRUMENTATION;
#endif
XRayWithVecGeom<ABBoxNavigator>( axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result_VecGeomABB );
#ifdef CALLGRIND
CALLGRIND_STOP_INSTRUMENTATION;
CALLGRIND_DUMP_STATS;
#endif
timer.Stop();
std::stringstream VecGeomABBimage;
VecGeomABBimage << imagenamebase.str();
VecGeomABBimage << "_VecGeomABB.bmp";
make_bmp(volume_result_VecGeomABB, VecGeomABBimage.str().c_str(), data_size_x, data_size_y);
make_diff_bmp(volume_result_VecGeom, volume_result_VecGeomABB, "diffVecGeomSimplevsABB.bmp", data_size_x, data_size_y);
make_diff_bmp(volume_result, volume_result_VecGeomABB, "diffROOTVecGeomABB.bmp", data_size_x, data_size_y);
std::cout << std::endl;
std::cout << " VecGeom ABB Elapsed time : "<< timer.Elapsed() << std::endl;
return 0;
// use the vector interface
timer.Start();
XRayWithVecGeom_VecNav( axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result );
timer.Stop();
std::cout << std::endl;
std::cout << " VecGeom Vector Interface Elapsed time : "<< timer.Elapsed() << std::endl;
std::stringstream VecGeomimagevec;
VecGeomimagevec << imagenamebase.str();
VecGeomimagevec << "_VecGeomVecNav.bmp";
make_bmp(volume_result, VecGeomimagevec.str().c_str(), data_size_x, data_size_y);
delete[] volume_result;
}
return 0;
}
//////////////////////////////////
// main function
int main(int argc, char * argv[])
{
int axis= 0;
double axis1_start= 0.;
double axis1_end= 0.;
double axis2_start= 0.;
double axis2_end= 0.;
double pixel_axis= 1.;
if( argc < 5 )
{
std::cerr<< std::endl;
std::cerr<< "Need to give rootfile, volumename, direction phi and direction theta (in degrees)"<< std::endl;
return 1;
}
TGeoManager::Import( argv[1] );
std::string testvolume( argv[2] );
//double directionphi = atof(argv[3])*vecgeom::kDegToRad;
//double directiontheta = atof(argv[4])*vecgeom::kDegToRad;
for(auto i= 5; i< argc; i++)
{
if( ! strcmp(argv[i], "--usolids") )
usolids= true;
if( ! strcmp(argv[i], "--vecgeom") )
usolids= false;
if( ! strcmp(argv[i], "--novoxel") )
voxelize = false;
}
int found = 0;
TGeoVolume * foundvolume = NULL;
// now try to find shape with logical volume name given on the command line
TObjArray *vlist = gGeoManager->GetListOfVolumes( );
for( auto i = 0; i < vlist->GetEntries(); ++i )
{
TGeoVolume * vol = reinterpret_cast<TGeoVolume*>(vlist->At( i ));
std::string fullname(vol->GetName());
std::size_t founds = fullname.compare(testvolume);
if ( founds==0 ){
found++;
foundvolume = vol;
std::cerr << "("<< i<< ")found matching volume " << foundvolume->GetName()
<< " of type " << foundvolume->GetShape()->ClassName() << "\n";
}
}
std::cerr << "volume found " << found << " times \n\n";
// if volume not found take world
if( ! foundvolume ) {
std::cerr << "specified volume not found; xraying complete detector\n";
foundvolume = gGeoManager->GetTopVolume();
}
if( foundvolume ) {
foundvolume->GetShape()->InspectShape();
std::cerr << "volume capacity "
<< foundvolume->GetShape()->Capacity() << "\n";
// get bounding box to generate x-ray start positions
double dx = ((TGeoBBox*)foundvolume->GetShape())->GetDX()*1.5;
double dy = ((TGeoBBox*)foundvolume->GetShape())->GetDY()*1.5;
double dz = ((TGeoBBox*)foundvolume->GetShape())->GetDZ()*1.5;
double origin[3]= {0., };
origin[0]= ((TGeoBBox*)foundvolume->GetShape())->GetOrigin()[0];
origin[1]= ((TGeoBBox*)foundvolume->GetShape())->GetOrigin()[1];
origin[2]= ((TGeoBBox*)foundvolume->GetShape())->GetOrigin()[2];
TGeoMaterial * matVacuum = new TGeoMaterial("Vacuum",0,0,0);
TGeoMedium * vac = new TGeoMedium("Vacuum",1,matVacuum);
TGeoVolume* boundingbox= gGeoManager->MakeBox("BoundingBox", vac,
std::abs(origin[0]) + dx,
std::abs(origin[1]) + dy,
std::abs(origin[2]) + dz );
// TGeoManager * geom = boundingbox->GetGeoManager();
std::cout << gGeoManager->CountNodes() << "\n";
if(! voxelize ) DeleteROOTVoxels();
// TGeoManager * mg1 = gGeoManager;
gGeoManager = 0;
TGeoManager * mgr2 = new TGeoManager();
// delete gGeoManager;
// gGeoManager = new TGeoManager();
boundingbox->AddNode( foundvolume, 1);
mgr2->SetTopVolume( boundingbox );
mgr2->CloseGeometry();
gGeoManager = mgr2;
gGeoManager->Export("DebugGeom.root");
mgr2->GetTopNode()->GetMatrix()->Print();
std::cout << gGeoManager->CountNodes() << "\n";
//delete world->GetVoxels();
//world->SetVoxelFinder(0);
std::cout<< std::endl;
std::cout<< "BoundingBoxDX: "<< dx<< std::endl;
std::cout<< "BoundingBoxDY: "<< dy<< std::endl;
std::cout<< "BoundingBoxDZ: "<< dz<< std::endl;
std::cout<< std::endl;
std::cout<< "BoundingBoxOriginX: "<< origin[0]<< std::endl;
std::cout<< "BoundingBoxOriginY: "<< origin[1]<< std::endl;
std::cout<< "BoundingBoxOriginZ: "<< origin[2]<< std::endl<< std::endl;
Vector3D<Precision> p;
// Vector3D<Precision> dir( std::cos(directionphi)*std::sin(directiontheta), std::sin(directionphi)*std::sin(directiontheta), std::cos(directiontheta) );
//
Vector3D<Precision> dir( -0.00366952650659481318523580384294 , 0.00101412421199570282163981982393 , 0.999991248519344400058628252737 );
//Vector3D<Precision> dir( 1 , 0. , 0. );
dir.FixZeroes();
// init data for image
int data_size_x= 1;//(axis1_end-axis1_start)/pixel_axis;
int data_size_y= 1;//(axis2_end-axis2_start)/pixel_axis;
int *volume_result= (int*) new int[data_size_y * data_size_x*3];
Stopwatch timer;
timer.Start();
XRayWithROOT( axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result );
timer.Stop();
std::cout << std::endl;
std::cout << " ROOT Elapsed time : "<< timer.Elapsed() << std::endl;
#ifdef VECGEOM_GEANT4
G4VPhysicalVolume * world = SetupGeant4Geometry( testvolume, Vector3D<Precision>( std::abs(origin[0]) + dx,
std::abs(origin[1]) + dy,
std::abs(origin[2]) + dz ) );
G4GeoManager::Instance().LoadG4Geometry( world );
timer.Start();
XRayWithGeant4( world, axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result );
timer.Stop();
std::cout << " Geant4 Elapsed time : "<< timer.Elapsed() << std::endl;
#endif
// convert current gGeoManager to a VecGeom geometry
RootGeoManager::Instance().LoadRootGeometry();
std::cout << "Detector loaded " << "\n";
timer.Start();
XRayWithVecGeom( axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result );
timer.Stop();
std::cout << " VecGeom Elapsed time : "<< timer.Elapsed() << std::endl;
// use the vector interface
timer.Start();
XRayWithVecGeom_VecNav( axis,
Vector3D<Precision>(origin[0],origin[1],origin[2]),
Vector3D<Precision>(dx,dy,dz),
dir,
axis1_start, axis1_end,
axis2_start, axis2_end,
data_size_x, data_size_y,
pixel_axis,
volume_result );
timer.Stop();
std::cout << std::endl;
std::cout << " VecGeom Vector Interface Elapsed time : "<< timer.Elapsed() << std::endl;
delete[] volume_result;
}
return 0;
}
//////////////////////////////////
// main function
int main(int argc, char *argv[])
{
if (argc < 3) {
std::cerr << std::endl;
std::cerr << "Need to give rootfile + volumename" << std::endl;
return 1;
}
TGeoManager::Import(argv[1]);
std::string testvolume(argv[2]);
int found = 0;
TGeoVolume *foundvolume = NULL;
// now try to find shape with logical volume name given on the command line
TObjArray *vlist = gGeoManager->GetListOfVolumes();
for (auto i = 0; i < vlist->GetEntries(); ++i) {
TGeoVolume *vol = reinterpret_cast<TGeoVolume *>(vlist->At(i));
std::string fullname(vol->GetName());
std::size_t founds = fullname.compare(testvolume);
if (founds == 0) {
found++;
foundvolume = vol;
std::cerr << "(" << i << ")found matching volume " << foundvolume->GetName() << " of type "
<< foundvolume->GetShape()->ClassName() << "\n";
}
}
std::cerr << "volume found " << found << " times \n\n";
// if volume not found take world
if (!foundvolume) {
std::cerr << "specified volume not found; exiting\n";
return 1;
}
if (foundvolume) {
// convert current gGeoManager to a VecGeom geometry
VPlacedVolume const *vecgeompvol = RootGeoManager::Instance().Convert(foundvolume)->Place();
for (int i = 0; i < 20; ++i) {
Vector3D<Precision> point = vecgeompvol->GetUnplacedVolume()->SamplePointOnSurface();
if (vecgeompvol->Inside(point) != vecgeom::kSurface) {
std::cerr << " WARNING : Inside does not report surface state \n";
}
Vector3D<Precision> dir = volumeUtilities::SampleDirection();
bool contained = vecgeompvol->Contains(point);
bool exiting = ExitingMethod2(vecgeompvol, point, dir);
double DO = vecgeompvol->DistanceToOut(point, dir);
double DI = vecgeompvol->DistanceToIn(point, dir);
std::cerr << i << " " << point << " "
<< contained
// << " ExitingM1 " << ExitingMethod1(vecgeompvol,point,dir)
<< " ExitingM2 " << exiting << " DI " << DI << " DO " << DO << " SO "
<< vecgeompvol->SafetyToOut(point) << " SI " << vecgeompvol->SafetyToIn(point) << "\n";
if (exiting && DO > vecgeom::kTolerance) {
std::cout << " WARNING FOR DO : should be zero \n";
std::cout << "./CompareDistances " << argv[1] << " " << argv[2] << std::setprecision(20) << " " << point[0]
<< " " << point[1] << " " << point[2] << " " << dir[0] << " " << dir[1] << " " << dir[2] << "\n";
}
if (contained && !exiting && DO < vecgeom::kTolerance) {
std::cout << " FATAL WARNING FOR DO : should be finite \n";
std::cout << "./CompareDistances " << argv[1] << " " << argv[2] << std::setprecision(20) << " " << point[0]
<< " " << point[1] << " " << point[2] << " " << dir[0] << " " << dir[1] << " " << dir[2] << "\n";
}
if (!exiting && DI > vecgeom::kTolerance) {
std::cout << " WARNING FOR DI : should be zero \n";
std::cout << "./CompareDistances " << argv[1] << " " << argv[2] << std::setprecision(20) << " " << point[0]
<< " " << point[1] << " " << point[2] << " " << dir[0] << " " << dir[1] << " " << dir[2] << "\n";
}
if (!exiting && !contained && DI > 1E20) {
std::cout << " FATAL WARNING FOR DI : should be zero \n";
std::cout << "./CompareDistances " << argv[1] << " " << argv[2] << std::setprecision(20) << " " << point[0]
<< " " << point[1] << " " << point[2] << " " << dir[0] << " " << dir[1] << " " << dir[2] << "\n";
}
std::cout << "\n\n";
} // end for
return 0;
} // end if found volume
return 1;
}
int main()
{
Vectors3DSOA points, dirs, intermediatepoints, intermediatedirs;
StructOfCoord rpoints, rintermediatepoints, rdirs, rintermediatedirs;
int np=1024;
int NREPS = 1000;
points.alloc(np);
dirs.alloc(np);
intermediatepoints.alloc(np);
intermediatedirs.alloc(np);
rpoints.alloc(np);
rdirs.alloc(np);
rintermediatepoints.alloc(np);
rintermediatedirs.alloc(np);
double *distances = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
double *distancesROOTSCALAR = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
double *distancesUSOLIDSCALAR = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
double *distances2 = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
double *steps = (double *) _mm_malloc(np*sizeof(double), ALIGNMENT_BOUNDARY);
for(auto i=0;i<np;++i) steps[i]=1E30;
std::vector<Vector3D> conventionalpoints(np);
std::vector<Vector3D> conventionaldirs(np);
Vector3D * conventionalpoints2 = (Vector3D *) new Vector3D[np];
Vector3D * conventionaldirs2 = (Vector3D *) new Vector3D[np];
StopWatch timer;
// generate benchmark cases
TransformationMatrix const * identity = new TransformationMatrix(0,0,0,0,0,0);
// the world volume is a tube
double worldrmax = 100.;
double worldrmin = 0.;
double worldz = 200.;
PhysicalVolume * world = GeoManager::MakePlacedTube( new TubeParameters<>(worldrmin, worldrmax, worldz, 0, 2.*M_PI), identity );
PhysicalVolume * beampipe = GeoManager::MakePlacedTube( new TubeParameters<>(worldrmax/40., worldrmax/20., worldz), identity );
world->AddDaughter( beampipe );
BoxParameters * plateparams = new BoxParameters(30,5.,2.*worldz/3.);
PhysicalVolume * plate1 = GeoManager::MakePlacedBox( plateparams, new TransformationMatrix(50, 0, 0, 35, 0, 10) );
PhysicalVolume * plate2 = GeoManager::MakePlacedBox( plateparams, new TransformationMatrix(-50, 0, 0, 35, 0, 10) );
PhysicalVolume * plate3 = GeoManager::MakePlacedBox( plateparams, new TransformationMatrix(0, 50, 0, -35, 0, 10) );
PhysicalVolume * plate4 = GeoManager::MakePlacedBox( plateparams, new TransformationMatrix(0, -50, 0, -35, 0, 10) );
world->AddDaughter( plate1 );
world->AddDaughter( plate2 );
world->AddDaughter( plate3 );
world->AddDaughter( plate4 );
// TransformationMatrix * tm = new TransformationMatrix(TransCases[t][0], TransCases[t][1], TransCases[t][2],
// EulerAngles[r][0], EulerAngles[r][1], EulerAngles[r][2]);
// these dispatch to specialized matrices
// TransformationMatrix const * sm = TransformationMatrix::createSpecializedMatrix( TransCases[t][0], TransCases[t][1], TransCases[t][2],
// EulerAngles[r][0], EulerAngles[r][1], EulerAngles[r][2] );
double rmin = 10.;
double rmax = 20.;
double dz = 30.;
double phis =0.;
//double dphi = 2.*M_PI;
double dphi = M_PI;
TubeParameters<double> const *tp = gTestShapeContainer.GetTubeParams(0);
PhysicalVolume * daughter = GeoManager::MakePlacedTube( tp, tm );
//std::cerr << daughter->UnplacedContains( Vector3D(15, 1, 15) ) << std::endl;
//std::cerr << daughter->UnplacedContains( Vector3D(-15, 1, 15) ) << std::endl;
// testing UnplacedContains
// for(auto k=0;k<100;k++)
// {
// Vector3D x( cos(k/(100.)*2*M_PI), sin(k/(100.)*2*M_PI), 0 );
// std::cerr << "## " << k/100.*2*M_PI << " " << daughter->UnplacedContains( x ) << std::endl;
// }
world->AddDaughter(daughter);
world->fillWithRandomPoints(points,np);
world->fillWithBiasedDirections(points, dirs, np, 8/10.);
daughter->fillWithRandomPoints(points,np);
points.toStructureOfVector3D( conventionalpoints );
dirs.toStructureOfVector3D( conventionaldirs );
points.toStructureOfVector3D( conventionalpoints2 );
dirs.toStructureOfVector3D( conventionaldirs2 );
//// time performance for this placement ( we should probably include some random physical steps )
timer.Start();
for(int reps=0;reps< NREPS ;reps++)
{
daughter->DistanceToOut(points,dirs,steps,distances);
}
timer.Stop();
double t0 = timer.getDeltaSecs();
//
// // std::cerr << tm->GetTranslationIdType() << " " << tm->getNumberOfZeroEntries() << " " << timer.getDeltaSecs() << std::endl;
//
// timer.Start();
// for(int reps=0;reps<NREPS;reps++)
// {
// daughter->DistanceToInIL(points,dirs,steps,distances);
// }
// timer.Stop();
// double til = timer.getDeltaSecs();
//
// timer.Start();
// for(int reps=0;reps<NREPS;reps++)
// {
// daughter->DistanceToInIL( conventionalpoints2, conventionaldirs2, steps, distances, np );
// }
// timer.Stop();
// double til2 = timer.getDeltaSecs();
//
//
// compare with case that uses external unspecialized transformation
//0, 20, 30, M_PI
PhysicalVolume * unplaceddaughter = GeoManager::MakePlacedTube( new TubeParameters<>( rmin, rmax ,dz, phis, dphi ), identity );
timer.Start();
for(int reps=0;reps<NREPS;reps++)
{
if(! tm->isIdentity() )
{
tm->MasterToLocal(points, intermediatepoints );
tm->MasterToLocalVec( dirs, intermediatedirs );
unplaceddaughter->DistanceToIn( intermediatepoints, intermediatedirs, steps, distances2);
}
else
{
unplaceddaughter->DistanceToIn( points, dirs, steps, distances2);
}
}
timer.Stop();
double t1 = timer.getDeltaSecs();
//
//
// // compare with external specialized transformation ( sm )
// sm->print();
timer.Start();
for(int reps=0;reps<NREPS;reps++)
{
sm->MasterToLocal(points, intermediatepoints );
sm->MasterToLocalVec( dirs, intermediatedirs );
unplaceddaughter->DistanceToIn( intermediatepoints, intermediatedirs, steps, distances2);
}
timer.Stop();
double t2 = timer.getDeltaSecs();
// std::cerr << "VECTOR " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t0 << " " << t1 << " " << t2 << " " << til << " " << til2 << std::endl;
// cmpresults( distances, distances2, np );
//
//
// // now we do the scalar interface: first of all placed version
// timer.Start();
// for(int reps=0;reps<NREPS;reps++)
// {
// for(auto j=0;j<np;++j)
// {
// distances[j]=daughter->DistanceToIn( conventionalpoints[j], conventionaldirs[j], steps[j]);
// }
// }
// timer.Stop();
// double t3 = timer.getDeltaSecs();
//
// // now unplaced version
// timer.Start();
// for(int reps=0;reps<NREPS;reps++)
// {
// for(auto j=0;j<np;++j)
// {
// Vector3D localp, localdir;
// tm->MasterToLocal(conventionalpoints[j], localp);
// tm->MasterToLocalVec(conventionaldirs[j], localdir);
// distances2[j]=unplaceddaughter->DistanceToIn( localp, localdir, steps[j]);
// }
// }
// timer.Stop();
// double t4 = timer.getDeltaSecs();
//
// // now unplaced version
// timer.Start();
// for(int reps=0;reps<NREPS;reps++)
// {
// for(auto j=0;j<np;++j)
// {
// Vector3D localp, localdir;
// sm->MasterToLocal(conventionalpoints[j], localp);
// sm->MasterToLocalVec(conventionaldirs[j], localdir);
// distances2[j]=unplaceddaughter->DistanceToIn( localp, localdir, steps[j]);
// }
// }
// timer.Stop();
// double t5 = timer.getDeltaSecs();
//
// // now unplaced version but inlined matrices
// timer.Start();
// for(int reps=0;reps<NREPS;reps++)
// {
// for(auto j=0;j<np;++j)
// {
// Vector3D localp, localdir;
// // this inlines I think
// tm->MasterToLocal<-1,-1>(conventionalpoints[j], localp);
// tm->MasterToLocalVec<-1>(conventionaldirs[j], localdir);
// distances2[j]=unplaceddaughter->DistanceToIn( localp, localdir, 1E30);
// }
// }
// timer.Stop();
// double t6 = timer.getDeltaSecs();
//
// std::cerr << "SCALAR " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t3 << " " << t4 << " " << t5 << " " << t6 << std::endl;
//
TGeoMatrix * rootmatrix= new TGeoCombiTrans(TransCases[t][0], TransCases[t][1], TransCases[t][2],
new TGeoRotation("rot1",EulerAngles[r][0], EulerAngles[r][1], EulerAngles[r][2]));
TGeoManager *geom = new TGeoManager("","");
TGeoVolume * vol = geom->MakeTubs("atube",0, tp->GetRmin(), tp->GetRmax(), tp->GetDZ(),tp->GetSPhi() *360/(2.*M_PI), tp->GetSPhi()+360*tp->GetDPhi()/(2.*M_PI));
TGeoShape * roottube=vol->GetShape();
// now the scalar version from ROOTGeantV
// timer.Start();
// for(int reps=0;reps<NREPS;reps++)
// {
// for(auto j=0;j<np;++j)
// {
// Vector3D localp, localdir;
// rootmatrix->MasterToLocal( &conventionalpoints[j].x, &localp.x );
// rootmatrix->MasterToLocalVect( &conventionaldirs[j].x, &localdir.x );
// distancesROOTSCALAR[j]=roottube->DistFromOutside( &localp.x, &localdir.x, 3, Utils::kInfinity, 0);
// }
// }
// timer.Stop();
// double t7 = timer.getDeltaSecs();
// now the scalar version from ROOTGeantV
timer.Start();
for(int reps=0;reps<NREPS;reps++)
{
for(auto j=0;j<np;++j)
{
Vector3D localp, localdir;
rootmatrix->MasterToLocal( &conventionalpoints[j].x, &localp.x );
rootmatrix->MasterToLocalVect( &conventionaldirs[j].x, &localdir.x );
distancesROOTSCALAR[j]=roottube->DistFromInside( &conventionalpoints[j].x, &conventionaldirs[j].x, 3, Utils::kInfinity, 0);
}
}
timer.Stop();
double t7 = timer.getDeltaSecs();
// now the VECTOR version from ROOT
// now the scalar version from ROOTGeantV
timer.Start();
for(int reps=0;reps<NREPS;reps++)
{
rootmatrix->MasterToLocalCombined_v( reinterpret_cast<StructOfCoord const &>(points), reinterpret_cast<StructOfCoord &>(intermediatepoints),
reinterpret_cast<StructOfCoord const &>(dirs), reinterpret_cast<StructOfCoord &>(intermediatedirs), np );
roottube->DistFromOutsideSOA_v( reinterpret_cast<StructOfCoord const &>(intermediatepoints),
reinterpret_cast<StructOfCoord const &>(intermediatedirs), 3, steps, 0, distances2, np);
}
timer.Stop();
double t8 = timer.getDeltaSecs();
cmpresults( distancesROOTSCALAR, distances, np, daughter, conventionalpoints, conventionaldirs );
// now we compare with loop over USolids version (scalar; trying to inline matrices as done in Geant4 typically)
VUSolid * utub = new UTubs("utubs1",rmin,rmax,dz, phis, dphi);
timer.Start();
for(int reps=0;reps<NREPS;reps++)
{
for(auto j=0;j<np;++j)
{
Vector3D localp, localdir;
// this inlines I think
tm->MasterToLocal<1,-1>( conventionalpoints[j], localp );
tm->MasterToLocalVec<-1>( conventionaldirs[j], localdir );
distancesUSOLIDSCALAR[j]=utub->DistanceToIn( reinterpret_cast<UVector3 const & > (localp), reinterpret_cast<UVector3 &> ( localdir ), 1e30);
}
}
timer.Stop();
double t9 = timer.getDeltaSecs();
std::cerr << "new vec (placed)" << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t0 << std::endl;
std::cerr << "new vec (old matrix)" << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t1 << std::endl;
std::cerr << "new vec (unplaced)" << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t2 << std::endl;
std::cerr << "RSCAL " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t7 << std::endl;
std::cerr << "RVEC " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t8 << std::endl;
std::cerr << "USOLIDS SCAL " << tm->isTranslation() << " " << tm->isRotation() << "("<<tm->getNumberOfZeroEntries()<<")" << " " << t9 << std::endl;
delete tm;
delete sm;
}
