34 #if defined ( _WIN64 ) || defined ( _WIN32 )
46 this->firstModelOnly =
true;
47 this->removeNegativeDensity =
true;
50 this->requestedResolution = -1.0;
51 this->changeMapResolution =
false;
52 this->changeMapResolutionTriLinear =
false;
55 this->pdbBFactorNewVal = -1.0;
58 this->maxBandwidth = 0;
59 this->rotationUncertainty = 0;
62 this->usePhase =
true;
65 this->maxSphereDists = 0.0;
69 this->taylorSeriesCap = 10;
72 this->normaliseMap =
false;
75 this->invertMap =
false;
78 this->blurFactor = 350.0;
79 this->maskingThresholdIQRs = 3.0;
80 this->maskMap =
false;
81 this->useCorrelationMasking =
false;
82 this->halfMapKernel = 0.0;
83 this->correlationKernel = 0.0;
84 this->saveMask =
false;
85 this->maskFileName =
"maskFile";
86 this->appliedMaskFileName =
"";
89 this->fourierWeightsFileName =
"";
92 this->reBoxMap =
false;
93 this->boundsExtraSpace = 3.0;
94 this->boundsSimilarityThreshold = 0;
95 this->useSameBounds =
false;
96 this->forceBounds =
new proshade_signed [6];
99 this->moveToCOM =
false;
105 this->addExtraSpace = 10.0;
106 this->coOrdsExtraSpace = 10.0;
109 this->progressiveSphereMapping =
false;
112 this->outName =
"reBoxed";
115 this->computeEnergyLevelsDesc =
true;
116 this->computeTraceSigmaDesc =
true;
117 this->computeRotationFuncDesc =
true;
118 this->enLevMatrixPowerWeight = 1.0;
121 this->peakNeighbours = 1;
122 this->noIQRsFromMedianNaivePeak = -999.9;
125 this->smoothingFactor = 15.0;
128 this->findSymCentre =
false;
129 this->useBiCubicInterpolationOnPeaks =
true;
130 this->maxSymmetryFold = 30;
131 this->fscThreshold = 0.33;
132 this->peakThresholdMin = 0.75;
133 this->fastISearch =
true;
134 this->symMissPeakThres = 0.3;
135 this->axisErrTolerance = 0.01;
136 this->axisErrToleranceDefault =
true;
137 this->minSymPeak = 0.3;
138 this->recommendedSymmetryType =
"";
139 this->recommendedSymmetryFold = 0;
140 this->requestedSymmetryType =
"";
141 this->requestedSymmetryFold = 0;
142 this->detectedSymmetry.clear ( );
150 this->overlayStructureName =
"movedStructure";
151 this->rotTrsJSONFile =
"movedStructureOperations.json";
155 this->messageShift = 0;
167 #if defined ( _WIN64 ) || defined ( _WIN32 )
174 this->task = settings->
task;
177 for (
size_t fIt = 0; fIt < settings->
inputFiles.size(); fIt++ ) { this->inputFiles.push_back ( settings->
inputFiles.at(fIt) ); }
178 this->forceP1 = settings->
forceP1;
196 this->usePhase = settings->
usePhase;
214 this->maskMap = settings->
maskMap;
218 this->saveMask = settings->
saveMask;
226 this->reBoxMap = settings->
reBoxMap;
230 this->forceBounds =
new proshade_signed [6];
231 for (
size_t fbIt = 0; fbIt < 6; fbIt++ ) { this->forceBounds[fbIt] = settings->
forceBounds[fbIt]; }
247 this->outName = settings->
outName;
271 this->axisErrToleranceDefault = settings->axisErrToleranceDefault;
279 this->detectedSymmetry.clear ( );
286 this->centrePosition.clear ( );
287 for (
size_t cpIt = 0; cpIt < settings->
centrePosition.size(); cpIt++ )
297 this->verbose = settings->
verbose;
309 #if defined ( _WIN64 ) || defined ( _WIN32 )
316 this->task = taskToPerform;
319 this->forceP1 =
true;
321 this->firstModelOnly =
true;
322 this->removeNegativeDensity =
true;
325 this->requestedResolution = -1.0;
326 this->changeMapResolution =
false;
327 this->changeMapResolutionTriLinear =
false;
330 this->pdbBFactorNewVal = -1.0;
333 this->maxBandwidth = 0;
334 this->rotationUncertainty = 0;
337 this->usePhase =
true;
340 this->maxSphereDists = 0.0;
343 this->integOrder = 0;
344 this->taylorSeriesCap = 10;
347 this->normaliseMap =
false;
350 this->invertMap =
false;
353 this->blurFactor = 350.0;
354 this->maskingThresholdIQRs = 3.0;
355 this->maskMap =
false;
356 this->useCorrelationMasking =
false;
357 this->halfMapKernel = 0.0;
358 this->correlationKernel = 0.0;
359 this->saveMask =
false;
360 this->maskFileName =
"maskFile";
361 this->appliedMaskFileName =
"";
364 this->fourierWeightsFileName =
"";
372 this->reBoxMap =
false;
373 this->boundsExtraSpace = 3.0;
374 this->boundsSimilarityThreshold = 0;
375 this->useSameBounds =
false;
376 this->forceBounds =
new proshade_signed [6];
379 this->addExtraSpace = 10.0;
380 this->coOrdsExtraSpace = 10.0;
383 this->progressiveSphereMapping =
false;
386 this->outName =
"reBoxed";
389 this->computeEnergyLevelsDesc =
true;
390 this->computeTraceSigmaDesc =
true;
391 this->computeRotationFuncDesc =
true;
392 this->enLevMatrixPowerWeight = 1.0;
395 this->peakNeighbours = 1;
396 this->noIQRsFromMedianNaivePeak = -999.9;
399 this->smoothingFactor = 15.0;
402 this->findSymCentre =
false;
403 this->useBiCubicInterpolationOnPeaks =
true;
404 this->maxSymmetryFold = 30;
405 this->fscThreshold = 0.33;
406 this->peakThresholdMin = 0.75;
407 this->fastISearch =
true;
408 this->symMissPeakThres = 0.3;
409 this->axisErrTolerance = 0.01;
410 this->axisErrToleranceDefault =
true;
411 this->minSymPeak = 0.3;
412 this->recommendedSymmetryType =
"";
413 this->recommendedSymmetryFold = 0;
414 this->requestedSymmetryType =
"";
415 this->requestedSymmetryFold = 0;
416 this->detectedSymmetry.clear ( );
424 this->overlayStructureName =
"movedStructure";
425 this->rotTrsJSONFile =
"movedStructureOperations.json";
429 this->messageShift = 0;
432 switch ( this->task )
435 std::cerr << std::endl <<
"=====================" << std::endl <<
"!! ProSHADE ERROR !!" << std::endl <<
"=====================" << std::endl << std::flush;
436 std::cerr <<
"Error Code : " <<
"E000014" << std::endl << std::flush;
437 std::cerr <<
"ProSHADE version : " << PROSHADE_VERSION << std::endl << std::flush;
438 std::cerr <<
"File : " <<
"ProSHADE.cpp" << std::endl << std::flush;
439 std::cerr <<
"Line : " << 97 << std::endl << std::flush;
440 std::cerr <<
"Function : " <<
"ProSHADE_settings (Task) constructor" << std::endl << std::flush;
441 std::cerr <<
"Message : " <<
"No task has been specified for task specific constructor." << std::endl << std::flush;
442 std::cerr <<
"Further information : " <<
"This ProSHADE_settings class constructor is intended to\n : set the internal variables to default value given a\n : particular taks. By supplying this task as NA, this beats\n : the purpose of the constructor. Please use the\n : non-argumental constructor if task is not yet known." << std::endl << std::endl << std::flush;
444 exit ( EXIT_FAILURE );
447 this->requestedResolution = 6.0;
448 this->pdbBFactorNewVal = 80.0;
449 this->changeMapResolution =
true;
450 this->maskMap =
false;
451 this->moveToCOM =
true;
452 this->reBoxMap =
false;
456 this->changeMapResolution =
false;
457 this->maskMap =
false;
458 this->moveToCOM =
true;
459 this->reBoxMap =
false;
463 this->requestedResolution = 8.0;
464 this->changeMapResolution =
true;
465 this->maskMap =
false;
466 this->moveToCOM =
false;
467 this->reBoxMap =
false;
471 this->changeMapResolution =
false;
472 this->maskMap =
true;
473 this->moveToCOM =
false;
485 #if defined ( _WIN64 ) || defined ( _WIN32 )
492 delete[] this->forceBounds;
495 if ( this->detectedSymmetry.size() > 0 ) {
for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( this->detectedSymmetry.size() ); it++ ) {
if ( this->detectedSymmetry.at(it) != nullptr ) {
delete[] this->detectedSymmetry.at(it); } } }
507 if ( lhs.AlmostEquals( rhs ) )
526 #if defined ( _WIN64 ) || defined ( _WIN32 )
546 #if defined ( _WIN64 ) || defined ( _WIN32 )
553 this->requestedResolution = resolution;
566 #if defined ( _WIN64 ) || defined ( _WIN32 )
573 this->pdbBFactorNewVal = newBF;
586 #if defined ( _WIN64 ) || defined ( _WIN32 )
593 this->normaliseMap = normalise;
606 #if defined ( _WIN64 ) || defined ( _WIN32 )
613 this->invertMap = mInv;
626 #if defined ( _WIN64 ) || defined ( _WIN32 )
633 this->verbose = verbosity;
646 #if defined ( _WIN64 ) || defined ( _WIN32 )
653 this->blurFactor = blurFac;
667 #if defined ( _WIN64 ) || defined ( _WIN32 )
674 this->maskingThresholdIQRs = noIQRs;
687 #if defined ( _WIN64 ) || defined ( _WIN32 )
694 this->maskMap = mask;
708 #if defined ( _WIN64 ) || defined ( _WIN32 )
715 this->useCorrelationMasking = corMask;
730 #if defined ( _WIN64 ) || defined ( _WIN32 )
737 this->halfMapKernel = typNoi;
750 #if defined ( _WIN64 ) || defined ( _WIN32 )
757 this->correlationKernel = minMS;
770 #if defined ( _WIN64 ) || defined ( _WIN32 )
777 this->saveMask = savMsk;
790 #if defined ( _WIN64 ) || defined ( _WIN32 )
797 this->maskFileName = mskFln;
810 #if defined ( _WIN64 ) || defined ( _WIN32 )
817 this->appliedMaskFileName = mskFln;
830 #if defined ( _WIN64 ) || defined ( _WIN32 )
837 this->fourierWeightsFileName = fWgFln;
850 #if defined ( _WIN64 ) || defined ( _WIN32 )
857 this->reBoxMap = reBx;
871 #if defined ( _WIN64 ) || defined ( _WIN32 )
878 this->boundsExtraSpace = boundsExSp;
891 #if defined ( _WIN64 ) || defined ( _WIN32 )
898 this->boundsSimilarityThreshold = boundsThres;
912 #if defined ( _WIN64 ) || defined ( _WIN32 )
919 this->useSameBounds = sameB;
933 #if defined ( _WIN64 ) || defined ( _WIN32 )
940 this->outName = oFileName;
953 #if defined ( _WIN64 ) || defined ( _WIN32 )
960 this->changeMapResolution = mrChange;
973 #if defined ( _WIN64 ) || defined ( _WIN32 )
980 this->changeMapResolutionTriLinear = mrChange;
993 #if defined ( _WIN64 ) || defined ( _WIN32 )
1000 this->moveToCOM = com;
1015 #if defined ( _WIN64 ) || defined ( _WIN32 )
1022 if ( this->moveToCOM )
1024 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested specific map box centre and also centre of mass centring. These are mutually exclusive - turning COM centring off.",
"WP00067" );
1025 this->moveToCOM =
false;
1029 this->boxCentre.at(0) = xPos;
1030 this->boxCentre.at(1) = yPos;
1031 this->boxCentre.at(2) = zPos;
1044 #if defined ( _WIN64 ) || defined ( _WIN32 )
1051 this->addExtraSpace = exSpace;
1064 #if defined ( _WIN64 ) || defined ( _WIN32 )
1071 this->coOrdsExtraSpace = exSpace;
1084 #if defined ( _WIN64 ) || defined ( _WIN32 )
1091 this->maxBandwidth = band;
1104 #if defined ( _WIN64 ) || defined ( _WIN32 )
1111 this->maxSphereDists = sphDist;
1124 #if defined ( _WIN64 ) || defined ( _WIN32 )
1131 this->integOrder = intOrd;
1145 #if defined ( _WIN64 ) || defined ( _WIN32 )
1152 this->taylorSeriesCap = tayCap;
1165 #if defined ( _WIN64 ) || defined ( _WIN32 )
1172 this->progressiveSphereMapping = progSphMap;
1186 #if defined ( _WIN64 ) || defined ( _WIN32 )
1193 this->computeEnergyLevelsDesc = enLevDesc;
1207 #if defined ( _WIN64 ) || defined ( _WIN32 )
1214 this->computeTraceSigmaDesc = trSigVal;
1228 #if defined ( _WIN64 ) || defined ( _WIN32 )
1235 this->computeRotationFuncDesc = rotfVal;
1249 #if defined ( _WIN64 ) || defined ( _WIN32 )
1256 this->peakNeighbours = pkS;
1271 #if defined ( _WIN64 ) || defined ( _WIN32 )
1278 this->noIQRsFromMedianNaivePeak = noIQRs;
1293 #if defined ( _WIN64 ) || defined ( _WIN32 )
1300 this->usePhase = phaseUsage;
1315 #if defined ( _WIN64 ) || defined ( _WIN32 )
1322 this->enLevMatrixPowerWeight = mPower;
1337 #if defined ( _WIN64 ) || defined ( _WIN32 )
1344 this->smoothingFactor = smFact;
1358 #if defined ( _WIN64 ) || defined ( _WIN32 )
1365 this->symMissPeakThres = mpThres;
1379 #if defined ( _WIN64 ) || defined ( _WIN32 )
1386 this->findSymCentre = sCen;
1400 #if defined ( _WIN64 ) || defined ( _WIN32 )
1407 this->axisErrTolerance = axThres;
1423 #if defined ( _WIN64 ) || defined ( _WIN32 )
1430 this->axisErrToleranceDefault = behav;
1444 #if defined ( _WIN64 ) || defined ( _WIN32 )
1451 this->minSymPeak = minSP;
1466 #if defined ( _WIN64 ) || defined ( _WIN32 )
1473 this->recommendedSymmetryType = val;
1489 #if defined ( _WIN64 ) || defined ( _WIN32 )
1496 this->recommendedSymmetryFold = val;
1509 #if defined ( _WIN64 ) || defined ( _WIN32 )
1516 this->requestedSymmetryType = val;
1529 #if defined ( _WIN64 ) || defined ( _WIN32 )
1536 this->requestedSymmetryFold = val;
1550 #if defined ( _WIN64 ) || defined ( _WIN32 )
1557 proshade_double* hlpAxis =
new proshade_double [7];
1561 hlpAxis[0] = sym[0];
1562 hlpAxis[1] = sym[1];
1563 hlpAxis[2] = sym[2];
1564 hlpAxis[3] = sym[3];
1565 hlpAxis[4] = sym[4];
1566 hlpAxis[5] = sym[5];
1567 hlpAxis[6] = sym[6];
1584 #if defined ( _WIN64 ) || defined ( _WIN32 )
1591 this->overlayStructureName = filename;
1602 #if defined ( _WIN64 ) || defined ( _WIN32 )
1609 this->rotTrsJSONFile = filename;
1620 #if defined ( _WIN64 ) || defined ( _WIN32 )
1627 this->useBiCubicInterpolationOnPeaks = bicubPeaks;
1638 #if defined ( _WIN64 ) || defined ( _WIN32 )
1645 this->maxSymmetryFold = maxFold;
1656 #if defined ( _WIN64 ) || defined ( _WIN32 )
1663 this->fscThreshold = fscThr;
1674 #if defined ( _WIN64 ) || defined ( _WIN32 )
1681 this->peakThresholdMin = peakThr;
1692 #if defined ( _WIN64 ) || defined ( _WIN32 )
1699 this->removeNegativeDensity = nDens;
1719 std::stringstream hlpSS;
1720 hlpSS <<
"The bandwidth was determined as: " << this->
maxBandwidth;
1729 std::stringstream hlpSS;
1730 hlpSS <<
"The bandwidth was determined as: " << this->
maxBandwidth;
1749 if (
static_cast<proshade_unsign
> ( std::ceil ( ( 360.0 / uncertainty ) / 2 ) ) % 2 == 0 )
1751 this->
maxBandwidth =
static_cast<proshade_unsign
> ( std::ceil ( ( 360.0 / uncertainty ) / 2.0 ) );
1755 this->
maxBandwidth =
static_cast<proshade_unsign
> ( std::ceil ( ( 360.0 / uncertainty ) / 2.0 ) ) + 1;
1759 std::stringstream hlpSS;
1760 hlpSS <<
"The bandwidth was determined from uncertainty " << uncertainty <<
" degrees as: " << this->
maxBandwidth;
1782 std::stringstream hlpSS;
1783 hlpSS <<
"The sphere distances were determined as " << this->
maxSphereDists <<
" Angstroms.";
1792 std::stringstream hlpSS;
1793 hlpSS <<
"The sphere distances were determined as " << this->
maxSphereDists <<
" Angstroms.";
1814 std::stringstream hlpSS;
1815 hlpSS <<
"The integration order was determined as " << this->
integOrder;
1824 std::stringstream hlpSS;
1825 hlpSS <<
"The integration order was determined as " << this->
integOrder;
1859 proshade_unsign theoXDim =
static_cast< proshade_unsign
> ( std::ceil ( xDimAngs / ( this->
requestedResolution / 2.0f ) ) );
1860 proshade_unsign theoYDim =
static_cast< proshade_unsign
> ( std::ceil ( yDimAngs / ( this->
requestedResolution / 2.0f ) ) );
1861 proshade_unsign theoZDim =
static_cast< proshade_unsign
> ( std::ceil ( zDimAngs / ( this->
requestedResolution / 2.0f ) ) );
1864 proshade_unsign maxDim = std::max ( theoXDim, std::max ( theoYDim, theoZDim ) );
1865 proshade_unsign minDim = std::min ( theoXDim, std::min ( theoYDim, theoZDim ) );
1866 proshade_unsign midDim = 0;
1867 if ( ( xDim < maxDim ) && ( xDim > minDim ) ) { midDim = theoXDim; }
1868 else if ( ( yDim < maxDim ) && ( yDim > minDim ) ) { midDim = theoYDim; }
1869 else { midDim = theoZDim; }
1871 proshade_unsign circ = ( maxDim ) + ( midDim );
1878 proshade_single maxDiag =
static_cast< proshade_single
> ( std::sqrt ( std::pow (
static_cast<proshade_single
> ( maxDim ) * ( this->
requestedResolution / 2.0f ), 2.0f ) +
1879 std::pow (
static_cast<proshade_single
> ( midDim ) * ( this->
requestedResolution / 2.0f ), 2.0f ) ) );
1902 #if defined ( _WIN64 ) || defined ( _WIN32 )
1912 this->noStructures =
static_cast<proshade_unsign
> ( settings->
inputFiles.size() );
1913 this->verbose =
static_cast<proshade_signed
> ( settings->
verbose );
1919 switch ( settings->
task )
1922 throw ProSHADE_exception (
"No task has been specified.",
"E000001", __FILE__, __LINE__, __func__,
"ProSHADE requires to be told which particular functiona-\n : lity (task) is requested from it. In order to do so, the\n : command line arguments specifying task need to be used\n : (if used from command line), or the ProSHADE_settings\n : object needs to have the member variable \'Task\' set to\n : one of the following values: Distances, Symmetry,\n : OverlayMap or MapManip." );
1926 this->setSymmetryResults ( settings );
1946 std::cerr << std::endl <<
"=====================" << std::endl <<
"!! ProSHADE ERROR !!" << std::endl <<
"=====================" << std::endl << std::flush;
1947 std::cerr <<
"Error Code : " << err.
get_errc() << std::endl << std::flush;
1948 std::cerr <<
"ProSHADE version : " << PROSHADE_VERSION << std::endl << std::flush;
1949 std::cerr <<
"File : " << err.
get_file() << std::endl << std::flush;
1950 std::cerr <<
"Line : " << err.
get_line() << std::endl << std::flush;
1951 std::cerr <<
"Function : " << err.
get_func() << std::endl << std::flush;
1952 std::cerr <<
"Message : " << err.what() << std::endl << std::flush;
1953 std::cerr <<
"Further information : " << err.
get_info() << std::endl << std::endl << std::flush;
1957 exit ( EXIT_FAILURE );
1963 std::cerr << std::endl <<
"=====================" << std::endl <<
"!! ProSHADE ERROR !!" << std::endl <<
"=====================" << std::endl << std::flush;
1966 #if __cplusplus >= 201103L
1967 std::exception_ptr exc = std::current_exception();
1972 std::rethrow_exception ( exc );
1975 catch (
const std::exception& e )
1977 std::cerr <<
"Caught unknown exception with following information: " << e.what() << std::endl << std::flush;
1980 std::cerr <<
"Unknown error with no further explanation available. Please contact the author for help." << std::endl << std::flush;
1982 std::cerr <<
"Terminating..." << std::endl << std::endl << std::flush;
1986 exit ( EXIT_FAILURE );
2000 #if defined ( _WIN64 ) || defined ( _WIN32 )
2007 if ( this->originalBounds.size() > 0 ) {
for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->originalBounds.size() ); iter++ ) {
delete[] this->originalBounds.at(iter); } }
2008 if ( this->reboxedBounds.size() > 0 ) {
for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->reboxedBounds.size() ); iter++ ) {
delete[] this->reboxedBounds.at(iter); } }
2009 if ( this->manipulatedMaps.size() > 0 ) {
for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->manipulatedMaps.size() ); iter++ ) {
delete[] this->manipulatedMaps.at(iter); } }
2012 this->enLevs.clear ( );
2013 this->trSigm.clear ( );
2014 this->rotFun.clear ( );
2017 if ( this->RecomSymAxes.size() > 0 )
2019 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->RecomSymAxes.size() ); iter++ )
2021 delete[] this->RecomSymAxes.at(iter);
2023 this->RecomSymAxes.clear ( );
2034 #if defined ( _WIN64 ) || defined ( _WIN32 )
2042 return ( this->symRecommType );
2049 #if defined ( _WIN64 ) || defined ( _WIN32 )
2056 return ( this->symRecommFold );
2065 void ProSHADE_run::setRecommendedSymmetry ( std::string val )
2068 this->symRecommType = val;
2082 void ProSHADE_run::setRecommendedFold ( proshade_unsign val )
2085 this->symRecommFold = val;
2099 void ProSHADE_run::setRecommendedAxis ( proshade_double* sym )
2132 #if defined ( _WIN64 ) || defined ( _WIN32 )
2142 const struct option_port longopts[] =
2144 {
"version", no_argument,
nullptr,
'v' },
2145 {
"help", no_argument,
nullptr,
'h' },
2146 {
"verbose", required_argument,
nullptr,
'!' },
2147 {
"distances", no_argument,
nullptr,
'D' },
2148 {
"mapManip", no_argument,
nullptr,
'M' },
2149 {
"symmetry", no_argument,
nullptr,
'S' },
2150 {
"symCentre", no_argument,
nullptr,
'I' },
2151 {
"overlay", no_argument,
nullptr,
'O' },
2152 {
"file", required_argument,
nullptr,
'f' },
2153 {
"forceSpgP1", no_argument,
nullptr,
'u' },
2154 {
"removeWaters", no_argument,
nullptr,
'w' },
2155 {
"firstModel", no_argument,
nullptr,
'x' },
2156 {
"resolution", required_argument,
nullptr,
'r' },
2157 {
"bandwidth", required_argument,
nullptr,
'b' },
2158 {
"sphereDists", required_argument,
nullptr,
's' },
2159 {
"extraSpace", required_argument,
nullptr,
'e' },
2160 {
"integOrder", required_argument,
nullptr,
'i' },
2161 {
"taylorCap", required_argument,
nullptr,
't' },
2162 {
"invertMap", no_argument,
nullptr,
'@' },
2163 {
"normalise", no_argument,
nullptr,
'#' },
2164 {
"mask", no_argument,
nullptr,
'$' },
2165 {
"saveMask", no_argument,
nullptr,
'%' },
2166 {
"maskFile", required_argument,
nullptr,
'^' },
2167 {
"applyMask", required_argument,
nullptr,
'G' },
2168 {
"maskBlurring", required_argument,
nullptr,
'&' },
2169 {
"maskThreshold", required_argument,
nullptr,
'*' },
2170 {
"mapReboxing", no_argument,
nullptr,
'R' },
2171 {
"boundsSpace", required_argument,
nullptr,
'(' },
2172 {
"boundsThreshold", required_argument,
nullptr,
')' },
2173 {
"sameBoundaries", no_argument,
nullptr,
'-' },
2174 {
"reBoxedFilename", required_argument,
nullptr,
'g' },
2175 {
"pdbTempFact", required_argument,
nullptr,
'd' },
2176 {
"center", no_argument,
nullptr,
'c' },
2177 {
"changeMapResol", no_argument,
nullptr,
'j' },
2178 {
"changeMapTriLin", no_argument,
nullptr,
'a' },
2179 {
"noPhase", no_argument,
nullptr,
'p' },
2180 {
"progressive", no_argument,
nullptr,
'k' },
2181 {
"noEnL", no_argument,
nullptr,
'l' },
2182 {
"noTrS", no_argument,
nullptr,
'm' },
2183 {
"noFRF", no_argument,
nullptr,
'n' },
2184 {
"EnLWeight", required_argument,
nullptr,
'_' },
2185 {
"peakNeigh", required_argument,
nullptr,
'=' },
2186 {
"peakThres", required_argument,
nullptr,
'+' },
2187 {
"missAxThres", required_argument,
nullptr,
'[' },
2188 {
"sameAxComp", required_argument,
nullptr,
']' },
2189 {
"axisComBeh", no_argument,
nullptr,
'q' },
2190 {
"bicubSearch", no_argument,
nullptr,
'A' },
2191 {
"maxSymPrime", required_argument,
nullptr,
'B' },
2192 {
"minPeakHeight", required_argument,
nullptr,
'o' },
2193 {
"fscThres", required_argument,
nullptr,
'C' },
2194 {
"peakMinThres", required_argument,
nullptr,
'E' },
2195 {
"reqSym", required_argument,
nullptr,
'{' },
2196 {
"overlayFile", required_argument,
nullptr,
'}' },
2197 {
"overlayJSONFile", required_argument,
nullptr,
'y' },
2198 {
"angUncertain", required_argument,
nullptr,
';' },
2199 {
"fourierWeights", required_argument,
nullptr,
'z' },
2200 {
"keepNegDens", no_argument,
nullptr,
'F' },
2201 {
"coordExtraSpace", required_argument,
nullptr,
'H' },
2202 {
nullptr, 0,
nullptr, 0 }
2206 const char*
const shortopts =
"AaB:b:C:cDd:E:e:Ff:G:g:H:hIi:jklmMno:Opqr:Rs:St:uvwxy:z:!:@#$%^:&:*:(:):-_:=:+:[:]:{:}:;:";
2212 int opt = getopt_long_port ( argc, argv, shortopts, longopts,
nullptr );
2227 exit ( EXIT_SUCCESS );
2239 this->setVerbosity (
static_cast<proshade_signed
> ( atoi ( optarg ) ) );
2246 this->task = Distances;
2253 this->task = MapManip;
2260 this->task = Symmetry;
2263 const FloatingPoint< proshade_single > lhs1 ( this->requestedResolution ), rhs1 ( -1.0f );
2264 if ( lhs1.AlmostEquals ( rhs1 ) ) { this->requestedResolution = 6.0; }
2266 const FloatingPoint< proshade_double > lhs2 ( this->pdbBFactorNewVal ), rhs2 ( -1.0 );
2267 if ( lhs2.AlmostEquals ( rhs2 ) ) { this->pdbBFactorNewVal = 80.0; }
2268 this->changeMapResolution = !this->changeMapResolution;
2269 this->moveToCOM = !this->moveToCOM;
2277 this->task = OverlayMap;
2284 this->addStructure ( std::string ( optarg ) );
2291 this->forceP1 = !this->forceP1;
2305 this->firstModelOnly = !this->firstModelOnly;
2312 this->setResolution (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2319 this->setBandwidth (
static_cast<proshade_unsign
> ( atoi ( optarg ) ) );
2326 this->setExtraSpace (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2333 this->setCoordExtraSpace (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2340 this->setIntegrationOrder (
static_cast<proshade_unsign
> ( atof ( optarg ) ) );
2347 this->setSphereDistances (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2354 this->setTaylorSeriesCap (
static_cast<proshade_unsign
> ( atof ( optarg ) ) );
2361 this->setMapInversion (
true );
2368 this->setNormalisation (
true );
2375 this->setMasking (
true );
2382 this->setMasking (
true );
2383 this->setMaskSaving (
true );
2390 this->setMaskFilename (
static_cast<std::string
> ( optarg ) );
2397 this->setAppliedMaskFilename (
static_cast<std::string
> ( optarg ) );
2404 this->setFourierWeightsFilename (
static_cast<std::string
> ( optarg ) );
2411 this->setMaskBlurFactor (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2418 this->setMaskIQR (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2425 this->setMasking (
true );
2426 this->setMapReboxing (
true );
2433 this->setBoundsSpace (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2440 this->setBoundsThreshold (
static_cast<proshade_signed
> ( atoi ( optarg ) ) );
2447 this->setSameBoundaries (
true );
2454 this->setOutputFilename (
static_cast<std::string
> ( optarg ) );
2461 this->setPDBBFactor (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2468 this->moveToCOM = !this->moveToCOM;
2475 this->changeMapResolution = !this->changeMapResolution;
2482 this->setMapResolutionChangeTriLinear (
true );
2489 this->setPhaseUsage (
false );
2496 this->setProgressiveSphereMapping (
true );
2503 this->setEnergyLevelsComputation (
false );
2510 this->setTraceSigmaComputation (
false );
2517 this->setRotationFunctionComputation (
false );
2524 this->setEnLevShellWeight (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2531 this->setPeakNeighboursNumber (
static_cast<proshade_unsign
> ( atoi ( optarg ) ) );
2538 this->setPeakNaiveNoIQR (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2545 this->setSymmetryCentreSearch (
true );
2552 this->setMissingPeakThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2559 setAxisComparisonThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2566 this->setAxisComparisonThresholdBehaviour ( !this->axisErrToleranceDefault );
2573 this->setBicubicInterpolationSearch ( !this->useBiCubicInterpolationOnPeaks );
2580 setMaxSymmetryFold (
static_cast<proshade_unsign
> ( atoi ( optarg ) ) );
2587 this->minSymPeak =
static_cast<proshade_double
> ( atof ( optarg ) );
2594 this->setFSCThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2601 this->setPeakThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2608 std::string input =
static_cast<std::string
> ( optarg );
2610 if ( input.at(0) ==
'C' )
2612 this->setRequestedSymmetry (
"C" );
2614 std::string numHlp ( input.begin()+1, input.end() );
2615 if ( numHlp.length() > 0 ) { this->setRequestedFold (
static_cast< proshade_unsign
> ( atoi ( numHlp.c_str() ) ) ); }
2616 else { std::cerr <<
"!!! ProSHADE ERROR !!! The input argument requests search for Cyclic/Dihedral symmetry, but does not specify the requested fold." << std::endl; exit ( EXIT_FAILURE ); }
2620 if ( input.at(0) ==
'D' )
2622 this->setRequestedSymmetry (
"D" );
2624 std::string numHlp ( input.begin()+1, input.end() );
2625 if ( numHlp.length() > 0 ) { this->setRequestedFold (
static_cast< proshade_unsign
> ( atoi ( numHlp.c_str() ) ) ); }
2626 else { std::cerr <<
"!!! ProSHADE ERROR !!! The input argument requests search for Cyclic/Dihedral symmetry, but does not specify the requested fold." << std::endl; exit ( EXIT_FAILURE ); }
2630 if ( input.at(0) ==
'T' )
2632 this->setRequestedSymmetry (
"T" );
2636 if ( input.at(0) ==
'O' )
2638 this->setRequestedSymmetry (
"O" );
2642 if ( input.at(0) ==
'I' )
2644 this->setRequestedSymmetry (
"I" );
2648 std::cerr <<
"!!! ProSHADE ERROR !!! Failed to parse the requested symmetry type. Allowed types are C, D, T, O and I, with C and D requiring to be followed by a number specifying the fold." << std::endl; exit ( EXIT_FAILURE );
2661 this->setOverlaySaveFile (
static_cast<std::string
> ( optarg ) );
2668 this->setOverlayJsonFile (
static_cast<std::string
> ( optarg ) );
2675 this->rotationUncertainty =
static_cast<proshade_double
> ( atof ( optarg ) );
2682 this->setNegativeDensity (
false );
2692 std::cout <<
"!!! ProSHADE ERROR !!! Unrecognised short option -" <<
static_cast<char> ( optopt ) <<
" . Please use -h for help on the command line options." << std::endl;
2696 std::cout <<
"!!! ProSHADE ERROR !!! Unrecognised long option " << argv[
static_cast<int> (optind)-1] <<
" . Please use -h for help on the command line options." << std::endl;
2700 exit ( EXIT_SUCCESS );
2720 #if defined ( _WIN64 ) || defined ( _WIN32 )
2728 std::stringstream strstr;
2729 strstr.str(std::string());
2730 if ( this->task == NA ) { strstr <<
"NA"; }
2731 if ( this->task == Distances ) { strstr <<
"DISTANCES COMPUTATION"; }
2732 if ( this->task == MapManip ) { strstr <<
"MAP MANIPULATION"; }
2733 if ( this->task == Symmetry ) { strstr <<
"SYMMETRY DETECTION"; }
2734 if ( this->task == OverlayMap ) { strstr <<
"MAP OVERLAY"; }
2735 printf (
"Task to perform : %37s\n", strstr.str().c_str() );
2738 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->inputFiles.size() ); iter++ )
2740 strstr.str(std::string());
2741 strstr << this->inputFiles.at(iter);
2742 printf (
"File(s) to process : %37s\n", strstr.str().c_str() );
2745 strstr.str(std::string());
2746 if ( this->forceP1 ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2747 printf (
"Force P1 spacegroup : %37s\n", strstr.str().c_str() );
2749 strstr.str(std::string());
2750 if ( this->
removeWaters ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2751 printf (
"Waters removed : %37s\n", strstr.str().c_str() );
2753 strstr.str(std::string());
2754 if ( this->firstModelOnly ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2755 printf (
"Only 1st model : %37s\n", strstr.str().c_str() );
2757 strstr.str(std::string());
2758 if ( this->removeNegativeDensity ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2759 printf (
"Remove neg. dens. : %37s\n", strstr.str().c_str() );
2762 strstr.str(std::string());
2763 strstr << this->requestedResolution;
2764 printf (
"Resolution (comp) : %37s\n", strstr.str().c_str() );
2766 strstr.str(std::string());
2767 if ( this->changeMapResolution ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2768 printf (
"Change map resol : %37s\n", strstr.str().c_str() );
2770 strstr.str(std::string());
2771 if ( this->changeMapResolutionTriLinear ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2772 printf (
"Change map tri-lin : %37s\n", strstr.str().c_str() );
2775 strstr.str(std::string());
2776 strstr << this->pdbBFactorNewVal;
2777 printf (
"PDB B-factor const : %37s\n", strstr.str().c_str() );
2780 strstr.str(std::string());
2781 strstr << this->maxBandwidth;
2782 printf (
"Bandwidth : %37s\n", strstr.str().c_str() );
2784 strstr.str(std::string());
2785 strstr << this->rotationUncertainty;
2786 printf (
"Rotation doubt : %37s\n", strstr.str().c_str() );
2789 strstr.str(std::string());
2790 if ( this->usePhase ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2791 printf (
"Use phase info : %37s\n", strstr.str().c_str() );
2794 strstr.str(std::string());
2795 strstr << this->maxSphereDists;
2796 printf (
"Sphere distances : %37s\n", strstr.str().c_str() );
2799 strstr.str(std::string());
2800 strstr << this->integOrder;
2801 printf (
"Integration order : %37s\n", strstr.str().c_str() );
2803 strstr.str(std::string());
2804 strstr << this->taylorSeriesCap;
2805 printf (
"Taylor series cap : %37s\n", strstr.str().c_str() );
2808 strstr.str(std::string());
2809 if ( this->normaliseMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2810 printf (
"Map normalisation : %37s\n", strstr.str().c_str() );
2813 strstr.str(std::string());
2814 if ( this->invertMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2815 printf (
"Map inversion : %37s\n", strstr.str().c_str() );
2818 strstr.str(std::string());
2819 strstr << this->blurFactor;
2820 printf (
"Map blurring : %37s\n", strstr.str().c_str() );
2822 strstr.str(std::string());
2823 strstr << this->maskingThresholdIQRs;
2824 printf (
"Masking threshold : %37s\n", strstr.str().c_str() );
2826 strstr.str(std::string());
2827 if ( this->maskMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2828 printf (
"Map masking : %37s\n", strstr.str().c_str() );
2830 strstr.str(std::string());
2831 if ( this->useCorrelationMasking ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2832 printf (
"Correlation mask : %37s\n", strstr.str().c_str() );
2834 strstr.str(std::string());
2835 strstr << this->halfMapKernel;
2836 printf (
"Half-map kernel : %37s\n", strstr.str().c_str() );
2838 strstr.str(std::string());
2839 strstr << this->correlationKernel;
2840 printf (
"Correlation kernel : %37s\n", strstr.str().c_str() );
2842 strstr.str(std::string());
2843 if ( this->saveMask ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2844 printf (
"Saving mask : %37s\n", strstr.str().c_str() );
2846 strstr.str(std::string());
2847 strstr << this->maskFileName;
2848 printf (
"Map mask filename : %37s\n", strstr.str().c_str() );
2851 strstr.str(std::string());
2852 if ( this->reBoxMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2853 printf (
"Map re-boxing : %37s\n", strstr.str().c_str() );
2855 strstr.str(std::string());
2856 strstr << this->boundsExtraSpace;
2857 printf (
"Bounds extra space : %37s\n", strstr.str().c_str() );
2859 strstr.str(std::string());
2860 strstr << this->boundsSimilarityThreshold;
2861 printf (
"Bounds similarity : %37s\n", strstr.str().c_str() );
2863 strstr.str(std::string());
2864 if ( this->useSameBounds ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2865 printf (
"Same boundaries : %37s\n", strstr.str().c_str() );
2867 strstr.str(std::string());
2868 if ( this->forceBounds !=
nullptr )
2870 strstr << this->forceBounds[0] <<
" - " << this->forceBounds[1] <<
" | " << this->forceBounds[2] <<
" - " << this->forceBounds[3] <<
" | " << this->forceBounds[4] <<
" - " << this->forceBounds[5];
2871 printf (
"Bounds similarity : %37s\n", strstr.str().c_str() );
2875 strstr <<
"Not allocated";
2876 printf (
"Bounds similarity : %37s\n", strstr.str().c_str() );
2880 strstr.str(std::string());
2881 if ( this->moveToCOM ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2882 printf (
"Map COM centering : %37s\n", strstr.str().c_str() );
2884 strstr.str(std::string());
2885 strstr << this->boxCentre.at(0) <<
" ; " << this->boxCentre.at(1) <<
" ; " << this->boxCentre.at(2);
2886 printf (
"BOX centering : %37s\n", strstr.str().c_str() );
2889 strstr.str(std::string());
2890 strstr << this->addExtraSpace;
2891 printf (
"Extra space : %37s\n", strstr.str().c_str() );
2893 strstr.str(std::string());
2894 strstr << this->coOrdsExtraSpace;
2895 printf (
"Extra co-ord space : %37s\n", strstr.str().c_str() );
2898 strstr.str(std::string());
2899 if ( this->progressiveSphereMapping ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2900 printf (
"Progressive spheres : %37s\n", strstr.str().c_str() );
2903 strstr.str(std::string());
2904 strstr << this->outName;
2905 printf (
"Re-boxed filename : %37s\n", strstr.str().c_str() );
2908 strstr.str(std::string());
2909 if ( this->computeEnergyLevelsDesc ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2910 printf (
"Energy lvl desc : %37s\n", strstr.str().c_str() );
2912 strstr.str(std::string());
2913 strstr << this->enLevMatrixPowerWeight;
2914 printf (
"Energy lvl weight : %37s\n", strstr.str().c_str() );
2916 strstr.str(std::string());
2917 if ( this->findSymCentre ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2918 printf (
"Symmetry centre : %37s\n", strstr.str().c_str() );
2920 strstr.str(std::string());
2921 if ( this->computeTraceSigmaDesc ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2922 printf (
"Tr sigma desc : %37s\n", strstr.str().c_str() );
2924 strstr.str(std::string());
2925 if ( this->computeRotationFuncDesc ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2926 printf (
"Full RF desc : %37s\n", strstr.str().c_str() );
2929 strstr.str(std::string());
2930 strstr << this->peakNeighbours;
2931 printf (
"Neightbours to peak : %37s\n", strstr.str().c_str() );
2933 strstr.str(std::string());
2934 strstr << this->noIQRsFromMedianNaivePeak;
2935 printf (
"Peak IQR threshold : %37s\n", strstr.str().c_str() );
2938 strstr.str(std::string());
2939 strstr << this->smoothingFactor;
2940 printf (
"Smoothing factor : %37s\n", strstr.str().c_str() );
2943 strstr.str(std::string());
2944 strstr << this->symMissPeakThres;
2945 printf (
"Missing ax. thres : %37s\n", strstr.str().c_str() );
2947 strstr.str(std::string());
2948 strstr << this->axisErrTolerance;
2949 printf (
"Same ax. threshold : %37s\n", strstr.str().c_str() );
2951 strstr.str(std::string());
2952 if ( this->axisErrToleranceDefault ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2953 printf (
"Same ax. thre. decr.: %37s\n", strstr.str().c_str() );
2955 strstr.str(std::string());
2956 strstr << this->minSymPeak;
2957 printf (
"Min. sym. peak size : %37s\n", strstr.str().c_str() );
2959 strstr.str(std::string());
2960 strstr << this->recommendedSymmetryType <<
"-" << this->recommendedSymmetryFold;
2961 printf (
"Recommended symm. : %37s\n", strstr.str().c_str() );
2963 strstr.str(std::string());
2964 strstr << this->requestedSymmetryType <<
"-" << this->requestedSymmetryFold;
2965 printf (
"Requested symm. : %37s\n", strstr.str().c_str() );
2967 strstr.str(std::string());
2968 if ( this->useBiCubicInterpolationOnPeaks ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2969 printf (
"Use bicubic interp. : %37s\n", strstr.str().c_str() );
2971 strstr.str(std::string());
2972 strstr << this->maxSymmetryFold;
2973 printf (
"Max symmetry fold : %37s\n", strstr.str().c_str() );
2975 strstr.str(std::string());
2976 strstr << this->fscThreshold;
2977 printf (
"FSC Threshold : %37s\n", strstr.str().c_str() );
2979 strstr.str(std::string());
2980 strstr << this->peakThresholdMin;
2981 printf (
"Peak Threshold : %37s\n", strstr.str().c_str() );
2983 strstr.str(std::string());
2984 if ( this->fastISearch ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2985 printf (
"Fast I Search : %37s\n", strstr.str().c_str() );
2988 strstr.str(std::string());
2989 strstr << this->overlayStructureName;
2990 printf (
"Overlay file : %37s\n", strstr.str().c_str() );
2992 strstr.str(std::string());
2993 strstr << this->rotTrsJSONFile;
2994 printf (
"JSON overlay file : %37s\n", strstr.str().c_str() );
2997 strstr.str(std::string());
2998 strstr << this->verbose;
2999 printf (
"Verbosity : %37s\n", strstr.str().c_str() );
3010 #if defined ( _WIN64 ) || defined ( _WIN32 )
3017 return ( this->enLevs );
3024 #if defined ( _WIN64 ) || defined ( _WIN32 )
3031 return ( this->trSigm );
3038 #if defined ( _WIN64 ) || defined ( _WIN32 )
3045 return ( this->rotFun );
3055 return ( this->noStructures );
3065 return ( this->verbose );
3075 return (
static_cast<proshade_unsign
> ( this->RecomSymAxes.size() ) );
3085 return (
static_cast<proshade_unsign
> ( this->RecomSymAxes.size() ) );
3093 #if defined ( _WIN64 ) || defined ( _WIN32 )
3100 if (
static_cast<proshade_unsign
> ( this->RecomSymAxes.size() ) <= axisNo )
3103 return ( std::vector< std::string > ( ) );
3107 std::vector< std::string > ret;
3110 std::stringstream ssHlp;
3111 ssHlp << this->RecomSymAxes.at(axisNo)[0];
3115 ssHlp << this->RecomSymAxes.at(axisNo)[1];
3119 ssHlp << this->RecomSymAxes.at(axisNo)[2];
3123 ssHlp << this->RecomSymAxes.at(axisNo)[3];
3127 ssHlp << this->RecomSymAxes.at(axisNo)[4];
3131 ssHlp << this->RecomSymAxes.at(axisNo)[5];
3135 ssHlp << this->RecomSymAxes.at(axisNo)[6];
3148 #if defined ( _WIN64 ) || defined ( _WIN32 )
3155 return ( this->allCSymAxes );
3163 #if defined ( _WIN64 ) || defined ( _WIN32 )
3170 return ( this->mapCOMShift );
3178 #if defined ( _WIN64 ) || defined ( _WIN32 )
3185 if ( noStructures <= strNo )
3188 return ( std::vector< proshade_signed > ( ) );
3192 std::vector< proshade_signed > ret;
3210 #if defined ( _WIN64 ) || defined ( _WIN32 )
3217 if ( noStructures <= strNo )
3220 return ( std::vector< proshade_signed > ( ) );
3224 std::vector< proshade_signed > ret;
3244 #if defined ( _WIN64 ) || defined ( _WIN32 )
3251 return ( this->manipulatedMaps.at(strNo)[mapIndex] );
3261 #if defined ( _WIN64 ) || defined ( _WIN32 )
3275 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++)
3277 reboxMap[iter] =
static_cast<double> ( run->
getMapValue ( strNo, iter ) );
3289 #if defined ( _WIN64 ) || defined ( _WIN32 )
3296 if ( this->eulerAngles.size() != 3 )
3298 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3299 return ( std::vector< proshade_double > ( ) );
3303 return ( this->eulerAngles );
3311 #if defined ( _WIN64 ) || defined ( _WIN32 )
3318 if ( this->eulerAngles.size() != 3 )
3320 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3321 return ( std::vector< proshade_double > ( ) );
3325 proshade_double* rotMat =
new proshade_double[9];
3330 std::vector< proshade_double > ret;
3345 #if defined ( _WIN64 ) || defined ( _WIN32 )
3352 if ( this->coordRotationCentre.size() != 3 )
3354 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3355 return ( std::vector< proshade_double > ( ) );
3359 std::vector < proshade_double > ret;
3373 #if defined ( _WIN64 ) || defined ( _WIN32 )
3380 if ( this->overlayTranslation.size() != 3 )
3382 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3383 return ( std::vector< proshade_double > ( ) );
3387 return ( this->overlayTranslation );